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

meerk40t/core/node/elem_image.py

@@ -96,7 +96,7 @@ class ImageNode(Node):
         self._processed_image = None
         self._processed_matrix = None
         self._process_image_failed = False
-        self._processing_message = None
+        self.message = None
         if self.operations or self.dither or self.prevent_crop:
             step = UNITS_PER_INCH / self.dpi
             step_x = step
@@ -141,6 +141,9 @@ class ImageNode(Node):
         self.set_dirty_bounds()
         self.process_image(self.step_x, self.step_y, not self.prevent_crop)
 
+    def as_image(self):
+        return self.active_image, self.bbox()
+
     def bbox(self, transformed=True, with_stroke=False):
         image_width, image_height = self.active_image.size
         matrix = self.active_matrix
@@ -212,7 +215,7 @@ class ImageNode(Node):
         """
         self._needs_update = True
         if context is not None:
-            self._processing_message = "Processing..."
+            self.message = "Processing..."
             context.signal("refresh_scene", "Scene")
         if self._update_thread is None:
 
@@ -221,11 +224,9 @@ class ImageNode(Node):
                 self._update_thread = None
                 if context is not None:
                     if self._process_image_failed:
-                        self._processing_message = (
-                            "Process image could not exist in memory."
-                        )
+                        self.message = "Process image could not exist in memory."
                     else:
-                        self._processing_message = None
+                        self.message = None
                     context.signal("refresh_scene", "Scene")
                     context.signal("image_updated", self)
 
@@ -293,10 +294,16 @@ class ImageNode(Node):
             bb = self.bbox()
             self._bounds = bb
             self._paint_bounds = bb
-        except (MemoryError, Image.DecompressionBombError, ValueError):
+        except (
+            MemoryError,
+            Image.DecompressionBombError,
+            ValueError,
+            ZeroDivisionError,
+        ):
             # Memory error if creating requires too much memory.
             # DecompressionBomb if over 272 megapixels.
             # ValueError if bounds are NaN.
+            # ZeroDivide if inverting the processed matrix cannot happen because image is a line
             self._process_image_failed = True
         self.updated()
 
@@ -574,6 +581,20 @@ class ImageNode(Node):
         """
         from PIL import Image, ImageOps
 
+        try:
+            from PIL.Image import Transform
+
+            AFFINE = Transform.AFFINE
+        except ImportError:
+            AFFINE = Image.AFFINE
+
+        try:
+            from PIL.Image import Resampling
+
+            BICUBIC = Resampling.BICUBIC
+        except ImportError:
+            BICUBIC = Image.BICUBIC
+
         image = self.image
 
         transparent_mask = self._get_transparent_mask(image)
@@ -589,6 +610,7 @@ class ImageNode(Node):
         if box is None:
             # If box is entirely white, bbox caused value error, or crop not set.
             box = (0, 0, image.width, image.height)
+        orgbox = (box[0], box[1], box[2], box[3])
 
         transform_matrix = copy(self.matrix)  # Prevent Knock-on effect.
 
@@ -612,6 +634,8 @@ class ImageNode(Node):
         image_height = ceil(bbox[3] * step_scale_y) - floor(bbox[1] * step_scale_y)
         tx = bbox[0]
         ty = bbox[1]
+        # Caveat: we move the picture backward, so that the non-white
+        # image content aligns at 0 , 0 - but we don't crop the image
         transform_matrix.post_translate(-tx, -ty)
         transform_matrix.post_scale(step_scale_x, step_scale_y)
         if step_y < 0:
@@ -640,7 +664,7 @@ class ImageNode(Node):
                 image_width = 1
             image = image.transform(
                 (image_width, image_height),
-                Image.AFFINE,
+                AFFINE,
                 (
                     transform_matrix.a,
                     transform_matrix.c,
@@ -649,21 +673,11 @@ class ImageNode(Node):
                     transform_matrix.d,
                     transform_matrix.f,
                 ),
-                resample=Image.BICUBIC,
+                resample=BICUBIC,
                 fillcolor="black" if self.invert else "white",
             )
         actualized_matrix = Matrix()
 
-        # If crop applies, apply crop.
-        if crop:
-            box = self._get_crop_box(image)
-            if box is not None:
-                width = box[2] - box[0]
-                height = box[3] - box[1]
-                if width != image.width or height != image.height:
-                    image = image.crop(box)
-                    actualized_matrix.post_translate(box[0], box[1])
-
         if step_y < 0:
             # if step_y is negative, translate.
             actualized_matrix.post_translate(0, -image_height)
@@ -671,6 +685,22 @@ class ImageNode(Node):
             # if step_x is negative, translate.
             actualized_matrix.post_translate(-image_width, 0)
 
+        # If crop applies, apply crop.
+        if crop:
+            cbox = self._get_crop_box(image)
+            if cbox is not None:
+                width = cbox[2] - cbox[0]
+                height = cbox[3] - cbox[1]
+                if width != image.width or height != image.height:
+                    image = image.crop(cbox)
+                    # TODO:
+                    # We did not crop the image so far, but we already applied
+                    # the cropped transformation! That may be faulty, and needs to
+                    # be corrected at a later stage, but this logic, even if clumsy
+                    # is good enough: don't shift things twice!
+                    if orgbox[0] == 0 and orgbox[1] == 0:
+                        actualized_matrix.post_translate(cbox[0], cbox[1])
+
         actualized_matrix.post_scale(step_x, step_y)
         actualized_matrix.post_translate(tx, ty)
 

meerk40t/core/node/elem_line.py

@@ -72,6 +72,18 @@ class LineNode(Node, Stroked, FunctionalParameter):
             self.stroke_width_zero()
 
         self.set_dirty_bounds()
+        self.functional_parameter = (
+            "line",
+            0,
+            self.x1,
+            self.y1,
+            0,
+            self.x2,
+            self.y2,
+            0,
+            (self.x1 + self.x2) / 2.0,
+            (self.y1 + self.y2) / 2.0,
+        )
 
     def __copy__(self):
         nd = self.node_dict
@@ -230,3 +242,51 @@ class LineNode(Node, Stroked, FunctionalParameter):
             SVG_VALUE_NON_SCALING_STROKE if not self.stroke_scale else ""
         )
         return path
+
+    @property
+    def functional_parameter(self):
+        return self.mkparam
+
+    @functional_parameter.setter
+    def functional_parameter(self, value):
+        def getit(data, idx, default):
+            if idx < len(data):
+                return data[idx]
+            else:
+                return default
+
+        if isinstance(value, (list, tuple)):
+            self.mkparam = value
+            if self.mkparam:
+                method = self.mkparam[0]
+
+                cx = (self.x1 + self.x2) / 2
+                cy = (self.y1 + self.y2) / 2
+                mx = getit(self.mkparam, 8, cx)
+                my = getit(self.mkparam, 9, cy)
+
+                if self.x1 != self.mkparam[2] or self.y1 != self.mkparam[3]:
+                    # Start changed.
+                    self.x1 = getit(self.mkparam, 2, self.x1)
+                    self.y1 = getit(self.mkparam, 3, self.y1)
+                    self.mkparam[8] = cx
+                    self.mkparam[9] = cy
+                elif self.x2 != self.mkparam[5] or self.y2 != self.mkparam[6]:
+                    # End changed
+                    self.x2 = getit(self.mkparam, 5, self.x2)
+                    self.y2 = getit(self.mkparam, 6, self.y2)
+                    self.mkparam[8] = cx
+                    self.mkparam[9] = cy
+                elif cx != mx or cy != my:
+                    # Midpoint changed.
+                    dx = mx - cx
+                    dy = my - cy
+                    self.x1 += dx
+                    self.y1 += dy
+                    self.x2 += dx
+                    self.y2 += dy
+                    self.mkparam[2] = self.x1
+                    self.mkparam[3] = self.y1
+                    self.mkparam[5] = self.x2
+                    self.mkparam[6] = self.y2
+                self.altered()

meerk40t/core/node/elem_rect.py

@@ -251,12 +251,14 @@ class RectNode(Node, Stroked, FunctionalParameter):
     @property
     def functional_parameter(self):
         dimens = 0.5 * min(self.width, self.height)
+        try:
+            k = min(1.0, self.rx / dimens)
+        except ZeroDivisionError:
+            k = 0.0
         return (
             "rect",
             2,
-            min(1.0, self.rx / dimens),
-            # 2,
-            # min(1.0, self.ry / self.height),
+            k,
         )
 
     @functional_parameter.setter