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

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/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/core/elements/element_treeops.py

@@ -3570,6 +3570,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/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/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/core/elements/shapes.py

@@ -1729,7 +1729,7 @@ def init_commands(kernel):
                 # self.signal("rebuild_tree")
                 self.signal("refresh_tree", apply)
             else:
-                self.signal("element_property_update", apply)
+                self.signal("element_property_reload", apply)
                 self.signal("refresh_scene", "Scene")
         return "elements", data
 

meerk40t/core/elements/testcases.py

@@ -0,0 +1,105 @@
+from math import sqrt
+
+from meerk40t.core.node.node import Fillrule, Linecap, Linejoin, Node
+from meerk40t.core.units import (
+    UNITS_PER_MM,
+    UNITS_PER_PIXEL,
+    UNITS_PER_POINT,
+    Angle,
+    Length,
+)
+from meerk40t.kernel import CommandSyntaxError
+from meerk40t.svgelements import (
+    SVG_RULE_EVENODD,
+    SVG_RULE_NONZERO,
+    Color,
+    Matrix,
+    Path,
+    Polygon,
+    Polyline,
+)
+from meerk40t.tools.geomstr import Geomstr
+
+
+def plugin(kernel, lifecycle=None):
+    _ = kernel.translation
+    if lifecycle == "postboot":
+        init_commands(kernel)
+
+
+def init_commands(kernel):
+    self = kernel.elements
+
+    _ = kernel.translation
+
+    classify_new = self.post_classify
+
+    def polybool_crash_test(channel, _):
+        # rect_info = "M 30961.4173228,10320.4724409 L 474741.732283,10320.4724409 L 474741.732283,392177.952756 L 30961.4173228,392177.952756 L 30961.4173228,10320.4724409"
+        # geom = Geomstr().svg(rect_info)
+        # Testcase: polybool crash AttributeError: 'NoneType' object has no attribute 'next' for element difference
+        data = []
+        x_pos = 30961.4173228
+        y_pos = 10320.4724409
+        width = 474741.732283 - x_pos
+        height = 392177.952756 - y_pos
+        node1 = self.elem_branch.add(
+            label = "Shape 1",
+            x=x_pos,
+            y=y_pos,
+            width=width,
+            height=height,
+            stroke=self.default_stroke,
+            stroke_width=self.default_strokewidth,
+            fill=self.default_fill,
+            type="elem rect",
+        )
+        data.append(node1)
+        geom = Geomstr()
+        definition = (
+            ((30961.417322839014,10320.472440944883), 
+            (72243.30708661533,10320.472440944883)), 
+            ((72243.30708661533,10320.472440944883), 
+            (72243.30708661678,20640.944881889765)), 
+            ((72243.30708661533,10320.472440944883), 
+            (113525.19685039311,10320.472440944883)), 
+            ((113525.19685039311,10320.472440944883), 
+            (113525.19685039311,20640.944881889765)), 
+            ((72243.30708661678,20640.944881889765), 
+            (113525.19685039311,20640.944881889765)), 
+            ((113525.19685039311,10320.472440944883), 
+            (154807.08661416644,10320.472440944883)), 
+            ((154807.08661416644,10320.472440944883), 
+            (154807.08661417232,20640.944881889765)), 
+            ((154807.08661417232,20640.944881889765), 
+            (196088.97637794417,20640.944881889765)), 
+            ((154807.08661416644,10320.472440944883), 
+            (196088.97637794568,10320.472440944883)), 
+            ((196088.97637794417,20640.944881889765), 
+            (196088.97637794568,10320.472440944883)),
+        )
+        for s, e in definition:
+            geom.line(complex(s[0], s[1]), complex(e[0], e[1]))
+        node2 = self.elem_branch.add(
+            label = "Shape 2",
+            geometry=geom,
+            stroke=self.default_stroke,
+            stroke_width=self.default_strokewidth,
+            fill=self.default_fill,
+            type="elem path",
+        )
+
+        data.append(node2)
+        return "elements", data
+
+    @self.console_command(
+        "test",
+        output_type="elements",
+    )
+    def element_test(command, channel, _, data=None, post=None, **kwargs):
+        # rect_info = "M 30961.4173228,10320.4724409 L 474741.732283,10320.4724409 L 474741.732283,392177.952756 L 30961.4173228,392177.952756 L 30961.4173228,10320.4724409"
+        # geom = Geomstr().svg(rect_info)
+        # Testcase: polybool crash AttributeError: 'NoneType' object has no attribute 'next' for element difference
+        info, data = polybool_crash_test(channel, _)
+        post.append(classify_new(data))
+        return info, data

meerk40t/core/node/op_cut.py

@@ -246,7 +246,15 @@ class CutOpNode(Node, Parameters):
             return False, False, None
         feedback = []
         if node.type in self._allowed_elements:
-            if not self.default:
+            if self.default and usedefault:
+                # Have classified but more classification might be needed
+                if self.valid_node_for_reference(node):
+                    self.add_reference(node)
+                    feedback.append("stroke")
+                    feedback.append("fill")
+                    return True, self.stopop, feedback
+            else:
+                # Even if the default attribute set that would be a valid thing
                 if self.has_attributes():
                     result = False
                     for attribute in self.allowed_attributes:
@@ -271,13 +279,6 @@ class CutOpNode(Node, Parameters):
                         feedback.append("stroke")
                         feedback.append("fill")
                         return True, self.stopop, feedback
-            elif self.default and usedefault:
-                # Have classified but more classification might be needed
-                if self.valid_node_for_reference(node):
-                    self.add_reference(node)
-                    feedback.append("stroke")
-                    feedback.append("fill")
-                    return True, self.stopop, feedback
         return False, False, None
 
     def add_reference(self, node=None, pos=None, **kwargs):

meerk40t/core/node/op_dots.py

@@ -174,7 +174,14 @@ class DotsOpNode(Node, Parameters):
             return False, False, None
         feedback = []
         if node.type in self._allowed_elements:
-            if not self.default:
+            if self.default and usedefault:
+                # Have classified but more classification might be needed
+                if self.valid_node_for_reference(node):
+                    self.add_reference(node)
+                    feedback.append("stroke")
+                    feedback.append("fill")
+                    return True, self.stopop, feedback
+            else:
                 if self.has_attributes():
                     result = False
                     for attribute in self.allowed_attributes:
@@ -199,13 +206,6 @@ class DotsOpNode(Node, Parameters):
                         feedback.append("stroke")
                         feedback.append("fill")
                         return True, self.stopop, feedback
-            elif self.default and usedefault:
-                # Have classified but more classification might be needed
-                if self.valid_node_for_reference(node):
-                    self.add_reference(node)
-                    feedback.append("stroke")
-                    feedback.append("fill")
-                    return True, self.stopop, feedback
         return False, False, None
 
     def load(self, settings, section):

meerk40t/core/node/op_engrave.py

@@ -211,7 +211,13 @@ class EngraveOpNode(Node, Parameters):
             return False, False, None
         feedback = []
         if node.type in self._allowed_elements:
-            if not self.default:
+            if self.default and usedefault:
+                # Have classified but more classification might be needed
+                if self.valid_node_for_reference(node):
+                    feedback.append("stroke")
+                    feedback.append("fill")
+                    return True, self.stopop, feedback
+            else:
                 if self.has_attributes():
                     result = False
                     for attribute in self.allowed_attributes:
@@ -236,12 +242,6 @@ class EngraveOpNode(Node, Parameters):
                         feedback.append("stroke")
                         feedback.append("fill")
                         return True, self.stopop, feedback
-            elif self.default and usedefault:
-                # Have classified but more classification might be needed
-                if self.valid_node_for_reference(node):
-                    feedback.append("stroke")
-                    feedback.append("fill")
-                    return True, self.stopop, feedback
         return False, False, None
 
     def add_reference(self, node=None, pos=None, **kwargs):

meerk40t/core/node/op_raster.py

@@ -268,7 +268,14 @@ class RasterOpNode(Node, Parameters):
 
         feedback = []
         if node.type in self._allowed_elements:
-            if not self.default:
+            if self.default and usedefault:
+                # Have classified but more classification might be needed
+                if self.valid_node_for_reference(node):
+                    self.add_reference(node)
+                    feedback.append("stroke")
+                    feedback.append("fill")
+                    return True, self.stopop, feedback
+            else:
                 if self.has_attributes():
                     result = False
                     for attribute in self.allowed_attributes:
@@ -311,13 +318,6 @@ class RasterOpNode(Node, Parameters):
                             self.add_reference(node)
                             # Have classified but more classification might be needed
                             return True, self.stopop, feedback
-            elif self.default and usedefault:
-                # Have classified but more classification might be needed
-                if self.valid_node_for_reference(node):
-                    self.add_reference(node)
-                    feedback.append("stroke")
-                    feedback.append("fill")
-                    return True, self.stopop, feedback
         return False, False, None
 
     def load(self, settings, section):

meerk40t/extra/encode_detect.py

@@ -165,13 +165,19 @@ class EncodingDetectFile:
 
     def load(self, file_path):
         # open file
-        fh = open(file_path, "rb")
+        try:
+            fh = open(file_path, "rb")
+        except Exception:
+            return False
 
         # detect a byte order mark (BOM)
         file_encoding, bom_marker, file_data = self._detect_bom(fh)
         if file_encoding:
             # file has a BOM - decode everything past it
-            decode = fh.read().decode(file_encoding)
+            try:
+                decode = fh.read().decode(file_encoding)
+            except UnicodeDecodeError:
+                return False
             # print(f"decoded: {decode}")
             fh.close()
 

meerk40t/extra/hershey.py

@@ -7,7 +7,6 @@ from os.path import basename, exists, join, realpath, splitext
 from meerk40t.core.node.elem_path import PathNode
 from meerk40t.core.node.node import Fillrule, Linejoin
 from meerk40t.core.units import UNITS_PER_INCH, Length
-from meerk40t.kernel import get_safe_path
 from meerk40t.tools.geomstr import BeamTable, Geomstr
 from meerk40t.tools.jhfparser import JhfFont
 from meerk40t.tools.shxparser import ShxFont, ShxFontParseError
@@ -116,7 +115,7 @@ class Meerk40tFonts:
 
     @property
     def font_directory(self):
-        safe_dir = realpath(get_safe_path(self.context.kernel.name))
+        safe_dir = self.context.kernel.os_information["WORKDIR"]
         self.context.setting(str, "font_directory", safe_dir)
         fontdir = self.context.font_directory
         if not exists(fontdir):
@@ -129,7 +128,7 @@ class Meerk40tFonts:
     def font_directory(self, value):
         if not exists(value):
             # We cant allow a non-valid directory
-            value = realpath(get_safe_path(self.context.kernel.name))
+            value = self.context.kernel.os_information["WORKDIR"]
         self.context.setting(str, "font_directory", value)
         self.context.font_directory = value
         self._available_fonts = None

meerk40t/extra/inkscape.py

@@ -5,8 +5,6 @@ from subprocess import PIPE, TimeoutExpired, run
 from time import time
 
 from meerk40t.core.exceptions import BadFileError
-from meerk40t.kernel.kernel import get_safe_path
-
 
 def get_inkscape(context, manual_candidate=None):
     root_context = context
@@ -143,7 +141,7 @@ class MultiLoader:
                     break
 
         context_root = kernel.root
-        safe_dir = os.path.realpath(get_safe_path(kernel.name))
+        safe_dir = kernel.os_information["WORKDIR"]
         logfile = os.path.join(safe_dir, "inkscape.log")
 
         inkscape = get_inkscape(context_root)
@@ -228,7 +226,7 @@ def plugin(kernel, lifecycle):
             inkscape_path, filename = data
             channel(_("inkscape load - loading the previous conversion..."))
             try:
-                kernel.elements.load(filename)
+                kernel.elements.load(filename, svg_ppi=kernel.elements.svg_ppi)
             except BadFileError as e:
                 channel(_("File is Malformed."))
                 channel(str(e))
@@ -423,7 +421,7 @@ def plugin(kernel, lifecycle):
                 ],
                 "pattern": [False, ("<pattern",), METHOD_CONVERT_TO_PNG],
             }
-            safe_dir = os.path.realpath(get_safe_path(kernel.name))
+            safe_dir = kernel.os_information["WORKDIR"]
             svg_temp_file = os.path.join(safe_dir, "temp.svg")
             png_temp_file = os.path.join(safe_dir, "temp.png")
             needs_conversion = 0