gerberdiff 0.29.0__py3-none-any.whl

gerberdiff/parse/tokenizer.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+
+class TokenType(StrEnum):
+    G = "G"
+    D = "D"
+    M = "M"
+    X = "X"
+    Y = "Y"
+    I = "I"  # noqa: E741
+    J = "J"
+    END_OF_BLOCK = "EOB"
+    EXTENDED = "EXTENDED"
+    COMMENT = "COMMENT"
+    EOF = "EOF"
+
+
+@dataclass
+class Token:
+    type: TokenType
+    value: int | str | None  # int for G/D/M/X/Y/I/J; str for EXTENDED/COMMENT; None for EOB/EOF
+    line: int
+    # raw digit string for X/Y/I/J -- needed by convert_coordinate for trailing-zero omission
+    raw: str | None = field(default=None)
+
+
+def tokenize_gerber(content: str) -> Generator[Token, None, None]:
+    """Yield tokens from a Gerber RS-274X file content string.
+
+    Handles:
+    - %...% extended command blocks (yields one EXTENDED token per *-terminated
+      command inside the block; the % delimiters are stripped)
+    - G04 comments (rest of block until * is the comment body)
+    - Coordinate words: X, Y, I, J with sign-aware integer values
+    - G, D, M codes with integer values
+    - Bare * end-of-block separators
+    - Whitespace and newlines outside extended blocks are silently skipped
+    """
+    pos = 0
+    line = 1
+    length = len(content)
+
+    def peek() -> str:
+        return content[pos] if pos < length else ""
+
+    def advance() -> str:
+        nonlocal pos, line
+        ch = content[pos]
+        pos += 1
+        if ch == "\n":
+            line += 1
+        return ch
+
+    def read_digits() -> tuple[str, int]:
+        """Consume an optional leading sign then digit characters.
+
+        Returns (raw_str, parsed_int).  raw_str carries the sign (if any) and
+        all digit characters exactly as written -- needed for trailing-zero-omission
+        coordinate scaling.  parsed_int is the signed integer value (0 on empty).
+        """
+        raw = ""
+        if peek() in ("+", "-"):
+            raw += advance()
+        while pos < length and content[pos].isdigit():
+            raw += advance()
+        value = int(raw, 10) if raw and raw not in ("+", "-") else 0
+        return raw, value
+
+    while pos < length:
+        ch = peek()
+
+        # Skip whitespace and newlines (newlines also increment `line` via advance)
+        if ch in (" ", "\t", "\r", "\n"):
+            advance()
+            continue
+
+        tok_line = line
+
+        if ch == "%":
+            advance()  # consume opening %
+            buf = ""
+            while pos < length and peek() != "%":
+                c = peek()
+                if c == "*":
+                    advance()
+                    if buf:
+                        yield Token(TokenType.EXTENDED, buf, tok_line)
+                        buf = ""
+                elif c in ("\n", "\r"):
+                    advance()
+                else:
+                    buf += advance()
+            # Emit any trailing content before closing %
+            if buf:
+                yield Token(TokenType.EXTENDED, buf, tok_line)
+            if pos < length and peek() == "%":
+                advance()  # consume closing %
+
+        elif ch == "G":
+            advance()
+            raw, num = read_digits()
+            if num == 4:
+                # G04: rest of block (until *) is a comment
+                comment = ""
+                while pos < length and peek() != "*":
+                    comment += advance()
+                yield Token(TokenType.COMMENT, comment.strip(), tok_line)
+            else:
+                yield Token(TokenType.G, num, tok_line)
+
+        elif ch == "D":
+            advance()
+            _, num = read_digits()
+            yield Token(TokenType.D, num, tok_line)
+
+        elif ch == "M":
+            advance()
+            _, num = read_digits()
+            yield Token(TokenType.M, num, tok_line)
+
+        elif ch == "X":
+            advance()
+            raw, num = read_digits()
+            yield Token(TokenType.X, num, tok_line, raw)
+
+        elif ch == "Y":
+            advance()
+            raw, num = read_digits()
+            yield Token(TokenType.Y, num, tok_line, raw)
+
+        elif ch == "I":
+            advance()
+            raw, num = read_digits()
+            yield Token(TokenType.I, num, tok_line, raw)
+
+        elif ch == "J":
+            advance()
+            raw, num = read_digits()
+            yield Token(TokenType.J, num, tok_line, raw)
+
+        elif ch == "*":
+            advance()
+            yield Token(TokenType.END_OF_BLOCK, None, tok_line)
+
+        else:
+            # Unknown character -- skip silently (robustness for non-standard files)
+            advance()
+
+    yield Token(TokenType.EOF, None, line)

gerberdiff/render/compiled_render.py

@@ -0,0 +1,240 @@
+"""Compile pass: group ParsedImage nets into batched draw groups.
+
+The compile pass walks the flat nets list once and emits ``CompiledRender``
+-- a list of ``CompiledLayer`` objects each holding ``CompiledGroup`` items
+that the renderer can dispatch without re-inspecting every net.
+
+Batching rules
+--------------
+* ``ApertureState.Flash`` + simple aperture (no hole) -> ``FlashBatch``
+  (grouped by aperture_code)
+* ``ApertureState.Flash`` + holed aperture -> ``HoledFlash`` (one per net)
+* ``ApertureState.Flash`` + ``MacroAperture`` -> ``MacroFlash`` (one per net)
+* ``ApertureState.Flash`` + ``BlockAperture`` -> ``BlockFlash`` (one per net)
+* ``ApertureState.On`` -> ``StrokeBatch`` (grouped by aperture_code)
+* ``RegionFill`` -> ``RegionGroup``
+* ``ApertureState.Off`` flushes any open stroke batch.
+
+Layer boundaries flush all open batches.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from gerberdiff.types import (
+    ApertureState,
+    BlockAperture,
+    CircleAperture,
+    DrawOp,
+    MacroAperture,
+    MirrorState,
+    ObroundAperture,
+    ParsedImage,
+    Polarity,
+    PolygonAperture,
+    RectangleAperture,
+    RegionFill,
+    StepAndRepeat,
+)
+
+# ---------------------------------------------------------------------------
+# Group dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FlashBatch:
+    """Simple flashes sharing one aperture (no hole, no macro/block)."""
+
+    kind: Literal["flash_batch"] = field(default="flash_batch", init=False)
+    aperture_code: int = 0
+    nets: list[DrawOp] = field(default_factory=list)
+
+
+@dataclass
+class StrokeBatch:
+    """D01 strokes sharing one aperture."""
+
+    kind: Literal["stroke_batch"] = field(default="stroke_batch", init=False)
+    aperture_code: int = 0
+    nets: list[DrawOp] = field(default_factory=list)
+
+
+@dataclass
+class RegionGroup:
+    """Contiguous region fill bounded by G36/G37 markers."""
+
+    kind: Literal["region_group"] = field(default="region_group", init=False)
+    nets: list[DrawOp] = field(default_factory=list)
+
+
+@dataclass
+class HoledFlash:
+    """Single flash for an aperture with a punch-through hole."""
+
+    kind: Literal["holed_flash"] = field(default="holed_flash", init=False)
+    aperture_code: int = 0
+    net: DrawOp | None = None
+
+
+@dataclass
+class MacroFlash:
+    """Single flash for a macro aperture."""
+
+    kind: Literal["macro_flash"] = field(default="macro_flash", init=False)
+    aperture_code: int = 0
+    net: DrawOp | None = None
+
+
+@dataclass
+class BlockFlash:
+    """Single flash for a block aperture (rendered in Phase 14)."""
+
+    kind: Literal["block_flash"] = field(default="block_flash", init=False)
+    aperture_code: int = 0
+    net: DrawOp | None = None
+
+
+CompiledGroup = FlashBatch | StrokeBatch | RegionGroup | HoledFlash | MacroFlash | BlockFlash
+
+
+# ---------------------------------------------------------------------------
+# Compiled layer / render containers
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CompiledLayer:
+    """One polarity layer with batched draw groups."""
+
+    layer_index: int = 0
+    step_and_repeat: StepAndRepeat = field(default_factory=StepAndRepeat)
+    polarity: Polarity = Polarity.Dark
+    mirror: MirrorState = MirrorState.None_
+    rotation: float = 0.0
+    scale: float = 1.0
+    groups: list[CompiledGroup] = field(default_factory=list)
+
+
+@dataclass
+class CompiledRender:
+    """Output of the compile pass, consumed by the renderer."""
+
+    layers: list[CompiledLayer] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Compile pass
+# ---------------------------------------------------------------------------
+
+
+def compile_render(parsed_image: ParsedImage) -> CompiledRender:
+    """Walk parsed_image.nets once and produce a ``CompiledRender``.
+
+    The resulting structure is layer-ordered and batch-merged so the renderer
+    can operate without any aperture-classification logic.
+    """
+    compiled = CompiledRender()
+
+    # Build a CompiledLayer for every LayerState in the parsed image.
+    layer_map: dict[int, CompiledLayer] = {}
+    for i, ls in enumerate(parsed_image.layers):
+        cl = CompiledLayer(
+            layer_index=i,
+            step_and_repeat=ls.step_and_repeat,
+            polarity=ls.polarity,
+            mirror=ls.mirror,
+            rotation=ls.rotation,
+            scale=ls.scale,
+        )
+        layer_map[i] = cl
+        compiled.layers.append(cl)
+
+    # Mutable batching state (closed over by the flush helpers below).
+    pending_flash: FlashBatch | None = None
+    pending_stroke: StrokeBatch | None = None
+    # The layer that owns the two pending batches.
+    batch_layer: CompiledLayer | None = None
+
+    def _flush_flash() -> None:
+        nonlocal pending_flash
+        if pending_flash is not None and batch_layer is not None:
+            batch_layer.groups.append(pending_flash)
+        pending_flash = None
+
+    def _flush_stroke() -> None:
+        nonlocal pending_stroke
+        if pending_stroke is not None and batch_layer is not None:
+            batch_layer.groups.append(pending_stroke)
+        pending_stroke = None
+
+    def _switch_layer(new_layer: CompiledLayer) -> None:
+        nonlocal batch_layer
+        _flush_flash()
+        _flush_stroke()
+        batch_layer = new_layer
+
+    for item in parsed_image.draw_ops:
+        if isinstance(item, RegionFill):
+            layer = layer_map.get(item.layer_index)
+            if layer is not None:
+                _flush_flash()
+                _flush_stroke()
+                if item.segments:
+                    layer.groups.append(RegionGroup(nets=list(item.segments)))
+            continue
+
+        net = item
+        layer = layer_map.get(net.layer_index)
+        if layer is None:
+            continue
+
+        # Flush open batches whenever the active layer changes.
+        if batch_layer is not layer:
+            _switch_layer(layer)
+
+        # ---- Flash (D03) ----
+        if net.aperture_state == ApertureState.Flash:
+            _flush_stroke()
+            ap = parsed_image.apertures.get(net.aperture_index)
+            if isinstance(ap, MacroAperture):
+                _flush_flash()
+                layer.groups.append(MacroFlash(aperture_code=net.aperture_index, net=net))
+            elif isinstance(ap, BlockAperture):
+                _flush_flash()
+                layer.groups.append(BlockFlash(aperture_code=net.aperture_index, net=net))
+            elif (
+                isinstance(
+                    ap, (CircleAperture, RectangleAperture, ObroundAperture, PolygonAperture)
+                )
+                and ap.hole_diameter is not None
+            ):
+                _flush_flash()
+                layer.groups.append(HoledFlash(aperture_code=net.aperture_index, net=net))
+            else:
+                # Simple flash -- batch by aperture_code.
+                if pending_flash is None or pending_flash.aperture_code != net.aperture_index:
+                    _flush_flash()
+                    pending_flash = FlashBatch(aperture_code=net.aperture_index)
+                pending_flash.nets.append(net)
+
+        # ---- On (D01 draw) ----
+        elif net.aperture_state == ApertureState.On:
+            _flush_flash()
+            if pending_stroke is None or pending_stroke.aperture_code != net.aperture_index:
+                _flush_stroke()
+                pending_stroke = StrokeBatch(aperture_code=net.aperture_index)
+            pending_stroke.nets.append(net)
+
+        # ---- Off (D02 move) -- just flush open batches ----
+        elif net.aperture_state == ApertureState.Off:
+            _flush_flash()
+            _flush_stroke()
+
+    # Final flush.
+    _flush_flash()
+    _flush_stroke()
+
+    return compiled

gerberdiff/render/draw_ops.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import math
+
+import cairocffi as cairo
+
+from gerberdiff.types import (
+    Aperture,
+    ApertureState,
+    ArcSegment,
+    BlockAperture,
+    CircleAperture,
+    DrawOp,
+    InterpolationMode,
+    MacroAperture,
+    ObroundAperture,
+    PolygonAperture,
+    RectangleAperture,
+)
+
+# ---------------------------------------------------------------------------
+# Arc
+# ---------------------------------------------------------------------------
+
+
+def draw_arc_path(ctx: cairo.Context, arc: ArcSegment, clockwise: bool) -> None:
+    """Add an arc to the current path without stroking or filling.
+
+    Gerber clockwise arcs map to cairo's ``arc_negative`` because cairo
+    angles increase counter-clockwise.
+    """
+    start_rad = math.radians(arc.start_angle_deg)
+    end_rad = math.radians(arc.end_angle_deg)
+    if clockwise:
+        ctx.arc_negative(arc.center_x, arc.center_y, arc.radius, start_rad, end_rad)
+    else:
+        ctx.arc(arc.center_x, arc.center_y, arc.radius, start_rad, end_rad)
+
+
+# ---------------------------------------------------------------------------
+# Region segments
+# ---------------------------------------------------------------------------
+
+
+def draw_net_segment_in_region(ctx: cairo.Context, net: DrawOp) -> None:
+    """Add one net to the current region path (inside a G36..G37 block).
+
+    ``ApertureState.Off`` starts a new contour; arcs use :func:`draw_arc_path`;
+    linear moves become ``line_to``.
+    """
+    if net.aperture_state == ApertureState.Off:
+        ctx.move_to(net.stop_x, net.stop_y)
+    elif net.arc_segment is not None:
+        draw_arc_path(
+            ctx,
+            net.arc_segment,
+            net.interpolation == InterpolationMode.ClockwiseCircular,
+        )
+    else:
+        ctx.line_to(net.stop_x, net.stop_y)
+
+
+# ---------------------------------------------------------------------------
+# Stroke
+# ---------------------------------------------------------------------------
+
+
+def draw_net_as_stroke(ctx: cairo.Context, net: DrawOp, aperture: Aperture | None) -> None:
+    """Stroke a single ``On``-state net using the aperture's line width."""
+    if aperture is None:
+        return
+
+    match aperture:
+        case CircleAperture():
+            ctx.set_line_width(aperture.diameter)
+            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+        case RectangleAperture():
+            # NOTE: max(w, h) is used as the stroke width so that the wide
+            # dimension is used for traces where the long axis aligns with the
+            # stroke direction (the common case).  A fully correct Minkowski-sum
+            # stroke requires geometry-aware rendering; see
+            # docs/geometry-diff.md.
+            ctx.set_line_width(max(aperture.width, aperture.height))
+            ctx.set_line_cap(cairo.LINE_CAP_SQUARE)
+        case ObroundAperture():
+            # NOTE: same approximation as RectangleAperture above.
+            ctx.set_line_width(max(aperture.width, aperture.height))
+            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+        case PolygonAperture():
+            ctx.set_line_width(aperture.outer_diameter)
+            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+        case _:
+            ctx.set_line_width(0.001)
+            ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+
+    ctx.new_path()
+    ctx.move_to(net.start_x, net.start_y)
+    if net.arc_segment is not None:
+        draw_arc_path(
+            ctx,
+            net.arc_segment,
+            net.interpolation == InterpolationMode.ClockwiseCircular,
+        )
+    else:
+        ctx.line_to(net.stop_x, net.stop_y)
+    ctx.stroke()
+
+
+# ---------------------------------------------------------------------------
+# Flash
+# ---------------------------------------------------------------------------
+
+
+def draw_flash(ctx: cairo.Context, net: DrawOp, aperture: Aperture | None) -> None:
+    """Draw a flash (D03) at ``net.stop_x``, ``net.stop_y``.
+
+    Macro and Block apertures are handled by the renderer directly
+    (``macro_renderer`` / block render pass) so they are silently skipped here.
+    """
+    if aperture is None:
+        return
+
+    x, y = net.stop_x, net.stop_y
+    match aperture:
+        case CircleAperture():
+            _draw_circle_flash(ctx, x, y, aperture)
+        case RectangleAperture():
+            _draw_rectangle_flash(ctx, x, y, aperture)
+        case ObroundAperture():
+            _draw_obround_flash(ctx, x, y, aperture)
+        case PolygonAperture():
+            _draw_polygon_flash(ctx, x, y, aperture)
+        case MacroAperture() | BlockAperture():
+            pass  # deferred to renderer
+
+
+# ---------------------------------------------------------------------------
+# Private helpers -- each takes a concrete aperture type for mypy narrowing
+# ---------------------------------------------------------------------------
+
+
+def _draw_hole(ctx: cairo.Context, x: float, y: float, hole_diameter: float) -> None:
+    """Punch a circular hole using DEST_OUT compositing."""
+    ctx.save()
+    ctx.set_operator(cairo.OPERATOR_DEST_OUT)
+    ctx.new_path()
+    ctx.arc(x, y, hole_diameter / 2.0, 0.0, 2.0 * math.pi)
+    ctx.fill()
+    ctx.restore()
+
+
+def _draw_circle_flash(ctx: cairo.Context, x: float, y: float, ap: CircleAperture) -> None:
+    ctx.new_path()
+    ctx.arc(x, y, ap.diameter / 2.0, 0.0, 2.0 * math.pi)
+    ctx.fill()
+    if ap.hole_diameter is not None:
+        _draw_hole(ctx, x, y, ap.hole_diameter)
+
+
+def _draw_rectangle_flash(ctx: cairo.Context, x: float, y: float, ap: RectangleAperture) -> None:
+    w2, h2 = ap.width / 2.0, ap.height / 2.0
+    ctx.new_path()
+    ctx.rectangle(x - w2, y - h2, ap.width, ap.height)
+    ctx.fill()
+    if ap.hole_diameter is not None:
+        _draw_hole(ctx, x, y, ap.hole_diameter)
+
+
+def _draw_obround_flash(ctx: cairo.Context, x: float, y: float, ap: ObroundAperture) -> None:
+    """Obround: rectangle with semicircular ends on the short axis."""
+    w, h = ap.width, ap.height
+    r = min(w, h) / 2.0
+    w2, h2 = w / 2.0, h / 2.0
+    ctx.new_path()
+    if w >= h:
+        # Horizontal obround
+        ctx.arc(x + w2 - r, y, r, -math.pi / 2.0, math.pi / 2.0)
+        ctx.arc(x - w2 + r, y, r, math.pi / 2.0, 3.0 * math.pi / 2.0)
+    else:
+        # Vertical obround
+        ctx.arc(x, y + h2 - r, r, 0.0, math.pi)
+        ctx.arc(x, y - h2 + r, r, math.pi, 2.0 * math.pi)
+    ctx.close_path()
+    ctx.fill()
+    if ap.hole_diameter is not None:
+        _draw_hole(ctx, x, y, ap.hole_diameter)
+
+
+def _draw_polygon_flash(ctx: cairo.Context, x: float, y: float, ap: PolygonAperture) -> None:
+    r = ap.outer_diameter / 2.0
+    n = ap.num_vertices
+    rot = math.radians(ap.rotation)
+    ctx.new_path()
+    for i in range(n):
+        angle = rot + 2.0 * math.pi * i / n
+        px = x + r * math.cos(angle)
+        py = y + r * math.sin(angle)
+        if i == 0:
+            ctx.move_to(px, py)
+        else:
+            ctx.line_to(px, py)
+    ctx.close_path()
+    ctx.fill()
+    if ap.hole_diameter is not None:
+        _draw_hole(ctx, x, y, ap.hole_diameter)