Move device filter handling (#42)

* run device filters earlier using fixed scale
* add UI options for displaying source image, move path, filtered path

Closes #32

Author: karliss

inkcut/core/models.py

@@ -304,6 +304,8 @@ def _bind_observers(self):
         """ Try to load the plugin state """
         #: Restore
         try:
+            log.debug("Restoring plugin {} state restored from: {}".format(
+                self.manifest.id, self._state_file))
             with enaml.imports():
                 with open(self._state_file, 'r') as f:
                     state = pickle.loads(f.read())
@@ -325,7 +327,7 @@ def _save_state(self, change):
         """ Try to save the plugin state """
         if change['type'] in ['update', 'container', 'request']:
             try:
-                log.info("Saving state due to change: {}".format(change))
+                log.info("Saving state {} due to change: {}".format(self.manifest.id, change))
 
                 #: Dump first so any failure to encode doesn't wipe out the
                 #: previous state

inkcut/core/utils.py

@@ -269,6 +269,21 @@ def rect_to_path(rect):
     return path
 
 
+def make_move_path(model, initial_position: QPointF = None):
+    """ Returns the path of movements between drawn lines
+    """
+    path = QPainterPath()
+    if initial_position:
+        path.moveTo(initial_position.x(), initial_position.y())
+    for i in range(model.elementCount()):
+        e = model.elementAt(i)
+        if e.isMoveTo():
+            path.lineTo(e.x, e.y)
+        else:
+            path.moveTo(e.x, e.y)
+    return path
+
+
 def find_subclasses(cls):
     """Finds all known (imported) subclasses of the given class"""
     cmds = []

inkcut/device/filters/blade_offset.py

@@ -51,6 +51,10 @@ class BladeOffsetFilter(DeviceFilter):
     #: Change config
     config = Instance(BladeOffsetConfig, ()).tag(config=True)
 
+    @property
+    def stage(self):
+        return DeviceFilter.FILTER_STAGE_PATH_COMBINED
+
     def apply_to_model(self, model, job):
         """Apply the filter to the path model.
 

inkcut/device/filters/min_line.py

@@ -59,6 +59,10 @@ class MinLineFilter(DeviceFilter):
     #: Change config
     config = Instance(MinLineConfig, ()).tag(config=True)
 
+    @property
+    def stage(self):
+        return DeviceFilter.FILTER_STAGE_PATH_COMBINED
+
     def apply_to_model(self, model, job):
         if self.config.min_jump > 0:
             model = self.apply_min_jump(model)

inkcut/device/filters/overcut.py

@@ -29,7 +29,11 @@ def _default_overcut_units(self):
 class OvercutFilter(DeviceFilter):
     #: Change config
     config = Instance(OvercutConfig, ()).tag(config=True)
-    
+
+    @property
+    def stage(self):
+        return DeviceFilter.FILTER_STAGE_POLYLINE
+
     def apply_to_polypath(self, polypath):
         """ Apply the filter to the polypath. It's much easier doing this
         after conversion to polypaths.
@@ -72,7 +76,7 @@ def apply_overcut(self, poly, overcut):
             path.lineTo(p)
 
             # Check if that point is past the distance we need to go
-            if path.length() > overcut: 
+            if path.length() > overcut:
                 t = path.percentAtLength(overcut)
                 poly.append(path.pointAtPercent(t))
                 return  # Done!

inkcut/device/filters/repeat.py

@@ -29,6 +29,10 @@ class RepeatConfig(Model):
 class RepeatFilter(DeviceFilter):
     config = Instance(RepeatConfig, ()).tag(config=True)
 
+    @property
+    def stage(self):
+        return DeviceFilter.FILTER_STAGE_PATH_COMBINED
+
     def apply_to_model(self, model, job):
         if self.config.steps <= 1:
             return model

inkcut/device/plugin.py

@@ -237,6 +237,13 @@ class DeviceFilter(Model):
     #: The protocol specific config
     config = Instance(Model, ()).tag(config=True)
 
+    FILTER_STAGE_PATH_COMBINED = 1
+    FILTER_STAGE_POLYLINE = 2
+
+    @property
+    def stages(self) -> int:
+        return 0
+
     def apply_to_model(self, model, job):
         """ Apply the filter to the model
 
@@ -657,7 +664,6 @@ def clone(self, device_plugin):
         new_dev.name = self.name
         new_dev.manufacturer = self.manufacturer
         new_dev.model = self.model
-        new_dev.area = self.area.clone()
         new_dev.custom = self.custom
         if driver.factory:
             connection_decl = self.connection.declaration
@@ -701,11 +707,9 @@ def init(self, job):
 
         job.info.speed = config.speed
 
-        direction = self.config.expansion_direction
-
         # Get the internal QPainterPath "model" transformed to how this
         # device outputs
-        model = job.create(direction)
+        model = job.create_transform_filtered(self)
 
         tr = self.config.get_paper_to_work_transform(job.material)
         #: Move the job to the new origin
@@ -1054,11 +1058,6 @@ def process(self, model):
         if not skip_interpolation and step_size <= 0:
             raise ValueError("Cannot have a step size <= 0!")
         try:
-            # Apply device filters
-            for f in self.filters:
-                log.debug(" filter | Running {} on model".format(f))
-                model = f.apply_to_model(model, job=self)
-
             # Since Qt's toSubpathPolygons converts curves without accepting
             # a parameter to set the minimum distance between points on the
             # curve, we need to prescale by a "quality factor" before
@@ -1076,11 +1075,6 @@ def process(self, model):
                     1/config.quality_factor, 1/config.quality_factor)
                 polypath = list(map(m_inv.map, polypath))
 
-            # Apply device filters to polypath
-            for f in self.filters:
-                log.debug(" filter | Running {} on polypath".format(f))
-                polypath = f.apply_to_polypath(polypath)
-
             for path in polypath:
 
                 #: And then each point within the path
@@ -1372,32 +1366,4 @@ def _refresh_filters(self):
         for extension in sorted(point.extensions, key=lambda ext: ext.rank):
             for t in extension.get_children(extensions.DeviceFilter):
                 filters.append(t)
-        self.filters = filters
-
-    # -------------------------------------------------------------------------
-    # Live progress API
-    # -------------------------------------------------------------------------
-
-    @observe('device', 'device.job', 'device.alignment_corner', 'device.paper_corner', 'device.area')
-    def _reset_preview(self, change):
-        # TODO: device plugin shouldn't need to know anything about preview plugin, preview plugin should subscribe to
-        # relevant events itself
-        preview_plugin = self.workbench.get_plugin('inkcut.preview')
-        preview_plugin.reset_live_preview(self.device, self.device.job, clear_paths=True)
-
-    @observe('device.origin')
-    def _reset_preview2(self, change):
-        # TODO: device plugin shouldn't need to know anything about preview plugin, preview plugin should subscribe to
-        # relevant events itself
-        preview_plugin = self.workbench.get_plugin('inkcut.preview')
-        preview_plugin.reset_live_preview(self.device, self.device.job, clear_paths=False)
-
-    @observe('device.position')
-    def _update_preview(self, change):
-        """ Watch the position of the device as it changes. """
-        if change['type'] == 'update' and self.device.job:
-            x, y, z = change['value']
-            origin = self.device.config.inverse_transform.map(QPointF(x, y))
-            x, y = origin.x(), origin.y()
-            preview_plugin = self.workbench.get_plugin('inkcut.preview')
-            preview_plugin.live_preview.update((x, y, z))
+        self.filters = filters

inkcut/job/models.py

@@ -22,6 +22,8 @@
 from enaml.qt.QtGui import QPainterPath, QTransform
 from enaml.qt.QtCore import QPointF, QRectF
 from enaml.colors import ColorMember
+
+import inkcut.core.utils
 from inkcut.core.api import Model, AreaBase
 from inkcut.core.svg import QtSvgDoc
 from inkcut.core.utils import split_painter_path, log
@@ -30,7 +32,6 @@
 from . import filters
 from . import ordering
 
-
 class Material(AreaBase):
     """ Model representing the plot media
     """
@@ -291,7 +292,7 @@ def _default_optimized_path(self):
 
         return doc
 
-    def _default_content_direction(self):
+    def _default_quadrant_direction(self):
         return QPointF(1, 1)
 
     @observe('path', 'order', 'filters')
@@ -477,6 +478,58 @@ def create(self, expansion_direction: QPointF):
 
         return model
 
+    def create_transform_filtered(self, device):
+        config = device.config
+        model = self.create(config.expansion_direction)
+
+        from inkcut.device.plugin import DeviceFilter
+
+        # Apply device filters
+        has_polyline_filter = False
+        for f in device.filters:
+            log.debug(" filter | Running {} on model".format(f))
+            if f.stage & DeviceFilter.FILTER_STAGE_POLYLINE:
+                has_polyline_filter = True
+            if f.stage & DeviceFilter.FILTER_STAGE_PATH_COMBINED:
+                model = f.apply_to_model(model, job=device)
+
+        # Only apply polyline transformation if necessary. So that original curves can be preserved
+        # and sent to device directly when supported.
+        if has_polyline_filter:
+            # Since Qt's toSubpathPolygons converts curves without accepting
+            # a parameter to set the minimum distance between points on the
+            # curve, we need to prescale by a "quality factor" before
+            # converting then undo the scaling to effectively adjust the
+            # number of points on a curve.
+            quality_factor = config.quality_factor
+            m = QTransform.fromScale(
+                quality_factor, quality_factor)
+            # Some versions of Qt seem to require a value in toSubpathPolygons
+            polypath = model.toSubpathPolygons(m)
+
+            if config.quality_factor != 1:
+                # Undo the prescaling, if the quality_factor > 1 the curve
+                # quality will be improved.
+                m_inv = QTransform.fromScale(
+                    1 / quality_factor, 1 / quality_factor)
+                polypath = list(map(m_inv.map, polypath))
+
+            # Apply device filters to polypath
+            for f in device.filters:
+                log.debug(" filter | Running {} on polypath".format(f))
+                if f.stage & DeviceFilter.FILTER_STAGE_POLYLINE:
+                    polypath = f.apply_to_polypath(polypath)
+
+            end_point = model.currentPosition()
+            model = QPainterPath()
+            for path in polypath:
+                model.addPolygon(path)
+
+            model.moveTo(end_point)
+
+        return model
+
+
     def _check_bounds(self, plot, area):
         """ Checks that the width and height of plot are less than the width
         and height of area
@@ -558,15 +611,7 @@ def move_path(self):
         """ Returns the path the head moves when not cutting
 
         """
-        # Compute the negative
-        path = QPainterPath()
-        for i in range(self.model.elementCount()):
-            e = self.model.elementAt(i)
-            if e.isMoveTo():
-                path.lineTo(e.x, e.y)
-            else:
-                path.moveTo(e.x, e.y)
-        return path
+        return inkcut.core.utils.make_move_path(self.model)
 
     @property
     def cut_path(self):
@@ -575,30 +620,6 @@ def cut_path(self):
         """
         return self.model
 
-    #     def get_offset_path(self,device):
-    #         """ Returns path where it is cutting """
-    #         path = QPainterPath()
-    #         _p = QPointF(0,0) # previous point
-    #         step = 0.1
-    #         for subpath in QtSvgDoc.toSubpathList(self.model):#.toSubpathPolygons():
-    #             e = subpath.elementAt(0)
-    #             path.moveTo(QPointF(e.x,e.y))
-    #             length = subpath.length()
-    #             distance = 0
-    #             while distance<=length:
-    #                 t = subpath.percentAtLength(distance)
-    #                 p = subpath.pointAtPercent(t)
-    #                 a = subpath.angleAtPercent(t)+90
-    #                 #path.moveTo(p)#QPointF(x,y))
-    #                 # TOOD: Do i need numpy here???
-    #                 x = p.x()+np.multiply(self.device.blade_offset,np.sin(np.deg2rad(a)))
-    #                 y = p.y()+np.multiply(self.device.blade_offset,np.cos(np.deg2rad(a)))
-    #                 path.lineTo(QPointF(x,y))
-    #                 distance+=step
-    #             #_p = p # update last
-    #
-    #         return path
-
     def add_stack(self):
         """ Add a complete stack or fill the row