meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7010__py2.py3-none-any.whl

meerk40t/core/cutcode/quadcut.py

@@ -1,61 +1,61 @@
-from ...svgelements import Point
-from ...tools.zinglplotter import ZinglPlotter
-from .cutobject import CutObject
-
-
-class QuadCut(CutObject):
-    def __init__(
-        self,
-        start_point,
-        control_point,
-        end_point,
-        settings=None,
-        passes=1,
-        parent=None,
-        color=None,
-    ):
-        CutObject.__init__(
-            self,
-            start_point,
-            end_point,
-            settings=settings,
-            passes=passes,
-            parent=parent,
-            color=color,
-        )
-        self._control = control_point
-
-    def __repr__(self):
-        return f'QuadCut({repr(self.start)}, {repr(self.c())}, {repr(self.end)}, settings="{self.settings}", passes={self.passes})'
-
-    def __str__(self):
-        return f"QuadCut({repr(self.start)}, {repr(self.c())}, {repr(self.end)}, passes={self.passes})"
-
-    def c(self):
-        return self._control
-
-    def length(self):
-        return Point.distance(self.start, self.c()) + Point.distance(self.c(), self.end)
-
-    def generator(self):
-        # pylint: disable=unsubscriptable-object
-        start = self.start
-        c = self.c()
-        end = self.end
-        return ZinglPlotter.plot_quad_bezier(
-            start[0],
-            start[1],
-            c[0],
-            c[1],
-            end[0],
-            end[1],
-        )
-
-    def point(self, t):
-        x0, y0 = self.start
-        x1, y1 = self.c()
-        x2, y2 = self.end
-        e = 1 - t
-        x = e * e * x0 + 2 * e * t * x1 + t * t * x2
-        y = e * e * y0 + 2 * e * t * y1 + t * t * y2
-        return x, y
+from ...svgelements import Point
+from ...tools.zinglplotter import ZinglPlotter
+from .cutobject import CutObject
+
+
+class QuadCut(CutObject):
+    def __init__(
+        self,
+        start_point,
+        control_point,
+        end_point,
+        settings=None,
+        passes=1,
+        parent=None,
+        color=None,
+    ):
+        CutObject.__init__(
+            self,
+            start_point,
+            end_point,
+            settings=settings,
+            passes=passes,
+            parent=parent,
+            color=color,
+        )
+        self._control = control_point
+
+    def __repr__(self):
+        return f'QuadCut({repr(self.start)}, {repr(self.c())}, {repr(self.end)}, settings="{self.settings}", passes={self.passes})'
+
+    def __str__(self):
+        return f"QuadCut({repr(self.start)}, {repr(self.c())}, {repr(self.end)}, passes={self.passes})"
+
+    def c(self):
+        return self._control
+
+    def length(self):
+        return Point.distance(self.start, self.c()) + Point.distance(self.c(), self.end)
+
+    def generator(self):
+        # pylint: disable=unsubscriptable-object
+        start = self.start
+        c = self.c()
+        end = self.end
+        return ZinglPlotter.plot_quad_bezier(
+            start[0],
+            start[1],
+            c[0],
+            c[1],
+            end[0],
+            end[1],
+        )
+
+    def point(self, t):
+        x0, y0 = self.start
+        x1, y1 = self.c()
+        x2, y2 = self.end
+        e = 1 - t
+        x = e * e * x0 + 2 * e * t * x1 + t * t * x2
+        y = e * e * y0 + 2 * e * t * y1 + t * t * y2
+        return x, y

meerk40t/core/cutcode/rastercut.py

@@ -1,148 +1,168 @@
-from meerk40t.core.cutcode.cutobject import CutObject
-from meerk40t.tools.rasterplotter import RasterPlotter
-
-
-class RasterCut(CutObject):
-    """
-    Rastercut accepts an image of type "L" or "1", and an offset in the x and y.
-    """
-
-    def __init__(
-        self,
-        image,
-        offset_x,
-        offset_y,
-        step_x,
-        step_y,
-        inverted=False,
-        bidirectional=True,
-        horizontal=True,
-        start_minimum_y=True,
-        start_minimum_x=True,
-        overscan=0,
-        settings=None,
-        passes=1,
-        parent=None,
-        color=None,
-    ):
-        CutObject.__init__(
-            self, settings=settings, passes=passes, parent=parent, color=color
-        )
-        if image.mode not in ("L", "1"):
-            image = image.convert("L")
-        # assert image.mode in ("L", "1")
-        self.first = True  # Raster cuts are always first within themselves.
-        self.image = image
-        self.offset_x = offset_x
-        self.offset_y = offset_y
-        self.step_x = step_x
-        self.step_y = step_y
-        # if False -> burn in one direction, if True -> burn back and forth
-        self.bidirectional = bidirectional
-        self.horizontal = horizontal
-        self.start_minimum_y = start_minimum_y
-        self.start_minimum_x = start_minimum_x
-        self.width, self.height = image.size
-        self.inverted = inverted
-        self.scan = overscan
-        if inverted:
-            skip_pixel = 255
-
-            def image_filter(pixel):
-                return pixel / 255.0
-
-        else:
-            skip_pixel = 0
-
-            def image_filter(pixel):
-                return (255 - pixel) / 255.0
-
-        self.plot = RasterPlotter(
-            data=image.load(),
-            width=self.width,
-            height=self.height,
-            horizontal=self.horizontal,
-            start_minimum_y=self.start_minimum_y,
-            start_minimum_x=self.start_minimum_x,
-            bidirectional=self.bidirectional,
-            skip_pixel=skip_pixel,
-            overscan=self.scan,
-            offset_x=self.offset_x,
-            offset_y=self.offset_y,
-            step_x=self.step_x,
-            step_y=self.step_y,
-            filter=image_filter,
-        )
-
-    def reversible(self):
-        return False
-
-    def reverse(self):
-        pass
-
-    @property
-    def start(self):
-        return self.plot.initial_position_in_scene()
-
-    @property
-    def end(self):
-        return self.plot.final_position_in_scene()
-
-    def lower(self):
-        return self.plot.offset_y + self.height
-
-    def upper(self):
-        return self.plot.offset_y
-
-    def right(self):
-        return self.plot.offset_x + self.width
-
-    def left(self):
-        return self.plot.offset_x
-
-    def length(self):
-        """
-        crosshatch will be translated into two passes, so we have either a clear horizontal or a clear vertical
-
-        self.scan_x * width in pixel = real width
-
-        overscan is in device units
-
-        @return:
-        """
-
-        if self.horizontal:
-            scanlines = self.height
-            scan_step = self.step_y
-            scan_stride = self.step_x
-            scan_distance = self.width * scan_stride
-        else:
-            scanlines = self.width
-            scan_stride = self.step_x
-            scan_step = self.step_y
-            scan_distance = self.height * scan_stride
-        # Total scan-distance is pixel_distance plus overscan
-        scan_distance += self.scan
-        if not self.bidirectional:
-            # Burning in only one direction means we have 2 x distance
-            scan_distance *= 2
-        total_distance_per_scanline = scan_distance + scan_step
-        return scanlines * total_distance_per_scanline
-
-    def extra(self):
-        if self.horizontal:
-            return self.height * 0.119
-        else:
-            return self.width * 0.119
-
-    def major_axis(self):
-        return 0 if self.plot.horizontal else 1
-
-    def x_dir(self):
-        return 1 if self.plot.start_minimum_x else -1
-
-    def y_dir(self):
-        return 1 if self.plot.start_minimum_y else -1
-
-    def generator(self):
-        return self.plot.plot()
+from meerk40t.core.cutcode.cutobject import CutObject
+from meerk40t.tools.rasterplotter import RasterPlotter
+
+class RasterCut(CutObject):
+    """
+    Rastercut accepts an image of type "L" or "1", and an offset in the x and y.
+    """
+
+    def __init__(
+        self,
+        image,
+        offset_x,
+        offset_y,
+        step_x,
+        step_y,
+        inverted=False,
+        direction = 0,
+        bidirectional=True,
+        horizontal=True,
+        start_minimum_y=True,
+        start_minimum_x=True,
+        overscan=0,
+        settings=None,
+        passes=1,
+        parent=None,
+        color=None,
+        post_filter=None,
+        label=None,
+        laserspot=0,
+        special=None,
+    ):
+        CutObject.__init__(
+            self, settings=settings, passes=passes, parent=parent, color=color, label=label,
+        )
+        if image.mode not in ("L", "1"):
+            image = image.convert("L")
+        # assert image.mode in ("L", "1")
+        self.first = True  # Raster cuts are always first within themselves.
+        self.image = image
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+        self.step_x = step_x
+        self.step_y = step_y
+        # if False -> burn in one direction, if True -> burn back and forth
+        self.bidirectional = bidirectional
+        self.horizontal = horizontal
+        self.start_minimum_y = start_minimum_y
+        self.start_minimum_x = start_minimum_x
+        self.width, self.height = image.size
+        self.inverted = inverted
+        self.scan = overscan
+        # Only relevant for bidirectional mode
+        if inverted:
+            skip_pixel = 255
+
+            def image_filter(pixel):
+                return pixel / 255.0
+
+        else:
+            skip_pixel = 0
+
+            def image_filter(pixel):
+                return (255 - pixel) / 255.0
+
+        if post_filter is None:
+            post_filter = image_filter
+
+        self.plot = RasterPlotter(
+            data=image.load(),
+            width=self.width,
+            height=self.height,
+            direction=direction,
+            horizontal=self.horizontal,
+            start_minimum_y=self.start_minimum_y,
+            start_minimum_x=self.start_minimum_x,
+            bidirectional=self.bidirectional,
+            skip_pixel=skip_pixel,
+            overscan=self.scan,
+            offset_x=self.offset_x,
+            offset_y=self.offset_y,
+            step_x=self.step_x,
+            step_y=self.step_y,
+            filter=post_filter,
+            laserspot=laserspot,
+            special=special,
+        )
+
+    def reversible(self):
+        return False
+
+    def reverse(self):
+        pass
+
+    @property
+    def start(self):
+        return self.plot.initial_position_in_scene()
+
+    @property
+    def end(self):
+        return self.plot.final_position_in_scene()
+
+    def lower(self):
+        return self.plot.offset_y + self.height
+
+    def upper(self):
+        return self.plot.offset_y
+
+    def right(self):
+        return self.plot.offset_x + self.width
+
+    def left(self):
+        return self.plot.offset_x
+
+    def length(self):
+        """
+        crosshatch will be translated into two passes, so we have either a clear horizontal or a clear vertical
+
+        self.scan_x * width in pixel = real width
+
+        overscan is in device units
+
+        Todo: this is unaware of the optimisation algorithms introduced, so this needs to be revised.
+
+        @return:
+        """
+
+        if self.horizontal:
+            pixels = self.width
+            scanlines = self.height
+            scan_step = self.step_y
+            scan_stride = self.step_x
+        else:
+            pixels = self.height
+            scanlines = self.width
+            scan_step = self.step_x
+            scan_stride = self.step_y
+        scan_distance = pixels * scan_stride
+        # Total scan-distance is pixel_distance plus overscan
+        scan_distance += self.scan
+        if not self.bidirectional:
+            # Burning in only one direction means we have 2 x distance
+            scan_distance *= 2
+        total_distance_per_scanline = scan_distance + scan_step
+        return scanlines * total_distance_per_scanline
+
+    def extra(self):
+        return self.height * 0.119 if self.horizontal else self.width * 0.119
+
+    def internal_travel(self):
+        return self.plot.distance_travel
+
+    def internal_length(self):
+        distance = self.plot.distance_burn
+        if distance == 0:
+            distance = self.length()
+        return distance
+
+    def major_axis(self):
+        return 0 if self.plot.horizontal else 1
+
+    def x_dir(self):
+        return 1 if self.plot.start_minimum_x else -1
+
+    def y_dir(self):
+        return 1 if self.plot.start_minimum_y else -1
+
+    def generator(self):
+        return self.plot.plot()

meerk40t/core/cutcode/waitcut.py

@@ -1,34 +1,34 @@
-from .cutobject import CutObject
-
-
-class WaitCut(CutObject):
-    def __init__(self, wait, settings=None, passes=1, parent=None, color=None):
-        """
-        Establish a wait cut.
-        @param wait: wait time in ms.
-        @param settings: Settings for wait cut.
-        @param passes: Number of passes.
-        @param parent: CutObject parent.
-        """
-        CutObject.__init__(
-            self,
-            (0, 0),
-            (0, 0),
-            settings=settings,
-            passes=passes,
-            parent=parent,
-            color=color,
-        )
-        self.dwell_time = wait
-        self.first = True  # Wait cuts are standalone
-        self.last = True
-
-    def reversible(self):
-        return False
-
-    def reverse(self):
-        pass
-
-    def generate(self):
-        # Dwell time is already in ms.
-        yield "wait", self.dwell_time
+from .cutobject import CutObject
+
+
+class WaitCut(CutObject):
+    def __init__(self, wait, settings=None, passes=1, parent=None, color=None):
+        """
+        Establish a wait cut.
+        @param wait: wait time in ms.
+        @param settings: Settings for wait cut.
+        @param passes: Number of passes.
+        @param parent: CutObject parent.
+        """
+        CutObject.__init__(
+            self,
+            (0, 0),
+            (0, 0),
+            settings=settings,
+            passes=passes,
+            parent=parent,
+            color=color,
+        )
+        self.dwell_time = wait
+        self.first = True  # Wait cuts are standalone
+        self.last = True
+
+    def reversible(self):
+        return False
+
+    def reverse(self):
+        pass
+
+    def generate(self):
+        # Dwell time is already in ms.
+        yield "wait", self.dwell_time