meerk40t 0.9.7040__tar.gz → 0.9.7050__tar.gz

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerk40t
-Version: 0.9.7040
+Version: 0.9.7050
 Summary: MeerK40t LaserCutter Software
 Home-page: https://github.com/meerk40t/meerk40t
 Author: Tatarize

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/balormk/controller.py

@@ -1003,7 +1003,11 @@ class GalvoController:
     def get_scale_from_correction_file(filename):
         with open(filename, "rb") as f:
             label = f.read(0x16)
-            if label.decode("utf-16") == "LMC1COR_1.0":
+            try:
+                decoded_label = label.decode("utf-16")
+            except UnicodeDecodeError:
+                decoded_label = label.decode("utf-8", errors="ignore")
+            if decoded_label == "LMC1COR_1.0":
                 unk = f.read(2)
                 return struct.unpack("63d", f.read(0x1F8))[43]
             else:
@@ -1049,7 +1053,11 @@ class GalvoController:
         """
         with open(filename, "rb") as f:
             label = f.read(0x16)
-            if label.decode("utf-16") == "LMC1COR_1.0":
+            try:
+                decoded_label = label.decode("utf-16")
+            except UnicodeDecodeError:
+                decoded_label = label.decode("utf-8", errors="ignore")
+            if decoded_label == "LMC1COR_1.0":
                 header = f.read(0x1FA)
                 return self._read_float_correction_file(f)
             else:

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/core/cutplan.py

@@ -24,7 +24,7 @@ from typing import Optional
 import numpy as np
 
 from ..svgelements import Group, Matrix, Path, Polygon
-from ..tools.geomstr import Geomstr, stitch_geometries
+from ..tools.geomstr import Geomstr, stitch_geometries, stitcheable_nodes
 from ..tools.pathtools import VectorMontonizer
 from .cutcode.cutcode import CutCode
 from .cutcode.cutgroup import CutGroup
@@ -265,41 +265,6 @@ class CutPlan:
                         stitch_tolerance = 0
                     default_stroke = None
                     default_strokewidth = None
-
-                    def stitcheable_nodes(data, tolerance) -> list:
-                        out = []
-                        geoms = []
-                        # Store all geometries together with an indicator, to which node they belong
-                        for idx, node in enumerate(data):
-                            if not hasattr(node, "as_geometry"):
-                                continue
-                            for g1 in node.as_geometry().as_contiguous():
-                                geoms.append((idx, g1))
-                        for idx1, (nodeidx1, g1) in enumerate(geoms):
-                            for idx2 in range(idx1 + 1, len(geoms)):
-                                nodeidx2 = geoms[idx2][0]
-                                g2 = geoms[idx2][1]
-                                fp1 = g1.first_point
-                                fp2 = g2.first_point
-                                lp1 = g1.last_point
-                                lp2 = g2.last_point
-                                if fp1 is None or fp2 is None:
-                                    continue
-                                if lp1 is None or lp2 is None:
-                                    continue
-                                if (
-                                    abs(lp1 - lp2) <= tolerance
-                                    or abs(lp1 - fp2) <= tolerance
-                                    or abs(fp1 - fp2) <= tolerance
-                                    or abs(fp1 - lp2) <= tolerance
-                                ):
-                                    if nodeidx1 not in out:
-                                        out.append(nodeidx1)
-                                    if nodeidx2 not in out:
-                                        out.append(nodeidx2)
-
-                        return [data[idx] for idx in out]
-
                     geoms = []
                     to_be_deleted = []
                     data = stitcheable_nodes(list(op.flat()), stitch_tolerance)

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/core/elements/shapes.py

@@ -66,7 +66,7 @@ from meerk40t.svgelements import (
     Polygon,
     Polyline,
 )
-from meerk40t.tools.geomstr import Geomstr, stitch_geometries
+from meerk40t.tools.geomstr import Geomstr, stitch_geometries, stitcheable_nodes
 
 
 def plugin(kernel, lifecycle=None):
@@ -2778,38 +2778,6 @@ def init_commands(kernel):
                     return data, tolerance, keep, False
             return data, tolerance_val, keep, True
 
-        def stitcheable_nodes(data, tolerance) -> list:
-            out = []
-            geoms = []
-            # Store all geometries together with an indicator, to which node they belong
-            for idx, node in enumerate(data):
-                if not hasattr(node, "as_geometry"):
-                    continue
-                for g1 in node.as_geometry().as_contiguous():
-                    geoms.append((idx, g1))
-            if tolerance == 0:
-                tolerance = 1e-6
-            for idx1, (nodeidx1, g1) in enumerate(geoms):
-                for idx2 in range(idx1 + 1, len(geoms)):
-                    nodeidx2 = geoms[idx2][0]
-                    g2 = geoms[idx2][1]
-                    fp1 = g1.first_point
-                    fp2 = g2.first_point
-                    lp1 = g1.last_point
-                    lp2 = g2.last_point
-                    if (
-                        abs(lp1 - lp2) <= tolerance
-                        or abs(lp1 - fp2) <= tolerance
-                        or abs(fp1 - fp2) <= tolerance
-                        or abs(fp1 - lp2) <= tolerance
-                    ):
-                        if nodeidx1 not in out:
-                            out.append(nodeidx1)
-                        if nodeidx2 not in out:
-                            out.append(nodeidx2)
-
-            return [data[idx] for idx in out]
-
         data, tolerance, keep, valid = _prepare_stitching_params(
             channel, data, tolerance, keep
         )
@@ -2829,13 +2797,12 @@ def init_commands(kernel):
             default_strokewidth = None
             default_fill = None
             for node in s_data:
-                if hasattr(node, "as_geometry"):
-                    geom: Geomstr = node.as_geometry()
-                    geoms.extend(iter(geom.as_contiguous()))
-                    if default_stroke is None and hasattr(node, "stroke"):
-                        default_stroke = node.stroke
-                    if default_strokewidth is None and hasattr(node, "stroke_width"):
-                        default_strokewidth = node.stroke_width
+                geom: Geomstr = node.as_geometry()
+                geoms.extend(iter(geom.as_contiguous()))
+                if default_stroke is None and hasattr(node, "stroke"):
+                    default_stroke = node.stroke
+                if default_strokewidth is None and hasattr(node, "stroke_width"):
+                    default_strokewidth = node.stroke_width
                 to_be_deleted.append(node)
             prev_len = len(geoms)
             if geoms:

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/core/node/blobnode.py

@@ -41,8 +41,15 @@ class BlobNode(Node):
         return False
 
     @staticmethod
-    def hex_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+    def hex_view(data, data_type, info=''):
+        """
+        Render a hex dump with an optional info header.
+
+        data: bytes to display
+        data_type: mime type
+        info: an arbitrary string to append to the end of first line of header
+        """
+        header1 = f"Data-Type: {data_type}, Length={len(data)}{info}\n"
         header2 = "Offset | Hex                                             | Ascii          \n"
         header2 += "-------+-------------------------------------------------+----------------\n"
         if isinstance(data, str):
@@ -70,8 +77,16 @@ class BlobNode(Node):
         return header1 + header2 + "".join(hex_data)
 
     @staticmethod
-    def ascii_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+    def ascii_view(data, data_type, info=''):
+        """
+        Render an ascii view with an optional info header.
+
+        data: bytes to display
+        data_type: mime type
+        info: an arbitrary string to append to the end of first line of header
+        """
+
+        header1 = f"Data-Type: {data_type}, Length={len(data)}{info}\n"
         header2 = "Offset | Hex                                             | Ascii          \n"
         header2 += "-------+-------------------------------------------------+----------------\n"
         if isinstance(data, str):

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/core/planner.py

@@ -43,7 +43,9 @@ def plugin(kernel, lifecycle=None):
             },
         ]
         kernel.register_choices("planner", choices)
-
+        INNER_WARNING = _(
+            "Notabene: Reduce Travel Time and Burn Inner First cannot be used at the same time."
+        )
         choices = [
             {
                 "attr": "opt_raster_optimisation",
@@ -97,7 +99,9 @@ def plugin(kernel, lifecycle=None):
                     "When this option IS checked, Meerk40t will burn each subpath "
                     + "and then move to the nearest remaining subpath instead, "
                     + "reducing the time taken moving between burn items."
-                ),
+                )
+                + "\n"
+                + INNER_WARNING,
                 "page": "Optimisations",
                 "section": "_20_Reducing Movements",
             },
@@ -187,9 +191,11 @@ def plugin(kernel, lifecycle=None):
                 "default": False,
                 "type": bool,
                 "label": _("Combine path segments"),
-                "tip": 
-                    _("Stitch segments together that are very close (ideally having joint start/end points).") + "\n" +
-                    _("Only inside a single cut/engrave operation."),
+                "tip": _(
+                    "Stitch segments together that are very close (ideally having joint start/end points)."
+                )
+                + "\n"
+                + _("Only inside a single cut/engrave operation."),
                 "page": "Optimisations",
                 "section": "_05_Stitching",
             },
@@ -199,7 +205,9 @@ def plugin(kernel, lifecycle=None):
                 "default": "0",
                 "type": Length,
                 "label": _("Tolerance"),
-                "tip": _("Tolerance to decide whether two path segments should be joined."),
+                "tip": _(
+                    "Tolerance to decide whether two path segments should be joined."
+                ),
                 "page": "Optimisations",
                 "section": "_05_Stitching",
                 "conditional": (context, "opt_stitching"),
@@ -221,7 +229,9 @@ def plugin(kernel, lifecycle=None):
                     + "* Deselecting Cut Inner First if you are not cutting fully through your material \n"
                     + "* Putting the inner paths into a separate earlier operation(s) and not using Merge Operations or Cut Inner First \n"
                     + "* If you are using multiple passes, check Merge Passes"
-                ),
+                )
+                + "\n"
+                + INNER_WARNING,
                 "page": "Optimisations",
                 "section": "_10_Burn sequence",
             },
@@ -285,8 +295,11 @@ def plugin(kernel, lifecycle=None):
                 "type": bool,
                 "label": _("Keep effect lines together"),
                 "tip": (
-                    _("Active: effects like hatches are dealt with as a bigger shape") + "\n" +
-                    _("Inactive: every single line segment will be dealt with individually.")
+                    _("Active: effects like hatches are dealt with as a bigger shape")
+                    + "\n"
+                    + _(
+                        "Inactive: every single line segment will be dealt with individually."
+                    )
                 ),
                 "page": "Optimisations",
                 "section": "_25_Effects",
@@ -298,8 +311,9 @@ def plugin(kernel, lifecycle=None):
                 "type": bool,
                 "label": _("Optimize internally"),
                 "tip": (
-                    _("Active: hatch lines will be optimized internally") + "\n" +
-                    _("Inactive: hatch lines will be burnt sequentially.")
+                    _("Active: hatch lines will be optimized internally")
+                    + "\n"
+                    + _("Inactive: hatch lines will be burnt sequentially.")
                 ),
                 "page": "Optimisations",
                 "section": "_25_Effects",

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/grbl/device.py

@@ -495,6 +495,19 @@ class GRBLDevice(Service, Status):
                 "section": "_20_" + _("Maximum speeds"),
                 "subsection": "_10_",
             },
+            {
+                "attr": "rapid_speed",
+                "object": self,
+                "default": 600,
+                "type": float,
+                "label": _("Travel speed"),
+                "trailer": "mm/s",
+                "tip": _(
+                    "What is the travel speed for your device to move from point to another."
+                ),
+                "section": "_25_" + _("Travel"),
+                "subsection": "_10_",
+            },
             {
                 "attr": "limit_buffer",
                 "object": self,
@@ -900,7 +913,8 @@ class GRBLDevice(Service, Status):
                 # self.redlight_preferred = True
                 # self.driver.set("power", int(self.red_dot_level / 100 * 1000))
                 self.driver._clean()
-                self.driver.laser_on(power=int(self.red_dot_level), speed=1000)
+                rapid_speed = self.setting(float, "rapid_speed", 600.0)
+                self.driver.laser_on(power=int(self.red_dot_level), speed=rapid_speed)
                 # By default, any move is a G0 move which will not activate the laser,
                 # so we need to switch to G1 mode:
                 self.driver.move_mode = 1

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/grbl/driver.py

@@ -47,7 +47,12 @@ class GRBLDriver(Parameters):
         self.stepper_step_size = UNITS_PER_MIL
 
         self.plot_planner = PlotPlanner(
-            self.settings, single=True, ppi=False, shift=False, group=True, require_uniform_movement = False,
+            self.settings,
+            single=True,
+            ppi=False,
+            shift=False,
+            group=True,
+            require_uniform_movement=False,
         )
         self.queue = []
         self._queue_current = 0
@@ -407,10 +412,10 @@ class GRBLDriver(Parameters):
         for q in self.queue:
             # Are there any custom commands to be executed?
             # Usecase (as described in issue https://github.com/meerk40t/meerk40t/issues/2764 ):
-            # Switch between M3 and M4 mode for cut / raster 
+            # Switch between M3 and M4 mode for cut / raster
             #   M3=used to cut as gantry acceleration doesn't matter on a cut.
-            #   M4=used for Raster/Engrave operations, as grblHAL will 
-            #   adjust power based on gantry speed including acceleration. 
+            #   M4=used for Raster/Engrave operations, as grblHAL will
+            #   adjust power based on gantry speed including acceleration.
 
             cmd_string = q.settings.get("custom_commands", "")
             if cmd_string:
@@ -437,7 +442,7 @@ class GRBLDriver(Parameters):
             self.on_value = 1.0
             # Do we have a custom z-Value?
             # NB: zaxis is not a property inside Parameters like power/or speed
-            # so we need to deal with it more directly 
+            # so we need to deal with it more directly
             # (e.g. self.power is the equivalent to self.settings.["power"]))
             qzaxis = q.settings.get("zaxis", self.zaxis)
             if qzaxis != self.zaxis:
@@ -534,6 +539,7 @@ class GRBLDriver(Parameters):
                             PLOT_RAPID | PLOT_JOG
                         ):  # Plot planner requests position change.
                             # self.move_mode = 0
+                            self.rapid_mode()
                             self._move(x, y)
                         continue
                     # if on == 0:
@@ -609,6 +615,10 @@ class GRBLDriver(Parameters):
         @param values:
         @return:
         """
+        speedvalue = self.service.setting(float, "rapid_speed", 600.0)
+        if self.speed != speedvalue:
+            self.speed = speedvalue
+            self.speed_dirty = True
 
     def finished_mode(self, *values):
         """

{meerk40t-0.9.7040 → meerk40t-0.9.7050}/meerk40t/gui/laserpanel.py

@@ -888,6 +888,25 @@ class OptimizePanel(wx.Panel):
             self.checkbox_optimize.SetValue(newvalue)
             self.optimize_panel.Enable(newvalue)
 
+    def ensure_mutually_exclusive(self, prio: str):
+        # Ensure that opt_inner_first and opt_reduce_travel are mutually exclusive
+        inner_first = self.context.planner.opt_inner_first
+        reduce_travel = self.context.planner.opt_reduce_travel
+        if inner_first and reduce_travel:
+            if prio == "opt_inner_first":
+                self.context.planner.opt_reduce_travel = False
+            else:
+                self.context.planner.opt_inner_first = False
+            self.optimize_panel.reload()
+
+    @signal_listener("opt_inner_first")
+    def opt_inner_update(self, origin, *message):
+        self.ensure_mutually_exclusive("opt_inner_first")
+
+    @signal_listener("opt_reduce_travel")
+    def opt_reduce_travel_update(self, origin, *message):
+        self.ensure_mutually_exclusive("opt_reduce_travel")
+
     def on_optimize(self, event):
         newvalue = bool(self.checkbox_optimize.GetValue())
         if newvalue != self.context.planner.do_optimization: