meerk40t 0.9.7930__py2.py3-none-any.whl → 0.9.7940__py2.py3-none-any.whl

meerk40t/core/bindalias.py

@@ -267,7 +267,7 @@ DEFAULT_ALIAS = {
     "+left": (".timerleft 0 0.1 left 1mm",),
     "+up": (".timerup 0 0.1 up 1mm",),
     "+down": (".timerdown 0 0.1 down 1mm",),
-    "burn": ("planz clear copy preprocess validate blob preopt optimize spool", ),
+    "burn": ("planz clear copy preprocess validate blob preopt optimize spool",),
     "-scale_up": (".timerscale_up off",),
     "-scale_down": (".timerscale_down off",),
     "-rotate_cw": (".timerrotate_cw off",),
@@ -318,7 +318,11 @@ class Bind(Service):
                         key,
                     )
 
-                channel(_("    Key                    Command"))
+                channel(
+                    "    {key} {command}".format(
+                        key=_("Key").ljust(22), command=_("Command")
+                    )
+                )
                 for i, key in enumerate(sorted(self.keymap.keys(), key=keymap_index)):
                     value = self.keymap[key]
                     channel(f"{i:2d}: {key.ljust(22)} {value}")
@@ -445,8 +449,12 @@ class Alias(Service):
             _ = self._
             if alias is None:
                 reverse_keymap = {v: k for k, v in self.bind.keymap.items()}
-                channel(_("Aliases (keybind)`:"))
-                channel(_("    Alias                  Command(s)"))
+                channel(_("Aliases (keybind):"))
+                channel(
+                    "    {key} {value}".format(
+                        key=_("Alias").ljust(22), value=_("Command(s)")
+                    )
+                )
                 last = None
                 i = -1
                 for key in sorted(

meerk40t/core/elements/files.py

@@ -95,7 +95,7 @@ def init_commands(kernel):
         except OSError as e:
             channel(str(e))
 
-    @self.console_command("save_types", help=_("save_types"))
+    @self.console_command("save_types", help=_("save_types - display save types"))
     def file_save_types(command, channel, _, **kwargs):
         for saver, save_name, sname in kernel.find("save"):
             for description, extension, mimetype, version in saver.save_types():

meerk40t/core/elements/shapes.py

@@ -2984,7 +2984,7 @@ def init_commands(kernel):
         with self.undoscope("Create cross"):
             node = self.elem_branch.add(
                 label=_("Cross at ({xp}, {yp})").format(
-                    xp=xpos.length_mm, yp=ypos.length_mm
+                    xp=Length(xpos).length_mm, yp=Length(ypos).length_mm
                 ),
                 geometry=geom,
                 stroke=self.default_stroke,

meerk40t/core/node/effect_hatch.py

@@ -2,8 +2,8 @@ import itertools
 from copy import copy
 from math import sqrt
 
-from meerk40t.core.node.node import Node
 from meerk40t.core.node.mixins import Suppressable
+from meerk40t.core.node.node import Node
 from meerk40t.core.units import Angle, Length
 from meerk40t.svgelements import Color, Point
 from meerk40t.tools.geomstr import Geomstr  # ,  Scanbeam
@@ -179,8 +179,8 @@ class HatchEffectNode(Node, Suppressable):
         factor = sqrt(abs(matrix.determinant))
         self._distance *= factor
         # Let's establish the angle
-        p1:Point = matrix.point_in_matrix_space((0, 0))
-        p2:Point = matrix.point_in_matrix_space((1, 0))
+        p1: Point = matrix.point_in_matrix_space((0, 0))
+        p2: Point = matrix.point_in_matrix_space((1, 0))
         angle = p1.angle_to(p2)
         self._angle -= angle
         # from math import tau
@@ -240,6 +240,8 @@ class HatchEffectNode(Node, Suppressable):
                     subs = right_types(e)
                     res.extend(subs)
                 elif e.type.startswith("elem"):
+                    if hasattr(e, "hidden") and e.hidden:
+                        continue
                     res.append(e)
             return res
 
@@ -301,7 +303,6 @@ class HatchEffectNode(Node, Suppressable):
                     angle=self._angle + p * self._angle_delta,
                 )
 
-
     def set_interim(self):
         self.empty_cache()
         self._interim = True
@@ -315,9 +316,9 @@ class HatchEffectNode(Node, Suppressable):
 
     def can_drop(self, drag_node):
         if (
-            hasattr(drag_node, "as_geometry") or
-            drag_node.type in ("effect", "file", "group", "reference") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            hasattr(drag_node, "as_geometry")
+            or drag_node.type in ("effect", "file", "group", "reference")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
         ):
             return True
         return False

meerk40t/core/node/effect_warp.py

@@ -210,7 +210,6 @@ class WarpEffectNode(Node, FunctionalParameter):
         self.d3 = complex(nn3.x - pp3.x, nn3.y - pp3.y)
         self.d4 = complex(nn4.x - pp4.x, nn4.y - pp4.y)
 
-
     def default_map(self, default_map=None):
         default_map = super().default_map(default_map=default_map)
         default_map["element_type"] = "Warp"
@@ -229,6 +228,8 @@ class WarpEffectNode(Node, FunctionalParameter):
                     subs = right_types(e)
                     res.extend(subs)
                 elif e.type.startswith("elem"):
+                    if hasattr(e, "hidden") and e.hidden:
+                        continue
                     res.append(e)
             return res
 
@@ -297,7 +298,11 @@ class WarpEffectNode(Node, FunctionalParameter):
             self.altered()
 
     def can_drop(self, drag_node):
-        if hasattr(drag_node, "as_geometry") or drag_node.type in ("effect", "file", "group", "reference") or (drag_node.type.startswith("op ") and drag_node.type != "op dots"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or drag_node.type in ("effect", "file", "group", "reference")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+        ):
             return True
         return False
 

meerk40t/core/node/effect_wobble.py

@@ -2,8 +2,8 @@ import math
 from copy import copy
 from math import sqrt
 
-from meerk40t.core.node.node import Node
 from meerk40t.core.node.mixins import Suppressable
+from meerk40t.core.node.node import Node
 from meerk40t.core.units import Length
 from meerk40t.svgelements import Color
 from meerk40t.tools.geomstr import Geomstr  # ,  Scanbeam
@@ -225,6 +225,8 @@ class WobbleEffectNode(Node, Suppressable):
                     subs = right_types(e)
                     res.extend(subs)
                 elif e.type.startswith("elem"):
+                    if hasattr(e, "hidden") and e.hidden:
+                        continue
                     res.append(e)
             return res
 
@@ -384,7 +386,11 @@ class WobbleEffectNode(Node, Suppressable):
         self.altered()
 
     def can_drop(self, drag_node):
-        if hasattr(drag_node, "as_geometry") or drag_node.type in ("effect", "file", "group", "reference") or (drag_node.type.startswith("op ") and drag_node.type != "op dots"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or drag_node.type in ("effect", "file", "group", "reference")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+        ):
             return True
         return False
 

meerk40t/core/node/op_image.py

@@ -21,16 +21,17 @@ Methods:
 """
 from copy import copy
 from math import isnan
+
 from meerk40t.constants import (
-    RASTER_T2B,
     RASTER_B2T,
-    RASTER_R2L,
-    RASTER_L2R,
-    RASTER_HATCH,
+    RASTER_CROSSOVER,
     RASTER_GREEDY_H,
     RASTER_GREEDY_V,
-    RASTER_CROSSOVER,
+    RASTER_HATCH,
+    RASTER_L2R,
+    RASTER_R2L,
     RASTER_SPIRAL,
+    RASTER_T2B,
 )
 from meerk40t.core.cutcode.rastercut import RasterCut
 from meerk40t.core.elements.element_types import *
@@ -67,7 +68,13 @@ class ImageOpNode(Node, Parameters):
         super().__init__(type="op image", **kwargs)
         self._formatter = "{enabled}{pass}{element_type}{direction}{speed}mm/s @{power}"
         # They might come from a svg read, but shouldnt be in settings
-        for attrib in ("lock", "dangerous", "use_grayscale", "consider_laserspot", "overrule_dpi"):
+        for attrib in (
+            "lock",
+            "dangerous",
+            "use_grayscale",
+            "consider_laserspot",
+            "overrule_dpi",
+        ):
             if attrib in self.settings:
                 del self.settings[attrib]
 
@@ -146,7 +153,9 @@ class ImageOpNode(Node, Parameters):
             # Move operation to a different position.
             return True
         elif drag_node.type in ("file", "group"):
-            return not any(e.has_ancestor("branch reg") for e in drag_node.flat(elem_nodes))
+            return not any(
+                e.has_ancestor("branch reg") for e in drag_node.flat(elem_nodes)
+            )
         return False
 
     def drop(self, drag_node, modify=True, flag=False):
@@ -255,8 +264,12 @@ class ImageOpNode(Node, Parameters):
             height_in_inches = (max_y - min_y) / UNITS_PER_INCH
             speed_in_per_s = self.speed / MM_PER_INCH
             if self.raster_direction in (
-                RASTER_T2B, RASTER_B2T, RASTER_HATCH, 
-                RASTER_GREEDY_H, RASTER_CROSSOVER, RASTER_SPIRAL,
+                RASTER_T2B,
+                RASTER_B2T,
+                RASTER_HATCH,
+                RASTER_GREEDY_H,
+                RASTER_CROSSOVER,
+                RASTER_SPIRAL,
             ):
                 scanlines = height_in_inches * dpi
                 if not self.bidirectional:
@@ -268,7 +281,12 @@ class ImageOpNode(Node, Parameters):
                 this_len = scanlines * width_in_inches + height_in_inches
                 estimate += this_len / speed_in_per_s
                 # print (f"Horizontal scanlines: {scanlines}, Length: {this_len:.1f}")
-            if self.raster_direction in (RASTER_L2R, RASTER_R2L, RASTER_HATCH, RASTER_GREEDY_V):
+            if self.raster_direction in (
+                RASTER_L2R,
+                RASTER_R2L,
+                RASTER_HATCH,
+                RASTER_GREEDY_V,
+            ):
                 scanlines = width_in_inches * dpi
                 if not self.bidirectional:
                     scanlines *= 2
@@ -304,7 +322,14 @@ class ImageOpNode(Node, Parameters):
             if self.consider_laserspot:
                 try:
                     laserspot = getattr(context.device, "laserspot", "0.3mm")
-                    spot = 2 * float(Length(laserspot)) / ( context.device.view.native_scale_x + context.device.view.native_scale_y)
+                    spot = (
+                        2
+                        * float(Length(laserspot))
+                        / (
+                            context.device.view.native_scale_x
+                            + context.device.view.native_scale_y
+                        )
+                    )
                     # print (f"Laserpot in device units: {spot:.2f} [{laserspot.length_mm}], scale: {context.device.view.native_scale_x + context.device.view.native_scale_y:.2f}")
                 except (ValueError, AttributeError):
                     spot = 0
@@ -388,9 +413,12 @@ class ImageOpNode(Node, Parameters):
         def call_me(method):
             def handler():
                 method(self)
+
             return handler
 
-        for key, description, method in context.kernel.lookup_all("raster_preprocessor/.*"):
+        for key, description, method in context.kernel.lookup_all(
+            "raster_preprocessor/.*"
+        ):
             if key == self.raster_direction:
                 plan.commands.append(call_me(method))
                 # print (f"Found {description}")
@@ -433,7 +461,13 @@ class ImageOpNode(Node, Parameters):
             start_on_top = self.raster_preference_top
             if direction in (RASTER_GREEDY_V, RASTER_L2R, RASTER_R2L):
                 horizontal = False
-            if direction in (RASTER_B2T, RASTER_T2B, RASTER_HATCH, RASTER_CROSSOVER, RASTER_GREEDY_H):
+            if direction in (
+                RASTER_B2T,
+                RASTER_T2B,
+                RASTER_HATCH,
+                RASTER_CROSSOVER,
+                RASTER_GREEDY_H,
+            ):
                 horizontal = True
             if direction in (RASTER_T2B, RASTER_CROSSOVER):
                 start_on_top = True
@@ -494,7 +528,7 @@ class ImageOpNode(Node, Parameters):
                     gres = 0
                 if gres > 255:
                     gres = 255
-                stepsize = 255 /  gres
+                stepsize = 255 / gres
 
                 # no need for the filter as we have already moved every
                 # pixel during preprocessing to either 255 or 0
@@ -607,27 +641,42 @@ class ImageOpNode(Node, Parameters):
             else:
                 # Create Cut Object for regular image
                 image_filter = None
-                do_optimize = self.raster_direction in (RASTER_GREEDY_H, RASTER_GREEDY_V)
+                do_optimize = self.raster_direction in (
+                    RASTER_GREEDY_H,
+                    RASTER_GREEDY_V,
+                )
                 if do_optimize:
                     # get some image statistics
                     white_pixels = 0
                     used_colors = pil_image.getcolors()
                     for col_count, col in used_colors:
-                        if col==255:
+                        if col == 255:
                             white_pixels = col_count
                             break
-                    white_pixel_ratio = white_pixels / (pil_image.width * pil_image.height)
+                    white_pixel_ratio = white_pixels / (
+                        pil_image.width * pil_image.height
+                    )
                     # print (f"white pixels: {white_pixels}, ratio = {white_pixel_ratio:.3f}")
                     if white_pixel_ratio < 0.3:
-                        self.raster_direction = RASTER_T2B if self.raster_direction == RASTER_GREEDY_H else RASTER_L2R
+                        self.raster_direction = (
+                            RASTER_T2B
+                            if self.raster_direction == RASTER_GREEDY_H
+                            else RASTER_L2R
+                        )
 
-                if self.raster_direction in (RASTER_CROSSOVER, RASTER_SPIRAL): # Crossover - need both
+                if self.raster_direction in (
+                    RASTER_CROSSOVER,
+                    RASTER_SPIRAL,
+                ):  # Crossover - need both
                     settings["raster_step_x"] = step_x
                     settings["raster_step_y"] = step_y
-                if self.raster_direction == RASTER_CROSSOVER and "split_crossover" in self._instructions:
+                if (
+                    self.raster_direction == RASTER_CROSSOVER
+                    and "split_crossover" in self._instructions
+                ):
                     self._instructions["mode_filter"] = "ROW"
-                    horizontal=True
-                    bidirectional=True
+                    horizontal = True
+                    bidirectional = True
                     start_on_top = True
                     start_on_left = True
                     if horizontal:
@@ -666,7 +715,7 @@ class ImageOpNode(Node, Parameters):
                     cutcodes.append(cut)
 
                     # Now set it for the next pass
-                    horizontal=False
+                    horizontal = False
                     if horizontal:
                         # Raster step is only along y for horizontal raster
                         settings["raster_step_x"] = 0
@@ -701,7 +750,7 @@ class ImageOpNode(Node, Parameters):
                 )
                 cut.path = path
                 cut.original_op = self.type
-            cutcodes.append(cut)
+                cutcodes.append(cut)
             if self.raster_direction == RASTER_HATCH:
                 # Create optional crosshatch cut
                 direction = RASTER_L2R if start_on_left else RASTER_R2L
@@ -750,6 +799,11 @@ class ImageOpNode(Node, Parameters):
         self._bounds = None
         if self.output:
             if self._children:
-                self._bounds = Node.union_bounds(self._children, bounds=self._bounds, ignore_locked=False, ignore_hidden=True)
+                self._bounds = Node.union_bounds(
+                    self._children,
+                    bounds=self._bounds,
+                    ignore_locked=False,
+                    ignore_hidden=True,
+                )
             self._bounds_dirty = False
         return self._bounds