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

meerk40t/core/elements/shapes.py

@@ -66,7 +66,7 @@ from meerk40t.svgelements import (
     Polygon,
     Polyline,
 )
-from meerk40t.tools.geomstr import Geomstr, stitch_geometries
+from meerk40t.tools.geomstr import Geomstr, stitch_geometries, stitcheable_nodes
 
 
 def plugin(kernel, lifecycle=None):
@@ -181,12 +181,18 @@ def init_commands(kernel):
     @self.console_argument("x_pos", type=Length, help=_("X-coordinate of center"))
     @self.console_argument("y_pos", type=Length, help=_("Y-coordinate of center"))
     @self.console_argument("rx", type=Length, help=_("Primary radius of ellipse"))
-    @self.console_argument("ry", type=Length, help=_("Secondary radius of ellipse (default equal to primary radius=circle)"))
-    @self.console_argument("start_angle", type=Angle, help=_("Start angle of arc (default 0°)"))
-    @self.console_argument("end_angle", type=Angle, help=_("End angle of arc (default 360°)"))
-    @self.console_option(
-        "rotation", "r", type=Angle, help=_("Rotation of arc")
+    @self.console_argument(
+        "ry",
+        type=Length,
+        help=_("Secondary radius of ellipse (default equal to primary radius=circle)"),
+    )
+    @self.console_argument(
+        "start_angle", type=Angle, help=_("Start angle of arc (default 0°)")
     )
+    @self.console_argument(
+        "end_angle", type=Angle, help=_("End angle of arc (default 360°)")
+    )
+    @self.console_option("rotation", "r", type=Angle, help=_("Rotation of arc"))
     @self.console_command(
         "arc",
         help=_("arc <cx> <cy> <rx> <ry> <start> <end>"),
@@ -195,7 +201,18 @@ def init_commands(kernel):
         all_arguments_required=True,
     )
     def element_arc(
-        channel, _, x_pos, y_pos, rx, ry=None, start_angle=None, end_angle=None, rotation=None, data=None, post=None, **kwargs
+        channel,
+        _,
+        x_pos,
+        y_pos,
+        rx,
+        ry=None,
+        start_angle=None,
+        end_angle=None,
+        rotation=None,
+        data=None,
+        post=None,
+        **kwargs,
     ):
         if start_angle is None:
             start_angle = Angle("0deg")
@@ -211,7 +228,7 @@ def init_commands(kernel):
         cy = float(y_pos)
         geom = Geomstr()
         geom.arc_as_cubics(
-            start_t=start_angle.radians, 
+            start_t=start_angle.radians,
             end_t=end_angle.radians,
             rx=rx_val,
             ry=ry_val,
@@ -656,7 +673,83 @@ def init_commands(kernel):
                 height=500,
             )
         except Exception:
-            pass # Not relevant...
+            pass  # Not relevant...
+
+    @self.console_argument("prop", type=str, help=_("property to get"))
+    @self.console_command(
+        "property-get",
+        help=_("get property value"),
+        input_type=(
+            None,
+            "elements",
+        ),
+        output_type="elements",
+    )
+    def element_property_get(command, channel, _, data, post=None, prop=None, **kwargs):
+        def possible_representation(node, prop) -> str:
+            def simple_rep(prop, value):
+                if isinstance(value, (float, int)) and prop in (
+                    "x",
+                    "y",
+                    "cx",
+                    "cy",
+                    "r",
+                    "rx",
+                    "ry",
+                ):
+                    try:
+                        s = Length(value).length_mm
+                        return s
+                    except ValueError:
+                        pass
+                elif isinstance(value, Length):
+                    return value.length_mm
+                elif isinstance(value, Angle):
+                    return value.angle_degrees
+                elif isinstance(value, str):
+                    return f"'{value}'"
+                return repr(value)
+
+            value = getattr(node, prop, None)
+            if isinstance(value, (str, float, int)):
+                return simple_rep(prop, value)
+            elif isinstance(value, (tuple, list)):
+                stuff = []
+                for v in value:
+                    stuff.append(simple_rep("x", v))
+                return ",".join(stuff)
+            return simple_rep(prop, value)
+
+        if data is None:
+            data = list(self.elems(emphasized=True))
+        if len(data) == 0:
+            channel(_("No selected elements."))
+            return
+        if prop is None or (prop == "?"):
+            channel(_("You need to provide the property to get."))
+            identified = []
+            for op in data:
+                if op.type in identified:
+                    continue
+                identified.append(op.type)
+                prop_str = f"{op.type} has the following properties:"
+                first = True
+                for d in op.__dict__:
+                    if d.startswith("_"):
+                        continue
+                    prop_str = f"{prop_str}{'' if first else ','} {d}"
+                    first = False
+                channel(prop_str)
+            return
+        for d in data:
+            if not hasattr(d, prop):
+                channel(
+                    f"Node: {d.display_label()} (Type: {d.type}) has no property called '{prop}'"
+                )
+            else:
+                channel(
+                    f"Node: {d.display_label()} (Type: {d.type}): {prop}={getattr(d, prop, '')} ({possible_representation(d, prop)})"
+                )
 
     @self.console_argument("prop", type=str, help=_("property to set"))
     @self.console_argument("new_value", type=str, help=_("new property value"))
@@ -681,7 +774,7 @@ def init_commands(kernel):
         if len(data) == 0:
             channel(_("No selected elements."))
             return
-        if prop is None or (prop == "?" and new_value=="?"):
+        if prop is None or (prop == "?" and new_value == "?"):
             channel(_("You need to provide the property to set."))
             if prop == "?":
                 identified = []
@@ -689,13 +782,17 @@ def init_commands(kernel):
                     if op.type in identified:
                         continue
                     identified.append(op.type)
-                    prop_str = f"{op.type} has the following properties: "
+                    prop_str = f"{op.type} has the following properties:"
+                    first = True
                     for d in op.__dict__:
                         if d.startswith("_"):
                             continue
-                        prop_str = f"{prop_str}, {d}"
+                        prop_str = f"{prop_str}{'' if first else ','} {d}"
+                        first = False
                     channel(prop_str)
-                channel ("Be careful what you do - this is a failsafe method to crash MeerK40t, burn down your house or whatever...")
+                channel(
+                    "Be careful what you do - this is a failsafe method to crash MeerK40t, burn down your house or whatever..."
+                )
             return
         classify_required = False
         prop = prop.lower()
@@ -769,7 +866,9 @@ def init_commands(kernel):
                     if prop in ("x", "y"):
                         if not e.can_move(self.lock_allows_move):
                             channel(
-                                _("Element can not be moved: {name}").format(name=str(e))
+                                _("Element can not be moved: {name}").format(
+                                    name=str(e)
+                                )
                             )
                             continue
                         # We need to adjust the matrix
@@ -795,7 +894,9 @@ def init_commands(kernel):
                             continue
                         if hasattr(e, "can_scale") and not e.can_scale:
                             channel(
-                                _("Element can not be scaled: {name}").format(name=str(e))
+                                _("Element can not be scaled: {name}").format(
+                                    name=str(e)
+                                )
                             )
                             continue
                         if hasattr(e, "matrix") and hasattr(e, "bounds"):
@@ -865,7 +966,9 @@ def init_commands(kernel):
                                 delattr(e, "wxfont")
                                 text_elems.append(e)
                         if prop in ("mktext", "mkfont"):
-                            for property_op in self.kernel.lookup_all("path_updater/.*"):
+                            for property_op in self.kernel.lookup_all(
+                                "path_updater/.*"
+                            ):
                                 property_op(self.kernel.root, e)
                         if prop in (
                             "dpi",
@@ -935,7 +1038,7 @@ def init_commands(kernel):
         if not data:
             channel(_("No selected operations."))
             return
-        if prop is None or (prop == "?" and new_value=="?"):
+        if prop is None or (prop == "?" and new_value == "?"):
             channel(_("You need to provide the property to set."))
             if prop == "?":
                 identified = []
@@ -949,7 +1052,9 @@ def init_commands(kernel):
                             continue
                         prop_str = f"{prop_str}, {d}"
                     channel(prop_str)
-                channel ("Be careful what you do - this is a failsafe method to crash MeerK40t, burn down your house or whatever...")
+                channel(
+                    "Be careful what you do - this is a failsafe method to crash MeerK40t, burn down your house or whatever..."
+                )
             return
         prop = prop.lower()
         if len(new_value) == 0:
@@ -982,7 +1087,6 @@ def init_commands(kernel):
             new_value = testval
             prevalidated = True
 
-
         changed = []
         # _("Update property")
         with self.undoscope("Update property"):
@@ -1030,7 +1134,6 @@ def init_commands(kernel):
                             ).format(val=new_value, field=prop, oldval=oldval)
                         )
 
-
                 else:
                     channel(
                         _("Operation {name} has no property {field}").format(
@@ -1122,7 +1225,7 @@ def init_commands(kernel):
                         f"Simplified {node.type} ({node.display_label()}), tolerance: {tolerance}={Length(tolerance, digits=4).length_mm})"
                     )
                     if seg_before:
-                        saving = f"({(seg_before - seg_after)/seg_before*100:.1f}%)"
+                        saving = f"({(seg_before - seg_after) / seg_before * 100:.1f}%)"
                     else:
                         saving = ""
                     channel(f"Subpaths before: {sub_before} to {sub_after}")
@@ -1363,7 +1466,9 @@ def init_commands(kernel):
         with self.undoscope("Set stroke-width"):
             for e in data:
                 if hasattr(e, "lock") and e.lock:
-                    channel(_("Can't modify a locked element: {name}").format(name=str(e)))
+                    channel(
+                        _("Can't modify a locked element: {name}").format(name=str(e))
+                    )
                     continue
                 e.stroke_width = stroke_width
                 try:
@@ -1396,7 +1501,9 @@ def init_commands(kernel):
         with self.undoscope("Update stroke-scale"):
             for e in data:
                 if hasattr(e, "lock") and e.lock:
-                    channel(_("Can't modify a locked element: {name}").format(name=str(e)))
+                    channel(
+                        _("Can't modify a locked element: {name}").format(name=str(e))
+                    )
                     continue
                 e.stroke_scaled = command == "enable_stroke_scale"
                 e.altered()
@@ -1700,7 +1807,9 @@ def init_commands(kernel):
                 for e in apply:
                     if hasattr(e, "lock") and e.lock:
                         channel(
-                            _("Can't modify a locked element: {name}").format(name=str(e))
+                            _("Can't modify a locked element: {name}").format(
+                                name=str(e)
+                            )
                         )
                         continue
                     e.stroke = None
@@ -1712,7 +1821,9 @@ def init_commands(kernel):
                 for e in apply:
                     if hasattr(e, "lock") and e.lock:
                         channel(
-                            _("Can't modify a locked element: {name}").format(name=str(e))
+                            _("Can't modify a locked element: {name}").format(
+                                name=str(e)
+                            )
                         )
                         continue
                     e.stroke = Color(color)
@@ -1803,13 +1914,14 @@ def init_commands(kernel):
             return "elements", data
         # _("Set fill")
         with self.undoscope("Set fill"):
-
             if color == "none":
                 self.set_start_time("fill")
                 for e in apply:
                     if hasattr(e, "lock") and e.lock:
                         channel(
-                            _("Can't modify a locked element: {name}").format(name=str(e))
+                            _("Can't modify a locked element: {name}").format(
+                                name=str(e)
+                            )
                         )
                         continue
                     e.fill = None
@@ -1821,7 +1933,9 @@ def init_commands(kernel):
                 for e in apply:
                     if hasattr(e, "lock") and e.lock:
                         channel(
-                            _("Can't modify a locked element: {name}").format(name=str(e))
+                            _("Can't modify a locked element: {name}").format(
+                                name=str(e)
+                            )
                         )
                         continue
                     e.fill = Color(color)
@@ -2626,15 +2740,26 @@ def init_commands(kernel):
                 self.first_emphasized = None
         return "elements", data
 
-    @self.console_argument("tolerance", type=str, help=_("Tolerance to stitch paths together"))
-    @self.console_option("keep", "k", type=bool, action="store_true", default=False, help=_("Keep original paths"))
+    @self.console_argument(
+        "tolerance", type=str, help=_("Tolerance to stitch paths together")
+    )
+    @self.console_option(
+        "keep",
+        "k",
+        type=bool,
+        action="store_true",
+        default=False,
+        help=_("Keep original paths"),
+    )
     @self.console_command(
         "stitch",
         help=_("stitch selected elements"),
         input_type=(None, "elements"),
         output_type="elements",
     )
-    def stitched(command, channel, _, data=None, tolerance=None, keep=None, post=None, **kwargs):
+    def stitched(
+        command, channel, _, data=None, tolerance=None, keep=None, post=None, **kwargs
+    ):
         def _prepare_stitching_params(channel, data, tolerance, keep):
             if data is None:
                 data = list(self.elems(emphasized=True))
@@ -2652,38 +2777,10 @@ def init_commands(kernel):
                     channel(f"Invalid tolerance value: {tolerance}")
                     return data, tolerance, keep, False
             return data, tolerance_val, keep, True
-        
-        def stitcheable_nodes(data, tolerance) -> list:
-            out = []
-            geoms = []
-            # Store all geometries together with an indicator, to which node they belong
-            for idx, node in enumerate(data):
-                if not hasattr(node, "as_geometry"):
-                    continue
-                for g1 in node.as_geometry().as_contiguous():
-                    geoms.append((idx, g1))
-            for idx1, (nodeidx1, g1) in enumerate(geoms):
-                for idx2 in range(idx1 + 1, len(geoms)):
-                    nodeidx2 = geoms[idx2][0]
-                    g2 = geoms[idx2][1]
-                    fp1 = g1.first_point
-                    fp2 = g2.first_point
-                    lp1 = g1.last_point
-                    lp2 = g2.last_point
-                    if (
-                        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)
-                        if nodeidx2 not in out:
-                            out.append(nodeidx2)
-
-            return [data[idx] for idx in out]
-
-        data, tolerance, keep, valid = _prepare_stitching_params(channel, data, tolerance, keep)
+
+        data, tolerance, keep, valid = _prepare_stitching_params(
+            channel, data, tolerance, keep
+        )
         if not valid:
             return
         s_data = stitcheable_nodes(data, tolerance)
@@ -2700,13 +2797,12 @@ def init_commands(kernel):
             default_strokewidth = None
             default_fill = None
             for node in s_data:
-                if hasattr(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"):
-                        default_strokewidth = node.stroke_width
+                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"):
+                    default_strokewidth = node.stroke_width
                 to_be_deleted.append(node)
             prev_len = len(geoms)
             if geoms:
@@ -2728,10 +2824,101 @@ def init_commands(kernel):
                     )
                     data_out.append(node)
             new_len = len(data_out)
-            channel(f"Sub-Paths before: {prev_len} -> consolidated to {new_len} sub-paths")
-        
+            channel(
+                f"Sub-Paths before: {prev_len} -> consolidated to {new_len} sub-paths"
+            )
+
         post.append(classify_new(data_out))
         self.set_emphasis(data_out)
         return "elements", data_out
 
+    @self.console_argument("xpos", type=Length, help=_("X-Position of cross center"))
+    @self.console_argument("ypos", type=Length, help=_("Y-Position of cross center"))
+    @self.console_argument("diameter", type=Length, help=_("Diameter of cross"))
+    @self.console_option(
+        "circle",
+        "c",
+        type=bool,
+        action="store_true",
+        default=False,
+        help=_("Draw a circle around cross"),
+    )
+    @self.console_option(
+        "diagonal",
+        "d",
+        type=bool,
+        action="store_true",
+        default=False,
+        help=_("Draw the cross diagonally"),
+    )
+    @self.console_command(
+        "cross",
+        help=_("Create a small cross at the given position"),
+        input_type=None,
+        output_type="elements",
+    )
+    def cross(
+        command,
+        channel,
+        _,
+        data=None,
+        xpos=None,
+        ypos=None,
+        diameter=None,
+        circle=None,
+        diagonal=None,
+        post=None,
+        **kwargs,
+    ):
+        if xpos is None or ypos is None or diameter is None:
+            channel(_("You need to provide center-point and diameter: cross x y d"))
+            return
+        try:
+            xp = float(xpos)
+            yp = float(ypos)
+            dia = float(diameter)
+        except ValueError:
+            channel(_("Invalid values given"))
+            return
+        if circle is None:
+            circle = False
+        if diagonal is None:
+            diagonal = False
+        geom = Geomstr()
+        if diagonal:
+            sincos45 = dia / 2 * sqrt(2) / 2
+            geom.line(
+                complex(xp - sincos45, yp - sincos45),
+                complex(xp + sincos45, yp + sincos45),
+            )
+            geom.line(
+                complex(xp + sincos45, yp - sincos45),
+                complex(xp - sincos45, yp + sincos45),
+            )
+        else:
+            geom.line(complex(xp - dia / 2, yp), complex(xp + dia / 2, yp))
+            geom.line(complex(xp, yp - dia / 2), complex(xp, yp + dia / 2))
+        if circle:
+            geom.append(Geomstr.circle(dia / 2, xp, yp))
+        # _("Create cross") - hint for translator
+        with self.undoscope("Create cross"):
+            node = self.elem_branch.add(
+                label=_("Cross at ({xp}, {yp})").format(
+                    xp=xpos.length_mm, yp=ypos.length_mm
+                ),
+                geometry=geom,
+                stroke=self.default_stroke,
+                stroke_width=self.default_strokewidth,
+                fill=None,
+                type="elem path",
+            )
+            if data is None:
+                data = []
+            data.append(node)
+
+            # Newly created! Classification needed?
+            post.append(classify_new(data))
+        self.signal("refresh_scene", "Scene")
+        return "elements", data
+
     # --------------------------- END COMMANDS ------------------------------

meerk40t/core/elements/tree_commands.py

@@ -2,7 +2,6 @@
 This is a giant list of console commands that deal with and often implement the elements system in the program.
 """
 
-
 from meerk40t.kernel import CommandSyntaxError
 
 from .element_types import *
@@ -39,9 +38,10 @@ def init_commands(kernel):
             for i, n in enumerate(node.children):
                 p = list(path)
                 p.append(str(i))
-                channel(
-                    f"{'.'.join(p).ljust(10)}: {str(n._bounds)} - {str(n._bounds_dirty)} {str(n.type)} - {str(str(n)[:16])}"
-                )
+                if hasattr(n, "_bounds"):
+                    channel(
+                        f"{'.'.join(p).ljust(10)}: {str(n._bounds)} - {str(n._bounds_dirty)} {str(n.type)} - {str(str(n)[:16])}"
+                    )
                 b_list(p, n)
 
         for d in data:
@@ -49,7 +49,12 @@ def init_commands(kernel):
             if d.type == "root":
                 channel(_("Tree:"))
             else:
-                channel(f"{str(d)}:")
+                if hasattr(d, "_bounds"):
+                    channel(
+                        f"{str(d)}: {str(d._bounds)} - {str(d._bounds_dirty)} {str(d.type)} - {str(str(d)[:16])}"
+                    )
+                else:
+                    channel(f"{str(d)}:")
             b_list([], d)
             channel("----------")
 

meerk40t/core/node/blobnode.py

@@ -41,8 +41,15 @@ class BlobNode(Node):
         return False
 
     @staticmethod
-    def hex_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+    def hex_view(data, data_type, info=''):
+        """
+        Render a hex dump with an optional info header.
+
+        data: bytes to display
+        data_type: mime type
+        info: an arbitrary string to append to the end of first line of header
+        """
+        header1 = f"Data-Type: {data_type}, Length={len(data)}{info}\n"
         header2 = "Offset | Hex                                             | Ascii          \n"
         header2 += "-------+-------------------------------------------------+----------------\n"
         if isinstance(data, str):
@@ -70,8 +77,16 @@ class BlobNode(Node):
         return header1 + header2 + "".join(hex_data)
 
     @staticmethod
-    def ascii_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+    def ascii_view(data, data_type, info=''):
+        """
+        Render an ascii view with an optional info header.
+
+        data: bytes to display
+        data_type: mime type
+        info: an arbitrary string to append to the end of first line of header
+        """
+
+        header1 = f"Data-Type: {data_type}, Length={len(data)}{info}\n"
         header2 = "Offset | Hex                                             | Ascii          \n"
         header2 += "-------+-------------------------------------------------+----------------\n"
         if isinstance(data, str):

meerk40t/core/node/elem_ellipse.py

@@ -3,8 +3,8 @@ from math import cos, sin, sqrt, tau
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Node
@@ -171,12 +171,16 @@ class EllipseNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable
         tablen = self.mktablength
         numtabs = self.mktabpositions
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
 
         return path
 
@@ -261,19 +265,25 @@ class EllipseNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True