Merge pull request #10 from lexelby/live-simulate

live stitching preview in the Params extension

1 files changed, 152 insertions, 20 deletions

diff --git a/embroider_simulate.py b/embroider_simulate.py
index 2629c812..f3f9e5e2 100644
--- a/embroider_simulate.py
+++ b/embroider_simulate.py
@@ -3,21 +3,31 @@ import os
 import numpy
 import wx
 import inkex
+import simplestyle
+import colorsys
+
+from embroider import patches_to_stitches, stitches_to_polylines
 
 class EmbroiderySimulator(wx.Frame):
     def __init__(self, *args, **kwargs):
-        stitch_file = kwargs.pop('stitch_file')
+        stitch_file = kwargs.pop('stitch_file', None)
+        patches = kwargs.pop('patches', None)
+        self.on_close_hook = kwargs.pop('on_close', None)
         self.frame_period = kwargs.pop('frame_period', 80)
         self.stitches_per_frame = kwargs.pop('stitches_per_frame', 1)
+        self.target_duration = kwargs.pop('target_duration', None)
 
         wx.Frame.__init__(self, *args, **kwargs)
+
         self.panel = wx.Panel(self, wx.ID_ANY)
         self.panel.SetFocus()
 
-        self.stitches = self._parse_stitches(stitch_file)
-        self.width, self.height = self.get_dimensions()
+        self.load(stitch_file, patches)
 
-        self.buffer = wx.EmptyBitmap(self.width, self.height)
+        if self.target_duration:
+            self.adjust_speed(self.target_duration)
+
+        self.buffer = wx.Bitmap(self.width, self.height)
         self.dc = wx.MemoryDC()
         self.dc.SelectObject(self.buffer)
         self.canvas = wx.GraphicsContext.Create(self.dc)
@@ -28,8 +38,33 @@ class EmbroiderySimulator(wx.Frame):
         self.panel.Bind(wx.EVT_PAINT, self.on_paint)
         self.panel.Bind(wx.EVT_KEY_DOWN, self.on_key_down)
 
+        self.timer = None
+
         self.last_pos = None
 
+        self.Bind(wx.EVT_CLOSE, self.on_close)
+
+    def load(self, stitch_file=None, patches=None):
+        if stitch_file:
+            self.mirror = True
+            self.segments = self._parse_stitch_file(stitch_file)
+        elif patches:
+            self.mirror = False
+            self.segments = self._patches_to_segments(patches)
+        else:
+            return
+
+        self.trim_margins()
+        self.width, self.height = self.get_dimensions()
+
+    def adjust_speed(self, duration):
+        self.frame_period = 1000 * float(duration) / len(self.segments)
+        self.stitches_per_frame = 1
+
+        while self.frame_period < 1.0:
+            self.frame_period *= 2
+            self.stitches_per_frame *= 2
+
     def on_key_down(self, event):
         keycode = event.GetKeyCode()
 
@@ -50,6 +85,10 @@ class EmbroiderySimulator(wx.Frame):
                 self.timer.Stop()
             else:
                 self.timer.Start(self.frame_period)
+        elif keycode == ord("R"):
+            self.stop()
+            self.clear()
+            self.go()
 
         self.frame_period = max(1, self.frame_period)
         self.stitches_per_frame = max(self.stitches_per_frame, 1)
@@ -64,15 +103,55 @@ class EmbroiderySimulator(wx.Frame):
 
         return string
 
-    def _parse_stitches(self, stitch_file_path):
+    def color_to_pen(self, color):
+        # python colorsys module uses floats from 0 to 1.0
+        color = [value / 255.0 for value in color]
+
+        hls = list(colorsys.rgb_to_hls(*color))
+
+        # Our background is white.  If the color is too close to white, then
+        # it won't be visible.  Capping lightness should make colors visible
+        # without changing them too much.
+        hls[1] = min(hls[1], 0.85)
+
+        color = colorsys.hls_to_rgb(*hls)
+
+        # convert back to values in the range of 0-255
+        color = [value * 255 for value in color]
+
+        return wx.Pen(color)
+
+    def _patches_to_segments(self, patches):
+        stitches = patches_to_stitches(patches)
+
+        segments = []
+
+        last_pos = None
+        last_color = None
+        pen = None
+
+        for stitch in stitches:
+            pos = (stitch.x, stitch.y)
+
+            if stitch.color == last_color:
+                segments.append(((last_pos, pos), pen))
+            else:
+                pen = self.color_to_pen(simplestyle.parseColor(stitch.color))
+
+            last_pos = pos
+            last_color = stitch.color
+
+        return segments
+
+    def _parse_stitch_file(self, stitch_file_path):
         # "$","1","229","229","229","(null)","(null)"
         # "*","JUMP","1.595898","48.731899"
         # "*","STITCH","1.595898","48.731899"
 
-        stitches = []
+        segments = []
 
         pos = (0, 0)
-        color = wx.Brush('black')
+        pen = wx.Brush('black')
         cut = True
 
         with open(stitch_file_path) as stitch_file:
@@ -84,7 +163,7 @@ class EmbroiderySimulator(wx.Frame):
 
                 if symbol == "$":
                     red, green, blue = fields[2:5]
-                    color = wx.Pen((int(red), int(green), int(blue)))
+                    color = color_to_pen((int(red), int(green), int(blue)))
                 elif symbol == "*":
                     if command == "COLOR":
                         # change color
@@ -97,33 +176,84 @@ class EmbroiderySimulator(wx.Frame):
                         new_pos = (int(float(x) * 10), int(float(y) * 10))
 
                         if not cut:
-                            stitches.append(((pos, new_pos), color))
+                            segments.append(((pos, new_pos), pen))
 
                         cut = False
                         pos = new_pos
 
-        return stitches
+        return segments
+
+    def all_coordinates(self):
+        for segment in self.segments:
+            start, end = segment[0]
+
+            yield start
+            yield end
+
+    def trim_margins(self):
+        """remove any unnecessary whitespace around the design"""
+
+        min_x = sys.maxint
+        min_y = sys.maxint
+
+        for x, y in self.all_coordinates():
+            min_x = min(min_x, x)
+            min_y = min(min_y, y)
+
+        new_segments = []
+
+        for segment in self.segments:
+            (start, end), color = segment
+
+            new_segment = (
+                           (
+                            (start[0] - min_x, start[1] - min_y),
+                            (end[0] - min_x, end[1] - min_y),
+                           ),
+                           color
+                          )
+
+            new_segments.append(new_segment)
+
+        self.segments = new_segments
 
     def get_dimensions(self):
         width = 0
         height = 0
 
-        for stitch in self.stitches:
-            (start_x, start_y), (end_x, end_y) = stitch[0]
-
-            width = max(width, start_x, end_x)
-            height = max(height, start_y, end_y)
+        for x, y in self.all_coordinates():
+            width = max(width, x)
+            height = max(height, y)
 
         return width, height
 
     def go(self):
+        self.clear()
+
         self.current_stitch = 0
-        self.timer = wx.PyTimer(self.draw_one_stitch)
+
+        if not self.timer:
+            self.timer = wx.PyTimer(self.draw_one_frame)
+
         self.timer.Start(self.frame_period)
 
+    def on_close(self, event):
+        self.stop()
+
+        if self.on_close_hook:
+            self.on_close_hook()
+
+        self.Destroy()
+
+    def stop(self):
+        if self.timer:
+            self.timer.Stop()
+
     def clear(self):
         self.dc.SetBackground(wx.Brush('white'))
         self.dc.Clear()
+        self.last_pos = None
+        self.Refresh()
 
     def on_size(self, e):
         # ensure that the whole canvas is visible
@@ -149,12 +279,14 @@ class EmbroiderySimulator(wx.Frame):
         dc = wx.ClientDC(self)
         dc.DrawBitmap(self.buffer, 0, 0)
 
-    def draw_one_stitch(self):
+    def draw_one_frame(self):
         for i in xrange(self.stitches_per_frame):
             try:
-                ((x1, y1), (x2, y2)), color = self.stitches[self.current_stitch]
-                y1 = self.height - y1
-                y2 = self.height - y2
+                ((x1, y1), (x2, y2)), color = self.segments[self.current_stitch]
+
+                if self.mirror:
+                    y1 = self.height - y1
+                    y2 = self.height - y2
 
                 self.canvas.SetPen(color)
                 self.canvas.DrawLines(((x1, y1), (x2, y2)))