plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/seams.py

@@ -0,0 +1,138 @@
+"""Seams: where outlined shapes touch (stacked, dodged or adjacent bars, pie wedges), the
+shared edge is redrawn in one color (white by default), so neighbours stay apart instead of
+showing two overlapping outlines.  The outlines under a seam are left out of the shapes'
+geometry (not painted over), so none shows through the seam's anti-aliased edges."""
+
+from typing import Any
+from .canvas import Canvas
+
+__all__ = ["rect_contacts", "rect_seams", "seam_box", "outline_pieces", "draw_seams"]
+
+Rect = tuple[float, float, float, float, float]       # x0, y0, x1, y1 (page units), width
+_EPS = 0.01                                            # page units: edges this close touch
+#: (at most: closer for rectangles smaller than 1 px, see :func:`rect_contacts`)
+
+
+def rect_seams(new: list[Rect], old: list[Rect]) -> list[tuple[float, ...]]:
+    """Segments ``(x0, y0, x1, y1, width)`` where a rectangle of ``new`` touches another of
+    ``new`` or one of ``old`` (edges at the same place, overlapping along it); the width is
+    the wider outline of the two."""
+    return list(dict.fromkeys(s for s, _ in rect_contacts(new, old)))
+
+
+def rect_contacts(new: list[Rect], old: list[Rect]) -> list[tuple[tuple[float, ...], int]]:
+    """As :func:`rect_seams`, each segment with the index of the other rectangle of the
+    pair in ``old + new`` (an earlier one when it is in ``old``)."""
+    import bisect
+    out: list[tuple[tuple[float, ...], int]] = []
+    every = old + new
+    # per side (left, right, top, bottom: the coordinate's index in a rectangle), the
+    # rectangles by the position of that edge in steps of _EPS; each bucket sorted by the
+    # start along the edge (y0 for left and right, x0 for top and bottom), with the
+    # starts and the longest edge for bisection
+    index: list[dict[int, Any]] = [{}, {}, {}, {}]
+    for i, r in enumerate(every):
+        for c in range(4):
+            index[c].setdefault(round(r[c] / _EPS), []).append(i)
+    for c in range(4):
+        a = 1 if c in (0, 2) else 0
+        for k, js in index[c].items():
+            js.sort(key=lambda j: every[j][a])
+            longest = max(0.0, *(every[j][a + 2] - every[j][a] for j in js))
+            index[c][k] = (js, [every[j][a] for j in js], longest)
+    first_new = len(old)
+    size = [min(r[2] - r[0], r[3] - r[1]) for r in every]
+    # right and bottom edges against every other rectangle; left and top ones against the
+    # earlier rectangles only (pairs of new ones are found from one side)
+    sides = ((2, 0, True), (3, 1, True), (0, 2, False), (1, 3, False))
+    for i in range(first_new, len(every)):
+        r = every[i]
+        x0, y0, x1, y1, w = r
+        for mine, other, both in sides:
+            v = r[mine]
+            k = round(v / _EPS)
+            found = index[other]
+            lo_e, hi_e = (y0, y1) if mine in (0, 2) else (x0, x1)
+            near: list[int] = []
+            for kk in (k - 1, k, k + 1):
+                bucket = found.get(kk)
+                if bucket is None:
+                    continue
+                js, starts, longest = bucket
+                first = bisect.bisect_left(starts, lo_e - longest)
+                last = bisect.bisect_right(starts, hi_e)
+                near.extend(sorted(js[first:last]))
+            for j in near:
+                if j == i or (not both and j >= first_new):
+                    continue
+                b = every[j]
+                # edges this close touch: _EPS, or 1 % of the smaller rectangle (gaps
+                # between rectangles narrower than a px are not contacts)
+                if abs(b[other] - v) > min(_EPS, 0.01 * min(size[i], size[j])):
+                    continue
+                width = max(w, b[4])
+                if mine in (0, 2):
+                    lo, hi = max(y0, b[1]), min(y1, b[3])
+                    if hi - lo > _EPS:
+                        out.append(((v, lo, v, hi, width), j))
+                else:
+                    lo, hi = max(x0, b[0]), min(x1, b[2])
+                    if hi - lo > _EPS:
+                        out.append(((lo, v, hi, v, width), j))
+    return out
+
+
+Box = tuple[float, float, float, float]                # x0, y0, x1, y1
+
+
+def seam_box(segment: tuple[float, ...], square: bool = False) -> Box:
+    """The area an axis-aligned segment ``(x0, y0, x1, y1, width)`` covers when stroked
+    with butt caps, or square caps (``square``)."""
+    x0, y0, x1, y1, w = segment[:5]
+    h = w / 2
+    e = h if square else 0.0
+    if abs(x1 - x0) <= _EPS:
+        return (x0 - h, min(y0, y1) - e, x0 + h, max(y0, y1) + e)
+    return (min(x0, x1) - e, y0 - h, max(x0, x1) + e, y0 + h)
+
+
+def _minus(a: Box, b: Box) -> list[Box]:
+    ax0, ay0, ax1, ay1 = a
+    bx0, by0, bx1, by1 = b
+    if bx0 >= ax1 or bx1 <= ax0 or by0 >= ay1 or by1 <= ay0:
+        return [a]
+    out = []
+    if by0 > ay0:
+        out.append((ax0, ay0, ax1, by0))
+    if by1 < ay1:
+        out.append((ax0, by1, ax1, ay1))
+    my0, my1 = max(ay0, by0), min(ay1, by1)
+    if bx0 > ax0:
+        out.append((ax0, my0, bx0, my1))
+    if bx1 < ax1:
+        out.append((bx1, my0, ax1, my1))
+    return [r for r in out if r[2] - r[0] > 1e-9 and r[3] - r[1] > 1e-9]
+
+
+def outline_pieces(rect: Box, width: float, cuts: list[Box]) -> list[Box]:
+    """The area of a rectangle's outline (``width``, centred on the edges, square corners)
+    without the ``cuts``, as disjoint rectangles."""
+    x0, y0, x1, y1 = rect
+    h = width / 2
+    if y1 - y0 <= width or x1 - x0 <= width:
+        pieces = [(x0 - h, y0 - h, x1 + h, y1 + h)]
+    else:
+        pieces = [(x0 - h, y0 - h, x1 + h, y0 + h), (x0 - h, y1 - h, x1 + h, y1 + h),
+                  (x0 - h, y0 + h, x0 + h, y1 - h), (x1 - h, y0 + h, x1 + h, y1 - h)]
+    for c in cuts:
+        pieces = [q for p in pieces for q in _minus(p, c)]
+    return pieces
+
+
+def draw_seams(canvas: Canvas, segments: list[tuple[float, ...]], color: Any) -> None:
+    """Draw seams (butt caps, so outlines across their ends stay whole)."""
+    if not segments or color is None:
+        return
+    canvas.draw_segments([s[0] for s in segments], [s[1] for s in segments],
+                         [s[2] for s in segments], [s[3] for s in segments], stroke=color,
+                         stroke_width=[s[4] for s in segments], stroke_linecap="butt")