Only apply dash for width 1

Author: radarhere

Tests/images/imagedraw_dash_line.png

@@ -1782,8 +1782,8 @@ def test_dash_line() -> None:
     draw = ImageDraw.Draw(im)
 
     # Act
-    draw.line([(10, 90), (90, 90)], "green", 2, dash=(10, 5))
-    draw.line([(10, 10), (50, 50), (90, 10)], "green", 2, dash=(8, 4))
+    draw.line([(10, 90), (90, 90)], "green", dash=(10, 5))
+    draw.line([(10, 10), (50, 50), (90, 10)], "green", dash=(8, 4))
 
     # Assert
     assert_image_equal_tofile(im, "Tests/images/imagedraw_dash_line.png")
@@ -1798,14 +1798,12 @@ def test_dash_polygon() -> None:
     draw.polygon(
         [(10, 10), (90, 10), (10, 90)],
         outline="green",
-        width=1,
         dash=(10, 5),
     )
     draw.polygon(
         [(20, 20), (60, 20), (20, 60)],
         fill="red",
         outline="green",
-        width=1,
         dash=(10, 5),
     )
 
@@ -1819,8 +1817,8 @@ def test_dash_rectangle() -> None:
     draw = ImageDraw.Draw(im)
 
     # Act
-    draw.rectangle([10, 10, 90, 90], outline="green", width=1, dash=(10, 5))
-    draw.rectangle([30, 30, 70, 70], fill="red", outline="green", width=1, dash=(10, 5))
+    draw.rectangle([10, 10, 90, 90], outline="green", dash=(10, 5))
+    draw.rectangle([30, 30, 70, 70], fill="red", outline="green", dash=(10, 5))
 
     # Assert
     assert_image_equal_tofile(im, "Tests/images/imagedraw_dash_rectangle.png")

Tests/images/imagedraw_dash_polygon.png

@@ -307,10 +307,10 @@ Methods
         The dash pattern specifies the lengths of alternating drawn and blank segments
         (e.g. ``(10, 5)`` draws 10 pixels, skips 5, and repeats). If an odd number of
         values is given, it continues to alternate (e.g. ``(1, 2, 3)`` draws 1 pixel,
-        skips 2, draws 3, skips 1, draws 2, and so on). When ``dash`` is set, ``joint``
-        is ignored.
+        skips 2, draws 3, skips 1, draws 2, and so on). When ``dash`` is set, ``width``
+        and ``joint`` are ignored.
 
-        .. versionadded:: 12.3.0
+        .. versionadded:: 13.0.0
 
 .. py:method:: ImageDraw.pieslice(xy, start, end, fill=None, outline=None, width=1)
 
@@ -354,9 +354,10 @@ Methods
         The dash pattern specifies the lengths of alternating drawn and blank segments
         (e.g. ``(10, 5)`` draws 10 pixels, skips 5, and repeats). If an odd number of
         values is given, it continues to alternate (e.g. ``(1, 2, 3)`` draws 1 pixel,
-        skips 2, draws 3, skips 1, draws 2, and so on).
+        skips 2, draws 3, skips 1, draws 2, and so on). When ``dash`` is set, ``width``
+        is ignored.
 
-        .. versionadded:: 12.3.0
+        .. versionadded:: 13.0.0
 
 
 .. py:method:: ImageDraw.regular_polygon(bounding_circle, n_sides, rotation=0, fill=None, outline=None, width=1)
@@ -393,9 +394,10 @@ Methods
         The dash pattern specifies the lengths of alternating drawn and blank segments
         (e.g. ``(10, 5)`` draws 10 pixels, skips 5, and repeats). If an odd number of
         values is given, it continues to alternate (e.g. ``(1, 2, 3)`` draws 1 pixel,
-        skips 2, draws 3, skips 1, draws 2, and so on).
+        skips 2, draws 3, skips 1, draws 2, and so on). When ``dash`` is set, ``width``
+        is ignored.
 
-        .. versionadded:: 12.3.0
+        .. versionadded:: 13.0.0
 
 .. py:method:: ImageDraw.rounded_rectangle(xy, radius=0, fill=None, outline=None, width=1, corners=None)
 

Tests/images/imagedraw_dash_rectangle.png

@@ -222,72 +222,15 @@ def circle(
         ellipse_xy = (xy[0] - radius, xy[1] - radius, xy[0] + radius, xy[1] + radius)
         self.ellipse(ellipse_xy, fill, outline, width)
 
-    def _normalize_points(self, xy: Coords) -> list[Sequence[float]]:
-        """Convert various coordinate formats to a list of (x, y) tuples."""
+    def _normalize_coords(self, xy: Coords) -> Sequence[Sequence[float]]:
+        """Normalize 1 or 2 dimensional coord sequence into 2d sequence."""
         if isinstance(xy[0], (list, tuple)):
-            return list(cast("Sequence[Sequence[float]]", xy))
+            return cast("Sequence[Sequence[float]]", xy)
         else:
-            flat_xy = cast("Sequence[float]", xy)
-            return [flat_xy[i : i + 2] for i in range(0, len(flat_xy), 2)]
-
-    def _draw_dashed_line(
-        self,
-        p1: Sequence[float],
-        p2: Sequence[float],
-        dash: tuple[int, ...],
-        ink: int,
-        width: int,
-        dash_offset: int,
-    ) -> int:
-        """Draw a single dashed line segment between two points.
-
-        Returns the updated dash_offset for continuing the pattern
-        along the next segment.
-        """
-        dx = p2[0] - p1[0]
-        dy = p2[1] - p1[1]
-        segment_length = math.hypot(dx, dy)
-        if segment_length == 0:
-            return dash_offset
-
-        vx = dx / segment_length
-        vy = dy / segment_length
-
-        remaining = segment_length
-        x, y = p1
-
-        # Determine where we are in the dash pattern
-        dash_cycle_length = sum(dash)
-        offset = dash_offset % dash_cycle_length
-        dash_index = 0
-        consumed = 0
-        for i, d in enumerate(dash):
-            if consumed + d > offset:
-                dash_index = i
-                break
-            consumed += d
-        pixels_used: float = offset - consumed
-
-        while remaining > 0.5:
-            current_dash_length = dash[dash_index % len(dash)]
-            step = min(current_dash_length - pixels_used, remaining)
-
-            nx = x + vx * step
-            ny = y + vy * step
-
-            if dash_index % 2 == 0:
-                self.draw.draw_lines([(x, y), (nx, ny)], ink, width)
-
-            x = nx
-            y = ny
-            remaining -= step
-            pixels_used += step
-
-            if pixels_used >= current_dash_length:
-                pixels_used = 0
-                dash_index += 1
-
-        return (dash_offset + int(round(segment_length))) % dash_cycle_length
+            return [
+                cast("Sequence[float]", tuple(xy[i : i + 2]))
+                for i in range(0, len(xy), 2)
+            ]
 
     def line(
         self,
@@ -303,27 +246,22 @@ def line(
             return
 
         if dash is not None:
-            if len(dash) == 0:
+            if len(dash) == 0 or any(not isinstance(v, int) for v in dash):
                 msg = "dash must be a non-empty tuple of ints"
                 raise ValueError(msg)
-            points = self._normalize_points(xy)
-            dash_offset = 0
-            for i in range(len(points) - 1):
-                dash_offset = self._draw_dashed_line(
-                    points[i], points[i + 1], dash, ink, width, dash_offset
-                )
+            self.draw.draw_lines(xy, ink, 1, dash)
         else:
             self.draw.draw_lines(xy, ink, width)
             if joint == "curve" and width > 4:
-                joint_points = self._normalize_points(xy)
-                for i in range(1, len(joint_points) - 1):
-                    point = joint_points[i]
+                points = self._normalize_coords(xy)
+                for i in range(1, len(points) - 1):
+                    point = points[i]
                     angles = [
                         math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
                         % 360
                         for start, end in (
-                            (joint_points[i - 1], point),
-                            (point, joint_points[i + 1]),
+                            (points[i - 1], point),
+                            (point, points[i + 1]),
                         )
                     ]
                     if angles[0] == angles[1]:
@@ -425,18 +363,10 @@ def polygon(
             return
 
         if dash is not None:
-            if len(dash) == 0:
+            if len(dash) == 0 or any(not isinstance(v, int) for v in dash):
                 msg = "dash must be a non-empty tuple of ints"
                 raise ValueError(msg)
-            points = self._normalize_points(xy)
-            # Close the polygon by connecting last point to first
-            if points[0] != points[-1]:
-                points.append(points[0])
-            dash_offset = 0
-            for i in range(len(points) - 1):
-                dash_offset = self._draw_dashed_line(
-                    points[i], points[i + 1], dash, ink, width, dash_offset
-                )
+            self.draw.draw_polygon(xy, ink, 0, 1, dash)
         elif width == 1:
             self.draw.draw_polygon(xy, ink, 0, width)
         elif self.im is not None:
@@ -447,7 +377,7 @@ def polygon(
             draw = Draw(mask)
             draw.draw.draw_polygon(xy, mask_ink, 1)
 
-            self.draw.draw_polygon(xy, ink, 0, width * 2 - 1, mask.im)
+            self.draw.draw_polygon(xy, ink, 0, width * 2 - 1, None, mask.im)
 
     def regular_polygon(
         self,
@@ -478,27 +408,21 @@ def rectangle(
             return
 
         if dash is not None:
-            if len(dash) == 0:
+            if len(dash) == 0 or any(not isinstance(v, int) for v in dash):
                 msg = "dash must be a non-empty tuple of ints"
                 raise ValueError(msg)
-            (x0, y0), (x1, y1) = self._normalize_points(xy)
-            rect_points = [
-                (x0, y0),
-                (x1, y0),
-                (x1, y1),
-                (x0, y1),
-                (x0, y0),
-            ]
-            dash_offset = 0
-            for i in range(4):
-                dash_offset = self._draw_dashed_line(
-                    rect_points[i],
-                    rect_points[i + 1],
-                    dash,
-                    ink,
-                    width,
-                    dash_offset,
-                )
+            self.draw.draw_lines(
+                [
+                    (xy[0], xy[1]),
+                    (xy[2], xy[1]),
+                    (xy[2], xy[3]),
+                    (xy[0], xy[3]),
+                    (xy[0], xy[1]),
+                ],
+                ink,
+                1,
+                dash,
+            )
         else:
             self.draw.draw_rectangle(xy, ink, 0, width)
 
@@ -513,7 +437,7 @@ def rounded_rectangle(
         corners: tuple[bool, bool, bool, bool] | None = None,
     ) -> None:
         """Draw a rounded rectangle."""
-        (x0, y0), (x1, y1) = self._normalize_points(xy)
+        (x0, y0), (x1, y1) = self._normalize_coords(xy)
         if x1 < x0:
             msg = "x1 must be greater than or equal to x0"
             raise ValueError(msg)

Tests/test_imagedraw.py

@@ -3217,7 +3217,8 @@ _draw_lines(ImagingDrawObject *self, PyObject *args) {
     PyObject *data;
     int ink;
     int width;
-    if (!PyArg_ParseTuple(args, "Oii", &data, &ink, &width)) {
+    PyObject *dash = NULL;
+    if (!PyArg_ParseTuple(args, "Oii|O", &data, &ink, &width, &dash)) {
         return NULL;
     }
 
@@ -3228,6 +3229,7 @@ _draw_lines(ImagingDrawObject *self, PyObject *args) {
 
     if (width == 1) {
         double *p = NULL;
+        int dash_offset = 0;
         for (i = 0; i < n - 1; i++) {
             p = &xy[i + i];
             if (ImagingDrawLine(
@@ -3237,7 +3239,9 @@ _draw_lines(ImagingDrawObject *self, PyObject *args) {
                     (int)p[2],
                     (int)p[3],
                     &ink,
-                    self->blend
+                    self->blend,
+                    dash,
+                    &dash_offset
                 ) < 0) {
                 free(xy);
                 return NULL;
@@ -3399,8 +3403,9 @@ _draw_polygon(ImagingDrawObject *self, PyObject *args) {
     int fill = 0;
     int width = 0;
     ImagingObject *maskp = NULL;
+    PyObject *dash = NULL;
     if (!PyArg_ParseTuple(
-            args, "Oi|iiO!", &data, &ink, &fill, &width, &Imaging_Type, &maskp
+            args, "Oi|iiOO!", &data, &ink, &fill, &width, &dash, &Imaging_Type, &maskp
         )) {
         return NULL;
     }
@@ -3439,7 +3444,8 @@ _draw_polygon(ImagingDrawObject *self, PyObject *args) {
             fill,
             width,
             self->blend,
-            maskp ? maskp->image : NULL
+            maskp ? maskp->image : NULL,
+            dash != Py_None ? dash : NULL
         ) < 0) {
         free(ixy);
         return NULL;
@@ -3459,7 +3465,8 @@ _draw_rectangle(ImagingDrawObject *self, PyObject *args) {
     int ink;
     int fill = 0;
     int width = 0;
-    if (!PyArg_ParseTuple(args, "Oi|ii", &data, &ink, &fill, &width)) {
+    PyObject *dash = NULL;
+    if (!PyArg_ParseTuple(args, "Oi|iiO", &data, &ink, &fill, &width, &dash)) {
         return NULL;
     }