Tighten a bit the RendererAgg API.

anntzer · anntzer · commit 56e87ef9f870 · 2020-07-18T11:27:08.000+02:00
The get_content_extents and tostring_rgba_minimized methods of
RendererAgg are used to implement 1) agg_filter and 2) rasterization in
MixedModeRenderer (i.e. for vector backends).  They can easily instead
be implemented at the Python level (i.e., via _get_nonzero_slices),
which makes it easier to plug in an alternative renderer (e.g.,
mplcairo) for rasterization in MixedModeRenderer.  I'm not convinced
_get_nonzero_slices needs to be exposed as public API (it's quite simple
anyways), but it could be if we absolutely want to present an
alternative for the deprecated methods.
diff --git a/doc/api/next_api_changes/deprecations/17788-AL.rst b/doc/api/next_api_changes/deprecations/17788-AL.rst
@@ -0,0 +1,3 @@
+``RendererAgg.get_content_extents``, ``RendererAgg.tostring_rgba_minimized``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+... are deprecated.
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -116,8 +116,12 @@ def _update_methods(self):
         # self.draw_path_collection = self._renderer.draw_path_collection
         self.draw_quad_mesh = self._renderer.draw_quad_mesh
         self.copy_from_bbox = self._renderer.copy_from_bbox
-        self.get_content_extents = self._renderer.get_content_extents
 
+    @cbook.deprecated("3.4")  # Also needs to be removed at C-level.
+    def get_content_extents(self):
+        return self._renderer.get_content_extents()
+
+    @cbook.deprecated("3.4")
     def tostring_rgba_minimized(self):
         extents = self.get_content_extents()
         bbox = [[extents[0], self.height - (extents[1] + extents[3])],
@@ -364,23 +368,21 @@ def post_processing(image, dpi):
         The saved renderer is restored and the returned image from
         post_processing is plotted (using draw_image) on it.
         """
-
-        width, height = int(self.width), int(self.height)
-
-        buffer, (l, b, w, h) = self.tostring_rgba_minimized()
+        orig_img = np.asarray(self.buffer_rgba())
+        slice_y, slice_x = cbook._get_nonzero_slices(orig_img[..., 3])
+        cropped_img = orig_img[slice_y, slice_x]
 
         self._renderer = self._filter_renderers.pop()
         self._update_methods()
 
-        if w > 0 and h > 0:
-            img = np.frombuffer(buffer, np.uint8)
-            img, ox, oy = post_processing(img.reshape((h, w, 4)) / 255.,
-                                          self.dpi)
+        if cropped_img.size:
+            img, ox, oy = post_processing(cropped_img / 255, self.dpi)
             gc = self.new_gc()
             if img.dtype.kind == 'f':
                 img = np.asarray(img * 255., np.uint8)
-            img = img[::-1]
-            self._renderer.draw_image(gc, l + ox, height - b - h + oy, img)
+            self._renderer.draw_image(
+                gc, slice_x.start + ox, int(self.height) - slice_y.stop + oy,
+                img[::-1])
 
 
 class FigureCanvasAgg(FigureCanvasBase):
diff --git a/lib/matplotlib/backends/backend_mixed.py b/lib/matplotlib/backends/backend_mixed.py
@@ -1,5 +1,6 @@
 import numpy as np
 
+from matplotlib import cbook
 from matplotlib.backends.backend_agg import RendererAgg
 from matplotlib.tight_bbox import process_figure_for_rasterizing
 
@@ -98,21 +99,19 @@ def stop_rasterizing(self):
         self._renderer = self._vector_renderer
 
         height = self._height * self.dpi
-        buffer, bounds = self._raster_renderer.tostring_rgba_minimized()
-        l, b, w, h = bounds
-        if w > 0 and h > 0:
-            image = np.frombuffer(buffer, dtype=np.uint8)
-            image = image.reshape((h, w, 4))
-            image = image[::-1]
+        img = np.asarray(self._raster_renderer.buffer_rgba())
+        slice_y, slice_x = cbook._get_nonzero_slices(img[..., 3])
+        cropped_img = img[slice_y, slice_x]
+        if cropped_img.size:
             gc = self._renderer.new_gc()
             # TODO: If the mixedmode resolution differs from the figure's
             #       dpi, the image must be scaled (dpi->_figdpi). Not all
             #       backends support this.
             self._renderer.draw_image(
                 gc,
-                l * self._figdpi / self.dpi,
-                (height-b-h) * self._figdpi / self.dpi,
-                image)
+                slice_x.start * self._figdpi / self.dpi,
+                (height - slice_y.stop) * self._figdpi / self.dpi,
+                cropped_img[::-1])
         self._raster_renderer = None
 
         # restore the figure dpi.
diff --git a/lib/matplotlib/cbook/__init__.py b/lib/matplotlib/cbook/__init__.py
@@ -2162,6 +2162,24 @@ def _unmultiplied_rgba8888_to_premultiplied_argb32(rgba8888):
     return argb32
 
 
+def _get_nonzero_slices(buf):
+    """
+    Return the bounds of the nonzero region of a 2D array as a pair of slices.
+
+    ``buf[_get_nonzero_slices(buf)]`` is the smallest sub-rectangle in *buf*
+    that encloses all non-zero entries in *buf*.  If *buf* is fully zero, then
+    ``(slice(0, 0), slice(0, 0))`` is returned.
+    """
+    x_nz, = buf.any(axis=0).nonzero()
+    y_nz, = buf.any(axis=1).nonzero()
+    if len(x_nz) and len(y_nz):
+        l, r = x_nz[[0, -1]]
+        b, t = y_nz[[0, -1]]
+        return slice(b, t + 1), slice(l, r + 1)
+    else:
+        return slice(0, 0), slice(0, 0)
+
+
 def _pformat_subprocess(command):
     """Pretty-format a subprocess command for printing/logging purposes."""
     return (command if isinstance(command, str)

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+``RendererAgg.get_content_extents``, ``RendererAgg.tostring_rgba_minimized``
	`2`	`+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
	`3`	`+... are deprecated.`