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

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

meerk40t/core/spoolers.py

@@ -370,7 +370,7 @@ class SpoolerJob:
 
         @return:
         """
-        if self.is_running:
+        if self.is_running():
             return "Running"
         else:
             return "Queued"

meerk40t/core/units.py

@@ -106,7 +106,9 @@ class Length:
         unitless=1.0,
         preferred_units=None,
         digits=None,
+        settings=None,
     ):
+        self.settings = settings if settings is not None else {}
         self._digits = digits
         self._amount = amount
         if relative_length:
@@ -121,6 +123,8 @@ class Length:
             else:
                 raise ValueError("Arguments not acceptable")
             s = str(value)
+            if s in self.settings:
+                s = str(self.settings[s])
             match = REGEX_LENGTH.match(s)
             if not match:
                 raise ValueError(f"Length was not parsable: '{s}'.")

meerk40t/grbl/emulator.py

@@ -368,6 +368,15 @@ class GRBLEmulator:
             else:
                 self._buffer.append(chr(c))
 
+    def _home_device(self):
+        if hasattr(self.device.driver, "physical_home"):
+            # If the driver has a physical home, we can use that.
+            self.device.driver.physical_home()
+        elif hasattr(self.device.driver, "home"):
+            self.device.driver.home()
+        else:
+            self.device.driver.move_abs(0, 0)
+
     def _grbl_special(self, data):
         """
         GRBL special commands are commands beginning with $ that do purely grbl specific things.
@@ -458,14 +467,7 @@ class GRBLEmulator:
         elif data == "$H":
             if not self.settings["homing_cycle_enable"]:
                 return 5  # Homing cycle not enabled by settings.
-            try:
-                self.device.driver.physical_home()
-            except AttributeError:
-                pass
-            try:
-                self.device.driver.move_abs(0, 0)
-            except AttributeError:
-                pass
+            self._home_device()
             return 0
         elif data.startswith("$J="):
             """

meerk40t/grbl/gcodejob.py

@@ -574,8 +574,10 @@ class GcodeJob:
                     # Numeric value format is not valid or missing an expected value.
                     return ERROR_NUMERIC_VALUE_INVALID
                 if 0.0 < v <= 1.0:
-                    v *= 1000  # numbers between 0-1 are taken to be in range 0-1.
+                    v *= 1000  # numbers between 0-1 are taken to be in range 0-1000.
                 if self.power != v:
+                    # print(f"Setting power to {v}")
+                    self.plot_commit()  # Power change means plot change
                     try:
                         self._driver.set("power", v)
                     except AttributeError:
@@ -707,12 +709,18 @@ class GcodeJob:
         if power is None:
             power = 1000
         power = min(1000, power)
+        # print (f"Plotting location: ({x}, {y}) with power {power} (self.power={self.power})")
         if self.plotcut is None:
             ox, oy = matrix.transform_point([self.x, self.y])
-            self.plotcut = PlotCut(settings={"speed": self.speed})
+            p = power if power else self.power
+            if p is None:
+                p = 1000
+            settings = {"speed": self.speed, "power": p}
+            self.plotcut = PlotCut(settings=settings)
             self.plotcut.plot_init(int(round(ox)), int(round(oy)))
         tx, ty = matrix.transform_point([x, y])
-        self.plotcut.plot_append(int(round(tx)), int(round(ty)), (power / 1000.0))
+        on = power / self.power if self.power else 0
+        self.plotcut.plot_append(int(round(tx)), int(round(ty)), on)
         if not self.program_mode:
             self.plot_commit()
         self.x = x

meerk40t/grbl/plugin.py

@@ -175,7 +175,9 @@ def plugin(kernel, lifecycle=None):
             {
                 "provider": "provider/device/grbl",
                 "friendly_name": _("Longer Ray5 (GRBL)"),
-                "extended_info": _("Longer-branded 5w/10w/20w grbl diode laser.\nMake sure you verify your bed size! This machine has several upgrade kits."),
+                "extended_info": _(
+                    "Longer-branded 5w/10w/20w grbl diode laser.\nMake sure you verify your bed size! This machine has several upgrade kits."
+                ),
                 "priority": 21,
                 "family": _("Longer Diode-Laser"),
                 "choices": [
@@ -229,9 +231,13 @@ def plugin(kernel, lifecycle=None):
             hidden=True,
         )
         def grblserver(
+            command,
+            channel,
+            _,
             port=23,
             verbose=False,
             quit=False,
+            remainder=None,
             **kwargs,
         ):
             """
@@ -239,10 +245,13 @@ def plugin(kernel, lifecycle=None):
             this emulates a grbl devices in order to be compatible with software that
             controls that type of device.
             """
+            if remainder and remainder.lower() in ("stop", "quit"):
+                quit = True
             root = kernel.root
             grblcontrol = root.device.lookup("grblcontrol")
             if grblcontrol is None:
                 if quit:
+                    channel(_("No control instance to stop."))
                     return
                 grblcontrol = GRBLControl(root)
                 root.device.register("grblcontrol", grblcontrol)