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

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/gui/about.py

@@ -1790,6 +1790,25 @@ class ComponentPanel(ScrolledPanel):
             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")
+            entry[1] = info
+            entry[2] = status
+            self.content.append(entry)
+
         def get_ezdxf():
             entry = ["ezdxf", "", "", "https://ezdxf.readthedocs.io/en/stable/"]
             try:
@@ -1959,6 +1978,7 @@ class ComponentPanel(ScrolledPanel):
         get_numpy()
         get_pillow()
         get_potrace()
+        get_vtrace()
         get_ezdxf()
         get_pyusb()
         get_pyserial()

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)