meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

meerk40t/core/elements/element_types.py

@@ -13,6 +13,7 @@ non_structural_nodes = (
     "op engrave",
     "op dots",
     "effect hatch",
+    "effect wobble",
     "util console",
     "util wait",
     "util home",
@@ -32,6 +33,7 @@ non_structural_nodes = (
     "elem rect",
     "elem line",
     "elem text",
+    "image raster",
     "file",
     "group",
 )
@@ -61,7 +63,8 @@ place_nodes = (
     "place point",
     "place current",
 )
-effect_nodes = ("effect hatch",)
+effect_nodes = ("effect hatch", "effect wobble")
+image_nodes = ("image raster", "image processed", "elem image")
 elem_nodes = (
     "elem ellipse",
     "elem image",
@@ -71,7 +74,6 @@ elem_nodes = (
     "elem rect",
     "elem line",
     "elem text",
-    "effect hatch",
 )
 elem_group_nodes = (
     "elem ellipse",
@@ -82,7 +84,9 @@ elem_group_nodes = (
     "elem rect",
     "elem line",
     "elem text",
+    "image raster",
     "effect hatch",
+    "effect wobble",
     "group",
     "file",
 )
@@ -96,5 +100,6 @@ elem_ref_nodes = (
     "elem line",
     "elem text",
     "effect hatch",
+    "effect wobble",
     "reference",
 )

meerk40t/core/elements/elements.py

@@ -117,7 +117,11 @@ def plugin(kernel, lifecycle=None):
         kernel.register("format/elem text", "{element_type} {desc} {text}")
         kernel.register(
             "format/effect hatch",
-            "{effect}{element_type} - {distance} {angle} ({children})",
+            "{element_type} - {distance} {angle} ({children})",
+        )
+        kernel.register(
+            "format/effect wobble",
+            "{element_type} - {type} {radius} ({children})",
         )
         kernel.register("format/reference", "*{reference}")
         kernel.register(
@@ -494,7 +498,7 @@ class Elemental(Service):
         self.points = list()
         self.segments = list()
 
-        self.undo = Undo(self._tree)
+        self.undo = Undo(self, self._tree)
         self.do_undo = True
         self.suppress_updates = False
 
@@ -522,14 +526,15 @@ class Elemental(Service):
 
         direct = os.path.dirname(self.op_data._config_file)
         self.mywordlist = Wordlist(self.kernel.version, direct)
-        self.load_persistent_operations("previous")
+        with self.undofree():
+            self.load_persistent_operations("previous")
 
-        ops = list(self.ops())
-        if len(ops) == 0 and not self.operation_default_empty:
-            self.load_default(performclassify=False)
-        if list(self.ops()):
-            # Something was loaded for default ops. Mark that.
-            self.undo.mark("op-loaded")  # Mark defaulted
+            ops = list(self.ops())
+            if len(ops) == 0 and not self.operation_default_empty:
+                self.load_default(performclassify=False)
+            if list(self.ops()):
+                # Something was loaded for default ops. Mark that.
+                self.undo.mark("op-loaded")  # Mark defaulted
 
         self._default_stroke = None
         self._default_strokewidth = None
@@ -677,13 +682,18 @@ class Elemental(Service):
         #     pnode.targeted = True
         #     pnode = pnode.parent
 
+    def unassigned_elements(self):
+        for e in self.elems():
+            if (e._references is None or len(e._references) == 0) and e.type not in (
+                "file",
+                "group",
+            ):
+                yield e
+
     def have_unassigned_elements(self):
-        unassigned = False
-        for node in self.elems():
-            if len(node._references) == 0 and node.type not in ("file", "group"):
-                unassigned = True
-                break
-        return unassigned
+        for node in self.unassigned_elements():
+            return True
+        return False
 
     def have_unburnable_elements(self):
         unassigned = False
@@ -713,17 +723,23 @@ class Elemental(Service):
         return float(Length(v))
 
     def length_x(self, v):
-        return float(Length(v, relative_length=self.device.view.width))
+        try:
+            return float(Length(v, relative_length=self.device.view.width))
+        except AttributeError:
+            return 0.0
 
     def length_y(self, v):
-        return float(Length(v, relative_length=self.device.view.height))
+        try:
+            return float(Length(v, relative_length=self.device.view.height))
+        except AttributeError:
+            return 0.0
 
     def bounds(self, x0, y0, x1, y1):
         return (
-            float(Length(x0, relative_length=self.device.view.width)),
-            float(Length(y0, relative_length=self.device.view.height)),
-            float(Length(x1, relative_length=self.device.view.width)),
-            float(Length(y1, relative_length=self.device.view.height)),
+            self.length_x(x0),
+            self.length_y(y0),
+            self.length_x(x1),
+            self.length_y(y1),
         )
 
     def area(self, v):
@@ -1439,6 +1455,7 @@ class Elemental(Service):
             # Restore emphasized flags
             for e in emph_data:
                 e.emphasized = True
+        self.signal("element_property_reload", data)
 
     def remove_unused_default_copies(self):
         # Let's clean non-used operations that come from defaults...
@@ -1617,6 +1634,13 @@ class Elemental(Service):
                 continue
             yield item
 
+    def op_groups(self, **kwargs):
+        operations = self._tree.get(type="branch ops")
+        for item in operations.flat(**kwargs):
+            if item.type.startswith("branch") or item.type.startswith("ref"):
+                continue
+            yield item
+
     def elems(self, **kwargs):
         elements = self._tree.get(type="branch elems")
         yield from elements.flat(types=elem_nodes, **kwargs)
@@ -1826,7 +1850,7 @@ class Elemental(Service):
             if drop_node.drop(drag_node, modify=False):
                 # Is the drag node coming from the regmarks branch?
                 # If yes then we might need to classify.
-                if drag_node._parent.type == "branch reg":
+                if drag_node.has_ancestor("branch reg"):
                     if drag_node.type in ("file", "group"):
                         for e in drag_node.flat(elem_nodes):
                             to_classify.append(e)
@@ -3471,6 +3495,7 @@ class Elemental(Service):
                             # self.unlisten_tree(self)
                             elemcount_then = self.count_elems()
                             opcount_then = self.count_op()
+                            self._loading_cleared = False
                             results = loader.load(
                                 self, self, filename_to_process, **kwargs
                             )
@@ -3487,11 +3512,12 @@ class Elemental(Service):
                             ):
                                 return True
                             elif results:
-                                self.signal(
-                                    "warning",
-                                    _("File is Empty"),
-                                    _("File is Malformed"),
-                                )
+                                if not self._loading_cleared:
+                                    self.signal(
+                                        "warning",
+                                        _("File is Empty"),
+                                        _("File is Malformed"),
+                                    )
                                 return True
 
                         except FileNotFoundError:

meerk40t/core/elements/geometry.py

@@ -74,6 +74,14 @@ def init_commands(kernel):
                 path.append(e)
         return "geometry", path
 
+    @self.console_command("validate", input_type="geometry", output_type="geometry")
+    def geometry_validate(channel, _, data=None, **kwargs):
+        try:
+            data.validate()
+            channel(_("Geometry is valid."))
+        except AssertionError:
+            channel(_("Geometry was not valid."))
+
     @self.console_argument("x_pos", type=Length)
     @self.console_argument("y_pos", type=Length)
     @self.console_argument("r_pos", type=Length)

meerk40t/core/elements/offset_clpr.py

@@ -473,14 +473,27 @@ def init_commands(kernel):
                 pyc_method = pyclipr.ClipType.Xor
             else:
                 pyc_method = pyclipr.ClipType.Union
+            # Definition of enumerators has changed, so let#s try to be backwards compatible
             if filltype.startswith("no") or filltype.startswith("z"):
-                pyc_filltype = pyclipr.FillType.NonZero
+                try:
+                    pyc_filltype = pyclipr.FillRule.NonZero
+                except AttributeError:
+                    pyc_filltype = pyclipr.FillType.NonZero
             elif filltype.startswith("p") or filltype.startswith("+"):
-                pyc_filltype = pyclipr.FillType.Positive
+                try:
+                    pyc_filltype = pyclipr.FillRule.Positive
+                except AttributeError:
+                    pyc_filltype = pyclipr.FillType.Positive
             elif filltype.startswith("ne") or filltype.startswith("-"):
-                pyc_filltype = pyclipr.FillType.Negative
+                try:
+                    pyc_filltype = pyclipr.FillRule.Negative
+                except AttributeError:
+                    pyc_filltype = pyclipr.FillType.Negative
             else:
-                pyc_filltype = pyclipr.FillType.EvenOdd
+                try:
+                    pyc_filltype = pyclipr.FillRule.EvenOdd
+                except AttributeError:
+                    pyc_filltype = pyclipr.FillType.EvenOdd
 
             if self.any_open and pyc_method in (pyclipr.ClipType.Union,):
                 self.newpath = self.clipr_clipper.execute(
@@ -678,6 +691,118 @@ def init_commands(kernel):
             self.signal("refresh_scene", "Scene")
         return "elements", data_out
 
+    # Pocketing
+    @self.console_argument(
+        "offset",
+        type=str,
+        help=_(
+            "offset to line mm (negative values to left/outside, positive values to right/inside)"
+        ),
+    )
+    @self.console_option(
+        "jointype", "j", type=str, help=_("join type: round, miter, square")
+    )
+    @self.console_option(
+        "separate",
+        "s",
+        action="store_true",
+        type=bool,
+        help=_("deal with subpaths separately"),
+    )
+    @self.console_option(
+        "repeats",
+        "r",
+        type=int,
+        help=_("amount of repetitions, 0=until area is fully filled"),
+    )
+    @self.console_option(
+        "interpolation", "i", type=int, help=_("interpolation points per segment")
+    )
+    @self.console_command(
+        "pocket",
+        help=_("create a pocketing path for any of the given elements"),
+        input_type=(None, "elements"),
+        output_type="elements",
+    )
+    def element_pocket_path(
+        command,
+        channel,
+        _,
+        offset=None,
+        jointype=None,
+        separate=None,
+        repeats=0,
+        interpolation=None,
+        data=None,
+        post=None,
+        **kwargs,
+    ):
+        if data is None:
+            data = list(self.elems(emphasized=True))
+        if len(data) == 0:
+            channel(_("No elements selected"))
+            return "elements", data
+        if interpolation is None:
+            interpolation = 500
+        if separate is None:
+            separate = False
+        if offset is None:
+            offset = 0
+        else:
+            try:
+                ll = Length(offset)
+                offset = float(ll)
+            except ValueError:
+                offset = 0
+        if offset == 0.0:
+            channel("Invalid offset, nothing to do")
+            return
+        # Our definition for an offset is different this time
+        offset *= -1
+        if repeats is None or repeats < 0:
+            repeats = 0
+        if offset > 0 and repeats == 0:
+            channel(
+                "You need to provide the -r parameter to set the amount of repetitions"
+            )
+            return
+
+        if jointype is None:
+            jointype = "miter"
+        jointype = jointype.lower()
+        default_stroke = None
+        for node in data:
+            if hasattr(node, "stroke"):
+                default_stroke = node.stroke
+                break
+        if default_stroke is None:
+            default_stroke = self._default_stroke
+        data_out = []
+        rep_count = 0
+        mydata = [e for e in data]
+        while (rep_count < repeats or repeats == 0) and len(mydata) > 0:
+            rep_count += 1
+            c_off = ClipperOffset(interpolation=interpolation)
+            c_off.add_nodes(mydata)
+            c_off.process_data(offset, jointype=jointype, separate=separate)
+            mydata.clear()
+            for geom in c_off.result_geometry():
+                if geom is not None:
+                    newnode = self.elem_branch.add(
+                        geometry=geom, type="elem path", stroke=default_stroke
+                    )
+                    newnode.stroke_width = UNITS_PER_PIXEL
+                    newnode.linejoin = Linejoin.JOIN_ROUND
+                    newnode.label = f"Offset: {Length(offset).length_mm}"
+                    mydata.append(newnode)
+                    data_out.append(newnode)
+
+        # Newly created! Classification needed?
+        if len(data_out) > 0:
+            post.append(classify_new(data_out))
+            self.signal("refresh_scene", "Scene")
+        return "elements", data_out
+
     # ---- Let's add some CAG commands....
     @self.console_argument(
         "method",

meerk40t/core/elements/offset_mk.py

@@ -633,7 +633,8 @@ def path_offset(
         # print (f"Subpath {spct}")
         p = Path(subpath)
         if not linearize:
-            p.approximate_arcs_with_cubics()
+            # p.approximate_arcs_with_cubics()
+            pass
         offset = offset_value
         # # No offset bigger than half the path size, otherwise stuff will get crazy
         # if offset > 0:
@@ -829,6 +830,7 @@ def path_offset(
     result = results[0]
     for idx in range(1, len(results)):
         result += results[idx]
+    # result.approximate_arcs_with_cubics()
     return result
 
 

meerk40t/core/elements/shapes.py

@@ -238,37 +238,39 @@ def init_commands(kernel):
         input_type=(None, "elements"),
     )
     def effect_hatch(
-        command, data=None, angle=None, angle_delta=None, distance=None, **kwargs
+        command,
+        data=None,
+        angle=None,
+        angle_delta=None,
+        distance=None,
+        post=None,
+        **kwargs,
     ):
         """
         Add an effect hatch object
         """
-        node = self.elem_branch.add(
+        if data is None:
+            data = list(self.elems(emphasized=True))
+        if len(data) == 0:
+            return
+        first_node = data[0]
+
+        node = first_node.parent.add(
             type="effect hatch",
             label="Hatch Effect",
             hatch_angle=angle.as_radians,
             hatch_angle_delta=angle_delta.as_radians,
             hatch_distance=distance,
         )
+        for n in data:
+            node.append_child(n)
+
+        # Newly created! Classification needed?
+        post.append(classify_new([node]))
+
         self.set_emphasis([node])
-        if data is not None:
-            for n in data:
-                node.append_child(n)
         node.focus()
 
-    @self.console_command(
-        "toggle",
-        help=_("Toggles effect from being group to an effect."),
-        input_type="elements",
-    )
-    def effect_toggle(command, data=None, **kwargs):
-        """
-        Toggles effect hatch object
-        """
-        for n in data:
-            if n.type.startswith("effect "):
-                n.effect = not n.effect
-
     @self.console_option(
         "size", "s", type=float, default=16, help=_("font size to for object")
     )
@@ -732,12 +734,10 @@ def init_commands(kernel):
     def element_pathd_info(command, channel, _, data, real=True, **kwargs):
         for node in data:
             try:
-                if node.path.transform.is_identity():
-                    channel(
-                        f"{str(node)} (Identity): {node.path.d(transformed=not real)}"
-                    )
-                else:
-                    channel(f"{str(node)}: {node.path.d(transformed=not real)}")
+                g = node.as_geometry()
+                path = g.as_path()
+                ident = " (Identity)" if node.matrix.is_identity() else ""
+                channel(f"{str(node)}{ident}: {path.d(transformed=not real)}")
             except AttributeError:
                 channel(f"{str(node)}: Invalid")
 
@@ -2021,7 +2021,10 @@ def init_commands(kernel):
             except AttributeError:
                 pass
             if e.type == "elem path":
-                e.path.approximate_bezier_with_circular_arcs()
+                g = e.geometry
+                path = g.as_path()
+                path.approximate_bezier_with_circular_arcs()
+                e.geometry = Geomstr.svg(path)
                 e.altered()
 
         return "elements", data

meerk40t/core/laserjob.py

@@ -183,6 +183,13 @@ class LaserJob:
             self.runtime += time.time() - self.time_started
         self._stopped = True
 
+    def stop_after_loop(self):
+        self.loops = self.loops_executed + 1
+
+    def add_another_loop(self):
+        if not isinf(self.loops):
+            self.loops += 1
+
     def elapsed_time(self):
         """
         How long is this job already running...

meerk40t/core/node/bootstrap.py

@@ -4,6 +4,7 @@ from meerk40t.core.node.branch_ops import BranchOperationsNode
 from meerk40t.core.node.branch_regmark import BranchRegmarkNode
 from meerk40t.core.node.cutnode import CutNode
 from meerk40t.core.node.effect_hatch import HatchEffectNode
+from meerk40t.core.node.effect_wobble import WobbleEffectNode
 from meerk40t.core.node.elem_ellipse import EllipseNode
 from meerk40t.core.node.elem_image import ImageNode
 from meerk40t.core.node.elem_line import LineNode
@@ -14,6 +15,7 @@ from meerk40t.core.node.elem_rect import RectNode
 from meerk40t.core.node.elem_text import TextNode
 from meerk40t.core.node.filenode import FileNode
 from meerk40t.core.node.groupnode import GroupNode
+from meerk40t.core.node.image_raster import ImageRasterNode
 from meerk40t.core.node.layernode import LayerNode
 from meerk40t.core.node.op_cut import CutOpNode
 from meerk40t.core.node.op_dots import DotsOpNode
@@ -71,6 +73,7 @@ bootstrap = {
     "op image": ImageOpNode,
     "op dots": DotsOpNode,
     "effect hatch": HatchEffectNode,
+    "effect wobble": WobbleEffectNode,
     "util console": ConsoleOperation,
     "util wait": WaitOperation,
     "util home": HomeOperation,
@@ -90,6 +93,7 @@ bootstrap = {
     "elem polyline": PolylineNode,
     "elem image": ImageNode,
     "elem text": TextNode,
+    "image raster": ImageRasterNode,
     "reference": ReferenceNode,
     "cutcode": CutNode,
     "branch ops": BranchOperationsNode,