Expand via DRC to inclusive declared layer spans (#96)

Author: seveibar

lib/drc/AutoroutingDrcEngine.ts

@@ -11,6 +11,7 @@ import type {
   SimplifiedPcbTrace,
   SimplifiedPcbTraces,
 } from "../types"
+import { getViaLayers } from "../utils/getViaLayers"
 
 type Point = { x: number; y: number }
 
@@ -615,7 +616,7 @@ export class AutoroutingDrcEngine {
           x: routePoint.x,
           y: routePoint.y,
           diameter: routePoint.via_diameter ?? this.srj.minViaDiameter ?? 0.3,
-          layers: [routePoint.from_layer, routePoint.to_layer],
+          layers: getViaLayers(routePoint, this.srj.layerCount),
         })
       }
     }

lib/index.ts

@@ -24,3 +24,4 @@ export type {
   SingleLayerConnectionPoint,
   SimpleRouteJson,
 } from "./solvers/GlobalDrcForceImproveSolver"
+export { getViaLayers } from "./utils/getViaLayers"

lib/utils/convertToCircuitJson.ts

@@ -3,6 +3,7 @@ import type { AnyCircuitElement, PcbTrace, PcbVia } from "circuit-json"
 import type { Obstacle, SimpleRouteJson, SimplifiedPcbTrace } from "../types"
 import type { HighDensityRoute } from "../types/high-density-types"
 import { getConnectionPointLayers } from "../types/srj-types"
+import { getViaLayers } from "./getViaLayers"
 import { mapZToLayerName } from "./mapZToLayerName"
 import type { LayerName } from "./mapZToLayerName"
 import { pointToBoxDistance } from "@tscircuit/math-utils"
@@ -57,6 +58,7 @@ function convertHdRouteToCircuitJsonTraces(
   baseId: string,
   connectionName: string,
   width = 0.1,
+  layerCount: number,
 ): PcbTrace[] {
   const traces: PcbTrace[] = []
 
@@ -75,7 +77,7 @@ function convertHdRouteToCircuitJsonTraces(
             x: point.x,
             y: point.y,
             width,
-            layer: mapZToLayerName(point.z, 2),
+            layer: mapZToLayerName(point.z, layerCount),
             ...(isFirstPoint && (point as any).pcb_port_id
               ? { start_pcb_port_id: (point as any).pcb_port_id }
               : {}),
@@ -148,7 +150,7 @@ function convertHdRouteToCircuitJsonTraces(
               x: point.x,
               y: point.y,
               width,
-              layer: mapZToLayerName(point.z, 2),
+              layer: mapZToLayerName(point.z, layerCount),
               ...(isFirstPoint && (point as any).pcb_port_id
                 ? { start_pcb_port_id: (point as any).pcb_port_id }
                 : {}),
@@ -179,7 +181,7 @@ function convertHdRouteToCircuitJsonTraces(
             x: point.x,
             y: point.y,
             width,
-            layer: mapZToLayerName(point.z, 2),
+            layer: mapZToLayerName(point.z, layerCount),
             ...(isLastPoint && (point as any).pcb_port_id
               ? { end_pcb_port_id: (point as any).pcb_port_id }
               : {}),
@@ -454,6 +456,7 @@ function createPcbPadElements(srj: SimpleRouteJson): AnyCircuitElement[] {
  */
 function extractViasFromRoutes(
   routes: SimplifiedPcbTrace[] | HighDensityRoute[],
+  layerCount: number,
   minViaDiameter = 0.3,
 ): PcbVia[] {
   const vias: PcbVia[] = []
@@ -476,7 +479,7 @@ function extractViasFromRoutes(
                 y: segment.y,
                 outer_diameter: viaDiameter,
                 hole_diameter: viaDiameter * 0.5,
-                layers: [segment.from_layer, segment.to_layer] as LayerName[],
+                layers: getViaLayers(segment, layerCount) as LayerName[],
               })
               viaLocations.add(locationKey)
             }
@@ -498,8 +501,8 @@ function extractViasFromRoutes(
             Math.abs(prevPoint.x - currPoint.x) < 0.01 &&
             Math.abs(prevPoint.y - currPoint.y) < 0.01
           ) {
-            const fromLayer = mapZToLayerName(prevPoint.z, 2)
-            const toLayer = mapZToLayerName(currPoint.z, 2)
+            const fromLayer = mapZToLayerName(prevPoint.z, layerCount)
+            const toLayer = mapZToLayerName(currPoint.z, layerCount)
             const locationKey = `${currPoint.x},${currPoint.y},${fromLayer},${toLayer}`
 
             if (!viaLocations.has(locationKey)) {
@@ -511,7 +514,10 @@ function extractViasFromRoutes(
                 y: currPoint.y,
                 outer_diameter: viaDiameter,
                 hole_diameter: viaDiameter * 0.5,
-                layers: [fromLayer, toLayer] as LayerName[],
+                layers: getViaLayers(
+                  { from_layer: fromLayer, to_layer: toLayer },
+                  layerCount,
+                ) as LayerName[],
               })
               viaLocations.add(locationKey)
             }
@@ -550,7 +556,13 @@ export function convertToCircuitJson(
   circuitJson.push(...createPcbPadElements(srjWithPointPairs))
 
   // Extract and add vias as independent pcb_via elements
-  circuitJson.push(...extractViasFromRoutes(routes, minViaDiameter))
+  circuitJson.push(
+    ...extractViasFromRoutes(
+      routes,
+      srjWithPointPairs.layerCount,
+      minViaDiameter,
+    ),
+  )
 
   // Build a map of connection names to simplify lookups
   const connectionMap = new Map<string, string>()
@@ -583,6 +595,7 @@ export function convertToCircuitJson(
           `trace_${index}`,
           connectionMap.get(connectionName) || connectionName,
           minTraceWidth,
+          srjWithPointPairs.layerCount,
         )
         circuitJson.push(...(traces as AnyCircuitElement[]))
       })

lib/utils/getViaLayers.ts

@@ -0,0 +1,26 @@
+import { mapZToLayerName } from "./mapZToLayerName"
+
+type ViaLayers = {
+  layers?: string[]
+  from_layer?: string
+  to_layer?: string
+}
+
+/** Normalize the explicit-layer and inclusive-endpoint representations. */
+export const getViaLayers = (via: ViaLayers, layerCount: number): string[] => {
+  if (via.layers !== undefined) return via.layers
+  if (!Number.isInteger(layerCount) || layerCount < 1) {
+    throw new Error(`Invalid board layer count: ${layerCount}`)
+  }
+  const boardLayers = Array.from({ length: layerCount }, (_, z) =>
+    mapZToLayerName(z, layerCount),
+  )
+  const from = boardLayers.findIndex((layer) => layer === via.from_layer)
+  const to = boardLayers.findIndex((layer) => layer === via.to_layer)
+  if (from < 0 || to < 0) {
+    throw new Error(
+      `Via span ${via.from_layer} -> ${via.to_layer} is outside the board`,
+    )
+  }
+  return boardLayers.slice(Math.min(from, to), Math.max(from, to) + 1)
+}

tests/autorouting-drc-explicit-via-layers.test.ts

@@ -0,0 +1,61 @@
+import { expect, test } from "bun:test"
+import { AutoroutingDrcEngine } from "../lib/drc/AutoroutingDrcEngine"
+import type { SimpleRouteJson, SimplifiedPcbTraces } from "../lib/types"
+import { convertToCircuitJson } from "../lib/utils/convertToCircuitJson"
+
+test("DRC treats endpoint spans and explicit via layers as the same geometry", () => {
+  const srj: SimpleRouteJson = {
+    layerCount: 4,
+    minTraceWidth: 0.12,
+    minViaDiameter: 0.2,
+    bounds: { minX: -2, minY: -2, maxX: 2, maxY: 2 },
+    obstacles: [],
+    connections: [],
+  }
+  const traces: SimplifiedPcbTraces = [
+    {
+      type: "pcb_trace",
+      pcb_trace_id: "power",
+      connection_name: "power",
+      route: [
+        {
+          route_type: "via",
+          x: 0,
+          y: 0,
+          from_layer: "top",
+          to_layer: "inner2",
+        },
+      ],
+    },
+    {
+      type: "pcb_trace",
+      pcb_trace_id: "signal",
+      connection_name: "signal",
+      route: [
+        { route_type: "wire", x: -1, y: 0, width: 0.12, layer: "inner1" },
+        { route_type: "wire", x: 1, y: 0, width: 0.12, layer: "inner1" },
+      ],
+    },
+  ]
+  const engine = new AutoroutingDrcEngine(srj)
+  expect(engine.evaluate(traces).errors.length).toBeGreaterThan(0)
+  const declared = structuredClone(traces)
+  const via = declared[0]!.route[0]!
+  if (via.route_type !== "via") throw new Error("Expected a via")
+  via.layers = ["top", "inner1", "inner2"]
+  expect(engine.evaluate(declared).errors).toEqual(
+    engine.evaluate(traces).errors,
+  )
+  via.layers = ["top", "inner1", "inner2", "bottom"]
+  expect(engine.evaluate(declared).errors.length).toBeGreaterThan(0)
+  for (const point of declared[1]!.route) {
+    if (point.route_type === "wire") point.layer = "bottom"
+  }
+  expect(engine.evaluate(declared).errors.length).toBeGreaterThan(0)
+  via.layers = ["top", "inner1", "inner2"]
+  expect(engine.evaluate(declared).errors).toEqual([])
+  const json = convertToCircuitJson(srj, declared)
+  const exportedVia = json.find((element) => element.type === "pcb_via")
+  expect(exportedVia?.layers).toEqual(["top", "inner1", "inner2"])
+  expect(engine.evaluate(traces).errors.length).toBeGreaterThan(0)
+})

tests/autorouting-drc-via-span-pad.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from "bun:test"
+import { AutoroutingDrcEngine } from "../lib/drc/AutoroutingDrcEngine"
+import type { SimpleRouteJson, SimplifiedPcbTraces } from "../lib/types"
+
+test("checks via-to-pad clearance on intermediate layers only within the span", () => {
+  const srj: SimpleRouteJson = {
+    layerCount: 4,
+    minTraceWidth: 0.1,
+    minViaDiameter: 0.3,
+    bounds: { minX: -2, minY: -2, maxX: 2, maxY: 2 },
+    connections: [],
+    obstacles: [
+      {
+        type: "rect",
+        layers: ["inner1"],
+        center: { x: 0, y: 0 },
+        width: 0.2,
+        height: 0.2,
+        connectedTo: ["pcb_smtpad_foreign"],
+      },
+    ],
+  }
+  const traces: SimplifiedPcbTraces = [
+    {
+      type: "pcb_trace",
+      pcb_trace_id: "power",
+      connection_name: "power",
+      route: [
+        {
+          route_type: "via",
+          x: 0,
+          y: 0,
+          from_layer: "top",
+          to_layer: "inner2",
+        },
+      ],
+    },
+  ]
+  const input = structuredClone(traces)
+  const errors = new AutoroutingDrcEngine(srj).evaluate(traces).errors
+  expect(errors).toHaveLength(1)
+  expect(errors[0]?.type).toBe("pcb_pad_pad_clearance_error")
+  expect(traces).toEqual(input)
+
+  const via = traces[0]!.route[0]!
+  if (via.route_type !== "via") throw new Error("Expected a via")
+  via.layers = ["top", "inner1", "inner2"]
+  expect(new AutoroutingDrcEngine(srj).evaluate(traces).errors).toEqual(errors)
+  srj.obstacles[0]!.layers = ["bottom"]
+  expect(new AutoroutingDrcEngine(srj).evaluate(traces).errors).toEqual([])
+})

tests/convert-hd-via-span.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test"
+import type { SimpleRouteJson } from "../lib/types"
+import { convertToCircuitJson } from "../lib/utils/convertToCircuitJson"
+
+test("HD conversion expands a four-layer via span using the actual stack", () => {
+  const srj: SimpleRouteJson = {
+    layerCount: 4,
+    minTraceWidth: 0.1,
+    bounds: { minX: -2, minY: -2, maxX: 2, maxY: 2 },
+    obstacles: [],
+    connections: [],
+  }
+  const json = convertToCircuitJson(srj, [
+    {
+      connectionName: "signal",
+      traceThickness: 0.1,
+      viaDiameter: 0.3,
+      vias: [{ x: 0, y: 0 }],
+      route: [
+        { x: -1, y: 0, z: 0 },
+        { x: 0, y: 0, z: 0 },
+        { x: 0, y: 0, z: 2 },
+        { x: 1, y: 0, z: 2 },
+      ],
+    },
+  ])
+  const via = json.find((element) => element.type === "pcb_via")
+  expect(via?.layers).toEqual(["top", "inner1", "inner2"])
+  const trace = json.find((element) => element.type === "pcb_trace")
+  expect(trace?.route.at(-1)).toMatchObject({ layer: "inner2" })
+})

tests/via-layer-span.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test"
+import { getViaLayers } from "../lib/utils/getViaLayers"
+
+test("normalizes both via APIs across the complete inclusive layer span", () => {
+  const layers = ["top", "inner1", "inner2", "bottom"]
+  expect(getViaLayers({ layers }, 4)).toBe(layers)
+  expect(getViaLayers({ from_layer: "top", to_layer: "bottom" }, 4)).toEqual(
+    layers,
+  )
+  expect(getViaLayers({ from_layer: "bottom", to_layer: "top" }, 4)).toEqual(
+    layers,
+  )
+  expect(getViaLayers({ from_layer: "inner3", to_layer: "inner1" }, 6)).toEqual(
+    ["inner1", "inner2", "inner3"],
+  )
+  expect(getViaLayers({ from_layer: "inner1", to_layer: "inner1" }, 4)).toEqual(
+    ["inner1"],
+  )
+  expect(() =>
+    getViaLayers({ from_layer: "inner4", to_layer: "top" }, 4),
+  ).toThrow("outside the board")
+})

types/srj-types.ts

@@ -111,6 +111,8 @@ export interface SimplifiedPcbTrace {
         to_layer: string
         from_layer: string
         via_diameter?: number
+        /** Explicit copper layers; otherwise expand the inclusive from/to span. */
+        layers?: string[]
       }
     | {
         route_type: "jumper"