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

meerk40t/core/node/image_raster.py

@@ -1,113 +1,156 @@
-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
+from copy import copy
+
+from meerk40t.core.node.node import Node
+from meerk40t.core.units import UNITS_PER_INCH
+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} @{dpi}"
+        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
+
+        pil_image, bounds = self.image, self.bounds
+
+        try:
+            default_map["width"] = image.width
+            default_map["height"] = image.height
+            default_map["offset_x"] = bounds[0]
+            default_map["offset_y"] = bounds[1]
+        except:
+            default_map["width"] = 0
+            default_map["height"] = 0
+            default_map["offset_x"] = 0
+            default_map["offset_y"] = 0
+            default_map["step_x"] = 1
+            default_map["step_y"] = 1
+            default_map["dpi"] = 1
+            return default_map
+
+        # Get steps from individual images
+        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
+        default_map["step_x"] = step_x
+        default_map["step_y"] = step_y
+        dpi_x = float(UNITS_PER_INCH / step_x)
+        dpi_y = float(UNITS_PER_INCH / step_y)
+        default_map["dpi"] = round((dpi_x + dpi_y) / 2)
+        default_map["element_type"] = "Image"
+        return default_map
+
+    def can_drop(self, drag_node):
+        # Dragging element into element.
+        return bool(
+            hasattr(drag_node, "as_geometry") or
+            hasattr(drag_node, "as_image") or
+            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
+            drag_node.type in ("file", "group")
+        )
+
+    def drop(self, drag_node, modify=True, flag=False):
+        # Dragging element into element.
+        if not self.can_drop(drag_node):
+            return False
+        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+            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, flag=flag)
+        return False
+
+    def notify_scaled(self, *args, **kwargs):
+        super().notify_scaled(*args, **kwargs)
+        self.notify_update()
+
+    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/layernode.py

@@ -1,31 +1,31 @@
-from meerk40t.core.node.node import Node
-
-
-class LayerNode(Node):
-    """
-    Bootstrapped type: 'layer'
-    """
-
-    def __init__(self, **kwargs):
-        self.layer_name = None
-        super().__init__(type="layer", **kwargs)
-        self._formatter = "{element_type} {id} ({children} elems)"
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["name"] = self.layer_name
-        default_map["element_type"] = "Layer"
-        default_map["children"] = str(len(self.count_children()))
-        return default_map
-
-    def notify_selected(self, node=None, **kwargs):
-        if node is self:
-            if hasattr(self.parent, "activate"):
-                self.parent.activate(self.layer_name)
-
-    def drop(self, drag_node, modify=True):
-        return False
-
-    @property
-    def bounds(self):
-        return None
+from meerk40t.core.node.node import Node
+
+
+class LayerNode(Node):
+    """
+    Bootstrapped type: 'layer'
+    """
+
+    def __init__(self, **kwargs):
+        self.layer_name = None
+        super().__init__(type="layer", **kwargs)
+        self._formatter = "{element_type} {id} ({children} elems)"
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["name"] = self.layer_name
+        default_map["element_type"] = "Layer"
+        default_map["children"] = str(len(self.count_children()))
+        return default_map
+
+    def notify_selected(self, node=None, **kwargs):
+        if node is self:
+            if hasattr(self.parent, "activate"):
+                self.parent.activate(self.layer_name)
+
+    def drop(self, drag_node, modify=True, flag=False):
+        return False
+
+    @property
+    def bounds(self):
+        return None

meerk40t/core/node/mixins.py

@@ -1,107 +1,135 @@
-"""
-Mixins for nodes are aspects of code which can and should be used between multiple different nodes which convey some
-basic functionality.
-
-The use of ABC allows @abstractmethod decorators which require any subclass to implement the required method.
-"""
-
-from abc import ABC
-from math import sqrt
-
-
-class Stroked(ABC):
-    """
-    Stroked nodes provide a stroke_scaled matrix controlled stroke mixin. Such that the stroke scaling can be enabled
-    and disabled, and it will increase or decrease the implied_stroke_width. If stroke scaling is disabled then the
-    stroke_width is independent to the scaling of the node (dictated by the .matrix attribute).
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-
-    @property
-    def stroke_scaled(self):
-        return self.stroke_scale
-
-    @stroke_scaled.setter
-    def stroke_scaled(self, v):
-        """
-        Setting stroke_scale directly will not resize the stroke-width based on current scaling. This function allows
-        the toggling of the stroke-scaling without the current stroke_width being affected.
-
-        @param v:
-        @return:
-        """
-        if bool(v) == bool(self.stroke_scale):
-            # Unchanged.
-            return
-        if not v:
-            self.stroke_width *= self.stroke_factor
-        self.stroke_width_zero()
-        self.stroke_scale = v
-
-    @property
-    def implied_stroke_width(self):
-        """
-        The implied stroke width is stroke_width if not scaled or the scaled stroke_width if scaled.
-
-        @return:
-        """
-        if self.stroke_scale:
-            factor = self.stroke_factor
-        else:
-            factor = 1
-        if hasattr(self, "stroke"):
-            # print (f"Have stroke {self.stroke}, {type(self.stroke).__name__}")
-            if self.stroke is None or self.stroke.argb is None:
-                # print ("set to zero")
-                factor = 0
-
-        return self.stroke_width * factor
-
-    @property
-    def stroke_factor(self):
-        """
-        The stroke factor is the ratio of the new to old stroke-width scale.
-
-        @return:
-        """
-        matrix = self.matrix
-        stroke_one = sqrt(abs(matrix.determinant))
-        try:
-            return stroke_one / self._stroke_zero
-        except (AttributeError, ZeroDivisionError, TypeError):
-            return 1.0
-
-    def stroke_reify(self):
-        """Set the stroke width to the real stroke width."""
-        if self.stroke_scale:
-            self.stroke_width *= self.stroke_factor
-        self.stroke_width_zero()
-
-    def stroke_width_zero(self):
-        """
-        Ensures the current stroke scale is marked as stroke_zero.
-        @return:
-        """
-        matrix = self.matrix
-        self._stroke_zero = sqrt(abs(matrix.determinant))
-
-
-class FunctionalParameter(ABC):
-    """
-    Functional Parameters mixin allows the use and utility of functional parameters for this node type.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self.mkparam = None
-        super().__init__()
-
-    @property
-    def functional_parameter(self):
-        return self.mkparam
-
-    @functional_parameter.setter
-    def functional_parameter(self, value):
-        if isinstance(value, (list, tuple)):
-            self.mkparam = value
+"""
+Mixins for nodes are aspects of code which can and should be used between multiple different nodes which convey some
+basic functionality.
+
+The use of ABC allows @abstractmethod decorators which require any subclass to implement the required method.
+"""
+
+from abc import ABC
+from math import sqrt
+
+
+class Stroked(ABC):
+    """
+    Stroked nodes provide a stroke_scaled matrix controlled stroke mixin. Such that the stroke scaling can be enabled
+    and disabled, and it will increase or decrease the implied_stroke_width. If stroke scaling is disabled then the
+    stroke_width is independent to the scaling of the node (dictated by the .matrix attribute).
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self._acts_as_keyhole = False
+
+    @property
+    def stroke_scaled(self):
+        return self.stroke_scale
+
+    @stroke_scaled.setter
+    def stroke_scaled(self, v):
+        """
+        Setting stroke_scale directly will not resize the stroke-width based on current scaling. This function allows
+        the toggling of the stroke-scaling without the current stroke_width being affected.
+
+        @param v:
+        @return:
+        """
+        if bool(v) == bool(self.stroke_scale):
+            # Unchanged.
+            return
+        if not v:
+            self.stroke_width *= self.stroke_factor
+        self.stroke_width_zero()
+        self.stroke_scale = v
+
+    @property
+    def implied_stroke_width(self):
+        """
+        The implied stroke width is stroke_width if not scaled or the scaled stroke_width if scaled.
+
+        @return:
+        """
+        if self.stroke_scale:
+            factor = self.stroke_factor
+        else:
+            factor = 1
+        if hasattr(self, "stroke"):
+            # print (f"Have stroke {self.stroke}, {type(self.stroke).__name__}")
+            if self.stroke is None or self.stroke.argb is None:
+                # print ("set to zero")
+                factor = 0
+
+        return self.stroke_width * factor
+
+    @property
+    def stroke_factor(self):
+        """
+        The stroke factor is the ratio of the new to old stroke-width scale.
+
+        @return:
+        """
+        matrix = self.matrix
+        stroke_one = sqrt(abs(matrix.determinant))
+        try:
+            return stroke_one / self._stroke_zero
+        except (AttributeError, ZeroDivisionError, TypeError):
+            return 1.0
+
+    def stroke_reify(self):
+        """Set the stroke width to the real stroke width."""
+        if self.stroke_scale:
+            self.stroke_width *= self.stroke_factor
+        self.stroke_width_zero()
+
+    def stroke_width_zero(self):
+        """
+        Ensures the current stroke scale is marked as stroke_zero.
+        @return:
+        """
+        matrix = self.matrix
+        self._stroke_zero = sqrt(abs(matrix.determinant))
+
+
+class FunctionalParameter(ABC):
+    """
+    Functional Parameters mixin allows the use and utility of functional parameters for this node type.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.mkparam = None
+        super().__init__()
+
+    @property
+    def functional_parameter(self):
+        return self.mkparam
+
+    @functional_parameter.setter
+    def functional_parameter(self, value):
+        if isinstance(value, (list, tuple)):
+            self.mkparam = value
+
+
+class LabelDisplay(ABC):
+    """
+    Any node inheriting this allow the display of the label on the scene
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.label_display = False
+        super().__init__()
+
+
+class Suppressable(ABC):
+    """
+    Any node inheriting this can be suppressed
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.hidden = False
+        if "hidden" in kwargs:
+            if isinstance(kwargs["hidden"], str):
+                if kwargs["hidden"].lower() == "true":
+                    kwargs["hidden"] = True
+                else:
+                    kwargs["hidden"] = False
+            self.hidden = kwargs["hidden"]
+        super().__init__()