codefig 0.17.0__py3-none-any.whl

codefig/lint_geom.py

@@ -0,0 +1,528 @@
+"""v0.12.0: geometric text checks over the *drawn* SVG (lint rule CF-TXT-010).
+
+The scene-graph overlap check (CF-TXT-005) only sees nodes. Many labels are drawn by
+their owner instead: group titles, region labels, Matrix side labels, Fork branch
+labels, span labels, chart tick labels. This module looks at what was actually
+painted, in paint order:
+
+* **covered** — an opaque fill painted *after* a text run hides part of it (a group
+  title under its first child, a region label under a neighbouring box, a Matrix
+  label clipped by the next box, a label under an arrowhead);
+* **struck** — a stroke (edge, frame, region outline, span line, marker) runs through
+  the middle band of a text run; **grazes** when it only touches the glyph box;
+* **text–text** — two text runs overlap.
+
+Knockout holes (edge labels) are honoured: a stroke clipped away around a label does
+not count.
+"""
+from __future__ import annotations
+
+import math
+import re
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+Pt = Tuple[float, float]
+Rect = Tuple[float, float, float, float]  # x0, y0, x1, y1
+
+_NUM = r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?"
+
+
+def _apply(m: Sequence[float], x: float, y: float) -> Pt:
+    return (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
+
+
+def _f(v: Any, d: float = 0.0) -> float:
+    try:
+        return float(re.sub(r"[a-z%]+$", "", str(v)))
+    except (TypeError, ValueError):
+        return d
+
+
+def parse_path(d: str) -> List[Tuple[List[Pt], bool]]:
+    """Flatten an SVG path into polylines ``[(points, closed)]`` (curves sampled)."""
+    toks = re.findall(r"[MmLlHhVvCcSsQqTtAaZz]|" + _NUM, d or "")
+    out: List[Tuple[List[Pt], bool]] = []
+    cur: List[Pt] = []
+    x = y = 0.0
+    sx = sy = 0.0
+    i = 0
+    cmd = ""
+    last_ctrl: Optional[Pt] = None
+
+    def num() -> float:
+        nonlocal i
+        v = float(toks[i])
+        i += 1
+        return v
+
+    def flush(closed: bool = False) -> None:
+        nonlocal cur
+        if len(cur) >= 2:
+            out.append((cur, closed))
+        cur = []
+
+    while i < len(toks):
+        t = toks[i]
+        if re.match(r"[A-Za-z]", t):
+            cmd = t
+            i += 1
+            if cmd in "Zz":
+                if cur:
+                    cur.append((sx, sy))
+                flush(True)
+                x, y = sx, sy
+                continue
+        if not cmd:
+            i += 1
+            continue
+        rel = cmd.islower()
+        c = cmd.upper()
+        try:
+            if c == "M":
+                nx, ny = num(), num()
+                if rel:
+                    nx, ny = x + nx, y + ny
+                flush()
+                x, y = nx, ny
+                sx, sy = x, y
+                cur = [(x, y)]
+                cmd = "l" if rel else "L"
+            elif c == "L":
+                nx, ny = num(), num()
+                x, y = (x + nx, y + ny) if rel else (nx, ny)
+                cur.append((x, y))
+            elif c == "H":
+                nx = num()
+                x = x + nx if rel else nx
+                cur.append((x, y))
+            elif c == "V":
+                ny = num()
+                y = y + ny if rel else ny
+                cur.append((x, y))
+            elif c in "CSQT":
+                if c == "C":
+                    pts = [num() for _ in range(6)]
+                elif c == "S":
+                    pts = [0.0, 0.0] + [num() for _ in range(4)]
+                elif c == "Q":
+                    pts = [num() for _ in range(4)]
+                else:
+                    pts = [num(), num()]
+                if rel:
+                    pts = [v + (x if k % 2 == 0 else y) for k, v in enumerate(pts)]
+                if c == "S":
+                    lc = last_ctrl or (x, y)
+                    pts[0], pts[1] = 2 * x - lc[0], 2 * y - lc[1]
+                if c in "CS":
+                    p0, p1, p2, p3 = (x, y), (pts[0], pts[1]), (pts[2], pts[3]), (pts[4], pts[5])
+                    for k in range(1, 9):
+                        u = k / 8
+                        a, b, cc, dd = (1 - u) ** 3, 3 * u * (1 - u) ** 2, 3 * u * u * (1 - u), u ** 3
+                        cur.append((a * p0[0] + b * p1[0] + cc * p2[0] + dd * p3[0],
+                                    a * p0[1] + b * p1[1] + cc * p2[1] + dd * p3[1]))
+                    last_ctrl = p2
+                    x, y = p3
+                elif c == "Q":
+                    p0, p1, p2 = (x, y), (pts[0], pts[1]), (pts[2], pts[3])
+                    for k in range(1, 7):
+                        u = k / 6
+                        cur.append(((1 - u) ** 2 * p0[0] + 2 * u * (1 - u) * p1[0] + u * u * p2[0],
+                                    (1 - u) ** 2 * p0[1] + 2 * u * (1 - u) * p1[1] + u * u * p2[1]))
+                    x, y = p2
+                else:
+                    x, y = pts[0], pts[1]
+                    cur.append((x, y))
+                continue
+            elif c == "A":
+                rx, ry, _rot, large, sweep, nx, ny = [num() for _ in range(7)]
+                if rel:
+                    nx, ny = x + nx, y + ny
+                cur.extend(_arc_points(x, y, rx, ry, _rot, bool(large), bool(sweep), nx, ny))
+                x, y = nx, ny
+            else:
+                i += 1
+        except (IndexError, ValueError):
+            break
+        last_ctrl = None
+    flush()
+    return out
+
+
+def _arc_points(x1: float, y1: float, rx: float, ry: float, phi_deg: float, fa: bool,
+                fs: bool, x2: float, y2: float, n: int = 12) -> List[Pt]:
+    """Sample an SVG elliptical arc (endpoint parameterisation, SVG spec F.6.5)."""
+    if rx == 0 or ry == 0 or (x1 == x2 and y1 == y2):
+        return [(x2, y2)]
+    rx, ry = abs(rx), abs(ry)
+    phi = math.radians(phi_deg)
+    c, s_ = math.cos(phi), math.sin(phi)
+    dx, dy = (x1 - x2) / 2, (y1 - y2) / 2
+    x1p, y1p = c * dx + s_ * dy, -s_ * dx + c * dy
+    lam = (x1p / rx) ** 2 + (y1p / ry) ** 2
+    if lam > 1:
+        rx, ry = rx * math.sqrt(lam), ry * math.sqrt(lam)
+    num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p
+    den = rx * rx * y1p * y1p + ry * ry * x1p * x1p
+    co = math.sqrt(max(0.0, num / den)) if den else 0.0
+    if fa == fs:
+        co = -co
+    cxp, cyp = co * rx * y1p / ry, -co * ry * x1p / rx
+    cx, cy = c * cxp - s_ * cyp + (x1 + x2) / 2, s_ * cxp + c * cyp + (y1 + y2) / 2
+
+    def ang(ux: float, uy: float, vx: float, vy: float) -> float:
+        a = math.atan2(ux * vy - uy * vx, ux * vx + uy * vy)
+        return a
+
+    t1 = ang(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+    dt = ang((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry)
+    if not fs and dt > 0:
+        dt -= 2 * math.pi
+    elif fs and dt < 0:
+        dt += 2 * math.pi
+    out = []
+    for k in range(1, n + 1):
+        t = t1 + dt * k / n
+        ex, ey = rx * math.cos(t), ry * math.sin(t)
+        out.append((c * ex - s_ * ey + cx, s_ * ex + c * ey + cy))
+    return out
+
+
+def _is_none(c: Optional[str]) -> bool:
+    return c is None or str(c).strip().lower() in ("none", "transparent", "")
+
+
+def _opaque_fill(a: Dict[str, str]) -> bool:
+    f = a.get("fill")
+    if _is_none(f) or str(f).startswith("url("):
+        return False
+    if _f(a.get("fill-opacity", 1), 1) < 0.5 or _f(a.get("opacity", 1), 1) < 0.5:
+        return False
+    return True
+
+
+def _stroked(a: Dict[str, str]) -> bool:
+    if _is_none(a.get("stroke")):
+        return False
+    if _f(a.get("stroke-width", 1), 1) <= 0:
+        return False
+    if _f(a.get("stroke-opacity", 1), 1) < 0.25 or _f(a.get("opacity", 1), 1) < 0.25:
+        return False
+    return True
+
+
+def _geometry(tag: str, a: Dict[str, str]) -> List[Tuple[List[Pt], bool]]:
+    if tag == "line":
+        return [([(_f(a.get("x1")), _f(a.get("y1"))), (_f(a.get("x2")), _f(a.get("y2")))], False)]
+    if tag == "rect":
+        x, y, w, h = _f(a.get("x")), _f(a.get("y")), _f(a.get("width")), _f(a.get("height"))
+        if w <= 0 or h <= 0:
+            return []
+        return [([(x, y), (x + w, y), (x + w, y + h), (x, y + h), (x, y)], True)]
+    if tag in ("polyline", "polygon"):
+        nums = [float(v) for v in re.findall(_NUM, a.get("points", ""))]
+        pts = list(zip(nums[0::2], nums[1::2]))
+        if tag == "polygon" and pts:
+            pts.append(pts[0])
+        return [(pts, tag == "polygon")] if len(pts) >= 2 else []
+    if tag in ("circle", "ellipse"):
+        cx, cy = _f(a.get("cx")), _f(a.get("cy"))
+        rx = _f(a.get("r")) if tag == "circle" else _f(a.get("rx"))
+        ry = _f(a.get("r")) if tag == "circle" else _f(a.get("ry"))
+        pts = [(cx + rx * math.cos(2 * math.pi * k / 24), cy + ry * math.sin(2 * math.pi * k / 24))
+               for k in range(25)]
+        return [(pts, True)]
+    if tag == "path":
+        return parse_path(a.get("d", ""))
+    return []
+
+
+def _clip_holes(svg: str) -> Dict[str, List[Rect]]:
+    """Knockout clipPaths (edges.knockout_clip): id → hole rects (user space)."""
+    out: Dict[str, List[Rect]] = {}
+    for cid, d in re.findall(r'<clipPath id="([^"]+)"><path d="([^"]*)"', svg):
+        holes = []
+        for x, y, y2, x2, _y in re.findall(
+                r"M (%s),(%s) V (%s) H (%s) V (%s) Z" % (_NUM, _NUM, _NUM, _NUM, _NUM), d):
+            x, y, y2, x2 = float(x), float(y), float(y2), float(x2)
+            holes.append((min(x, x2), min(y, y2), max(x, x2), max(y, y2)))
+        out[cid] = holes
+    return out
+
+
+def _clip_seg(p: Pt, q: Pt, r: Rect) -> Optional[Tuple[Pt, Pt]]:
+    x0, y0, x1, y1 = r
+    dx, dy = q[0] - p[0], q[1] - p[1]
+    t0, t1 = 0.0, 1.0
+    for pp, qq in ((-dx, p[0] - x0), (dx, x1 - p[0]), (-dy, p[1] - y0), (dy, y1 - p[1])):
+        if abs(pp) < 1e-12:
+            if qq < 0:
+                return None
+            continue
+        t = qq / pp
+        if pp < 0:
+            t0 = max(t0, t)
+        else:
+            t1 = min(t1, t)
+        if t0 > t1:
+            return None
+    return ((p[0] + dx * t0, p[1] + dy * t0), (p[0] + dx * t1, p[1] + dy * t1))
+
+
+def _in(r: Rect, x: float, y: float) -> bool:
+    return r[0] <= x <= r[2] and r[1] <= y <= r[3]
+
+
+def _inter(a: Rect, b: Rect) -> float:
+    w = min(a[2], b[2]) - max(a[0], b[0])
+    h = min(a[3], b[3]) - max(a[1], b[1])
+    return w * h if w > 0 and h > 0 else 0.0
+
+
+def _area(r: Rect) -> float:
+    return max(0.0, r[2] - r[0]) * max(0.0, r[3] - r[1])
+
+
+def _pip(poly: Sequence[Pt], x: float, y: float) -> bool:
+    inside = False
+    n = len(poly)
+    j = n - 1
+    for i in range(n):
+        xi, yi = poly[i]
+        xj, yj = poly[j]
+        if (yi > y) != (yj > y) and x < (xj - xi) * (y - yi) / ((yj - yi) or 1e-12) + xi:
+            inside = not inside
+        j = i
+    return inside
+
+
+class _TextRun:
+    __slots__ = ("p", "idx", "core", "band", "text", "fs")
+
+    def __init__(self, p: Any, idx: int, core: Rect, band: Rect, fs: float) -> None:
+        self.p, self.idx, self.core, self.band, self.text, self.fs = p, idx, core, band, p.text, fs
+
+
+def _aabb(m: Sequence[float], x0: float, y0: float, x1: float, y1: float) -> Rect:
+    pts = [_apply(m, x0, y0), _apply(m, x1, y0), _apply(m, x0, y1), _apply(m, x1, y1)]
+    xs, ys = [p[0] for p in pts], [p[1] for p in pts]
+    return (min(xs), min(ys), max(xs), max(ys))
+
+
+def text_runs(prims: Sequence[Any]) -> List[_TextRun]:
+    from .textutil import measure_text
+
+    out: List[_TextRun] = []
+    cursor: Dict[int, float] = {}
+    for idx, p in enumerate(prims):
+        if p.tag != "text" or p.in_defs or p.font_size <= 0 or not (p.text or "").strip():
+            continue
+        a = p.attrs
+        fs = p.font_size
+        mono = "mono" in (p.family or "").lower()
+        bold = str(p.weight) in ("bold", "600", "700", "800", "900")
+        italic = a.get("font-style") == "italic"
+        try:
+            w = measure_text(p.text, fs, mono=mono, weight="bold" if bold else "normal",
+                             italic=italic)[0]
+        except Exception:  # pragma: no cover
+            continue
+        if "x" in a:
+            x = _f(a.get("x"))
+        elif p.text_id in cursor:
+            x = cursor[p.text_id]
+        else:
+            continue
+        anchor = a.get("text-anchor", "start")
+        if anchor == "middle":
+            x -= w / 2
+        elif anchor == "end":
+            x -= w
+        cursor[p.text_id] = x + w
+        y = _f(a.get("y"))
+        bs = str(a.get("baseline-shift", ""))
+        if bs.startswith("-"):
+            y += fs * 0.35
+        elif bs and bs not in ("0", "baseline"):
+            y -= fs * 0.45
+        ins = 0.06 * fs
+        core = _aabb(p.m, x + ins, y - 0.66 * fs, x + w - ins, y - 0.06 * fs)
+        band = _aabb(p.m, x + 2 * ins, y - 0.52 * fs, x + w - 2 * ins, y - 0.2 * fs)
+        out.append(_TextRun(p, idx, core, band, fs * p.scale))
+    return out
+
+
+def _related(a: Any, b: Any) -> bool:
+    """True when node ``b`` is ``a`` or one of its ancestors / descendants."""
+    if a is None or b is None:
+        return False
+    n = a
+    while n is not None:
+        if n is b:
+            return True
+        n = getattr(n, "parent", None)
+    n = b
+    while n is not None:
+        if n is a:
+            return True
+        n = getattr(n, "parent", None)
+    return False
+
+
+def _edge_inside(edge: Any, owner: Any) -> bool:
+    """The text belongs to one of the edge's ends: a container title / caption the edge
+    has to pass on its way in or out (``owner`` contains an end node, or ``owner`` is a
+    caption sitting next to the end node or its group), not a crossing."""
+    op = getattr(owner, "parent", None)
+    for port in (getattr(edge, "src", None), getattr(edge, "dst", None)):
+        n = getattr(port, "node", None)
+        depth = 0
+        while n is not None:
+            if n is owner:
+                return True
+            if op is not None and depth in (1, 2) and n is op:
+                return True
+            n = getattr(n, "parent", None)
+            depth += 1
+    return False
+
+
+def check_text_geometry(prims: Sequence[Any], svg: str, ignored: Any) -> Dict[str, list]:
+    """Return ``{"covered": [...], "struck": [...], "grazed": [...], "text": [...]}``;
+    each item ``(text_run, other_prim_or_run, rect)``."""
+    runs = text_runs(prims)
+    res: Dict[str, list] = {"covered": [], "struck": [], "grazed": [], "text": [], "gapped": []}
+    if not runs:
+        return res
+    holes = _clip_holes(svg)
+    shapes = []  # (idx, prim, polylines in root coords, aabb, fill?, stroke?)
+    for idx, p in enumerate(prims):
+        if p.tag == "text" or p.in_defs or p.tag == "image":
+            continue
+        if p.clip.startswith("cf-hatch"):  # hatch texture inside a shape, not a line
+            continue
+        a = p.attrs
+        fill, stroke = _opaque_fill(a), _stroked(a)
+        if not fill and not stroke:
+            continue
+        geo = _geometry(p.tag, a)
+        if not geo:
+            continue
+        polys = [([_apply(p.m, x, y) for x, y in pts], closed) for pts, closed in geo]
+        xs = [x for pts, _ in polys for x, _y in pts]
+        ys = [y for pts, _ in polys for _x, y in pts]
+        if not xs:
+            continue
+        hs = []
+        if p.clip and p.clip in holes:
+            hs = [_aabb(p.m, *h) for h in holes[p.clip]]
+        shapes.append((idx, p, polys, (min(xs), min(ys), max(xs), max(ys)), fill, stroke, hs))
+
+    own_bb: Dict[int, Rect] = {}
+    for _i, p, _polys, bb, _f_, _s_, _h in shapes:
+        if p.owner is None:
+            continue
+        o = own_bb.get(id(p.owner))
+        own_bb[id(p.owner)] = bb if o is None else (min(o[0], bb[0]), min(o[1], bb[1]),
+                                                     max(o[2], bb[2]), max(o[3], bb[3]))
+    for r in runs:
+        if ignored(r.p.chain, "CF-TXT-010"):
+            continue
+        core = r.core
+        ca = _area(core)
+        if ca <= 0:
+            continue
+        owner = r.p.owner
+        covered_by = None
+        struck_by = None
+        grazed_by = None
+        gapped_by = None
+        near = [(idx, polys[0][0], bb) for idx, p, polys, bb, fill, stroke, hs in shapes
+                if fill and polys and polys[0][1] and bb[0] <= core[2] and bb[2] >= core[0]
+                and bb[1] <= core[3] and bb[3] >= core[1]]
+
+        def hidden(x: float, y: float, after: int) -> bool:
+            """Point painted over by an opaque fill drawn after index ``after``."""
+            for fi, poly, fb in near:
+                if fi > after and _in(fb, x, y) and _pip(poly, x, y):
+                    return True
+            return False
+
+        # a label overflowing its own node is CF-TXT-007's finding, not ours
+        ob = own_bb.get(id(owner))
+        overflow = ob is not None and (core[0] < ob[0] - 0.5 or core[2] > ob[2] + 0.5)
+        for idx, p, polys, bb, fill, stroke, hs in shapes:
+            if overflow and p.owner is owner:
+                continue
+            if _inter(bb, core) <= 0 and not (
+                    bb[0] <= core[2] and bb[2] >= core[0] and bb[1] <= core[3] and bb[3] >= core[1]):
+                continue
+            if fill and idx > r.idx and covered_by is None and not _related(owner, p.owner) \
+                    and polys and polys[0][1]:
+                poly = polys[0][0]
+                n_in = n = 0
+                for gx in range(7):
+                    for gy in range(3):
+                        x = core[0] + (core[2] - core[0]) * (gx + 0.5) / 7
+                        y = core[1] + (core[3] - core[1]) * (gy + 0.5) / 3
+                        n += 1
+                        if _in(bb, x, y) and _pip(poly, x, y):
+                            n_in += 1
+                if n_in / n >= 0.12:
+                    covered_by = p
+            if stroke and struck_by is None:
+                for pts, _closed in polys:
+                    hit = None
+                    for i in range(len(pts) - 1):
+                        seg = _clip_seg(pts[i], pts[i + 1], core)
+                        if seg is None:
+                            continue
+                        (ax, ay), (bx, by) = seg
+                        for k in range(5):
+                            u = (k + 0.5) / 5
+                            x, y = ax + (bx - ax) * u, ay + (by - ay) * u
+                            if any(_in(h, x, y) for h in hs):
+                                # v0.13.0: an edge drawn *through* someone else's label
+                                # with a gap cut behind the text still reads as crossing
+                                if gapped_by is None and _in(r.band, x, y) \
+                                        and hasattr(p.owner, "src") and p.owner is not owner \
+                                        and not _related(owner, p.owner) \
+                                        and getattr(owner, "label_owner", None) is not p.owner \
+                                        and not _edge_inside(p.owner, owner):
+                                    gapped_by = p
+                                continue
+                            if hidden(x, y, idx):
+                                continue
+                            if _in(r.band, x, y):
+                                hit = "struck"
+                                break
+                            hit = hit or "grazed"
+                        if hit == "struck":
+                            break
+                    if hit == "struck":
+                        struck_by = p
+                        break
+                    if hit == "grazed" and grazed_by is None:
+                        grazed_by = p
+        if covered_by is not None:
+            res["covered"].append((r, covered_by, core))
+        elif struck_by is not None:
+            res["struck"].append((r, struck_by, core))
+        elif grazed_by is not None:
+            res["grazed"].append((r, grazed_by, core))
+        if gapped_by is not None and covered_by is None and struck_by is None:
+            res["gapped"].append((r, gapped_by, core))
+    # text vs text
+    runs_sorted = sorted(runs, key=lambda r: r.core[0])
+    for i, a in enumerate(runs_sorted):
+        if ignored(a.p.chain, "CF-TXT-010"):
+            continue
+        for b in runs_sorted[i + 1:]:
+            if b.core[0] > a.core[2]:
+                break
+            if a.p.text_id == b.p.text_id or ignored(b.p.chain, "CF-TXT-010"):
+                continue
+            ov = _inter(a.core, b.core)
+            if ov > 0.15 * min(_area(a.core), _area(b.core)):
+                res["text"].append((a, b, (max(a.core[0], b.core[0]), max(a.core[1], b.core[1]),
+                                           min(a.core[2], b.core[2]), min(a.core[3], b.core[3]))))
+    return res