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

meerk40t/core/elements/elements.py

@@ -219,7 +219,7 @@ def plugin(kernel, lifecycle=None):
                 "type": bool,
                 "label": _("Track changes and allow undo"),
                 "tip": _(
-                    "MK will save intermediate states to undo/redo changes") + "\n" + 
+                    "MK will save intermediate states to undo/redo changes") + "\n" +
                     _("This may consume a significant amount of memory"),
                 "page": "Start",
                 "section": "_60_Undo",
@@ -311,6 +311,22 @@ def plugin(kernel, lifecycle=None):
                 "page": "Classification",
                 "section": "_10_Assignment-Logic",
             },
+            {
+                "attr": "classify_fill",
+                "object": elements,
+                "default": False,
+                "type": bool,
+                "label": _("Classify elements on fill"),
+                "tip": _(
+                    "Usually MK will use the fill attribute as an indicator for a raster and will not distinguish between individual colors."
+                )
+                + "\n"
+                + _(
+                    "If you want to distinguish between different raster types then activate this option."
+                ),
+                "page": "Classification",
+                "section": "_10_Assignment-Logic",
+            },
             {
                 "attr": "classify_default",
                 "object": elements,
@@ -648,6 +664,7 @@ class Elemental(Service):
         self.setting(bool, "classify_inherit_fill", False)
         self.setting(bool, "classify_inherit_exclusive", True)
         self.setting(bool, "update_statusbar_on_material_load", True)
+        self.setting(bool, "classify_fill", False)
         # self.setting(bool, "classify_auto_inherit", False)
         self.setting(bool, "classify_default", True)
         self.setting(bool, "op_show_default", False)
@@ -2695,6 +2712,31 @@ class Elemental(Service):
         def emptydebug(value):
             return
 
+        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#"):
+                    try:
+                        used_id = int(op.id[3:])
+                        auto_raster_count = max(auto_raster_count, used_id)
+                    except (IndexError, ValueError):
+                        pass
+            return auto_raster_count + 1
+
+        def _select_raster_candidate(operations, node, fuzzydistance):
+            candidate = None
+            candidate_dist = float("inf")
+            for cand_op in operations:
+                if cand_op.type != "op raster":
+                    continue
+                col_d = Color.distance(cand_op.color, abs(node.fill))
+                if col_d > fuzzydistance:
+                    continue
+                if candidate is None or col_d < candidate_dist:
+                    candidate = cand_op
+                    candidate_dist = col_d
+            return candidate
+
         # I am tired of changing the code all the time, so let's do it properly
         debug = self.kernel.channel("classify", timestamp=True)
 
@@ -2807,17 +2849,58 @@ class Elemental(Service):
                         debug(
                             f"For {op.type}.{op.id}: black={is_black}, perform={perform_classification}, flag={self.classify_black_as_raster}"
                         )
-                    if hasattr(op, "classify") and perform_classification:
+                    if not (hasattr(op, "classify") and perform_classification):
+                        continue
+                    classified = False
+                    classifying_op = None
+                    if (
+                        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)
+                        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,
+                            )
+                            add_op_function(raster_candidate)
+                            new_operations_added = True
+
+                        classified, should_break, feedback = raster_candidate.classify(
+                            node,
+                            fuzzy=tempfuzzy,
+                            fuzzydistance=fuzzydistance,
+                            usedefault=False,
+                        )
+                        if classified:
+                            classifying_op = raster_candidate
+                            should_break = True
+                            if debug:
+                                debug(
+                                    f"{node_desc} was color-raster-classified: {sstroke} {sfill} matching operation: {type(classifying_op).__name__}, break={should_break}"
+                                )
+
+                    if not classified:
                         classified, should_break, feedback = op.classify(
                             node,
                             fuzzy=tempfuzzy,
                             fuzzydistance=fuzzydistance,
                             usedefault=False,
                         )
-                    else:
-                        continue
+                        if classified:
+                            classifying_op = op
                     if classified:
-                        update_debug_set(debug_set, op)
+                        update_debug_set(debug_set, classifying_op)
                         if feedback is not None and "stroke" in feedback:
                             classif_info[0] = True
                         if feedback is not None and "fill" in feedback:
@@ -2833,7 +2916,7 @@ class Elemental(Service):
                             sfill = ""
                         if debug:
                             debug(
-                                f"{node_desc} was classified: {sstroke} {sfill} matching operation: {type(op).__name__}, break={should_break}"
+                                f"{node_desc} was classified: {sstroke} {sfill} matching operation: {type(classifying_op).__name__}, break={should_break}"
                             )
                     if should_break:
                         break
@@ -2889,8 +2972,8 @@ class Elemental(Service):
                 default_candidates = []
                 for op in operations:
                     if (
-                        hasattr(op, "classify") and 
-                        getattr(op, "default", False) and 
+                        hasattr(op, "classify") and
+                        getattr(op, "default", False) and
                         hasattr(op, "valid_node_for_reference") and
                         op.valid_node_for_reference(node)
                     ):
@@ -3132,7 +3215,15 @@ class Elemental(Service):
                     and node.fill is not None
                     and node.fill.argb is not None
                 ):
-                    op = RasterOpNode(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"
+                    op = RasterOpNode(
+                        id=default_id,
+                        label=default_label,
+                        color=default_color,
+                        output = True,
+                    )
                     stdops.append(op)
                     if debug:
                         debug("add an op raster due to fill")

meerk40t/core/elements/shapes.py

@@ -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,7 +2777,7 @@ 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 = []
@@ -2662,6 +2787,8 @@ def init_commands(kernel):
                     continue
                 for g1 in node.as_geometry().as_contiguous():
                     geoms.append((idx, g1))
+            if tolerance == 0:
+                tolerance = 1e-6
             for idx1, (nodeidx1, g1) in enumerate(geoms):
                 for idx2 in range(idx1 + 1, len(geoms)):
                     nodeidx2 = geoms[idx2][0]
@@ -2671,10 +2798,10 @@ def init_commands(kernel):
                     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 
+                        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)
@@ -2683,7 +2810,9 @@ def init_commands(kernel):
 
             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)
@@ -2701,7 +2830,7 @@ def init_commands(kernel):
             default_fill = None
             for node in s_data:
                 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
@@ -2728,10 +2857,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 ------------------------------