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

meerk40t/extra/param_functions.py

@@ -435,7 +435,7 @@ def plugin(kernel, lifecycle):
         @self.console_argument("inversions", nargs="*", type=int)
         @context.console_command(
             "ffractal",
-            help=_("ffractal iterations"),
+            help=_("fractal iterations"),
             output_type="geometry",
             hidden=True,
         )

meerk40t/extra/potrace.py

@@ -48,21 +48,25 @@ potracer:   https://github.com/tatarize/potrace
 
 def plugin(kernel, lifecycle=None):
     if lifecycle == "invalidate":
+        invalid = False
+        return invalid
+
+    if lifecycle == "register":
+        _ = kernel.translation
+        import numpy
+        valid = False
         try:
-            import numpy
             import potrace
-            if not hasattr(potrace, "Bitmap"):
+            if hasattr(potrace, "Bitmap"):
+                valid = True
+            else:
                 # This is a strange variant, that we do not support!
                 print ("The version of potrace that is installed on your machine is incompatible. Please report this to the developers.")
-                return True
         except ImportError:
-            # print("Potrace plugin could not load because potracer/pypotrace is not installed.")
-            return True
-
-    if lifecycle == "register":
-        _ = kernel.translation
-        import numpy
-        import potrace
+            valid = False
+        
+        if not valid:
+            from . import mk_potrace as potrace
 
         def make_vector(
             image,

meerk40t/extra/vtracer.py

@@ -0,0 +1,222 @@
+"""
+Vtracer https://github.com/visioncortex/vtracer
+visioncortex VTracer is an open source software to convert raster images (like jpg & png)
+into vector graphics (svg). It can vectorize graphics and photographs and trace the curves
+to output compact vector files.
+Comparing to [Potrace](http://potrace.sourceforge.net/) which only accept binarized
+inputs (Black & White pixmap), VTracer has an image processing pipeline which
+can handle colored high resolution scans.
+Comparing to Adobe Illustrator's [Image Trace](https://helpx.adobe.com/illustrator/using/image-trace.html),
+VTracer's output is much more compact (less shapes) as we adopt a stacking strategy
+and avoid producing shapes with holes.
+A technical description of the algorithm is on [visioncortex.org/vtracer-docs](//www.visioncortex.org/vtracer-docs).
+To use it we need to have the python interface in place: pip install vtracer
+"""
+
+"""
+Not needed left here for reference purposes
+
+def simplified_load(source : str, bbox : tuple) -> list:
+    from meerk40t.tools.geomstr import Geomstr
+    from meerk40t.svgelements import Matrix, Color
+    from meerk40t.core.node.elem_path import PathNode
+    from time import perf_counter
+    t0 = perf_counter()
+    time_geom = 0
+    time_trans = 0
+    time_read = 0
+    time_bbox = 0
+    result_list = []
+    p_pattern = '<path d="'
+    t_pattern = 'transform="'
+    f_pattern = 'fill="'
+    black = Color("black")
+    content = []
+    min_x = float("inf")
+    min_y = float("inf")
+    max_x = -float("inf")
+    max_y = -float("inf")
+    with open(source, "r") as svg_file:
+        tt = perf_counter()
+        all_lines = svg_file.readlines()
+        time_read = perf_counter() - tt
+        for line in all_lines:
+            idx_start = line.find(p_pattern, 0)
+            if idx_start < 0:
+                continue
+            idx_end = line.find('"', idx_start + len(p_pattern))
+            d_str = line[idx_start + len(p_pattern):idx_end]
+            # print (d_str)
+            tt = perf_counter()
+            geom = Geomstr.svg(d_str)
+            time_geom += perf_counter() - tt
+            if geom.index == 0:
+                # print (f"Strange, empty from '{d_str}' ({line})")
+                continue
+            fill_value = None
+            mat_start = line.find(t_pattern, idx_end)
+            if mat_start >= 0:
+                tt = perf_counter()
+                mat_end = line.find('"', mat_start + len(t_pattern))
+                mat_str = line[mat_start + len(t_pattern):mat_end]
+                matrix = Matrix(mat_str)
+                geom.transform(matrix)
+                time_trans += perf_counter() - tt
+            fill_start = line.find(f_pattern, idx_end)
+            if fill_start >= 0:
+                fill_end = line.find('"', fill_start + len(f_pattern))
+                fill_str = line[fill_start + len(f_pattern):fill_end]
+                # if fill_str == "#ffffff":
+                #     continue
+
+            else:
+                fill_str = ""
+            content.append((geom, fill_str))
+            tt = perf_counter()
+            g_bb = geom.bbox()
+            min_x = min(min_x, g_bb[0])
+            min_y = min(min_y, g_bb[1])
+            max_x = max(max_x, g_bb[2])
+            max_y = max(max_y, g_bb[3])
+            time_bbox += perf_counter() - tt
+    t1 = perf_counter()
+    if content:
+        sx = (bbox[2] - bbox[0]) / (max_x - min_x)
+        sy = (bbox[3] - bbox[1]) / (max_y - min_y)
+        tx = bbox[0] - min_x
+        ty = bbox[1] - min_y
+        components = (sx, 0, 0, sy, tx, ty)
+        matrix = Matrix(components)
+    else:
+        matrix = None
+    for geom, fill_str in content:
+        if matrix:
+            tt = perf_counter()
+            geom.transform(matrix)
+            time_trans += perf_counter() - tt
+        node = PathNode(geometry = geom, stroke=black, stroke_width = 500)
+        if fill_str:
+            fill_value = Color(fill_str)
+            node.fill = fill_value
+        result_list.append(node)
+    t2 = perf_counter()
+    # print (f"Loading and geometry creation: {t1-t0:.2f}sec, node creation: {t2-t1:.2f} sec, total: {t2-t0:.2f}sec")
+    # print (f"Pure creation: {time_geom:.2f}sec, transform {time_trans:.2f}sec, reading {time_read:.2f}sec, bbox: {time_bbox:.2f}sec")
+    return result_list
+"""
+
+
+def plugin(kernel, lifecycle=None):
+    if lifecycle == "invalidate":
+        try:
+            import vtracer
+        except ImportError:
+            # print("vtracer plugin could not load because vtracer is not installed.")
+            return True
+
+    if lifecycle == "register":
+        _ = kernel.translation
+
+        @kernel.console_command(
+            "vtracer",
+            help=_("return paths around image"),
+            input_type=("image", "elements", None),
+            output_type="elements",
+        )
+        def do_vtracer(
+            channel,
+            data=None,
+            **kwargs,
+        ):
+            try:
+                import os
+                from time import perf_counter
+
+                from vtracer import convert_image_to_svg_py
+
+                from meerk40t.core.units import Length
+                from meerk40t.kernel import get_safe_path
+            except ImportError:
+                channel("vtracer isn't installed, use 'pip install vtracer'")
+                return None
+            elements = kernel.root.elements
+            if data is None:
+                data = list(elements.elems(emphasized=True))
+            if not data:
+                channel(_("Nothing selected"))
+                return
+            images = [node for node in data if hasattr(node, "image")]
+            if not images:
+                channel(_("No images selected"))
+                return
+
+            safe_dir = os.path.realpath(get_safe_path(kernel.name))
+            input_file = os.path.join(safe_dir, "_vtrace_input.png")
+            output_file = os.path.join(safe_dir, "_vtrace_output.svg")
+            t_start = perf_counter()
+            t_convert = t_load = 0
+            # _("Vectorizing image")
+            with elements.undoscope("Vectorizing image"):
+                for node in images:
+                    # kernel.root.signal("freeze_tree", True)
+                    _start = perf_counter()
+                    bb = node.bounds
+                    im_wd = bb[2] - bb[0]
+                    im_ht = bb[3] - bb[1]
+                    im_x = bb[0]
+                    im_y = bb[1]
+                    flag = node.prevent_crop
+                    if not flag:
+                        node.prevent_crop = True
+                        node.update(None)
+                        bb2 = node.bounds
+                        dx = bb2[0] - bb[0]
+                        dy = bb2[1] - bb[1]
+                        bb = (bb[0] - dx, bb[1] - dy, bb[2] - dx, bb[3] - dy)
+                        node.prevent_crop = flag
+                        node.update(None)
+                    image = node.image
+
+                    image.save(input_file)
+                    convert_image_to_svg_py(
+                        image_path=input_file, out_path=output_file, colormode="binary"
+                    )
+                    t_convert += perf_counter() - _start
+
+                    _start = perf_counter()
+                    # print (f"Vectorization took {t1-t0:.1f}sec, now loading file, executing {cmd}")
+                    elements.suppress_updates = True
+                    cmd = (
+                        f'xload "{output_file}"'
+                        + f" {Length(im_x).length_mm}"
+                        + f" {Length(im_y).length_mm}"
+                        f" {Length(im_wd).length_mm}" + f" {Length(im_ht).length_mm}"
+                    )
+                    kernel.root(f"{cmd}\n")
+                    # elements.suppress_updates = True
+                    # nodes = simplified_load(output_file, bb)
+                    # elem = kernel.elements.elem_branch.add(type="group", label=f"VTrace ({node.display_label()})")
+                    # for e in nodes:
+                    #     elem.add_node(e)
+                    # elements.suppress_updates = False
+                    t_load += perf_counter() - _start
+                    try:
+                        os.remove(input_file)
+                        os.remove(output_file)
+                    except (PermissionError, OSError):
+                        pass
+                    except Exception as e:
+                        channel(f"Could not remove temporary files: {e}")
+                    # kernel.root.signal("freeze_tree", False)
+            t_end = perf_counter()
+            channel(
+                _(
+                    "Time needed for vectorisation: {time_total}sec (analysis: {time_convert}sec, loading: {time_load}sec)"
+                ).format(
+                    time_total=round(t_end - t_start, 1),
+                    time_convert=round(t_convert, 1),
+                    time_load=round(t_load, 1),
+                )
+            )
+            kernel.root.signal("refresh_scene", "Scene")
+            return "elements", None

meerk40t/grbl/device.py

@@ -7,6 +7,7 @@ Registers relevant commands and options.
 
 from time import sleep
 
+from meerk40t.device.devicechoices import get_effect_choices
 from meerk40t.kernel import CommandSyntaxError, Service, signal_listener
 
 from ..core.laserjob import LaserJob
@@ -16,7 +17,6 @@ from ..core.view import View
 from ..device.mixins import Status
 from .controller import GrblController
 from .driver import GRBLDriver
-from meerk40t.device.devicechoices import get_effect_choices
 
 
 class GRBLDevice(Service, Status):
@@ -181,6 +181,30 @@ class GRBLDevice(Service, Status):
                 "tip": _("Override native home location"),
                 "subsection": "_60_Home position",
             },
+            {
+                "attr": "supports_z_axis",
+                "object": self,
+                "default": False,
+                "type": bool,
+                "label": _("Supports Z-axis"),
+                "tip": _("Does this device have a Z-axis?"),
+                "subsection": "_70_Z-Axis support",
+            },
+            {
+                "attr": "z_home_command",
+                "object": self,
+                "default": "$HZ",
+                "type": str,
+                "style": "combosmall",
+                "choices": [
+                    "$HZ",
+                    "G28 Z",
+                ],
+                "exclusive": False,
+                "label": _("Z-Homing"),
+                "tip": _("Which command triggers the z-homing sequence"),
+                "subsection": "_70_Z-Axis support",
+            },
             {
                 "attr": "signal_updates",
                 "object": self,
@@ -258,6 +282,7 @@ class GRBLDevice(Service, Status):
                 choice_dict["display"] = ["pyserial-not-installed"]
 
         from platform import system
+
         is_linux = system() == "Linux"
         choices = [
             {
@@ -271,7 +296,7 @@ class GRBLDevice(Service, Status):
                 "section": "_10_Serial Interface",
                 "subsection": "_00_",
                 "dynamic": update,
-                "exclusive": not is_linux, 
+                "exclusive": not is_linux,
             },
             {
                 "attr": "baud_rate",
@@ -635,6 +660,56 @@ class GRBLDevice(Service, Status):
         if self.permit_serial:
             self._register_console_serial()
 
+        @self.console_command(
+            "z_home",
+            help=_("Homes the z-Axis"),
+            input_type=None,
+        )
+        def command_zhome(command, channel, _, data=None, remainder=None, **kwgs):
+            if not self.supports_z_axis:
+                channel(_("This device does not support a z-axis."))
+                return
+            zhome = self.z_home_command
+            if not zhome:
+                channel(_("There is no homing sequence defined."))
+                return
+            channel(_("Z-Homing..."))
+            self.driver(zhome + self.driver.line_end)
+
+        @self.console_argument("step", type=Length, help=_("Amount to move the z-axis"))
+        @self.console_command(
+            "z_move",
+            help=_("Moves the z-Axis by the given amount"),
+            input_type=None,
+        )
+        def command_zmove_rel(command, channel, _, data=None, step=None, **kwgs):
+            if not self.supports_z_axis:
+                channel(_("This device does not support a z-axis."))
+                return
+            if step is None:
+                channel(_("No z-movement defined"))
+                return
+            # relative movement in mm
+            gcode = f"G91 G21 Z{step.mm:.3f}"
+            self.driver(gcode + self.driver.line_end)
+
+        @self.console_argument("step", type=Length, help=_("New z-axis position"))
+        @self.console_command(
+            "z_move_to",
+            help=_("Moves the z-Axis to the given position"),
+            input_type=None,
+        )
+        def command_zmove_abs(command, channel, _, data=None, step=None, **kwgs):
+            if not self.supports_z_axis:
+                channel(_("This device does not support a z-axis."))
+                return
+            if step is None:
+                channel(_("No z-movement defined"))
+                return
+            # absolute movement in mm
+            gcode = f"G91 G20 Z{step.mm:.3f}"
+            self.driver(gcode + self.driver.line_end)
+
         @self.console_command(
             ("gcode", "grbl"),
             help=_("Send raw gcode to the device"),
@@ -901,9 +976,7 @@ class GRBLDevice(Service, Status):
                 channel(_("Interpreter cannot be attached to any device."))
             return
 
-        @self.console_argument(
-            "index", type=int, help=_("macro to run (1-5).")
-        )
+        @self.console_argument("index", type=int, help=_("macro to run (1-5)."))
         @self.console_command(
             "macro",
             help=_("Send a predefined macro to the device."),
@@ -916,11 +989,11 @@ class GRBLDevice(Service, Status):
                     macrotext = self.setting(str, f"macro_{idx}", "")
                     channel(f"Content of macro {idx + 1}:")
                     for no, line in enumerate(macrotext.splitlines()):
-                        channel (f"{no:2d}: {line}")
+                        channel(f"{no:2d}: {line}")
                 return
             err = True
             try:
-                macro_index = int(index) -1
+                macro_index = int(index) - 1
                 if 0 <= macro_index <= 4:
                     err = False
             except ValueError:
@@ -1081,4 +1154,4 @@ class GRBLDevice(Service, Status):
     def get_raster_instructions(self):
         return {
             "gantry": True,
-        }
+        }

meerk40t/grbl/interpreter.py

@@ -12,7 +12,7 @@ from meerk40t.kernel import Module
 class GRBLInterpreter(Module):
     def __init__(self, service, path):
         Module.__init__(self, service, path)
-        self.emulator = GRBLEmulator(self, service.space.display.matrix())
+        self.emulator = GRBLEmulator(self, service.space.display.matrix)
         self._attached_device = None
 
     def __repr__(self):

meerk40t/gui/about.py

@@ -1770,6 +1770,8 @@ class ComponentPanel(ScrolledPanel):
 
         def get_potrace():
             entry = ["potracer", "", "", "https://pypi.org/project/potracer/"]
+            status = _("Present (slow)")
+            info = "0.05 (internal)"
             try:
                 import potrace
 
@@ -1780,11 +1782,26 @@ class ComponentPanel(ScrolledPanel):
                     entry[0] = "pypotrace"
                     entry[3] = "https://pypi.org/project/pypotrace/"
                     info = potrace.potracelib_version()
-                else:
-                    status = _("Present (slow)")
-                    info = "??"
                 if not hasattr(potrace, "Bitmap"):
                     status = _("Faulty, please report")
+            except ImportError:
+                pass
+            entry[1] = info
+            entry[2] = status
+            self.content.append(entry)
+
+        def get_vtrace():
+            entry = ["vtracer", "", "", "https://pypi.org/project/vtracer/"]
+            try:
+                import vtracer
+
+                # for e in vars(vtracer):
+                #     print (f"var {e} - {getattr(vtracer, e)}")
+                try:
+                    info = vtracer.__version__
+                except AttributeError:
+                    info = "??"
+                status = _("Present")
             except ImportError:
                 info = "??"
                 status = _("Missing")
@@ -1961,6 +1978,7 @@ class ComponentPanel(ScrolledPanel):
         get_numpy()
         get_pillow()
         get_potrace()
+        get_vtrace()
         get_ezdxf()
         get_pyusb()
         get_pyserial()

meerk40t/gui/basicops.py

@@ -459,21 +459,21 @@ class BasicOpPanel(wx.Panel):
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Active"))
+        header.SetToolTip(_("A: Active = toggle whether the elements assigned to this operation will be burned or not"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         header = wxStaticText(self.op_panel, wx.ID_ANY, label="S")
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Show"))
+        header.SetToolTip(_("S: Show = if inactive then you can suppress the drawing of the assigned elements"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         header = wxStaticText(self.op_panel, wx.ID_ANY, label="C")
         self.context.themes.set_window_colors(header)
         header.SetMinSize(dip_size(self, 20, -1))
         header.SetMaxSize(dip_size(self, 20, -1))
-        header.SetToolTip(_("Coolant"))
+        header.SetToolTip(_("C: Coolant = determines whether coolant remains / will be turned on / turned off at start of this operation"))
         info_sizer.Add(header, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
         unit = " [%]" if self.use_percent else ""

meerk40t/gui/choicepropertypanel.py

@@ -1117,10 +1117,7 @@ class ChoicePropertyPanel(ScrolledPanel):
                     control.SetValue(bool((data >> b) & 1))
                     if mask:
                         control.Enable(bool((mask_bits >> b) & 1))
-                    control.Bind(
-                        wx.EVT_CHECKBOX,
-                        on_checkbox_check(attr, control, obj, b, additional_signal),
-                    )
+                    control.Bind(wx.EVT_CHECKBOX, on_checkbox_bitcheck(attr, control, obj, b, additional_signal), )
 
                     # mask bit
                     if mask:

meerk40t/gui/devicepanel.py

@@ -5,12 +5,12 @@ from meerk40t.gui.icons import icons8_manager
 from meerk40t.gui.mwindow import MWindow
 from meerk40t.gui.wxutils import (
     StaticBoxSizer,
+    TextCtrl,
     dip_size,
     wxButton,
     wxListCtrl,
     wxStaticText,
     wxTreeCtrl,
-    TextCtrl,
 )
 from meerk40t.kernel import lookup_listener, signal_listener
 
@@ -71,15 +71,15 @@ class SelectDevice(wx.Dialog):
         )
         # Used for proper sorting in the device add menu.
         self.sort_family_name = {
-        _("K-Series CO2-Laser"): 99,
-        _("Ortur Diode-Laser"): 98,
-        _("Longer Diode-Laser"): 97,
-        _("Newly CO2-Laser"): 96,
-        _("Generic UV-Laser"): 95,
-        _("Generic CO2-Laser"): 94,
-        _("Generic Fibre-Laser"): 93,
-        _("Generic Diode-Laser"): 92,
-        _("Generic"): 91,
+            _("K-Series CO2-Laser"): 99,
+            _("Ortur Diode-Laser"): 98,
+            _("Longer Diode-Laser"): 97,
+            _("Newly CO2-Laser"): 96,
+            _("Generic UV-Laser"): 95,
+            _("Generic CO2-Laser"): 94,
+            _("Generic Fibre-Laser"): 93,
+            _("Generic Diode-Laser"): 92,
+            _("Generic"): 91,
         }
         sizer_main.Add(self.tree_devices, 3, wx.EXPAND, 0)
         self.no_msg = (
@@ -125,7 +125,6 @@ class SelectDevice(wx.Dialog):
         self.Layout()
         self.populate_tree()
 
-
     def populate_tree(self):
         tree = self.tree_devices
         tree.DeleteAllItems()
@@ -223,18 +222,20 @@ class DevicePanel(wx.Panel):
             | wx.LC_SINGLE_SEL
             | wx.LC_SORT_ASCENDING,
             context=self.context,
-            list_name="list_devices"
+            list_name="list_devices",
         )
         self.list_columns = {
             "device": 0,
             "driver": 1,
             "family": 2,
             "status": 3,
+            "location": 4,
         }
         self.devices_list.InsertColumn(self.list_columns["device"], _("Device"))
         self.devices_list.InsertColumn(self.list_columns["driver"], _("Driver"))
         self.devices_list.InsertColumn(self.list_columns["family"], _("Type"))
         self.devices_list.InsertColumn(self.list_columns["status"], _("Status"))
+        self.devices_list.InsertColumn(self.list_columns["location"], _("Interface"))
         self.devices_list.resize_columns()
         sizer_1.Add(self.devices_list, 7, wx.EXPAND, 0)
 
@@ -287,9 +288,7 @@ class DevicePanel(wx.Panel):
         self.Bind(
             wx.EVT_BUTTON, self.on_button_create_device, self.button_create_device
         )
-        self.Bind(
-            wx.EVT_BUTTON, self.on_button_copy_device, self.button_copy_device
-        )
+        self.Bind(wx.EVT_BUTTON, self.on_button_copy_device, self.button_copy_device)
         self.Bind(
             wx.EVT_BUTTON, self.on_button_remove_device, self.button_remove_device
         )
@@ -317,7 +316,6 @@ class DevicePanel(wx.Panel):
     def pane_hide(self, *args):
         pass
 
-
     def on_start_edit(self, event):
         event.Allow()
 
@@ -410,11 +408,17 @@ class DevicePanel(wx.Panel):
             except AttributeError:
                 pass
 
+            try:
+                loc_info = device.location()
+            except AttributeError:
+                loc_info = "undefined"
+
             self.devices_list.SetItem(index, self.list_columns["driver"], type_info)
             self.devices_list.SetItem(index, self.list_columns["family"], family_info)
             self.devices_list.SetItem(
                 index, self.list_columns["status"], _(active_status)
             )
+            self.devices_list.SetItem(index, self.list_columns["location"], loc_info)
             self.devices_list.SetItemData(index, dev_index)
             if self.context.device is device:
                 self.devices_list.SetItemTextColour(index, wx.RED)

meerk40t/gui/gui_mixins.py

@@ -63,6 +63,8 @@ class FormatPainter:
             ("linecap", True),
             ("linejoin", True),
             ("fillrule", True),
+            ("stroke_dash", True),
+            ("mktablength", False),
             # Image attributes
             ("dpi", False),
             ("operations", False),
@@ -193,6 +195,8 @@ class FormatPainter:
                         flag_changed = True
 
                     if flag_changed:
+                        if hasattr(node, "empty_cache"):
+                            node.empty_cache()
                         nodes_changed.append(node)
                         if node.type == "elem image":
                             nodes_images.append(node)
@@ -584,7 +588,10 @@ class Warnings:
                             image_node = node.node if hasattr(node, "node") else node
                             if getattr(image_node, "hidden", False):
                                 continue
-                            opdpi = op.dpi if useop else image_node.dpi
+                            if hasattr(image_node, "dpi"):
+                                opdpi = op.dpi if useop else image_node.dpi
+                            else:
+                                opdpi = op.dpi
                             step_x, step_y = self.context.device.view.dpi_to_steps(opdpi)
                             step_x *= self.context.device.view.native_scale_x
                             step_y *= self.context.device.view.native_scale_y