meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

meerk40t/core/cutplan.py

@@ -17,7 +17,7 @@ CutPlan handles the various complicated algorithms to optimising the sequence of
 from copy import copy
 from math import isinf
 from os import times
-from time import time
+from time import perf_counter, time
 from typing import Optional
 
 import numpy as np
@@ -175,7 +175,16 @@ class CutPlan:
         #     axis = rotary.axis
 
         original_ops = copy(self.plan)
+        if self.context.opt_raster_optimisation and self.context.do_optimization:
+            try:
+                margin = float(Length(self.context.opt_raster_opt_margin, "0"))
+            except (AttributeError, ValueError):
+                margin = 0
+            self.optimize_rasters(original_ops, "op raster", margin)
+            # We could do this as well, but images are burnt separately anyway...
+            # self.optimize_rasters(original_ops, "op image", margin)
         self.plan.clear()
+
         idx = 0
         self.context.elements.mywordlist.push()
 
@@ -185,7 +194,10 @@ class CutPlan:
                 self.context.elements.mywordlist.move_all_indices(1)
 
             for original_op in original_ops:
-                op = copy(original_op)
+                try:
+                    op = original_op.copy_with_reified_tree()
+                except AttributeError:
+                    op = original_op
                 if not hasattr(op, "type") or op.type is None:
                     self.plan.append(op)
                     continue
@@ -193,8 +205,6 @@ class CutPlan:
                     continue
                 self.plan.append(op)
                 if op.type.startswith("op"):
-                    for child in original_op.children:
-                        op.add_node(copy(child))
                     if hasattr(op, "preprocess"):
                         op.preprocess(self.context, placement, self)
                     for node in op.flat():
@@ -531,8 +541,8 @@ class CutPlan:
                     float(Length(stol))
                     * 2
                     / (
-                        self.context.device.native_scale_x
-                        + self.context.device.native_scale_y
+                        self.context.device.view.native_scale_x
+                        + self.context.device.view.native_scale_y
                     )
                 )
             except ValueError:
@@ -637,6 +647,122 @@ class CutPlan:
         self.plan.clear()
         self.commands.clear()
 
+    def optimize_rasters(self, operation_list, op_type, margin):
+        def generate_clusters(operation):
+            def overlapping(bounds1, bounds2, margin):
+                # The rectangles don't overlap if
+                # one rectangle's minimum in some dimension
+                # is greater than the other's maximum in
+                # that dimension.
+                flagx = (bounds1[0] > bounds2[2] + margin) or (
+                    bounds2[0] > bounds1[2] + margin
+                )
+                flagy = (bounds1[1] > bounds2[3] + margin) or (
+                    bounds2[1] > bounds1[3] + margin
+                )
+                return bool(not (flagx or flagy))
+
+            clusters = list()
+            cluster_bounds = list()
+            for node in operation.children:
+                try:
+                    if node.type == "reference":
+                        node = node.node
+                    bb = node.paint_bounds
+                except AttributeError:
+                    # Either no element node or does not have bounds
+                    continue
+                clusters.append([node])
+                cluster_bounds.append(
+                    (
+                        bb[0],
+                        bb[1],
+                        bb[2],
+                        bb[3],
+                    )
+                )
+
+            def detail_overlap(index1, index2):
+                # But is there a real overlap, or just one with the union bounds?
+                for outer_node in clusters[index1]:
+                    try:
+                        bb_outer = outer_node.paint_bounds
+                    except AttributeError:
+                        continue
+                    for inner_node in clusters[index2]:
+                        try:
+                            bb_inner = inner_node.paint_bounds
+                        except AttributeError:
+                            continue
+                        if overlapping(bb_outer, bb_inner, margin):
+                            return True
+                # We did not find anything...
+                return False
+
+            needs_repeat = True
+            while needs_repeat:
+                needs_repeat = False
+                for outer_idx in range(len(clusters) - 1, -1, -1):
+                    # Loop downwards as we are manipulating the arrays
+                    bb = cluster_bounds[outer_idx]
+                    for inner_idx in range(outer_idx - 1, -1, -1):
+                        cc = cluster_bounds[inner_idx]
+                        if not overlapping(bb, cc, margin):
+                            continue
+                        # Overlap!
+                        # print (f"Reuse cluster {inner_idx} for {outer_idx}")
+                        real_overlap = detail_overlap(outer_idx, inner_idx)
+                        if real_overlap:
+                            needs_repeat = True
+                            # We need to extend the inner cluster by the outer
+                            clusters[inner_idx].extend(clusters[outer_idx])
+                            cluster_bounds[inner_idx] = (
+                                min(bb[0], cc[0]),
+                                min(bb[1], cc[1]),
+                                max(bb[2], cc[2]),
+                                max(bb[3], cc[3]),
+                            )
+                            clusters.pop(outer_idx)
+                            cluster_bounds.pop(outer_idx)
+                            # We are done with the inner loop, as we effectively
+                            # destroyed the cluster element we compared
+                            break
+
+            return clusters
+
+        stime = perf_counter()
+        scount = 0
+        ecount = 0
+        for idx in range(len(operation_list) - 1, -1, -1):
+            op = operation_list[idx]
+            if (
+                not hasattr(op, "type")
+                or not hasattr(op, "children")
+                or op.type != op_type
+            ):
+                # That's not what we are looking for
+                continue
+            scount += 1
+            clusters = generate_clusters(op)
+            ecount += len(clusters)
+            if len(clusters) > 0:
+                # Create cluster copies of the raster op
+                for entry in clusters:
+                    newop = copy(op)
+                    newop._references.clear()
+                    for node in entry:
+                        newop.add_reference(node)
+                    newop.set_dirty_bounds()
+                    operation_list.insert(idx + 1, newop)
+
+                # And remove the original one...
+                operation_list.pop(idx)
+        etime = perf_counter()
+        if self.channel:
+            self.channel(
+                f"Optimise {op_type} finished after {etime-stime:.2f} seconds, inflated {scount} operations to {ecount}"
+            )
+
 
 def is_inside(inner, outer, tolerance=0):
     """
@@ -805,6 +931,10 @@ def inner_first_ident(context: CutGroup, channel=None, tolerance=0):
     groups = [cut for cut in context if isinstance(cut, (CutGroup, RasterCut))]
     closed_groups = [g for g in groups if isinstance(g, CutGroup) and g.closed]
     context.contains = closed_groups
+    if channel:
+        channel(
+            f"Compare {len(groups)} groups against {len(closed_groups)} closed groups"
+        )
 
     constrained = False
     for outer in closed_groups:
@@ -842,7 +972,7 @@ def inner_first_ident(context: CutGroup, channel=None, tolerance=0):
     if channel:
         end_times = times()
         channel(
-            f"Inner paths identified in {time() - start_time:.3f} elapsed seconds "
+            f"Inner paths identified in {time() - start_time:.3f} elapsed seconds: {constrained} "
             f"using {end_times[0] - start_times[0]:.3f} seconds CPU"
         )
     return context
@@ -1175,11 +1305,12 @@ def inner_selection_cutcode(
     if channel:
         end_times = times()
         end_length = ordered.length_travel(True)
-        channel(
-            f"Length at end: {end_length:.0f} steps "
-            f"({(end_length - start_length) / start_length:+.0%}), "
-            f"optimized in {time() - start_time:.3f} "
-            f"elapsed seconds using {end_times[0] - start_times[0]:.3f} "
-            f"seconds CPU in {iterations} iterations"
-        )
+        msg = f"Length at end: {end_length:.0f} steps "
+        if start_length != 0:
+            msg += f"({(end_length - start_length) / start_length:+.0%}), "
+        msg += f"optimized in {time() - start_time:.3f} "
+        msg += f"elapsed seconds using {end_times[0] - start_times[0]:.3f} "
+        msg += f"seconds CPU in {iterations} iterations"
+
+        channel(msg)
     return ordered

meerk40t/core/elements/clipboard.py

@@ -59,14 +59,13 @@ def init_commands(kernel):
             copy_node = copy(e)
             # Need to add stroke and fill, as copy will take the
             # default values for these attributes
-            for optional in ("fill", "stroke"):
+            options = ["fill", "stroke", "wxfont"]
+            for prop in dir(e):
+                if prop.startswith("mk"):
+                    options.append(prop)
+            for optional in options:
                 if hasattr(e, optional):
                     setattr(copy_node, optional, getattr(e, optional))
-            hadoptional = False
-            for optional in ("wxfont", "mktext", "mkfont", "mkfontsize"):
-                if hasattr(e, optional):
-                    setattr(copy_node, optional, getattr(e, optional))
-                    hadoptional = True
             self._clipboard[destination].append(copy_node)
         # Let the world know we have filled the clipboard
         self.signal("icons")
@@ -93,14 +92,20 @@ def init_commands(kernel):
                     continue
                 # Need to add stroke and fill, as copy will take the
                 # default values for these attributes
-                for optional in ("fill", "stroke"):
+                options = ["fill", "stroke", "wxfont"]
+                for optional in options:
                     if hasattr(e, optional):
                         setattr(copy_node, optional, getattr(e, optional))
                 hadoptional = False
-                for optional in ("wxfont", "mktext", "mkfont", "mkfontsize"):
+                options = []
+                for prop in dir(e):
+                    if prop.startswith("mk"):
+                        options.append(prop)
+                for optional in options:
                     if hasattr(e, optional):
                         setattr(copy_node, optional, getattr(e, optional))
                         hadoptional = True
+
                 if hadoptional:
                     for property_op in self.kernel.lookup_all("path_updater/.*"):
                         property_op(self.kernel.root, copy_node)
@@ -158,7 +163,11 @@ def init_commands(kernel):
         self._clipboard[destination] = []
         for e in data:
             copy_node = copy(e)
-            for optional in ("wxfont", "mktext", "mkfont", "mkfontsize"):
+            options = ["fill", "stroke", "wxfont"]
+            for prop in dir(e):
+                if prop.startswith("mk"):
+                    options.append(prop)
+            for optional in options:
                 if hasattr(e, optional):
                     setattr(copy_node, optional, getattr(e, optional))
             self._clipboard[destination].append(copy_node)