@tscircuit/copper-pour-solver 0.0.26 → 0.0.28

package/lib/solvers/CopperPourPipelineSolver.ts

@@ -1,10 +1,15 @@
 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"
+import { generateBRep } from "./copper-pour/generate-brep"
+import { getBoardPolygon } from "./copper-pour/get-board-polygon"
+import {
+  crossSectionToCopperPourIslands,
+  removeTinyIslands,
+  subtractBlockersFromPour,
+} from "./copper-pour/manifold-geometry-adapter"
+import { isManifoldGeometryInitialized } from "./copper-pour/manifold-runtime"
+import { processObstaclesForPour } from "./copper-pour/process-obstacles"
 
 export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
   pipelineDef = []
@@ -17,6 +22,12 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
   }
 
   override getOutput(): PipelineOutput {
+    if (!isManifoldGeometryInitialized()) {
+      throw new Error(
+        "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours.",
+      )
+    }
+
     const brep_shapes: BRepShape[] = []
 
     for (const region of this.input.regionsForPour) {
@@ -38,27 +49,12 @@ export class CopperPourPipelineSolver extends BasePipelineSolver<InputProblem> {
         region.outline,
       )
 
-      let pourPolygons: Flatten.Polygon | Flatten.Polygon[] = boardPolygon
-
-      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 finalPour = removeTinyIslands(
+        subtractBlockersFromPour(boardPolygon, polygonsToSubtract),
+      )
+      const pourIslands = crossSectionToCopperPourIslands(finalPour)
 
-      const new_breps = generateBRep(pourPolygons)
+      const new_breps = generateBRep(pourIslands)
       brep_shapes.push(...new_breps)
     }
 

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

@@ -1,59 +1,43 @@
-import Flatten from "@flatten-js/core"
 import type { BRepShape } from "circuit-json"
+import type { CopperPourIsland } from "./manifold-geometry-adapter"
+import { signedArea, type PolygonRing } from "./polygon-ring"
+
+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 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
-  })
+const ringToVertices = (ring: PolygonRing) =>
+  ring.map((point) => ({
+    x: point.x,
+    y: point.y,
+  }))
 
-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,11 @@
 import type { InputPourRegion } from "lib/types"
-import Flatten from "@flatten-js/core"
+import { normalizeRing, type PolygonRing } from "./polygon-ring"
 
-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 +17,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,159 @@
+import type { FillRule } from "manifold-3d"
+import {
+  getCrossSection,
+  runManifoldOperation,
+  type CrossSection,
+} from "./manifold-runtime"
+import {
+  fromScaledManifoldPolygons,
+  MANIFOLD_GEOMETRY_SCALE,
+  normalizeRing,
+  signedArea,
+  toScaledManifoldPolygons,
+  type PolygonRing,
+} from "./polygon-ring"
+
+export const DEFAULT_MIN_ISLAND_AREA = 1e-8
+
+export type CopperPourIsland = {
+  outerRing: PolygonRing
+  innerRings: PolygonRing[]
+}
+
+export const crossSectionFromPolygon = (
+  polygon: PolygonRing,
+  fillRule: FillRule = "Positive",
+): CrossSection => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    [polygon],
+    "crossSectionFromPolygon",
+  )
+  const CrossSection = getCrossSection()
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([])
+  }
+  return runManifoldOperation("crossSectionFromPolygon", scaledPolygons, () =>
+    CrossSection.ofPolygons(scaledPolygons, fillRule),
+  )
+}
+
+export const crossSectionFromPolygons = (
+  polygons: PolygonRing[],
+  fillRule: FillRule = "Positive",
+): CrossSection => {
+  const scaledPolygons = toScaledManifoldPolygons(
+    polygons,
+    "crossSectionFromPolygons",
+  )
+  const CrossSection = getCrossSection()
+  if (scaledPolygons.length === 0) {
+    return CrossSection.ofPolygons([])
+  }
+  return runManifoldOperation("crossSectionFromPolygons", scaledPolygons, () =>
+    CrossSection.ofPolygons(scaledPolygons, fillRule),
+  )
+}
+
+export const composeCrossSections = (
+  sections: CrossSection[],
+): CrossSection => {
+  const nonEmptySections = sections.filter((section) => !section.isEmpty())
+  const CrossSection = getCrossSection()
+  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 CrossSection = getCrossSection()
+  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[],
+): CrossSection => {
+  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: CrossSection,
+  minArea = DEFAULT_MIN_ISLAND_AREA,
+): CrossSection => {
+  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: CrossSection,
+): 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
+}

package/lib/solvers/copper-pour/manifold-runtime.ts

@@ -0,0 +1,51 @@
+import type {
+  CrossSection as CrossSectionType,
+  ManifoldToplevel,
+} from "manifold-3d"
+import {
+  getManifoldModule,
+  getManifoldModuleSync,
+} from "manifold-3d/lib/wasm.js"
+import { describeScaledPolygons, type ScaledPolygons } from "./polygon-ring"
+
+let manifoldModulePromise: Promise<ManifoldToplevel> | null = null
+
+export const initializeManifoldGeometry = async () => {
+  if (getManifoldModuleSync()) return
+  manifoldModulePromise ??= getManifoldModule().catch((error) => {
+    manifoldModulePromise = null
+    throw error
+  })
+  await manifoldModulePromise
+}
+
+export const isManifoldGeometryInitialized = () =>
+  Boolean(getManifoldModuleSync())
+
+export const getCrossSection = () => {
+  const manifold = getManifoldModuleSync()
+  if (!manifold) {
+    throw new Error(
+      "Manifold geometry has not been initialized. Call initializeManifoldGeometry() before solving copper pours.",
+    )
+  }
+  return manifold.CrossSection
+}
+
+export const runManifoldOperation = <T>(
+  operation: string,
+  polygons: ScaledPolygons,
+  callback: () => T,
+): T => {
+  try {
+    return callback()
+  } catch (error) {
+    const details = describeScaledPolygons(polygons)
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(
+      `${operation} failed: ${message}; details=${JSON.stringify(details)}`,
+    )
+  }
+}
+
+export type CrossSection = CrossSectionType

package/lib/solvers/copper-pour/polygon-primitives.ts

@@ -0,0 +1,57 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { PolygonRing } from "./polygon-ring"
+
+export 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
+}
+
+export 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 segmentToPolygon = (
+  start: Point,
+  end: Point,
+  width: number,
+): PolygonRing => {
+  const segmentLength = Math.hypot(start.x - end.x, start.y - end.y)
+  if (segmentLength === 0) return []
+
+  const centerX = (start.x + end.x) / 2
+  const centerY = (start.y + end.y) / 2
+  const angle = Math.atan2(end.y - start.y, end.x - start.x)
+  const cosAngle = Math.cos(angle)
+  const sinAngle = Math.sin(angle)
+  const halfLength = segmentLength / 2
+  const halfWidth = width / 2
+
+  return [
+    { x: -halfLength, y: -halfWidth },
+    { x: halfLength, y: -halfWidth },
+    { x: halfLength, y: halfWidth },
+    { x: -halfLength, y: halfWidth },
+  ].map((point) => ({
+    x: centerX + point.x * cosAngle - point.y * sinAngle,
+    y: centerY + point.x * sinAngle + point.y * cosAngle,
+  }))
+}

package/lib/solvers/copper-pour/polygon-ring.ts

@@ -0,0 +1,126 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SimplePolygon } from "manifold-3d"
+
+export const MANIFOLD_GEOMETRY_SCALE = 1_000_000
+
+export type PolygonRing = Point[]
+export type ScaledPolygons = SimplePolygon[]
+
+export 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 describeScaledPolygons = (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
+
+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
+}
+
+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)