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

meerk40t/extra/vectrace.py

@@ -1,146 +1,147 @@
-from meerk40t.svgelements import Matrix, Path, Polygon
-
-
-def plugin(kernel, lifecycle=None):
-    if lifecycle == "register":
-        _ = kernel.translation
-
-        @kernel.console_command(
-            "vectrace",
-            help=_("return paths around image"),
-            input_type="image",
-            output_type="elements",
-        )
-        def vectrace(data, **kwargs):
-            elements = kernel.root.elements
-            path = Path(fill="black", stroke="blue")
-            paths = []
-            for node in data:
-                matrix = node.matrix
-                image = node.image
-                width, height = node.image.size
-                if image.mode != "L":
-                    image = image.convert("L")
-                image = image.point(lambda e: int(e > 127) * 255)
-                for points in _vectrace(image.load(), width, height):
-                    path += Polygon(*points)
-                path.transform *= Matrix(matrix)
-                paths.append(
-                    elements.elem_branch.add(
-                        path=abs(path),
-                        stroke_width=0,
-                        stroke_scaled=False,
-                        type="elem path",
-                    )
-                )
-            return "elements", paths
-
-
-_NORTH = 3
-_EAST = 0
-_SOUTH = 1
-_WEST = 2
-
-
-def _trace(pixels, x, y, width, height):
-    """
-    This function is called only when the scanline polygon tracing has located a
-    point with a white values above y and before x.
-    Keeping a black pixel on the right. Position 0,0 is the topleft corner
-    above and more left than all pixels. There are n+1,m+1 locations for n,m
-    pixels. The pixel equal to the current position is always bottom right (se).
-    The pixels adjacent to the current location are:
-    (x - 1, y - 1),   (x    , y - 1)
-                    X
-    (x - 1, y    ),   (x    , y    )
-    @param pixels:
-    @param x:
-    @param y:
-    @return:
-    """
-    start_y = y
-    start_x = x
-    direction = _EAST
-    positions = [x + y * 1j]
-    scanpoints = list()
-
-    def px(pixel_x, pixel_y):
-        if 0 <= pixel_x < width and 0 <= pixel_y < height:
-            return pixels[pixel_x, pixel_y]
-        else:
-            return 255
-
-    while True:
-        nw = px(x - 1, y - 1)
-        ne = px(x, y - 1)
-        sw = px(x - 1, y)
-        se = px(x, y)
-        if direction == _EAST:
-            pixel_right = se
-            pixel_left = ne
-            # print("Going East (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
-        elif direction == _NORTH:
-            pixel_right = ne
-            pixel_left = nw
-            # print("Going North (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
-        elif direction == _SOUTH:
-            pixel_right = sw
-            pixel_left = se
-            # print("Going South (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
-        else:  # WEST
-            pixel_right = nw
-            pixel_left = sw
-            # print("Going West (%d,%d): %d vs %d." % (y, x, pixel_left, pixel_right))
-        # print("%s %s\n%s %s" % (str(nw).ljust(4), str(ne).ljust(4), str(sw).ljust(4), str(se).ljust(4)))
-
-        if pixel_left and pixel_right:
-            direction += 1  # Turn right.
-            positions.append(x + y * 1j)
-        if not pixel_left and not pixel_right:
-            direction -= 1  # Turn Left
-            positions.append(x + y * 1j)
-        if pixel_left and not pixel_right:
-            pass  # Pixel still on right.
-        if not pixel_left and pixel_right:
-            # Turn Policy Right-Only
-            direction += 1  # or direction -= 1
-            positions.append(x + y * 1j)
-
-        direction = (direction + 4) % 4
-
-        if direction == _EAST:
-            x += 1
-        elif direction == _NORTH:
-            y -= 1
-            scanpoints.append((x, y))
-        elif direction == _SOUTH:
-            scanpoints.append((x, y))
-            y += 1
-        else:  # WEST
-            x -= 1
-        if start_y == y and start_x == x:
-            break
-    positions.append(x + y * 1j)
-    return scanpoints, positions
-
-
-def _vectrace(pixels, width, height):
-    """
-    Returns a list of points comprising the edge vectors of the image.
-    We're only dealing with grayscale images.
-    """
-    for y in range(height):
-        for x in range(width):
-            if pixels[x, y] == 0:
-                scanpoints, positions = _trace(pixels, x, y, width, height)
-                scanpoints.sort(key=lambda p: p[1] * width + p[0])
-                for i in range(0, len(scanpoints), 2):
-                    x0 = scanpoints[i][0]
-                    x1 = scanpoints[i + 1][0]
-                    y0 = scanpoints[i][1]
-                    y1 = scanpoints[i + 1][1]
-                    if y0 != y1:
-                        raise ValueError
-                    for xi in range(x0, x1):
-                        pixels[xi, y0] = 0 if pixels[xi, y0] else 255
-                yield positions
+from meerk40t.svgelements import Matrix, Path, Polygon
+
+
+def plugin(kernel, lifecycle=None):
+    if lifecycle == "register":
+        _ = kernel.translation
+
+        @kernel.console_command(
+            "vectrace",
+            help=_("return paths around image"),
+            input_type="image",
+            output_type="elements",
+        )
+        def vectrace(data, **kwargs):
+            elements = kernel.root.elements
+            path = Path(fill="black", stroke="blue")
+            paths = []
+            with elements.undoscope("Vectrace"):
+                for node in data:
+                    matrix = node.matrix
+                    image = node.image
+                    width, height = node.image.size
+                    if image.mode != "L":
+                        image = image.convert("L")
+                    image = image.point(lambda e: int(e > 127) * 255)
+                    for points in _vectrace(image.load(), width, height):
+                        path += Polygon(*points)
+                    path.transform *= Matrix(matrix)
+                    paths.append(
+                        elements.elem_branch.add(
+                            path=abs(path),
+                            stroke_width=500,
+                            stroke_scaled=False,
+                            type="elem path",
+                        )
+                    )
+            return "elements", paths
+
+
+_NORTH = 3
+_EAST = 0
+_SOUTH = 1
+_WEST = 2
+
+
+def _trace(pixels, x, y, width, height):
+    """
+    This function is called only when the scanline polygon tracing has located a
+    point with a white values above y and before x.
+    Keeping a black pixel on the right. Position 0,0 is the topleft corner
+    above and more left than all pixels. There are n+1,m+1 locations for n,m
+    pixels. The pixel equal to the current position is always bottom right (se).
+    The pixels adjacent to the current location are:
+    (x - 1, y - 1),   (x    , y - 1)
+                    X
+    (x - 1, y    ),   (x    , y    )
+    @param pixels:
+    @param x:
+    @param y:
+    @return:
+    """
+    start_y = y
+    start_x = x
+    direction = _EAST
+    positions = [x + y * 1j]
+    scanpoints = list()
+
+    def px(pixel_x, pixel_y):
+        if 0 <= pixel_x < width and 0 <= pixel_y < height:
+            return pixels[pixel_x, pixel_y]
+        else:
+            return 255
+
+    while True:
+        nw = px(x - 1, y - 1)
+        ne = px(x, y - 1)
+        sw = px(x - 1, y)
+        se = px(x, y)
+        if direction == _EAST:
+            pixel_right = se
+            pixel_left = ne
+            # print("Going East (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
+        elif direction == _NORTH:
+            pixel_right = ne
+            pixel_left = nw
+            # print("Going North (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
+        elif direction == _SOUTH:
+            pixel_right = sw
+            pixel_left = se
+            # print("Going South (%d,%d): %d vs %d." % (x, y, pixel_left, pixel_right))
+        else:  # WEST
+            pixel_right = nw
+            pixel_left = sw
+            # print("Going West (%d,%d): %d vs %d." % (y, x, pixel_left, pixel_right))
+        # print("%s %s\n%s %s" % (str(nw).ljust(4), str(ne).ljust(4), str(sw).ljust(4), str(se).ljust(4)))
+
+        if pixel_left and pixel_right:
+            direction += 1  # Turn right.
+            positions.append(x + y * 1j)
+        if not pixel_left and not pixel_right:
+            direction -= 1  # Turn Left
+            positions.append(x + y * 1j)
+        if pixel_left and not pixel_right:
+            pass  # Pixel still on right.
+        if not pixel_left and pixel_right:
+            # Turn Policy Right-Only
+            direction += 1  # or direction -= 1
+            positions.append(x + y * 1j)
+
+        direction = (direction + 4) % 4
+
+        if direction == _EAST:
+            x += 1
+        elif direction == _NORTH:
+            y -= 1
+            scanpoints.append((x, y))
+        elif direction == _SOUTH:
+            scanpoints.append((x, y))
+            y += 1
+        else:  # WEST
+            x -= 1
+        if start_y == y and start_x == x:
+            break
+    positions.append(x + y * 1j)
+    return scanpoints, positions
+
+
+def _vectrace(pixels, width, height):
+    """
+    Returns a list of points comprising the edge vectors of the image.
+    We're only dealing with grayscale images.
+    """
+    for y in range(height):
+        for x in range(width):
+            if pixels[x, y] == 0:
+                scanpoints, positions = _trace(pixels, x, y, width, height)
+                scanpoints.sort(key=lambda p: p[1] * width + p[0])
+                for i in range(0, len(scanpoints), 2):
+                    x0 = scanpoints[i][0]
+                    x1 = scanpoints[i + 1][0]
+                    y0 = scanpoints[i][1]
+                    y1 = scanpoints[i + 1][1]
+                    if y0 != y1:
+                        raise ValueError
+                    for xi in range(x0, x1):
+                        pixels[xi, y0] = 0 if pixels[xi, y0] else 255
+                yield positions

meerk40t/extra/winsleep.py

@@ -1,83 +1,83 @@
-import platform
-
-"""
-Winsleep is a internal standalone Windows-only plugin that works for sys.platform 'win32'.
-The plugin does not register if the platform is not MSW.
-
-If any signal origin gives a pipe;running signal of True, it will execute sleepmode_disable.
-When all signals then give pipe;running signals of False, it will execute sleepmode_enable.
-
-We also register sleepmode_disable and sleepmode_enable as hidden commands which flag
-the ctypes windll kernel32 threadstate to be ES_SYSTEM_REQUIRED which disables sleeping
-in windows.
-"""
-
-
-SLEEP_DISABLED = [None, dict(), False]
-
-
-def on_usb_running(origin, value):
-    """
-    Registered during the boot and unregistered during shutdown lifecycle.
-
-    On_usb_running listens for pipe;running signals and if any origin value is true
-    This calls sleepmode_disable.
-    """
-    running = SLEEP_DISABLED[1]
-    running[origin] = value
-    any_origin_running = False
-    for v in running:
-        q = running[v]
-        if q:
-            any_origin_running = True
-            break
-    if any_origin_running != SLEEP_DISABLED[2]:
-        SLEEP_DISABLED[2] = any_origin_running
-        if any_origin_running:
-            # pylint: disable=E1102
-            SLEEP_DISABLED[0](".sleepmode_disable\n")
-        else:
-            # pylint: disable=E1102
-            SLEEP_DISABLED[0](".sleepmode_enable\n")
-
-
-def plugin(kernel, lifecycle):
-    if lifecycle == "invalidate":
-        # Plugin only matters for MSW platform
-        return platform.system() != "Windows"
-    if lifecycle == "boot":
-        context = kernel.root
-
-        context.listen("pipe;running", on_usb_running)
-    elif lifecycle == "register":
-        context = kernel.root
-        SLEEP_DISABLED[0] = context
-        _ = kernel.translation
-
-        @context.console_command(
-            "sleepmode_disable", help=_("disables sleepmode"), hidden=True
-        )
-        def sleepmode_disable(**kwargs):
-            try:
-                import ctypes
-
-                # ES_CONTINUOUS, 0x80000000, # ES_SYSTEM_REQUIRED = 0x00000001
-                ctypes.windll.kernel32.SetThreadExecutionState(0x80000001)
-            except AttributeError:
-                pass
-
-        @context.console_command(
-            "sleepmode_enable", help=_("enables sleepmode"), hidden=True
-        )
-        def sleepmode_enable(**kwargs):
-            try:
-                import ctypes
-
-                # ES_CONTINUOUS, 0x80000000
-                ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)
-            except AttributeError:
-                pass
-
-    elif lifecycle == "shutdown":
-        context = kernel.root
-        context.unlisten("pipe;running", on_usb_running)
+import platform
+
+"""
+Winsleep is a internal standalone Windows-only plugin that works for sys.platform 'win32'.
+The plugin does not register if the platform is not MSW.
+
+If any signal origin gives a pipe;running signal of True, it will execute sleepmode_disable.
+When all signals then give pipe;running signals of False, it will execute sleepmode_enable.
+
+We also register sleepmode_disable and sleepmode_enable as hidden commands which flag
+the ctypes windll kernel32 threadstate to be ES_SYSTEM_REQUIRED which disables sleeping
+in windows.
+"""
+
+
+SLEEP_DISABLED = [None, dict(), False]
+
+
+def on_usb_running(origin, value):
+    """
+    Registered during the boot and unregistered during shutdown lifecycle.
+
+    On_usb_running listens for pipe;running signals and if any origin value is true
+    This calls sleepmode_disable.
+    """
+    running = SLEEP_DISABLED[1]
+    running[origin] = value
+    any_origin_running = False
+    for v in running:
+        q = running[v]
+        if q:
+            any_origin_running = True
+            break
+    if any_origin_running != SLEEP_DISABLED[2]:
+        SLEEP_DISABLED[2] = any_origin_running
+        if any_origin_running:
+            # pylint: disable=E1102
+            SLEEP_DISABLED[0](".sleepmode_disable\n")
+        else:
+            # pylint: disable=E1102
+            SLEEP_DISABLED[0](".sleepmode_enable\n")
+
+
+def plugin(kernel, lifecycle):
+    if lifecycle == "invalidate":
+        # Plugin only matters for MSW platform
+        return platform.system() != "Windows"
+    if lifecycle == "boot":
+        context = kernel.root
+
+        context.listen("pipe;running", on_usb_running)
+    elif lifecycle == "register":
+        context = kernel.root
+        SLEEP_DISABLED[0] = context
+        _ = kernel.translation
+
+        @context.console_command(
+            "sleepmode_disable", help=_("disables sleepmode"), hidden=True
+        )
+        def sleepmode_disable(**kwargs):
+            try:
+                import ctypes
+
+                # ES_CONTINUOUS, 0x80000000, # ES_SYSTEM_REQUIRED = 0x00000001
+                ctypes.windll.kernel32.SetThreadExecutionState(0x80000001)
+            except AttributeError:
+                pass
+
+        @context.console_command(
+            "sleepmode_enable", help=_("enables sleepmode"), hidden=True
+        )
+        def sleepmode_enable(**kwargs):
+            try:
+                import ctypes
+
+                # ES_CONTINUOUS, 0x80000000
+                ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)
+            except AttributeError:
+                pass
+
+    elif lifecycle == "shutdown":
+        context = kernel.root
+        context.unlisten("pipe;running", on_usb_running)