gerberdiff 0.29.0__py3-none-any.whl

gerberdiff/geometry/attribute.py

@@ -0,0 +1,203 @@
+"""Change attribution: match expanded ops between revisions and classify.
+
+Three-stage algorithm:
+
+1. **Exact cancellation** -- ops with identical content signatures (same
+   world geometry, polarity, kind) are unchanged.  This typically covers
+   the vast majority of ops and costs only hashing.
+2. **Gated geometric matching** -- remaining ops are pooled by (kind,
+   polarity) and matched A->B by centroid proximity within *gate_radius*
+   (KD-tree candidates, globally-greedy by distance for determinism).
+3. **Classification** of each matched pair:
+
+   - same dims, offset >  move_tol  -> ``moved``
+   - same dims, offset <= move_tol  -> unchanged (float noise)
+   - dims changed                   -> ``resized`` (dx/dy still recorded)
+
+   "Same dims" = identical aperture signature *and* relative area delta
+   within *area_tol* (the area check distinguishes a stretched stroke from
+   a translated one).
+
+Unmatched A-ops are ``removed``; unmatched B-ops are ``added``.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import Counter
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.spatial import cKDTree
+
+from gerberdiff.geometry.layer_geometry import ExpandedOp
+from gerberdiff.geometry.types import ChangeKind
+
+# Classification kinds (public result vocabulary).
+KIND_ADDED: ChangeKind = "added"
+KIND_REMOVED: ChangeKind = "removed"
+KIND_MOVED: ChangeKind = "moved"
+KIND_RESIZED: ChangeKind = "resized"
+
+
+@dataclass
+class OpChange:
+    """One attributed change between revisions (engine-internal record)."""
+
+    kind: ChangeKind
+    before: ExpandedOp | None
+    after: ExpandedOp | None
+    dx: float = 0.0  # inches (after - before), 0 when one side is absent
+    dy: float = 0.0
+
+
+@dataclass
+class Partition:
+    """Result of exact-cancellation matching between two op lists."""
+
+    unchanged_a: list[ExpandedOp]
+    unchanged_b: list[ExpandedOp]
+    a_only: list[ExpandedOp]
+    b_only: list[ExpandedOp]
+
+
+def partition_unchanged(
+    a_ops: list[ExpandedOp],
+    b_ops: list[ExpandedOp],
+) -> Partition:
+    """Multiset-match ops by content signature (stage 1)."""
+    counts_a = Counter(op.signature for op in a_ops)
+    counts_b = Counter(op.signature for op in b_ops)
+    shared = counts_a & counts_b
+
+    def _split(
+        ops: list[ExpandedOp], budget: Counter[str]
+    ) -> tuple[list[ExpandedOp], list[ExpandedOp]]:
+        unchanged: list[ExpandedOp] = []
+        only: list[ExpandedOp] = []
+        for op in ops:
+            if budget[op.signature] > 0:
+                budget[op.signature] -= 1
+                unchanged.append(op)
+            else:
+                only.append(op)
+        return unchanged, only
+
+    unchanged_a, a_only = _split(a_ops, Counter(shared))
+    unchanged_b, b_only = _split(b_ops, Counter(shared))
+    return Partition(unchanged_a=unchanged_a, unchanged_b=unchanged_b, a_only=a_only, b_only=b_only)
+
+
+def attribute_changes(
+    parts: Partition,
+    *,
+    move_tol: float,
+    gate_radius: float,
+    area_tol: float,
+) -> tuple[list[OpChange], int]:
+    """Stages 2+3: match and classify the non-identical ops.
+
+    All distances in inches.  Returns ``(changes, unchanged_count)`` where
+    *unchanged_count* includes both exact-signature matches and matched
+    pairs whose offset fell below *move_tol*.
+    """
+    unchanged_count = len(parts.unchanged_a)
+    changes: list[OpChange] = []
+
+    matched_a: set[int] = set()
+    matched_b: set[int] = set()
+
+    # Pool by (kind, polarity): a flash never matches a stroke, dark never
+    # matches clear.
+    pools: dict[tuple[str, str], tuple[list[int], list[int]]] = {}
+    for i, op in enumerate(parts.a_only):
+        pools.setdefault((op.kind, op.polarity.value), ([], []))[0].append(i)
+    for j, op in enumerate(parts.b_only):
+        pools.setdefault((op.kind, op.polarity.value), ([], []))[1].append(j)
+
+    for a_idx, b_idx in pools.values():
+        if not a_idx or not b_idx:
+            continue
+        pairs = _match_pool(parts, a_idx, b_idx, gate_radius, matched_a, matched_b)
+        for a_op, b_op in pairs:
+            dx = b_op.centroid_x - a_op.centroid_x
+            dy = b_op.centroid_y - a_op.centroid_y
+            offset = math.hypot(dx, dy)
+            if _dims_same(a_op, b_op, area_tol):
+                if offset <= move_tol:
+                    unchanged_count += 1
+                else:
+                    changes.append(OpChange(kind=KIND_MOVED, before=a_op, after=b_op, dx=dx, dy=dy))
+            elif offset <= move_tol and a_op.geom.equals(b_op.geom):
+                # Different aperture description, identical geometry (e.g. a
+                # square obround re-declared as a circle): not a change.
+                unchanged_count += 1
+            else:
+                changes.append(OpChange(kind=KIND_RESIZED, before=a_op, after=b_op, dx=dx, dy=dy))
+
+    for i, op in enumerate(parts.a_only):
+        if i not in matched_a:
+            changes.append(OpChange(kind=KIND_REMOVED, before=op, after=None))
+    for j, op in enumerate(parts.b_only):
+        if j not in matched_b:
+            changes.append(OpChange(kind=KIND_ADDED, before=None, after=op))
+
+    return changes, unchanged_count
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _match_pool(
+    parts: Partition,
+    a_indices: list[int],
+    b_indices: list[int],
+    gate_radius: float,
+    matched_a: set[int],
+    matched_b: set[int],
+) -> list[tuple[ExpandedOp, ExpandedOp]]:
+    """Greedy global matching by centroid distance within *gate_radius*."""
+    pairs_out: list[tuple[ExpandedOp, ExpandedOp]] = []
+    a_pts = [(parts.a_only[i].centroid_x, parts.a_only[i].centroid_y) for i in a_indices]
+    b_pts = [(parts.b_only[j].centroid_x, parts.b_only[j].centroid_y) for j in b_indices]
+    tree = cKDTree(b_pts)
+
+    k = min(8, len(b_pts))
+    candidates: list[tuple[float, int, int]] = []
+    for ai_local, pt in enumerate(a_pts):
+        d_raw, i_raw = tree.query(pt, k=k, distance_upper_bound=gate_radius)
+        # query on a single point returns scalars for k=1, 1-D arrays otherwise.
+        d_arr = np.atleast_1d(np.asarray(d_raw, dtype=float))
+        i_arr = np.atleast_1d(np.asarray(i_raw, dtype=int))
+        for d, j_local in zip(d_arr, i_arr, strict=True):
+            if math.isinf(float(d)) or int(j_local) >= len(b_pts):
+                continue
+            candidates.append((float(d), ai_local, int(j_local)))
+
+    # Sort by distance (deterministic index tie-break), accept greedily.
+    candidates.sort(key=lambda c: (c[0], c[1], c[2]))
+    used_a_local: set[int] = set()
+    used_b_local: set[int] = set()
+    for _d, ai_local, bj_local in candidates:
+        if ai_local in used_a_local or bj_local in used_b_local:
+            continue
+        used_a_local.add(ai_local)
+        used_b_local.add(bj_local)
+        ai = a_indices[ai_local]
+        bj = b_indices[bj_local]
+        matched_a.add(ai)
+        matched_b.add(bj)
+        pairs_out.append((parts.a_only[ai], parts.b_only[bj]))
+    return pairs_out
+
+
+def _dims_same(a: ExpandedOp, b: ExpandedOp, area_tol: float) -> bool:
+    """Same dimensions modulo orientation (a rotated pad is still 'moved')."""
+    if a.dims_signature != b.dims_signature:
+        return False
+    biggest = max(a.area, b.area)
+    if biggest <= 0.0:
+        return True
+    return abs(a.area - b.area) / biggest <= area_tol

gerberdiff/geometry/driver.py

@@ -0,0 +1,227 @@
+"""Directory-level geometry diff driver.
+
+``compute_geometry_diff`` is the geometry-engine counterpart of
+``diff_engine.compute_full_diff``: it pairs layer files with
+``match_layers``, parses both revisions, expands geometry, runs the boolean
+diff and attribution per layer, and assembles a
+:class:`~gerberdiff.geometry.types.GeometryDiffResult`.
+
+The geometry pipeline is Cairo-free.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from gerberdiff.geometry.attribute import OpChange, attribute_changes, partition_unchanged
+from gerberdiff.geometry.geom_diff import boolean_layer_diff
+from gerberdiff.geometry.layer_geometry import (
+    LayerGeometry,
+    build_layer_geometry,
+    resolve_geometry,
+)
+from gerberdiff.geometry.types import (
+    MM2_PER_IN2,
+    GeometryChange,
+    GeometryDiffResult,
+    LayerGeometryDiff,
+)
+from gerberdiff.types import (
+    Diagnostic,
+    DiagnosticSeverity,
+    GerberParseError,
+    LayerStatus,
+    LayerType,
+    ParsedImage,
+)
+
+# Default tolerances (user-facing units; see docs/geometry-diff.md).
+DEFAULT_MOVE_TOL_MM = 0.005  # 5 um: below this a matched pair is "unchanged"
+DEFAULT_GATE_RADIUS_MM = 0.2  # max centroid distance to pair two ops
+DEFAULT_AREA_TOL = 0.01  # 1% relative area delta still counts as same dims
+DEFAULT_DUST_AREA_MM2 = 1e-6  # boolean-diff components below this are noise
+
+_MM_PER_IN = 25.4
+
+
+def compute_geometry_diff(
+    before_dir: Path,
+    after_dir: Path,
+    *,
+    layers: Sequence[str] | None = None,
+    move_tol_mm: float = DEFAULT_MOVE_TOL_MM,
+    gate_radius_mm: float = DEFAULT_GATE_RADIUS_MM,
+    area_tol: float = DEFAULT_AREA_TOL,
+    dust_area_mm2: float = DEFAULT_DUST_AREA_MM2,
+    on_diagnostic: Callable[[Path, Diagnostic], None] | None = None,
+) -> GeometryDiffResult:
+    """Geometry-diff two directories of Gerber/Excellon layer files.
+
+    Parameters
+    ----------
+    before_dir, after_dir:
+        Directories containing the before and after layer files.
+    layers:
+        If given, only layers whose names appear in this sequence are diffed.
+    move_tol_mm:
+        Minimum centroid displacement (mm) for a matched pair to be reported
+        as ``moved`` rather than unchanged.
+    gate_radius_mm:
+        Maximum centroid distance (mm) at which two ops can be considered
+        the same object.
+    area_tol:
+        Relative area delta within which two matched ops still count as the
+        same dimensions (distinguishes ``moved`` from ``resized``).
+    dust_area_mm2:
+        Boolean-difference components smaller than this (mm^2) are dropped
+        as numeric noise.
+    on_diagnostic:
+        Called with ``(path, diagnostic)`` for every non-fatal parse or
+        expansion diagnostic.
+
+    Raises
+    ------
+    GerberParseError
+        When a file contains a fatal (``Error``-severity) parse diagnostic.
+    OSError
+        When a layer file cannot be read.
+    """
+    from gerberdiff.diff.layer_matcher import EXCELLON_SUFFIXES, match_layers
+    from gerberdiff.parse.excellon_parser import parse_excellon
+    from gerberdiff.parse.gerber_state import parse_gerber
+
+    move_tol_in = move_tol_mm / _MM_PER_IN
+    gate_radius_in = gate_radius_mm / _MM_PER_IN
+    dust_area_in2 = dust_area_mm2 / MM2_PER_IN2
+
+    def _parse(path: Path) -> ParsedImage:
+        content = path.read_text(errors="replace")
+        if path.suffix.lower() in EXCELLON_SUFFIXES:
+            img = parse_excellon(content, source_path=path)
+        else:
+            img = parse_gerber(content, source_path=path)
+        for diag in img.diagnostics:
+            if diag.severity == DiagnosticSeverity.Error:
+                raise GerberParseError(path, diag.message, diag.line)
+            if on_diagnostic is not None:
+                on_diagnostic(path, diag)
+        return img
+
+    def _build(path: Path) -> LayerGeometry:
+        geometry = build_layer_geometry(_parse(path))
+        if on_diagnostic is not None:
+            for diag in geometry.diagnostics:
+                on_diagnostic(path, diag)
+        return geometry
+
+    pairs = match_layers(before_dir, after_dir)
+    if layers is not None:
+        pairs = [p for p in pairs if p.name in layers]
+
+    result = GeometryDiffResult()
+    for pair in pairs:
+        if pair.status in (LayerStatus.Added, LayerStatus.Removed):
+            src_path = pair.after_path if pair.status == LayerStatus.Added else pair.before_path
+            assert src_path is not None  # invariant guaranteed by match_layers
+            geometry = _build(src_path)
+            total_mm2 = resolve_geometry(geometry.ops).area * MM2_PER_IN2
+            result.layers.append(
+                LayerGeometryDiff(
+                    name=pair.name,
+                    layer_type=pair.layer_type,
+                    status=pair.status,
+                    added_area_mm2=total_mm2 if pair.status == LayerStatus.Added else 0.0,
+                    removed_area_mm2=total_mm2 if pair.status == LayerStatus.Removed else 0.0,
+                )
+            )
+            continue
+
+        assert pair.before_path is not None and pair.after_path is not None
+        geom_a = _build(pair.before_path)
+        geom_b = _build(pair.after_path)
+        result.layers.append(
+            _diff_layer_pair(
+                pair.name,
+                pair.layer_type,
+                geom_a,
+                geom_b,
+                move_tol_in=move_tol_in,
+                gate_radius_in=gate_radius_in,
+                area_tol=area_tol,
+                dust_area_in2=dust_area_in2,
+            )
+        )
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _diff_layer_pair(
+    name: str,
+    layer_type: LayerType,
+    geom_a: LayerGeometry,
+    geom_b: LayerGeometry,
+    *,
+    move_tol_in: float,
+    gate_radius_in: float,
+    area_tol: float,
+    dust_area_in2: float,
+) -> LayerGeometryDiff:
+    parts = partition_unchanged(geom_a.ops, geom_b.ops)
+
+    added_geom, removed_geom = boolean_layer_diff(
+        geom_a,
+        geom_b,
+        parts.a_only,
+        parts.b_only,
+        parts.unchanged_a,
+        dust_area=dust_area_in2,
+    )
+
+    op_changes, unchanged_count = attribute_changes(
+        parts,
+        move_tol=move_tol_in,
+        gate_radius=gate_radius_in,
+        area_tol=area_tol,
+    )
+
+    changes = [_to_public_change(c) for c in op_changes]
+    # Top-of-board first (descending Y), then left-to-right -- matches the
+    # raster engine's region ordering.
+    changes.sort(key=lambda c: (-c.centroid_y, c.centroid_x))
+
+    return LayerGeometryDiff(
+        name=name,
+        layer_type=layer_type,
+        status=LayerStatus.Matched,
+        changes=changes,
+        unchanged_count=unchanged_count,
+        added_area_mm2=added_geom.area * MM2_PER_IN2,
+        removed_area_mm2=removed_geom.area * MM2_PER_IN2,
+    )
+
+
+def _to_public_change(change: OpChange) -> GeometryChange:
+    """Convert an engine-internal OpChange to the public GeometryChange."""
+    primary = change.after if change.after is not None else change.before
+    assert primary is not None  # every OpChange has at least one side
+    moved_or_resized = change.before is not None and change.after is not None
+    return GeometryChange(
+        kind=change.kind,
+        op_kind=primary.kind,
+        centroid_x=primary.centroid_x,
+        centroid_y=primary.centroid_y,
+        area_mm2=primary.area * MM2_PER_IN2,
+        dx_mm=change.dx * _MM_PER_IN if moved_or_resized else None,
+        dy_mm=change.dy * _MM_PER_IN if moved_or_resized else None,
+        net_name=primary.net_name,
+        before_op=change.before.source if change.before is not None else None,
+        after_op=change.after.source if change.after is not None else None,
+        before_geom=change.before.geom if change.before is not None else None,
+        after_geom=change.after.geom if change.after is not None else None,
+    )

gerberdiff/geometry/expand.py

@@ -0,0 +1,232 @@
+"""Expand individual IR draw operations into shapely geometry.
+
+Each function returns ``(geometry, diagnostics)``.  Geometry is in the
+operation's own coordinate space (inches); layer transforms and
+step-and-repeat are applied later by ``layer_geometry``.
+
+Fidelity notes
+--------------
+- Round-aperture strokes are exact (capsule = ``LineString.buffer``).
+- Non-round convex apertures on **linear** strokes are exact: the Minkowski
+  sum of a segment with a convex shape is the convex hull of the shape placed
+  at both endpoints.
+- Non-round apertures on **arc** strokes fall back to a round brush of
+  radius ``max(w, h) / 2`` with an Info diagnostic (matches the raster
+  engine's documented approximation for that case).
+- Aperture holes are subtracted from the flash shape only.  They do *not*
+  erase underlying image content (Gerber spec semantics; the raster engine's
+  ``DEST_OUT`` punch is a known compositing shortcut).
+"""
+
+from __future__ import annotations
+
+from shapely.geometry import LineString, Polygon
+from shapely.geometry.base import BaseGeometry
+from shapely.ops import unary_union
+from shapely.validation import make_valid
+
+from gerberdiff.geometry.macro_geom import macro_flash_geometry
+from gerberdiff.geometry.primitives import (
+    arc_points,
+    circle,
+    obround,
+    rectangle,
+    regular_polygon,
+)
+from gerberdiff.types import (
+    Aperture,
+    ApertureState,
+    BlockAperture,
+    CircleAperture,
+    Diagnostic,
+    DiagnosticSeverity,
+    DrawOp,
+    MacroAperture,
+    ObroundAperture,
+    PolygonAperture,
+    RectangleAperture,
+    RegionFill,
+)
+
+_EMPTY: BaseGeometry = Polygon()
+_NO_DIAGS: list[Diagnostic] = []
+
+
+# ---------------------------------------------------------------------------
+# Simple aperture outline (shared by flash and stroke expansion)
+# ---------------------------------------------------------------------------
+
+
+def _aperture_outline(ap: Aperture, x: float, y: float) -> BaseGeometry | None:
+    """The filled outline of a simple aperture centred at (x, y), no hole."""
+    match ap:
+        case CircleAperture():
+            if ap.diameter <= 0.0:
+                return None
+            return circle(x, y, ap.diameter / 2.0)
+        case RectangleAperture():
+            if ap.width <= 0.0 or ap.height <= 0.0:
+                return None
+            return rectangle(x, y, ap.width, ap.height)
+        case ObroundAperture():
+            if ap.width <= 0.0 or ap.height <= 0.0:
+                return None
+            return obround(x, y, ap.width, ap.height)
+        case PolygonAperture():
+            if ap.outer_diameter <= 0.0 or ap.num_vertices < 3:
+                return None
+            return regular_polygon(x, y, ap.outer_diameter / 2.0, ap.num_vertices, ap.rotation)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Flash (D03)
+# ---------------------------------------------------------------------------
+
+
+def flash_geometry(
+    op: DrawOp,
+    ap: Aperture | None,
+) -> tuple[BaseGeometry, list[Diagnostic]]:
+    """Expand a flash at ``(op.stop_x, op.stop_y)``.
+
+    Block apertures are handled by ``layer_geometry`` (they flatten into the
+    replay sequence); passing one here returns empty geometry.
+    """
+    if ap is None or isinstance(ap, BlockAperture):
+        return _EMPTY, _NO_DIAGS
+
+    x, y = op.stop_x, op.stop_y
+
+    if isinstance(ap, MacroAperture):
+        return macro_flash_geometry(ap, x, y)
+
+    shape = _aperture_outline(ap, x, y)
+    if shape is None:
+        return _EMPTY, _NO_DIAGS
+
+    hole = ap.hole_diameter
+    if hole is not None and hole > 0.0:
+        shape = shape.difference(circle(x, y, hole / 2.0))
+    return shape, _NO_DIAGS
+
+
+# ---------------------------------------------------------------------------
+# Stroke (D01)
+# ---------------------------------------------------------------------------
+
+
+def stroke_geometry(
+    op: DrawOp,
+    ap: Aperture | None,
+) -> tuple[BaseGeometry, list[Diagnostic]]:
+    """Expand a D01 stroke (linear or arc) into its swept filled shape."""
+    if ap is None:
+        return _EMPTY, _NO_DIAGS
+
+    if op.arc_segment is not None:
+        return _arc_stroke(op, ap)
+    return _linear_stroke(op, ap)
+
+
+def _linear_stroke(op: DrawOp, ap: Aperture) -> tuple[BaseGeometry, list[Diagnostic]]:
+    start = (op.start_x, op.start_y)
+    stop = (op.stop_x, op.stop_y)
+    degenerate = start == stop
+
+    if isinstance(ap, CircleAperture):
+        if ap.diameter <= 0.0:
+            return _EMPTY, _NO_DIAGS
+        r = ap.diameter / 2.0
+        if degenerate:
+            return circle(*stop, r), _NO_DIAGS
+        return LineString([start, stop]).buffer(r), _NO_DIAGS
+
+    # Convex non-round aperture: exact Minkowski sum for a linear segment is
+    # the convex hull of the aperture placed at both endpoints.
+    shape_a = _aperture_outline(ap, *start)
+    if shape_a is None:
+        return _EMPTY, _NO_DIAGS
+    if degenerate:
+        return shape_a, _NO_DIAGS
+    shape_b = _aperture_outline(ap, *stop)
+    assert shape_b is not None  # same aperture, same validity
+    return unary_union([shape_a, shape_b]).convex_hull, _NO_DIAGS
+
+
+def _arc_stroke(op: DrawOp, ap: Aperture) -> tuple[BaseGeometry, list[Diagnostic]]:
+    arc = op.arc_segment
+    assert arc is not None
+    pts = arc_points(arc)
+
+    if isinstance(ap, CircleAperture):
+        if ap.diameter <= 0.0:
+            return _EMPTY, _NO_DIAGS
+        return LineString(pts).buffer(ap.diameter / 2.0), _NO_DIAGS
+
+    # Non-round aperture swept along an arc: approximate with a round brush.
+    width = _stroke_fallback_width(ap)
+    if width <= 0.0:
+        return _EMPTY, _NO_DIAGS
+    diag = Diagnostic(
+        severity=DiagnosticSeverity.Info,
+        message=(
+            f"arc stroke with {type(ap).__name__} approximated by a round "
+            f"brush of diameter {width:.6f} in"
+        ),
+    )
+    return LineString(pts).buffer(width / 2.0), [diag]
+
+
+def _stroke_fallback_width(ap: Aperture) -> float:
+    """Brush width for non-round arc strokes (mirrors the raster engine)."""
+    match ap:
+        case RectangleAperture() | ObroundAperture():
+            return max(ap.width, ap.height)
+        case PolygonAperture():
+            return ap.outer_diameter
+        case _:
+            return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Region fill (G36/G37)
+# ---------------------------------------------------------------------------
+
+
+def region_geometry(region: RegionFill) -> tuple[BaseGeometry, list[Diagnostic]]:
+    """Expand a region fill into polygon geometry.
+
+    Contours are split on ``Off`` (D02 move) segments; arcs are sampled at
+    chord tolerance.  Multiple contours combine with even-odd semantics
+    (matching the renderer's ``FILL_RULE_EVEN_ODD``).
+    """
+    contours: list[list[tuple[float, float]]] = []
+    current: list[tuple[float, float]] = []
+
+    for seg in region.segments:
+        if seg.aperture_state == ApertureState.Off:
+            if len(current) >= 3:
+                contours.append(current)
+            current = [(seg.stop_x, seg.stop_y)]
+            continue
+        if not current:
+            current = [(seg.start_x, seg.start_y)]
+        if seg.arc_segment is not None:
+            # Skip the first sample -- it coincides with the current endpoint.
+            current.extend(arc_points(seg.arc_segment)[1:])
+        else:
+            current.append((seg.stop_x, seg.stop_y))
+
+    if len(current) >= 3:
+        contours.append(current)
+
+    if not contours:
+        return _EMPTY, _NO_DIAGS
+
+    geom: BaseGeometry = _EMPTY
+    for contour in contours:
+        ring = make_valid(Polygon(contour))
+        # Even-odd combination: overlapping areas toggle.
+        geom = geom.symmetric_difference(ring)
+    return geom, _NO_DIAGS