@tscircuit/copper-pour-solver 0.0.24 → 0.0.25

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

@@ -1,59 +1,52 @@
-import Flatten from "@flatten-js/core"
 import type { BRepShape } from "circuit-json"
+import type { CopperPourIsland, PolygonRing } from "./manifold-geometry-adapter"
+
+const signedArea = (ring: PolygonRing) => {
+  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
+}
+
+const ensureAreaSign = (
+  ring: PolygonRing,
+  desiredSign: "positive" | "negative",
+) => {
+  const area = signedArea(ring)
+  const shouldReverse =
+    (desiredSign === "positive" && area < 0) ||
+    (desiredSign === "negative" && area > 0)
+  return shouldReverse ? [...ring].reverse() : ring
+}
+
+const ringToVertices = (ring: PolygonRing) =>
+  ring.map((point) => ({
+    x: point.x,
+    y: point.y,
+  }))
 
-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[] => {
+export const generateBRep = (pourIslands: CopperPourIsland[]): 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,
-      })
-    }
+  for (const island of pourIslands) {
+    if (island.outerRing.length < 3) continue
+
+    // circuit-json BRep uses implicit closure. Keep the previous renderer-facing
+    // winding: outer rings have negative signed area, holes have positive area.
+    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

package/lib/solvers/copper-pour/get-board-polygon.ts

@@ -1,18 +1,12 @@
 import type { InputPourRegion } from "lib/types"
-import Flatten from "@flatten-js/core"
+import type { PolygonRing } from "./manifold-geometry-adapter"
+import { normalizeRing } from "./manifold-geometry-adapter"
 
-export const getBoardPolygon = (region: InputPourRegion): Flatten.Polygon => {
+export const getBoardPolygon = (region: InputPourRegion): PolygonRing => {
   const board_edge_margin = region.board_edge_margin ?? 0
 
   if (region.outline && region.outline.length > 0) {
-    const polygon = new Flatten.Polygon(
-      region.outline.map((p) => Flatten.point(p.x, p.y)),
-    )
-    // Ensure polygon is CCW for consistent boolean operations
-    if (polygon.orientation() === Flatten.ORIENTATION.CW) {
-      polygon.reverse()
-    }
-    return polygon
+    return normalizeRing(region.outline, "getBoardPolygon.outline")
   }
 
   const { bounds } = region
@@ -24,15 +18,13 @@ export const getBoardPolygon = (region: InputPourRegion): Flatten.Polygon => {
   }
 
   if (newBounds.minX >= newBounds.maxX || newBounds.minY >= newBounds.maxY) {
-    return new Flatten.Polygon()
+    return []
   }
 
-  return new Flatten.Polygon(
-    new Flatten.Box(
-      newBounds.minX,
-      newBounds.minY,
-      newBounds.maxX,
-      newBounds.maxY,
-    ).toPoints(),
-  )
+  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 },
+  ]
 }

package/lib/solvers/copper-pour/manifold-geometry-adapter.ts

@@ -0,0 +1,306 @@
+import type { Point } from "@tscircuit/math-utils"
+import type {
+  CrossSection as CrossSectionType,
+  FillRule,
+  SimplePolygon,
+} from "manifold-3d"
+
+const manifoldModule = await import("manifold-3d")
+const manifoldFactory = manifoldModule.default as unknown as () => Promise<{
+  CrossSection: typeof CrossSectionType
+  setup: () => void
+}>
+const manifold = await manifoldFactory()
+manifold.setup()
+
+const { CrossSection } = manifold
+
+export const MANIFOLD_GEOMETRY_SCALE = 1_000_000
+export const DEFAULT_MIN_ISLAND_AREA = 1e-8
+
+export type PolygonRing = Point[]
+type ScaledPolygons = SimplePolygon[]
+export type CopperPourIsland = {
+  outerRing: PolygonRing
+  innerRings: PolygonRing[]
+}
+
+const describePolygons = (polygons: ScaledPolygons) => {
+  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,
+  }
+}
+
+const assertFinitePoint = (point: Point, operation: string) => {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new Error(
+      `${operation} received non-finite point (${point.x}, ${point.y})`,
+    )
+  }
+}
+
+const pointsEqual = (a: Point, b: Point) => a.x === b.x && a.y === b.y
+
+const signedArea = (ring: PolygonRing) => {
+  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
+}
+
+export const normalizeRing = (
+  ring: PolygonRing,
+  operation = "normalizeRing",
+): PolygonRing => {
+  const normalized: PolygonRing = []
+
+  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(signedArea(normalized)) < 1e-18) {
+    return []
+  }
+
+  return normalized
+}
+
+// Manifold owns all robust 2D clipping/offsetting for copper-pour geometry.
+// This adapter keeps scaling, ring normalization, errors, and output grouping
+// out of the solver so the rest of the repo stays independent of WASM details.
+export const toScaledManifoldPolygons = (
+  polygons: PolygonRing[],
+  operation = "toScaledManifoldPolygons",
+): ScaledPolygons => {
+  const scaledPolygons: ScaledPolygons = []
+
+  for (const polygon of polygons) {
+    const normalized = normalizeRing(polygon, operation)
+    if (normalized.length < 3) continue
+    const positiveRing =
+      signedArea(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
+}
+
+export const fromScaledManifoldPolygons = (
+  polygons: SimplePolygon[],
+): PolygonRing[] =>
+  polygons
+    .map((polygon) =>
+      normalizeRing(
+        polygon.map(([x, y]) => ({
+          x: x / MANIFOLD_GEOMETRY_SCALE,
+          y: y / MANIFOLD_GEOMETRY_SCALE,
+        })),
+        "fromScaledManifoldPolygons",
+      ),
+    )
+    .filter((polygon) => polygon.length >= 3)
+
+const runManifoldOperation = <T>(
+  operation: string,
+  polygons: ScaledPolygons,
+  callback: () => T,
+): T => {
+  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)}`,
+    )
+  }
+}
+
+export const crossSectionFromPolygon = (
+  polygon: PolygonRing,
+  fillRule: FillRule = "Positive",
+): CrossSectionType => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    [polygon],
+    "crossSectionFromPolygon",
+  )
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([])
+  }
+  return runManifoldOperation("crossSectionFromPolygon", scaledPolygons, () =>
+    CrossSection.ofPolygons(scaledPolygons, fillRule),
+  )
+}
+
+export const crossSectionFromPolygons = (
+  polygons: PolygonRing[],
+  fillRule: FillRule = "Positive",
+): CrossSectionType => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    polygons,
+    "crossSectionFromPolygons",
+  )
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([])
+  }
+  return runManifoldOperation("crossSectionFromPolygons", scaledPolygons, () =>
+    CrossSection.ofPolygons(scaledPolygons, fillRule),
+  )
+}
+
+export const composeCrossSections = (
+  sections: CrossSectionType[],
+): CrossSectionType => {
+  const nonEmptySections = sections.filter((section) => !section.isEmpty())
+  if (nonEmptySections.length === 0) {
+    return CrossSection.ofPolygons([])
+  }
+  return runManifoldOperation("composeCrossSections", [], () =>
+    CrossSection.compose(nonEmptySections),
+  )
+}
+
+export const offsetPolygon = (
+  polygon: PolygonRing,
+  margin: number,
+  joinType: "Square" | "Round" | "Miter" = "Miter",
+): PolygonRing[] => {
+  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())
+}
+
+export const subtractBlockersFromPour = (
+  pourPolygon: PolygonRing,
+  blockerPolygons: PolygonRing[],
+): CrossSectionType => {
+  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),
+  )
+}
+
+export const removeTinyIslands = (
+  section: CrossSectionType,
+  minArea = DEFAULT_MIN_ISLAND_AREA,
+): CrossSectionType => {
+  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)
+}
+
+export const crossSectionToCopperPourIslands = (
+  section: CrossSectionType,
+): CopperPourIsland[] => {
+  const islands: CopperPourIsland[] = []
+
+  for (const island of section.decompose()) {
+    const rings = fromScaledManifoldPolygons(island.toPolygons())
+    if (rings.length === 0) continue
+
+    const outerRing = rings.reduce((largest, ring) =>
+      Math.abs(signedArea(ring)) > Math.abs(signedArea(largest))
+        ? ring
+        : largest,
+    )
+    const innerRings = rings.filter((ring) => ring !== outerRing)
+
+    islands.push({
+      outerRing,
+      innerRings,
+    })
+  }
+
+  return islands
+}
+
+export const geometryDebugSummary = (
+  label: string,
+  polygons: PolygonRing[],
+) => ({
+  label,
+  ...describePolygons(toScaledManifoldPolygons(polygons, label)),
+})

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

@@ -1,4 +1,3 @@
-import Flatten from "@flatten-js/core"
 import type { Point } from "@tscircuit/math-utils"
 import type {
   InputCircularPad,
@@ -7,10 +6,14 @@ import type {
   InputRectPad,
   InputTracePad,
 } from "lib/types"
-import { circleToPolygon } from "./circle-to-polygon"
+import {
+  normalizeRing,
+  offsetPolygon,
+  type PolygonRing,
+} from "./manifold-geometry-adapter"
 
 interface ProcessedObstacles {
-  polygonsToSubtract: Flatten.Polygon[]
+  polygonsToSubtract: PolygonRing[]
 }
 
 const isRectPad = (pad: InputPad): pad is InputRectPad => pad.shape === "rect"
@@ -21,6 +24,34 @@ const isCircularPad = (pad: InputPad): pad is InputCircularPad =>
 const isPolygonPad = (pad: InputPad): pad is InputPolygonPad =>
   pad.shape === "polygon"
 
+const circleToPolygon = (
+  center: Point,
+  radius: number,
+  numSegments = 32,
+): PolygonRing => {
+  const points: PolygonRing = []
+  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),
+    })
+  }
+  return points
+}
+
+const boxToPolygon = (
+  minX: number,
+  minY: number,
+  maxX: number,
+  maxY: number,
+): PolygonRing => [
+  { x: minX, y: minY },
+  { x: maxX, y: minY },
+  { x: maxX, y: maxY },
+  { x: minX, y: maxY },
+]
+
 export const processObstaclesForPour = (
   pads: InputPad[],
   pourConnectivityKey: string,
@@ -32,7 +63,7 @@ export const processObstaclesForPour = (
   },
   boardOutline?: Point[],
 ): ProcessedObstacles => {
-  const polygonsToSubtract: Flatten.Polygon[] = []
+  const polygonsToSubtract: PolygonRing[] = []
 
   const { padMargin, traceMargin, board_edge_margin, cutoutMargin } = margins
 
@@ -42,13 +73,10 @@ export const processObstaclesForPour = (
     board_edge_margin &&
     board_edge_margin > 0
   ) {
-    const boardPoly = new Flatten.Polygon(
-      boardOutline.map((p) => Flatten.point(p.x, p.y)),
+    const vertices = normalizeRing(
+      boardOutline,
+      "processObstacles.boardOutline",
     )
-    if (boardPoly.area() < 0) {
-      boardPoly.reverse()
-    }
-    const vertices = boardPoly.vertices
 
     // Add clearance shapes at vertices
     for (let i = 0; i < vertices.length; i++) {
@@ -58,21 +86,21 @@ export const processObstaclesForPour = (
 
       if (!p1 || !p2 || !p3) continue
 
-      const v1 = new Flatten.Vector(p1, p2)
-      const v2 = new Flatten.Vector(p2, p3)
-      const crossProduct = v1.cross(v2)
+      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
 
-      const circle = new Flatten.Circle(p2, board_edge_margin)
-      polygonsToSubtract.push(circleToPolygon(circle))
+      polygonsToSubtract.push(circleToPolygon(p2, board_edge_margin))
 
       if (crossProduct < 0) {
-        const box = new Flatten.Box(
-          p2.x - board_edge_margin,
-          p2.y - board_edge_margin,
-          p2.x + board_edge_margin,
-          p2.y + board_edge_margin,
+        polygonsToSubtract.push(
+          boxToPolygon(
+            p2.x - board_edge_margin,
+            p2.y - board_edge_margin,
+            p2.x + board_edge_margin,
+            p2.y + board_edge_margin,
+          ),
         )
-        polygonsToSubtract.push(new Flatten.Polygon(box.toPoints()))
       }
     }
 
@@ -111,9 +139,7 @@ export const processObstaclesForPour = (
         y: centerY + p.x * sinAngle + p.y * cosAngle,
       }))
 
-      polygonsToSubtract.push(
-        new Flatten.Polygon(rotatedCorners.map((p) => Flatten.point(p.x, p.y))),
-      )
+      polygonsToSubtract.push(rotatedCorners)
     }
   }
 
@@ -130,24 +156,23 @@ export const processObstaclesForPour = (
 
     if (isCircularPad(pad)) {
       const margin = isHoleOrCutout ? (cutoutMargin ?? 0) : padMargin
-      const circle = new Flatten.Circle(
-        new Flatten.Point(pad.x, pad.y),
-        pad.radius + margin,
+      polygonsToSubtract.push(
+        circleToPolygon({ x: pad.x, y: pad.y }, pad.radius + margin),
       )
-      polygonsToSubtract.push(circleToPolygon(circle))
       continue
     }
 
     if (isRectPad(pad)) {
       const margin = isHoleOrCutout ? (cutoutMargin ?? 0) : padMargin
       const { bounds } = pad
-      const b = new Flatten.Box(
-        bounds.minX - margin,
-        bounds.minY - margin,
-        bounds.maxX + margin,
-        bounds.maxY + margin,
+      polygonsToSubtract.push(
+        boxToPolygon(
+          bounds.minX - margin,
+          bounds.minY - margin,
+          bounds.maxX + margin,
+          bounds.maxY + margin,
+        ),
       )
-      polygonsToSubtract.push(new Flatten.Polygon(b.toPoints()))
       continue
     }
 
@@ -166,67 +191,24 @@ export const processObstaclesForPour = (
 
       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
+      const polygon = normalizeRing(uniquePoints, "processObstacles.polygonPad")
+      if (polygon.length < 3) 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))
-      }
+      polygonsToSubtract.push(...offsetPolygon(polygon, margin))
       continue
     }
 
     if (isTracePad(pad)) {
       // Add circles for each vertex
       for (const segment of pad.segments) {
-        const circle = new Flatten.Circle(
-          new Flatten.Point(segment.x, segment.y),
-          pad.width / 2 + traceMargin,
+        polygonsToSubtract.push(
+          circleToPolygon(segment, pad.width / 2 + traceMargin),
         )
-        polygonsToSubtract.push(circleToPolygon(circle))
       }
 
       // Add rectangles for each segment
@@ -265,11 +247,7 @@ export const processObstaclesForPour = (
           y: centerY + p.x * sinAngle + p.y * cosAngle,
         }))
 
-        polygonsToSubtract.push(
-          new Flatten.Polygon(
-            rotatedCorners.map((p) => Flatten.point(p.x, p.y)),
-          ),
-        )
+        polygonsToSubtract.push(rotatedCorners)
       }
     }
   }