meerk40t 0.9.7030__py2.py3-none-any.whl → 0.9.7040__py2.py3-none-any.whl

meerk40t/balormk/mock_connection.py

@@ -48,6 +48,7 @@ class MockConnection:
 
     def write(self, index=0, packet=None):
         from meerk40t.balormk.controller import GetSerialNo
+
         packet_length = len(packet)
         assert packet_length == 0xC or packet_length == 0xC00
         if packet is not None:
@@ -88,6 +89,7 @@ class MockConnection:
 
     def _parse_single(self, packet):
         from meerk40t.balormk.controller import single_command_lookup
+
         b0 = packet[1] << 8 | packet[0]
         b1 = packet[3] << 8 | packet[2]
         b2 = packet[5] << 8 | packet[4]
@@ -104,12 +106,11 @@ class MockConnection:
 
         # Convert input to bytes early
         if isinstance(data, str):
-            data = data.encode('ascii')
+            data = data.encode("ascii")
 
         # Create fixed-size response with padding
         self._implied_response = bytearray(8)
-        self._implied_response[:len(data)] = data[:8]
-
+        self._implied_response[: len(data)] = data[:8]
 
     def read(self, index=0):
         if self._implied_response is None:

meerk40t/balormk/usb_connection.py

@@ -232,10 +232,19 @@ class USBConnection:
         except usb.core.NoBackendError as e:
             self.channel(str(e))
             from platform import system
+
             osname = system()
             if osname == "Windows":
-                self.channel(_("Did you install the libusb driver via Zadig (https://zadig.akeo.ie/)?"))
-                self.channel(_("Consult the wiki: https://github.com/meerk40t/meerk40t/wiki/Install%3A-Windows"))
+                self.channel(
+                    _(
+                        "Did you install the libusb driver via Zadig (https://zadig.akeo.ie/)?"
+                    )
+                )
+                self.channel(
+                    _(
+                        "Consult the wiki: https://github.com/meerk40t/meerk40t/wiki/Install%3A-Windows"
+                    )
+                )
             self.channel(_("PyUsb detected no backend LibUSB driver."))
             return -2
         except ConnectionRefusedError:

meerk40t/camera/camera.py

@@ -189,32 +189,33 @@ class Camera(Service):
                 pass
         return actual_width, actual_height
 
-    def _get_capture(self, set_resolution = True):
+    def _get_capture(self, set_resolution=True):
         import platform
+
         # print (self.uri, type(self.uri).__name__)
         if platform.system() == "Windows":
             self.logger("Set DSHOW for Windows")
             cv2.CAP_DSHOW
-            #sets the Windows cv2 backend to DSHOW (Direct Video Input Show)
+            # sets the Windows cv2 backend to DSHOW (Direct Video Input Show)
             cap = cv2.VideoCapture(self.uri)
         elif platform.system() == "Linux":
             self.logger("Set GSTREAMER for Linux")
-            cv2.CAP_GSTREAMER # set the Linux cv2 backend to GTREAMER
-            #cv2.CAP_V4L
+            cv2.CAP_GSTREAMER  # set the Linux cv2 backend to GTREAMER
+            # cv2.CAP_V4L
             cap = cv2.VideoCapture(self.uri)
         else:
             self.logger("Try something for Darwin")
             cap = cv2.VideoCapture(self.uri)
             # For MAC please refer to link below for I/O
-            cap.set(cv2.CAP_FFMPEG, cv2.CAP_AVFOUNDATION) # not sure!
-            #please refer to reference link at bottom of page for more I/O
+            cap.set(cv2.CAP_FFMPEG, cv2.CAP_AVFOUNDATION)  # not sure!
+            # please refer to reference link at bottom of page for more I/O
         if set_resolution:
-            self.logger (f"Try to start camera with {self.width}x{self.height}")
+            self.logger(f"Try to start camera with {self.width}x{self.height}")
             cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.width)
             cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.height)
-            self.logger (
-                f"Capture: {str(self.capture)}\n" +
-                f"Frame resolution set to: ({cap.get(cv2.CAP_PROP_FRAME_WIDTH)}x{cap.get(cv2.CAP_PROP_FRAME_HEIGHT)})"
+            self.logger(
+                f"Capture: {str(self.capture)}\n"
+                + f"Frame resolution set to: ({cap.get(cv2.CAP_PROP_FRAME_WIDTH)}x{cap.get(cv2.CAP_PROP_FRAME_HEIGHT)})"
             )
 
         return cap
@@ -297,14 +298,18 @@ class Camera(Service):
                 actual_height = 0
                 actual_width = 0
                 msg = f"(Fail: {e})"
-            self.logger(f"Tried {width}x{height} ({description}) - received {actual_width}x{actual_height} {msg}")
+            self.logger(
+                f"Tried {width}x{height} ({description}) - received {actual_width}x{actual_height} {msg}"
+            )
             if int(actual_width) == width and int(actual_height) == height:
                 supported_resolutions.append((width, height, description))
-
-        cap.release()
+        try:
+            # Might crash if the camera is not opened
+            cap.release()
+        except cv2.error:
+            pass
         return supported_resolutions
 
-
     def process_frame(self):
         frame = self._current_raw
         if (

meerk40t/camera/gui/camerapanel.py

@@ -947,35 +947,41 @@ class CameraInterface(MWindow):
                         "label": _("Camera {index}").format(index=0),
                         "action": camera_click(0),
                         "signal": "camset0",
+                        "multi_autoexec": True,
                     },
                     {
                         "identifier": "cam1",
                         "label": _("Camera {index}").format(index=1),
                         "action": camera_click(1),
                         "signal": "camset1",
+                        "multi_autoexec": True,
                     },
                     {
                         "identifier": "cam2",
                         "label": _("Camera {index}").format(index=2),
                         "action": camera_click(2),
                         "signal": "camset2",
+                        "multi_autoexec": True,
                     },
                     {
                         "identifier": "cam3",
                         "label": _("Camera {index}").format(index=3),
                         "action": camera_click(3),
                         "signal": "camset3",
+                        "multi_autoexec": True,
                     },
                     {
                         "identifier": "cam4",
                         "label": _("Camera {index}").format(index=4),
                         "action": camera_click(4),
                         "signal": "camset4",
+                        "multi_autoexec": True,
                     },
                     {
                         "identifier": "id_cam",
                         "label": _("Identify cameras"),
                         "action": detect_usb_cameras,
+                        "multi_autoexec": True,
                     },
                 ],
             },

meerk40t/core/cutplan.py

@@ -15,11 +15,12 @@ CutPlan handles the various complicated algorithms to optimising the sequence of
 """
 
 from copy import copy
+from functools import lru_cache
 from math import isinf
 from os import times
 from time import perf_counter, time
 from typing import Optional
-from functools import lru_cache
+
 import numpy as np
 
 from ..svgelements import Group, Matrix, Path, Polygon
@@ -31,7 +32,8 @@ from .cutcode.cutobject import CutObject
 from .cutcode.rastercut import RasterCut
 from .node.node import Node
 from .node.util_console import ConsoleOperation
-from .units import Length, UNITS_PER_MM
+from .units import UNITS_PER_MM, Length
+
 """
 The time to compile does outweigh the benefit...
 try:
@@ -46,6 +48,7 @@ except Exception as e:
         return inner
 """
 
+
 class CutPlanningFailedError(Exception):
     pass
 
@@ -171,7 +174,9 @@ class CutPlan:
         for place in self.plan:
             if not hasattr(place, "type"):
                 continue
-            if place.type.startswith("place ") and (hasattr(place, "output") and place.output):
+            if place.type.startswith("place ") and (
+                hasattr(place, "output") and place.output
+            ):
                 loops = 1
                 if hasattr(place, "loops") and place.loops > 1:
                     loops = place.loops
@@ -225,7 +230,9 @@ class CutPlan:
                                 coolop = ConsoleOperation(command=cmd)
                                 self.plan.append(coolop)
                             else:
-                                self.channel("The current device does not support a coolant method")
+                                self.channel(
+                                    "The current device does not support a coolant method"
+                                )
                         current_cool = cool
                 # Is there already a coolant operation?
                 if getattr(original_op, "type", "") == "util console":
@@ -244,10 +251,16 @@ class CutPlan:
                 op_type = getattr(op, "type", "")
                 if op_type.startswith("place "):
                     continue
-                if op_type == "op cut" and self.context.opt_stitching and self.context.do_optimization:
+                if (
+                    op_type == "op cut"
+                    and self.context.opt_stitching
+                    and self.context.do_optimization
+                ):
                     # This isn't a lossless operation: dotted/dashed lines will be treated as solid lines
                     try:
-                        stitch_tolerance = float(Length(self.context.opt_stitch_tolerance))
+                        stitch_tolerance = float(
+                            Length(self.context.opt_stitch_tolerance)
+                        )
                     except ValueError:
                         stitch_tolerance = 0
                     default_stroke = None
@@ -270,11 +283,15 @@ class CutPlan:
                                 fp2 = g2.first_point
                                 lp1 = g1.last_point
                                 lp2 = g2.last_point
+                                if fp1 is None or fp2 is None:
+                                    continue
+                                if lp1 is None or lp2 is None:
+                                    continue
                                 if (
-                                    abs(lp1 - lp2) <= tolerance or
-                                    abs(lp1 - fp2) <= tolerance or
-                                    abs(fp1 - fp2) <= tolerance or
-                                    abs(fp1 - lp2) <= tolerance 
+                                    abs(lp1 - lp2) <= tolerance
+                                    or abs(lp1 - fp2) <= tolerance
+                                    or abs(fp1 - fp2) <= tolerance
+                                    or abs(fp1 - lp2) <= tolerance
                                 ):
                                     if nodeidx1 not in out:
                                         out.append(nodeidx1)
@@ -282,7 +299,7 @@ class CutPlan:
                                         out.append(nodeidx2)
 
                         return [data[idx] for idx in out]
-                    
+
                     geoms = []
                     to_be_deleted = []
                     data = stitcheable_nodes(list(op.flat()), stitch_tolerance)
@@ -290,11 +307,13 @@ class CutPlan:
                         if node is op:
                             continue
                         if hasattr(node, "as_geometry"):
-                            geom : Geomstr = node.as_geometry()
+                            geom: Geomstr = node.as_geometry()
                             geoms.extend(iter(geom.as_contiguous()))
                             if default_stroke is None and hasattr(node, "stroke"):
                                 default_stroke = node.stroke
-                            if default_strokewidth is None and hasattr(node, "stroke_width"):
+                            if default_strokewidth is None and hasattr(
+                                node, "stroke_width"
+                            ):
                                 default_strokewidth = node.stroke_width
                             to_be_deleted.append(node)
                     result = stitch_geometries(geoms, stitch_tolerance)
@@ -313,7 +332,9 @@ class CutPlan:
                         # print (f"Paths at start of action: {len(list(op.flat()))}")
 
                 self.plan.append(op)
-                if (op_type.startswith("op") or op_type.startswith("util")) and hasattr(op, "preprocess"):
+                if (op_type.startswith("op") or op_type.startswith("util")) and hasattr(
+                    op, "preprocess"
+                ):
                     op.preprocess(self.context, placement, self)
                 if op_type.startswith("op"):
                     for node in op.flat():
@@ -523,11 +544,15 @@ class CutPlan:
         """
         if not isinstance(last_item, CutCode):
             # The last plan item is not cutcode, merge is only between cutobjects adding to cutcode.
-            self.channel (f"last_item is no cutcode ({type(last_item).__name__}), can't merge")
+            self.channel(
+                f"last_item is no cutcode ({type(last_item).__name__}), can't merge"
+            )
             return False
         if not isinstance(current_item, CutObject):
             # The object to be merged is not a cutObject and cannot be added to Cutcode.
-            self.channel (f"current_item is no cutcode ({type(current_item).__name__}), can't merge")
+            self.channel(
+                f"current_item is no cutcode ({type(current_item).__name__}), can't merge"
+            )
             return False
         last_op = last_item.original_op
         if last_op is None:
@@ -536,7 +561,9 @@ class CutPlan:
         if current_op is None:
             current_op = ""
         if last_op.startswith("util") or current_op.startswith("util"):
-            self.channel (f"{last_op} / {current_op} - at least one is a util operation, can't merge")
+            self.channel(
+                f"{last_op} / {current_op} - at least one is a util operation, can't merge"
+            )
             return False
 
         if (
@@ -544,7 +571,9 @@ class CutPlan:
             and last_item.pass_index != current_item.pass_index
         ):
             # Do not merge if opt_merge_passes is off, and pass_index do not match
-            self.channel (f"{last_item.pass_index} / {current_item.pass_index} - pass indices are different, can't merge")
+            self.channel(
+                f"{last_item.pass_index} / {current_item.pass_index} - pass indices are different, can't merge"
+            )
             return False
 
         if (
@@ -553,11 +582,15 @@ class CutPlan:
         ):
             # Do not merge if opt_merge_ops is off, and the original ops do not match
             # Same settings object implies same original operation
-            self.channel (f"Settings do differ from {last_op} to {current_op} and merge ops= {context.opt_merge_ops}")
+            self.channel(
+                f"Settings do differ from {last_op} to {current_op} and merge ops= {context.opt_merge_ops}"
+            )
             return False
         if not context.opt_inner_first and last_item.original_op == "op cut":
             # Do not merge if opt_inner_first is off, and operation was originally a cut.
-            self.channel (f"Inner first {context.opt_inner_first}, last op= {last_item.original_op} - Last op was a cut, can't merge")
+            self.channel(
+                f"Inner first {context.opt_inner_first}, last op= {last_item.original_op} - Last op was a cut, can't merge"
+            )
             return False
         return True  # No reason these should not be merged.
 
@@ -773,7 +806,9 @@ class CutPlan:
             # We don't combine across plan boundaries
             if not isinstance(pitem, CutGroup):
                 continue
-            grouping, to_be_deleted, item_combined, total = process_plan_item(pitem, busy, total, plan_idx, l_plan)
+            grouping, to_be_deleted, item_combined, total = process_plan_item(
+                pitem, busy, total, plan_idx, l_plan
+            )
             combined += item_combined
             group_count += len(grouping)
 
@@ -1164,7 +1199,9 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
                 return False
         return True
 
-    def scanbeam_code_not_working_reliably(outer_cut, outer_path, inner_cut, inner_path):
+    def scanbeam_code_not_working_reliably(
+        outer_cut, outer_path, inner_cut, inner_path
+    ):
         from ..tools.geomstr import Polygon as Gpoly
         from ..tools.geomstr import Scanbeam
 
@@ -1195,24 +1232,25 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
 
             p1x, p1y = poly[0]
             old_sq_dist = sq_length(p1x - x, p1y - y)
-            for i in range(n+1):
+            for i in range(n + 1):
                 p2x, p2y = poly[i % n]
                 new_sq_dist = sq_length(p2x - x, p2y - y)
                 # We are approximating the edge to an extremely thin ellipse and see
                 # whether our point is on that ellipse
                 reldist = (
-                    old_sq_dist + new_sq_dist +
-                    2.0 * np.sqrt(old_sq_dist * new_sq_dist) -
-                    sq_length(p2x - p1x, p2y - p1y)
+                    old_sq_dist
+                    + new_sq_dist
+                    + 2.0 * np.sqrt(old_sq_dist * new_sq_dist)
+                    - sq_length(p2x - p1x, p2y - p1y)
                 )
                 if reldist < tolerance_square:
                     return True
 
-                if y > min(p1y,p2y):
-                    if y <= max(p1y,p2y):
-                        if x <= max(p1x,p2x):
+                if y > min(p1y, p2y):
+                    if y <= max(p1y, p2y):
+                        if x <= max(p1x, p2x):
                             if p1y != p2y:
-                                xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
+                                xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
                             if p1x == p2x or x <= xints:
                                 inside = not inside
                 p1x, p1y = p2x, p2y
@@ -1231,20 +1269,20 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
 
         # Separating Axis Theorem (SAT) for Polygon Containment
 
-        # The Separating Axis Theorem (SAT) is a powerful technique for collision detection 
+        # The Separating Axis Theorem (SAT) is a powerful technique for collision detection
         # between convex polygons. It can also be adapted to determine polygon containment.
 
         # How SAT Works:
 
         # Generate Axes: For each edge of the outer polygon, create a perpendicular axis.
         # Project Polygons: Project both the inner and outer polygons onto each axis.
-        # Check Overlap: If the projections of the inner polygon are completely contained 
-        # within the projections of the outer polygon on all axes, 
+        # Check Overlap: If the projections of the inner polygon are completely contained
+        # within the projections of the outer polygon on all axes,
         # then the inner polygon is fully contained.
-        
-        # Convex Polygons: SAT is most efficient for convex polygons. 
+
+        # Convex Polygons: SAT is most efficient for convex polygons.
         # For concave polygons, you might need to decompose them into convex sub-polygons.
-        # Computational Cost: SAT can be computationally expensive for large numbers of polygons. 
+        # Computational Cost: SAT can be computationally expensive for large numbers of polygons.
         # In such cases, spatial indexing can be used to reduce the number of pairwise comparisons.
         def project_polygon(polygon, axis):
             # Projects a polygon onto a given axis.
@@ -1280,7 +1318,6 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
     """
 
     def raycasting_code_new(outer_polygon, inner_polygon):
-
         def precompute_intersections(polygon):
             slopes = []
             intercepts = []
@@ -1309,9 +1346,13 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
                 slope = slopes[i]
                 intercept = intercepts[i]
                 p1, p2 = polygon[i], polygon[(i + 1) % len(polygon)]
-                
+
                 if np.isnan(slope):  # Vertical line
-                    if x == intercept and y >= min(p1[1], p2[1]) and y <= max(p1[1], p2[1]):
+                    if (
+                        x == intercept
+                        and y >= min(p1[1], p2[1])
+                        and y <= max(p1[1], p2[1])
+                    ):
                         inside = not inside
                 else:
                     if y > min(p1[1], p2[1]):
@@ -1321,17 +1362,21 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
                                     xints = (y - intercept) / slope
                                 if p1[0] == p2[0] or x <= xints:
                                     inside = not inside
-                                
+
             return inside
-                
+
         def is_polygon_inside(outer_polygon, inner_polygon):
             slopes, intercepts, is_vertical = precompute_intersections(outer_polygon)
             for point in inner_polygon:
-                if not point_in_polygon(point[0], point[1], slopes, intercepts, is_vertical, outer_polygon):
+                if not point_in_polygon(
+                    point[0], point[1], slopes, intercepts, is_vertical, outer_polygon
+                ):
                     return False
             return True
 
-        return is_polygon_inside(outer_polygon=outer_polygon, inner_polygon=inner_polygon)
+        return is_polygon_inside(
+            outer_polygon=outer_polygon, inner_polygon=inner_polygon
+        )
 
     def shapely_code(outer_polygon, inner_polygon):
         from shapely.geometry import Polygon
@@ -1341,15 +1386,18 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
         poly_b = Polygon(outer_polygon)
         # Check for containment
         return poly_a.within(poly_b)
-            
+
     @lru_cache(maxsize=128)
     def get_polygon(path, resolution):
         geom = Geomstr.svg(path)
         polygon = np.array(
-            list((p.real, p.imag) for p in geom.as_equal_interpolated_points(distance = resolution))
+            list(
+                (p.real, p.imag)
+                for p in geom.as_equal_interpolated_points(distance=resolution)
+            )
         )
         return polygon
-    
+
     """
     # Testroutines
     from time import perf_counter
@@ -1372,13 +1420,14 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
         t5 = perf_counter()
     except ImportError:
         res4 = "Shapely missing"
-        t5 = t4     
+        t5 = t4
     print (f"Tolerance: {tolerance}, vm={res0} in {t1 - t0:.3f}s, sb={res1} in {t1 - t0:.3f}s, ray-old={res2} in {t2 - t1:.3f}s, ray-new={res3} in {t3 - t2:.3f}s, shapely={res4} in {t4 - t3:.3f}s")
     """
     inner_polygon = get_polygon(inner_path.d(), resolution)
-    outer_polygon = get_polygon(outer_path.d(), resolution)        
+    outer_polygon = get_polygon(outer_path.d(), resolution)
     try:
         import shapely
+
         return shapely_code(outer_polygon, inner_polygon)
     except ImportError:
         return vm_code(outer, outer_polygon, inner, inner_polygon)
@@ -1387,6 +1436,7 @@ def is_inside(inner, outer, tolerance=0, resolution=50):
     # return vm_code(outer, outer_path, inner, inner_path)
     return
 
+
 def reify_matrix(self):
     """Apply the matrix to the path and reset matrix."""
     self.element = abs(self.element)
@@ -1466,13 +1516,15 @@ def inner_first_ident(context: CutGroup, kernel=None, channel=None, tolerance=0)
     if kernel:
         busy = kernel.busyinfo
         _ = kernel.translation
-        min_res = min(kernel.device.view.native_scale_x, kernel.device.view.native_scale_y)
+        min_res = min(
+            kernel.device.view.native_scale_x, kernel.device.view.native_scale_y
+        )
         # a 0.5 mm resolution is enough
         resolution = int(0.5 * UNITS_PER_MM / min_res)
         # print(f"Chosen resolution: {resolution} - minscale = {min_res}")
     else:
         busy = None
-        resolution = 10 
+        resolution = 10
     for outer in closed_groups:
         for inner in groups:
             current_pass += 1
@@ -1695,7 +1747,13 @@ def short_travel_cutcode(
         for idx, c in enumerate(unordered):
             if isinstance(c, CutGroup):
                 c.skip = False
-                unordered[idx] = short_travel_cutcode(context=c, kernel=kernel, complete_path=False, grouped_inner=False, channel=channel)
+                unordered[idx] = short_travel_cutcode(
+                    context=c,
+                    kernel=kernel,
+                    complete_path=False,
+                    grouped_inner=False,
+                    channel=channel,
+                )
     # As these are reversed, we reverse again...
     ordered.extend(reversed(unordered))
     # print (f"And after extension {len(ordered)} items in list")