@tscircuit/copper-pour-solver 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -11,6 +11,7 @@ interface InputPourRegion {
     padMargin: number;
     traceMargin: number;
     board_edge_margin?: number;
+    cutout_margin?: number;
 }
 interface BaseInputPad {
     padId: string;
@@ -32,7 +33,11 @@ interface InputTracePad extends BaseInputPad {
     width: number;
     segments: Point[];
 }
-type InputPad = InputRectPad | InputCircularPad | InputTracePad;
+interface InputPolygonPad extends BaseInputPad {
+    shape: "polygon";
+    points: Point[];
+}
+type InputPad = InputRectPad | InputCircularPad | InputTracePad | InputPolygonPad;
 interface InputProblem {
     regionsForPour: InputPourRegion[];
     pads: InputPad[];
@@ -54,6 +59,7 @@ declare const convertCircuitJsonToInputProblem: (circuitJson: AnyCircuitElement[
     pad_margin: number;
     trace_margin: number;
     board_edge_margin?: number;
+    cutout_margin?: number;
 }) => InputProblem;
 
-export { type BaseInputPad, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem };
+export { type BaseInputPad, CopperPourPipelineSolver, type InputCircularPad, type InputPad, type InputPolygonPad, type InputPourRegion, type InputProblem, type InputRectPad, type InputTracePad, type PipelineOutput, convertCircuitJsonToInputProblem };

package/dist/index.js

@@ -57,9 +57,10 @@ var circleToPolygon = (circle, numSegments = 32) => {
 var isRectPad = (pad) => pad.shape === "rect";
 var isTracePad = (pad) => pad.shape === "trace";
 var isCircularPad = (pad) => pad.shape === "circle";
+var isPolygonPad = (pad) => pad.shape === "polygon";
 var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline) => {
   const polygonsToSubtract = [];
-  const { padMargin, traceMargin, board_edge_margin } = margins;
+  const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins;
   if (boardOutline && boardOutline.length > 0 && board_edge_margin && board_edge_margin > 0) {
     const boardPoly = new Flatten3.Polygon(
       boardOutline.map((p) => Flatten3.point(p.x, p.y))
@@ -123,9 +124,18 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
     if (isOnNet) {
       continue;
     }
+    const isHoleOrCutout = pad.connectivityKey.startsWith("hole:") || pad.connectivityKey.startsWith("cutout:");
     if (isCircularPad(pad)) {
-      const isHole = pad.connectivityKey.startsWith("hole:");
-      const margin = isHole ? 0 : padMargin;
+      const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to circular pad/hole/cutout: ${pad.padId}, margin: ${margin}`
+        );
+      } else {
+        console.log(
+          `Applying pad margin to circular pad: ${pad.padId}, margin: ${margin}`
+        );
+      }
       const circle = new Flatten3.Circle(
         new Flatten3.Point(pad.x, pad.y),
         pad.radius + margin
@@ -134,16 +144,83 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
       continue;
     }
     if (isRectPad(pad)) {
+      const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to rect pad/cutout: ${pad.padId}, margin: ${margin}`
+        );
+      } else {
+        console.log(
+          `Applying pad margin to rect pad: ${pad.padId}, margin: ${margin}`
+        );
+      }
       const { bounds } = pad;
       const b = new Flatten3.Box(
-        bounds.minX - padMargin,
-        bounds.minY - padMargin,
-        bounds.maxX + padMargin,
-        bounds.maxY + padMargin
+        bounds.minX - margin,
+        bounds.minY - margin,
+        bounds.maxX + margin,
+        bounds.maxY + margin
       );
       polygonsToSubtract.push(new Flatten3.Polygon(b.toPoints()));
       continue;
     }
+    if (isPolygonPad(pad)) {
+      const margin = isHoleOrCutout ? cutoutMargin ?? 0 : 0;
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to polygon cutout: ${pad.padId}, margin: ${margin}`
+        );
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const uniquePoints = pad.points.filter((p) => {
+        const key = `${p.x},${p.y}`;
+        if (seen.has(key)) {
+          console.log(
+            `Duplicate point detected and removed for ${pad.padId}: (${p.x}, ${p.y})`
+          );
+          return false;
+        }
+        seen.add(key);
+        return true;
+      });
+      if (uniquePoints.length < 3) continue;
+      const polygon = new Flatten3.Polygon(
+        uniquePoints.map((p) => Flatten3.point(p.x, p.y))
+      );
+      if (Math.abs(polygon.area()) < 1e-9) continue;
+      if (margin <= 0) {
+        polygonsToSubtract.push(polygon);
+        continue;
+      }
+      if (polygon.area() > 0) {
+        polygon.reverse();
+      }
+      const offsetLines = [];
+      const polygonVertices = polygon.vertices;
+      for (let i = 0; i < polygonVertices.length; i++) {
+        const p1 = polygonVertices[i];
+        const p2 = polygonVertices[(i + 1) % polygonVertices.length];
+        const segment = Flatten3.segment(p1, p2);
+        if (segment.length === 0) continue;
+        const line = Flatten3.line(segment.start, segment.end);
+        const norm = line.norm;
+        const offsetLine = line.translate(norm.multiply(-margin));
+        offsetLines.push(offsetLine);
+      }
+      const newPolygonPoints = [];
+      for (let i = 0; i < offsetLines.length; i++) {
+        const line1 = offsetLines[i];
+        const line2 = offsetLines[(i + 1) % offsetLines.length];
+        const ip = line1.intersect(line2);
+        if (ip.length > 0) {
+          newPolygonPoints.push(ip[0]);
+        }
+      }
+      if (newPolygonPoints.length >= 3) {
+        polygonsToSubtract.push(new Flatten3.Polygon(newPolygonPoints));
+      }
+      continue;
+    }
     if (isTracePad(pad)) {
       for (const segment of pad.segments) {
         const circle = new Flatten3.Circle(
@@ -254,7 +331,8 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
         {
           padMargin: region.padMargin,
           traceMargin: region.traceMargin,
-          board_edge_margin: region.board_edge_margin
+          board_edge_margin: region.board_edge_margin,
+          cutoutMargin: region.cutout_margin
         },
         region.outline
       );
@@ -294,6 +372,9 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
   const source_traces = circuitJson.filter(
     (e) => e.type === "source_trace"
   );
+  const pcb_traces = circuitJson.filter(
+    (e) => e.type === "pcb_trace"
+  );
   const source_nets = circuitJson.filter(
     (e) => e.type === "source_net"
   );
@@ -333,6 +414,14 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
     ...sourceTraceIdToConnectivityKey,
     ...sourceNetIdToConnectivityKey
   };
+  const pcbTraceIdToConnectivityKey = Object.fromEntries(
+    pcb_traces.map(
+      (trace) => [
+        trace.pcb_trace_id,
+        trace.source_trace_id ? idToConnectivityKey[trace.source_trace_id] : void 0
+      ]
+    ).filter((entry) => Boolean(entry[1]))
+  );
   const pads = [];
   for (const elm of circuitJson) {
     if (elm.type === "pcb_smtpad") {
@@ -399,25 +488,100 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
         y: hole.y,
         radius: hole.hole_diameter / 2
       });
+    } else if (elm.type === "pcb_cutout") {
+      const cutout = elm;
+      console.log(
+        `Processing cutout: ${cutout.pcb_cutout_id} (shape: ${cutout.shape})`
+      );
+      if (cutout.shape === "rect") {
+        pads.push({
+          shape: "rect",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer,
+          // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          bounds: {
+            minX: cutout.center.x - cutout.width / 2,
+            minY: cutout.center.y - cutout.height / 2,
+            maxX: cutout.center.x + cutout.width / 2,
+            maxY: cutout.center.y + cutout.height / 2
+          }
+        });
+      } else if (cutout.shape === "circle") {
+        pads.push({
+          shape: "circle",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer,
+          // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          x: cutout.center.x,
+          y: cutout.center.y,
+          radius: cutout.radius
+        });
+      } else if (cutout.shape === "polygon") {
+        console.log(
+          `Polygon cutout points for ${cutout.pcb_cutout_id}: ${JSON.stringify(cutout.points)}`
+        );
+        pads.push({
+          shape: "polygon",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer,
+          // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          points: cutout.points
+        });
+      }
+    } else if (elm.type === "pcb_via") {
+      const via = elm;
+      if (!via.layers.includes(options.layer)) continue;
+      let connectivityKey;
+      if (via.pcb_trace_id) {
+        connectivityKey = pcbTraceIdToConnectivityKey[via.pcb_trace_id];
+      }
+      if (!connectivityKey) {
+        connectivityKey = `unconnected-via:${via.pcb_via_id}`;
+      }
+      pads.push({
+        shape: "circle",
+        padId: via.pcb_via_id,
+        layer: options.layer,
+        connectivityKey,
+        x: via.x,
+        y: via.y,
+        radius: via.outer_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
-      });
+      let currentSegmentGroup = [];
+      let currentWidth = null;
+      const commitGroup = () => {
+        if (currentSegmentGroup.length > 1) {
+          pads.push({
+            shape: "trace",
+            padId: `${trace.pcb_trace_id}-${pads.length}`,
+            layer: options.layer,
+            connectivityKey,
+            segments: currentSegmentGroup,
+            width: currentWidth
+          });
+        }
+        currentSegmentGroup = [];
+        currentWidth = null;
+      };
+      for (const r of trace.route) {
+        const ri = r;
+        const isWireOnLayer = ri.route_type === "wire" && ri.layer === options.layer;
+        if (isWireOnLayer) {
+          if (currentWidth === null) currentWidth = ri.width;
+          currentSegmentGroup.push({ x: ri.x, y: ri.y });
+        } else {
+          commitGroup();
+        }
+      }
+      commitGroup();
     }
   }
   const { width, height } = pcb_board;
@@ -435,7 +599,8 @@ var convertCircuitJsonToInputProblem = (circuitJson, options) => {
       connectivityKey: options.pour_connectivity_key,
       padMargin: options.pad_margin,
       traceMargin: options.trace_margin,
-      board_edge_margin: options.board_edge_margin ?? 0
+      board_edge_margin: options.board_edge_margin ?? 0,
+      cutout_margin: options.cutout_margin
     }
   ];
   return {

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

@@ -7,6 +7,8 @@ import type {
   PcbPort,
   PcbSmtPad,
   PcbTrace,
+  PcbVia,
+  Point,
   SourceNet,
   SourcePort,
   SourceTrace,
@@ -14,6 +16,7 @@ import type {
 import type {
   InputCircularPad,
   InputPad,
+  InputPolygonPad,
   InputProblem,
   InputRectPad,
   InputTracePad,
@@ -27,6 +30,7 @@ export const convertCircuitJsonToInputProblem = (
     pad_margin: number
     trace_margin: number
     board_edge_margin?: number
+    cutout_margin?: number
   },
 ): InputProblem => {
   const source_ports = circuitJson.filter(
@@ -38,6 +42,9 @@ export const convertCircuitJsonToInputProblem = (
   const source_traces = circuitJson.filter(
     (e) => e.type === "source_trace",
   ) as SourceTrace[]
+  const pcb_traces = circuitJson.filter(
+    (e) => e.type === "pcb_trace",
+  ) as PcbTrace[]
   const source_nets = circuitJson.filter(
     (e) => e.type === "source_net",
   ) as SourceNet[]
@@ -87,6 +94,21 @@ export const convertCircuitJsonToInputProblem = (
     ...sourceNetIdToConnectivityKey,
   }
 
+  const pcbTraceIdToConnectivityKey: Record<string, string> =
+    Object.fromEntries(
+      pcb_traces
+        .map(
+          (trace) =>
+            [
+              trace.pcb_trace_id,
+              trace.source_trace_id
+                ? idToConnectivityKey[trace.source_trace_id]
+                : undefined,
+            ] as const,
+        )
+        .filter((entry): entry is [string, string] => Boolean(entry[1])),
+    )
+
   const pads: InputPad[] = []
 
   for (const elm of circuitJson) {
@@ -160,27 +182,104 @@ export const convertCircuitJsonToInputProblem = (
         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,
+    } else if (elm.type === "pcb_cutout") {
+      const cutout = elm as any
+      console.log(
+        `Processing cutout: ${cutout.pcb_cutout_id} (shape: ${cutout.shape})`,
       )
-      if (!first_wire) continue
-      if (first_wire.route_type === "via") continue
-      if (first_wire.layer !== options.layer) continue
+      if (cutout.shape === "rect") {
+        pads.push({
+          shape: "rect",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer, // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          bounds: {
+            minX: cutout.center.x - cutout.width / 2,
+            minY: cutout.center.y - cutout.height / 2,
+            maxX: cutout.center.x + cutout.width / 2,
+            maxY: cutout.center.y + cutout.height / 2,
+          },
+        } as InputRectPad)
+      } else if (cutout.shape === "circle") {
+        pads.push({
+          shape: "circle",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer, // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          x: cutout.center.x,
+          y: cutout.center.y,
+          radius: cutout.radius,
+        } as InputCircularPad)
+      } else if (cutout.shape === "polygon") {
+        console.log(
+          `Polygon cutout points for ${cutout.pcb_cutout_id}: ${JSON.stringify(cutout.points)}`,
+        )
+        pads.push({
+          shape: "polygon",
+          padId: cutout.pcb_cutout_id,
+          layer: options.layer, // through-all
+          connectivityKey: `cutout:${cutout.pcb_cutout_id}`,
+          points: cutout.points,
+        } as InputPolygonPad)
+      }
+    } else if (elm.type === "pcb_via") {
+      const via = elm as PcbVia
+      if (!via.layers.includes(options.layer)) continue
+
+      let connectivityKey: string | undefined
+      if (via.pcb_trace_id) {
+        connectivityKey = pcbTraceIdToConnectivityKey[via.pcb_trace_id]
+      }
 
+      if (!connectivityKey) {
+        connectivityKey = `unconnected-via:${via.pcb_via_id}`
+      }
+
+      pads.push({
+        shape: "circle",
+        padId: via.pcb_via_id,
+        layer: options.layer,
+        connectivityKey,
+        x: via.x,
+        y: via.y,
+        radius: via.outer_diameter / 2,
+      } as InputCircularPad)
+    } else if (elm.type === "pcb_trace") {
+      const trace = elm as PcbTrace
       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)
+      let currentSegmentGroup: Point[] = []
+      let currentWidth: number | null = null
+
+      const commitGroup = () => {
+        if (currentSegmentGroup.length > 1) {
+          pads.push({
+            shape: "trace",
+            padId: `${trace.pcb_trace_id}-${pads.length}`,
+            layer: options.layer,
+            connectivityKey,
+            segments: currentSegmentGroup,
+            width: currentWidth!,
+          } as InputTracePad)
+        }
+        currentSegmentGroup = []
+        currentWidth = null
+      }
+
+      for (const r of trace.route) {
+        const ri = r as any
+        const isWireOnLayer =
+          ri.route_type === "wire" && ri.layer === options.layer
+        if (isWireOnLayer) {
+          if (currentWidth === null) currentWidth = ri.width
+          currentSegmentGroup.push({ x: ri.x, y: ri.y })
+        } else {
+          commitGroup()
+        }
+      }
+      commitGroup()
     }
   }
 
@@ -200,6 +299,7 @@ export const convertCircuitJsonToInputProblem = (
       padMargin: options.pad_margin,
       traceMargin: options.trace_margin,
       board_edge_margin: options.board_edge_margin ?? 0,
+      cutout_margin: options.cutout_margin,
     },
   ]
 

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -29,6 +29,7 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
           padMargin: region.padMargin,
           traceMargin: region.traceMargin,
           board_edge_margin: region.board_edge_margin,
+          cutoutMargin: region.cutout_margin,
         },
         region.outline,
       )

package/lib/solvers/copper-pour/process-obstacles.ts

@@ -3,6 +3,7 @@ import type { Point } from "@tscircuit/math-utils"
 import type {
   InputCircularPad,
   InputPad,
+  InputPolygonPad,
   InputRectPad,
   InputTracePad,
 } from "lib/types"
@@ -17,6 +18,8 @@ const isTracePad = (pad: InputPad): pad is InputTracePad =>
   pad.shape === "trace"
 const isCircularPad = (pad: InputPad): pad is InputCircularPad =>
   pad.shape === "circle"
+const isPolygonPad = (pad: InputPad): pad is InputPolygonPad =>
+  pad.shape === "polygon"
 
 export const processObstaclesForPour = (
   pads: InputPad[],
@@ -25,12 +28,13 @@ export const processObstaclesForPour = (
     padMargin: number
     traceMargin: number
     board_edge_margin?: number
+    cutoutMargin?: number
   },
   boardOutline?: Point[],
 ): ProcessedObstacles => {
   const polygonsToSubtract: Flatten.Polygon[] = []
 
-  const { padMargin, traceMargin, board_edge_margin } = margins
+  const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins
 
   if (
     boardOutline &&
@@ -120,9 +124,21 @@ export const processObstaclesForPour = (
       continue
     }
 
+    const isHoleOrCutout =
+      pad.connectivityKey.startsWith("hole:") ||
+      pad.connectivityKey.startsWith("cutout:")
+
     if (isCircularPad(pad)) {
-      const isHole = pad.connectivityKey.startsWith("hole:")
-      const margin = isHole ? 0 : padMargin
+      const margin = isHoleOrCutout ? (cutoutMargin ?? 0) : padMargin
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to circular pad/hole/cutout: ${pad.padId}, margin: ${margin}`,
+        )
+      } else {
+        console.log(
+          `Applying pad margin to circular pad: ${pad.padId}, margin: ${margin}`,
+        )
+      }
       const circle = new Flatten.Circle(
         new Flatten.Point(pad.x, pad.y),
         pad.radius + margin,
@@ -132,17 +148,103 @@ export const processObstaclesForPour = (
     }
 
     if (isRectPad(pad)) {
+      const margin = isHoleOrCutout ? (cutoutMargin ?? 0) : padMargin
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to rect pad/cutout: ${pad.padId}, margin: ${margin}`,
+        )
+      } else {
+        console.log(
+          `Applying pad margin to rect pad: ${pad.padId}, margin: ${margin}`,
+        )
+      }
       const { bounds } = pad
       const b = new Flatten.Box(
-        bounds.minX - padMargin,
-        bounds.minY - padMargin,
-        bounds.maxX + padMargin,
-        bounds.maxY + padMargin,
+        bounds.minX - margin,
+        bounds.minY - margin,
+        bounds.maxX + margin,
+        bounds.maxY + margin,
       )
       polygonsToSubtract.push(new Flatten.Polygon(b.toPoints()))
       continue
     }
 
+    if (isPolygonPad(pad)) {
+      const margin = isHoleOrCutout ? (cutoutMargin ?? 0) : 0
+      if (isHoleOrCutout) {
+        console.log(
+          `Applying cutout margin to polygon cutout: ${pad.padId}, margin: ${margin}`,
+        )
+      }
+
+      const seen = new Set<string>()
+      const uniquePoints = pad.points.filter((p) => {
+        const key = `${p.x},${p.y}`
+        if (seen.has(key)) {
+          console.log(
+            `Duplicate point detected and removed for ${pad.padId}: (${p.x}, ${p.y})`,
+          )
+          return false
+        }
+        seen.add(key)
+        return true
+      })
+
+      if (uniquePoints.length < 3) continue
+
+      const polygon = new Flatten.Polygon(
+        uniquePoints.map((p) => Flatten.point(p.x, p.y)),
+      )
+
+      if (Math.abs(polygon.area()) < 1e-9) continue
+
+      if (margin <= 0) {
+        polygonsToSubtract.push(polygon)
+        continue
+      }
+
+      // Ensure polygon is CCW for consistent normal direction.
+      // In flatten-js, CCW corresponds to a negative area.
+      if (polygon.area() > 0) {
+        polygon.reverse()
+      }
+
+      const offsetLines: Flatten.Line[] = []
+      const polygonVertices = polygon.vertices
+      for (let i = 0; i < polygonVertices.length; i++) {
+        const p1 = polygonVertices[i]!
+        const p2 = polygonVertices[(i + 1) % polygonVertices.length]!
+
+        const segment = Flatten.segment(p1, p2)
+
+        if (segment.length === 0) continue
+
+        const line = Flatten.line(segment.start, segment.end)
+
+        // For a CCW polygon, the normal (rotated +90deg, i.e. "left") points inward.
+        // We must translate outward, so we use a negative margin.
+        const norm = line.norm
+        const offsetLine = line.translate(norm.multiply(-margin))
+        offsetLines.push(offsetLine)
+      }
+
+      const newPolygonPoints: Flatten.Point[] = []
+      for (let i = 0; i < offsetLines.length; i++) {
+        const line1 = offsetLines[i]!
+        const line2 = offsetLines[(i + 1) % offsetLines.length]!
+
+        const ip = line1.intersect(line2)
+        if (ip.length > 0) {
+          newPolygonPoints.push(ip[0]!)
+        }
+      }
+
+      if (newPolygonPoints.length >= 3) {
+        polygonsToSubtract.push(new Flatten.Polygon(newPolygonPoints))
+      }
+      continue
+    }
+
     if (isTracePad(pad)) {
       // Add circles for each vertex
       for (const segment of pad.segments) {

package/lib/types.ts

@@ -10,6 +10,7 @@ export interface InputPourRegion {
   padMargin: number
   traceMargin: number
   board_edge_margin?: number
+  cutout_margin?: number
 }
 
 export interface BaseInputPad {
@@ -36,7 +37,16 @@ export interface InputTracePad extends BaseInputPad {
   segments: Point[]
 }
 
-export type InputPad = InputRectPad | InputCircularPad | InputTracePad
+export interface InputPolygonPad extends BaseInputPad {
+  shape: "polygon"
+  points: Point[]
+}
+
+export type InputPad =
+  | InputRectPad
+  | InputCircularPad
+  | InputTracePad
+  | InputPolygonPad
 
 export interface InputProblem {
   regionsForPour: InputPourRegion[]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/copper-pour-solver",
   "main": "dist/index.js",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "scripts": {
     "format": "biome format . --write",
     "format:check": "biome format .",