matplotlib · brunobeltran · Apr 18, 2020 · oscargus · Apr 24, 2023
diff --git a/lib/matplotlib/backends/backend_mixed.py b/lib/matplotlib/backends/backend_mixed.py
@@ -1,8 +1,9 @@
 import numpy as np
 
 from matplotlib import cbook
-from .backend_agg import RendererAgg
 from matplotlib._tight_bbox import process_figure_for_rasterizing
+from matplotlib.backends.backend_agg import RendererAgg
+from matplotlib.transforms import Bbox, Affine2D, IdentityTransform
 
 
 class MixedModeRenderer:
@@ -68,6 +69,71 @@ def __getattr__(self, attr):
         # to the underlying C implementation).
         return getattr(self._renderer, attr)
 
+    # need to wrap each drawing function that might be called on the rasterized
+    # version of the renderer to save what the "true" bbox is for scaling the
+    # output correctly
+    # the functions we might want to overwrite are:
+    # `draw_path`, `draw_image`, `draw_gouraud_triangle`, `draw_text`,
+    # `draw_markers`, `draw_path_collection`, `draw_quad_mesh`
+
+    def _update_true_bbox(self, bbox, transform=None):
+        """Convert to real units and update"""
+        if transform is None:
+            transform = IdentityTransform()
+        bbox = bbox.transformed(transform + Affine2D().scale(
+            self._figdpi / self.dpi))
+        if self._true_bbox is None:
+            self._true_bbox = bbox
+        else:
+            self._true_bbox = Bbox.union([self._true_bbox, bbox])
+
+    def draw_path(self, gc, path, transform, rgbFace=None):
+        if self._rasterizing > 0:
+            bbox = Bbox.null()
+            bbox.update_from_path(path, ignore=True)
+            self._update_true_bbox(bbox, transform)
+        return self._renderer.draw_path(gc, path, transform, rgbFace)
+
+    def draw_path_collection(self, gc, master_transform, paths, all_transforms,
+                             offsets, offsetTrans, facecolors, edgecolors,
+                             linewidths, linestyles, antialiaseds, urls,
+                             offset_position):
+        if self._rasterizing > 0:
+            bbox = Bbox.null()
+            # TODO probably faster to merge all coordinates from path using
+            # numpy for large lists of paths, such as the one produced by the
+            # test case tests/test_backed_pgf.py:test_mixed_mode
+            for path in paths:
+                bbox.update_from_path(path, ignore=False)
+            self._update_true_bbox(bbox, master_transform)
+        return self._renderer.draw_path_collection(
+                gc, master_transform, paths, all_transforms, offsets,
+                offsetTrans, facecolors, edgecolors, linewidths, linestyles,
+                antialiaseds, urls, offset_position)
+
+    def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
+                       coordinates, offsets, offsetTrans, facecolors,
+                       antialiased, edgecolors):
+        if self._rasterizing > 0:
+            # TODO should check if this is always Bbox.unit for efficiency
+            bbox = Bbox.null()
+            cshape = coordinates.shape
+            flat_coords = coordinates.reshape((cshape[0]*cshape[1], cshape[2]))
+            bbox.update_from_data_xy(flat_coords, ignore=True)
+            self._update_true_bbox(bbox, master_transform)
+
+        return self._renderer.draw_quad_mesh(
+                gc, master_transform, meshWidth, meshHeight, coordinates,
+                offsets, offsetTrans, facecolors, antialiased, edgecolors)
+
+    def draw_gouraud_triangle(self, gc, points, colors, transform):
 @_api.deprecated("3.7", alternative="draw_gouraud_triangles") 
 def draw_gouraud_triangle(self, gc, points, colors, transform): 
 @_api.deprecated("3.7", alternative="draw_gouraud_triangles") 
 def draw_gouraud_triangle(self, gc, points, colors, transform): 
+        if self._rasterizing > 0:
+            bbox = Bbox.null()
+            bbox.update_from_data_xy(points, ignore=True)
+            self._update_true_bbox(bbox, transform)
+        return self._renderer.draw_gouraud_triangle(
+                gc, points, colors, transform)
+
     def start_rasterizing(self):
         """
         Enter "raster" mode.  All subsequent drawing commands (until
@@ -83,6 +149,7 @@ def start_rasterizing(self):
         self._raster_renderer = self._raster_renderer_class(
             self._width*self.dpi, self._height*self.dpi, self.dpi)
         self._renderer = self._raster_renderer
+        self._true_bbox = None
 
     def stop_rasterizing(self):
         """
@@ -92,21 +159,35 @@ def stop_rasterizing(self):
         """
 
         self._renderer = self._vector_renderer
-
         height = self._height * self.dpi
-        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,
-                slice_x.start * self._figdpi / self.dpi,
-                (height - slice_y.stop) * self._figdpi / self.dpi,
-                cropped_img[::-1])
+        # these bounds are in pixels, relative to the figure when pixelated
+        # at the requested DPI. However, the vectorized backends draw at a
+        # fixed DPI of 72, and typically aren't snapped to the
+        # requested-DPI pixel grid, so we have to grab the actual bounds to
+        # put the image into some other way
+        if self._true_bbox is not None:
+            #    raise NotImplementedError(
+            #        "Something was drawn using a method not wrapped by "
+            #        "MixedModeRenderer.")
+            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.
+                # because rasterizing will have rounded size to nearest
+                # pixel, we need to rescale our drawing to fit the original
+                # intended Bbox. This results in a slightly different DPI than
+                # requested, but that's better than the drawing not fitting
+                # into the space requested, see Issue #6827
+
+                self._renderer.draw_image(
+                    gc, self._true_bbox.x0, self._true_bbox.y0, cropped_img[::-1],
+                    true_size=(self._true_bbox.width, self._true_bbox.height)
+                )
+
         self._raster_renderer = None
 
         # restore the figure dpi.

diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py
@@ -1980,21 +1980,28 @@ def check_gc(self, gc, fillcolor=None):
     def get_image_magnification(self):
         return self.image_dpi/72.0
 
-    def draw_image(self, gc, x, y, im, transform=None):
+    def option_true_bbox_image(self):
+        return True
+
+    def draw_image(self, gc, x, y, im, transform=None, true_size=None):
         # docstring inherited
 
         h, w = im.shape[:2]
         if w == 0 or h == 0:
             return
 
+        if true_size is not None:
+            w, h = true_size
+
         if transform is None:
             # If there's no transform, alpha has already been applied
             gc.set_alpha(1.0)
 
         self.check_gc(gc)
 
-        w = 72.0 * w / self.image_dpi
-        h = 72.0 * h / self.image_dpi
+        if true_size is None:
+            w = 72.0 * w / self.image_dpi
+            h = 72.0 * h / self.image_dpi
 
         imob = self.file.imageObject(im)
 

diff --git a/lib/matplotlib/backends/backend_pgf.py b/lib/matplotlib/backends/backend_pgf.py
@@ -605,13 +605,19 @@ def option_image_nocomposite(self):
         # docstring inherited
         return not mpl.rcParams['image.composite_image']
 
-    def draw_image(self, gc, x, y, im, transform=None):
+    def option_true_bbox_image(self):
+        return True
+
+    def draw_image(self, gc, x, y, im, transform=None, true_size=None):
         # docstring inherited
 
         h, w = im.shape[:2]
         if w == 0 or h == 0:
             return
 
+        if true_size is not None:
+            w, h = true_size
+
         if not os.path.exists(getattr(self.fh, "name", "")):
             raise ValueError(
                 "streamed pgf-code does not support raster graphics, consider "

diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py
@@ -424,30 +424,41 @@ def _get_clip_cmd(self, gc):
             clip.append(f"{custom_clip_cmd}\n")
         return "".join(clip)
 
+    def option_true_bbox_image(self):
+        return True
+
     @_log_if_debug_on
-    def draw_image(self, gc, x, y, im, transform=None):
+    def draw_image(self, gc, x, y, im, transform=None, true_size=None):
         # docstring inherited
 
         h, w = im.shape[:2]
+
+        if h == 0 or w == 0:
+            return
+
         imagecmd = "false 3 colorimage"
         data = im[::-1, :, :3]  # Vertically flipped rgb values.
         hexdata = data.tobytes().hex("\n", -64)  # Linewrap to 128 chars.
 
         if transform is None:
             matrix = "1 0 0 1 0 0"
-            xscale = w / self.image_magnification
-            yscale = h / self.image_magnification
+            if true_size is None:
+                xscale = w / self.image_magnification
+                yscale = h / self.image_magnification
+            else:
+                xscale = true_size[0]
+                yscale = true_size[1]
         else:
-            matrix = " ".join(map(str, transform.frozen().to_values()))
             xscale = 1.0
             yscale = 1.0
+            matrix = " ".join(map(str, transform.frozen().to_values()))
 
         self._pswriter.write(f"""\
 gsave
 {self._get_clip_cmd(gc)}
-{x:g} {y:g} translate
+{x:.2f} {y:.2f} translate
 [{matrix}] concat
-{xscale:g} {yscale:g} scale
+{xscale:.2f} {yscale:.2f} scale
 /DataString {w:d} string def
 {w:d} {h:d} 8 [ {w:d} 0 0 -{h:d} 0 {h:d} ]
 {{

diff --git a/lib/matplotlib/backends/backend_svg.py b/lib/matplotlib/backends/backend_svg.py
@@ -915,10 +915,13 @@ def option_scale_image(self):
         # docstring inherited
         return True
 
+    def option_true_bbox_image(self):
+        return True
+
     def get_image_magnification(self):
         return self.image_dpi / 72.0
 
-    def draw_image(self, gc, x, y, im, transform=None):
+    def draw_image(self, gc, x, y, im, transform=None, true_size=None):
         # docstring inherited
 
         h, w = im.shape[:2]
@@ -960,12 +963,28 @@ def draw_image(self, gc, x, y, im, transform=None):
             w = 72.0 * w / self.image_dpi
             h = 72.0 * h / self.image_dpi
 
+            if true_size is not None:
+                width, height = true_size
+                # because rasterization happens only for integer pixels, the
+                # round-trip width w = # int(width/72*image_dpi)*72/image_dpi
+                # need not match the "real" width
+                scale_x = width/w
+                scale_y = height/h
+                real_h = height
+            else:
+                scale_x = 1
+                scale_y = 1
+                real_h = h
+
             self.writer.element(
                 'image',
                 transform=_generate_transform([
-                    ('scale', (1, -1)), ('translate', (0, -h))]),
+                    ('translate',
+                     (x*(1 - scale_x), y*(1 - scale_y) + real_h)),
+                    ('scale', (scale_x, -scale_y))
+                ]),
                 x=_short_float_fmt(x),
-                y=_short_float_fmt(-(self.height - y - h)),
+                y=_short_float_fmt(-(self.height - y - real_h)),
                 width=_short_float_fmt(w), height=_short_float_fmt(h),
                 attrib=attrib)
         else:

diff --git a/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf b/lib/matplotlib/tests/baseline_images/test_axes/hist2d.pdf