@tscircuit/copper-pour-solver 0.0.1

package/dist/index.js

@@ -0,0 +1,368 @@
+// lib/solvers/CopperPourPipelineSolver.ts
+import { BasePipelineSolver } from "@tscircuit/solver-utils";
+
+// lib/solvers/copper-pour/get-board-polygon.ts
+import Flatten from "@flatten-js/core";
+var getBoardPolygon = (region) => {
+  if (region.outline && region.outline.length > 0) {
+    return new Flatten.Polygon(
+      region.outline.map((p) => Flatten.point(p.x, p.y))
+    );
+  }
+  const { bounds } = region;
+  return new Flatten.Polygon(
+    new Flatten.Box(
+      bounds.minX,
+      bounds.minY,
+      bounds.maxX,
+      bounds.maxY
+    ).toPoints()
+  );
+};
+
+// lib/solvers/CopperPourPipelineSolver.ts
+import Flatten5 from "@flatten-js/core";
+
+// lib/solvers/copper-pour/process-obstacles.ts
+import Flatten3 from "@flatten-js/core";
+
+// lib/solvers/copper-pour/circle-to-polygon.ts
+import Flatten2 from "@flatten-js/core";
+var circleToPolygon = (circle, numSegments = 32) => {
+  const points = [];
+  for (let i = 0; i < numSegments; i++) {
+    const angle = i / numSegments * 2 * Math.PI;
+    points.push(
+      new Flatten2.Point(
+        circle.center.x + circle.r * Math.cos(angle),
+        circle.center.y + circle.r * Math.sin(angle)
+      )
+    );
+  }
+  return new Flatten2.Polygon(points);
+};
+
+// lib/solvers/copper-pour/process-obstacles.ts
+var isRectPad = (pad) => pad.shape === "rect";
+var isTracePad = (pad) => pad.shape === "trace";
+var isCircularPad = (pad) => pad.shape === "circle";
+var processObstaclesForPour = (pads, pourConnectivityKey, margins) => {
+  const polygonsToSubtract = [];
+  const { padMargin, traceMargin } = margins;
+  for (const pad of pads) {
+    const isOnNet = pad.connectivityKey === pourConnectivityKey;
+    if (isOnNet) {
+      continue;
+    }
+    if (isCircularPad(pad)) {
+      const isHole = pad.connectivityKey.startsWith("hole:");
+      const margin = isHole ? 0 : padMargin;
+      const circle = new Flatten3.Circle(
+        new Flatten3.Point(pad.x, pad.y),
+        pad.radius + margin
+      );
+      polygonsToSubtract.push(circleToPolygon(circle));
+      continue;
+    }
+    if (isRectPad(pad)) {
+      const { bounds } = pad;
+      const b = new Flatten3.Box(
+        bounds.minX - padMargin,
+        bounds.minY - padMargin,
+        bounds.maxX + padMargin,
+        bounds.maxY + padMargin
+      );
+      polygonsToSubtract.push(new Flatten3.Polygon(b.toPoints()));
+      continue;
+    }
+    if (isTracePad(pad)) {
+      for (const segment of pad.segments) {
+        const circle = new Flatten3.Circle(
+          new Flatten3.Point(segment.x, segment.y),
+          pad.width / 2 + traceMargin
+        );
+        polygonsToSubtract.push(circleToPolygon(circle));
+      }
+      for (let i = 0; i < pad.segments.length - 1; i++) {
+        const p1 = pad.segments[i];
+        const p2 = pad.segments[i + 1];
+        if (!p1 || !p2) continue;
+        const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y);
+        if (segmentLength === 0) continue;
+        const enlargedWidth = pad.width + traceMargin * 2;
+        const centerX = (p1.x + p2.x) / 2;
+        const centerY = (p1.y + p2.y) / 2;
+        const rotationDeg = Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180 / Math.PI;
+        const w2 = segmentLength / 2;
+        const h2 = enlargedWidth / 2;
+        const angleRad = rotationDeg * Math.PI / 180;
+        const cosAngle = Math.cos(angleRad);
+        const sinAngle = Math.sin(angleRad);
+        const corners = [
+          { x: -w2, y: -h2 },
+          { x: w2, y: -h2 },
+          { x: w2, y: h2 },
+          { x: -w2, y: h2 }
+        ];
+        const rotatedCorners = corners.map((p) => ({
+          x: centerX + p.x * cosAngle - p.y * sinAngle,
+          y: centerY + p.x * sinAngle + p.y * cosAngle
+        }));
+        polygonsToSubtract.push(
+          new Flatten3.Polygon(
+            rotatedCorners.map((p) => Flatten3.point(p.x, p.y))
+          )
+        );
+      }
+      continue;
+    }
+  }
+  return { polygonsToSubtract };
+};
+
+// lib/solvers/copper-pour/generate-brep.ts
+import Flatten4 from "@flatten-js/core";
+var faceToVertices = (face) => face.edges.map((e) => {
+  const pt = {
+    x: e.start.x,
+    y: e.start.y
+  };
+  if (e.isArc) {
+    const bulge = Math.tan(e.shape.sweep / 4);
+    if (Math.abs(bulge) > 1e-9) {
+      pt.bulge = bulge;
+    }
+  }
+  return pt;
+});
+var generateBRep = (pourPolygons) => {
+  const brep_shapes = [];
+  const polygons = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons];
+  for (const p of polygons) {
+    const islands = p.splitToIslands();
+    for (const island of islands) {
+      if (island.isEmpty()) continue;
+      const faces = [...island.faces];
+      const outer_face_ccw = faces.find(
+        (f) => f.orientation() === Flatten4.ORIENTATION.CCW
+      );
+      const inner_faces_cw = faces.filter(
+        (f) => f.orientation() === Flatten4.ORIENTATION.CW
+      );
+      if (!outer_face_ccw) continue;
+      outer_face_ccw.reverse();
+      const outer_ring_vertices = faceToVertices(outer_face_ccw);
+      const inner_rings = inner_faces_cw.map((f) => {
+        f.reverse();
+        return { vertices: faceToVertices(f) };
+      });
+      brep_shapes.push({
+        outer_ring: { vertices: outer_ring_vertices },
+        inner_rings
+      });
+    }
+  }
+  return brep_shapes;
+};
+
+// lib/solvers/CopperPourPipelineSolver.ts
+var CopperPourPipelineSolver = class extends BasePipelineSolver {
+  constructor(input) {
+    super(input);
+    this.input = input;
+  }
+  pipelineDef = [];
+  getOutput() {
+    const brep_shapes = [];
+    for (const region of this.input.regionsForPour) {
+      const boardPolygon = getBoardPolygon(region);
+      const padsForLayer = this.input.pads.filter(
+        (p) => p.layer === region.layer
+      );
+      const { polygonsToSubtract } = processObstaclesForPour(
+        padsForLayer,
+        region.connectivityKey,
+        {
+          padMargin: region.padMargin,
+          traceMargin: region.traceMargin
+        }
+      );
+      let pourPolygons = boardPolygon;
+      for (const poly of polygonsToSubtract) {
+        pourPolygons = Flatten5.BooleanOperations.subtract(
+          pourPolygons,
+          poly
+        );
+      }
+      const new_breps = generateBRep(pourPolygons);
+      brep_shapes.push(...new_breps);
+    }
+    return {
+      brep_shapes
+    };
+  }
+};
+
+// lib/circuit-json/convert-circuit-json-to-input-problem.ts
+var convertCircuitJsonToInputProblem = (circuitJson, options) => {
+  const source_ports = circuitJson.filter(
+    (e) => e.type === "source_port"
+  );
+  const pcb_ports = circuitJson.filter(
+    (e) => e.type === "pcb_port"
+  );
+  const source_traces = circuitJson.filter(
+    (e) => e.type === "source_trace"
+  );
+  const source_nets = circuitJson.filter(
+    (e) => e.type === "source_net"
+  );
+  const pcb_board = circuitJson.find((e) => e.type === "pcb_board");
+  if (!pcb_board) throw new Error("No pcb_board found in circuit json");
+  const sourcePortIdToConnectivityKey = Object.fromEntries(
+    source_ports.map((sp) => [
+      sp.source_port_id,
+      sp.subcircuit_connectivity_map_key
+    ])
+  );
+  const pcbPortIdToConnectivityKey = Object.fromEntries(
+    pcb_ports.map((pp) => [
+      pp.pcb_port_id,
+      sourcePortIdToConnectivityKey[pp.source_port_id]
+    ])
+  );
+  const pcbPlatedHoleIdToConnectivityKey = {};
+  for (const pcb_port of pcb_ports) {
+    if (pcb_port.pcb_port_id) {
+      pcbPlatedHoleIdToConnectivityKey[pcb_port.pcb_port_id] = pcbPortIdToConnectivityKey[pcb_port.pcb_port_id];
+    }
+  }
+  const sourceTraceIdToConnectivityKey = Object.fromEntries(
+    source_traces.map((st) => [
+      st.source_trace_id,
+      st.subcircuit_connectivity_map_key
+    ])
+  );
+  const sourceNetIdToConnectivityKey = Object.fromEntries(
+    source_nets.map((sn) => [
+      sn.source_net_id,
+      sn.subcircuit_connectivity_map_key
+    ])
+  );
+  const idToConnectivityKey = {
+    ...sourceTraceIdToConnectivityKey,
+    ...sourceNetIdToConnectivityKey
+  };
+  const pads = [];
+  for (const elm of circuitJson) {
+    if (elm.type === "pcb_smtpad") {
+      const smtpad = elm;
+      if (smtpad.layer !== options.layer) continue;
+      let connectivityKey;
+      if (smtpad.pcb_port_id) {
+        connectivityKey = pcbPortIdToConnectivityKey[smtpad.pcb_port_id];
+      }
+      if (!connectivityKey) {
+        connectivityKey = `unconnected:${smtpad.pcb_smtpad_id}`;
+      }
+      if (smtpad.shape === "rect") {
+        pads.push({
+          shape: "rect",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          bounds: {
+            minX: smtpad.x - smtpad.width / 2,
+            minY: smtpad.y - smtpad.height / 2,
+            maxX: smtpad.x + smtpad.width / 2,
+            maxY: smtpad.y + smtpad.height / 2
+          }
+        });
+      } else if (smtpad.shape === "circle") {
+        pads.push({
+          shape: "circle",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          x: smtpad.x,
+          y: smtpad.y,
+          radius: smtpad.radius
+        });
+      }
+    } else if (elm.type === "pcb_plated_hole") {
+      const platedHole = elm;
+      if (platedHole.shape !== "circle") continue;
+      if (!platedHole.layers.includes(options.layer)) continue;
+      let connectivityKey = pcbPlatedHoleIdToConnectivityKey[platedHole.pcb_plated_hole_id];
+      if (!connectivityKey) {
+        connectivityKey = `unconnected-plated-hole:${platedHole.pcb_plated_hole_id}`;
+      }
+      pads.push({
+        shape: "circle",
+        padId: platedHole.pcb_plated_hole_id,
+        layer: options.layer,
+        connectivityKey,
+        x: platedHole.x,
+        y: platedHole.y,
+        radius: platedHole.outer_diameter / 2
+      });
+    } else if (elm.type === "pcb_hole") {
+      const hole = elm;
+      if (hole.hole_shape !== "circle") continue;
+      pads.push({
+        shape: "circle",
+        padId: hole.pcb_hole_id,
+        layer: options.layer,
+        // holes are through-all
+        connectivityKey: `hole:${hole.pcb_hole_id}`,
+        x: hole.x,
+        y: hole.y,
+        radius: hole.hole_diameter / 2
+      });
+    } else if (elm.type === "pcb_trace") {
+      const trace = elm;
+      const first_wire = trace.route.find(
+        (r) => r.route_type === "wire" && r.layer
+      );
+      if (!first_wire) continue;
+      if (first_wire.route_type === "via") continue;
+      if (first_wire.layer !== options.layer) continue;
+      if (!trace.source_trace_id) continue;
+      const connectivityKey = idToConnectivityKey[trace.source_trace_id];
+      if (!connectivityKey) continue;
+      pads.push({
+        shape: "trace",
+        padId: trace.pcb_trace_id,
+        layer: first_wire.layer,
+        connectivityKey,
+        segments: trace.route.map((r) => ({ x: r.x, y: r.y })),
+        width: first_wire.width
+      });
+    }
+  }
+  const { width, height } = pcb_board;
+  const regionsForPour = [
+    {
+      shape: "rect",
+      layer: options.layer,
+      bounds: {
+        minX: -width / 2,
+        minY: -height / 2,
+        maxX: width / 2,
+        maxY: height / 2
+      },
+      outline: pcb_board.outline,
+      connectivityKey: options.pour_connectivity_key,
+      padMargin: options.pad_margin,
+      traceMargin: options.trace_margin
+    }
+  ];
+  return {
+    pads,
+    regionsForPour
+  };
+};
+export {
+  CopperPourPipelineSolver,
+  convertCircuitJsonToInputProblem
+};

package/lib/circuit-json/convert-circuit-json-to-input-problem.ts

@@ -0,0 +1,208 @@
+import type {
+  AnyCircuitElement,
+  LayerRef,
+  PcbBoard,
+  PcbHole,
+  PcbPlatedHole,
+  PcbPort,
+  PcbSmtPad,
+  PcbTrace,
+  SourceNet,
+  SourcePort,
+  SourceTrace,
+} from "circuit-json"
+import type {
+  InputCircularPad,
+  InputPad,
+  InputProblem,
+  InputRectPad,
+  InputTracePad,
+} from "lib/types"
+
+export const convertCircuitJsonToInputProblem = (
+  circuitJson: AnyCircuitElement[],
+  options: {
+    layer: LayerRef
+    pour_connectivity_key: string
+    pad_margin: number
+    trace_margin: number
+  },
+): InputProblem => {
+  const source_ports = circuitJson.filter(
+    (e) => e.type === "source_port",
+  ) as SourcePort[]
+  const pcb_ports = circuitJson.filter(
+    (e) => e.type === "pcb_port",
+  ) as PcbPort[]
+  const source_traces = circuitJson.filter(
+    (e) => e.type === "source_trace",
+  ) as SourceTrace[]
+  const source_nets = circuitJson.filter(
+    (e) => e.type === "source_net",
+  ) as SourceNet[]
+  const pcb_board = circuitJson.find((e) => e.type === "pcb_board") as
+    | PcbBoard
+    | undefined
+
+  if (!pcb_board) throw new Error("No pcb_board found in circuit json")
+
+  const sourcePortIdToConnectivityKey = Object.fromEntries(
+    source_ports.map((sp) => [
+      sp.source_port_id,
+      sp.subcircuit_connectivity_map_key,
+    ]),
+  )
+  const pcbPortIdToConnectivityKey: Record<string, string | undefined> =
+    Object.fromEntries(
+      pcb_ports.map((pp) => [
+        pp.pcb_port_id,
+        sourcePortIdToConnectivityKey[pp.source_port_id],
+      ]),
+    )
+  const pcbPlatedHoleIdToConnectivityKey: Record<string, string | undefined> =
+    {}
+  for (const pcb_port of pcb_ports) {
+    if (pcb_port.pcb_port_id) {
+      pcbPlatedHoleIdToConnectivityKey[pcb_port.pcb_port_id] =
+        pcbPortIdToConnectivityKey[pcb_port.pcb_port_id]
+    }
+  }
+
+  const sourceTraceIdToConnectivityKey = Object.fromEntries(
+    source_traces.map((st) => [
+      st.source_trace_id,
+      st.subcircuit_connectivity_map_key,
+    ]),
+  )
+  const sourceNetIdToConnectivityKey = Object.fromEntries(
+    source_nets.map((sn) => [
+      sn.source_net_id,
+      sn.subcircuit_connectivity_map_key,
+    ]),
+  )
+
+  const idToConnectivityKey = {
+    ...sourceTraceIdToConnectivityKey,
+    ...sourceNetIdToConnectivityKey,
+  }
+
+  const pads: InputPad[] = []
+
+  for (const elm of circuitJson) {
+    if (elm.type === "pcb_smtpad") {
+      const smtpad = elm as PcbSmtPad
+      if (smtpad.layer !== options.layer) continue
+
+      let connectivityKey: string | undefined
+      if (smtpad.pcb_port_id) {
+        connectivityKey = pcbPortIdToConnectivityKey[smtpad.pcb_port_id]
+      }
+      if (!connectivityKey) {
+        connectivityKey = `unconnected:${smtpad.pcb_smtpad_id}`
+      }
+
+      if (smtpad.shape === "rect") {
+        pads.push({
+          shape: "rect",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          bounds: {
+            minX: smtpad.x - smtpad.width! / 2,
+            minY: smtpad.y - smtpad.height! / 2,
+            maxX: smtpad.x + smtpad.width! / 2,
+            maxY: smtpad.y + smtpad.height! / 2,
+          },
+        } as InputRectPad)
+      } else if (smtpad.shape === "circle") {
+        pads.push({
+          shape: "circle",
+          padId: smtpad.pcb_smtpad_id,
+          layer: smtpad.layer,
+          connectivityKey,
+          x: smtpad.x,
+          y: smtpad.y,
+          radius: smtpad.radius!,
+        } as InputCircularPad)
+      }
+    } else if (elm.type === "pcb_plated_hole") {
+      const platedHole = elm as PcbPlatedHole
+      if (platedHole.shape !== "circle") continue
+      if (!platedHole.layers.includes(options.layer)) continue
+
+      // TODO better connectivity check
+      let connectivityKey =
+        pcbPlatedHoleIdToConnectivityKey[platedHole.pcb_plated_hole_id]
+      if (!connectivityKey) {
+        connectivityKey = `unconnected-plated-hole:${platedHole.pcb_plated_hole_id}`
+      }
+
+      pads.push({
+        shape: "circle",
+        padId: platedHole.pcb_plated_hole_id,
+        layer: options.layer,
+        connectivityKey,
+        x: platedHole.x,
+        y: platedHole.y,
+        radius: platedHole.outer_diameter / 2,
+      } as InputCircularPad)
+    } else if (elm.type === "pcb_hole") {
+      const hole = elm as PcbHole
+      if (hole.hole_shape !== "circle") continue
+
+      pads.push({
+        shape: "circle",
+        padId: hole.pcb_hole_id,
+        layer: options.layer, // holes are through-all
+        connectivityKey: `hole:${hole.pcb_hole_id}`,
+        x: hole.x,
+        y: hole.y,
+        radius: hole.hole_diameter / 2,
+      } as InputCircularPad)
+    } else if (elm.type === "pcb_trace") {
+      const trace = elm as PcbTrace
+      const first_wire = trace.route.find(
+        (r: any) => r.route_type === "wire" && r.layer,
+      )
+      if (!first_wire) continue
+      if (first_wire.route_type === "via") continue
+      if (first_wire.layer !== options.layer) continue
+
+      if (!trace.source_trace_id) continue
+      const connectivityKey = idToConnectivityKey[trace.source_trace_id]
+      if (!connectivityKey) continue
+
+      pads.push({
+        shape: "trace",
+        padId: trace.pcb_trace_id,
+        layer: first_wire.layer!,
+        connectivityKey,
+        segments: trace.route.map((r: any) => ({ x: r.x, y: r.y })),
+        width: first_wire.width,
+      } as InputTracePad)
+    }
+  }
+
+  const { width, height } = pcb_board
+  const regionsForPour = [
+    {
+      shape: "rect" as const,
+      layer: options.layer,
+      bounds: {
+        minX: -width / 2,
+        minY: -height / 2,
+        maxX: width / 2,
+        maxY: height / 2,
+      },
+      outline: pcb_board.outline,
+      connectivityKey: options.pour_connectivity_key,
+      padMargin: options.pad_margin,
+      traceMargin: options.trace_margin,
+    },
+  ]
+
+  return {
+    pads,
+    regionsForPour,
+  }
+}

package/lib/index.ts

@@ -0,0 +1,3 @@
+export * from "./solvers/CopperPourPipelineSolver"
+export * from "./circuit-json/convert-circuit-json-to-input-problem"
+export * from "./types"

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -0,0 +1,51 @@
+import { BasePipelineSolver } from "@tscircuit/solver-utils"
+import { getBoardPolygon } from "./copper-pour/get-board-polygon"
+import Flatten from "@flatten-js/core"
+import { processObstaclesForPour } from "./copper-pour/process-obstacles"
+import { generateBRep } from "./copper-pour/generate-brep"
+import type { BRepShape } from "circuit-json"
+import type { InputProblem, PipelineOutput } from "lib/types"
+
+export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
+  pipelineDef = []
+  constructor(public input: InputProblem) {
+    super(input)
+  }
+
+  override getOutput(): PipelineOutput {
+    const brep_shapes: BRepShape[] = []
+
+    for (const region of this.input.regionsForPour) {
+      const boardPolygon = getBoardPolygon(region)
+
+      const padsForLayer = this.input.pads.filter(
+        (p) => p.layer === region.layer,
+      )
+
+      const { polygonsToSubtract } = processObstaclesForPour(
+        padsForLayer,
+        region.connectivityKey,
+        {
+          padMargin: region.padMargin,
+          traceMargin: region.traceMargin,
+        },
+      )
+
+      let pourPolygons: Flatten.Polygon = boardPolygon
+
+      for (const poly of polygonsToSubtract) {
+        pourPolygons = Flatten.BooleanOperations.subtract(
+          pourPolygons,
+          poly,
+        ) as Flatten.Polygon
+      }
+
+      const new_breps = generateBRep(pourPolygons)
+      brep_shapes.push(...new_breps)
+    }
+
+    return {
+      brep_shapes,
+    }
+  }
+}

package/lib/solvers/copper-pour/circle-to-polygon.ts

@@ -0,0 +1,15 @@
+import Flatten from "@flatten-js/core"
+
+export const circleToPolygon = (circle: Flatten.Circle, numSegments = 32) => {
+  const points: Flatten.Point[] = []
+  for (let i = 0; i < numSegments; i++) {
+    const angle = (i / numSegments) * 2 * Math.PI
+    points.push(
+      new Flatten.Point(
+        circle.center.x + circle.r * Math.cos(angle),
+        circle.center.y + circle.r * Math.sin(angle),
+      ),
+    )
+  }
+  return new Flatten.Polygon(points)
+}

package/lib/solvers/copper-pour/generate-brep.ts

@@ -0,0 +1,60 @@
+import Flatten from "@flatten-js/core"
+import type { BRepShape } from "circuit-json"
+
+const faceToVertices = (face: Flatten.Face) =>
+  face.edges.map((e) => {
+    const pt: { x: number; y: number; bulge?: number } = {
+      x: e.start.x,
+      y: e.start.y,
+    }
+    if (e.isArc) {
+      const bulge = Math.tan((e.shape as Flatten.Arc).sweep / 4)
+      if (Math.abs(bulge) > 1e-9) {
+        pt.bulge = bulge
+      }
+    }
+    return pt
+  })
+
+export const generateBRep = (
+  pourPolygons: Flatten.Polygon | Flatten.Polygon[],
+): BRepShape[] => {
+  const brep_shapes: BRepShape[] = []
+
+  const polygons = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons]
+
+  for (const p of polygons) {
+    const islands = p.splitToIslands()
+
+    for (const island of islands) {
+      if (island.isEmpty()) continue
+
+      const faces = [...island.faces] as Flatten.Face[]
+      const outer_face_ccw = faces.find(
+        (f) => f.orientation() === Flatten.ORIENTATION.CCW,
+      )
+      const inner_faces_cw = faces.filter(
+        (f) => f.orientation() === Flatten.ORIENTATION.CW,
+      )
+
+      if (!outer_face_ccw) continue
+
+      // BRep requires outer ring to be CW and inner rings to be CCW.
+      // Flatten-js provides outer face as CCW and inner faces as CW.
+      // We need to reverse them.
+      outer_face_ccw.reverse()
+      const outer_ring_vertices = faceToVertices(outer_face_ccw)
+      const inner_rings = inner_faces_cw.map((f) => {
+        f.reverse()
+        return { vertices: faceToVertices(f) }
+      })
+
+      brep_shapes.push({
+        outer_ring: { vertices: outer_ring_vertices },
+        inner_rings,
+      })
+    }
+  }
+
+  return brep_shapes
+}