@tscircuit/copper-pour-solver 0.0.25 → 0.0.26

package/dist/index.js

@@ -1,255 +1,18 @@
 // lib/solvers/CopperPourPipelineSolver.ts
 import { BasePipelineSolver } from "@tscircuit/solver-utils";
 
-// lib/solvers/copper-pour/generate-brep.ts
-var signedArea = (ring) => {
-  let area = 0;
-  for (let i = 0; i < ring.length; i++) {
-    const current = ring[i];
-    const next = ring[(i + 1) % ring.length];
-    area += current.x * next.y - next.x * current.y;
-  }
-  return area / 2;
-};
-var ensureAreaSign = (ring, desiredSign) => {
-  const area = signedArea(ring);
-  const shouldReverse = desiredSign === "positive" && area < 0 || desiredSign === "negative" && area > 0;
-  return shouldReverse ? [...ring].reverse() : ring;
-};
-var ringToVertices = (ring) => ring.map((point) => ({
-  x: point.x,
-  y: point.y
-}));
-var generateBRep = (pourIslands) => {
-  const brep_shapes = [];
-  for (const island of pourIslands) {
-    if (island.outerRing.length < 3) continue;
-    const outerRing = ensureAreaSign(island.outerRing, "negative");
-    const innerRings = island.innerRings.filter((ring) => ring.length >= 3).map((ring) => ensureAreaSign(ring, "positive"));
-    brep_shapes.push({
-      outer_ring: { vertices: ringToVertices(outerRing) },
-      inner_rings: innerRings.map((ring) => ({
-        vertices: ringToVertices(ring)
-      }))
-    });
-  }
-  return brep_shapes;
-};
-
-// lib/solvers/copper-pour/manifold-geometry-adapter.ts
-var manifoldModule = await import("manifold-3d");
-var manifoldFactory = manifoldModule.default;
-var manifold = await manifoldFactory();
-manifold.setup();
-var { CrossSection } = manifold;
-var MANIFOLD_GEOMETRY_SCALE = 1e6;
-var DEFAULT_MIN_ISLAND_AREA = 1e-8;
-var describePolygons = (polygons) => {
-  let pointCount = 0;
-  const bbox = {
-    minX: Number.POSITIVE_INFINITY,
-    minY: Number.POSITIVE_INFINITY,
-    maxX: Number.NEGATIVE_INFINITY,
-    maxY: Number.NEGATIVE_INFINITY
-  };
-  for (const polygon of polygons) {
-    pointCount += polygon.length;
-    for (const [x, y] of polygon) {
-      bbox.minX = Math.min(bbox.minX, x);
-      bbox.minY = Math.min(bbox.minY, y);
-      bbox.maxX = Math.max(bbox.maxX, x);
-      bbox.maxY = Math.max(bbox.maxY, y);
-    }
-  }
-  return {
-    polygonCount: polygons.length,
-    pointCount,
-    bbox: pointCount > 0 ? bbox : null,
-    scale: MANIFOLD_GEOMETRY_SCALE
-  };
-};
-var assertFinitePoint = (point, operation) => {
-  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
-    throw new Error(
-      `${operation} received non-finite point (${point.x}, ${point.y})`
-    );
-  }
-};
-var pointsEqual = (a, b) => a.x === b.x && a.y === b.y;
-var signedArea2 = (ring) => {
-  let area = 0;
-  for (let i = 0; i < ring.length; i++) {
-    const current = ring[i];
-    const next = ring[(i + 1) % ring.length];
-    area += current.x * next.y - next.x * current.y;
-  }
-  return area / 2;
-};
-var normalizeRing = (ring, operation = "normalizeRing") => {
-  const normalized = [];
-  for (const point of ring) {
-    assertFinitePoint(point, operation);
-    const roundedPoint = {
-      x: Math.round(point.x * MANIFOLD_GEOMETRY_SCALE) / MANIFOLD_GEOMETRY_SCALE,
-      y: Math.round(point.y * MANIFOLD_GEOMETRY_SCALE) / MANIFOLD_GEOMETRY_SCALE
-    };
-    const previous = normalized[normalized.length - 1];
-    if (!previous || !pointsEqual(previous, roundedPoint)) {
-      normalized.push(roundedPoint);
-    }
-  }
-  if (normalized.length > 1 && pointsEqual(normalized[0], normalized[normalized.length - 1])) {
-    normalized.pop();
-  }
-  const uniquePoints = new Set(normalized.map((p) => `${p.x},${p.y}`));
-  if (uniquePoints.size < 3 || Math.abs(signedArea2(normalized)) < 1e-18) {
-    return [];
-  }
-  return normalized;
-};
-var toScaledManifoldPolygons = (polygons, operation = "toScaledManifoldPolygons") => {
-  const scaledPolygons = [];
-  for (const polygon of polygons) {
-    const normalized = normalizeRing(polygon, operation);
-    if (normalized.length < 3) continue;
-    const positiveRing = signedArea2(normalized) < 0 ? [...normalized].reverse() : normalized;
-    scaledPolygons.push(
-      positiveRing.map((p) => [
-        Math.round(p.x * MANIFOLD_GEOMETRY_SCALE),
-        Math.round(p.y * MANIFOLD_GEOMETRY_SCALE)
-      ])
-    );
-  }
-  return scaledPolygons;
-};
-var fromScaledManifoldPolygons = (polygons) => polygons.map(
-  (polygon) => normalizeRing(
-    polygon.map(([x, y]) => ({
-      x: x / MANIFOLD_GEOMETRY_SCALE,
-      y: y / MANIFOLD_GEOMETRY_SCALE
-    })),
-    "fromScaledManifoldPolygons"
-  )
-).filter((polygon) => polygon.length >= 3);
-var runManifoldOperation = (operation, polygons, callback) => {
-  try {
-    return callback();
-  } catch (error) {
-    const details = describePolygons(polygons);
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `${operation} failed: ${message}; details=${JSON.stringify(details)}`
-    );
-  }
-};
-var crossSectionFromPolygon = (polygon, fillRule = "Positive") => {
-  const scaledPolygons = toScaledManifoldPolygons(
-    [polygon],
-    "crossSectionFromPolygon"
-  );
-  if (scaledPolygons.length === 0) {
-    return CrossSection.ofPolygons([]);
-  }
-  return runManifoldOperation(
-    "crossSectionFromPolygon",
-    scaledPolygons,
-    () => CrossSection.ofPolygons(scaledPolygons, fillRule)
-  );
-};
-var crossSectionFromPolygons = (polygons, fillRule = "Positive") => {
-  const scaledPolygons = toScaledManifoldPolygons(
-    polygons,
-    "crossSectionFromPolygons"
-  );
-  if (scaledPolygons.length === 0) {
-    return CrossSection.ofPolygons([]);
-  }
-  return runManifoldOperation(
-    "crossSectionFromPolygons",
-    scaledPolygons,
-    () => CrossSection.ofPolygons(scaledPolygons, fillRule)
-  );
-};
-var composeCrossSections = (sections) => {
-  const nonEmptySections = sections.filter((section) => !section.isEmpty());
-  if (nonEmptySections.length === 0) {
-    return CrossSection.ofPolygons([]);
-  }
-  return runManifoldOperation(
-    "composeCrossSections",
-    [],
-    () => CrossSection.compose(nonEmptySections)
-  );
-};
-var offsetPolygon = (polygon, margin, joinType = "Miter") => {
-  const scaledPolygons = toScaledManifoldPolygons([polygon], "offsetPolygon");
-  if (scaledPolygons.length === 0 || margin <= 0) {
-    return scaledPolygons.length === 0 ? [] : [normalizeRing(polygon)];
-  }
-  const scaledMargin = margin * MANIFOLD_GEOMETRY_SCALE;
-  const section = runManifoldOperation(
-    "offsetPolygon.input",
-    scaledPolygons,
-    () => CrossSection.ofPolygons(scaledPolygons, "Positive")
-  );
-  const offset = runManifoldOperation(
-    "offsetPolygon.offset",
-    scaledPolygons,
-    () => section.offset(scaledMargin, joinType, 2, 32)
-  );
-  return fromScaledManifoldPolygons(offset.toPolygons());
-};
-var subtractBlockersFromPour = (pourPolygon, blockerPolygons) => {
-  const pourSection = crossSectionFromPolygon(pourPolygon);
-  const blockerSection = crossSectionFromPolygons(blockerPolygons);
-  if (pourSection.isEmpty() || blockerSection.isEmpty()) {
-    return pourSection;
-  }
-  const operationPolygons = [
-    ...toScaledManifoldPolygons([pourPolygon], "subtractBlockersFromPour.pour"),
-    ...toScaledManifoldPolygons(
-      blockerPolygons,
-      "subtractBlockersFromPour.blockers"
-    )
-  ];
-  return runManifoldOperation(
-    "subtractBlockersFromPour",
-    operationPolygons,
-    () => pourSection.subtract(blockerSection)
-  );
-};
-var removeTinyIslands = (section, minArea = DEFAULT_MIN_ISLAND_AREA) => {
-  if (section.isEmpty()) return section;
-  const minScaledArea = minArea * MANIFOLD_GEOMETRY_SCALE * MANIFOLD_GEOMETRY_SCALE;
-  const islands = section.decompose().filter((island) => Math.abs(island.area()) >= minScaledArea);
-  return composeCrossSections(islands);
-};
-var crossSectionToCopperPourIslands = (section) => {
-  const islands = [];
-  for (const island of section.decompose()) {
-    const rings = fromScaledManifoldPolygons(island.toPolygons());
-    if (rings.length === 0) continue;
-    const outerRing = rings.reduce(
-      (largest, ring) => Math.abs(signedArea2(ring)) > Math.abs(signedArea2(largest)) ? ring : largest
-    );
-    const innerRings = rings.filter((ring) => ring !== outerRing);
-    islands.push({
-      outerRing,
-      innerRings
-    });
-  }
-  return islands;
-};
-var geometryDebugSummary = (label, polygons) => ({
-  label,
-  ...describePolygons(toScaledManifoldPolygons(polygons, label))
-});
-
 // lib/solvers/copper-pour/get-board-polygon.ts
+import Flatten from "@flatten-js/core";
 var getBoardPolygon = (region) => {
   const board_edge_margin = region.board_edge_margin ?? 0;
   if (region.outline && region.outline.length > 0) {
-    return normalizeRing(region.outline, "getBoardPolygon.outline");
+    const polygon = new Flatten.Polygon(
+      region.outline.map((p) => Flatten.point(p.x, p.y))
+    );
+    if (polygon.orientation() === Flatten.ORIENTATION.CW) {
+      polygon.reverse();
+    }
+    return polygon;
   }
   const { bounds } = region;
   const newBounds = {
@@ -259,64 +22,74 @@ var getBoardPolygon = (region) => {
     maxY: bounds.maxY - board_edge_margin
   };
   if (newBounds.minX >= newBounds.maxX || newBounds.minY >= newBounds.maxY) {
-    return [];
+    return new Flatten.Polygon();
   }
-  return [
-    { x: newBounds.minX, y: newBounds.minY },
-    { x: newBounds.maxX, y: newBounds.minY },
-    { x: newBounds.maxX, y: newBounds.maxY },
-    { x: newBounds.minX, y: newBounds.maxY }
-  ];
+  return new Flatten.Polygon(
+    new Flatten.Box(
+      newBounds.minX,
+      newBounds.minY,
+      newBounds.maxX,
+      newBounds.maxY
+    ).toPoints()
+  );
 };
 
+// lib/solvers/CopperPourPipelineSolver.ts
+import Flatten5 from "@flatten-js/core";
+
 // 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 isPolygonPad = (pad) => pad.shape === "polygon";
-var circleToPolygon = (center, radius, numSegments = 32) => {
+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({
-      x: center.x + radius * Math.cos(angle),
-      y: center.y + radius * Math.sin(angle)
-    });
+    points.push(
+      new Flatten2.Point(
+        circle.center.x + circle.r * Math.cos(angle),
+        circle.center.y + circle.r * Math.sin(angle)
+      )
+    );
   }
-  return points;
+  return new Flatten2.Polygon(points);
 };
-var boxToPolygon = (minX, minY, maxX, maxY) => [
-  { x: minX, y: minY },
-  { x: maxX, y: minY },
-  { x: maxX, y: maxY },
-  { x: minX, y: maxY }
-];
+
+// 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 isPolygonPad = (pad) => pad.shape === "polygon";
 var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline) => {
   const polygonsToSubtract = [];
   const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins;
   if (boardOutline && boardOutline.length > 0 && board_edge_margin && board_edge_margin > 0) {
-    const vertices = normalizeRing(
-      boardOutline,
-      "processObstacles.boardOutline"
+    const boardPoly = new Flatten3.Polygon(
+      boardOutline.map((p) => Flatten3.point(p.x, p.y))
     );
+    if (boardPoly.area() < 0) {
+      boardPoly.reverse();
+    }
+    const vertices = boardPoly.vertices;
     for (let i = 0; i < vertices.length; i++) {
       const p1 = vertices[i === 0 ? vertices.length - 1 : i - 1];
       const p2 = vertices[i];
       const p3 = vertices[(i + 1) % vertices.length];
       if (!p1 || !p2 || !p3) continue;
-      const v1 = { x: p2.x - p1.x, y: p2.y - p1.y };
-      const v2 = { x: p3.x - p2.x, y: p3.y - p2.y };
-      const crossProduct = v1.x * v2.y - v1.y * v2.x;
-      polygonsToSubtract.push(circleToPolygon(p2, board_edge_margin));
+      const v1 = new Flatten3.Vector(p1, p2);
+      const v2 = new Flatten3.Vector(p2, p3);
+      const crossProduct = v1.cross(v2);
+      const circle = new Flatten3.Circle(p2, board_edge_margin);
+      polygonsToSubtract.push(circleToPolygon(circle));
       if (crossProduct < 0) {
-        polygonsToSubtract.push(
-          boxToPolygon(
-            p2.x - board_edge_margin,
-            p2.y - board_edge_margin,
-            p2.x + board_edge_margin,
-            p2.y + board_edge_margin
-          )
+        const box = new Flatten3.Box(
+          p2.x - board_edge_margin,
+          p2.y - board_edge_margin,
+          p2.x + board_edge_margin,
+          p2.y + board_edge_margin
         );
+        polygonsToSubtract.push(new Flatten3.Polygon(box.toPoints()));
       }
     }
     for (let i = 0; i < vertices.length; i++) {
@@ -344,7 +117,9 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
         x: centerX + p.x * cosAngle - p.y * sinAngle,
         y: centerY + p.x * sinAngle + p.y * cosAngle
       }));
-      polygonsToSubtract.push(rotatedCorners);
+      polygonsToSubtract.push(
+        new Flatten3.Polygon(rotatedCorners.map((p) => Flatten3.point(p.x, p.y)))
+      );
     }
   }
   for (const pad of pads) {
@@ -355,22 +130,23 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
     const isHoleOrCutout = pad.connectivityKey.startsWith("hole:") || pad.connectivityKey.startsWith("cutout:");
     if (isCircularPad(pad)) {
       const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
-      polygonsToSubtract.push(
-        circleToPolygon({ x: pad.x, y: pad.y }, pad.radius + margin)
+      const circle = new Flatten3.Circle(
+        new Flatten3.Point(pad.x, pad.y),
+        pad.radius + margin
       );
+      polygonsToSubtract.push(circleToPolygon(circle));
       continue;
     }
     if (isRectPad(pad)) {
       const margin = isHoleOrCutout ? cutoutMargin ?? 0 : padMargin;
       const { bounds } = pad;
-      polygonsToSubtract.push(
-        boxToPolygon(
-          bounds.minX - margin,
-          bounds.minY - margin,
-          bounds.maxX + margin,
-          bounds.maxY + margin
-        )
+      const b = new Flatten3.Box(
+        bounds.minX - margin,
+        bounds.minY - margin,
+        bounds.maxX + margin,
+        bounds.maxY + margin
       );
+      polygonsToSubtract.push(new Flatten3.Polygon(b.toPoints()));
       continue;
     }
     if (isPolygonPad(pad)) {
@@ -385,20 +161,50 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
         return true;
       });
       if (uniquePoints.length < 3) continue;
-      const polygon = normalizeRing(uniquePoints, "processObstacles.polygonPad");
-      if (polygon.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;
       }
-      polygonsToSubtract.push(...offsetPolygon(polygon, margin));
+      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) {
-        polygonsToSubtract.push(
-          circleToPolygon(segment, pad.width / 2 + traceMargin)
+        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];
@@ -425,13 +231,62 @@ var processObstaclesForPour = (pads, pourConnectivityKey, margins, boardOutline)
           x: centerX + p.x * cosAngle - p.y * sinAngle,
           y: centerY + p.x * sinAngle + p.y * cosAngle
         }));
-        polygonsToSubtract.push(rotatedCorners);
+        polygonsToSubtract.push(
+          new Flatten3.Polygon(
+            rotatedCorners.map((p) => Flatten3.point(p.x, p.y))
+          )
+        );
       }
     }
   }
   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) {
@@ -461,32 +316,23 @@ var CopperPourPipelineSolver = class extends BasePipelineSolver {
         },
         region.outline
       );
-      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
-        console.info(
-          JSON.stringify([
-            geometryDebugSummary("input pour polygon", [boardPolygon]),
-            geometryDebugSummary("unioned blockers input", polygonsToSubtract)
-          ])
-        );
-      }
-      const finalPour = removeTinyIslands(
-        subtractBlockersFromPour(boardPolygon, polygonsToSubtract)
-      );
-      const pourIslands = crossSectionToCopperPourIslands(finalPour);
-      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
-        console.info(
-          JSON.stringify(
-            geometryDebugSummary(
-              "final copper polygons",
-              pourIslands.flatMap((island) => [
-                island.outerRing,
-                ...island.innerRings
-              ])
-            )
-          )
-        );
+      let pourPolygons = boardPolygon;
+      for (const poly of polygonsToSubtract) {
+        const currentPolys = Array.isArray(pourPolygons) ? pourPolygons : [pourPolygons];
+        const nextPolys = [];
+        for (const p of currentPolys) {
+          const result = Flatten5.BooleanOperations.subtract(p, poly);
+          if (result) {
+            if (Array.isArray(result)) {
+              nextPolys.push(...result.filter((r) => !r.isEmpty()));
+            } else {
+              if (!result.isEmpty()) nextPolys.push(result);
+            }
+          }
+        }
+        pourPolygons = nextPolys;
       }
-      const new_breps = generateBRep(pourIslands);
+      const new_breps = generateBRep(pourPolygons);
       brep_shapes.push(...new_breps);
     }
     return {

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -1,15 +1,10 @@
 import { BasePipelineSolver } from "@tscircuit/solver-utils"
-import type { BRepShape } from "circuit-json"
-import type { InputProblem, PipelineOutput } from "lib/types"
-import { generateBRep } from "./copper-pour/generate-brep"
 import { getBoardPolygon } from "./copper-pour/get-board-polygon"
-import {
-  crossSectionToCopperPourIslands,
-  geometryDebugSummary,
-  removeTinyIslands,
-  subtractBlockersFromPour,
-} from "./copper-pour/manifold-geometry-adapter"
+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 = []
@@ -43,35 +38,27 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
         region.outline,
       )
 
-      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
-        console.info(
-          JSON.stringify([
-            geometryDebugSummary("input pour polygon", [boardPolygon]),
-            geometryDebugSummary("unioned blockers input", polygonsToSubtract),
-          ]),
-        )
-      }
-
-      const finalPour = removeTinyIslands(
-        subtractBlockersFromPour(boardPolygon, polygonsToSubtract),
-      )
-      const pourIslands = crossSectionToCopperPourIslands(finalPour)
+      let pourPolygons: Flatten.Polygon | Flatten.Polygon[] = boardPolygon
 
-      if (process.env.COPPER_POUR_DEBUG_GEOMETRY) {
-        console.info(
-          JSON.stringify(
-            geometryDebugSummary(
-              "final copper polygons",
-              pourIslands.flatMap((island) => [
-                island.outerRing,
-                ...island.innerRings,
-              ]),
-            ),
-          ),
-        )
+      for (const poly of polygonsToSubtract) {
+        const currentPolys = Array.isArray(pourPolygons)
+          ? pourPolygons
+          : [pourPolygons]
+        const nextPolys: Flatten.Polygon[] = []
+        for (const p of currentPolys) {
+          const result = Flatten.BooleanOperations.subtract(p, poly)
+          if (result) {
+            if (Array.isArray(result)) {
+              nextPolys.push(...result.filter((r) => !r.isEmpty()))
+            } else {
+              if (!result.isEmpty()) nextPolys.push(result)
+            }
+          }
+        }
+        pourPolygons = nextPolys
       }
 
-      const new_breps = generateBRep(pourIslands)
+      const new_breps = generateBRep(pourPolygons)
       brep_shapes.push(...new_breps)
     }
 

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)
+}