diff --git a/lib/stitch_plan/stitch_plan.py b/lib/stitch_plan/stitch_plan.py index 1a4662957..0fa87d716 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) + color_block.add_stitch(stop=True) + color_block = stitch_plan.new_color_block(color_block.color) - # process_stop() may have split the block into two - color_block = stitch_plan.last_color_block - - 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 0ccaeaf8f..000000000 --- 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)