breakneck 0.2.1__py3-none-any.whl

breakneck/base.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass(frozen=True)
+class Coords2D:
+    x: int
+    y: int
+
+    def __post_init__(self):
+        object.__setattr__(self, "x", int(self.x))
+        object.__setattr__(self, "y", int(self.y))
+
+    def __hash__(self):
+        return hash((self.x, self.y))
+
+    def __eq__(self, other):
+        return self.x == other.x and self.y == other.y
+
+    def __getitem__(self, idx):
+        if idx == 0:
+            return self.x
+        elif idx == 1:
+            return self.y
+        else:
+            raise IndexError("Index out of range")
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __len__(self):
+        return 2
+
+    def __repr__(self):
+        return f"Coords({self.x}, {self.y})"
+
+    def as_tol(self, tol_nm):
+        return Coords2D(round(self.x / tol_nm), round(self.y / tol_nm))
+
+    def as_tuple(self):
+        return self.x, self.y
+
+
+class Sides(str, Enum):
+    front = "front"
+    back = "back"
+    both = "both"

breakneck/cli.py

@@ -0,0 +1,305 @@
+import argparse
+from collections.abc import Sequence
+
+import kipy.board
+import kipy.board_types
+import shapely.geometry
+from kipy.board import BoardLayer as BL
+from kipy.proto.board import board_types_pb2
+from kipy.proto.common import base_types_pb2
+from loguru import logger
+
+import breakneck.conversions
+import breakneck.footprint
+
+
+def break_tracks(
+    board: kipy.board.Board,
+    footprints: Sequence[breakneck.footprint.BNFootprint],
+    tracks: Sequence[kipy.board_types.Track | kipy.board_types.ArcTrack],
+    neck_length: float = 10,
+    dry_run: bool = False,
+) -> None:
+    """
+    Break tracks crossing the courtyards of footprints on a board.
+    """
+    all_tracks = {t.id.value: t for t in tracks}
+    logger.debug("Getting all courtyards")
+
+    max_width = max(t.width for t in all_tracks.values())
+    remove_dict = {}
+    create_dict = {}
+
+    neck_length_nm = int(neck_length * 1000000)  # mm to nm
+
+    for fpc in footprints:
+        logger.debug(f"Breaking tracks for {fpc.ref}")
+        items_to_remove, items_to_create = fpc.break_tracks(
+            list(all_tracks.values()), max_width, neck_length_nm
+        )
+
+        # remove items from all_tracks and create_list
+        for item in items_to_remove:
+            all_tracks.pop(item.id.value)
+            create_dict.pop(item.id.value, None)
+
+        # add new items to all_tracks and create_list
+        for item in items_to_create:
+            all_tracks[item.id.value] = item
+            create_dict[item.id.value] = item
+
+        # add items to remove_list
+        for item in items_to_remove:
+            remove_dict[item.id.value] = item
+
+    commit = board.begin_commit()
+    board.remove_items(list(remove_dict.values()))
+    board.create_items(list(create_dict.values()))
+    if dry_run:
+        board.drop_commit(commit)
+    else:
+        board.push_commit(commit)
+
+
+def execute_cut(args):
+    kicad = kipy.KiCad()
+    board = kicad.get_board()
+
+    tracks = board.get_tracks()
+    footprints = board.get_footprints()
+
+    num_all_tracks = len(tracks)
+    num_all_footprints = len(footprints)
+
+    if args.selection:
+        items = board.get_selection()
+
+        if len(items) == 0:
+            logger.error("No items selected")
+            return
+
+        # get tracks from selection
+        sel_tracks = [
+            item
+            for item in items
+            if isinstance(item, kipy.board_types.Track)
+            or isinstance(item, kipy.board_types.ArcTrack)
+        ]
+
+        # get footprints from selection
+        sel_footprints = [
+            item
+            for item in items
+            if isinstance(item, kipy.board_types.FootprintInstance)
+        ]
+
+        # If selection has no tracks or footprints, use all tracks and footprints
+
+        if sel_tracks:
+            tracks = sel_tracks
+        if sel_footprints:
+            footprints = sel_footprints
+
+    bnfootprints = breakneck.footprint.get_bn_footprints(footprints)
+
+    if args.sides:
+        if args.sides == "front":
+            tracks = [t for t in tracks if t.layer == BL.BL_F_Cu]
+            bnfootprints = [
+                fpc for fpc in bnfootprints if not fpc.front_courtyard.is_empty
+            ]
+        elif args.sides == "back":
+            tracks = [t for t in tracks if t.layer == BL.BL_B_Cu]
+            bnfootprints = [
+                fpc for fpc in bnfootprints if not fpc.back_courtyard.is_empty
+            ]
+
+    if args.netclass:
+        nets = board.get_nets(args.netclass)
+        net_names = set(n.name for n in nets)
+        tracks = [t for t in tracks if t.net in net_names]
+
+    num_tracks = len(tracks)
+    num_footprints = len(bnfootprints)
+
+    logger.info(
+        f"Breaking tracks on {num_tracks}/{num_all_tracks} tracks "
+        f"and {num_footprints}/{num_all_footprints} footprints"
+    )
+
+    if num_tracks == 0:
+        logger.warning("No tracks to break")
+        return
+
+    if num_footprints == 0:
+        logger.warning("No footprints to break tracks on")
+        return
+
+    break_tracks(board, bnfootprints, tracks, dry_run=args.dry_run)
+
+
+def execute_gndvia_check(args):
+    max_distance = args.distance * 1000000  # mm to nm
+
+    kicad = kipy.KiCad()
+    board = kicad.get_board()
+
+    vias = board.get_vias()
+
+    all_pads = board.get_pads()
+    gnd_tht_pads = [
+        pad
+        for pad in all_pads
+        if pad.net.name == "GND" and pad.proto.type == kipy.board_types.PadType.PT_PTH
+    ]
+
+    # We treat GND THT pads as vias as well
+    gnd_vias = [via for via in vias if via.net.name == "GND"] + gnd_tht_pads
+
+    gnd_via_coords = [
+        breakneck.conversions.vector2_as_coords(via.position) for via in gnd_vias
+    ]
+    gnd_via_points = [shapely.geometry.Point(coords) for coords in gnd_via_coords]
+
+    gnd_via_tree = shapely.STRtree(gnd_via_points)
+
+    non_gnd_vias = [via for via in vias if via.net.name != "GND"]
+    non_gnd_via_coords = [
+        breakneck.conversions.vector2_as_coords(via.position) for via in non_gnd_vias
+    ]
+    non_gnd_via_points = [
+        shapely.geometry.Point(coords) for coords in non_gnd_via_coords
+    ]
+
+    nearests_idxs = [gnd_via_tree.nearest(pt) for pt in non_gnd_via_points]
+
+    nearests = [gnd_via_points[idx] for idx in nearests_idxs]
+    distances = [
+        shapely.distance(nearest, non_gnd_via)
+        for nearest, non_gnd_via in zip(nearests, non_gnd_via_points)
+    ]
+
+    # Get those non-gnd vias that are more than 3000000 nm away from the nearest gnd via
+    lone_via_idxs = [
+        i for i, distance in enumerate(distances) if distance > max_distance
+    ]
+
+    new_lines = []
+    for idx in lone_via_idxs:
+        # Draw a line from the lone via to the nearest gnd via on layer BL.BL_Eco2_User
+        # with thickness 0.05mm = 50000 nm
+        ngvc = non_gnd_via_coords[idx]
+        gvc = gnd_via_coords[nearests_idxs[idx]]
+        start_proto_vector = base_types_pb2.Vector2(x_nm=ngvc[0], y_nm=-ngvc[1])
+        end_proto_vector = base_types_pb2.Vector2(x_nm=gvc[0], y_nm=-gvc[1])
+
+        shape = base_types_pb2.GraphicShape(
+            segment=base_types_pb2.GraphicSegmentAttributes(
+                start=start_proto_vector, end=end_proto_vector
+            )
+        )
+
+        board_graphic_shape = board_types_pb2.BoardGraphicShape(shape=shape)
+
+        segment = kipy.board_types.BoardSegment(proto=board_graphic_shape)
+        segment.layer = BL.BL_Eco2_User
+        segment.attributes.stroke.width = 100000
+        new_lines.append(segment)
+
+    shapes = board.get_shapes()
+    eco2_shapes = [shape for shape in shapes if shape.layer == BL.BL_Eco2_User]
+
+    commit = board.begin_commit()
+    board.remove_items(eco2_shapes)
+    board.create_items(new_lines)
+    if args.dry_run:
+        board.drop_commit(commit)
+    else:
+        board.push_commit(commit)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--dry-run",
+        "-n",
+        action="store_true",
+        help="Do everything except commit the changes",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    cut_parser = subparsers.add_parser("cut", help="Add neckdowns to tracks")
+
+    cut_parser.add_argument(
+        "--selection", action="store_true", help="Use selected items"
+    )
+
+    cut_parser.add_argument(
+        "--sides",
+        choices=["front", "back", "both"],
+        default="both",
+        help="Side of the board to break tracks on",
+    )
+
+    cut_parser.add_argument(
+        "--length",
+        "-l",
+        type=float,
+        default=10,
+        help="Neckdown length outside of the courtyard, in mm",
+    )
+
+    cut_parser.add_argument("--netclass", type=str, help="Netclass to break tracks on")
+
+    gnd_via_parser = subparsers.add_parser("gndvia", help="Visualize GND via distances")
+
+    gnd_via_parser.add_argument(
+        "--distance",
+        "-d",
+        type=float,
+        default=2,
+        help="Maximum distance to GND via, in mm",
+    )
+
+    subparsers.add_parser("clear", help="Remove annotations from User.Eco2 layer")
+
+    return parser.parse_args()
+
+
+def execute_clear(args):
+    kicad = kipy.KiCad()
+    board = kicad.get_board()
+
+    shapes = board.get_shapes()
+    eco2_shapes = [shape for shape in shapes if shape.layer == BL.BL_Eco2_User]
+
+    if not shapes:
+        logger.info("No shapes to clear")
+        return
+
+    commit = board.begin_commit()
+    board.remove_items(eco2_shapes)
+    if args.dry_run:
+        board.drop_commit(commit)
+    else:
+        board.push_commit(commit)
+
+
+def main():
+    args = parse_args()
+
+    match args.command:
+        case "cut":
+            execute_cut(args)
+
+        case "gndvia":
+            execute_gndvia_check(args)
+
+        case "clear":
+            execute_clear(args)
+
+
+if __name__ == "__main__":
+    main()

breakneck/conversions.py

@@ -0,0 +1,370 @@
+from collections import defaultdict
+
+import kipy
+import kipy.board_types as kbt
+import kipy.common_types
+import kipy.geometry
+import kipy.util.units
+import numpy as np
+import shapely.geometry as sg
+
+from breakneck.base import Coords2D
+
+OpenShape = kbt.BoardSegment | kbt.BoardArc
+ClosedShape = kbt.BoardRectangle | kbt.BoardCircle | kbt.BoardPolygon
+
+OpenShapes = list[OpenShape]
+ClosedShapes = list[ClosedShape]
+
+
+def vector2_as_coords(point: kipy.geometry.Vector2) -> Coords2D:
+    """
+    Convert a point to coordinates in millimeters with y-up orientation.
+    """
+    # Shapely uses y-up coordinates
+    return Coords2D(point.x, -point.y)
+
+
+def coords_as_vector2(coords: Coords2D) -> kipy.geometry.Vector2:
+    """
+    Convert coordinates in millimeters with y-up orientation to a point.
+    """
+    return kipy.geometry.Vector2.from_xy(coords.x, -coords.y)
+
+
+def track_as_linestring(track: kbt.Track | kbt.ArcTrack) -> sg.LineString:
+    if isinstance(track, kbt.Track):
+        return sg.LineString(
+            [vector2_as_coords(track.start).as_tuple(), vector2_as_coords(track.end)]
+        )
+    else:
+        return arc_as_linestring(track)
+
+
+def _polyline_as_coords(polyline: kipy.geometry.PolyLine) -> list[Coords2D]:
+    return [vector2_as_coords(node.point) for node in polyline.nodes]
+
+
+def _polyline_as_tuples(polyline: kipy.geometry.PolyLine) -> list[tuple[int, int]]:
+    return [coords.as_tuple() for coords in _polyline_as_coords(polyline)]
+
+
+def polygon_as_shapely_polygon(polygon: kipy.geometry.PolygonWithHoles) -> sg.Polygon:
+    print("converting")
+    coords = _polyline_as_tuples(polygon.outline)
+    holes = [_polyline_as_tuples(hole) for hole in polygon.holes]
+    return sg.Polygon(coords, holes)
+
+
+def board_polygon_as_polygons(
+    polygon: kbt.BoardPolygon,
+) -> list[sg.Polygon]:
+    polygons: list[sg.Polygon] = []
+    for poly in polygon.polygons:
+        polygons.append(polygon_as_shapely_polygon(poly))
+    return polygons
+
+
+def board_segment_as_linestring(
+    segment: kbt.BoardSegment,
+) -> sg.LineString:
+    return sg.LineString(
+        [vector2_as_coords(segment.start), vector2_as_coords(segment.end)]
+    )
+
+
+def board_segments_as_linestrings(
+    boardsegments: list[kbt.BoardSegment],
+) -> list[sg.LineString]:
+    return [board_segment_as_linestring(bs) for bs in boardsegments]
+
+
+def board_rectangle_as_polygon(
+    rectangle: kbt.BoardRectangle,
+) -> sg.Polygon:
+    # Get corner coordinates
+    top_left = rectangle.top_left
+    bottom_right = rectangle.bottom_right
+    coords = [
+        (top_left.x, -top_left.y),
+        (bottom_right.x, -top_left.y),
+        (bottom_right.x, -bottom_right.y),
+        (top_left.x, -bottom_right.y),
+    ]
+    return sg.Polygon(coords)
+
+
+def arc_as_linestring(
+    arc: kipy.common_types.Arc | kbt.ArcTrack,
+) -> sg.LineString:
+    # Get the start and end points of the arc
+    start = vector2_as_coords(arc.start)
+    mid = vector2_as_coords(arc.mid)
+
+    # Calculate the center of the arc
+    arc_center = arc.center()
+
+    if arc_center is None:
+        # Return an empty line string for degenerate arcs
+        return sg.LineString([])
+
+    center = vector2_as_coords(arc_center)
+
+    # Calculate the radius of the arc
+    radius = int(arc.radius())
+
+    # Determine if the arc is CW or CCW
+    cross_product = (start.x - center.x) * (mid.y - center.y) - (start.y - center.y) * (
+        mid.x - center.x
+    )
+
+    # Calculate the start and end angles of the arc
+    start_angle = arc.start_angle()
+    end_angle = arc.end_angle()
+    assert start_angle is not None
+    assert end_angle is not None
+
+    # kipy coordinates are y-down but we use y-up. Adjust angles accordingly
+    start_angle = -start_angle
+    end_angle = -end_angle
+
+    if cross_product > 0:  # Counterclockwise
+        if end_angle < start_angle:
+            end_angle += 2 * np.pi
+    else:  # Clockwise
+        if end_angle > start_angle:
+            end_angle -= 2 * np.pi
+
+    # We want points at every degree
+
+    # Calculate the angle of the arc
+    angle = abs(end_angle - start_angle)
+
+    num_points = int(np.degrees(angle)) + 1
+
+    angles = np.linspace(start_angle, end_angle, num_points)
+
+    arc_points = [
+        Coords2D(int(center.x + radius * np.cos(a)), int(center.y + radius * np.sin(a)))
+        for a in angles
+    ]
+
+    return sg.LineString(arc_points)
+
+
+def board_circle_as_polygon(
+    circle: kbt.BoardCircle, num_points: int = 360
+) -> sg.Polygon:
+    # Get the center of the circle
+    center = vector2_as_coords(circle.center)
+
+    # Get the radius of the circle
+    radius = int(circle.radius())
+
+    # We want points at every degree
+    angles = np.linspace(0, 2 * np.pi, num_points)
+
+    # Calculate the points of the circle
+    circle_points = [
+        Coords2D(int(center.x + radius * np.cos(a)), int(center.y + radius * np.sin(a)))
+        for a in angles
+    ]
+
+    # Create the circle
+    return sg.Polygon(circle_points)
+
+
+def polyline_as_shapely(polyline: kipy.geometry.PolyLine) -> sg.LineString:
+    return sg.LineString(_polyline_as_tuples(polyline))
+
+
+def closed_shapes_as_polygon(shapes: ClosedShapes) -> list[sg.Polygon]:
+    geometries = []
+    for shape in shapes:
+        if isinstance(shape, kbt.BoardRectangle):
+            geometries.append(board_rectangle_as_polygon(shape))
+        elif isinstance(shape, kbt.BoardCircle):
+            geometries.append(board_circle_as_polygon(shape))
+        elif isinstance(shape, kbt.BoardPolygon):
+            geometries.extend(board_polygon_as_polygons(shape))
+    return geometries
+
+
+def open_shapes_as_polygon(shapes: OpenShapes, tol_nm: int) -> list[sg.Polygon]:
+    """
+    Convert a list of open shapes to a list of shapely polygons
+    """
+    chains = _chain_shapes(shapes, tol_nm)
+    polygons = []
+    for chain in chains:
+        coords = []
+        for shape in chain:
+            if isinstance(shape, kbt.BoardSegment):
+                coords.append(vector2_as_coords(shape.start).as_tuple())
+            elif isinstance(shape, kbt.BoardArc):
+                coords.append(vector2_as_coords(shape.start).as_tuple())
+                coords.extend(arc_as_linestring(shape).coords[1:-1])
+            else:
+                raise ValueError(f"Shape {type(shape)} not supported")
+        coords.append(coords[0])
+        polygons.append(sg.Polygon(coords))
+    return polygons
+
+
+def _get_endpoints(shape: kbt.BoardShape, tol_nm: int) -> tuple[Coords2D, Coords2D]:
+    """Return the start and end Coords2D of a BoardSegment."""
+
+    if isinstance(shape, kbt.BoardSegment) or isinstance(shape, kbt.BoardArc):
+        start = Coords2D(shape.start.x, shape.start.y).as_tol(tol_nm)
+        end = Coords2D(shape.end.x, shape.end.y).as_tol(tol_nm)
+    else:
+        raise ValueError(f"Shape {type(shape)} not supported")
+
+    return start, end
+
+
+def build_shape_adjacency_graph(
+    shapes: OpenShapes, tol_nm: int
+) -> tuple[
+    dict[Coords2D, list[Coords2D]],
+    dict[Coords2D, OpenShapes],
+]:
+    """Build an adjacency graph for non-closed KiPy board shapes.
+
+    The adjacency dict maps Coords2D to a list of connected Coords2D.
+    The shape_map dict maps Coords2D to a list of connected BoardShapes.
+    """
+    adjacency: dict[Coords2D, list[Coords2D]] = defaultdict(list)
+    shape_map: dict[Coords2D, list[kbt.BoardSegment | kbt.BoardArc]] = defaultdict(list)
+
+    for shape in shapes:
+        assert isinstance(shape, kbt.BoardSegment) or isinstance(shape, kbt.BoardArc)
+        start, end = _get_endpoints(shape, tol_nm)
+
+        adjacency[start].append(end)
+        adjacency[end].append(start)
+        shape_map[start].append(shape)
+        shape_map[end].append(shape)
+
+    return adjacency, shape_map
+
+
+def _reverse_segment(segment: kbt.BoardSegment) -> None:
+    segment.start, segment.end = segment.end, segment.start
+
+
+def _reverse_arc(arc: kbt.BoardArc) -> None:
+    arc.start, arc.end = arc.end, arc.start
+    arc.start_angle, arc.end_angle = arc.end_angle, arc.start_angle
+
+
+def _reverse_shape(shape: kbt.BoardShape) -> None:
+    if isinstance(shape, kbt.BoardSegment):
+        _reverse_segment(shape)
+    elif isinstance(shape, kbt.BoardArc):
+        _reverse_arc(shape)
+    else:
+        raise ValueError(f"Shape {type(shape)} not supported")
+
+
+def _extract_chain(
+    shape: OpenShape,
+    shapes: OpenShapes,
+    visited_shapes: set[OpenShape],
+    tol_nm: int,
+) -> OpenShapes:
+    """Extract a chain of connected shapes from a starting point."""
+    ordered_shapes = []
+
+    visited_shapes.add(shape)
+    chain_start, end = _get_endpoints(shape, tol_nm)
+    ordered_shapes.append(shape)
+
+    while True:
+        # Find a connected shape: start or end point should equal to
+        # the end point of the last shape
+
+        found = False
+
+        for next_shape in shapes:
+            if next_shape in visited_shapes:
+                continue
+
+            next_start, next_end = _get_endpoints(next_shape, tol_nm)
+
+            if end == next_start:
+                ordered_shapes.append(next_shape)
+                visited_shapes.add(next_shape)
+                end = next_end
+                found = True
+                break
+            elif end == next_end:
+                _reverse_shape(next_shape)
+                ordered_shapes.append(next_shape)
+                visited_shapes.add(next_shape)
+                end = next_start
+                found = True
+                break
+
+        if not found:
+            break
+
+    return ordered_shapes
+
+
+def _chain_shapes(shapes: OpenShapes, tol_nm: int) -> list[OpenShapes]:
+    """Convert a list of unordered BoardShapes to chains of shapes."""
+
+    # Courtyards are so simple that a graph is not needed
+
+    # Start traversing the shapes
+    ordered_chains: list[OpenShapes] = []
+    visited_shapes = set()
+
+    for shape in shapes:
+        if shape in visited_shapes:
+            continue
+        chain = _extract_chain(shape, shapes, visited_shapes, tol_nm)
+        if chain:
+            ordered_chains.append(chain)
+
+    return ordered_chains
+
+
+def _chain_as_polygon(chain: OpenShapes) -> sg.Polygon:
+    coords = []
+    for shape in chain:
+        if isinstance(shape, kbt.BoardSegment):
+            coords.append(vector2_as_coords(shape.start).as_tuple())
+        elif isinstance(shape, kbt.BoardArc):
+            coords.append(vector2_as_coords(shape.start).as_tuple())
+            coords.extend(arc_as_linestring(shape).coords[1:-1])
+        else:
+            raise ValueError(f"Shape {type(shape)} not supported")
+    coords.append(coords[0])
+    return sg.Polygon(coords)
+
+
+def as_polygons(shapes: list[kbt.BoardShape], tol_nm: int) -> list[sg.Polygon]:
+    """Convert a list of BoardShapes to a list of shapely Polygons."""
+    closed_shapes: ClosedShapes = []
+    open_shapes: OpenShapes = []
+
+    for shape in shapes:
+        if isinstance(shape, kbt.BoardRectangle) or isinstance(shape, kbt.BoardCircle):
+            closed_shapes.append(shape)
+        elif isinstance(shape, kbt.BoardPolygon):
+            closed_shapes.append(shape)
+        elif isinstance(shape, kbt.BoardSegment) or isinstance(shape, kbt.BoardArc):
+            open_shapes.append(shape)
+        else:
+            raise ValueError(f"Shape {type(shape)} not supported")
+
+    polygons = closed_shapes_as_polygon(closed_shapes)
+
+    chains = _chain_shapes(open_shapes, tol_nm)
+
+    for chain in chains:
+        polygons.append(_chain_as_polygon(chain))
+
+    return polygons

breakneck/footprint.py

@@ -0,0 +1,234 @@
+from collections.abc import Sequence
+
+import kipy.board
+import kipy.board_types
+import shapely
+import shapely.geometry as sg
+from kipy.board import BoardLayer as BL
+from kipy.proto.board import board_types_pb2
+from loguru import logger
+
+import breakneck.base
+import breakneck.conversions
+import breakneck.track
+from breakneck.base import Coords2D
+
+
+def get_courtyard_shapes(
+    footprint: kipy.board_types.FootprintInstance,
+    layer: board_types_pb2.BoardLayer.ValueType,
+) -> list[kipy.board_types.BoardShape]:
+    """
+    Get the front or back courtyard shapes of a footprint
+    """
+    return [sh for sh in footprint.definition.shapes if sh.layer == layer]
+
+
+def get_courtyard_polygons(
+    footprint: kipy.board_types.FootprintInstance,
+) -> tuple[sg.Polygon, sg.Polygon]:
+    """Get the front and back courtyard polygons of a footprint."""
+
+    f_crtyd_shapes = get_courtyard_shapes(footprint, BL.BL_F_CrtYd)
+    f_poly = shapely.union_all(breakneck.conversions.as_polygons(f_crtyd_shapes, 1000))
+    if f_poly.is_empty:
+        f_poly = sg.Polygon()
+    assert isinstance(f_poly, sg.Polygon)
+    b_crtyd_shapes = get_courtyard_shapes(footprint, BL.BL_B_CrtYd)
+    b_poly = shapely.union_all(breakneck.conversions.as_polygons(b_crtyd_shapes, 1000))
+    if b_poly.is_empty:
+        b_poly = sg.Polygon()
+    assert isinstance(b_poly, sg.Polygon)
+
+    return f_poly, b_poly
+
+
+class BNFootprint:
+    def __init__(self, ref: str, footprint: kipy.board_types.FootprintInstance):
+        self.ref = ref
+        self.footprint = footprint
+        self.front_courtyard, self.back_courtyard = get_courtyard_polygons(footprint)
+        self.is_tht = False
+        pads = self.footprint.definition.pads
+        non_gnd_pads = [p for p in pads if p.net.name != "GND"]
+        if any(
+            [p for p in non_gnd_pads if p.pad_type == kipy.board_types.PadType.PT_PTH]
+        ):
+            self.is_tht = True
+        self.nets = list(set([p.net.name for p in pads]))
+        self._buffered_courtyards: dict[
+            tuple[int, breakneck.base.Sides], sg.Polygon
+        ] = {}
+
+    def buffer_courtyard(
+        self,
+        buffer_width_nm: int,
+        side: breakneck.base.Sides,
+    ) -> sg.Polygon:
+        if (buffer_width_nm, side) in self._buffered_courtyards:
+            return self._buffered_courtyards[(buffer_width_nm, side)]
+
+        if side == breakneck.base.Sides.front:
+            courtyard = self.front_courtyard
+        elif side == breakneck.base.Sides.back:
+            courtyard = self.back_courtyard
+        elif side == breakneck.base.Sides.both:
+            courtyard = shapely.union_all([self.front_courtyard, self.back_courtyard])
+            assert isinstance(courtyard, sg.Polygon)
+
+        buffered_courtyard = courtyard.buffer(
+            buffer_width_nm, cap_style="round", join_style="round", quad_segs=90
+        )
+
+        self._buffered_courtyards[(buffer_width_nm, side)] = buffered_courtyard
+
+        return buffered_courtyard
+
+    def _is_likely_origin(
+        self,
+        track: kipy.board_types.Track | kipy.board_types.ArcTrack,
+        linestring: sg.LineString,
+    ) -> bool:
+        """
+        Check if a track is likely to originate from the footprint.
+
+        A track is likely to originate from the footprint if it crosses the respective couryard and shares a net with a pad.
+        """
+        if track.net.name not in self.nets:
+            return False
+
+        if self.is_tht:
+            courtyard = shapely.union_all([self.front_courtyard, self.back_courtyard])
+            assert isinstance(courtyard, sg.Polygon)
+        elif track.layer == BL.BL_F_Cu:
+            courtyard = self.front_courtyard
+        elif track.layer == BL.BL_B_Cu:
+            courtyard = self.back_courtyard
+        else:
+            return False
+
+        if courtyard.intersects(linestring):
+            return True
+
+        return False
+
+    def _sort_cut_points(
+        self, cut_points: list[sg.Point], linestring: sg.LineString
+    ) -> list[sg.Point]:
+        """
+        Sort cut points along the linestring.
+        """
+        return sorted(
+            cut_points,
+            key=lambda p: linestring.line_locate_point(p),
+        )
+
+    def break_tracks(
+        self,
+        tracks: Sequence[kipy.board_types.Track | kipy.board_types.ArcTrack],
+        bounding_box_width: int,
+        neck_length: int,
+        padding: int = 10000,
+    ) -> tuple[
+        list[kipy.board_types.Track | kipy.board_types.ArcTrack],
+        list[kipy.board_types.Track | kipy.board_types.ArcTrack],
+    ]:
+        """
+        Break tracks crossing the courtyards of this footprint.
+        """
+
+        items_to_remove = []
+        items_to_create = []
+
+        # Get the bounding box hits for tracks
+
+        front_bounding_box = self.front_courtyard.envelope.buffer(bounding_box_width)
+        back_bounding_box = self.back_courtyard.envelope.buffer(bounding_box_width)
+
+        front_track_tree = breakneck.track.TrackTree(
+            [t for t in tracks if t.layer == BL.BL_F_Cu]
+        )
+        back_track_tree = breakneck.track.TrackTree(
+            [t for t in tracks if t.layer == BL.BL_B_Cu]
+        )
+        front_hits = front_track_tree.intersects(front_bounding_box)
+        back_hits = back_track_tree.intersects(back_bounding_box)
+        if self.is_tht:
+            back_hits += back_track_tree.intersects(front_bounding_box)
+            front_hits += front_track_tree.intersects(back_bounding_box)
+
+        hits = front_hits + back_hits
+
+        logger.debug(f"Found {len(hits)} tracks crossing the courtyards.")
+
+        # If there are no hits, return early
+
+        if not hits:
+            return items_to_remove, items_to_create
+
+        bb_tracks, linestrings = zip(*hits)
+        for track, linestring in zip(bb_tracks, linestrings):
+            assert isinstance(linestring, sg.LineString)
+            assert isinstance(track, kipy.board_types.Track) or isinstance(
+                track, kipy.board_types.ArcTrack
+            )
+            if self.is_tht:
+                side = breakneck.base.Sides.both
+            elif track.layer == BL.BL_F_Cu:
+                side = breakneck.base.Sides.front
+            elif track.layer == BL.BL_B_Cu:
+                side = breakneck.base.Sides.back
+            else:
+                raise ValueError(f"Unexpected track layer: {track.layer}")
+
+            if self._is_likely_origin(track, linestring):
+                # Find possible cut points at the neck length
+                neck_buffer = self.buffer_courtyard(
+                    neck_length + track.width // 2 + padding, side
+                )
+                cut_points = neck_buffer.boundary.intersection(linestring)
+                logger.debug(f"Cut points: {cut_points}")
+            else:
+                # Find possible cut points at the courtyard boundary
+                cut_points = self.buffer_courtyard(
+                    track.width // 2 + padding, side
+                ).boundary.intersection(linestring)
+
+            # Order the found points along the track
+            track_points = []  # crossing points
+            if not cut_points.is_empty:
+                if isinstance(cut_points, sg.Point):
+                    points = [Coords2D(int(cut_points.x), int(cut_points.y))]
+                elif isinstance(cut_points, sg.MultiPoint):
+                    points = [Coords2D(int(p.x), int(p.y)) for p in cut_points.geoms]
+                else:
+                    raise ValueError(f"Unexpected geometry type: {type(cut_points)}")
+                track_points.extend(points)
+            if not track_points:
+                continue
+
+            logger.debug(f"Track points: {track_points}")
+
+            new_tracks = breakneck.track.break_track(track, track_points)
+            items_to_remove.append(track)
+            items_to_create.extend(new_tracks)
+
+        return items_to_remove, items_to_create
+
+
+def get_bn_footprints(
+    footprints: Sequence[kipy.board_types.FootprintInstance],
+) -> list[BNFootprint,]:
+    """Get BNFootprint objects of all footprints on a board."""
+
+    fpcs: list[BNFootprint] = []
+
+    for fp in footprints:
+        fpcs.append(
+            BNFootprint(
+                ref=fp.reference_field.text.value,
+                footprint=fp,
+            )
+        )
+
+    return fpcs

breakneck/test_polyfinder.py

@@ -0,0 +1,32 @@
+import pytest
+import shapely.geometry as sg
+from polyfinder import find_polygons
+
+
+def test_find_polygons():
+    segments = [
+        # First ring
+        sg.LineString([(0, 0), (1, 0)]),
+        sg.LineString([(1, 0), (1, 1)]),
+        sg.LineString([(1, 1), (0, 1)]),
+        sg.LineString([(0, 1), (0, 0)]),
+        # Second ring
+        sg.LineString([(2, 2), (3, 2)]),
+        sg.LineString([(3, 2), (3, 3)]),
+        sg.LineString([(3, 3), (2, 3)]),
+        sg.LineString([(2, 3), (2, 2)]),
+    ]
+
+    linear_rings = find_polygons(segments)
+    expected_rings = [
+        sg.LinearRing([(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]),
+        sg.LinearRing([(2, 2), (3, 2), (3, 3), (2, 3), (2, 2)]),
+    ]
+
+    assert len(linear_rings) == len(expected_rings)
+    for ring, expected_ring in zip(linear_rings, expected_rings):
+        assert ring.equals(expected_ring)
+
+
+if __name__ == "__main__":
+    pytest.main()

breakneck/track.py

@@ -0,0 +1,222 @@
+import math
+import uuid
+from collections.abc import Iterable, Sequence
+
+import kipy.board
+import kipy.board_types
+import kipy.common_types
+import kipy.proto.board.board_types_pb2 as board_types_pb2
+import kipy.proto.common.types.base_types_pb2 as base_types_pb2
+import shapely
+import shapely.geometry as sg
+
+import breakneck.conversions
+import breakneck.footprint
+from breakneck.base import Coords2D
+
+
+def round_track_width(width_nm: int, tol_nm=10000) -> int:
+    return tol_nm * int(round(width_nm / tol_nm))
+
+
+def get_unique_track_widths(
+    tracks: Iterable[kipy.board_types.Track | kipy.board_types.ArcTrack], tol_nm=10000
+) -> list[int]:
+    """Get tolerance-rounded unique track widths from a list of tracks."""
+    track_widths = set()
+
+    for track in tracks:
+        track_widths.add(round_track_width(track.width, tol_nm))
+
+    return sorted(list(track_widths))
+
+
+def get_max_track_width(
+    tracks: Iterable[kipy.board_types.Track | kipy.board_types.ArcTrack],
+) -> int:
+    return max([track.width for track in tracks])
+
+
+def break_track_segment(
+    track: kipy.board_types.Track, points: list[Coords2D]
+) -> list[kipy.board_types.Track]:
+    """
+    Break a track segment at points
+    """
+
+    if not points:
+        raise ValueError("No points to break track")
+
+    start = breakneck.conversions.vector2_as_coords(track.start)
+    end = breakneck.conversions.vector2_as_coords(track.end)
+
+    current = start
+
+    new_tracks = []
+
+    even = False
+    for point in points + [end]:
+        new_track_proto = board_types_pb2.Track(
+            id=base_types_pb2.KIID(value=str(uuid.uuid4())),
+        )
+        new_track = kipy.board_types.Track(new_track_proto)
+
+        new_track.start = breakneck.conversions.coords_as_vector2(current)
+        new_track.end = breakneck.conversions.coords_as_vector2(point)
+
+        new_track.width = track.width
+        new_track.net = track.net
+        new_track.layer = track.layer
+
+        # bump even segment widths by 1 nm down
+        if even:
+            new_track.width -= 1
+        even = not even
+
+        if (abs(new_track.start.x - new_track.end.x) > 10) or (
+            abs(new_track.start.y - new_track.end.y) > 10
+        ):
+            new_tracks.append(new_track)
+
+        current = point
+
+    return new_tracks
+
+
+def _calculate_angle(center: Coords2D, point: Coords2D) -> float:
+    return math.atan2(point.y - center.y, point.x - center.x)
+
+
+def _calculate_midpoint(
+    center: Coords2D,
+    start_angle: float,
+    end_angle: float,
+    radius: float,
+    clockwise: bool,
+) -> Coords2D:
+    """
+    Calculate the midpoint of an arc
+    """
+    if clockwise:
+        if start_angle < end_angle:
+            start_angle += 2 * math.pi
+    else:
+        if end_angle < start_angle:
+            end_angle += 2 * math.pi
+    mid_angle = (start_angle + end_angle) / 2
+    return Coords2D(
+        int(center.x + radius * math.cos(mid_angle)),
+        int(center.y + radius * math.sin(mid_angle)),
+    )
+
+
+def _is_arc_clockwise(
+    start: Coords2D,
+    mid: Coords2D,
+    end: Coords2D,
+    center: Coords2D,
+) -> bool:
+    """
+    Determine if an arc is clockwise or counterclockwise
+    """
+    # Calculate vectors from center to start, mid, and end points
+    vector_start = (start.x - center.x, start.y - center.y)
+    vector_mid = (mid.x - center.x, mid.y - center.y)
+    vector_end = (end.x - center.x, end.y - center.y)
+
+    # Calculate cross product of vectors (start to mid) and (mid to end)
+    cross_product = (vector_mid[0] - vector_start[0]) * (
+        vector_end[1] - vector_mid[1]
+    ) - (vector_mid[1] - vector_start[1]) * (vector_end[0] - vector_mid[0])
+
+    # If cross product is negative, the arc is clockwise
+    return cross_product < 0
+
+
+def break_arc_track(
+    track: kipy.board_types.ArcTrack, points: list[Coords2D]
+) -> list[kipy.board_types.Track]:
+    """
+    Break an arc track at points
+    """
+
+    if not points:
+        raise ValueError("No points to break track")
+
+    start = breakneck.conversions.vector2_as_coords(track.start)
+    mid = breakneck.conversions.vector2_as_coords(track.mid)
+    end = breakneck.conversions.vector2_as_coords(track.end)
+    center_vector = track.center()
+    assert center_vector is not None
+    center = breakneck.conversions.vector2_as_coords(center_vector)
+    radius = int(track.radius())
+    clockwise = _is_arc_clockwise(start, mid, end, center)
+
+    current = start
+    new_tracks = []
+
+    even = False
+    for point in points + [end]:
+        start_angle = _calculate_angle(center, current)
+        end_angle = _calculate_angle(center, point)
+        mid_point = _calculate_midpoint(
+            center, start_angle, end_angle, radius, clockwise
+        )
+        new_track_proto = board_types_pb2.Arc(
+            id=base_types_pb2.KIID(value=str(uuid.uuid4())),
+        )
+
+        new_track = kipy.board_types.ArcTrack(new_track_proto)
+        new_track.start = breakneck.conversions.coords_as_vector2(current)
+        new_track.mid = breakneck.conversions.coords_as_vector2(mid_point)
+        new_track.end = breakneck.conversions.coords_as_vector2(point)
+        new_track.width = track.width
+        new_track.net = track.net
+        new_track.layer = track.layer
+
+        # bump even segment widths down by 1 nm
+        if even:
+            new_track.width -= 1
+        even = not even
+
+        if (abs(new_track.start.x - new_track.end.x) > 10) or (
+            abs(new_track.start.y - new_track.end.y) > 10
+        ):
+            new_tracks.append(new_track)
+        current = point
+
+    return new_tracks
+
+
+def break_track(
+    track: kipy.board_types.Track | kipy.board_types.ArcTrack, points: list[Coords2D]
+) -> Sequence[kipy.board_types.Track | kipy.board_types.ArcTrack]:
+    """
+    Break a track at points
+    """
+    if isinstance(track, kipy.board_types.ArcTrack):
+        return break_arc_track(track, points)
+    else:
+        return break_track_segment(track, points)
+
+
+class TrackTree:
+    def __init__(
+        self, tracks: Iterable[kipy.board_types.Track | kipy.board_types.ArcTrack]
+    ):
+        self._tracks = list(tracks)
+        self._track_linestrings = [
+            breakneck.conversions.track_as_linestring(track) for track in self._tracks
+        ]
+        self._track_tree = shapely.STRtree(self._track_linestrings)
+
+    def intersects(
+        self, courtyard: shapely.geometry.Polygon
+    ) -> list[tuple[kipy.board_types.Track | kipy.board_types.ArcTrack, sg.LineString]]:
+        """
+        Return tracks that intersect with the given courtyard
+        """
+        intersect_indices = self._track_tree.query(courtyard, predicate="intersects")
+        return [
+            (self._tracks[i], self._track_linestrings[i]) for i in intersect_indices
+        ]

breakneck-0.2.1.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: breakneck
+Version: 0.2.1
+Summary: Stitching via visualization and manual forced neckdowns for KiCad
+Project-URL: Homepage, https://github.com/hatlabs/breakneck
+Author-email: Matti Airas <mairas@iki.fi>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: EDA,KiCad,PCB,breakneck,neckdown,stitching
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: kicad-python>=0.2.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: shapely>=2.0.7
+Requires-Dist: svgpathtools>=1.6.1
+Description-Content-Type: text/markdown
+
+# Breakneck: Via Stitching and Manual Neckdown for KiCad Layouts
+
+## Introduction
+
+### Via Stitching
+
+Ground via stitching is a common technique to reduce EMI and improve signal integrity in PCB designs. It involves placing GND vias next to signal vias to provide a return signal
+path between reference ground planes and to minimize the loop area. This is important
+for any signal with a high edge rate; nowadays basically every digital signal in a design.
+
+Breakneck visualizes stitching via requirements by drawing lines between signal vias and their closest GND vias if the nearest GND via is further away than a specified distance. The user can then manually place the GND vias to meet the requirements. The lines are drawn on the User.Eco2 layer which should not be used for any other purpose (any existing content on this layer will be overwritten).
+
+The screenshot below shows a design with routed signals lacking stitching vias. The yellow lines indicate the signal vias missing a GND via within a distance of 2mm.
+
+![Stitching Vias](https://github.com/hatlabs/breakneck/blob/main/stitching-via-screenshot.png?raw=true)
+
+### Manual Neckdown
+
+**NB:** [This `kicad-python` bug](https://gitlab.com/kicad/code/kicad-python/-/issues/18) prevents manual neckdown from being properly used at the moment.
+
+Neckdown, or its inverse, fanout, refers to narrowing down of PCB tracks and their clearances when routing tracks to
+fine-pitch components such as BGAs or QFNs. KiCad does not provide a built-in feature to automatically neckdown tracks,
+and while the KiCad Custom Rules are powerful, they do not support neckdowns. It is possible to define rules for
+tracks intersecting footprint courtyards, but the rule applies to the entire length of the track segment, not just the
+part that intersects the courtyard.
+
+Breakneck is a Python script that communicates with KiCad and cuts tracks at a specified distance from the intersection with a footprint courtyard.
+After these track cuts, custom rules apply to the expected track segments. The layout isn't otherwise modified.
+Automatic re-healing of broken tracks is prevented by nudging the track widths by one nanometer, making adjacent
+tracks different widths.
+
+## Installation
+
+As a prerequisite, [install uv](https://docs.astral.sh/uv/getting-started/installation/).
+
+To run breakneck without actually installing it:
+
+```
+uvx breakneck <command> [options...]
+```
+
+This actually works really fast and the only downside is that you have to type `uvx` every time. If you want to install breakneck, run:
+
+```
+uv tool install breakneck
+```
+
+## Usage
+
+**NOTE:** If you are running breakneck with `uvx`, prepend all breakneck commands below with `uvx`.
+
+Run `breakneck -h` to see the available options.
+
+`breakneck gndvia` draws stitching via lines on the User.Eco2 layer. The default distance is 2mm, but it can be changed with the `--distance` option.
+
+It is possible to run `breakneck gndvia` repeatedly using `watch` to provide semi-real time updates while placing the GND vias:
+
+```bash
+watch -n 1 breakneck gndvia
+```
+
+**NOTE:** It turns out, every execution will bump the undo buffer, so until breakneck is made a bit smarter, it will become very difficult to undo any actual changes.
+
+Breakneck has basic support for filtering the affected tracks and components by layer, netclass or selection.
+
+## Limitations
+
+- Component classes are not supported due to API limitations.
+- Grouped tracks and footprints are ignored due to API limitations. It is possible to enter a group and
+  run `breakneck --selection` to process the group members.
+- Multiple ground layers are not supported in `gndvia`. If you have isolated board sections, you will have a lot of bogus lines to the closest regular GND via.

breakneck-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+breakneck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+breakneck/base.py,sha256=QPDxDuz4vRSmW81amH5kV8ZrJK3Mmql_hl2tUH4tHX0,1012
+breakneck/cli.py,sha256=zM5xIgWMQhRGw7HypJM0IRX0AH5GqTN28uTQrq6ugYI,8763
+breakneck/conversions.py,sha256=NppAcBkEG6LnriU-a-hsCpUWFL4iLlJlYVR7NnLuh3M,11400
+breakneck/footprint.py,sha256=21eUeuQMTEIT1CZ890DVWXamLhRZOlIL3QpAxNGRKH8,8298
+breakneck/test_polyfinder.py,sha256=TPBpf0eIuweTB4XwgXK39cz91e-KLA0PzmqkdQTjOgo,914
+breakneck/track.py,sha256=QA4fuBk8uKJ046kuRX4zfmZ3cQ8i7WZo4m7KOaiJ4uQ,6747
+breakneck-0.2.1.dist-info/METADATA,sha256=IIj9ysuY7VBQOd3ZN_JGs0Lt6Gq_pfG694LnhYvq0j0,4528
+breakneck-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+breakneck-0.2.1.dist-info/entry_points.txt,sha256=REziUZZL6n8Z4dGEJKRzEMAFpa3v5g6Afzrswg1sRkQ,49
+breakneck-0.2.1.dist-info/licenses/LICENSE,sha256=K5Wr24wTv2iYs_vlVUMgUvSAR9nrHjk4FE0xVHUndQA,1065
+breakneck-0.2.1.dist-info/RECORD,,

breakneck-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

breakneck-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+breakneck = breakneck.cli:main

breakneck-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hat Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.