keep underlay, underpath, and border travel

lib/elements/auto_fill.py

@@ -214,7 +214,7 @@ class AutoFill(Fill):
             return None
 
     def to_stitch_groups(self, last_patch):
-        stitches = []
+        stitch_groups = []
 
         starting_point = self.get_starting_point(last_patch)
         ending_point = self.get_ending_point()
@@ -222,29 +222,40 @@ class AutoFill(Fill):
         try:
             if self.fill_underlay:
                 for i in range(len(self.fill_underlay_angle)):
-                    stitches.extend(auto_fill(self.underlay_shape,
-                                              self.fill_underlay_angle[i],
-                                              self.fill_underlay_row_spacing,
-                                              self.fill_underlay_row_spacing,
-                                              self.fill_underlay_max_stitch_length,
-                                              self.running_stitch_length,
-                                              self.staggers,
-                                              self.fill_underlay_skip_last,
-                                              starting_point,
-                                              underpath=self.underlay_underpath))
-                    starting_point = stitches[-1]
+                    underlay = StitchGroup(
+                        color=self.color,
+                        tags=("auto_fill", "auto_fill_underlay"),
+                        stitches=auto_fill(
+                            self.underlay_shape,
+                            self.fill_underlay_angle[i],
+                            self.fill_underlay_row_spacing,
+                            self.fill_underlay_row_spacing,
+                            self.fill_underlay_max_stitch_length,
+                            self.running_stitch_length,
+                            self.staggers,
+                            self.fill_underlay_skip_last,
+                            starting_point,
+                            underpath=self.underlay_underpath))
+                    stitch_groups.append(underlay)
 
-            stitches.extend(auto_fill(self.fill_shape,
-                                      self.angle,
-                                      self.row_spacing,
-                                      self.end_row_spacing,
-                                      self.max_stitch_length,
-                                      self.running_stitch_length,
-                                      self.staggers,
-                                      self.skip_last,
-                                      starting_point,
-                                      ending_point,
-                                      self.underpath))
+                    starting_point = underlay.stitches[-1]
+
+            stitch_group = StitchGroup(
+                color=self.color,
+                tags=("auto_fill", "auto_fill_top"),
+                stitches=auto_fill(
+                    self.fill_shape,
+                    self.angle,
+                    self.row_spacing,
+                    self.end_row_spacing,
+                    self.max_stitch_length,
+                    self.running_stitch_length,
+                    self.staggers,
+                    self.skip_last,
+                    starting_point,
+                    ending_point,
+                    self.underpath))
+            stitch_groups.append(stitch_group)
         except Exception:
             if hasattr(sys, 'gettrace') and sys.gettrace():
                 # if we're debugging, let the exception bubble up
@@ -262,18 +273,19 @@ class AutoFill(Fill):
 
             self.fatal(message)
 
-        return [StitchGroup(stitches=stitches, color=self.color)]
+        return stitch_groups
 
-    def validation_warnings(self):
-        if self.shape.area < 20:
-            label = self.node.get(INKSCAPE_LABEL) or self.node.get("id")
-            yield SmallShapeWarning(self.shape.centroid, label)
 
-        if self.shrink_or_grow_shape(self.expand, True).is_empty:
-            yield ExpandWarning(self.shape.centroid)
+def validation_warnings(self):
+    if self.shape.area < 20:
+        label = self.node.get(INKSCAPE_LABEL) or self.node.get("id")
+        yield SmallShapeWarning(self.shape.centroid, label)
 
-        if self.shrink_or_grow_shape(-self.fill_underlay_inset, True).is_empty:
-            yield UnderlayInsetWarning(self.shape.centroid)
+    if self.shrink_or_grow_shape(self.expand, True).is_empty:
+        yield ExpandWarning(self.shape.centroid)
 
-        for warning in super(AutoFill, self).validation_warnings():
-            yield warning
+    if self.shrink_or_grow_shape(-self.fill_underlay_inset, True).is_empty:
+        yield UnderlayInsetWarning(self.shape.centroid)
+
+    for warning in super(AutoFill, self).validation_warnings():
+        yield warning

lib/patterns.py

@@ -52,6 +52,12 @@ def _apply_fill_patterns(patterns, patches):
                 elif stitch.has_tag('fill_row_start') or stitch.has_tag('fill_row_end'):
                     # keep points if they are the start or end of a fill stitch row
                     patch_points.append(stitch)
+                elif stitch.has_tag('auto_fill') and not stitch.has_tag('auto_fill_top'):
+                    # keep auto-fill underlay
+                    patch_points.append(stitch)
+                elif stitch.has_tag('auto_fill_travel'):
+                    # keep travel stitches (underpath or travel around the border)
+                    patch_points.append(stitch)
             patch.stitches = patch_points
 
 

lib/stitch_plan/stitch_group.py

@@ -17,7 +17,7 @@ class StitchGroup:
     between them by the stitch plan generation code.
     """
 
-    def __init__(self, color=None, stitches=None, trim_after=False, stop_after=False, tie_modus=0, stitch_as_is=False):
+    def __init__(self, color=None, stitches=None, trim_after=False, stop_after=False, tie_modus=0, stitch_as_is=False, tags=None):
         self.color = color
         self.trim_after = trim_after
         self.stop_after = stop_after
@@ -28,6 +28,9 @@ class StitchGroup:
         if stitches:
             self.add_stitches(stitches)
 
+        if tags:
+            self.add_tags(tags)
+
     def __add__(self, other):
         if isinstance(other, StitchGroup):
             return StitchGroup(self.color, self.stitches + other.stitches)
@@ -51,3 +54,11 @@ class StitchGroup:
 
     def reverse(self):
         return StitchGroup(self.color, self.stitches[::-1])
+
+    def add_tags(self, tags):
+        for stitch in self.stitches:
+            stitch.add_tags(tags)
+
+    def add_tag(self, tag):
+        for stitch in self.stitches:
+            stitch.add_tag(tag)

lib/stitches/auto_fill.py

@@ -14,6 +14,7 @@ from shapely.ops import snap
 from shapely.strtree import STRtree
 
 from ..debug import debug
+from ..stitch_plan import Stitch
 from ..svg import PIXELS_PER_MM
 from ..utils.geometry import Point as InkstitchPoint
 from ..utils.geometry import line_string_to_point_list
@@ -592,9 +593,12 @@ def travel(travel_graph, start, end, running_stitch_length, skip_last):
     """Create stitches to get from one point on an outline of the shape to another."""
 
     path = networkx.shortest_path(travel_graph, start, end, weight='weight')
-    path = [InkstitchPoint(*p) for p in path]
+    path = [Stitch(*p) for p in path]
     stitches = running_stitch(path, running_stitch_length)
 
+    for stitch in stitches:
+        stitch.add_tag('auto_fill_travel')
+
     # The path's first stitch will start at the end of a row of stitches.  We
     # don't want to double that last stitch, so we'd like to skip it.
     if skip_last and len(path) > 2:
@@ -619,7 +623,7 @@ def path_to_stitches(path, travel_graph, fill_stitch_graph, angle, row_spacing,
 
     # If the very first stitch is travel, we'll omit it in travel(), so add it here.
     if not path[0].is_segment():
-        stitches.append(InkstitchPoint(*path[0].nodes[0]))
+        stitches.append(Stitch(*path[0].nodes[0]))
 
     for edge in path:
         if edge.is_segment():