meerk40t 0.9.7051__py2.py3-none-any.whl → 0.9.7910__py2.py3-none-any.whl

meerk40t/tools/geomstr.py

@@ -199,13 +199,17 @@ def stitcheable_nodes(data, tolerance) -> list:
     if tolerance == 0:
         tolerance = 1e-6
     for idx1, (nodeidx1, g1) in enumerate(geoms):
+        fp1 = g1.first_point
+        lp1 = g1.last_point
+        if fp1 is None or lp1 is None:
+            continue
         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 fp2 is None or lp2 is None:
+                continue
             if (
                 abs(lp1 - lp2) <= tolerance
                 or abs(lp1 - fp2) <= tolerance
@@ -251,11 +255,16 @@ def stitch_geometries(geometry_list: list, tolerance: float = 0.0) -> list:
         while geometries:
             candidate = geometries.pop(0)
             stitched = False
+            cand_fp = candidate.first_point
+            cand_lp = candidate.last_point
+            if cand_fp is None or cand_lp is None:
+                stitched_geometries.append(candidate)
+                continue
             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 targ_fp is None or targ_lp is None:
+                    continue
                 if abs(targ_lp - cand_fp) <= tolerance:
                     # Just append g1 to g2
                     if abs(targ_lp - cand_fp) > 0:
@@ -496,7 +505,7 @@ class Simplifier:
 
     def by_ratio(self, r):
         if r <= 0 or r > 1:
-            raise ValueError("Ratio must be 0<r<=1. Got {}".format(r))
+            raise ValueError(f"Ratio must be 0<r<=1. Got {r}")
 
         return self.by_number(r * len(self.thresholds))
 
@@ -531,7 +540,7 @@ class Clip:
                 x3 < y3,
             )
         ).all(axis=2)
-        splits = [list() for _ in range(len(subject))]
+        splits = [[] for _ in range(len(subject))]
         for s0, s1 in sorted(np.argwhere(checks), key=lambda e: e[0], reverse=True):
             splits[s0].extend(
                 [t for t, _ in subject.intersections(int(s0), clip.segments[s1])]
@@ -546,7 +555,7 @@ class Clip:
         @param clip:
         @return:
         """
-        splits = [list() for _ in range(len(subject))]
+        splits = [[] for _ in range(len(subject))]
         for s0 in range(len(subject)):
             for s1 in range(len(clip)):
                 for t0, t1 in subject.intersections(int(s0), clip.segments[s1]):
@@ -774,12 +783,12 @@ class Pattern:
         # Scale once, translate often
         m = Matrix.scale(cw, ch)
         geom = self.geomstr.as_transformed(m)
-        for col in range(start_value_x, cols + end_value_x, 1):
+        for col in range(start_value_x, cols + end_value_x):
             x_offset = col * (cw + 2 * px)
             x = top_left_x + x_offset
 
             top_left_y = y0
-            for row in range(start_value_y, rows + end_value_y, 1):
+            for row in range(start_value_y, rows + end_value_y):
                 y_offset = row * (ch + 2 * py)
                 if col % 2:
                     y_offset += (ch + 2 * py) / 2
@@ -942,9 +951,9 @@ class BeamTable:
             event = events[i]
             pt, adds, removes, sorts = event
             try:
-                next, _, _, _ = events[i + 1]
+                next_idx, _, _, _ = events[i + 1]
             except IndexError:
-                next = complex(float("inf"), float("inf"))
+                next_idx = complex(float("inf"), float("inf"))
 
             for index in removes:
                 try:
@@ -978,7 +987,7 @@ class BeamTable:
                     # was removed
                     pass
             i += 1
-            if pt == next:
+            if pt == next_idx:
                 continue
             if len(actives) > largest_actives:
                 largest_actives = len(actives)
@@ -1041,11 +1050,11 @@ class BeamTable:
             pt, index, swap = event
 
             try:
-                next, _, _ = events[i + 1]
-                scanline = (pt + next) / 2
+                next_idx, _, _ = events[i + 1]
+                scanline = (pt + next_idx) / 2
             except IndexError:
-                next = complex(float("inf"), float("inf"))
-                scanline = next
+                next_idx = complex(float("inf"), float("inf"))
+                scanline = next_idx
 
             if swap is not None:
                 s1 = actives.index(swap[0])
@@ -1058,7 +1067,7 @@ class BeamTable:
                 remove_index = actives.index(~index)
                 del actives[remove_index]
 
-            if pt != next:
+            if pt != next_idx:
                 if len(actives) > largest_actives:
                     largest_actives = len(actives)
                 # actives.sort(key=y_ints)
@@ -1125,9 +1134,9 @@ class BeamTable:
         starts = np.ravel(np.real(from_vals) + y_start * 1j)
         ends = np.ravel(np.real(to_vals) + y_end * 1j)
 
-        filter = np.dstack((starts != ends, ~np.isnan(starts))).all(axis=2)[0]
-        starts = starts[filter]
-        ends = ends[filter]
+        filtered = np.dstack((starts != ends, ~np.isnan(starts))).all(axis=2)[0]
+        starts = starts[filtered]
+        ends = ends[filtered]
         count = starts.shape[0]
         segments = np.dstack(
             (starts, [0] * count, [TYPE_LINE] * count, [0] * count, ends)
@@ -1147,7 +1156,7 @@ class BeamTable:
     def difference(self, *args):
         return self.cag("difference", *args)
 
-    def cag(self, cag_op, *args):
+    def cag_org(self, cag_op, *args):
         if self.geometry.index == 0:
             return Geomstr()
         if self._nb_scan is None:
@@ -1198,6 +1207,79 @@ class BeamTable:
         g.append_lines(segments)
         return g
 
+    def cag(self, cag_op, *args):
+        """
+        Vectorized CAG function that processes all arguments at once to reduce
+        Python loop overhead.
+        """
+        if self.geometry.index == 0:
+            return Geomstr()
+        if self._nb_scan is None:
+            self.compute_beam()
+
+        g = Geomstr()
+        actives = self._nb_scan[:-1]
+        lines = self.geometry.segments[actives, 2]
+
+        # Create a 3D mask for all arguments at once. Shape: (args, events, actives)
+        # This avoids the Python loop over `args`.
+        m = (np.imag(lines)[None, :, :] == np.array(args)[:, None, None]) & (
+            actives != -1
+        )
+
+        # Perform cumsum on the 3D array and combine results.
+        # This is the most computationally expensive part.
+        qq = (np.cumsum(m, axis=2) & 1).astype(bool)
+
+        # Combine the results from all arguments based on the CAG operation.
+        if cag_op == "union":
+            cc = np.any(qq, axis=0)
+        elif cag_op == "intersection":
+            cc = np.all(qq, axis=0)
+        elif cag_op == "xor":
+            # XOR is a reduction, so we sum the boolean values and check for oddness.
+            cc = (np.sum(qq, axis=0) & 1).astype(bool)
+        elif cag_op == "difference":
+            # A \ B is equivalent to A & ~B. For multiple args: A \ B \ C -> A & ~B & ~C
+            cc = qq[0]
+            if len(args) > 1:
+                cc &= np.all(~qq[1:], axis=0)
+        else:  # "eq"
+            # Check if all rows in qq are identical for each event/active pair.
+            cc = np.all(qq == qq[0], axis=0)
+
+        # manual pad (faster than np.pad), then diff
+        hshape = (cc.shape[0], cc.shape[1] + 1)
+        yy = np.zeros(hshape, dtype=np.int8)
+        yy[:, 1:] = cc.view(np.int8)
+        hh = np.diff(yy, axis=1)
+
+        # prepare event arrays only once
+        ev0, ev1 = self._nb_events[:-1], self._nb_events[1:]
+        r0, i0 = np.real(ev0), np.imag(ev0)
+        r1, i1 = np.real(ev1), np.imag(ev1)
+
+        # compute all intercepts
+        y0 = self.geometry.y_intercept(actives, r0, i0)
+        y1 = self.geometry.y_intercept(actives, r1, i1)
+
+        # broadcast real parts to match y-shapes (views, no copy)
+        starts = r0[:, None] + y0 * 1j
+        ends = r1[:, None] + y1 * 1j
+
+        # one-shot filter
+        valid = (starts != ends) & ~np.isnan(starts) & (hh != 0)
+        if np.any(valid):
+            segs = np.empty((np.count_nonzero(valid), 5), dtype=complex)
+            segs[:, 0] = starts[valid]
+            segs[:, 1] = 0
+            segs[:, 2] = TYPE_LINE
+            segs[:, 3] = 0
+            segs[:, 4] = ends[valid]
+            g.append_lines(segs)
+
+        return g
+
 
 class Scanbeam:
     """
@@ -1575,7 +1657,7 @@ class Geomstr:
     """
 
     def __init__(self, segments=None):
-        self._settings = dict()
+        self._settings = {}
         if segments is not None:
             if isinstance(segments, Geomstr):
                 self._settings.update(segments._settings)
@@ -2261,13 +2343,13 @@ class Geomstr:
         @param end_pos:
         @param start_pos:
         """
-        segments = list()
+        segments = []
         for point in self.as_contiguous_points(start_pos=start_pos, end_pos=end_pos):
             if isinstance(point, tuple):
                 point, settings = point
                 if segments:
                     yield segments, settings
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
 
@@ -2331,12 +2413,12 @@ class Geomstr:
         @param distance:
         @return:
         """
-        segments = list()
+        segments = []
         for point in self.as_equal_interpolated_points(distance=distance):
             if point is None:
                 if segments:
                     yield segments
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
         if segments:
@@ -2445,12 +2527,12 @@ class Geomstr:
         @param interpolate:
         @return:
         """
-        segments = list()
+        segments = []
         for point in self.as_interpolated_points(interpolate=interpolate):
             if point is None:
                 if segments:
                     yield segments
-                    segments = list()
+                    segments = []
             else:
                 segments.append(point)
         if segments:
@@ -2871,7 +2953,7 @@ class Geomstr:
 
         p_start = point_at_t(current_t)
 
-        for i in range(0, slices):
+        for i in range(slices):
             next_t = current_t + t_slice
             mid_t = (next_t + current_t) / 2
 
@@ -2932,7 +3014,7 @@ class Geomstr:
 
         p_start = point_at_t(current_t)
 
-        for i in range(0, slices):
+        for i in range(slices):
             next_t = current_t + t_slice
             if i == slices - 1:
                 next_t = end_t
@@ -3035,7 +3117,7 @@ class Geomstr:
         c = Clip(other)
         polycut = c.polycut(self, breaks=True)
 
-        geoms = list()
+        geoms = []
         g = Geomstr()
         geoms.append(g)
         for e in polycut.segments[: self.index]:
@@ -4009,10 +4091,9 @@ class Geomstr:
             return
         if segtype2 in NON_GEOMETRY_TYPES:
             return
-        if segtype1 == TYPE_LINE:
-            if segtype2 == TYPE_LINE:
-                yield from self._line_line_intersections(line1, line2)
-                return
+        if segtype1 == TYPE_LINE and segtype2 == TYPE_LINE:
+            yield from self._line_line_intersections(line1, line2)
+            return
         #     if oinfo.real == TYPE_QUAD:
         #         yield from self._line_quad_intersections(line1, line2)
         #         return
@@ -5227,22 +5308,34 @@ class Geomstr:
     def as_contiguous(self):
         """
         Generate individual subpaths of contiguous segments
+        Attention: this will not yield meta segments, like TYPE_NOP and others
 
         @return:
         """
-        last = 0
+        new_segments = []
         for idx, seg in enumerate(self.segments[: self.index]):
             segtype = self._segtype(seg)
+            if segtype in META_TYPES:
+                # Skip meta segments
+                continue
             if segtype == TYPE_END:
-                yield Geomstr(self.segments[last:idx])
-                last = idx + 1
-            elif idx > 0:
-                # are the start and endpositions different?
-                if self.segments[idx, 0] != self.segments[idx - 1, -1]:
-                    yield Geomstr(self.segments[last:idx])
-                    last = idx
-        if last != self.index:
-            yield Geomstr(self.segments[last : self.index])
+                if len(new_segments) > 0:
+                    yield Geomstr(new_segments)
+                new_segments.clear()
+            else:
+                if len(new_segments) == 0:
+                    new_segments.append(seg)
+                elif seg[0] != new_segments[-1][-1]:
+                    # If the start of the current segment is not the end of the last segment
+                    yield Geomstr(new_segments)
+                    new_segments.clear()
+                    new_segments.append(seg)
+                else:
+                    # If the start of the current segment is the end of the last segment
+                    new_segments.append(seg)
+        if len(new_segments) > 0:
+            # If there are still segments left, yield them
+            yield Geomstr(new_segments)
 
     def ensure_proper_subpaths(self):
         """
@@ -5489,7 +5582,7 @@ class Geomstr:
         """
         infos = self.segments[: self.index, 2]
         q = np.where(np.real(infos).astype(int) & 0b1001)[0]
-        for mid in range(0, len(q)):
+        for mid in range(len(q)):
             idxs = q[mid:]
             p1 = idxs[0]
             pen_downs = self.segments[idxs, 0]
@@ -5676,8 +5769,8 @@ class Geomstr:
         if lines is None:
             lines = self.segments[: self.index]
         if function_dict is None:
-            function_dict = dict()
-        default_dict = dict()
+            function_dict = {}
+        default_dict = {}
         defining_function = 0
         function_start = 0
         for index, line in enumerate(lines):
@@ -5735,7 +5828,7 @@ class Geomstr:
         final = Geomstr()
         for subgeom in geom.as_subpaths():
             newgeom = Geomstr()
-            points = list()
+            points = []
             closed = subgeom.is_closed()
 
             def processpts():

meerk40t/tools/rasterplotter.py

@@ -467,11 +467,6 @@ class RasterPlotter:
                 return int(round(self.offset_x)), int(round(self.offset_y))
             else:
                 return self.offset_x, self.offset_y
-        if self.use_integers:
-            if self.use_integers:
-                return int(round(self.offset_x)), int(round(self.offset_y))
-            else:
-                return self.offset_x, self.offset_y
         if self.use_integers:
             return (
                 int(round(self.offset_x + self.final_x * self.step_x)),