meerk40t 0.9.7030__py2.py3-none-any.whl → 0.9.7050__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")