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

meerk40t/tools/geomstr.py

@@ -107,7 +107,15 @@ TYPE_CALL = 0xB0 | 0b1111  # The two higher level bytes are call label index.
 
 # A summary of all points that have a special meaning, ie intended for other uses than pure geometry
 META_TYPES = (TYPE_NOP, TYPE_FUNCTION, TYPE_VERTEX, TYPE_UNTIL, TYPE_CALL)
-NON_GEOMETRY_TYPES = (TYPE_NOP, TYPE_FUNCTION, TYPE_VERTEX, TYPE_UNTIL, TYPE_CALL, TYPE_END)
+NON_GEOMETRY_TYPES = (
+    TYPE_NOP,
+    TYPE_FUNCTION,
+    TYPE_VERTEX,
+    TYPE_UNTIL,
+    TYPE_CALL,
+    TYPE_END,
+)
+
 
 class Polygon:
     def __init__(self, *args):
@@ -118,7 +126,6 @@ class Polygon:
         return self.geomstr.bbox(mx)
 
 
-
 def triangle_area(p1, p2, p3):
     """
     calculates the area of a triangle given its vertices
@@ -179,94 +186,127 @@ def remove(s, i):
     """
     s[i:-1] = s[i + 1 :]
 
-def stitch_geometries(geometry_list:list, tolerance:float=0.0) -> list:
-    action_list = list(geometry_list)
-    result_list = []
-    start_points = []
-    end_points = []
-    anychanges = True
-    were_stitches = False
-    iteration_loop = 0
-    while anychanges:
-        iteration_loop += 1
-        # print (f"Loop {iteration_loop}")
-        anychanges = False
-        for g1 in action_list:
-            if g1 is None:
-                continue
+
+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))
+    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]
+            g2 = geoms[idx2][1]
             fp1 = g1.first_point
+            fp2 = g2.first_point
             lp1 = g1.last_point
-            if fp1 is None or lp1 is None:
-                continue
-            was_stitched = False
-            for idx, g2 in enumerate(result_list):
-                fp2 = start_points[idx]
-                lp2 = end_points[idx]
-                # end - start: append
-                # end - end : append reverse
-                # start - start: insert reverse
-                # start - end: insert
-                dist_e_s = abs(lp2 - fp1)
-                dist_e_e = abs(lp2 - lp1)
-                dist_s_s = abs(fp2 - fp1)
-                dist_s_e = abs(fp2 - lp1)
-                # print (f"test #{idx} ({fp1.real:.2f},{fp1.imag:.2f})->({lp1.real:.2f},{lp1.imag:.2f}) versus ({fp2.real:.2f},{fp2.imag:.2f})->({lp2.real:.2f},{lp2.imag:.2f})")
-                # print (f"Gaps: e -> s: {dist_e_s:.3f}, e -> e: {dist_e_e:.3f}, s -> s: {dist_s_s:.3f},s -> e: {dist_s_e:.3f},")
-                if dist_e_s <= tolerance:
-                    # append
-                    if dist_e_s > 0:
-                        g2.line(lp2, fp1)
-                    g2.append(g1, end=False)
-                    was_stitched = True
-                elif dist_e_e <= tolerance:
-                    # append reverse
-                    g1.reverse()
-                    if dist_e_e > 0:
-                        g2.line(lp2, lp1)
-                    g2.append(g1, end=False)
-                    was_stitched = True
-                elif dist_s_s <= tolerance:
-                    # insert reverse
-                    g1.reverse()
-                    if dist_s_s > 0:
-                        g1.line(fp1, fp2)
-                    g2.insert(0, g1.segments[:g1.index])
-                    was_stitched = True
-                elif dist_s_e <= tolerance:
-                    # insert
-                    if dist_s_e > 0:
-                        g1.line(lp1, fp2)
-                    g2.insert(0, g1.segments[:g1.index])
-                    was_stitched = True
-                if was_stitched:
-                    # print ("stitched")
-                    # g2.debug_me()
-                    anychanges = True
-                    start_points[idx] = g2.first_point
-                    end_points[idx] = g2.last_point
-                    result_list[idx] = g2
-                    were_stitches = True
+            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)
+    # print (f"Stitchable nodes: {len(out)}")
+    return [data[idx] for idx in out]
+
+
+def stitch_geometries(geometry_list: list, tolerance: float = 0.0) -> list:
+    """
+    Stitches geometries within the given tolerance.
+
+    Args:
+        geometry_list: List of Geomstr objects to stitch.
+        tolerance: Maximum distance between endpoints to consider a stitch.
+
+    Returns:
+        List of stitched Geomstr objects, or None if no stitches were made.
+    """
+    # def coord(point):
+    #     return f"{point.real:.2f},{point.imag:.2f}"
+
+    geometries = [g for g in geometry_list if g is not None]
+    if not geometries:
+        return None
+    if tolerance == 0:
+        tolerance = 1e-6
+    # geometries.sort(key=lambda g: g.first_point)
+    anystitches = 1
+    pass_count = 0
+    # for idx, g in enumerate(geometries):
+    #     print (f"{idx}: {g.first_point} -> {g.last_point} ({g.index} segments)")
+
+    while anystitches > 0:
+        stitched_geometries = []
+        anystitches = 0
+        while geometries:
+            candidate = geometries.pop(0)
+            stitched = False
+            for i, target in enumerate(stitched_geometries):
+                cand_fp = candidate.first_point
+                cand_lp = candidate.last_point
+                targ_fp = target.first_point
+                targ_lp = target.last_point
+                if abs(targ_lp - cand_fp) <= tolerance:
+                    # Just append g1 to g2
+                    if abs(targ_lp - cand_fp) > 0:
+                        target.line(targ_lp, cand_fp)
+                    target.append(candidate)
+                    stitched_geometries[i] = target
+                    stitched = True
+                    break
+                if abs(targ_fp - cand_lp) <= tolerance:
+                    # Insert g1 at the start of g2
+                    if abs(targ_fp - cand_lp) > 0:
+                        candidate.line(cand_lp, targ_fp)
+                    candidate.append(target)
+                    stitched_geometries[i] = candidate
+                    stitched = True
+                    break
+                if abs(targ_fp - cand_fp) <= tolerance:
+                    # Insert the reverse of g1 at the start
+                    candidate.reverse()
+                    if abs(targ_fp - cand_fp) > 0:
+                        candidate.line(cand_fp, targ_fp)
+                    candidate.append(target)
+                    stitched_geometries[i] = candidate
+                    stitched = True
+                    break
+                if abs(targ_lp - cand_lp) <= tolerance:
+                    if abs(targ_lp - cand_lp) > 0:
+                        target.line(targ_lp, cand_lp)
+                    candidate.reverse()
+                    target.append(candidate)
+                    stitched_geometries[i] = target
+                    stitched = True
                     break
 
-            if not was_stitched:
-                # print ("Unchanged")
-                result_list.append(g1)
-                start_points.append(fp1)
-                end_points.append(lp1)
-        if anychanges:
-            action_list = list(result_list)
-            result_list.clear()
-            start_points.clear()
-            end_points.clear()
-    if were_stitches:
-        for g1 in result_list:
-            fp1 = g1.first_point
-            lp1 = g1.last_point
-            dist_e_s = abs(lp1 - fp1)
-            if 0 < dist_e_s <= tolerance:
-                g1.line(lp1, fp1)
-        return result_list
-    return None
+            if stitched:
+                anystitches += 1
+            else:
+                stitched_geometries.append(candidate)
+
+        # print (f"Stitch pass {pass_count}: {len(stitched_geometries)} geometries, {anystitches} stitches made, org= {len(geometry_list)}, tolerance={tolerance:.2f}")
+        if anystitches > 0:
+            # Stitches were made, so lets try again
+            geometries = list(stitched_geometries)
+            pass_count += 1
+    # Close any remaining small gaps between start and end points.
+    for g in stitched_geometries:
+        if 0 < abs(g.last_point - g.first_point) <= tolerance:
+            g.line(g.last_point, g.first_point)
+
+    return stitched_geometries
+
 
 class Simplifier:
     # Copyright (c) 2014 Elliot Hallmark
@@ -393,7 +433,7 @@ class Simplifier:
                 areas[min_vert] = right_area
 
             if min_vert > 1:
-                # cant try/except because 0-1=-1 is a valid index
+                # can't try/except because 0-1=-1 is a valid index
                 left_area = triangle_area(
                     self.pts[i[min_vert - 2]],
                     self.pts[i[min_vert - 1]],
@@ -442,13 +482,15 @@ class Simplifier:
         # for some points
         # sort point indices by threshold
         idx = list(range(len(self.pts)))
-        sorted_indices = sorted(zip(idx, self.thresholds), reverse=True, key=lambda x: x[1])
+        sorted_indices = sorted(
+            zip(idx, self.thresholds), reverse=True, key=lambda x: x[1]
+        )
 
         # grab first n indices
         sorted_indices = sorted_indices[:n]
 
         # re-sort by index
-        final_indices = sorted( [x[0] for x in sorted_indices] )
+        final_indices = sorted([x[0] for x in sorted_indices])
 
         return self.pts[final_indices]
 
@@ -1279,6 +1321,8 @@ class Scanbeam:
         @param tolerance: wiggle room, in favor of inside
         @return:
         """
+        if tolerance == 0:
+            tolerance == 1e-6
         self.scanline_to(y)
         for i in range(1, len(self._active_edge_list), 2):
             prior = self._active_edge_list[i - 1]
@@ -1712,11 +1756,26 @@ class Geomstr:
                 ):
                     # This is a deliberate subpath break
                     obj.end()
-            elif isinstance(seg, (Line, Close)) and seg.start is not None and seg.end is not None:
+            elif (
+                isinstance(seg, (Line, Close))
+                and seg.start is not None
+                and seg.end is not None
+            ):
                 obj.line(complex(seg.start), complex(seg.end))
-            elif isinstance(seg, QuadraticBezier) and seg.start is not None and seg.end is not None and seg.control is not None:
+            elif (
+                isinstance(seg, QuadraticBezier)
+                and seg.start is not None
+                and seg.end is not None
+                and seg.control is not None
+            ):
                 obj.quad(complex(seg.start), complex(seg.control), complex(seg.end))
-            elif isinstance(seg, CubicBezier) and seg.start is not None and seg.end is not None and seg.control1 is not None and seg.control2 is not None:
+            elif (
+                isinstance(seg, CubicBezier)
+                and seg.start is not None
+                and seg.end is not None
+                and seg.control1 is not None
+                and seg.control2 is not None
+            ):
                 obj.cubic(
                     complex(seg.start),
                     complex(seg.control1),
@@ -1867,16 +1926,22 @@ class Geomstr:
             rx = abs(rx)
             ry = abs(ry)
         if rx == ry == 0:
-            path.line(complex(x, y), complex(x + width, y), settings=settings),
-            path.line(
-                complex(x + width, y), complex(x + width, y + height), settings=settings
-            ),
-            path.line(
-                complex(x + width, y + height),
-                complex(x, y + height),
-                settings=settings,
-            ),
-            path.line(complex(x, y + height), complex(x, y), settings=settings),
+            (path.line(complex(x, y), complex(x + width, y), settings=settings),)
+            (
+                path.line(
+                    complex(x + width, y),
+                    complex(x + width, y + height),
+                    settings=settings,
+                ),
+            )
+            (
+                path.line(
+                    complex(x + width, y + height),
+                    complex(x, y + height),
+                    settings=settings,
+                ),
+            )
+            (path.line(complex(x, y + height), complex(x, y), settings=settings),)
         else:
             offset = 1 - (1.0 / math.sqrt(2))
             path.line(complex(x + rx, y), complex(x + width - rx, y), settings=settings)
@@ -2028,7 +2093,7 @@ class Geomstr:
         return geometry
 
     @classmethod
-    def wobble(cls, algorithm, outer, radius, interval, speed, unit_factor = 1):
+    def wobble(cls, algorithm, outer, radius, interval, speed, unit_factor=1):
         from meerk40t.fill.fills import Wobble
 
         w = Wobble(algorithm, radius=radius, speed=speed, interval=interval)
@@ -2130,12 +2195,28 @@ class Geomstr:
     @classmethod
     def wobble_dash(cls, outer, dashlength, interval, irrelevant, unit_factor=1):
         from meerk40t.fill.fills import dashed_line as algorithm
-        return cls.wobble(algorithm, outer, dashlength, interval * unit_factor, irrelevant, unit_factor=unit_factor)
+
+        return cls.wobble(
+            algorithm,
+            outer,
+            dashlength,
+            interval * unit_factor,
+            irrelevant,
+            unit_factor=unit_factor,
+        )
 
     @classmethod
     def wobble_tab(cls, outer, tablength, interval, tabpositions, unit_factor=1):
         from meerk40t.fill.fills import tabbed_path as algorithm
-        return cls.wobble(algorithm, outer, tablength, interval * unit_factor, tabpositions, unit_factor=unit_factor)
+
+        return cls.wobble(
+            algorithm,
+            outer,
+            tablength,
+            interval * unit_factor,
+            tabpositions,
+            unit_factor=unit_factor,
+        )
 
     @classmethod
     def from_float_segments(cls, float_segments):
@@ -2261,7 +2342,7 @@ class Geomstr:
         if segments:
             yield segments
 
-    def as_equal_interpolated_points(self, distance=100):
+    def as_equal_interpolated_points(self, distance=100, expand_lines=False):
         """
         Regardless of specified distance this will always give the start and end points of each node within the
         geometry. It will not duplicate the nodes if the start of one is the end of another. If the start and end
@@ -2294,7 +2375,21 @@ class Geomstr:
                 at_start = True
                 continue
             elif seg_type == TYPE_LINE:
-                pass
+                if expand_lines:
+                    ts = np.linspace(0, 1, 1000)
+                    pts = self._line_position(e, ts)
+                    distances = np.abs(pts[:-1] - pts[1:])
+                    distances = np.cumsum(distances)
+                    max_distance = distances[-1]
+                    dist_values = np.linspace(
+                        0,
+                        max_distance,
+                        int(np.ceil(max_distance / distance)),
+                        endpoint=False,
+                    )[1:]
+                    near_t = np.searchsorted(distances, dist_values, side="right")
+                    pts = pts[near_t]
+                    yield from pts
             elif seg_type == TYPE_QUAD:
                 ts = np.linspace(0, 1, 1000)
                 pts = self._quad_position(e, ts)
@@ -2811,7 +2906,7 @@ class Geomstr:
 
         @return:
         """
-        sweep = end_t - start_t 
+        sweep = end_t - start_t
         if slices is None:
             # A full ellipse can be properly represented with 12 slices - we err on the side of caution here...
             slices = int(1.5 * 12 * sweep / math.tau)
@@ -2967,7 +3062,10 @@ class Geomstr:
             current = self.segments[i]
             start0, control0, info0, control20, end0 = previous
             start1, control1, info1, control21, end1 = current
-            if self._segtype(previous) != TYPE_LINE or self._segtype(current) != TYPE_LINE:
+            if (
+                self._segtype(previous) != TYPE_LINE
+                or self._segtype(current) != TYPE_LINE
+            ):
                 continue
             towards0 = Geomstr.towards(None, start0, end0, 1 - amount)
             towards1 = Geomstr.towards(None, start1, end1, amount)
@@ -2986,7 +3084,10 @@ class Geomstr:
             current = self.segments[i]
             start0, control0, info0, control20, end0 = previous
             start1, control1, info1, control21, end1 = current
-            if self._segtype(previous) != TYPE_LINE or self._segtype(current) != TYPE_LINE:
+            if (
+                self._segtype(previous) != TYPE_LINE
+                or self._segtype(current) != TYPE_LINE
+            ):
                 continue
             towards0 = Geomstr.towards(None, start0, end0, 1 - amount)
             towards1 = Geomstr.towards(None, start1, end1, amount)
@@ -3527,7 +3628,7 @@ class Geomstr:
 
     def _cubic_length_via_quad(self, line):
         """
-        If we have scipy.integrate availible, use quad from that to solve this.
+        If we have scipy.integrate available, use quad from that to solve this.
 
         @param line:
         @return:
@@ -3580,9 +3681,13 @@ class Geomstr:
                 yield start, control, info, control2, mid[0]
                 for i in range(1, len(mid)):
                     if breaks:
-                        yield mid[i - 1], mid[i - 1], complex(TYPE_END, info.imag), mid[
-                            i - 1
-                        ], mid[i - 1]
+                        yield (
+                            mid[i - 1],
+                            mid[i - 1],
+                            complex(TYPE_END, info.imag),
+                            mid[i - 1],
+                            mid[i - 1],
+                        )
                     yield mid[i - 1], control, info, control2, mid[i]
                 if breaks:
                     yield mid[-1], 0, complex(TYPE_END, info.imag), 0, mid[-1]
@@ -4366,7 +4471,7 @@ class Geomstr:
         return wh, x_vals + y_vals * 1j, ta_hit, tb_hit
 
     #######################
-    # Geom Tranformations
+    # Geom Transformations
     #######################
 
     def transform(self, mx, e=None):
@@ -4656,10 +4761,13 @@ class Geomstr:
             return process(S, K, a, c)[:-1] + process(S, K, c, b)
 
         def quickhull_2d(S: np.ndarray) -> np.ndarray:
-            a, b = np.argmin(S[:,0]), np.argmax(S[:,0])
-            max_index = np.argmax(S[:,0])
+            a, b = np.argmin(S[:, 0]), np.argmax(S[:, 0])
+            max_index = np.argmax(S[:, 0])
             # max_element = S[max_index]
-            return process(S, np.arange(S.shape[0]), a, max_index)[:-1] + process(S, np.arange(S.shape[0]), max_index, a)[:-1]
+            return (
+                process(S, np.arange(S.shape[0]), a, max_index)[:-1]
+                + process(S, np.arange(S.shape[0]), max_index, a)[:-1]
+            )
 
         if len(pts) == 0:
             return
@@ -4685,7 +4793,6 @@ class Geomstr:
             for p in res_pts:
                 yield complex(p[0], p[1])
 
-
     def _convex_hull_original(self, pts):
         """
         Generate points of the convex hull around the given points.
@@ -4756,7 +4863,9 @@ class Geomstr:
         # but that will let multiple unit tests fail
         # val = (q.real - p.real) * (r.imag - p.imag) - (q.imag - p.imag) * (r.real - p.real)
 
-        val = (q.imag - p.imag) * (r.real - q.real) - (q.real - p.real) * (r.imag - q.imag)
+        val = (q.imag - p.imag) * (r.real - q.real) - (q.real - p.real) * (
+            r.imag - q.imag
+        )
         if val == 0:
             return "linear"
         elif val > 0:
@@ -5414,7 +5523,9 @@ class Geomstr:
             self.segments[p1] = c
             pt = c[-1]
 
-    def two_opt_distance(self, max_passes=None, chunk=0, auto_stop_threshold=None, feedback=None):
+    def two_opt_distance(
+        self, max_passes=None, chunk=0, auto_stop_threshold=None, feedback=None
+    ):
         """
         Perform two-opt optimization to minimize travel distances.
         @param max_passes: Max number of passes to attempt
@@ -5435,7 +5546,11 @@ class Geomstr:
         improved = True
         first_travel = self.travel_distance()
         last_travel = first_travel
-        threshold_value = None if auto_stop_threshold is None else auto_stop_threshold / 100.0 * last_travel
+        threshold_value = (
+            None
+            if auto_stop_threshold is None
+            else auto_stop_threshold / 100.0 * last_travel
+        )
         while improved:
             improved = False
 
@@ -5644,7 +5759,9 @@ class Geomstr:
                 elif threshold is not None:
                     newpoints = simplifier.simplify(threshold=threshold)
                 else:
-                    raise ValueError("You need to provide at least one parameter for simplify_geomstr")
+                    raise ValueError(
+                        "You need to provide at least one parameter for simplify_geomstr"
+                    )
                 newgeom.append(Geomstr.lines(newpoints))
                 points.clear()