remove incorrect stop logic

2 files changed, 24 insertions, 111 deletions

diff --git a/lib/stitch_plan/stitch_plan.py b/lib/stitch_plan/stitch_plan.py
index 1a466295..0fa87d71 100644
--- a/lib/stitch_plan/stitch_plan.py
+++ b/lib/stitch_plan/stitch_plan.py
@@ -1,6 +1,4 @@
 from .stitch import Stitch
-from .stop import process_stop
-from .trim import process_trim
 from .ties import add_ties
 from ..svg import PIXELS_PER_MM
 from ..utils.geometry import Point
@@ -26,26 +24,29 @@ def patches_to_stitch_plan(patches, collapse_len=3.0 * PIXELS_PER_MM):
         if not patch.stitches:
             continue
 
-        if color_block.color != patch.color or color_block.stop_after:
-            # add a color change (only if we didn't just do a "STOP after")
-            if not color_block.stop_after:
+        if color_block.color != patch.color:
+            if len(color_block) == 0:
+                # We just processed a stop, which created a new color block.
+                # We'll just claim this new block as ours:
+                color_block.color = patch.color
+            else:
+                # end the previous block with a color change
                 color_block.add_stitch(color_change=True)
 
-            color_block = stitch_plan.new_color_block(color=patch.color)
+                # make a new block of our color
+                color_block = stitch_plan.new_color_block(color=patch.color)
 
-        color_block.filter_duplicate_stitches()
         color_block.add_stitches(patch.stitches, no_ties=patch.stitch_as_is)
 
         if patch.trim_after:
             color_block.add_stitch(trim=True)
 
         if patch.stop_after:
-            process_stop(stitch_plan)
-
-            # process_stop() may have split the block into two
-            color_block = stitch_plan.last_color_block
+            color_block.add_stitch(stop=True)
+            color_block = stitch_plan.new_color_block(color_block.color)
 
-    add_ties(stitch_plan)
+    stitch_plan.filter_duplicate_stitches()
+    stitch_plan.add_ties()
 
     return stitch_plan
 
@@ -64,6 +65,14 @@ class StitchPlan(object):
     def add_color_block(self, color_block):
         self.color_blocks.append(color_block)
 
+    def filter_duplicate_stitches(self):
+        for color_block in self:
+            color_block.filter_duplicate_stitches()
+
+    def add_ties(self):
+        # see ties.py
+        add_ties(self)
+
     def __iter__(self):
         return iter(self.color_blocks)
 
@@ -198,12 +207,12 @@ class ColorBlock(object):
         stitches = [self.stitches[0]]
 
         for stitch in self.stitches[1:]:
-            if stitches[-1].jump or stitch.stop or stitch.trim:
-                # Don't consider jumps, stops, or trims as candidates for filtering
+            if stitches[-1].jump or stitch.stop or stitch.trim or stitch.color_change:
+                # Don't consider jumps, stops, color changes, or trims as candidates for filtering
                 pass
             else:
                 l = (stitch - stitches[-1]).length()
-                if l <= 0.1:
+                if l <= 0.1 * PIXELS_PER_MM:
                     # duplicate stitch, skip this one
                     continue
 
@@ -247,11 +256,3 @@ class ColorBlock(object):
         maxy = max(stitch.y for stitch in self)
 
         return minx, miny, maxx, maxy
-
-    def split_at(self, index):
-        """Split this color block into two at the specified stitch index"""
-
-        new_color_block = ColorBlock(self.color, self.stitches[index:])
-        del self.stitches[index:]
-
-        return new_color_block
diff --git a/lib/stitch_plan/stop.py b/lib/stitch_plan/stop.py
deleted file mode 100644
index 0ccaeaf8..00000000
--- a/lib/stitch_plan/stop.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from copy import copy
-
-from ..svg import PIXELS_PER_MM
-
-
-def process_stop(stitch_plan):
-    """Handle the "stop after" checkbox.
-
-    The user wants the machine to pause after this patch.  This can
-    be useful for applique and similar on multi-needle machines that
-    normally would not stop between colors.
-
-    In most machine embroidery file formats, there's no such thing as
-    an actual "STOP" instruction.  All that exists is a "color change"
-    command.
-
-    On multi-needle machines, the user assigns needles to the colors in
-    the design before starting stitching.  C01, C02, etc are the normal
-    needles, but C00 is special.  For a block of stitches assigned
-    to C00, the machine will continue sewing with the last color it
-    had and pause after it completes the C00 block.  Machines that don't
-    call it C00 still have a similar concept.
-
-    We'll add a STOP instruction at the end of this color block.
-    Unfortunately, we have a bit of a catch-22: the user needs to set
-    C00 (or equivalent) for the _start_ of this block to get the
-    machine to stop at the end of this block.  That means it will use
-    the previous color, which isn't the right color at all!
-
-    For the first STOP in a given thread color, we'll need to
-    introduce an extra color change.  The user can then set the correct
-    color for the first section and C00 for the second, resulting in
-    a stop where we want it.
-
-    We'll try to find a logical place to split the color block, like
-    a TRIM or a really long stitch.  Failing that, we'll just split
-    it in half.
-    """
-
-    color_block = stitch_plan.last_color_block
-
-    if not color_block or len(color_block) < 2:
-        return
-
-    last_stitch = color_block.last_stitch
-    color_block.add_stitch(stop=True)
-
-    if len(stitch_plan) > 1:
-        # if this isn't the first stop in this color, then we're done
-        if stitch_plan.color_blocks[-2].stop_after and \
-            stitch_plan.color_blocks[-2].color == color_block.color:
-                return
-
-    # We need to split this color block.  Pick the last TRIM or
-    # the last long stitch (probably between distant patches).
-
-    for i in xrange(len(color_block) - 2, -1, -1):
-        stitch = color_block.stitches[i]
-
-        if stitch.trim:
-            # ignore the trim right before the stop we just added
-            if i < len(color_block) - 2:
-                # split after the trim
-                i = i + 1
-                break
-
-        if i > 0:
-            next_stitch = color_block.stitches[i + 1]
-
-            if (stitch - next_stitch).length() > 20 * PIXELS_PER_MM:
-                break
-
-    if i == 0:
-        # Darn, we didn't find a TRIM or long stitch.  Just chop the
-        # block in half.
-        i = len(color_block) / 2
-
-    new_color_block = color_block.split_at(i)
-
-    # If we're splitting in the middle of a run of stitches, we don't
-    # want a gap to appear in the preview and the PDF printout, so
-    # add an extra stitch to bridge the gap.  Technically this will
-    # result in a double needle penetration but it's no big deal.
-    if not color_block.last_stitch.trim:
-        color_block.add_stitch(copy(new_color_block.stitches[0]))
-
-    color_block.add_stitch(color_change=True, fake_color_change=True)
-    stitch_plan.add_color_block(new_color_block)