Source code for jitxlib.gerber.extract.copper

"""Collect copper: routed traces, pours, and deliberate cross-net bridges.

Vias and pads are opaque to the query here; their copper is `padstacks.py`'s.
`OverlappableCopper` is opaque too, and for a different reason: it is not a
`Copper` subclass but a `SingleLayerFeature` with a registered transformer to
`Copper`, so a plain query flattens it and the exporter can no longer tell a
declared net tie from a short. The distinction has to survive the query,
because two separate decisions depend on it - whether a cross-net contact is
an intentional bridge, and what net set the resulting copper declares.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from logging import getLogger

from jitx import Copper, Placement, Via
from jitx.feature import OverlappableCopper
from jitx.landpattern import Pad
from jitx.run.runtime import RuntimeDesign
from jitx.shapes import Shape
from jitx.transform import Transform

from ..format.apertures import circle_aperture
from ..format.model import ArcObj, AttrSet, Draw, attr
from . import geometry, regions
from .layers import LayerModel
from .nets import NetResolver

logger = getLogger(__name__)

CONDUCTOR = attr(".AperFunction", "Conductor")
"""5.6.10: conductive copper, pours included. A region takes its aperture
attributes from the dictionary as it stands at `G36`, which is how a pour
carries one at all."""

ETCHED_COMPONENT = attr(".AperFunction", "EtchedComponent")
"""5.6.13.1: copper that deliberately joins two nets, "the net names are
different on both sides". A net tie, exactly. It is the mechanism that
changes the connectivity CAM computes, which is why a tie has to survive as
its own object rather than being merged into what it bridges."""


[docs] @dataclass class CopperPlan: """Per-conductor copper, before the region analysis runs. Args: pieces: everything conducting on the layer, for the connectivity graph and the union. strokes: draws and arcs, emitted after every region so they can never be erased. """ pieces: dict[int, list[regions.Piece]] = field(default_factory=dict) strokes: dict[int, list[Draw | ArcObj]] = field(default_factory=dict)
[docs] def piece(self, layer: int, item: regions.Piece) -> None: self.pieces.setdefault(layer, []).append(item)
[docs] def stroke(self, layer: int, items: list[Draw | ArcObj]) -> None: if items: self.strokes.setdefault(layer, []).extend(items)
[docs] def collect(design: RuntimeDesign, model: LayerModel, nets: NetResolver) -> CopperPlan: """Walk the design's copper into a per-layer plan.""" plan = CopperPlan() skipped = 0 for trace, copper in design.query(Copper, opaque=Via | Pad | OverlappableCopper): if not trace.transform: continue layer = layer_of(model, trace.transform, copper.layer) names = _names(nets, copper) if geometry.is_stroked(copper.shape): _add_trace(plan, layer, copper.shape, trace.transform, names, nets) elif geometry.is_filled(copper.shape): plan.piece( layer, regions.Piece( geometry.to_shapely(copper.shape, trace.transform).g, names ), ) else: skipped += 1 for trace, tie in design.query(OverlappableCopper): if not trace.transform: continue if not geometry.is_filled(tie.shape): skipped += 1 continue plan.piece( layer_of(model, trace.transform, tie.layer), regions.Piece(geometry.to_shapely(tie.shape, trace.transform).g, tie=True), ) if skipped: logger.warning("%d copper shapes were neither stroked nor filled", skipped) return plan
[docs] def layer_of(model: LayerModel, transform: Transform, layer: int) -> int: """The absolute conductor a layer index refers to under a placement. The side comes off the composed transform, which is where every side question in this package is answered. """ return model.normalize(Placement(transform).side.apply(layer))
def _names(nets: NetResolver, element: object) -> frozenset[str]: name = nets.name(element) return frozenset() if name is None else frozenset([name]) def _add_trace( plan: CopperPlan, layer: int, shape: Shape, transform: Transform, names: frozenset[str], nets: NetResolver, ) -> None: """A routed trace as draws and arcs, plus its footprint in the graph. The stroke is in the connectivity graph but not in the union: it is emitted after every clear region, so it can never be erased, and it contributes no region geometry for a hole to be wrong about. """ attrs: AttrSet = (nets.names_attribute(sorted(names)),) aperture = circle_aperture( geometry.stroke_width(shape, transform), attrs=(CONDUCTOR,) ) plan.stroke(layer, geometry.to_strokes(shape, aperture, transform, attrs)) plan.piece( layer, regions.Piece(geometry.to_shapely(shape, transform).g, names, filled=False), )