FIX: keep sub-pixel line marks visible when snapping (#20243)

Zish19 · Zish19 · commit eec0feee42ac · 2026-07-02T12:58:56.000+05:30
PathSnapper rounds each vertex to the nearest pixel. A line mark shorter
than one pixel then has both endpoints rounded onto the same pixel, so it
collapses to zero length and is not drawn at all. eventplot builds every
event as its own two-point segment, so plotting many closely spaced events
silently dropped most of them.

When the opening LINETO of a subpath snaps onto its MOVETO even though the
raw segment was non-degenerate, extend the endpoint by one pixel along the
segment's dominant axis so a single pixel is still drawn. Limiting this to
the first segment of a subpath leaves polygon outlines (bars, markers,
grids) snapping exactly as before.
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -5484,6 +5484,38 @@ def test_eventplot_defaults():
     axobj.eventplot(data)
 
 
+def test_eventplot_sub_pixel_events_not_dropped():
+    """
+    Event marks shorter than a pixel must still be drawn.
+
+    When an event line is less than a pixel tall, pixel snapping used to round
+    both of its endpoints to the same pixel, collapsing it to a zero-length
+    segment that the Agg renderer drew as nothing.  With many such events most
+    of the data silently disappeared.  Regression test for issue #20243.
+    """
+    n_events = 200
+    # One row of events, each in its own x column so a dropped mark leaves a
+    # detectable empty column.
+    positions = np.linspace(0.02, 0.98, n_events)
+
+    fig, ax = plt.subplots(figsize=(6, 2), dpi=100)  # 600 x 200 px
+    ax.eventplot(positions, linelengths=1, lineoffsets=0, colors='black')
+    ax.set_xlim(0, 1)
+    ax.set_ylim(-200, 200)  # each mark ~0.5 px tall -> would collapse if snapped
+    ax.set_axis_off()
+    fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
+
+    fig.canvas.draw()
+    buf = np.asarray(fig.canvas.buffer_rgba())
+
+    # Count image columns containing a mark.  Before the fix this was 0 (every
+    # sub-pixel mark vanished); afterwards each requested mark is rendered.
+    non_white = (buf[:, :, :3] < 128).any(axis=2)
+    cols_with_ink = non_white.any(axis=0).sum()
+
+    assert cols_with_ink >= n_events
+
+
 @pytest.mark.parametrize(('colors'), [
     ('0.5',),  # string color with multiple characters: not OK before #8193 fix
     ('tab:orange', 'tab:pink', 'tab:cyan', 'bLacK'),  # case-insensitive
diff --git a/src/path_converters.h b/src/path_converters.h
@@ -556,6 +556,14 @@ class PathSnapper
     bool m_snap;
     double m_snap_value;
 
+    // Previous vertex, kept so that the first segment of a subpath is not lost
+    // when snapping rounds both of its endpoints onto the same pixel.
+    unsigned m_prev_code;
+    double m_prev_snapped_x;
+    double m_prev_snapped_y;
+    double m_prev_raw_x;
+    double m_prev_raw_y;
+
     static bool should_snap(VertexSource &path, e_snap_mode snap_mode, unsigned total_vertices)
     {
         // If this contains only straight horizontal or vertical lines, it should be
@@ -609,7 +617,12 @@ class PathSnapper
                 e_snap_mode snap_mode,
                 unsigned total_vertices = 15,
                 double stroke_width = 0.0)
-        : m_source(&source)
+        : m_source(&source),
+          m_prev_code(agg::path_cmd_stop),
+          m_prev_snapped_x(0.0),
+          m_prev_snapped_y(0.0),
+          m_prev_raw_x(0.0),
+          m_prev_raw_y(0.0)
     {
         m_snap = should_snap(source, snap_mode, total_vertices);
 
@@ -623,6 +636,7 @@ class PathSnapper
 
     inline void rewind(unsigned path_id)
     {
+        m_prev_code = agg::path_cmd_stop;
         m_source->rewind(path_id);
     }
 
@@ -631,8 +645,36 @@ class PathSnapper
         unsigned code;
         code = m_source->vertex(x, y);
         if (m_snap && agg::is_vertex(code)) {
-            *x = floor(*x + 0.5) + m_snap_value;
-            *y = floor(*y + 0.5) + m_snap_value;
+            double raw_x = *x, raw_y = *y;
+            *x = floor(raw_x + 0.5) + m_snap_value;
+            *y = floor(raw_y + 0.5) + m_snap_value;
+
+            // A short line drawn on its own (an eventplot row, an hlines/vlines
+            // mark, a tick) is a MOVETO followed by a single LINETO.  If it is
+            // less than a pixel long both endpoints snap to the same pixel and
+            // nothing is drawn.  Keep the mark visible by extending the endpoint
+            // one pixel along the segment's dominant axis.  Only the opening
+            // segment of a subpath is treated this way, so polygon outlines
+            // (bars, markers) keep snapping unchanged.
+            if (code == agg::path_cmd_line_to &&
+                m_prev_code == agg::path_cmd_move_to &&
+                *x == m_prev_snapped_x && *y == m_prev_snapped_y) {
+                double dx = raw_x - m_prev_raw_x;
+                double dy = raw_y - m_prev_raw_y;
+                if (dx != 0.0 || dy != 0.0) {
+                    if (fabs(dx) >= fabs(dy)) {
+                        *x += (dx >= 0.0) ? 1.0 : -1.0;
+                    } else {
+                        *y += (dy >= 0.0) ? 1.0 : -1.0;
+                    }
+                }
+            }
+
+            m_prev_code = code;
+            m_prev_snapped_x = *x;
+            m_prev_snapped_y = *y;
+            m_prev_raw_x = raw_x;
+            m_prev_raw_y = raw_y;
         }
         return code;
     }
