meerk40t 0.9.7020__tar.gz → 0.9.7030__tar.gz

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerk40t
-Version: 0.9.7020
+Version: 0.9.7030
 Summary: MeerK40t LaserCutter Software
 Home-page: https://github.com/meerk40t/meerk40t
 Author: Tatarize

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/meerk40t/core/cutcode/cutcode.py

@@ -132,7 +132,7 @@ class CutCode(CutGroup):
                 length_of_previous_travel = Point.distance(prev.end, current.start)
                 total_distance_travel += length_of_previous_travel
             rapid_speed = self._native_speed(cutcode)
-            if rapid_speed is not None:
+            if rapid_speed is not None and rapid_speed != 0:
                 total_duration_travel = total_distance_travel / rapid_speed
                 duration_of_this_travel = length_of_previous_travel / rapid_speed
 

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/meerk40t/core/cutplan.py

@@ -23,7 +23,7 @@ from functools import lru_cache
 import numpy as np
 
 from ..svgelements import Group, Matrix, Path, Polygon
-from ..tools.geomstr import Geomstr
+from ..tools.geomstr import Geomstr, stitch_geometries
 from ..tools.pathtools import VectorMontonizer
 from .cutcode.cutcode import CutCode
 from .cutcode.cutgroup import CutGroup
@@ -32,7 +32,6 @@ from .cutcode.rastercut import RasterCut
 from .node.node import Node
 from .node.util_console import ConsoleOperation
 from .units import Length, UNITS_PER_MM
-
 """
 The time to compile does outweigh the benefit...
 try:
@@ -187,6 +186,7 @@ class CutPlan:
             placements.append(scene_to_device_matrix)
 
         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"))
@@ -244,6 +244,74 @@ class CutPlan:
                 op_type = getattr(op, "type", "")
                 if op_type.startswith("place "):
                     continue
+                if op_type == "op cut" and self.context.opt_stitching and self.context.do_optimization:
+                    # This isn't a lossless operation: dotted/dashed lines will be treated as solid lines
+                    try:
+                        stitch_tolerance = float(Length(self.context.opt_stitch_tolerance))
+                    except ValueError:
+                        stitch_tolerance = 0
+                    default_stroke = None
+                    default_strokewidth = None
+
+                    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]
+                    
+                    geoms = []
+                    to_be_deleted = []
+                    data = stitcheable_nodes(list(op.flat()), stitch_tolerance)
+                    for node in data:
+                        if node is op:
+                            continue
+                        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
+                            to_be_deleted.append(node)
+                    result = stitch_geometries(geoms, stitch_tolerance)
+                    if result is not None:
+                        # print (f"Paths at start of action: {len(list(op.flat()))}")
+                        for node in to_be_deleted:
+                            node.remove_node()
+                        for idx, g in enumerate(result):
+                            node = op.add(
+                                label=f"Stitch # {idx + 1}",
+                                stroke=default_stroke,
+                                stroke_width=default_strokewidth,
+                                geometry=g,
+                                type="elem path",
+                            )
+                        # print (f"Paths at start of action: {len(list(op.flat()))}")
+
                 self.plan.append(op)
                 if (op_type.startswith("op") or op_type.startswith("util")) and hasattr(op, "preprocess"):
                     op.preprocess(self.context, placement, self)

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/meerk40t/core/elements/element_treeops.py

@@ -2866,13 +2866,15 @@ def init_tree(kernel):
         dots_per_units = node.dpi / UNITS_PER_INCH
         new_width = width * dots_per_units
         new_height = height * dots_per_units
-
-        image = make_raster(
-            data,
-            bounds=bounds,
-            width=new_width,
-            height=new_height,
-        )
+        try:
+            image = make_raster(
+                data,
+                bounds=bounds,
+                width=new_width,
+                height=new_height,
+            )
+        except Exception:
+            return None, None
         matrix = Matrix.scale(width / new_width, height / new_height)
         matrix.post_translate(bounds[0], bounds[1])
         return image, matrix

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/meerk40t/core/elements/grid.py

@@ -198,7 +198,14 @@ def init_commands(kernel):
                 y_distance += height
             if origin is None:
                 origin = (1, 1)
-            cx, cy = origin
+            if isinstance(origin, (tuple, list)) and isinstance(origin[0], (tuple, list)):
+                origin = origin[0]
+            try:
+                cx, cy = origin
+            except ValueError:
+                cx = 1
+                cy = 1
+            
             data_out = list(data)
             if cx is None:
                 cx = 1

{meerk40t-0.9.7020 → meerk40t-0.9.7030}/meerk40t/core/elements/offset_mk.py

@@ -360,10 +360,11 @@ def offset_path(self, path, offset_value=0):
     # As this oveloading a regular method in a class
     # it needs to have the very same definition (including the class
     # reference self)
+    # Radial connectors seem to have issues, so we don't use them for now...
     p = path_offset(
         path,
         offset_value=-offset_value,
-        radial_connector=True,
+        radial_connector=False,
         linearize=True,
         interpolation=500,
     )