Auto-run: fix transform issue (#4043)

kaalleen · web-flow · commit 352f4aa76e7d · 2025-11-22T17:17:10.000+01:00
* auto-run: fix transform issue
* auto-run: remove empty groups in selection
* keep manual stitch in underpathing too
diff --git a/lib/extensions/auto_run.py b/lib/extensions/auto_run.py
@@ -5,11 +5,12 @@
 
 from typing import Any, List, Optional, Union
 
-from inkex import Boolean, Vector2d, errormsg
+from inkex import Boolean, Group, Vector2d, errormsg
 
 from ..elements import Stroke
 from ..i18n import _
 from ..stitches.auto_run import autorun
+from ..svg.svg import delete_empty_groups
 from .commands import CommandsExtension
 
 
@@ -34,7 +35,9 @@ def effect(self) -> None:
 
         break_up = self.options.break_up
 
-        autorun(elements, self.options.preserve_order, break_up, starting_point, ending_point, self.options.trim)
+        group = self._create_group()
+        autorun(elements, self.options.preserve_order, break_up, starting_point, ending_point, self.options.trim, group)
+        delete_empty_groups(self.svg.selection)
 
     def get_starting_point(self) -> Optional[Vector2d]:
         return self.get_command_point("autoroute_start")
@@ -62,3 +65,14 @@ def check_selection(self) -> List[Union[Stroke, Any]]:
             errormsg(_("Please select at least one stroke element."))
 
         return elements
+
+    def _create_group(self):
+        if self.options.preserve_order:
+            return None
+        node = self.svg.selection.rendering_order()[-1]
+        parent = node.getparent()
+        index = parent.index(node) + 1
+        group = Group()
+        group.label = _("Auto-Route")
+        parent.insert(index, group)
+        return group
diff --git a/lib/extensions/redwork.py b/lib/extensions/redwork.py
@@ -13,7 +13,7 @@
 from ..elements import Stroke
 from ..i18n import _
 from ..svg import PIXELS_PER_MM, get_correction_transform
-from ..svg.tags import SVG_GROUP_TAG
+from ..svg.svg import delete_empty_groups
 from ..utils.geometry import ensure_multi_line_string
 from .base import InkstitchExtension
 
@@ -78,15 +78,7 @@ def _delete_original_elements(self, elements):
         for element in elements:
             element.node.delete()
         # remove empty groups
-        for element in self.svg.selection:
-            selected_groups = self.svg.selection.filter(Group)
-            for group in selected_groups:
-                groups_within_group = reversed(list(group.iterdescendants(SVG_GROUP_TAG)))
-                for g in groups_within_group:
-                    if len(g) == 0:
-                        g.delete()
-                if len(group) == 0:
-                    group.delete()
+        delete_empty_groups(self.svg.selection)
 
     def _ensure_starting_point(self, multi_line_string, starting_point):
         # returns a MultiLineString whose first  LineString starts close to  starting_point
diff --git a/lib/stitches/auto_run.py b/lib/stitches/auto_run.py
@@ -16,8 +16,7 @@
 from ..svg import PIXELS_PER_MM, generate_unique_id, get_correction_transform
 from ..svg.tags import INKSCAPE_LABEL, INKSTITCH_ATTRIBS
 from ..utils.threading import check_stop_flag
-from .utils.autoroute import (add_elements_to_group, add_jumps,
-                              create_new_group, find_path,
+from .utils.autoroute import (add_elements_to_group, add_jumps, find_path,
                               get_starting_and_ending_nodes,
                               preserve_original_groups,
                               remove_original_elements)
@@ -119,7 +118,7 @@ def _get_segments(self):
                     self.segments.append([seg, self._elements[i]])
 
 
-def autorun(elements, preserve_order=False, break_up=None, starting_point=None, ending_point=None, trim=False):
+def autorun(elements, preserve_order=False, break_up=None, starting_point=None, ending_point=None, trim=False, group=None):
     graph = build_graph(elements, preserve_order, break_up)
 
     graph = add_jumps(graph, elements, preserve_order)
@@ -130,14 +129,11 @@ def autorun(elements, preserve_order=False, break_up=None, starting_point=None,
     path = find_path(graph, starting_point, ending_point)
     path = add_path_attribs(path)
 
-    new_elements, trims, original_parents = path_to_elements(graph, path, trim)
+    new_elements, trims, original_parents = path_to_elements(graph, path, trim, group)
 
     if preserve_order:
         preserve_original_groups(new_elements, original_parents, transform=False)
     else:
-        parent = elements[0].node.getparent()
-        insert_index = parent.index(elements[0].node)
-        group = create_new_group(parent, insert_index, _("Auto-Route"), False)
         add_elements_to_group(new_elements, group)
 
     if trim:
@@ -195,7 +191,7 @@ def add_path_attribs(path):
     return path
 
 
-def path_to_elements(graph, path, trim):  # noqa: C901
+def path_to_elements(graph, path, trim, parent=None):  # noqa: C901
     element_list = []
     original_parents = []
     trims = []
@@ -217,7 +213,7 @@ def path_to_elements(graph, path, trim):  # noqa: C901
         end_coord = graph.nodes[end]['point']
         # create a new element if we hit an other original element to keep it's properties
         if el and element and el != element and d and not direction == 'underpath':
-            element_list.append(create_element(d, position, path_direction, el))
+            element_list.append(create_element(d, position, path_direction, el, parent))
             original_parents.append(el.node.getparent())
             d = ""
             position += 1
@@ -234,7 +230,7 @@ def path_to_elements(graph, path, trim):  # noqa: C901
             # create a new element if direction (purpose) changes
             if direction != path_direction:
                 if d:
-                    element_list.append(create_element(d, position, path_direction, el))
+                    element_list.append(create_element(d, position, path_direction, el, parent))
                     original_parents.append(el.node.getparent())
                     d = ""
                     position += 1
@@ -246,7 +242,7 @@ def path_to_elements(graph, path, trim):  # noqa: C901
                 d += f", {end_coord.x} {end_coord.y}"
         elif el and d:
             # this is a jump, so complete the element whose path we've been building
-            element_list.append(create_element(d, position, path_direction, el))
+            element_list.append(create_element(d, position, path_direction, el, parent))
             original_parents.append(el.node.getparent())
             d = ""
 
@@ -257,17 +253,19 @@ def path_to_elements(graph, path, trim):  # noqa: C901
             position += 1
 
     if d:
-        element_list.append(create_element(d, position, path_direction, el))
+        element_list.append(create_element(d, position, path_direction, el, parent))
     original_parents.append(el.node.getparent())
 
     return element_list, trims, original_parents
 
 
-def create_element(path, position, direction, element):
+def create_element(path, position, direction, element, parent=None):  # noqa: C901
     if not path:
         return
 
     el_id = f"{direction}_{position}_"
+    if parent is None:
+        parent = element.node.getparent()
 
     index = position + 1
     if direction == "autorun":
@@ -276,7 +274,7 @@ def create_element(path, position, direction, element):
         path_type = 'autorun-top'
     else:
         label = _("AutoRun Underpath %d") % index
-        dasharray = '2 1.1'
+        dasharray = '3 0.5'
         path_type = 'autorun-underpath'
 
     node = inkex.PathElement()
@@ -287,13 +285,14 @@ def create_element(path, position, direction, element):
     node.set("style", element.node.style)
     node.style["fill"] = 'none'
     node.style["stroke-dasharray"] = dasharray
-    node.transform = get_correction_transform(element.node.getparent(), child=True)
+    node.transform = get_correction_transform(parent, child=True)
     node.apply_transform()
 
     # Set Ink/Stitch attributes
     stitch_length = element.node.get(INKSTITCH_ATTRIBS['running_stitch_length_mm'], '')
     tolerance = element.node.get(INKSTITCH_ATTRIBS['running_stitch_tolerance_mm'], '')
     repeats = int(element.node.get(INKSTITCH_ATTRIBS['repeats'], 1))
+    stroke_method = element.node.get('inkstitch:stroke_method', '')
     if repeats % 2 == 0:
         repeats -= 1
 
@@ -309,6 +308,8 @@ def create_element(path, position, direction, element):
             node.set(INKSTITCH_ATTRIBS['running_stitch_length_mm'], stitch_length)
         if tolerance:
             node.set(INKSTITCH_ATTRIBS['running_stitch_tolerance_mm'], tolerance)
+        if stroke_method == 'manual_stitch':
+            node.set('inkstitch:stroke_method', stroke_method)
     return Stroke(node)
 
 
diff --git a/lib/svg/svg.py b/lib/svg/svg.py
@@ -5,10 +5,11 @@
 
 import math
 
-from inkex import NSS, BaseElement, Transform
+from inkex import NSS, BaseElement, Group, Transform
 from lxml import etree
 
 from ..utils import cache
+from .tags import SVG_GROUP_TAG
 
 
 @cache
@@ -56,3 +57,15 @@ def point_upwards(node: BaseElement) -> None:
     # Clear the x and y coords, they've been incorporated to the transform above
     node.set('x', None)
     node.set('y', None)
+
+
+def delete_empty_groups(selection):
+    for element in selection:
+        selected_groups = selection.filter(Group)
+        for group in selected_groups:
+            groups_within_group = reversed(list(group.iterdescendants(SVG_GROUP_TAG)))
+            for g in groups_within_group:
+                if len(g) == 0:
+                    g.delete()
+            if len(group) == 0:
+                group.delete()
