gerberdiff 0.29.0__py3-none-any.whl

gerberdiff/geometry/macro_geom.py

@@ -0,0 +1,215 @@
+"""Macro aperture geometry: evaluated macro primitives -> shapely.
+
+Mirrors ``render/macro_renderer.py`` primitive-by-primitive, with two
+deliberate divergences (geometry follows the Gerber spec where the raster
+engine takes compositing shortcuts):
+
+1. **Exposure scope** -- an exposure-0 primitive erases *within the macro
+   flash only* (spec), whereas the raster engine's ``DEST_OUT`` erases
+   underlying canvas content globally.
+2. **Rotation centre** -- primitive rotation is applied to the *whole
+   primitive* around the macro origin (spec), whereas the raster engine
+   rotates some primitives (21, 5, 6, 7) around their own centre.  The two
+   agree in the overwhelmingly common cases (rotation 0 or centre at origin).
+
+A macro that fails to evaluate contributes no geometry and a ``Warning``
+diagnostic (matching the renderer's behaviour).
+"""
+
+from __future__ import annotations
+
+import math
+
+from shapely import affinity
+from shapely.geometry import Polygon
+from shapely.geometry.base import BaseGeometry
+
+from gerberdiff.geometry.primitives import circle, rectangle, regular_polygon
+from gerberdiff.parse.macro_parser import (
+    EvaluatedCircle,
+    EvaluatedLineCenter,
+    EvaluatedLineVector,
+    EvaluatedMoire,
+    EvaluatedOutline,
+    EvaluatedPolygon,
+    EvaluatedPrimitive,
+    EvaluatedThermal,
+    evaluate_macro_primitives,
+)
+from gerberdiff.types import Diagnostic, DiagnosticSeverity, MacroAperture
+
+_EMPTY: BaseGeometry = Polygon()
+
+
+def macro_flash_geometry(
+    aperture: MacroAperture,
+    x: float,
+    y: float,
+) -> tuple[BaseGeometry, list[Diagnostic]]:
+    """Expand a macro aperture flash at world position (x, y).
+
+    Returns the composed geometry (possibly empty) and any diagnostics.
+    Exposure-on primitives union into the accumulator; exposure-off
+    primitives subtract from it (within the macro only).
+    """
+    if aperture.macro_def is None:
+        return _EMPTY, []
+    try:
+        primitives = evaluate_macro_primitives(aperture.macro_def, aperture.params)
+    except Exception as exc:
+        return _EMPTY, [
+            Diagnostic(
+                severity=DiagnosticSeverity.Warning,
+                message=f"Macro '{aperture.macro_def.name}' evaluation failed: {exc}",
+            )
+        ]
+
+    acc: BaseGeometry = _EMPTY
+    for p in primitives:
+        geom = _primitive_geometry(p)
+        if geom is None or geom.is_empty:
+            continue
+        if _exposure_off(p):
+            acc = acc.difference(geom)
+        else:
+            acc = acc.union(geom)
+
+    if acc.is_empty:
+        return _EMPTY, []
+
+    # Macro coords -> world: scale to inches, then translate to the flash.
+    scale = aperture.unit_scale
+    if scale != 1.0:
+        acc = affinity.scale(acc, xfact=scale, yfact=scale, origin=(0, 0))
+    return affinity.translate(acc, xoff=x, yoff=y), []
+
+
+# ---------------------------------------------------------------------------
+# Per-primitive geometry (macro-local coordinates, unscaled)
+# ---------------------------------------------------------------------------
+
+
+def _exposure_off(p: EvaluatedPrimitive) -> bool:
+    exposure = getattr(p, "exposure", 1.0)
+    return bool(exposure == 0.0)
+
+
+def _rotated(geom: BaseGeometry, rotation_deg: float) -> BaseGeometry:
+    """Rotate a primitive around the macro origin (spec semantics)."""
+    if rotation_deg == 0.0 or geom.is_empty:
+        return geom
+    return affinity.rotate(geom, rotation_deg, origin=(0, 0))
+
+
+def _primitive_geometry(p: EvaluatedPrimitive) -> BaseGeometry | None:
+    match p:
+        case EvaluatedCircle():
+            if p.diameter <= 0.0:
+                return None
+            return _rotated(circle(p.center_x, p.center_y, p.diameter / 2.0), p.rotation)
+
+        case EvaluatedLineVector():
+            return _line_vector(p)
+
+        case EvaluatedLineCenter():
+            if p.width <= 0.0 or p.height <= 0.0:
+                return None
+            return _rotated(rectangle(p.center_x, p.center_y, p.width, p.height), p.rotation)
+
+        case EvaluatedOutline():
+            if len(p.vertices) < 6:  # need at least 3 points
+                return None
+            pts = [(p.vertices[i], p.vertices[i + 1]) for i in range(0, len(p.vertices) - 1, 2)]
+            return _rotated(Polygon(pts), p.rotation)
+
+        case EvaluatedPolygon():
+            if p.diameter <= 0.0 or p.num_vertices < 3:
+                return None
+            return _rotated(
+                regular_polygon(p.center_x, p.center_y, p.diameter / 2.0, p.num_vertices),
+                p.rotation,
+            )
+
+        case EvaluatedMoire():
+            return _moire(p)
+
+        case EvaluatedThermal():
+            return _thermal(p)
+
+    return None  # pragma: no cover -- exhaustive match above
+
+
+def _line_vector(p: EvaluatedLineVector) -> BaseGeometry | None:
+    """Rectangle spanning start->end with the given width."""
+    if p.width <= 0.0:
+        return None
+    dx = p.end_x - p.start_x
+    dy = p.end_y - p.start_y
+    length = math.hypot(dx, dy)
+    if length == 0.0:
+        return None
+    nx = -dy / length * (p.width / 2.0)
+    ny = dx / length * (p.width / 2.0)
+    quad = Polygon(
+        [
+            (p.start_x + nx, p.start_y + ny),
+            (p.start_x - nx, p.start_y - ny),
+            (p.end_x - nx, p.end_y - ny),
+            (p.end_x + nx, p.end_y + ny),
+        ]
+    )
+    return _rotated(quad, p.rotation)
+
+
+def _moire(p: EvaluatedMoire) -> BaseGeometry | None:
+    """Concentric rings plus a two-bar crosshair."""
+    outer_r = p.outer_diameter / 2.0
+    if outer_r <= 0.0:
+        return None
+
+    acc: BaseGeometry = _EMPTY
+    max_rings = p.max_rings if p.max_rings > 0 else 100
+    for i in range(max_rings):
+        r_outer = outer_r - i * (p.ring_thickness + p.ring_gap)
+        if r_outer <= 0.0:
+            break
+        ring: BaseGeometry = circle(p.center_x, p.center_y, r_outer)
+        r_inner = r_outer - p.ring_thickness
+        if r_inner > 0.0:
+            ring = ring.difference(circle(p.center_x, p.center_y, r_inner))
+        acc = acc.union(ring)
+
+    cl = p.crosshair_length / 2.0
+    ct = p.crosshair_thickness / 2.0
+    if cl > 0.0 and ct > 0.0:
+        h_bar = rectangle(p.center_x, p.center_y, cl * 2.0, ct * 2.0)
+        v_bar = rectangle(p.center_x, p.center_y, ct * 2.0, cl * 2.0)
+        acc = acc.union(h_bar).union(v_bar)
+
+    if acc.is_empty:
+        return None
+    return _rotated(acc, p.rotation)
+
+
+def _thermal(p: EvaluatedThermal) -> BaseGeometry | None:
+    """Annulus with four rectangular gaps at 0/90/180/270 degrees."""
+    r_outer = p.outer_diameter / 2.0
+    if r_outer <= 0.0:
+        return None
+
+    acc: BaseGeometry = circle(p.center_x, p.center_y, r_outer)
+    r_inner = p.inner_diameter / 2.0
+    if r_inner > 0.0:
+        acc = acc.difference(circle(p.center_x, p.center_y, r_inner))
+
+    gap_w = p.gap / 2.0
+    if gap_w > 0.0:
+        # Bars need only span the annulus (2*r_outer); oversizing to 4*r_outer
+        # avoids exact edge-tangency in the boolean difference.
+        h_gap = rectangle(p.center_x, p.center_y, r_outer * 4.0, gap_w * 2.0)
+        v_gap = rectangle(p.center_x, p.center_y, gap_w * 2.0, r_outer * 4.0)
+        acc = acc.difference(h_gap).difference(v_gap)
+
+    if acc.is_empty:
+        return None
+    return _rotated(acc, p.rotation)

gerberdiff/geometry/primitives.py

@@ -0,0 +1,108 @@
+"""Low-level shapely shape builders shared by the geometry engine.
+
+All coordinates are in **inches** (the IR convention).  Circle and arc
+tessellation is adaptive: segment counts are derived from a chord (sagitta)
+tolerance so small pads stay cheap while large features keep fidelity.
+"""
+
+from __future__ import annotations
+
+import math
+
+from shapely.geometry import LineString, Point, Polygon, box
+from shapely.geometry.base import BaseGeometry
+
+from gerberdiff.types import ArcSegment
+
+# Chord (sagitta) tolerance for circle/arc tessellation: 1 um in inches.
+CHORD_TOL_IN = 1e-3 / 25.4
+
+# Bounds for tessellation segment counts (full circle).
+_MIN_SEGMENTS = 16
+_MAX_SEGMENTS = 256
+
+
+def circle_segments(radius: float, tol: float = CHORD_TOL_IN) -> int:
+    """Segment count for a full circle of *radius* with sagitta <= *tol*.
+
+    sagitta = r * (1 - cos(pi/n))  =>  n >= pi / acos(1 - tol/r)
+    """
+    if radius <= tol:
+        return _MIN_SEGMENTS
+    n = math.pi / math.acos(1.0 - tol / radius)
+    return max(_MIN_SEGMENTS, min(_MAX_SEGMENTS, math.ceil(n)))
+
+
+def _quad_segs(radius: float) -> int:
+    """quad_segs value for shapely ``buffer`` (segments per quarter circle)."""
+    return max(4, math.ceil(circle_segments(radius) / 4))
+
+
+def circle(x: float, y: float, radius: float) -> BaseGeometry:
+    """Filled circle centred at (x, y)."""
+    return Point(x, y).buffer(radius, quad_segs=_quad_segs(radius))
+
+
+def rectangle(x: float, y: float, width: float, height: float) -> BaseGeometry:
+    """Axis-aligned filled rectangle centred at (x, y)."""
+    w2, h2 = width / 2.0, height / 2.0
+    return box(x - w2, y - h2, x + w2, y + h2)
+
+
+def obround(x: float, y: float, width: float, height: float) -> BaseGeometry:
+    """Obround (stadium/capsule): rectangle with semicircular short ends."""
+    r = min(width, height) / 2.0
+    if width == height:
+        return circle(x, y, r)
+    if width > height:
+        a = (x - (width / 2.0 - r), y)
+        b = (x + (width / 2.0 - r), y)
+    else:
+        a = (x, y - (height / 2.0 - r))
+        b = (x, y + (height / 2.0 - r))
+    return LineString([a, b]).buffer(r, quad_segs=_quad_segs(r))
+
+
+def regular_polygon(
+    x: float,
+    y: float,
+    outer_radius: float,
+    num_vertices: int,
+    rotation_deg: float = 0.0,
+) -> BaseGeometry:
+    """Regular n-gon centred at (x, y); first vertex at *rotation_deg*.
+
+    Matches the renderer's vertex placement (``_draw_polygon_flash``).
+    """
+    rot = math.radians(rotation_deg)
+    pts = [
+        (
+            x + outer_radius * math.cos(rot + 2.0 * math.pi * i / num_vertices),
+            y + outer_radius * math.sin(rot + 2.0 * math.pi * i / num_vertices),
+        )
+        for i in range(num_vertices)
+    ]
+    return Polygon(pts)
+
+
+def arc_points(arc: ArcSegment, tol: float = CHORD_TOL_IN) -> list[tuple[float, float]]:
+    """Sample an :class:`ArcSegment` into a polyline (including both endpoints).
+
+    The ArcSegment convention (``arc_math.py``) is directional and monotonic:
+    CCW arcs have ``end_angle_deg > start_angle_deg``; CW arcs have
+    ``end_angle_deg < start_angle_deg``.  The sweep is traversed directly --
+    no wraparound handling is required.
+    """
+    sweep = arc.end_angle_deg - arc.start_angle_deg
+    n_full = circle_segments(arc.radius, tol)
+    n = max(2, math.ceil(n_full * abs(sweep) / 360.0))
+    pts: list[tuple[float, float]] = []
+    for i in range(n + 1):
+        theta = math.radians(arc.start_angle_deg + sweep * i / n)
+        pts.append(
+            (
+                arc.center_x + arc.radius * math.cos(theta),
+                arc.center_y + arc.radius * math.sin(theta),
+            )
+        )
+    return pts

gerberdiff/geometry/types.py

@@ -0,0 +1,85 @@
+"""Public result types for the geometry diff engine.
+
+Unit conventions (documented in ``docs/schema.md``):
+
+- ``centroid_x`` / ``centroid_y`` are in **inches** (matching the raster
+  engine's ``Region`` convention),
+- areas are in **mm^2**,
+- ``dx_mm`` / ``dy_mm`` displacements are in **mm**.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Literal
+
+from gerberdiff.types import DrawOp, LayerStatus, LayerType, RegionFill
+
+if TYPE_CHECKING:
+    from shapely.geometry.base import BaseGeometry
+
+ChangeKind = Literal["added", "removed", "moved", "resized"]
+
+# mm^2 per square inch.
+MM2_PER_IN2 = 25.4 * 25.4
+
+
+@dataclass
+class GeometryChange:
+    """One attributed change on a layer.
+
+    ``centroid_*`` and ``area_mm2`` describe the after-state object when one
+    exists (added/moved/resized) and the before-state object otherwise
+    (removed).  ``before_geom`` / ``after_geom`` carry the shapely polygons
+    for programmatic/SVG use; they are excluded from ``repr`` and JSON.
+    """
+
+    kind: ChangeKind
+    op_kind: str  # flash | stroke | region
+    centroid_x: float  # inches
+    centroid_y: float  # inches
+    area_mm2: float
+    dx_mm: float | None = None  # moved/resized: after - before
+    dy_mm: float | None = None
+    net_name: str | None = None
+    before_op: DrawOp | RegionFill | None = field(default=None, repr=False)
+    after_op: DrawOp | RegionFill | None = field(default=None, repr=False)
+    before_geom: BaseGeometry | None = field(default=None, repr=False)
+    after_geom: BaseGeometry | None = field(default=None, repr=False)
+
+
+@dataclass
+class LayerGeometryDiff:
+    """Geometry diff result for one matched/added/removed layer pair."""
+
+    name: str
+    layer_type: LayerType
+    status: LayerStatus  # matched | added | removed
+    changes: list[GeometryChange] = field(default_factory=list)
+    unchanged_count: int = 0
+    added_area_mm2: float = 0.0
+    removed_area_mm2: float = 0.0
+
+    def count(self, kind: ChangeKind) -> int:
+        """Number of changes of the given *kind*."""
+        return sum(1 for c in self.changes if c.kind == kind)
+
+    @property
+    def has_changes(self) -> bool:
+        return (
+            bool(self.changes)
+            or self.status != LayerStatus.Matched
+            or self.added_area_mm2 > 0.0
+            or self.removed_area_mm2 > 0.0
+        )
+
+
+@dataclass
+class GeometryDiffResult:
+    """Full geometry diff across all matched layers."""
+
+    layers: list[LayerGeometryDiff] = field(default_factory=list)
+
+    @property
+    def has_changes(self) -> bool:
+        return any(layer.has_changes for layer in self.layers)

gerberdiff/parse/arc_math.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import math
+
+from gerberdiff.types import ArcSegment, BoundingBox
+
+_RAD_TO_DEG = 180.0 / math.pi
+
+
+def compute_arc_multi_quadrant(
+    start_x: float,
+    start_y: float,
+    end_x: float,
+    end_y: float,
+    i: float,
+    j: float,
+    clockwise: bool,
+) -> ArcSegment | None:
+    """Compute arc geometry for G75 (multi-quadrant) mode.
+
+    (i, j) are signed offsets from the start point to the arc centre.
+    The arc can sweep any angle up to 360deg.
+
+    Returns None for a degenerate arc (radius < 1e-10).
+    """
+    center_x = start_x + i
+    center_y = start_y + j
+    radius = math.hypot(start_x - center_x, start_y - center_y)
+
+    if radius < 1e-10:
+        return None
+
+    start_angle = math.atan2(start_y - center_y, start_x - center_x) * _RAD_TO_DEG
+    end_angle = math.atan2(end_y - center_y, end_x - center_x) * _RAD_TO_DEG
+
+    # Full-circle: start and end coincide
+    if math.hypot(start_x - end_x, start_y - end_y) < 1e-10:
+        end_angle = start_angle - 360.0 if clockwise else start_angle + 360.0
+    else:
+        if clockwise and end_angle >= start_angle:
+            end_angle -= 360.0
+        elif not clockwise and end_angle <= start_angle:
+            end_angle += 360.0
+
+    return ArcSegment(
+        center_x=center_x,
+        center_y=center_y,
+        radius=radius,
+        start_angle_deg=start_angle,
+        end_angle_deg=end_angle,
+    )
+
+
+def compute_arc_single_quadrant(
+    start_x: float,
+    start_y: float,
+    end_x: float,
+    end_y: float,
+    i: float,
+    j: float,
+    clockwise: bool,
+) -> ArcSegment | None:
+    """Compute arc geometry for G74 (single-quadrant) mode.
+
+    In G74 mode the magnitude of (i, j) is always positive but the sign is
+    implicit.  Try all four sign combinations and keep the candidate where the
+    arc sweep is <= 90deg (single-quadrant constraint), preferring the one with
+    the smallest start-to-end radius mismatch.
+
+    Returns None if no valid candidate is found.
+    """
+    abs_i = abs(i)
+    abs_j = abs(j)
+
+    best: ArcSegment | None = None
+    best_error = math.inf
+
+    for sign_i, sign_j in ((1, 1), (1, -1), (-1, 1), (-1, -1)):
+        cx = start_x + sign_i * abs_i
+        cy = start_y + sign_j * abs_j
+
+        r_start = math.hypot(start_x - cx, start_y - cy)
+        if r_start < 1e-10:
+            continue
+        r_end = math.hypot(end_x - cx, end_y - cy)
+
+        # Normalise angles to [0, 360)
+        sa = math.atan2(start_y - cy, start_x - cx) * _RAD_TO_DEG % 360.0
+        ea = math.atan2(end_y - cy, end_x - cx) * _RAD_TO_DEG % 360.0
+
+        # Compute the arc sweep in the intended direction
+        if clockwise:
+            sweep = sa - ea
+            if sweep <= 0:
+                sweep += 360.0
+        else:
+            sweep = ea - sa
+            if sweep <= 0:
+                sweep += 360.0
+
+        # G74 constraint: arc must stay within a single quadrant (<= 90deg)
+        if sweep > 90.5:
+            continue
+
+        error = abs(r_start - r_end)
+        if error < best_error:
+            best_error = error
+            # Full-circle degenerate case
+            if math.hypot(start_x - end_x, start_y - end_y) < 1e-10:
+                end_a = sa - 360.0 if clockwise else sa + 360.0
+            else:
+                end_a = ea
+            best = ArcSegment(
+                center_x=cx,
+                center_y=cy,
+                radius=r_start,
+                start_angle_deg=sa,
+                end_angle_deg=end_a,
+            )
+
+    return best
+
+
+def arc_bounding_box(arc: ArcSegment, aperture_radius: float = 0.0) -> BoundingBox:
+    """Return the axis-aligned bounding box of an arc segment.
+
+    Correctly handles multi-quadrant arcs by checking whether any of the four
+    axis-extrema angles (0, 90, 180, 270 degrees) fall within the swept range.
+
+    *aperture_radius* is added as padding on all sides (half the trace width).
+    """
+    bb = BoundingBox()
+    cx, cy, r = arc.center_x, arc.center_y, arc.radius
+
+    # Expand by both endpoints.
+    for theta_deg in (arc.start_angle_deg, arc.end_angle_deg):
+        theta_rad = math.radians(theta_deg)
+        bb.expand(cx + r * math.cos(theta_rad), cy + r * math.sin(theta_rad), aperture_radius)
+
+    # Determine the angular range covered by the arc.  The ArcSegment convention
+    # (set by compute_arc_multi_quadrant / compute_arc_single_quadrant) is:
+    #   CCW arcs: end_angle_deg > start_angle_deg
+    #   CW arcs:  end_angle_deg < start_angle_deg
+    # So [lo, hi] = [min, max] covers the swept interval regardless of direction.
+    lo = min(arc.start_angle_deg, arc.end_angle_deg)
+    hi = max(arc.start_angle_deg, arc.end_angle_deg)
+
+    # For each axis extremum (0deg, 90deg, 180deg, 270deg), check whether any integer
+    # multiple of 360deg shifted copy of that angle falls in [lo, hi].  If so,
+    # the arc passes through that extremum and we must expand the bbox.
+    for axis_angle in (0.0, 90.0, 180.0, 270.0):
+        k_start = math.ceil((lo - axis_angle) / 360.0)
+        for k in range(k_start, k_start + 4):
+            candidate = axis_angle + 360.0 * k
+            if lo <= candidate <= hi:
+                theta_rad = math.radians(axis_angle)
+                bb.expand(
+                    cx + r * math.cos(theta_rad), cy + r * math.sin(theta_rad), aperture_radius
+                )
+                break
+
+    return bb