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

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/node.py

@@ -499,9 +499,12 @@ class Node:
             node_copy._parent = copied_parent
             copied_parent._children.append(node_copy)
             if node.type == "reference":
-                original_referenced, copied_referenced = links[id(node.node)]
-                node_copy.node = copied_referenced
-                copied_referenced._references.append(node_copy)
+                try:
+                    original_referenced, copied_referenced = links[id(node.node)]
+                    node_copy.node = copied_referenced
+                    copied_referenced._references.append(node_copy)
+                except KeyError:
+                    pass
 
     def _validate_tree(self):
         for c in self._children:

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

@@ -181,6 +181,29 @@ def plugin(kernel, lifecycle=None):
                 "section": "_20_Reducing Movements",
                 "conditional": (context, "opt_reduce_travel"),
             },
+            {
+                "attr": "opt_stitching",
+                "object": context,
+                "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."),
+                "page": "Optimisations",
+                "section": "_05_Stitching",
+            },
+            {
+                "attr": "opt_stitch_tolerance",
+                "object": context,
+                "default": "0",
+                "type": Length,
+                "label": _("Tolerance"),
+                "tip": _("Tolerance to decide whether two path segments should be joined."),
+                "page": "Optimisations",
+                "section": "_05_Stitching",
+                "conditional": (context, "opt_stitching"),
+            },
             {
                 "attr": "opt_inner_first",
                 "object": context,

meerk40t/core/undos.py

@@ -81,7 +81,7 @@ class Undo:
             elif self._undo_index < len(self._undo_stack) and self._undo_stack[self._undo_index].hold:
                 # Just add another one on top of it
                 self._undo_index += 1
-            elif self._undo_stack[self._undo_index].message == self.LAST_STATE:
+            elif self._undo_index < len(self._undo_stack) and self._undo_stack[self._undo_index].message == self.LAST_STATE:
                 # Will be overwritten
                 pass
             elif self._undo_index < len(self._undo_stack) - 1 and self._undo_stack[self._undo_index + 1].message != self.LAST_STATE:

meerk40t/core/wordlist.py

@@ -394,6 +394,7 @@ class Wordlist:
 
     def load_csv_file(self, filename, force_header=None):
         self.empty_csv()
+        ct = 0
         headers = []
         decoder = EncodingDetectFile()
         result = decoder.load(filename)

meerk40t/dxf/dxf_io.py

@@ -251,6 +251,8 @@ class DXFProcessor:
         elif dxftype == "ELLIPSE":
             center = (entity.dxf.center)  # Center point of the ellipse (3D, but we'll use x,y)
             major_axis = entity.dxf.major_axis  # Vector representing the major axis
+            minor_axis = entity.minor_axis  # Vector representing the minor axis
+            # They should have the same sign, if they are different then they are mirrored?!
             ratio = entity.dxf.ratio  # Ratio of minor to major axis
             start_angle, end_angle = get_angles(entity)
 
@@ -262,6 +264,10 @@ class DXFProcessor:
                 major_axis[0] ** 2 + major_axis[1] ** 2
             )  # Length of the major axis (in XY plane)
             b = a * ratio  # Length of the minor axis
+            # Different signs? Inverse
+            if major_axis[0] * minor_axis[1] < 0:
+                b *= -1
+
             # geom = Geomstr.ellipse(
             #     start_t=start_angle,
             #     end_t=end_angle,

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