meerk40t 0.9.7020__py2.py3-none-any.whl → 0.9.7040__py2.py3-none-any.whl

meerk40t/image/imagetools.py

@@ -19,11 +19,11 @@ from .dither import dither
 
 
 def img_to_polygons(
-        node_image,                 # The image
-        minimal,                    # Minimum area in percent (int) to consider
-        maximal,                    # Maximum area in percent (int) to consider
-        ignoreinner,                # Ignore inner contours
-        needs_invert=True           # Does the image require inverting (we need white strcutures on a black background)
+    node_image,  # The image
+    minimal,  # Minimum area in percent (int) to consider
+    maximal,  # Maximum area in percent (int) to consider
+    ignoreinner,  # Ignore inner contours
+    needs_invert=True,  # Does the image require inverting (we need white strcutures on a black background)
 ):
     """
     Takes the image and provides a list of geomstr + associated matrix
@@ -33,7 +33,7 @@ def img_to_polygons(
         import cv2
         from PIL import ImageOps
     except ImportError:
-        return ([], [])
+        return [[], []]
     geom_list = list()
 
     # Convert the image to grayscale
@@ -44,10 +44,12 @@ def img_to_polygons(
 
     # Find contours in the binary image
     try:
-        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+        contours, hierarchies = cv2.findContours(
+            th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE
+        )
     except ValueError:
         # Invalid data
-        return ([], [])
+        return [[], []]
 
     # print(f"Found {len(contours)} contours and {len(hierarchies)} hierarchies")
     width, height = node_image.size
@@ -68,12 +70,12 @@ def img_to_polygons(
             continue
         region = contour.squeeze().astype(float).tolist()
         if type(region[0]) is list and len(region) > 2:
-            crdnts = [{'x': i[0], 'y': i[1]} for i in region]
+            crdnts = [{"x": i[0], "y": i[1]} for i in region]
 
             geom = Geomstr()
             notfirst = False
             for pnt in crdnts:
-                rx, ry = pnt['x'], pnt['y']
+                rx, ry = pnt["x"], pnt["y"]
                 if notfirst:
                     geom.line(complex(lx, ly), complex(rx, ry))
                 notfirst = True
@@ -81,20 +83,20 @@ def img_to_polygons(
                 ly = ry
             geom.close()
             matrix = Matrix()
-            geom_list.append( (geom, 100 * area / (width * height)) )
+            geom_list.append((geom, 100 * area / (width * height)))
 
     return geom_list
 
-def do_innerwhite(
-        minimal=None,
-        outer=False,
-        simplified=False,
-        line=False,
-        breakdown=False,
-        whiten=False,
-        data=None,
-    ):
 
+def do_innerwhite(
+    minimal=None,
+    outer=False,
+    simplified=False,
+    line=False,
+    breakdown=False,
+    whiten=False,
+    data=None,
+):
     import cv2
 
     def org_bounds(node):
@@ -342,9 +344,7 @@ def do_innerwhite(
                     # print(f"Erasing right: {dx}:{rwidth}")
                 newnode = copy(inode)
                 newnode.matrix = copy(inode.matrix)
-                newnode.label = (
-                    f"[{anyslices}]{'' if inode.label is None else inode.display_label()}"
-                )
+                newnode.label = f"[{anyslices}]{'' if inode.label is None else inode.display_label()}"
                 # newnode.dither = False
                 # newnode.operations.clear()
                 # newnode.prevent_crop = True
@@ -364,9 +364,7 @@ def do_innerwhite(
                 anyslices += 1
                 newnode = copy(inode)
                 newnode.matrix = copy(inode.matrix)
-                newnode.label = (
-                    f"[{anyslices}]{'' if inode.label is None else inode.display_label()}"
-                )
+                newnode.label = f"[{anyslices}]{'' if inode.label is None else inode.display_label()}"
                 # newnode.dither = False
                 # newnode.operations.clear()
                 # newnode.prevent_crop = True
@@ -382,12 +380,13 @@ def do_innerwhite(
                 data_out.append(newnode)
     return data_out
 
+
 def img_to_rectangles(
-        node_image,                 # The image
-        minimal,                    # Minimum area in percent (int) to consider
-        maximal,                    # Maximum area in percent (int) to consider
-        ignoreinner,                # Ignore inner contours
-        needs_invert=True           # Does the image require inverting (we need white strcutures on a black background)
+    node_image,  # The image
+    minimal,  # Minimum area in percent (int) to consider
+    maximal,  # Maximum area in percent (int) to consider
+    ignoreinner,  # Ignore inner contours
+    needs_invert=True,  # Does the image require inverting (we need white strcutures on a black background)
 ):
     """
     Takes the image and provides a list of geomstr + associated matrix
@@ -413,7 +412,9 @@ def img_to_rectangles(
 
     # Find contours in the binary image
     try:
-        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+        contours, hierarchies = cv2.findContours(
+            th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE
+        )
     except ValueError:
         # Invalid data
         return ([], [])
@@ -442,12 +443,20 @@ def img_to_rectangles(
         # print (f"center: {center_x:.2f}, {center_y:.2f}, dimension: {rect_width:.2f}x{rect_height:.2f}, angle={angle_deg:.1f}")
         # print (box)
         geom = Geomstr()
-        geom.line(start=complex(box[0][0], box[0][1]), end=complex(box[1][0], box[1][1]))
-        geom.line(start=complex(box[1][0], box[1][1]), end=complex(box[2][0], box[2][1]))
-        geom.line(start=complex(box[2][0], box[2][1]), end=complex(box[3][0], box[3][1]))
-        geom.line(start=complex(box[3][0], box[3][1]), end=complex(box[0][0], box[0][1]))
+        geom.line(
+            start=complex(box[0][0], box[0][1]), end=complex(box[1][0], box[1][1])
+        )
+        geom.line(
+            start=complex(box[1][0], box[1][1]), end=complex(box[2][0], box[2][1])
+        )
+        geom.line(
+            start=complex(box[2][0], box[2][1]), end=complex(box[3][0], box[3][1])
+        )
+        geom.line(
+            start=complex(box[3][0], box[3][1]), end=complex(box[0][0], box[0][1])
+        )
         # Geometry plus enclosed area
-        geom_list.append( (geom, 100 * area / (width * height)) )
+        geom_list.append((geom, 100 * area / (width * height)))
 
     return geom_list
 
@@ -509,7 +518,9 @@ def plugin(kernel, lifecycle=None):
             "default": True,
             "type": bool,
             "label": _("Scale oversized images"),
-            "tip": _("Set: Will scale down large images so they will fit on the laserbed."),
+            "tip": _(
+                "Set: Will scale down large images so they will fit on the laserbed."
+            ),
             "page": "Input/Output",
             "section": "Images",
         },
@@ -717,8 +728,9 @@ def plugin(kernel, lifecycle=None):
     ):
         if threshold_min is None:
             raise CommandSyntaxError
-        threshold_min, threshold_max = min(threshold_min, threshold_max), max(
-            threshold_max, threshold_min
+        threshold_min, threshold_max = (
+            min(threshold_min, threshold_max),
+            max(threshold_max, threshold_min),
         )
         divide = (threshold_max - threshold_min) / 255.0
         for node in data:
@@ -1282,7 +1294,7 @@ def plugin(kernel, lifecycle=None):
                     _("Can't modify a locked image: {name}").format(name=str(inode))
                 )
                 continue
-            img = inode.image #opaque_image
+            img = inode.image  # opaque_image
             original_mode = inode.image.mode
             img = img.convert("RGBA")
             try:
@@ -1495,7 +1507,7 @@ def plugin(kernel, lifecycle=None):
     )
     @context.console_command(
         "linecut",
-        help=_("Cuts and image with a line"),
+        help=_("Cuts an image with a line"),
         input_type="image",
         output_type="image",
         hidden=True,
@@ -1859,7 +1871,9 @@ def plugin(kernel, lifecycle=None):
             update_image_node(inode)
         return "image", data
 
-    @context.console_option("minimal", "m", type=float, help=_("minimal area (%)"), default=2)
+    @context.console_option(
+        "minimal", "m", type=float, help=_("minimal area (%)"), default=2
+    )
     @context.console_option(
         "outer",
         "o",
@@ -1915,7 +1929,6 @@ def plugin(kernel, lifecycle=None):
         post=None,
         **kwargs,
     ):
-
         try:
             import cv2
         except ImportError:
@@ -1950,7 +1963,7 @@ def plugin(kernel, lifecycle=None):
         if len(data_out):
             # _("Image white")
             with context.elements.undoscope("Image white"):
-                needs_adding = [True]*len(data_out)
+                needs_adding = [True] * len(data_out)
                 if breakdown or whiten:
                     for inode in data:
                         if inode in data_out:
@@ -1965,8 +1978,16 @@ def plugin(kernel, lifecycle=None):
         post.append(context.elements.post_classify(data_out))
         return "image", data_out
 
-    @context.console_option("threshold", "t", type=float, help=_("Threshold for simplification"), default=0.25)
-    @context.console_option("minimal", "m", type=float, help=_("minimal area (%)"), default=2)
+    @context.console_option(
+        "threshold",
+        "t",
+        type=float,
+        help=_("Threshold for simplification"),
+        default=0.25,
+    )
+    @context.console_option(
+        "minimal", "m", type=float, help=_("minimal area (%)"), default=2
+    )
     @context.console_option(
         "inner",
         "i",
@@ -2028,7 +2049,9 @@ def plugin(kernel, lifecycle=None):
         elements = context.elements
         # from PIL import Image
         if data is None:
-            data = list(e for e in elements.flat(emphasized=True) if e.type == "elem image")
+            data = list(
+                e for e in elements.flat(emphasized=True) if e.type == "elem image"
+            )
         if data is None or len(data) == 0:
             channel(_("No images selected"))
             return
@@ -2050,7 +2073,9 @@ def plugin(kernel, lifecycle=None):
         if threshold is None:
             # We are on pixel level
             threshold = 0.25
-        channel(f"Contouring: {minimal:.2f} <= area <= {maximal:.2f}, inverting: {'No' if dontinvert else 'Yes'}, threshold: {threshold:.2f}, inner: {'No' if ignoreinner else 'Yes'}")
+        channel(
+            f"Contouring: {minimal:.2f} <= area <= {maximal:.2f}, inverting: {'No' if dontinvert else 'Yes'}, threshold: {threshold:.2f}, inner: {'No' if ignoreinner else 'Yes'}"
+        )
         data_out = list()
 
         remembered_dithers = list()
@@ -2073,13 +2098,25 @@ def plugin(kernel, lifecycle=None):
                     continue
                 # Extract polygons from the image
                 if rectangles:
-                    contours = img_to_rectangles(node_image, minimal, maximal, ignoreinner, needs_invert=not dontinvert)
+                    contours = img_to_rectangles(
+                        node_image,
+                        minimal,
+                        maximal,
+                        ignoreinner,
+                        needs_invert=not dontinvert,
+                    )
                     msg = "Bounding"
                 else:
-                    contours = img_to_polygons(node_image, minimal, maximal, ignoreinner, needs_invert=not dontinvert)
+                    contours = img_to_polygons(
+                        node_image,
+                        minimal,
+                        maximal,
+                        ignoreinner,
+                        needs_invert=not dontinvert,
+                    )
                     msg = "Contour"
                 pidx = 0
-                for (geom, c_info) in contours:
+                for geom, c_info in contours:
                     pidx += 1
                     channel(f"Processing {idx+1}.{pidx}: area={c_info:.2f}%")
                     if simplified:
@@ -2101,7 +2138,9 @@ def plugin(kernel, lifecycle=None):
                 inode.update(None)
 
         t_total_overall = time.perf_counter() - t0
-        channel(f"Done, created: {len(data_out)} contour elements >= {minimal}% (Total time: {t_total_overall:.2f} sec)")
+        channel(
+            f"Done, created: {len(data_out)} contour elements >= {minimal}% (Total time: {t_total_overall:.2f} sec)"
+        )
         post.append(context.elements.post_classify(data_out))
         return "elements", data_out
 
@@ -2119,7 +2158,11 @@ def plugin(kernel, lifecycle=None):
         **kwargs,
     ):
         if data is None:
-            data = list(e for e in context.elements.flat(emphasized=True) if e.type == "elem image")
+            data = list(
+                e
+                for e in context.elements.flat(emphasized=True)
+                if e.type == "elem image"
+            )
         if len(data) == 0:
             channel("No image provided")
             return
@@ -2141,8 +2184,8 @@ def plugin(kernel, lifecycle=None):
     @context.console_command(
         "linefill",
         help=_("Create a linefill representation of the provided images"),
-        input_type = (None, "image", "elements"),
-        output_type = "elements",
+        input_type=(None, "image", "elements"),
+        output_type="elements",
     )
     def do_linefill(
         command,
@@ -2153,6 +2196,7 @@ def plugin(kernel, lifecycle=None):
         **kwargs,
     ):
         from time import perf_counter
+
         def trace_black_areas(image):
             def dfs(x, y):
                 path = []
@@ -2165,7 +2209,14 @@ def plugin(kernel, lifecycle=None):
                         continue
                     visited[x, y] = True
                     path.append((x_prev, y_prev, x, y))
-                    stack.extend([(x, y, x + 1, y), (x, y, x - 1, y), (x, y, x, y + 1), (x, y, x, y - 1)])
+                    stack.extend(
+                        [
+                            (x, y, x + 1, y),
+                            (x, y, x - 1, y),
+                            (x, y, x, y + 1),
+                            (x, y, x, y - 1),
+                        ]
+                    )
                 return path
 
             visited = np.zeros_like(image, dtype=bool)
@@ -2181,7 +2232,11 @@ def plugin(kernel, lifecycle=None):
             return separated
 
         if data is None:
-            data = list(e for e in context.elements.flat(emphasized=True) if e.type == "elem image")
+            data = list(
+                e
+                for e in context.elements.flat(emphasized=True)
+                if e.type == "elem image"
+            )
         if len(data) == 0:
             channel("No image provided")
             return
@@ -2209,13 +2264,15 @@ def plugin(kernel, lifecycle=None):
 
             multiple = trace_black_areas(image)
             points = sum(len(path) for path in multiple)
-            channel (f"Found points: {points}, subpaths={len(multiple)}")
+            channel(f"Found points: {points}, subpaths={len(multiple)}")
             # for y in range(20):
             #     msg = f"[{y:2d}]"
             #     for x in range(20):
             #         msg =f"{msg} {image[x,y]}"
             #     print (msg)
-            matrix = Matrix(f"scale ({(bounds[2] - bounds[0]) / node_image.width}, {(bounds[3] - bounds[1]) / node_image.height})")
+            matrix = Matrix(
+                f"scale ({(bounds[2] - bounds[0]) / node_image.width}, {(bounds[3] - bounds[1]) / node_image.height})"
+            )
             matrix.post_translate(bounds[0], bounds[1])
             # matrix = node.active_matrix
 
@@ -2234,8 +2291,8 @@ def plugin(kernel, lifecycle=None):
                     stroke=Color("blue"),
                     label=label,
                     type="elem path",
-                    stroke_width = 1000,
-                    linejoin=Linejoin.JOIN_ROUND
+                    stroke_width=1000,
+                    linejoin=Linejoin.JOIN_ROUND,
                 )
                 data_out.append(rnode)
                 return idx
@@ -2254,7 +2311,9 @@ def plugin(kernel, lifecycle=None):
                         y_prev, x_prev, y, x = path[i]
                         dx = x - x_prev
                         dy = y - y_prev
-                        if (dx * dx + dy * dy) >= 4: # Thats too wide by definition, new subpath
+                        if (
+                            dx * dx + dy * dy
+                        ) >= 4:  # Thats too wide by definition, new subpath
                             idx = save_geom(geom, idx, matrix)
                             geom = Geomstr()
                             continue
@@ -2268,6 +2327,7 @@ def plugin(kernel, lifecycle=None):
         post.append(context.elements.post_classify(data_out))
         return "elements", data_out
 
+
 class RasterImagePreprocessor:
     def __init__(self, kernel):
         self.test = False
@@ -2275,7 +2335,10 @@ class RasterImagePreprocessor:
         _ = self.kernel.translation
         RASTER_METHOD_OFFSET = 100
         self.methods = {
-            RASTER_METHOD_OFFSET + 0: (_("Split image along white areas"), self.process_innerwhite),
+            RASTER_METHOD_OFFSET + 0: (
+                _("Split image along white areas"),
+                self.process_innerwhite,
+            ),
         }
         self.register_methods()
 
@@ -2311,11 +2374,12 @@ class RasterImagePreprocessor:
         operation.bidirectional = True
         # print (f"Innerwhite exit: {len(operation.children)} children of {operation.type}")
 
-
     def register_methods(self):
         # Split image along white areas
         for method, (description, routine) in self.methods.items():
-            self.kernel.register(f"raster_preprocessor/Method_{method}", (method, description, routine))
+            self.kernel.register(
+                f"raster_preprocessor/Method_{method}", (method, description, routine)
+            )
 
 
 class RasterScripts:

meerk40t/internal_plugins.py

@@ -76,6 +76,10 @@ def plugin(kernel, lifecycle):
 
         plugins.append(potrace.plugin)
 
+        from .extra import vtracer
+
+        plugins.append(vtracer.plugin)
+
         from .extra import inkscape
 
         plugins.append(inkscape.plugin)

meerk40t/kernel/kernel.py

@@ -181,6 +181,7 @@ class Kernel(Settings):
         self.args = None
 
         self.os_information = self._get_environment()
+        self.show_aio_prompt = True
 
     def __str__(self):
         return f"Kernel({self.name}, {self.profile}, {self.version})"
@@ -188,8 +189,9 @@ class Kernel(Settings):
     def _get_environment(self):
         from platform import system
         from tempfile import gettempdir
+
         return {
-            "OS_NAME":  system(),
+            "OS_NAME": system(),
             "OS_TEMPDIR": os.path.realpath(gettempdir()),
             "WORKDIR": os.path.realpath(get_safe_path(self.name, create=True)),
         }
@@ -254,15 +256,21 @@ class Kernel(Settings):
                 kwargs_repr = [f"{k}={v}" for k, v in kwargs.items()]
                 signature = ", ".join(args_repr + kwargs_repr)
                 start = f"Calling {str(obj)}.{func.__name__}({signature})"
-                debug_file.write(start + "\n")
+                try:
+                    debug_file.write(start + "\n")
+                except (ValueError, OSError):
+                    pass
                 print(start)
                 t = time.time()
                 value = func(*args, **kwargs)
                 t = time.time() - t
                 finish = f"    {func.__name__} returned {value} after {t * 1000}ms"
                 print(finish)
-                debug_file.write(finish + "\n")
-                debug_file.flush()
+                try:
+                    debug_file.write(finish + "\n")
+                    debug_file.flush()
+                except (ValueError, OSError):
+                    pass
                 return value
 
             return wrapper_debug
@@ -1232,11 +1240,12 @@ class Kernel(Settings):
 
             async def aio_readline(loop):
                 while not self._shutdown:
-                    print(">>", end="", flush=True)
+                    if self.show_aio_prompt:
+                        print(">>", end="", flush=True)
 
                     line = await loop.run_in_executor(None, sys.stdin.readline)
                     line = line.strip()
-                    if line in ("quit", "shutdown", "restart"):
+                    if line in ("quit", "shutdown", "exit", "restart"):
                         self._quit = True
                         if line == "restart":
                             self._restart = True
@@ -2290,7 +2299,7 @@ class Kernel(Settings):
         it will execute that in the console_parser. This works like a
         terminal, where each letter of data can be sent to the console and
         execution will occur at the carriage return.
-        Additionally you can provide a '|' character that will separate commands on a single line 
+        Additionally you can provide a '|' character that will separate commands on a single line
         @param data:
         @return:
         """
@@ -2309,7 +2318,7 @@ class Kernel(Settings):
             # No: we can split the command
             quotations = data.count('"', 0, idx)
             if quotations % 2 == 0:
-                data = data[:idx].rstrip() + "\n" + data[idx+1:].lstrip()
+                data = data[:idx].rstrip() + "\n" + data[idx + 1 :].lstrip()
             start = idx + 1
         self._console_buffer += data
         data_out = None
@@ -2323,6 +2332,17 @@ class Kernel(Settings):
     def _console_interface(self, command: str):
         pass
 
+    def has_command(self, command: str) -> bool:
+        command = command.lower()
+        input_type = None  # Initial command context is None
+        # Process command matches.
+        for funct, name, regex in self.find("command", str(input_type), ".*"):
+            # Find all commands with matching input_type.
+            if not funct.regex and regex == command:
+                # Exact match only.
+                return True
+        return False
+
     def _console_parse(self, text: str, channel: "Channel"):
         """
         Takes single line console commands and executes them.
@@ -2515,9 +2535,7 @@ class Kernel(Settings):
                     if not helpstr:
                         helpstr = func.help
                     if helpstr:
-                        channel(
-                            "\t" + inspect.cleandoc(helpstr).replace("\n", " ")
-                        )
+                        channel("\t" + inspect.cleandoc(helpstr).replace("\n", " "))
                         channel("\n")
 
                     channel(f"\t{command_item} {' '.join(help_args)}")
@@ -2856,39 +2874,42 @@ class Kernel(Settings):
                 "Linux": "/usr/share/sounds/freedesktop/stereo/phone-incoming-call.oga",
             }
 
-            sys_snd = self.root.setting(str, "beep_soundfile", system_sound.get(OS_NAME, ""))
+            sys_snd = self.root.setting(
+                str, "beep_soundfile", system_sound.get(OS_NAME, "")
+            )
             use_default = not sys_snd or not os.path.exists(sys_snd)
 
             def _play_windows():
                 try:
                     import winsound
+
                     if use_default:
                         for x in range(5):
                             winsound.Beep(2000, 100)
                     else:
                         winsound.PlaySound(sys_snd, winsound.SND_FILENAME)
                 except Exception as e:
-                    channel ("Encountered exception {e} during play")
+                    channel("Encountered exception {e} during play")
                     pass
 
             def _play_darwin():
-                arg = system_sound['Darwin'] if use_default else sys_snd
-                cmd = ['afplay', arg]
+                arg = system_sound["Darwin"] if use_default else sys_snd
+                cmd = ["afplay", arg]
                 try:
                     subprocess.run(cmd, shell=False)
                 except OSError as e:
-                    channel (f"Could not run {cmd[0]}: {e}")
+                    channel(f"Could not run {cmd[0]}: {e}")
 
             def _play_linux():
                 try:
                     if not use_default:
-                        cmd = ['play', sys_snd]
+                        cmd = ["play", sys_snd]
                     else:
                         print("\a")
-                        cmd = ['say', 'Ding']
+                        cmd = ["say", "Ding"]
                     subprocess.run(cmd, shell=False)
                 except OSError as e:
-                    channel (f"Could not run {cmd[0]}: {e}")
+                    channel(f"Could not run {cmd[0]}: {e}")
 
             players = {
                 "Windows": _play_windows,
@@ -3180,7 +3201,9 @@ class Kernel(Settings):
         # ==========
         @self.console_command(
             "execute",
-            help=_("Loads a given file and executes all lines as commmands (as long as they don't start with a #)"),
+            help=_(
+                "Loads a given file and executes all lines as commmands (as long as they don't start with a #)"
+            ),
         )
         def load_and_execute(channel, _, remainder=None, **kwargs):
             if not remainder:
@@ -3346,13 +3369,17 @@ class Kernel(Settings):
                 channel(_("Infinite Loop Error."))
             else:
                 if not force and channel_name not in self.channels:
-                    channel(f"There is no channel named '{channel_name}', please use one of the existing channels or use the '-f' parameter to create one from scratch.")
+                    channel(
+                        f"There is no channel named '{channel_name}', please use one of the existing channels or use the '-f' parameter to create one from scratch."
+                    )
                     channel(_("----------"))
                     channel(_("Channels Active:"))
                     for i, name in enumerate(self.channels):
                         channel_name = self.channels[name]
                         is_watched = (
-                            "* " if self._console_channel in channel_name.watchers else "  "
+                            "* "
+                            if self._console_channel in channel_name.watchers
+                            else "  "
                         )
                         channel(f"{is_watched}{i + 1}: {name}")
                     return "channel", None