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

meerk40t/camera/plugin.py

@@ -15,13 +15,13 @@ def plugin(kernel, lifecycle=None):
         kernel.set_feature("camera")
     if lifecycle == "invalidate":
         try:
-            import cv2
+            import cv2 # pylint: disable=unused-import
         except ImportError:
             print("OpenCV is not installed. Disabling Camera. Install with:")
             print("\tpip install opencv-python-headless")
             return True
         try:
-            import numpy as np
+            import numpy as np # pylint: disable=unused-import
         except ImportError:
             print("Numpy is not installed. Disabling Camera.")
             return True
@@ -32,6 +32,12 @@ def plugin(kernel, lifecycle=None):
         kernel.register("camera-enabled", True)
         _ = kernel.translation
 
+        def get_camera_attribute(camera, attribute, default=None):
+            if isinstance(camera, int):
+                camera = f"camera/{camera}"
+            return kernel.read_persistent(str, camera, attribute, default) or default
+
+
         @kernel.console_option("width", "w", type=int, help="force the camera width")
         @kernel.console_option("height", "h", type=int, help="force the camera height")
         @kernel.console_option(
@@ -100,6 +106,32 @@ def plugin(kernel, lifecycle=None):
                 data.set_uri(uri)
             return "camera", data
 
+        @kernel.console_argument("label", type=str)
+        @kernel.console_command(
+            "label", help="Set camera label", output_type="camera", input_type="camera"
+        )
+        def camera_label(
+            _,
+            channel,
+            data=None,
+            label=None,
+            **kwargs,
+        ):
+            if label is None:
+                channel(_("Current labels:"))
+                for d in kernel.section_startswith("camera/"):
+                    # We read the persistent description instead of the context, 
+                    # as this might not be set.
+                    desc = get_camera_attribute(d, "desc", "No description set")
+                    channel(f"{d}: {desc}")
+            else:
+                data.desc = label
+                kernel.write_persistent(f"camera/{data.uri}", "desc", label)
+                # Alert UI to the change
+                kernel.signal("pane", "/", "")
+                kernel.signal("icon;label", "/", f"cam{data.uri}", label)
+            return "camera", data
+
         @kernel.console_command(
             "info", help="list camera info", output_type="camera", input_type="camera"
         )
@@ -110,9 +142,14 @@ def plugin(kernel, lifecycle=None):
             **kwargs,
         ):
             channel(_("Camera Information:"))
+            channel("Camera-Path\turi\tDescription")
+            channel("----\t---\t-----------")
             for d in kernel.section_startswith("camera/"):
-                context = kernel.get_context(d)
-                channel(f"{d}: {getattr(context, 'uri', '---')}")
+                # context = kernel.get_context(d)
+                # channel(f"{d}: {getattr(context, 'uri', '---')}")
+                camera_uri = get_camera_attribute(d, "uri", "No URI set")
+                camera_lbl = get_camera_attribute(d, "desc", "No description set")
+                channel(f"{d}:\t{camera_uri}\t{camera_lbl}")
             return "camera", data
 
         @kernel.console_command(
@@ -277,7 +314,11 @@ def plugin(kernel, lifecycle=None):
             input_type="camera",
         )
         def list_camera_resolutions(_, channel, data=None, **kwargs):
-            channel(f"Available resolutions for camera #{data.uri}")
+            if data is None:
+                channel(_("No camera selected."))
+                return
+            lbl = f" ({data.desc})" if data.desc  else ""
+            channel(f"Available resolutions for camera #{data.uri}{lbl}")
             info_array = data.guess_supported_resolutions()
             for width, height, description in info_array:
                 channel (f"{width}x{height} - {description}")

meerk40t/core/elements/branches.py

@@ -144,6 +144,7 @@ Functions:
 import re
 from copy import copy
 
+from meerk40t.core.elements.element_types import op_nodes
 from meerk40t.core.node.effect_hatch import HatchEffectNode
 from meerk40t.core.node.op_cut import CutOpNode
 from meerk40t.core.node.op_dots import DotsOpNode
@@ -153,8 +154,9 @@ from meerk40t.core.node.op_raster import RasterOpNode
 from meerk40t.core.units import Angle, Length
 from meerk40t.kernel import CommandSyntaxError
 from meerk40t.svgelements import Color, Matrix
-from meerk40t.core.elements.element_types import op_nodes
 from meerk40t.tools.geomstr import NON_GEOMETRY_TYPES
+
+
 def plugin(kernel, lifecycle=None):
     _ = kernel.translation
     if lifecycle == "postboot":
@@ -576,7 +578,6 @@ def init_commands(kernel):
         self.signal("refresh_scene", "Scene")
         return data_type, data
 
-
     @self.console_command(
         "empty",
         help=_("Remove all elements from provided operations"),
@@ -1336,10 +1337,28 @@ def init_commands(kernel):
     @self.console_command(
         "copy",
         help=_("Duplicate elements"),
-        input_type=("elements", "ops"),
+        input_type=("elements", "ops", None),
         output_type=("elements", "ops"),
     )
-    def e_copy(data=None, data_type=None, post=None, dx=None, dy=None, copies=None, **kwargs):
+    def e_copy(
+        data=None, data_type=None, post=None, dx=None, dy=None, copies=None, **kwargs
+    ):
+        if data_type is None:
+            if data is None:
+                # Take tree selection for ops, scene selection for elements
+                elemlist = list(self.elems(emphasized=True))
+                if elemlist:
+                    data_type = "elements"
+                    data = list(self.elems(emphasized=True))
+                else:
+                    data_type = "ops"
+                    data = list(self.ops(selected=True))
+            else:
+                # If data is given, we assume it is ops or elements
+                if data[0].type.startswith("op ", "util "):
+                    data_type = "ops"
+                else:
+                    data_type = "elements"
         if data is None:
             # Take tree selection for ops, scene selection for elements
             if data_type == "ops":
@@ -1646,19 +1665,44 @@ def init_commands(kernel):
         channel("----------")
         return "elements", data
 
-    @kernel.console_option("stitchtolerance", "s", type=Length, help=_("By default elements will be stitched together if they have common end/start points, this option allows to set a tolerance"))
-    @kernel.console_option("nostitch", "n", type=bool, action="store_true", help=_("By default elements will be stitched together if they have a common end/start point, this option prevents that and real subpaths will be created"))
+    @kernel.console_option(
+        "stitchtolerance",
+        "s",
+        type=Length,
+        help=_(
+            "By default elements will be stitched together if they have common end/start points, this option allows to set a tolerance"
+        ),
+    )
+    @kernel.console_option(
+        "nostitch",
+        "n",
+        type=bool,
+        action="store_true",
+        help=_(
+            "By default elements will be stitched together if they have a common end/start point, this option prevents that and real subpaths will be created"
+        ),
+    )
     @self.console_command(
         "merge",
         help=_("merge elements"),
         input_type="elements",
         output_type="elements",
     )
-    def element_merge(command, channel, _, data=None, post=None, nostitch=None, stitchtolerance=None, **kwargs):
+    def element_merge(
+        command,
+        channel,
+        _,
+        data=None,
+        post=None,
+        nostitch=None,
+        stitchtolerance=None,
+        **kwargs,
+    ):
         """
         Merge combines the geometries of the inputs. This matters in some cases where fills are used. Such that two
         nested circles forms a toroid rather two independent circles.
         """
+
         def set_nonset_attributes(node, e):
             try:
                 if node.stroke is None:
@@ -1681,16 +1725,18 @@ def init_commands(kernel):
                 def segtype(info):
                     return int(info[2].real) & 0xFF
 
-                if segtype(aseg) not in NON_GEOMETRY_TYPES and segtype(bseg) not in NON_GEOMETRY_TYPES:
+                if (
+                    segtype(aseg) not in NON_GEOMETRY_TYPES
+                    and segtype(bseg) not in NON_GEOMETRY_TYPES
+                ):
                     s1, _dummy2, _dummy3, _dummy4, e1 = aseg
                     s2, _dummy2, _dummy3, _dummy4, e2 = bseg
                     c1 = s1 if starta else e1
                     c2 = s2 if startb else e2
-                    if abs(c1 - c2) <= tolerance + 1E-6:
+                    if abs(c1 - c2) <= tolerance + 1e-6:
                         return True
                 return False
 
-
             seg1_start = other.segments[0]
             seg1_end = other.segments[other.index - 1]
             seg2_start = path.segments[0]
@@ -1726,7 +1772,12 @@ def init_commands(kernel):
                 orientation = False
                 path_before = False
                 separate = False
-                to_set_seg, to_set_idx, from_seg, from_idx = path.index - 1, 4, other.index - 1, 4
+                to_set_seg, to_set_idx, from_seg, from_idx = (
+                    path.index - 1,
+                    4,
+                    other.index - 1,
+                    4,
+                )
             else:
                 # ignore, path after other, proper orientation, disjoint
                 separate = True
@@ -1734,8 +1785,15 @@ def init_commands(kernel):
                 path_before = False
                 to_set_seg, to_set_idx, from_seg, from_idx = None, None, None, None
 
-            return separate, orientation, path_before, to_set_seg, to_set_idx, from_seg, from_idx
-
+            return (
+                separate,
+                orientation,
+                path_before,
+                to_set_seg,
+                to_set_idx,
+                from_seg,
+                from_idx,
+            )
 
         if nostitch is None:
             nostitch = False
@@ -1779,16 +1837,26 @@ def init_commands(kernel):
             else:
                 other = node.geometry
 
-                separate, orientation, path_before, to_set_seg, to_set_idx, from_seg, from_idx = merge_paths(other, path, nostitch, tolerance)
+                (
+                    separate,
+                    orientation,
+                    path_before,
+                    to_set_seg,
+                    to_set_idx,
+                    from_seg,
+                    from_idx,
+                ) = merge_paths(other, path, nostitch, tolerance)
                 if to_set_seg is not None:
-                    path.segments[to_set_seg, to_set_idx] = other.segments[from_seg, from_idx]
-                actionstr = 'Insert' if path_before else 'Append'
-                typestr = 'regular' if orientation else 'reversed'
+                    path.segments[to_set_seg, to_set_idx] = other.segments[
+                        from_seg, from_idx
+                    ]
+                actionstr = "Insert" if path_before else "Append"
+                typestr = "regular" if orientation else "reversed"
                 channel(f"{actionstr} a {typestr} path - separate: {separate}")
                 if not orientation:
                     path.reverse()
                 if path_before:
-                    node.geometry.insert(0, path.segments[:path.index])
+                    node.geometry.insert(0, path.segments[: path.index])
                 else:
                     node.geometry.append(path, end=separate)
 
@@ -1815,7 +1883,7 @@ def init_commands(kernel):
             return
         elements_nodes = []
         elems = []
-        groups= []
+        groups = []
         # _("Break elements")
         with self.undoscope("Break elements"):
             for node in data:
@@ -1825,7 +1893,9 @@ def init_commands(kernel):
                     if hasattr(node, attrib):
                         oldval = getattr(node, attrib, None)
                         node_attributes[attrib] = oldval
-                group_node = node.replace_node(type="group", label=node_label, expanded=True)
+                group_node = node.replace_node(
+                    type="group", label=node_label, expanded=True
+                )
                 groups.append(group_node)
                 try:
                     if hasattr(node, "final_geometry"):

meerk40t/core/elements/elements.py

@@ -71,11 +71,11 @@ def plugin(kernel, lifecycle=None):
             placements,
             render,
             shapes,
+            testcases,
             trace,
             tree_commands,
             undo_redo,
             wordlist,
-            testcases,
         )
 
         return [
@@ -218,9 +218,9 @@ def plugin(kernel, lifecycle=None):
                 "default": True,
                 "type": bool,
                 "label": _("Track changes and allow undo"),
-                "tip": _(
-                    "MK will save intermediate states to undo/redo changes") + "\n" +
-                    _("This may consume a significant amount of memory"),
+                "tip": _("MK will save intermediate states to undo/redo changes")
+                + "\n"
+                + _("This may consume a significant amount of memory"),
                 "page": "Start",
                 "section": "_60_Undo",
                 "signals": "restart",
@@ -645,6 +645,7 @@ class Elemental(Service):
         self.remembered_keyhole_nodes = []
         self.setting(bool, "use_undo", True)
         self.setting(int, "undo_levels", 20)
+        self.setting(bool, "filenode_selection", False)
         undo_active = self.use_undo
         undo_levels = self.undo_levels
         self.undo = Undo(self, self._tree, active=undo_active, levels=undo_levels)
@@ -751,7 +752,7 @@ class Elemental(Service):
             self.signal(source)
 
     @contextlib.contextmanager
-    def static(self, source:str):
+    def static(self, source: str):
         try:
             self.stop_updates(source, False)
             yield self
@@ -767,7 +768,7 @@ class Elemental(Service):
             self.do_undo = True
 
     @contextlib.contextmanager
-    def undoscope(self, message:str, static:bool = True):
+    def undoscope(self, message: str, static: bool = True):
         busy = self.kernel.busyinfo
         busy.start(msg=self.kernel.translation(message))
         undo_active = self.do_undo
@@ -903,7 +904,10 @@ class Elemental(Service):
                     child = child.node
                 if getattr(child, "hidden", False):
                     continue
-                if hasattr(child, "affected_children")  and len(child.affected_children()) == 0:
+                if (
+                    hasattr(child, "affected_children")
+                    and len(child.affected_children()) == 0
+                ):
                     continue
                 canburn = True
                 break
@@ -1094,7 +1098,11 @@ class Elemental(Service):
                     for ref in list(n._references):
                         ref.remove_node()
                 op_assign.drop(n, modify=True)
-                if impose == "to_elem" and target_color is not None and hasattr(n, attrib):
+                if (
+                    impose == "to_elem"
+                    and target_color is not None
+                    and hasattr(n, attrib)
+                ):
                     setattr(n, attrib, target_color)
                     if set_fill_to_none and hasattr(n, "fill"):
                         n.fill = None
@@ -2316,10 +2324,11 @@ class Elemental(Service):
         with self.undoscope("Drag and drop"):
             for drag_node in data:
                 to_be_refreshed.extend(drag_node.flat())
-                op_treatment = (
-                    drop_node.type in op_parent_nodes and (
-                        not drag_node.has_ancestor("branch reg") or
-                        (drag_node.has_ancestor("branch reg") and self.allow_reg_to_op_dragging)
+                op_treatment = drop_node.type in op_parent_nodes and (
+                    not drag_node.has_ancestor("branch reg")
+                    or (
+                        drag_node.has_ancestor("branch reg")
+                        and self.allow_reg_to_op_dragging
                     )
                 )
                 if drop_node is drag_node:
@@ -2585,6 +2594,7 @@ class Elemental(Service):
         keep_old_selection=False,
         use_smallest=False,
         exit_over_selection=False,
+        force_filenodes_too=False,
     ):
         def contains(box, x, y=None):
             if y is None:
@@ -2607,6 +2617,8 @@ class Elemental(Service):
             for node in self.elems(emphasized=True):
                 e_list.append(node)
         for node in self.elems_nodes(emphasized=False):
+            if not force_filenodes_too and node.type == "file":
+                continue
             try:
                 bounds = node.bounds
             except AttributeError:
@@ -2614,9 +2626,8 @@ class Elemental(Service):
             if hasattr(node, "hidden") and node.hidden:
                 continue
             # Empty group / files may cause problems
-            if node.type in ("file", "group"):
-                if not node._children:
-                    bounds = None
+            if node.type in ("group", "file") and not node._children:
+                bounds = None
             if bounds is None:
                 continue
             if contains(bounds, position):
@@ -2715,7 +2726,11 @@ class Elemental(Service):
         def _get_next_auto_raster_count(operations):
             auto_raster_count = 0
             for op in operations:
-                if op.type == "op raster" and op.id is not None and op.id.startswith("AR#"):
+                if (
+                    op.type == "op raster"
+                    and op.id is not None
+                    and op.id.startswith("AR#")
+                ):
                     try:
                         used_id = int(op.id[3:])
                         auto_raster_count = max(auto_raster_count, used_id)
@@ -2750,7 +2765,6 @@ class Elemental(Service):
                 debug_set[opnode.type] = 0
             debug_set[opnode.type] = debug_set[opnode.type] + 1
 
-
         if len(list(self.ops())) == 0 and not self.operation_default_empty:
             has_cut = False
             has_engrave = False
@@ -2796,7 +2810,7 @@ class Elemental(Service):
                 continue
             classif_info = [False, False]
             # Even for fuzzy we check first a direct hit
-            fuzzy_param = (False, True) if fuzzy else (False, )
+            fuzzy_param = (False, True) if fuzzy else (False,)
             do_stroke = True
             do_fill = True
             for tempfuzzy in fuzzy_param:
@@ -2854,24 +2868,27 @@ class Elemental(Service):
                     classified = False
                     classifying_op = None
                     if (
-                        self.classify_fill and
-                        op.type=="op raster" and
-                        hasattr(node, "fill") and node.fill is not None
+                        self.classify_fill
+                        and op.type == "op raster"
+                        and hasattr(node, "fill")
+                        and node.fill is not None
                     ):
                         # This is a special use case:
                         # Usually we don't distinguish a fill color - all non-transparent objects
                         # are assigned to a single raster operation.
                         # If the classify_fill flag is set, then we will use the fill attribute
                         # to look for / create a matching raster operation
-                        raster_candidate = _select_raster_candidate(operations, node, fuzzydistance)
+                        raster_candidate = _select_raster_candidate(
+                            operations, node, fuzzydistance
+                        )
                         if raster_candidate is None and self.classify_autogenerate:
                             # We need to create one...
                             auto_raster_count = _get_next_auto_raster_count(operations)
                             raster_candidate = RasterOpNode(
-                                id = f"AR#{auto_raster_count}",
-                                label = f"Auto-Raster #{auto_raster_count}",
-                                color = abs(node.fill),
-                                output = True,
+                                id=f"AR#{auto_raster_count}",
+                                label=f"Auto-Raster #{auto_raster_count}",
+                                color=abs(node.fill),
+                                output=True,
                             )
                             add_op_function(raster_candidate)
                             new_operations_added = True
@@ -2972,14 +2989,16 @@ class Elemental(Service):
                 default_candidates = []
                 for op in operations:
                     if (
-                        hasattr(op, "classify") and
-                        getattr(op, "default", False) and
-                        hasattr(op, "valid_node_for_reference") and
-                        op.valid_node_for_reference(node)
+                        hasattr(op, "classify")
+                        and getattr(op, "default", False)
+                        and hasattr(op, "valid_node_for_reference")
+                        and op.valid_node_for_reference(node)
                     ):
                         default_candidates.append(op)
                 if len(default_candidates) > 1 and debug:
-                    debug(f"For node {node_desc} there were {len(default_candidates)} default operations available, nb the very first will be taken!")
+                    debug(
+                        f"For node {node_desc} there were {len(default_candidates)} default operations available, nb the very first will be taken!"
+                    )
                 for op in default_candidates:
                     classified, should_break, feedback = op.classify(
                         node,
@@ -3097,7 +3116,7 @@ class Elemental(Service):
                     and node.stroke is not None
                     and node.stroke.argb is not None
                 ):
-                    fuzzy_param = (False, True) if fuzzy else (False, )
+                    fuzzy_param = (False, True) if fuzzy else (False,)
                     was_classified = False
                     for tempfuzzy in fuzzy_param:
                         if debug:
@@ -3179,7 +3198,7 @@ class Elemental(Service):
                             "white"
                         ) == abs(node.fill)
                     node_fill = Color("black") if is_black else abs(node.fill)
-                    fuzzy_param = (False, True) if fuzzy else (False, )
+                    fuzzy_param = (False, True) if fuzzy else (False,)
                     was_classified = False
                     for tempfuzzy in fuzzy_param:
                         if debug:
@@ -3215,14 +3234,18 @@ class Elemental(Service):
                     and node.fill is not None
                     and node.fill.argb is not None
                 ):
-                    default_color = abs(node.fill) if self.classify_fill else Color("black")
+                    default_color = (
+                        abs(node.fill) if self.classify_fill else Color("black")
+                    )
                     default_id = "AR#1" if self.classify_fill else "R1"
-                    default_label = "Auto-Raster #1" if self.classify_fill else "Standard-Raster"
+                    default_label = (
+                        "Auto-Raster #1" if self.classify_fill else "Standard-Raster"
+                    )
                     op = RasterOpNode(
                         id=default_id,
                         label=default_label,
                         color=default_color,
-                        output = True,
+                        output=True,
                     )
                     stdops.append(op)
                     if debug:
@@ -3291,7 +3314,6 @@ class Elemental(Service):
                         op.add_reference(node)
                         update_debug_set(debug_set, op)
 
-
         self.remove_unused_default_copies()
         if debug:
             debug("Summary:")

meerk40t/core/elements/trace.py

@@ -31,6 +31,7 @@ from meerk40t.core.units import Length
 from meerk40t.svgelements import Circle, Path, Point, Polyline
 from meerk40t.tools.geomstr import Geomstr
 
+
 def plugin(kernel, lifecycle=None):
     _ = kernel.translation
     if lifecycle == "postboot":
@@ -317,6 +318,7 @@ def generate_hull_shape_hull(data):
         pts.append(pts[0])  # loop
     return pts
 
+
 """
 There is no need for shape_complex any more as the regular hull routine already uses interpolation
 def generate_hull_shape_complex(data, resolution=None):
@@ -356,6 +358,7 @@ def generate_hull_shape_complex(data, resolution=None):
     return hull
 """
 
+
 def generate_hull_shape_circle_data(data):
     pts = []
     for node in data:
@@ -476,9 +479,7 @@ def init_commands(kernel):
         method = method.lower()
         if method not in ("segment", "quick", "hull", "circle"):
             channel(
-                _(
-                    "Invalid method, please use one of quick, hull, segment, circle."
-                )
+                _("Invalid method, please use one of quick, hull, segment, circle.")
             )
             return
 
@@ -553,6 +554,9 @@ def init_commands(kernel):
                     # Wait for some seconds
                     yield "wait", 5000
 
+                if hasattr(_spooler.context, "pre_outline"):
+                    yield from _spooler.context.pre_outline()
+
                 yield "wait_finish"
                 yield "rapid_mode"
                 idx = 0
@@ -563,6 +567,8 @@ def init_commands(kernel):
                         Length(amount=p[0]).length_mm,
                         Length(amount=p[1]).length_mm,
                     )
+                if hasattr(_spooler.context, "post_outline"):
+                    yield from _spooler.context.post_outline()
 
             _spooler.laserjob(
                 list(trace_hull(startmethod)), label=f"Trace Job: {method}", helper=True
@@ -598,9 +604,7 @@ def init_commands(kernel):
         method = method.lower()
         if not method in ("segment", "quick", "hull", "circle"):
             channel(
-                _(
-                    "Invalid method, please use one of quick, hull, segment, circle."
-                )
+                _("Invalid method, please use one of quick, hull, segment, circle.")
             )
             return
 

meerk40t/core/node/node.py

@@ -1282,6 +1282,8 @@ class Node:
         if keep_children is None:
             keep_children = False
         parent = self._parent
+        if parent is None:
+            raise ValueError(f"Cannot replace {self.type}-node without parent.")
         index = parent._children.index(self)
         parent._children.remove(self)
         self.notify_detached(self)

meerk40t/core/plotplanner.py

@@ -47,7 +47,7 @@ class PlotPlanner(Parameters):
         ppi=True,
         shift=True,
         group=True,
-        require_uniform_movement = True,
+        require_uniform_movement=True,
         **kwargs,
     ):
         super().__init__(settings, **kwargs)
@@ -69,17 +69,21 @@ class PlotPlanner(Parameters):
 
         if single:
             self.single = Single(self)
-        if ppi:
-            self.ppi = PPI(self)
         if shift:
             self.shift = Shift(self)
         if group:
             self.group = Group(self)
+        self.set_ppi(ppi)
 
         self.pos_x = None
         self.pos_y = None
         self.settings_then_jog = False
 
+    def set_ppi(self, ppi):
+        self.ppi = None
+        if ppi:
+            self.ppi = PPI(self)
+
     def push(self, plot):
         self.abort = False
         self.queue.append(plot)
@@ -653,4 +657,3 @@ def grouped(plot):
         group_y = y
     # There are no more plots.
     yield group_x, group_y
-