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

meerk40t/core/node/image_raster.py

@@ -0,0 +1,113 @@
+from copy import copy
+
+from meerk40t.core.node.node import Node
+from meerk40t.svgelements import Matrix
+
+
+class ImageRasterNode(Node):
+    """
+    ImageRasterNode is a basic image type. Its information is backed by a raster.
+    """
+
+    def __init__(self, **kwargs):
+        self.image = None
+        self.matrix = None
+        super().__init__(type="image raster", **kwargs)
+        self.__formatter = "{element_type} {id} {width}x{height}"
+        if self.matrix is None:
+            self.matrix = Matrix()
+        self._can_rotate = False
+        self._can_skew = False
+
+    def __copy__(self):
+        nd = self.node_dict
+        nd["matrix"] = copy(self.matrix)
+        nd["image"] = copy(self.image)
+        return ImageRasterNode(**nd)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{self.type}', {str(self.image)}, {str(self._parent)})"
+
+    def as_image(self):
+        return self.image, self.bbox()
+
+    def preprocess(self, context, matrix, plan):
+        """
+        Preprocess step during the cut planning stages.
+
+        We require a context to calculate the correct step values relative to the device
+        """
+        self.matrix *= matrix
+        self.set_dirty_bounds()
+
+    def bbox(self, transformed=True, with_stroke=False):
+        image_width, image_height = self.image.size
+        matrix = self.matrix
+        x0, y0 = matrix.point_in_matrix_space((0, 0))
+        x1, y1 = matrix.point_in_matrix_space((image_width, image_height))
+        x2, y2 = matrix.point_in_matrix_space((0, image_height))
+        x3, y3 = matrix.point_in_matrix_space((image_width, 0))
+        return (
+            min(x0, x1, x2, x3),
+            min(y0, y1, y2, y3),
+            max(x0, x1, x2, x3),
+            max(y0, y1, y2, y3),
+        )
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map.update(self.__dict__)
+        image = self.image
+        default_map["width"] = image.width
+        default_map["height"] = image.height
+        default_map["element_type"] = "Image"
+        return default_map
+
+    def drop(self, drag_node, modify=True):
+        # Dragging element into element.
+        if drag_node.type.startswith("elem"):
+            if modify:
+                self.insert_sibling(drag_node)
+            return True
+        elif drag_node.type.startswith("op"):
+            # If we drag an operation to this node,
+            # then we will reverse the game
+            return drag_node.drop(self, modify=modify)
+        return False
+
+    def revalidate_points(self):
+        bounds = self.bounds
+        if bounds is None:
+            return
+        if len(self._points) < 9:
+            self._points.extend([None] * (9 - len(self._points)))
+        self._points[0] = [bounds[0], bounds[1], "bounds top_left"]
+        self._points[1] = [bounds[2], bounds[1], "bounds top_right"]
+        self._points[2] = [bounds[0], bounds[3], "bounds bottom_left"]
+        self._points[3] = [bounds[2], bounds[3], "bounds bottom_right"]
+        cx = (bounds[0] + bounds[2]) / 2
+        cy = (bounds[1] + bounds[3]) / 2
+        self._points[4] = [cx, cy, "bounds center_center"]
+        self._points[5] = [cx, bounds[1], "bounds top_center"]
+        self._points[6] = [cx, bounds[3], "bounds bottom_center"]
+        self._points[7] = [bounds[0], cy, "bounds center_left"]
+        self._points[8] = [bounds[2], cy, "bounds center_right"]
+
+    def update_point(self, index, point):
+        return False
+
+    def add_point(self, point, index=None):
+        return False
+
+    @property
+    def opaque_image(self):
+        from PIL import Image
+
+        img = self.image
+        if img is not None:
+            if img.mode == "RGBA":
+                r, g, b, a = img.split()
+                background = Image.new("RGB", img.size, "white")
+                background.paste(img, mask=a)
+                img = background
+        return img

meerk40t/core/node/node.py

@@ -512,6 +512,38 @@ class Node:
     def valid_node_for_reference(self, node):
         return True
 
+    def copy_children_as_references(self, obj):
+        """
+        Copy the children of the given object as direct references to those children.
+        @param obj:
+        @return:
+        """
+        for element in obj.children:
+            self.add_reference(element)
+
+    def copy_with_reified_tree(self):
+        """
+        Make a copy of the current node, and a copy of the sub-nodes dereferencing any reference nodes
+        @return:
+        """
+        copy_c = copy(self)
+        copy_c.copy_children_as_real(self)
+        return copy_c
+
+    def copy_children_as_real(self, copy_node):
+        """
+        Copy the children of copy_node to the current node, dereferencing any reference nodes.
+        @param copy_node:
+        @return:
+        """
+        for child in copy_node.children:
+            child = child
+            if child.type == "reference":
+                child = child.node
+            copy_child = copy(child)
+            self.add_node(copy_child)
+            copy_child.copy_children_as_real(child)
+
     def is_draggable(self):
         return True
 
@@ -912,7 +944,7 @@ class Node:
         if node._parent is not None:
             raise ValueError("Cannot reparent node on add.")
         node._parent = self
-        node._root = self._root
+        node.set_root(self._root)
         if pos is None:
             self._children.append(node)
         else:
@@ -957,6 +989,17 @@ class Node:
             print(f"Did not produce a valid node for type '{type}'")
         return node
 
+    def set_root(self, root):
+        """
+        Set the root for this and all descendant to the provided root
+
+        @param root:
+        @return:
+        """
+        self._root = root
+        for c in self._children:
+            c.set_root(root)
+
     def _flatten(self, node):
         """
         Yield this node and all descendants in a flat generation.
@@ -1097,6 +1140,63 @@ class Node:
         self.unregister()
         return node
 
+    def swap_node(self, node):
+        """
+        Swap nodes swaps the current node with the provided node in the other position in the same tree. All children
+        during a swap are kept in place structurally. This permits swapping nodes between two positions that may be
+        nested, without creating a loop.
+
+        Special care is taken for both swaps being children of the same parent.
+
+        @param node: Node already in the tree that should be swapped with the current node.
+        @return:
+        """
+        # Remove self from tree.
+        parent = self._parent
+        n_parent = node._parent
+
+        index = parent._children.index(self)
+        n_index = n_parent._children.index(node)
+
+        if index < n_index:
+            # N_index is greater.
+            del n_parent._children[n_index]
+            del parent._children[index]
+
+            parent._children.insert(index, node)
+            n_parent._children.insert(n_index, self)
+        else:
+            # N_index is lesser, equal
+            del parent._children[index]
+            del n_parent._children[n_index]
+
+            n_parent._children.insert(n_index, self)
+            parent._children.insert(index, node)
+
+        node._parent = parent
+        self._parent = n_parent
+
+        # Make a copy of children
+        n_children = list(node._children)
+        children = list(self._children)
+
+        # Delete children.
+        node._children.clear()
+        self._children.clear()
+
+        # Move children without call attach / detach.
+        node._children.extend(children)
+        self._children.extend(n_children)
+
+        # Correct parent for all children.
+        for n in list(n_children):
+            n._parent = self
+        for n in list(children):
+            n._parent = node
+
+        # self._root._validate_tree()
+        self._root.notify_reorder()
+
     def remove_node(self, children=True, references=True, fast=False, destroy=True):
         """
         Remove the current node from the tree.
@@ -1132,6 +1232,25 @@ class Node:
             child.remove_all_children(fast=fast, destroy=destroy)
             child.remove_node(fast=fast, destroy=destroy)
 
+    def has_ancestor(self, type):
+        """
+        Return whether this node has an ancestor node that matches the given type, or matches the major type.
+
+        @param type:
+        @return:
+        """
+        if self.parent is None:
+            return False
+
+        if self.parent.type == type:
+            return True
+
+        if " " not in type:
+            if self.parent.type.startswith(type):
+                return True
+
+        return self.parent.has_ancestor(type=type)
+
     def get(self, type=None):
         """
         Recursive call for get to find first sub-nodes with the given type.

meerk40t/core/node/op_cut.py

@@ -35,6 +35,7 @@ class CutOpNode(Node, Parameters):
             "elem rect",
             "elem line",
             "effect hatch",
+            "effect wobble",
         )
         # Which elements do we consider for automatic classification?
         self._allowed_elements = (
@@ -44,6 +45,7 @@ class CutOpNode(Node, Parameters):
             "elem rect",
             "elem line",
             "effect hatch",
+            "effect wobble",
         )
         # To which attributes responds the classification color check
         self.allowed_attributes = [
@@ -235,14 +237,6 @@ class CutOpNode(Node, Parameters):
         settings.write_persistent(section, "hex_color", self.color.hexa)
         settings.write_persistent_dict(section, self.settings)
 
-    def copy_children(self, obj):
-        for element in obj.children:
-            self.add_reference(element)
-
-    def copy_children_as_real(self, copy_node):
-        for node in copy_node.children:
-            self.add_node(copy(node.node))
-
     def time_estimate(self):
         estimate = 0
         for node in self.children:

meerk40t/core/node/op_dots.py

@@ -198,14 +198,6 @@ class DotsOpNode(Node, Parameters):
         settings.write_persistent(section, "hex_color", self.color.hexa)
         settings.write_persistent_dict(section, self.settings)
 
-    def copy_children(self, obj):
-        for element in obj.children:
-            self.add_reference(element)
-
-    def copy_children_as_real(self, copy_node):
-        for node in copy_node.children:
-            self.add_node(copy(node.node))
-
     def time_estimate(self):
         estimate = 0
         for e in self.children:

meerk40t/core/node/op_engrave.py

@@ -34,6 +34,7 @@ class EngraveOpNode(Node, Parameters):
             "elem rect",
             "elem line",
             "effect hatch",
+            "effect wobble",
         )
         # Which elements do we consider for automatic classification?
         self._allowed_elements = (
@@ -43,6 +44,7 @@ class EngraveOpNode(Node, Parameters):
             "elem rect",
             "elem line",
             "effect hatch",
+            "effect wobble",
         )
 
         # To which attributes does the classification color check respond
@@ -224,24 +226,6 @@ class EngraveOpNode(Node, Parameters):
         settings.write_persistent(section, "hex_color", self.color.hexa)
         settings.write_persistent_dict(section, self.settings)
 
-    def copy_children(self, obj):
-        for element in obj.children:
-            self.add_reference(element)
-
-    def copy_children_as_real(self, copy_node):
-        context = self
-        for node in copy_node.children:
-            if node.type.startswith("effect"):
-                n = copy(node)
-                context.add_node(n)
-                context = n
-        for node in copy_node.children:
-            if node.type == "reference":
-                context.add_node(copy(node.node))
-        for node in self.children:
-            if node.type.startswith("effect"):
-                node.effect = True
-
     def time_estimate(self):
         estimate = 0
         for node in self.children:

meerk40t/core/node/op_image.py

@@ -21,11 +21,6 @@ class ImageOpNode(Node, Parameters):
             settings = dict(settings)
         Parameters.__init__(self, settings, **kwargs)
 
-        # Which elements can be added to an operation (manually via DND)?
-        self._allowed_elements_dnd = ("elem image",)
-        # Which elements do we consider for automatic classification?
-        self._allowed_elements = ("elem image",)
-
         # Is this op out of useful bounds?
         self.dangerous = False
         self.stopop = True
@@ -90,34 +85,32 @@ class ImageOpNode(Node, Parameters):
 
     def drop(self, drag_node, modify=True):
         # Default routine for drag + drop for an op node - irrelevant for others...
-        if drag_node.type.startswith("elem"):
-            if (
-                drag_node.type not in self._allowed_elements_dnd
-                or drag_node._parent.type == "branch reg"
-            ):
+        if hasattr(drag_node, "as_image"):
+            if drag_node._parent.type == "branch reg":
+                # We do not accept reg nodes.
                 return False
             # Dragging element onto operation adds that element to the op.
             if modify:
                 self.add_reference(drag_node, pos=0)
             return True
-        elif drag_node.type == "reference":
+        if drag_node.type == "reference":
             # Disallow drop of image refelems onto a Dot op.
-            if not drag_node.node.type in self._allowed_elements_dnd:
+            if not hasattr(drag_node.node, "as_image"):
                 return False
             # Move a refelem to end of op.
             if modify:
                 self.append_child(drag_node)
             return True
-        elif drag_node.type in op_nodes:
+        if drag_node.type in op_nodes:
             # Move operation to a different position.
             if modify:
                 self.insert_sibling(drag_node)
             return True
-        elif drag_node.type in ("file", "group"):
+        if drag_node.type in ("file", "group"):
             some_nodes = False
             for e in drag_node.flat(elem_nodes):
                 # Add element to operation
-                if e.type in self._allowed_elements_dnd:
+                if hasattr(e, "as_image"):
                     if modify:
                         self.add_reference(e)
                     some_nodes = True
@@ -125,14 +118,14 @@ class ImageOpNode(Node, Parameters):
         return False
 
     def valid_node_for_reference(self, node):
-        if node.type in self._allowed_elements_dnd:
+        if hasattr(node, "as_image"):
             return True
         else:
             return False
 
     def classify(self, node, fuzzy=False, fuzzydistance=100, usedefault=False):
         feedback = []
-        if node.type in self._allowed_elements:
+        if hasattr(node, "as_image"):
             self.add_reference(node)
             # Have classified and no more classification are needed
             feedback.append("stroke")
@@ -159,14 +152,6 @@ class ImageOpNode(Node, Parameters):
         settings.write_persistent(section, "hex_color", self.color.hexa)
         settings.write_persistent_dict(section, self.settings)
 
-    def copy_children(self, obj):
-        for element in obj.children:
-            self.add_reference(element)
-
-    def copy_children_as_real(self, copy_node):
-        for node in copy_node.children:
-            self.add_node(copy(node.node))
-
     def time_estimate(self):
         """
         The scanlines would equal "(e.height * 1000) / dpi" but our images are pre-actualized.
@@ -267,7 +252,7 @@ class ImageOpNode(Node, Parameters):
         for image_node in self.children:
             # Process each child. All settings are different for each child.
 
-            if image_node.type != "elem image":
+            if not hasattr(image_node, "as_image"):
                 continue
             settings = self.derive()
 
@@ -277,7 +262,7 @@ class ImageOpNode(Node, Parameters):
                 overscan = float(Length(overscan))
 
             # Set variables by direction
-            if image_node.direction is not None:
+            if hasattr(image_node, "direction") and image_node.direction is not None:
                 direction = image_node.direction
             else:
                 direction = self.raster_direction
@@ -298,9 +283,17 @@ class ImageOpNode(Node, Parameters):
                 start_on_left = True
             bidirectional = self.bidirectional
 
+            # Set variables
+            pil_image, bounds = image_node.as_image()
+            offset_x = bounds[0]
+            offset_y = bounds[1]
+
             # Get steps from individual images
-            step_x = image_node.step_x
-            step_y = image_node.step_y
+            image_width, image_height = pil_image.size
+            expected_width = bounds[2] - bounds[0]
+            expected_height = bounds[3] - bounds[1]
+            step_x = expected_width / image_width
+            step_y = expected_height / image_height
 
             if horizontal:
                 # Raster step is only along y for horizontal raster
@@ -311,12 +304,6 @@ class ImageOpNode(Node, Parameters):
                 settings["raster_step_x"] = step_x
                 settings["raster_step_y"] = 0
 
-            # Set variables
-            matrix = image_node.active_matrix
-            pil_image = image_node.active_image
-            offset_x = matrix.value_trans_x()
-            offset_y = matrix.value_trans_y()
-
             # Establish path
             min_x = offset_x
             min_y = offset_y

meerk40t/core/node/op_raster.py

@@ -40,7 +40,6 @@ class RasterOpNode(Node, Parameters):
             "elem rect",
             "elem line",
             "elem text",
-            #            "elem image",
         )
 
         # self.allowed_attributes.append("fill")
@@ -276,14 +275,6 @@ class RasterOpNode(Node, Parameters):
         settings.write_persistent(section, "hex_color", self.color.hexa)
         settings.write_persistent_dict(section, self.settings)
 
-    def copy_children(self, obj):
-        for element in obj.children:
-            self.add_reference(element)
-
-    def copy_children_as_real(self, copy_node):
-        for node in copy_node.children:
-            self.add_node(copy(node.node))
-
     def time_estimate(self):
         estimate = 0
         dpi = self.dpi

meerk40t/core/planner.py

@@ -45,6 +45,36 @@ def plugin(kernel, lifecycle=None):
         kernel.register_choices("planner", choices)
 
         choices = [
+            {
+                "attr": "opt_raster_optimisation",
+                "object": context,
+                "default": True,
+                "type": bool,
+                "label": _("Cluster raster objects"),
+                "tip": _(
+                    "Separate non-overlapping raster objects.\n"
+                    "Active: this will raster close (ie overlapping) objects as one,\n"
+                    "but will separately process objects lying apart from each other.\n"
+                    "Inactive: all objects will be lasered as one single unit."
+                ),
+                "page": "Optimisations",
+                "section": "_20_Reducing Movements",
+                "subsection": "Splitting rasters",
+            },
+            {
+                "attr": "opt_raster_opt_margin",
+                "object": context,
+                "default": "1mm",
+                "type": Length,
+                "label": _("Margin:"),
+                "tip": _(
+                    "Allowed gap between rasterable objects, to still be counted as one."
+                ),
+                "page": "Optimisations",
+                "section": "_20_Reducing Movements",
+                "subsection": "Splitting rasters",
+                "conditional": (context, "opt_raster_optimisation"),
+            },
             {
                 "attr": "opt_reduce_travel",
                 "object": context,
@@ -190,7 +220,7 @@ def plugin(kernel, lifecycle=None):
                 "type": bool,
                 "label": _("Group Inner Burns"),
                 "tip": _(
-                    "Try to complete a set of inner burns and the associated outer cut before moving onto other elements."
+                    "Try to complete a set of inner burns and the associated outer cut before moving onto other elements.\n"
                     + "This option only does something if Burn Inner First is also selected. "
                     + "If your design has multiple separate pieces on it, "
                     + "this should mostly cause each piece to be burned in entirety "
@@ -227,7 +257,6 @@ def plugin(kernel, lifecycle=None):
             },
         ]
         kernel.register_choices("optimize", choices)
-
         context.setting(bool, "opt_2opt", False)
         context.setting(bool, "opt_nearest_neighbor", True)
         context.setting(bool, "opt_reduce_directions", False)
@@ -259,6 +288,7 @@ class Planner(Service):
         Service.__init__(self, kernel, "planner")
         self._plan = dict()
         self._default_plan = "0"
+        self.do_optimization = True
 
     def length(self, v):
         return float(Length(v))