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

meerk40t/tools/geomstr.py

@@ -97,90 +97,115 @@ class Clip:
         self.clipping_shape = shape
         self.bounds = shape.bbox()
 
-    def clip(self, subject, split=True):
-        clip = self.clipping_shape
-        if split:
-            s = subject.segments[: subject.index]
-            c = clip.segments[: clip.index]
-            cmaxx = np.where(
-                np.real(c[:, 0]) > np.real(c[:, -1]),
-                np.real(c[:, 0]),
-                np.real(c[:, -1]),
-            )
-            sminx = np.where(
-                np.real(s[:, 0]) < np.real(s[:, -1]),
-                np.real(s[:, 0]),
-                np.real(s[:, -1]),
-            )
-            cminx = np.where(
-                np.real(c[:, 0]) < np.real(c[:, -1]),
-                np.real(c[:, 0]),
-                np.real(c[:, -1]),
-            )
-            smaxx = np.where(
-                np.real(s[:, 0]) > np.real(s[:, -1]),
-                np.real(s[:, 0]),
-                np.real(s[:, -1]),
-            )
-            cmaxy = np.where(
-                np.imag(c[:, 0]) > np.imag(c[:, -1]),
-                np.imag(c[:, 0]),
-                np.imag(c[:, -1]),
-            )
-            sminy = np.where(
-                np.imag(s[:, 0]) < np.imag(s[:, -1]),
-                np.imag(s[:, 0]),
-                np.imag(s[:, -1]),
-            )
-            cminy = np.where(
-                np.imag(c[:, 0]) < np.imag(c[:, -1]),
-                np.imag(c[:, 0]),
-                np.imag(c[:, -1]),
+    def _splits(self, subject, clip):
+        """
+        Calculate the splits in `subject` by the clip. This should return a list of t positions with the list being
+        as long as the number of segments in subject. Finds all intersections between subject and clip and the given
+        split positions (of subject) that would make the intersection list non-existant.
+
+        @param subject:
+        @param clip:
+        @return:
+        """
+        cminx, cminy, cmaxx, cmaxy = clip.aabb()
+        sminx, sminy, smaxx, smaxy = subject.aabb()
+        x0, y0 = np.meshgrid(cmaxx, sminx)
+        x1, y1 = np.meshgrid(cminx, smaxx)
+        x2, y2 = np.meshgrid(cmaxy, sminy)
+        x3, y3 = np.meshgrid(cminy, smaxy)
+
+        checks = np.dstack(
+            (
+                x0 > y0,
+                x1 < y1,
+                x2 > y2,
+                x3 < y3,
             )
-            smaxy = np.where(
-                np.imag(s[:, 0]) > np.imag(s[:, -1]),
-                np.imag(s[:, 0]),
-                np.imag(s[:, -1]),
+        ).all(axis=2)
+        splits = [list() 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])]
             )
-            x0, y0 = np.meshgrid(cmaxx, sminx)
-            x1, y1 = np.meshgrid(cminx, smaxx)
-            x2, y2 = np.meshgrid(cmaxy, sminy)
-            x3, y3 = np.meshgrid(cminy, smaxy)
+        return splits
+
+    def _splits_brute(self, subject, clip):
+        """
+        Find the subject clip splits by brute force (for debug testing).
+
+        @param subject:
+        @param clip:
+        @return:
+        """
+        splits = [list() 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]):
+                    splits[s0].append(t0)
+
+        return splits
+
+    def inside(self, subject):
+        """
+        Modifies subject to only contain the segments found inside the given clip.
+        @param subject:
+        @param clip:
+        @return:
+        """
+        clip = self.clipping_shape
+        c = Geomstr()
+        # Pip currently only works with line segments
+        for sp in clip.as_subpaths():
+            for segs in sp.as_interpolated_segments(interpolate=100):
+                c.polyline(segs)
+                c.end()
+        sb = Scanbeam(c)
 
-            checks = np.dstack(
-                (
-                    x0 > y0,
-                    x1 < y1,
-                    x2 > y2,
-                    x3 < y3,
-                )
-            ).all(axis=2)
-            # new_subject = Geomstr(s)
-            for s0, s1 in sorted(np.argwhere(checks), key=lambda e: e[0], reverse=True):
-                splits0 = [
-                    t for t, _ in subject.intersections(int(s0), clip.segments[s1])
-                ]
-                if len(splits0):
-                    split_lines = list(subject.split(s0, splits0))
-                    subject.replace(s0, s0, split_lines)
-
-        # Previous bruteforce.
-        # for i in range(clip.index):
-        #     for c in range(subject.index - 1, -1, -1):
-        #         for t0, t1 in sorted(
-        #             list(subject.intersections(c, clip.segments[i])),
-        #             key=lambda t: t[0],
-        #             reverse=True,
-        #         ):
-        #             subject.split(c, t0)
-
-        sb = Scanbeam(clip)
         mid_points = subject.position(slice(subject.index), 0.5)
         r = np.where(sb.points_in_polygon(mid_points))
+
         subject.segments = subject.segments[r]
         subject.index = len(subject.segments)
         return subject
 
+    def polycut(self, subject, breaks=False):
+        """
+        Performs polycut on the subject using the preset clipping shape. This only prevents intersections making all
+        intersections into divided segments.
+
+        @param subject:
+        @param breaks: should the polycut insert overt breaks.
+        @return:
+        """
+        clip = self.clipping_shape
+        splits = self._splits(subject, clip)
+        # splits2 = self._splits_brute(subject, clip)
+        # for q1, q2 in zip(splits, splits2):
+        #     assert(q1, q2)
+
+        for s0 in range(len(splits) - 1, -1, -1):
+            s = splits[s0]
+            if not s:
+                continue
+            split_lines = list(subject.split(s0, s, breaks=breaks))
+            subject.replace(s0, s0, split_lines)
+        subject.validate()
+        return subject
+
+    def clip(self, subject, split=True):
+        """
+        Clip algorithm works in 3 steps. First find the splits between the subject and clip and split the subject at
+        all positions where it intersects clip. Remove any subject line segment whose midpoint is not found within
+        clip.
+
+        @param subject:
+        @param split:
+        @return:
+        """
+        if split:
+            subject = self.polycut(subject)
+        return self.inside(subject)
+
 
 class Pattern:
     def __init__(self, geomstr=None):
@@ -194,7 +219,6 @@ class Pattern:
         self.cell_height = y1 - y0
         self.padding_x = 0
         self.padding_y = 0
-        self.extend_pattern = False
 
     def create_from_pattern(self, pattern, a=None, b=None, *args, **kwargs):
         """
@@ -278,38 +302,314 @@ class Pattern:
         ch = self.cell_height
         px = self.padding_x
         py = self.padding_y
-        cx = cw + px * 2
-        cy = ch + py * 2
-        start_index_x = math.floor(x0 / cx) - 1
-        start_index_y = math.floor(y0 / cy) - 1
-        end_index_x = math.ceil(x1 / cx) + 1
-        end_index_y = math.ceil(y1 / cy) + 1
-
-        if self.extend_pattern:
-            row_offset = -0.5 * self.cell_width
-            start_index_x -= 1
+        if abs(cw + 2 * px) <= 1e-4:
+            cols = 1
         else:
-            row_offset = 0
-
-        for c in range(start_index_x, end_index_x):
-            x = c * cx + row_offset
-            for r in range(start_index_y, end_index_y):
-                y = r * cy
-                if c % 2:
-                    y += 0.5 * cy
-                # Don't call draw if outside of hinge area
+            cols = int(((x1 - x0) + cw) / (cw + 2 * px)) + 1
+        if abs(ch + 2 * py) <= 1e-4:
+            rows = 1
+        else:
+            rows = int(((y1 - y0) + ch) / (ch + 2 * py)) + 1
+
+        cols = max(1, cols - 2)
+        rows = max(1, rows - 2)
+
+        start_value_x = 0
+        col = 0
+        x_offset = (col + start_value_x) * (cw + 2 * px)
+        x = x0 + x_offset
+        while x >= x0 - cw and x < x1:
+            start_value_x -= 1
+            x_offset = (col + start_value_x) * (cw + 2 * px)
+            x = x0 + x_offset
+            # print (f"X-lower bound: sx={start_value_x}, x={x:.2f}, x0={x0:.2f}, x1={x1:.2f}")
+
+        end_value_x = 0
+        col = cols - 1
+        x_offset = (col + end_value_x) * (cw + 2 * px)
+        x = x0 + x_offset
+        while x >= x0 and x < x1:
+            end_value_x += 1
+            x_offset = (col + end_value_x) * (cw + 2 * px)
+            x = x0 + x_offset
+            # print (f"X-upper bound: ex={end_value_x}, x={x:.2f}, x0={x0:.2f}, x1={x1:.2f}")
+
+        start_value_y = 0
+        row = 0
+        y_offset = (row + start_value_y) * (ch + 2 * py)
+        y = y0 + y_offset
+        while y >= y0 - ch and y < y1:
+            start_value_y -= 1
+            y_offset = (row + start_value_y) * (ch + 2 * py)
+            y = y0 + y_offset
+            # print (f"Y-lower bound: sy={start_value_y}, y={y:.2f}, y0={y0:.2f}, y1={y1:.2f}")
+
+        end_value_y = 0
+        row = rows - 1
+        y_offset = (row + end_value_y) * (ch + 2 * py)
+        y = y0 + y_offset
+        while y >= y0 and y < y1:
+            end_value_y += 1
+            y_offset = (row + end_value_y) * (ch + 2 * py)
+            y = y0 + y_offset
+            # print (f"Y-upper bound: ey={end_value_y}, y={y:.2f}, y0={y0:.2f}, y1={y1:.2f}")
+
+        # print (f"Cols={cols}, s_x={start_value_x}, e_x={end_value_x}")
+        # print (f"Rows={rows}, s_y={start_value_y}, e_y={end_value_y}")
+
+        # start_value_x -= 2
+        # start_value_y -= 2
+        # end_value_x += 1
+        # end_value_y += 1
+
+        top_left_x = x0
+        for col in range(start_value_x, cols + end_value_x, 1):
+            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):
+                y_offset = row * (ch + 2 * py)
+                if col % 2:
+                    y_offset += (ch + 2 * py) / 2
+                y = top_left_y + y_offset
+
                 m = Matrix.scale(cw, ch)
                 m *= Matrix.translate(x - self.offset_x, y - self.offset_y)
                 yield self.geomstr.as_transformed(m)
 
 
-class PolyBool:
-    def __init__(self):
-        self.inputs = list()
-        # List of each segment info about it.
+class BeamTable:
+    def __init__(self, geom):
+        self.geometry = geom
+        self._nb_events = None
+        self._nb_scan = None
+        self.intersections = Geomstr()
+
+    def sort_key(self, e):
+        return e[0].real, e[0].imag, ~e[1]
+
+    def compute_beam(self):
+        g = self.geometry
+        gs = g.segments
+        events = []
+        # Add start and end events.
+        for i in range(g.index):
+            if gs[i][2] != TYPE_LINE:
+                continue
+            if (gs[i][0].imag, gs[i][0].real) < (gs[i][-1].imag, gs[i][-1].real):
+                events.append((g.segments[i][0], i, None))
+                events.append((g.segments[i][-1], ~i, None))
+            else:
+                events.append((g.segments[i][0], ~i, None))
+                events.append((g.segments[i][-1], i, None))
+
+        # Sort start and end events.
+        events.sort(key=self.sort_key)
+
+        def check_intersection(q, r, y):
+            """
+            Check for intersections between p and r, at y.
+
+            p must occur before r in the sorted actives.
+
+            y is used to ensure this is a future point.
+            @param q: lower-active value
+            @param r: higher-active value
+            @param y: y value to not be equal
+            @return:
+            """
+            try:
+                for t1, t2 in g.intersections(q, r):
+                    if t1 in (0, 1) and t2 in (0, 1):
+                        continue
+                    pt_intersect = g.position(q, t1)
+                    if y < pt_intersect.imag:
+                        events.append((pt_intersect, 0, (q, r)))
+                        self.intersections.point(pt_intersect)
+                        events.sort(key=self.sort_key)
+            except AttributeError:
+                pass
+
+        # Store currently active segments.
+        actives = []
 
-    def add_segments(self, g):
-        self.inputs.append(g)
+        # Store previously active segments
+        active_lists = []
+
+        largest_actives = 0
+        for pt, index, swap in events:
+            x_pos = pt.real
+            y_pos = pt.imag
+            if isinstance(swap, tuple):
+                idx1, idx2 = swap
+                pos1 = actives.index(idx1)
+                pos2 = actives.index(idx2)
+                actives[pos1], actives[pos2] = actives[pos2], actives[pos1]
+                # We swapped pos1 and pos2 so we must check the outer values of this swap.
+                try:
+                    check_intersection(actives[pos1 - 1], actives[pos1], y_pos)
+                except IndexError:
+                    pass
+                try:
+                    check_intersection(actives[pos2], actives[pos2 + 1], y_pos)
+                except IndexError:
+                    pass
+            elif index >= 0:
+                # Index is being inserted, find x-position sorted.
+                lines = g.segments[actives]
+                a = lines[:, 0]
+                b = lines[:, -1]
+
+                old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+                try:
+                    # If horizontal slope is undefined. But, all x-ints are at x since x0=x1
+                    m = (b.imag - a.imag) / (b.real - a.real)
+                    y0 = a.imag - (m * a.real)
+                    x_intercepts = np.where(~np.isinf(m), (y_pos - y0) / m, a.real)
+                finally:
+                    np.seterr(**old_np_seterr)
+                idx = np.searchsorted(x_intercepts, np.imag(pt))
+                actives.insert(idx, index)
+                if len(actives) > largest_actives:
+                    largest_actives = len(actives)
+
+                # Check intersections between idx, idx + 1
+                try:
+                    check_intersection(index, actives[idx + 1], y_pos)
+                except IndexError:
+                    pass
+
+                # Check intersections between idx, idx - 1
+                try:
+                    check_intersection(actives[idx - 1], index, y_pos)
+                except IndexError:
+                    pass
+            else:
+                remove_index = actives.index(~index)
+                # Check intersections between idx-1, idx+ 1
+                try:
+                    check_intersection(actives[idx - 1], actives[idx + 1], y_pos)
+                except IndexError:
+                    pass
+                del actives[remove_index]
+
+            active_lists.append(list(actives))
+
+        active_lists.append([])
+        self._nb_events = [(e.imag, e.real) for e, _, _ in events]
+        self._nb_scan = np.zeros((len(active_lists), largest_actives), dtype=int)
+        self._nb_scan -= 1
+        for i, active in enumerate(active_lists):
+            self._nb_scan[i, 0 : len(active)] = active
+
+    def compute_beam_brute(self):
+        g = self.geometry
+        gs = g.segments
+        events = []
+        # Add start and end events.
+        for i in range(g.index):
+            if gs[i][2] != TYPE_LINE:
+                continue
+            if (gs[i][0].real, gs[i][0].imag) < (gs[i][-1].real, gs[i][-1].imag):
+                events.append((g.segments[i][0], i, None))
+                events.append((g.segments[i][-1], ~i, None))
+            else:
+                events.append((g.segments[i][0], ~i, None))
+                events.append((g.segments[i][-1], i, None))
+
+        wh, p, ta, tb = g.brute_line_intersections()
+        for w, pos in zip(wh, p):
+            events.append((pos, 0, w))
+            self.intersections.point(pos)
+
+        # Sort start, end, intersections events.
+        events.sort(key=self.sort_key)
+
+        # Store currently active segments.
+        actives = []
+
+        scanline = None
+
+        def x_ints(e):
+            return g.x_intercept(e, np.real(scanline))
+
+        # Store previously active segments
+        active_lists = []
+        real_events = []
+
+        largest_actives = 0
+
+        for i in range(len(events)):
+            event = events[i]
+            pt, index, swap = event
+
+            try:
+                next, _, _ = events[i + 1]
+                scanline = (pt + next) / 2
+            except IndexError:
+                next = complex(float("inf"), float("inf"))
+                scanline = next
+
+            if swap is not None:
+                pass
+            elif index >= 0:
+                actives.append(index)
+            else:
+                remove_index = actives.index(~index)
+                del actives[remove_index]
+
+            if pt != next:
+                if len(actives) > largest_actives:
+                    largest_actives = len(actives)
+                actives.sort(key=x_ints)
+                real_events.append(pt)
+                active_lists.append(list(actives))
+
+        self._nb_events = real_events
+        self._nb_scan = np.zeros((len(active_lists), largest_actives), dtype=int)
+        self._nb_scan -= 1
+        for i, active in enumerate(active_lists):
+            self._nb_scan[i, 0 : len(active)] = active
+
+    def points_in_polygon(self, e):
+        if self._nb_scan is None:
+            self.compute_beam_brute()
+        idx = np.searchsorted(self._nb_events, e)
+        actives = self._nb_scan[idx]
+        line = self.geometry.segments[actives]
+        a = line[:, :, 0]
+        a = np.where(actives == -1, np.nan + np.nan * 1j, a)
+        b = line[:, :, -1]
+        b = np.where(actives == -1, np.nan + np.nan * 1j, b)
+
+        q = self.geometry.y_intercept(actives, np.real(e))
+        # print(q)
+
+        old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+        try:
+            # If horizontal slope is undefined. But, all x-ints are at x since x0=x1
+            m = (b.real - a.real) / (b.imag - a.imag)
+            y0 = a.real - (m * a.imag)
+            ys = np.reshape(np.repeat(np.real(e), y0.shape[1]), y0.shape)
+            y_intercepts = np.where(~np.isinf(m), (ys - y0) / m, a.imag)
+        finally:
+            np.seterr(**old_np_seterr)
+        xs = np.reshape(np.repeat(np.imag(e), y0.shape[1]), y0.shape)
+        results = np.sum(y_intercepts <= xs, axis=1)
+        results %= 2
+        return results
+
+    def actives_at(self, value):
+        from bisect import bisect
+
+        if not self._nb_scan:
+            self.compute_beam_brute()
+        idx = np.searchsorted(self._nb_events, value)
+        # idx = bisect(self._nb_events, (value.imag, value.real))
+        actives = self._nb_scan[idx - 1]
+        aw = np.argwhere(actives != -1)[:, 0]
+        return actives[aw]
 
 
 class Scanbeam:
@@ -1070,6 +1370,81 @@ class Geomstr:
         geometry.rotate(-angle)
         return geometry
 
+    @classmethod
+    def wobble(cls, algorithm, outer, radius, interval, speed):
+        from meerk40t.fill.fills import Wobble
+
+        w = Wobble(algorithm, radius=radius, speed=speed, interval=interval)
+
+        geometry = cls()
+        for segments in outer.as_interpolated_segments(interpolate=50):
+            points = []
+            last = None
+            for pt in segments:
+                if last is not None:
+                    points.extend(
+                        [
+                            complex(wx, wy)
+                            for wx, wy in w(last.real, last.imag, pt.real, pt.imag)
+                        ]
+                    )
+                last = pt
+            geometry.append(Geomstr.lines(*points))
+        return geometry
+
+    @classmethod
+    def wobble_slowtooth(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import slowtooth as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_gear(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import gear as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_jigsaw(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import jigsaw as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_sawtooth(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import sawtooth as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_sinewave(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import sinewave as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_circle_left(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import circle_left as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_circle_right(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import circle_right as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    @classmethod
+    def wobble_circle(cls, outer, radius, interval, speed):
+        from meerk40t.fill.fills import circle as algorithm
+
+        return cls.wobble(algorithm, outer, radius, interval, speed)
+
+    def flag_settings(self):
+        for i in range(self.index):
+            info = self.segments[i][2]
+            self.segments[i][2] = complex(info.real, i)
+
     def copies(self, n):
         segs = self.segments[: self.index]
         self.segments = np.vstack([segs] * n)
@@ -1198,6 +1573,11 @@ class Geomstr:
         self.allocate_at_position(e, space)
         self.segments[e : e + space] = lines
 
+    def append_lines(self, lines):
+        self._ensure_capacity(self.index + len(lines))
+        self.segments[self.index : self.index + len(lines)] = lines
+        self.index += len(lines)
+
     def append(self, other):
         self._ensure_capacity(self.index + other.index + 1)
         if self.index != 0:
@@ -1207,6 +1587,25 @@ class Geomstr:
         ]
         self.index += other.index
 
+    def validate(self):
+        infos = self.segments[: self.index, 2]
+
+        starts = self.segments[: self.index, 0]
+        q = np.where(np.real(infos).astype(int) & 0b1000)
+        assert not np.any(np.isnan(starts[q]))
+
+        ends = self.segments[: self.index, 4]
+        q = np.where(np.real(infos).astype(int) & 0b0001)
+        assert not np.any(np.isnan(ends[q]))
+
+        c1 = self.segments[: self.index, 1]
+        q = np.where(np.real(infos).astype(int) & 0b0100)
+        assert not np.any(np.isnan(c1[q]))
+
+        c2 = self.segments[: self.index, 3]
+        q = np.where(np.real(infos).astype(int) & 0b0010)
+        assert not np.any(np.isnan(c2[q]))
+
     #######################
     # Geometric Primitives
     #######################
@@ -1570,6 +1969,36 @@ class Geomstr:
         r.translate(p1.real, p1.imag)
         return r
 
+    def divide(self, other):
+        """
+        Divide the current closed point shape by the other.
+
+        This should probably use the other part doing to splitting to create a proper divide. So if cut with a bezier
+        we would get a bezier segment making the connection on both sides of the shape.
+
+        @param other:
+        @return:
+        """
+        closed = self.is_closed()
+        c = Clip(other)
+        polycut = c.polycut(self, breaks=True)
+
+        geoms = list()
+        g = Geomstr()
+        geoms.append(g)
+        for e in polycut.segments[: self.index]:
+            if e[2].real == TYPE_END:
+                g = Geomstr()
+                geoms.append(g)
+            else:
+                g.append_lines([e])
+        if closed and len(geoms) >= 2:
+            first = geoms[0]
+            last = geoms[-1]
+            del geoms[-1]
+            first.insert(0, last.segments[: last.index])
+        return geoms
+
     def round_corners(self, amount=0.2):
         """
         Round segment corners.
@@ -1692,6 +2121,33 @@ class Geomstr:
     # Universal Functions
     #######################
 
+    def aabb(self):
+        """
+        Calculate the per-segment `Axis Aligned Bounding Box` of each individual segment
+
+        @return:
+        """
+        c = self.segments[: self.index]
+        infos = np.real(c[:, 2]).astype(int)
+
+        xs = np.dstack(
+            (
+                np.real(c[:, 0]),
+                np.real(c[:, 4]),
+                np.where(infos & 0b0100, np.real(c[:, 1]), np.real(c[:, 0])),
+                np.where(infos & 0b0010, np.real(c[:, 3]), np.real(c[:, 4])),
+            )
+        )
+        ys = np.dstack(
+            (
+                np.imag(c[:, 0]),
+                np.imag(c[:, 4]),
+                np.where(infos & 0b0100, np.imag(c[:, 1]), np.imag(c[:, 0])),
+                np.where(infos & 0b0010, np.imag(c[:, 3]), np.imag(c[:, 4])),
+            )
+        )
+        return xs.min(axis=2), ys.min(axis=2), xs.max(axis=2), ys.max(axis=2)
+
     def bbox(self, mx=None, e=None):
         """
         Get the bounds of the given geom primitive
@@ -2103,7 +2559,7 @@ class Geomstr:
 
         return quad(_abs_derivative, 0.0, 1.0, epsabs=1e-12, limit=1000)[0]
 
-    def split(self, e, t):
+    def split(self, e, t, breaks=False):
         """
         Splits individual geom e at position t [0-1]
 
@@ -2123,19 +2579,27 @@ class Geomstr:
             mid = self.towards(start, end, t)
             if isinstance(mid, complex):
                 yield start, control, info, control2, mid
+                if breaks:
+                    yield mid, mid, complex(TYPE_END, info.imag), mid, mid
                 yield mid, control, info, control2, end
             else:
                 # Mid is an array of complexes
                 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], control, info, control2, mid[i]
+                if breaks:
+                    yield mid[-1], 0, complex(TYPE_END, info.imag), 0, mid[-1]
                 yield mid[-1], control, info, control2, end
         if info.real == TYPE_QUAD:
-            yield from self._split_quad(e, t)
+            yield from self._split_quad(e, t, breaks=breaks)
         if info.real == TYPE_CUBIC:
-            yield from self._split_cubic(e, t)
+            yield from self._split_cubic(e, t, breaks=breaks)
 
-    def _split_quad(self, e, t):
+    def _split_quad(self, e, t, breaks):
         """
         Performs deCasteljau's algorithm unrolled.
         """
@@ -2153,7 +2617,9 @@ class Geomstr:
                 last = 0.0
                 for t0 in sorted(t):
                     # Thanks tiger.
-                    splits = list(self._split_quad(e, (t0 - last) / (1 - last)))
+                    splits = list(
+                        self._split_quad(e, (t0 - last) / (1 - last), breaks=breaks)
+                    )
                     last = t0
                     yield splits[0]
                     e = splits[1]
@@ -2164,9 +2630,10 @@ class Geomstr:
         r1_1 = t * (end - control) + control
         r2 = t * (r1_1 - r1_0) + r1_0
         yield start, r1_0, info, r1_0, r2
+        # yield r2, 0, complex(TYPE_END, info.imag), 0, r2
         yield r2, r1_1, info, r1_1, end
 
-    def _split_cubic(self, e, t):
+    def _split_cubic(self, e, t, breaks=False):
         if (
             not isinstance(e, (np.ndarray, tuple, list))
             or len(e) == 0
@@ -2180,7 +2647,9 @@ class Geomstr:
                 t = np.sort(t)
                 last = 0.0
                 for t0 in sorted(t):
-                    splits = list(self._split_cubic(e, (t0 - last) / (1 - last)))
+                    splits = list(
+                        self._split_cubic(e, (t0 - last) / (1 - last), breaks=breaks)
+                    )
                     last = t0
                     yield splits[0]
                     e = splits[1]
@@ -2194,6 +2663,7 @@ class Geomstr:
         r2_1 = t * (r1_2 - r1_1) + r1_1
         r3 = t * (r2_1 - r2_0) + r2_0
         yield start, r1_0, info, r2_0, r3
+        # yield r3, 0, complex(TYPE_END, info.imag), 0, r3
         yield r3, r2_1, info, r1_2, end
 
     def normal(self, e, t):
@@ -2444,22 +2914,22 @@ class Geomstr:
             if oinfo.real == 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
-            if oinfo.real == TYPE_CUBIC:
-                yield from self._line_cubic_intersections(line1, line2)
-                return
-
-        if info.real == TYPE_QUAD:
-            if oinfo.real == TYPE_LINE:
-                yield from self._line_quad_intersections(line2, line1)
-                return
-
-        if info.real == TYPE_CUBIC:
-            if oinfo.real == TYPE_LINE:
-                yield from self._line_cubic_intersections(line2, line1)
-                return
+        #     if oinfo.real == TYPE_QUAD:
+        #         yield from self._line_quad_intersections(line1, line2)
+        #         return
+        #     if oinfo.real == TYPE_CUBIC:
+        #         yield from self._line_cubic_intersections(line1, line2)
+        #         return
+        #
+        # if info.real == TYPE_QUAD:
+        #     if oinfo.real == TYPE_LINE:
+        #         yield from self._line_quad_intersections(line2, line1)
+        #         return
+        #
+        # if info.real == TYPE_CUBIC:
+        #     if oinfo.real == TYPE_LINE:
+        #         yield from self._line_cubic_intersections(line2, line1)
+        #         return
         yield from self._find_intersections(line1, line2)
 
     def _line_line_intersections(self, line1, line2):
@@ -2607,9 +3077,9 @@ class Geomstr:
         fun2 = self._get_segment_function(segment2[2].real)
         if fun1 is None or fun2 is None:
             return  # Only shapes can intersect. We don't do point x point.
-        yield from self._find_intersections_main(segment1, segment2, fun1, fun2)
+        yield from self._find_intersections_intercept(segment1, segment2, fun1, fun2)
 
-    def _find_intersections_main(
+    def _find_intersections_intercept(
         self,
         segment1,
         segment2,
@@ -2684,22 +3154,134 @@ class Geomstr:
         tb_hit = qb[hits] / denom[hits]
 
         for i, hit in enumerate(where_hit):
-            at = ta[0] + float(hit[1]) * step_a  # Zoomed min+segment intersected.
-            bt = tb[0] + float(hit[0]) * step_b
+            # Zoomed min+segment intersected.
+            # Fractional guess within intersected segment
+            at_guess = ta[0] + (hit[1] + ta_hit[i]) * step_a
+            bt_guess = tb[0] + (hit[0] + tb_hit[i]) * step_b
+
+            if depth == enhancements:
+                # We've enhanced as best as we can, yield the current + segment t-value to our answer
+                yield at_guess, bt_guess
+            else:
+                yield from self._find_intersections_intercept(
+                    segment1,
+                    segment2,
+                    fun1,
+                    fun2,
+                    ta=(at_guess - step_a / 2, at_guess + step_a / 2, at_guess),
+                    tb=(bt_guess - step_b / 2, bt_guess + step_b / 2, bt_guess),
+                    samples=enhance_samples,
+                    depth=depth + 1,
+                    enhancements=enhancements,
+                    enhance_samples=enhance_samples,
+                )
+
+    def _find_intersections_kross(
+        self,
+        segment1,
+        segment2,
+        fun1,
+        fun2,
+        samples=50,
+        ta=(0.0, 1.0, None),
+        tb=(0.0, 1.0, None),
+        depth=0,
+        enhancements=2,
+        enhance_samples=50,
+    ):
+        """
+        Calculate intersections by linearized polyline intersections with enhancements.
+        We calculate probable intersections by linearizing our segment into `sample` polylines
+        we then find those intersecting segments and the range of t where those intersections
+        could have occurred and then subdivide those segments in a series of enhancements to
+        find their intersections with increased precision.
+
+        This code is fast, but it could fail by both finding a rare phantom intersection (if there
+        is a low or no enhancements) or by failing to find a real intersection. Because the polylines
+        approximation did not intersect in the base case.
+
+        At a resolution of about 1e-15 the intersection calculations become unstable and intersection
+        candidates can duplicate or become lost. We terminate at that point and give the last best
+        guess.
+
+        :param segment1:
+        :param segment2:
+        :param samples:
+        :param ta:
+        :param tb:
+        :param depth:
+        :param enhancements:
+        :param enhance_samples:
+        :return:
+        """
+        assert samples >= 2
+        a = np.linspace(ta[0], ta[1], num=samples)
+        b = np.linspace(tb[0], tb[1], num=samples)
+        step_a = a[1] - a[0]
+        step_b = b[1] - b[0]
+        j = fun1(segment1, a)
+        k = fun2(segment2, b)
+
+        p0 = j[:-1]
+        d0 = j[1:] - j[:-1]
+        p1 = k[:-1]
+        d1 = k[1:] - k[:-1]
+
+        ap0, ap1 = np.meshgrid(p0, p1)
+        ad0, ad1 = np.meshgrid(d0, d1)
+        e = ap1 - ap0
+        ex = np.real(e)
+        ey = np.imag(e)
+        d0x = np.real(ad0)
+        d0y = np.imag(ad0)
+        d1x = np.real(ad1)
+        d1y = np.imag(ad1)
+
+        kross = (d0x * d1y) - (d0y * d1x)
+        # sqkross = kross * kross
+        # sqLen0 = np.real(ad0) * np.real(ad0) + np.imag(ad0) * np.imag(ad0)
+        # sqLen1 = np.real(ad1) * np.real(ad1) + np.imag(ad1) * np.imag(ad1)
+        s = ((ex * d1y) - (ey * d1x)) / kross
+        t = ((ex * d0y) - (ey * d0x)) / kross
+        hits = np.dstack(
+            (
+                # sqkross > 0.01 * sqLen0 * sqLen1,
+                s >= 0,
+                s <= 1,
+                t >= 0,
+                t <= 1,
+            )
+        ).all(axis=2)
+        where_hit = np.argwhere(hits)
+
+        # pos = ap0[hits] + s[hits] * ad0[hits]
+        if len(where_hit) != 1 and step_a < 1e-10:
+            # We're hits are becoming unstable give last best value.
+            if ta[2] is not None and tb[2] is not None:
+                yield ta[2], tb[2]
+            return
+
+        # Calculate the t values for the intersections
+        ta_hit = s[hits]
+        tb_hit = t[hits]
+
+        for i, hit in enumerate(where_hit):
+            # Zoomed min+segment intersected.
             # Fractional guess within intersected segment
-            a_fractional = ta_hit[i] * step_a
-            b_fractional = tb_hit[i] * step_b
+            at_guess = ta[0] + (hit[1] + ta_hit[i]) * step_a
+            bt_guess = tb[0] + (hit[0] + tb_hit[i]) * step_b
+
             if depth == enhancements:
                 # We've enhanced as best as we can, yield the current + segment t-value to our answer
-                yield at + a_fractional, bt + b_fractional
+                yield at_guess, bt_guess
             else:
-                yield from self._find_intersections_main(
+                yield from self._find_intersections_kross(
                     segment1,
                     segment2,
                     fun1,
                     fun2,
-                    ta=(at, at + step_a, at + a_fractional),
-                    tb=(bt, bt + step_b, bt + b_fractional),
+                    ta=(at_guess - step_a / 2, at_guess + step_a / 2, at_guess),
+                    tb=(bt_guess - step_b / 2, bt_guess + step_b / 2, bt_guess),
                     samples=enhance_samples,
                     depth=depth + 1,
                     enhancements=enhancements,
@@ -2735,6 +3317,57 @@ class Geomstr:
         finally:
             np.seterr(**old_np_seterr)
 
+    def brute_line_intersections(self):
+        """
+        Brute line intersections finds all the intersections of all the lines in the geomstr with brute force.
+
+        @return: intersection-indexes, position, t-values
+        """
+        geoms = self.segments[: self.index]
+        infos = np.real(geoms[:, 2]).astype(int)
+        q = np.where(infos == TYPE_LINE)
+        starts = geoms[q][:, 0]
+        ends = geoms[q][:, -1]
+        lines = np.dstack((starts, ends))[0]
+        x, y = np.triu_indices(len(starts), 1)
+        j = lines[x]
+        k = lines[y]
+        a1 = j[:, 0]
+        ax1 = np.real(a1)
+        ay1 = np.imag(a1)
+        b1 = k[:, 0]
+        bx1 = np.real(b1)
+        by1 = np.imag(b1)
+        a2 = j[:, 1]
+        ax2 = np.real(a2)
+        ay2 = np.imag(a2)
+        b2 = k[:, 1]
+        bx2 = np.real(b2)
+        by2 = np.imag(b2)
+
+        denom = (by2 - by1) * (ax2 - ax1) - (bx2 - bx1) * (ay2 - ay1)
+        qa = (bx2 - bx1) * (ay1 - by1) - (by2 - by1) * (ax1 - bx1)
+        qb = (ax2 - ax1) * (ay1 - by1) - (ay2 - ay1) * (ax1 - bx1)
+        hits = np.dstack(
+            (
+                denom != 0,  # Cannot be parallel.
+                np.sign(denom) == np.sign(qa),  # D and Qa must have same sign.
+                np.sign(denom) == np.sign(qb),  # D and Qb must have same sign.
+                abs(denom) >= abs(qa),  # D >= Qa (else not between 0 - 1)
+                abs(denom) >= abs(qb),  # D >= Qb (else not between 0 - 1)
+            )
+        )
+        hits = hits.all(axis=2)[0]
+
+        where_hits = np.dstack((x[hits], y[hits]))[0]
+        ta_hit = qa[hits] / denom[hits]
+        tb_hit = qb[hits] / denom[hits]
+
+        x_vals = ax1[hits] + ta_hit * (ax2[hits] - ax1[hits])
+        y_vals = ay1[hits] + ta_hit * (ay2[hits] - ay1[hits])
+
+        return where_hits, x_vals + y_vals * 1j, ta_hit, tb_hit
+
     #######################
     # Geom Tranformations
     #######################
@@ -3196,13 +3829,20 @@ class Geomstr:
         @return:
         """
         line = self.segments[e]
-        a = line[0]
-        b = line[-1]
-        if b.real - a.real == 0:
-            return float("inf")
-        return (b.imag - a.imag) / (b.real - a.real)
+        if len(line.shape) == 2:
+            a = line[:, 0]
+            b = line[:, -1]
+        else:
+            a = line[0]
+            b = line[-1]
+        old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+        try:
+            m = (b.imag - a.imag) / (b.real - a.real)
+        finally:
+            np.seterr(**old_np_seterr)
+        return m
 
-    def y_intercept(self, e):
+    def y_at_axis(self, e):
         """
         y_intercept value between start and end points.
 
@@ -3210,12 +3850,18 @@ class Geomstr:
         @return:
         """
         line = self.segments[e]
-        a = line[0]
-        b = line[-1]
-        if b.real - a.real == 0:
-            return float("inf")
-        im = (b.imag - a.imag) / (b.real - a.real)
-        return a.imag - (im * a.real)
+        if len(line.shape) == 2:
+            a = line[:, 0]
+            b = line[:, -1]
+        else:
+            a = line[0]
+            b = line[-1]
+        old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+        try:
+            im = (b.imag - a.imag) / (b.real - a.real)
+            return a.imag - (im * a.real)
+        finally:
+            np.seterr(**old_np_seterr)
 
     def endpoint_min_y(self, e):
         """
@@ -3285,12 +3931,45 @@ class Geomstr:
         @param y:
         @return:
         """
-        m = self.slope(e)
-        b = self.y_intercept(e)
-        if math.isnan(m) or math.isinf(m):
-            low = self.endpoint_min_y(e)
-            return low.real
-        return (y - b) / m
+        line = self.segments[e]
+        if len(line.shape) == 2:
+            a = line[:, 0]
+            b = line[:, -1]
+        else:
+            a = line[0]
+            b = line[-1]
+        old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+        try:
+            # If horizontal slope is undefined. But, all x-ints are at x since x0=x1
+            m = (b.imag - a.imag) / (b.real - a.real)
+            y0 = a.imag - (m * a.real)
+            return np.where(~np.isinf(m), (y - y0) / m, a.real)
+        finally:
+            np.seterr(**old_np_seterr)
+
+    def y_intercept(self, e, x):
+        """
+        Gives the y_intercept of a line at a specific value of x.
+
+        @param e:
+        @param x:
+        @return:
+        """
+        line = self.segments[e]
+        if len(line.shape) == 2:
+            a = line[:, 0]
+            b = line[:, -1]
+        else:
+            a = line[0]
+            b = line[-1]
+        old_np_seterr = np.seterr(invalid="ignore", divide="ignore")
+        try:
+            # If vertical slope is undefined. But, all y-ints are at y since y0=y1
+            m = (b.real - a.real) / (b.imag - a.imag)
+            x0 = a.real - (m * a.imag)
+            return np.where(~np.isinf(m), (x - x0) / m, a.imag)
+        finally:
+            np.seterr(**old_np_seterr)
 
     #######################
     # Geometry Window Functions
@@ -3315,7 +3994,8 @@ class Geomstr:
             elif np.real(i) == TYPE_CUBIC:
                 path.cubic(c0, c1, e)
             elif np.real(i) == TYPE_ARC:
-                path.arc(start=s, control=c0, end=e)
+                path.append(Arc(start=s, control=c0, end=e))
+                # path.arc(start=s, control=c0, end=e)
             elif np.real(i) == TYPE_POINT:
                 path.move(s)
                 path.closed()
@@ -3403,6 +4083,22 @@ class Geomstr:
         if last != self.index:
             yield Geomstr(self.segments[last : self.index])
 
+    def render(self, buffer=10, scale=1):
+        sb = Scanbeam(self)
+        nx, ny, mx, my = self.bbox()
+        px, py = np.mgrid[
+            nx - buffer : mx + buffer : scale, ny - buffer : my + buffer : scale
+        ]
+        ppx = px + 1j * py
+        pxs = ppx.ravel()
+        data = sb.points_in_polygon(pxs)
+
+        from PIL import Image
+
+        size = ppx.shape[::-1]
+        databytes = np.packbits(data)
+        return Image.frombytes(mode="1", size=size, data=databytes)
+
     def draw(self, draw, offset_x, offset_y):
         """
         Though not a requirement, this draws with the given ImageDraw api found in Pillow.