Fix additional misalignments due to numerical precision

ayshih · ayshih · commit 1261a30ae6aa · 2026-03-20T00:35:07.000-04:00
There are multiple instances where a value that would ideally be exactly
at a half display pixel might instead be one floating-point tick away in
the wrong direction.  Here fudge amounts are added so that the rounding
occurs in the desired direction.  An analogous situation occurs for
truncation to a whole pixel.  The amount of 1e-8 is chosen because it
covers 1e-13 relative error for 100,000 pixels.
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
@@ -410,8 +410,12 @@ def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0,
         magnified_extents = clipped_bbox.extents * magnification
         if ((not unsampled) and round_to_pixel_border):
             # Round to the nearest output pixel
-            x0, x1 = np.floor(magnified_extents[0::2] + 0.5)  # round half up
-            y0, y1 = np.ceil(magnified_extents[1::2] - 0.5)  # round half down
+            # Add a tiny fudge amount to account for numerical precision loss
+            # on the two sides away from the Agg anchor point (x0, y1)
+            x0 = np.floor(magnified_extents[0] + 0.5)  # round half up
+            y0 = np.ceil(magnified_extents[1] - 0.5 - 1e-8)  # round half down
+            x1 = np.floor(magnified_extents[2] + 0.5 + 1e-8)  # round half up
+            y1 = np.ceil(magnified_extents[3] - 0.5)  # round half down
             magnified_bbox = Bbox.from_extents([x0, y0, x1, y1])
         else:
             magnified_bbox = Bbox.from_extents(magnified_extents)
diff --git a/src/_image_resample.h b/src/_image_resample.h
@@ -589,8 +589,9 @@ class lookup_distortion
             if (dx >= 0 && dx < m_out_width &&
                 dy >= 0 && dy < m_out_height) {
                 const double *coord = m_mesh + (int(dy) * m_out_width + int(dx)) * 2;
-                *x = int(coord[0] * agg::image_subpixel_scale + offset);
-                *y = int(coord[1] * agg::image_subpixel_scale + offset);
+                // Add a tiny fudge amount to account for numerical precision loss
+                *x = int(coord[0] * agg::image_subpixel_scale + offset + 1e-8);
+                *y = int(coord[1] * agg::image_subpixel_scale + offset + 1e-8);
             }
         }
     }
@@ -780,10 +781,15 @@ void resample(
             params.affine.transform(&right, &top);
             if (left > right) { std::swap(left, right); }
             if (bottom > top) { std::swap(top, bottom); }
-            if (round(left) < left) { left = round(left); }
-            if (round(right) > right) { right = round(right); }
-            if (round(bottom) < bottom) { bottom = round(bottom); }
-            if (round(top) > top) { top = round(top); }
+            // Add a tiny fudge amount to account for numerical precision loss
+            int rleft = agg::iround(left - 1e-8);
+            int rright = agg::iround(right + 1e-8);
+            int rbottom = agg::iround(bottom - 1e-8);
+            int rtop = agg::iround(top + 1e-8);
+            if (rleft < left) { left = rleft; }
+            if (rright > right) { right = rright; }
+            if (rbottom < bottom) { bottom = rbottom; }
+            if (rtop > top) { top = rtop; }
             path.move_to(left, bottom);
             path.line_to(right, bottom);
             path.line_to(right, top);
