meerk40t 0.9.7010__tar.gz → 0.9.7030__tar.gz

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/PKG-INFO

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

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/balormk/galvo_commands.py

@@ -1153,7 +1153,6 @@ def plugin(service, lifecycle):
         import platform
 
         from meerk40t.balormk.clone_loader import load_sys
-        from meerk40t.kernel import get_safe_path
 
         kernel = service.kernel
 
@@ -1173,7 +1172,7 @@ def plugin(service, lifecycle):
             return
 
         # Check for file in the meerk40t directory (safe_path)
-        directory = get_safe_path(kernel.name, create=True)
+        directory = kernel.os_information["WORKDIR"]
         p = os.path.join(directory, service.clone_sys)
         if os.path.exists(p):
             load_sys(p, channel=channel)

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/cutcode/cutcode.py

@@ -132,7 +132,7 @@ class CutCode(CutGroup):
                 length_of_previous_travel = Point.distance(prev.end, current.start)
                 total_distance_travel += length_of_previous_travel
             rapid_speed = self._native_speed(cutcode)
-            if rapid_speed is not None:
+            if rapid_speed is not None and rapid_speed != 0:
                 total_duration_travel = total_distance_travel / rapid_speed
                 duration_of_this_travel = length_of_previous_travel / rapid_speed
 

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/cutplan.py

@@ -23,7 +23,7 @@ from functools import lru_cache
 import numpy as np
 
 from ..svgelements import Group, Matrix, Path, Polygon
-from ..tools.geomstr import Geomstr
+from ..tools.geomstr import Geomstr, stitch_geometries
 from ..tools.pathtools import VectorMontonizer
 from .cutcode.cutcode import CutCode
 from .cutcode.cutgroup import CutGroup
@@ -32,7 +32,6 @@ from .cutcode.rastercut import RasterCut
 from .node.node import Node
 from .node.util_console import ConsoleOperation
 from .units import Length, UNITS_PER_MM
-
 """
 The time to compile does outweigh the benefit...
 try:
@@ -187,6 +186,7 @@ class CutPlan:
             placements.append(scene_to_device_matrix)
 
         original_ops = copy(self.plan)
+
         if self.context.opt_raster_optimisation and self.context.do_optimization:
             try:
                 margin = float(Length(self.context.opt_raster_opt_margin, "0"))
@@ -244,6 +244,74 @@ class CutPlan:
                 op_type = getattr(op, "type", "")
                 if op_type.startswith("place "):
                     continue
+                if op_type == "op cut" and self.context.opt_stitching and self.context.do_optimization:
+                    # This isn't a lossless operation: dotted/dashed lines will be treated as solid lines
+                    try:
+                        stitch_tolerance = float(Length(self.context.opt_stitch_tolerance))
+                    except ValueError:
+                        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 (
+                                    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)
+                    for node in data:
+                        if node is op:
+                            continue
+                        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
+                            to_be_deleted.append(node)
+                    result = stitch_geometries(geoms, stitch_tolerance)
+                    if result is not None:
+                        # print (f"Paths at start of action: {len(list(op.flat()))}")
+                        for node in to_be_deleted:
+                            node.remove_node()
+                        for idx, g in enumerate(result):
+                            node = op.add(
+                                label=f"Stitch # {idx + 1}",
+                                stroke=default_stroke,
+                                stroke_width=default_strokewidth,
+                                geometry=g,
+                                type="elem path",
+                            )
+                        # print (f"Paths at start of action: {len(list(op.flat()))}")
+
                 self.plan.append(op)
                 if (op_type.startswith("op") or op_type.startswith("util")) and hasattr(op, "preprocess"):
                     op.preprocess(self.context, placement, self)

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/branches.py

@@ -187,7 +187,7 @@ def init_commands(kernel):
             return
         try:
             channel(_("loading..."))
-            result = self.load(new_file)
+            result = self.load(new_file, svg_ppi=self.svg_ppi)
             if result:
                 channel(_("Done."))
         except AttributeError:
@@ -1410,6 +1410,20 @@ def init_commands(kernel):
                 self.remove_operations(data)
         self.signal("update_group_labels")
 
+    @self.console_command(
+        "clear_all", help=_("Clear all content"), input_type=("elements", "ops")
+    )
+    def e_clear(command, channel, _, data=None, data_type=None, **kwargs):
+        channel(_("Deleting…"))
+        fast = True
+        with self.undoscope("Deleting"):
+            if data_type == "elements":
+                self.clear_elements(fast=fast)
+                self.emphasized()
+            else:
+                self.clear_operations(fast=fast)
+        self.signal("rebuild_tree", "all")
+
     # ==========
     # ELEMENT BASE
     # ==========
@@ -1490,7 +1504,7 @@ def init_commands(kernel):
         else:
             target = self.reg_branch
             scope = "Elements -> Regmarks"
-        
+
         with self.undoscope(scope):
             if data is None:
                 data = list()
@@ -1826,8 +1840,8 @@ def init_commands(kernel):
                     subpath.ensure_proper_subpaths()
                     idx += 1
                     subnode = group_node.add(
-                        geometry=subpath, 
-                        type="elem path", 
+                        geometry=subpath,
+                        type="elem path",
                         label=f"{node_label}-{idx}",
                         stroke=node_attributes.get("stroke", None),
                         fill=node_attributes.get("fill", None),

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/element_treeops.py

@@ -2866,13 +2866,15 @@ def init_tree(kernel):
         dots_per_units = node.dpi / UNITS_PER_INCH
         new_width = width * dots_per_units
         new_height = height * dots_per_units
-
-        image = make_raster(
-            data,
-            bounds=bounds,
-            width=new_width,
-            height=new_height,
-        )
+        try:
+            image = make_raster(
+                data,
+                bounds=bounds,
+                width=new_width,
+                height=new_height,
+            )
+        except Exception:
+            return None, None
         matrix = Matrix.scale(width / new_width, height / new_height)
         matrix.post_translate(bounds[0], bounds[1])
         return image, matrix
@@ -3570,6 +3572,40 @@ def init_tree(kernel):
         with self.undoscope("Outline"):
             self(f"outline {offset}mm\n")
         self.signal("refresh_tree")
+    
+    @tree_conditional(
+        lambda node: not is_regmark(node)
+        and hasattr(node, "as_geometry")
+    )
+    @tree_submenu(_("Offset shapes..."))
+    @tree_iterate("offset", 1, 5)
+    @tree_operation(
+        _("...to outside with {offset}mm distance"),
+        node_type=elem_nodes,
+        help=_("Create an outer offset around the selected elements"),
+        grouping="50_ELEM_MODIFY_ZMISC"
+    )
+    def make_positive_offsets(node, offset=1, **kwargs):
+        with self.undoscope("Offset"):
+            self(f"offset {offset}mm\n")
+        self.signal("refresh_tree")
+
+    @tree_conditional(
+        lambda node: not is_regmark(node)
+        and hasattr(node, "as_geometry")
+    )
+    @tree_submenu(_("Offset shapes..."))
+    @tree_iterate("offset", 1, 5)
+    @tree_operation(
+        _("...to inside with {offset}mm distance"),
+        node_type=elem_nodes,
+        help=_("Create an inner offset around the selected elements"),
+        grouping="50_ELEM_MODIFY_ZMISC"
+    )
+    def make_negative_offsets(node, offset=1, **kwargs):
+        with self.undoscope("Offset"):
+            self(f"offset -{offset}mm\n")
+        self.signal("refresh_tree")
 
     def mergeable(node):
         elems = list(self.elems(emphasized=True))

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/elements.py

@@ -75,6 +75,7 @@ def plugin(kernel, lifecycle=None):
             tree_commands,
             undo_redo,
             wordlist,
+            testcases,
         )
 
         return [
@@ -96,6 +97,7 @@ def plugin(kernel, lifecycle=None):
             placements.plugin,
             offset_mk.plugin,
             offset_clpr.plugin,
+            testcases.plugin,
         ]
     elif lifecycle == "preregister":
         kernel.register(
@@ -2699,6 +2701,13 @@ class Elemental(Service):
         if elements is None:
             return
         new_operations_added = False
+        debug_set = {}
+
+        def update_debug_set(debug_set, opnode):
+            if opnode.type not in debug_set:
+                debug_set[opnode.type] = 0
+            debug_set[opnode.type] = debug_set[opnode.type] + 1
+
 
         if len(list(self.ops())) == 0 and not self.operation_default_empty:
             has_cut = False
@@ -2732,6 +2741,13 @@ class Elemental(Service):
             add_op_function = self.add_classify_op
         for node in elements:
             node_desc = f"[{node.type}]{'' if node.id is None else node.id + '-'}{'<none>' if node.label is None else node.display_label()}"
+            if hasattr(node, "stroke") or hasattr(node, "fill"):
+                info = ""
+                if hasattr(node, "stroke") and node.stroke is not None:
+                    info += f"S:{node.stroke},"
+                if hasattr(node, "fill") and node.fill is not None:
+                    info += f"F:{node.fill},"
+                node_desc += f"({info})"
             # Following lines added to handle 0.7 special ops added to ops list
             if hasattr(node, "operation"):
                 add_op_function(node)
@@ -2758,7 +2774,7 @@ class Elemental(Service):
                     if not do_fill and op.type in ("op raster", "op image"):
                         continue
                     is_black = False
-                    whisperer = True
+                    perform_classification = True
                     if (
                         hasattr(node, "stroke")
                         and node.stroke is not None
@@ -2780,18 +2796,18 @@ class Elemental(Service):
                         and is_black
                         and isinstance(op, RasterOpNode)
                     ):
-                        whisperer = False
+                        perform_classification = False
                     elif (
                         self.classify_black_as_raster
                         and is_black
                         and isinstance(op, EngraveOpNode)
                     ):
-                        whisperer = False
+                        perform_classification = False
                     if debug:
                         debug(
-                            f"For {op.type}.{op.id}: black={is_black}, perform={whisperer}, flag={self.classify_black_as_raster}"
+                            f"For {op.type}.{op.id}: black={is_black}, perform={perform_classification}, flag={self.classify_black_as_raster}"
                         )
-                    if hasattr(op, "classify") and whisperer:
+                    if hasattr(op, "classify") and perform_classification:
                         classified, should_break, feedback = op.classify(
                             node,
                             fuzzy=tempfuzzy,
@@ -2801,6 +2817,7 @@ class Elemental(Service):
                     else:
                         continue
                     if classified:
+                        update_debug_set(debug_set, op)
                         if feedback is not None and "stroke" in feedback:
                             classif_info[0] = True
                         if feedback is not None and "fill" in feedback:
@@ -2869,78 +2886,41 @@ class Elemental(Service):
                 # let's iterate through the default ops and add them
                 if debug:
                     debug("Pass 2 (wasn't classified), looking for default ops")
+                default_candidates = []
                 for op in operations:
-                    if classif_info[0] and op.type in (
-                        "op engrave",
-                        "op cut",
-                        "op dots",
-                    ):
-                        continue
-                    if classif_info[1] and op.type in ("op raster", "op image"):
-                        continue
-                    is_black = False
-                    whisperer = True
                     if (
-                        hasattr(node, "stroke")
-                        and node.stroke is not None
-                        and node.stroke.argb is not None
-                        and node.type != "elem text"
-                    ):
-                        if fuzzy:
-                            is_black = (
-                                Color.distance("black", abs(node.stroke))
-                                <= fuzzydistance
-                                or Color.distance("white", abs(node.stroke))
-                                <= fuzzydistance
-                            )
-                        else:
-                            is_black = Color("black") == abs(node.stroke) or Color(
-                                "white"
-                            ) == abs(node.stroke)
-                    if (
-                        not self.classify_black_as_raster
-                        and is_black
-                        and isinstance(op, RasterOpNode)
+                        hasattr(op, "classify") and 
+                        getattr(op, "default", False) and 
+                        hasattr(op, "valid_node_for_reference") and
+                        op.valid_node_for_reference(node)
                     ):
-                        # print ("Default Skip Raster")
-                        whisperer = False
-                    elif (
-                        self.classify_black_as_raster
-                        and is_black
-                        and isinstance(op, EngraveOpNode)
-                    ):
-                        whisperer = False
-                    if debug:
-                        debug(
-                            f"For {op.type}.{op.id}: black={is_black}, perform={whisperer}, flag={self.classify_black_as_raster}"
-                        )
-                    if hasattr(op, "classify") and whisperer:
-                        classified, should_break, feedback = op.classify(
-                            node,
-                            fuzzy=fuzzy,
-                            fuzzydistance=fuzzydistance,
-                            usedefault=True,
-                        )
-                    else:
-                        continue
+                        default_candidates.append(op)
+                if len(default_candidates) > 1 and debug:
+                    debug(f"For node {node_desc} there were {len(default_candidates)} default operations available, nb the very first will be taken!")
+                for op in default_candidates:
+                    classified, should_break, feedback = op.classify(
+                        node,
+                        fuzzy=fuzzy,
+                        fuzzydistance=fuzzydistance,
+                        usedefault=True,
+                    )
                     if classified:
-                        if feedback is not None and "stroke" in feedback:
-                            classif_info[0] = True
-                        if feedback is not None and "fill" in feedback:
-                            classif_info[1] = True
+                        update_debug_set(debug_set, op)
+                        # Default ops fulfill stuff by definition
+                        classif_info[0] = True
+                        classif_info[1] = True
                         was_classified = True
                         if debug:
                             debug(
-                                f"Was classified to default operation: {type(op).__name__}, break={should_break}"
+                                f"Was classified to default operation: {type(op).__name__}"
                             )
-                    if should_break:
                         break
             # Let's make sure we only consider relevant, i.e. existing attributes...
             if hasattr(node, "stroke"):
                 if node.stroke is None or node.stroke.argb is None:
                     classif_info[0] = True
                 if node.type == "elem text":
-                    # even if it has, we are not going to something with it
+                    # even if it has, we are not going to do something with it
                     classif_info[0] = True
             else:
                 classif_info[0] = True
@@ -3218,8 +3198,14 @@ class Elemental(Service):
 
                     if not existing:
                         op.add_reference(node)
+                        update_debug_set(debug_set, op)
+
 
         self.remove_unused_default_copies()
+        if debug:
+            debug("Summary:")
+            for key, count in debug_set.items():
+                debug(f"{count} items assigned to {key}")
         if new_operations_added:
             self.signal("tree_changed")
 

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/grid.py

@@ -198,7 +198,14 @@ def init_commands(kernel):
                 y_distance += height
             if origin is None:
                 origin = (1, 1)
-            cx, cy = origin
+            if isinstance(origin, (tuple, list)) and isinstance(origin[0], (tuple, list)):
+                origin = origin[0]
+            try:
+                cx, cy = origin
+            except ValueError:
+                cx = 1
+                cy = 1
+            
             data_out = list(data)
             if cx is None:
                 cx = 1

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/offset_clpr.py

@@ -876,9 +876,6 @@ def init_commands(kernel):
         if method is None:
             method = "union"
         method = method.lower()
-        if filltype is None:
-            filltype = "evenodd"
-        filltype = filltype.lower()
         if keep is None:
             keep = False
 
@@ -891,6 +888,10 @@ def init_commands(kernel):
         else:
             long_method = "Union"
 
+        if filltype is None:
+            filltype = "evenodd" if method != "union" else "nonzero"
+        filltype = filltype.lower()
+
         if filltype.startswith("no") or filltype.startswith("z"):
             long_filltype = "NonZero"
         elif filltype.startswith("p") or filltype.startswith("+"):

{meerk40t-0.9.7010 → meerk40t-0.9.7030}/meerk40t/core/elements/offset_mk.py

@@ -360,10 +360,11 @@ def offset_path(self, path, offset_value=0):
     # As this oveloading a regular method in a class
     # it needs to have the very same definition (including the class
     # reference self)
+    # Radial connectors seem to have issues, so we don't use them for now...
     p = path_offset(
         path,
         offset_value=-offset_value,
-        radial_connector=True,
+        radial_connector=False,
         linearize=True,
         interpolation=500,
     )