ripples: improve varying width distances (#4079)

kaalleen · web-flow · commit b82cc2796736 · 2025-12-14T13:43:22.000+01:00
diff --git a/lib/elements/stroke.py b/lib/elements/stroke.py
@@ -233,7 +233,7 @@ def min_line_dist(self):
         min_dist = self.get_float_param("min_line_dist_mm")
         if min_dist is None:
             return
-        return max(min_dist, 0.01)
+        return min_dist
 
     _satin_guided_pattern_options = [
         ParamOption('default', _('Line count / Minimum line distance')),
diff --git a/lib/stitches/ripple_stitch.py b/lib/stitches/ripple_stitch.py
@@ -2,8 +2,9 @@
 from math import atan2, ceil
 
 import numpy as np
+from shapely import prepare
 from shapely.affinity import rotate, scale, translate
-from shapely.geometry import LineString, Point
+from shapely.geometry import LineString, Point, Polygon
 from shapely.ops import substring
 
 from ..elements import SatinColumn
@@ -28,7 +29,7 @@ def ripple_stitch(stroke):
     if stroke.as_multi_line_string().length < 0.1:
         return []
 
-    is_linear, helper_lines = _get_helper_lines(stroke)
+    is_linear, helper_lines, grid_lines = _get_helper_lines(stroke)
     if not helper_lines:
         return []
 
@@ -43,7 +44,7 @@ def ripple_stitch(stroke):
         stitches.reverse()
 
     if stitches and stroke.grid_size != 0:
-        stitches.extend(_do_grid(stroke, helper_lines, skip_start, skip_end, is_linear, stitches[-1]))
+        stitches.extend(_do_grid(stroke, grid_lines, skip_start, skip_end, is_linear, stitches[-1]))
         if stroke.grid_first:
             stitches = stitches[::-1]
 
@@ -60,7 +61,8 @@ def _get_stitches(stroke, is_linear, lines, skip_start):
                 # even though this is manual stitch placement, we do not want the
                 # connector lines to exceed the running stitch length value
                 # so let's add some points
-                points = LineString([stitches[-1], line[0]]).segmentize(stroke.running_stitch_length).coords
+                segments = LineString([stitches[-1], line[0]]).segmentize(stroke.running_stitch_length)
+                points = list(segments)[0].coords
                 if len(points) > 2:
                     stitches.extend([InkstitchPoint(coord[0], coord[1]) for coord in points[1:-1]])
             stitches.extend(line)
@@ -204,31 +206,44 @@ def _line_count_adjust(stroke, num_lines):
 def _get_helper_lines(stroke):
     lines = stroke.as_multi_line_string().geoms
     if len(lines) > 1:
-        return True, _get_satin_ripple_helper_lines(stroke)
+        helper_lines = _get_satin_ripple_helper_lines(stroke)
+        if stroke.grid_size > 0:
+            grid_lines = _get_satin_ripple_helper_lines(stroke, True)
+        else:
+            grid_lines = helper_lines
+        return True, helper_lines, grid_lines
     else:
         if stroke.manual_pattern_placement:
             path = stroke.parse_path()
             path = [stroke.strip_control_points(subpath) for subpath in path][0]
             outline = LineString(path)
         else:
+            if stroke.grid_size > 0:
+                stitch_len_list = [stroke.grid_size]
+            else:
+                stitch_len_list = stroke.running_stitch_length
             outline = LineString(even_running_stitch(
                 line_string_to_point_list(lines[0]),
-                stroke.grid_size or stroke.running_stitch_length,
+                stitch_len_list,
                 stroke.running_stitch_tolerance)
             )
 
         if stroke.is_closed:
-            return False, _get_circular_ripple_helper_lines(stroke, outline)
+            helper_lines = _get_circular_ripple_helper_lines(stroke, outline)
+            return False, helper_lines, helper_lines
         elif stroke.join_style == 1:
-            return True, _get_point_style_linear_helper_lines(stroke, outline)
+            helper_lines = _get_point_style_linear_helper_lines(stroke, outline)
+            return True, helper_lines, helper_lines
         else:
-            return True, _get_linear_ripple_helper_lines(stroke, outline)
+            helper_lines = _get_linear_ripple_helper_lines(stroke, outline)
+            return True, helper_lines, helper_lines
 
 
-def _get_satin_ripple_helper_lines(stroke):
-    # if grid_size has a number use this, otherwise use running_stitch_length
-    length = stroke.grid_size or min(stroke.running_stitch_length)
-
+def _get_satin_ripple_helper_lines(stroke, grid=False):
+    if grid and stroke.grid_size > 0:
+        length = stroke.grid_size
+    else:
+        length = stroke.running_stitch_tolerance
     # use satin column points for satin like build ripple stitches
     rail_pairs = SatinColumn(stroke.node).plot_points_on_rails(length)
     count = _get_satin_line_count(stroke, rail_pairs)
@@ -281,7 +296,10 @@ def _get_point_style_linear_helper_lines(stroke, outline):
 
 def _get_linear_ripple_helper_lines(stroke, outline):
     guide_line = stroke.get_guide_line()
-    max_dist = stroke.grid_size or stroke.running_stitch_length
+    if stroke.grid_size > 0:
+        max_dist = [stroke.grid_size]
+    else:
+        max_dist = stroke.running_stitch_length
 
     if guide_line:
         return _get_guided_helper_lines(stroke, outline, max_dist)
@@ -386,7 +404,7 @@ def _generate_guided_helper_lines(stroke, outline, max_distance, guide_line):
         translation = guide_point - start_point
         scaling = scale_steps[i]
         if stroke.rotate_ripples and previous_guide_point:
-            rotation = atan2(guide_point.y - previous_guide_point.y, guide_point.x - previous_guide_point.x)
+            rotation = get_rotation(previous_guide_point, guide_point)
             rotation = rotation - start_rotation
         else:
             rotation = 0
@@ -404,7 +422,7 @@ def _get_start_rotation(line):
     point0 = line.interpolate(0)
     point1 = line.interpolate(0.1)
 
-    return atan2(point1.y - point0.y, point1.x - point0.x)
+    return get_rotation(point0, point1)
 
 
 def generate_satin_guide_helper_lines(stroke, outline, guide_line):
@@ -422,7 +440,7 @@ def generate_satin_guide_helper_lines(stroke, outline, guide_line):
             return _generate_simple_satin_guide_helper_lines(stroke, outline, guide_line)
 
     outline_width = (outline1 - outline0).length()
-    outline_rotation = atan2(outline1.y - outline0.y, outline1.x - outline0.x)
+    outline_rotation = get_rotation(outline0, outline1)
 
     if stroke.satin_guide_pattern_position == "adaptive":
         return _generate_satin_guide_helper_lines_with_varying_pattern_distance(
@@ -450,7 +468,7 @@ def _generate_simple_satin_guide_helper_lines(stroke, outline, guide_line):
     point0 = pairs[0][0]
     point1 = pairs[0][1]
 
-    start_rotation = atan2(point1.y - point0.y, point1.x - point0.x)
+    start_rotation = get_rotation(point0, point1)
     start_scale = (point1 - point0).length()
     outline_center = InkstitchPoint.from_shapely_point(outline.centroid)
 
@@ -463,7 +481,7 @@ def _generate_simple_satin_guide_helper_lines(stroke, outline, guide_line):
         guide_center = (point0 + point1) / 2
         translation = guide_center - outline_center
         if stroke.rotate_ripples:
-            rotation = atan2(point1.y - point0.y, point1.x - point0.x)
+            rotation = get_rotation(point0, point1)
             rotation = rotation - start_rotation
         else:
             rotation = 0
@@ -499,7 +517,7 @@ def _generate_satin_guide_helper_lines_with_constant_pattern_distance(stroke, gu
 
         # move to point0, rotate and scale so the other point hits point1
         scaling = (point1 - point0).length() / outline_width
-        rotation = atan2(point1.y - point0.y, point1.x - point0.x)
+        rotation = get_rotation(point0, point1)
         rotation = rotation - outline_rotation
         translation = point0 - outline0
         transformed_outline = _transform_outline(translation, rotation, scaling, outline, Point(point0), 0)
@@ -511,33 +529,39 @@ def _generate_satin_guide_helper_lines_with_constant_pattern_distance(stroke, gu
     return _point_dict_to_helper_lines(len(outline.coords), line_point_dict)
 
 
-def _generate_satin_guide_helper_lines_with_varying_pattern_distance(stroke, guide_line, outline, outline0, outline_width, outline_rotation):
-    # rotate pattern and get the pattern width
-    transformed_outline = _transform_outline(Point([0, 0]), outline_rotation, 1, outline, Point(outline0), 0)
-    minx, miny, maxx, maxy = transformed_outline.bounds
-    pattern_height = maxy - miny
+def _generate_satin_guide_helper_lines_with_varying_pattern_distance(stroke, guide_line, outline, outline0, outline_height, outline_rotation):
+    outline = _transform_outline(Point([0, 0]), -outline_rotation, 1, outline, Point(outline0), 0)
+    minx, miny, maxx, maxy = outline.bounds
+    bbox = Polygon([(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)])
+
+    min_distance = stroke.min_line_dist or 0.1
+    miny -= min_distance
+    maxy - min_distance
+    min_dist_bbox = Polygon([(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)])
 
-    distance = 0
-    min_distance = stroke.min_line_dist or 0
     line_point_dict = defaultdict(list)
-    while True:
-        if distance > guide_line.center_line.length:
-            break
+
+    pairs = guide_line.plot_points_on_rails(0.1)
+    last_bbox = None
+    for point0, point1 in pairs:
         check_stop_flag()
-        point0, point1 = get_cut_points(guide_line, distance)
 
         # move to point0, rotate and scale so the other point hits point1
-        scaling = (point1 - point0).length() / outline_width
-        rotation = atan2(point1.y - point0.y, point1.x - point0.x)
-        rotation = rotation - outline_rotation
+        scaling = (point1 - point0).length() / outline_height
+        rotation = get_rotation(point0, point1)
         translation = point0 - outline0
         transformed_outline = _transform_outline(translation, rotation, scaling, outline, Point(point0), 0)
 
-        distance += max(0.01, (pattern_height * scaling) + min_distance)
+        this_bbox = _transform_outline(translation, rotation, scaling, bbox, Point(point0), 0)
+        if last_bbox is not None:
+            if not last_bbox.disjoint(this_bbox):
+                continue
 
         # outline to helper line points
         for j, point in enumerate(transformed_outline.coords):
             line_point_dict[j].append(InkstitchPoint(point[0], point[1]))
+        last_bbox = _transform_outline(translation, rotation, scaling, min_dist_bbox, Point(point0), 0)
+        prepare(last_bbox)
 
     return _point_dict_to_helper_lines(len(outline.coords), line_point_dict)
 
@@ -547,6 +571,10 @@ def get_cut_points(guide_line, distance):
     return guide_line.find_cut_points(*cut_point.coords)
 
 
+def get_rotation(point0, point1):
+    return atan2(point1.y - point0.y, point1.x - point0.x)
+
+
 def _transform_outline(translation, rotation, scaling, outline, origin, scale_axis):
     # transform
     transformed_outline = translate(outline, translation.x, translation.y)
