@tscircuit/rectdiff 0.0.9 → 0.0.11

package/lib/solvers/GapFillSolver/GapFillSolverPipeline.ts

@@ -0,0 +1,129 @@
+import {
+  BasePipelineSolver,
+  definePipelineStep,
+  type PipelineStep,
+} from "@tscircuit/solver-utils"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { GraphicsObject } from "graphics-debug"
+import { FindSegmentsWithAdjacentEmptySpaceSolver } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
+import { ExpandEdgesToEmptySpaceSolver } from "./ExpandEdgesToEmptySpaceSolver"
+
+export class GapFillSolverPipeline extends BasePipelineSolver<{
+  meshNodes: CapacityMeshNode[]
+}> {
+  findSegmentsWithAdjacentEmptySpaceSolver?: FindSegmentsWithAdjacentEmptySpaceSolver
+  expandEdgesToEmptySpaceSolver?: ExpandEdgesToEmptySpaceSolver
+
+  override pipelineDef: PipelineStep<any>[] = [
+    definePipelineStep(
+      "findSegmentsWithAdjacentEmptySpaceSolver",
+      FindSegmentsWithAdjacentEmptySpaceSolver,
+      (gapFillPipeline) => [
+        {
+          meshNodes: gapFillPipeline.inputProblem.meshNodes,
+        },
+      ],
+      {
+        onSolved: () => {
+          // Gap fill solver completed
+        },
+      },
+    ),
+    definePipelineStep(
+      "expandEdgesToEmptySpace",
+      ExpandEdgesToEmptySpaceSolver,
+      (gapFillPipeline: GapFillSolverPipeline) => [
+        {
+          inputMeshNodes: gapFillPipeline.inputProblem.meshNodes,
+          segmentsWithAdjacentEmptySpace:
+            gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver!.getOutput()
+              .segmentsWithAdjacentEmptySpace,
+        },
+      ],
+      {
+        onSolved: () => {
+          // Gap fill solver completed
+        },
+      },
+    ),
+  ] as const
+
+  override getOutput(): { outputNodes: CapacityMeshNode[] } {
+    const expandedSegments =
+      this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? []
+    const expandedNodes = expandedSegments.map((es) => es.newNode)
+
+    return {
+      outputNodes: [...this.inputProblem.meshNodes, ...expandedNodes],
+    }
+  }
+
+  override initialVisualize(): GraphicsObject {
+    const graphics: Required<GraphicsObject> = {
+      title: "GapFillSolverPipeline - Initial",
+      coordinateSystem: "cartesian" as const,
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: [],
+    }
+
+    for (const node of this.inputProblem.meshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.3)",
+        fill: "rgba(100, 100, 100, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`,
+        ].join("\n"),
+      })
+    }
+
+    return graphics
+  }
+
+  override finalVisualize(): GraphicsObject {
+    const graphics: Required<GraphicsObject> = {
+      title: "GapFillSolverPipeline - Final",
+      coordinateSystem: "cartesian" as const,
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: [],
+    }
+
+    const { outputNodes } = this.getOutput()
+    const expandedSegments =
+      this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? []
+    const expandedNodeIds = new Set(
+      expandedSegments.map((es) => es.newNode.capacityMeshNodeId),
+    )
+
+    for (const node of outputNodes) {
+      const isExpanded = expandedNodeIds.has(node.capacityMeshNodeId)
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
+        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`,
+        ].join("\n"),
+      })
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/GapFillSolver/edge-constants.ts

@@ -0,0 +1,48 @@
+/**
+ * The four normalized edges of a rect
+ */
+export const EDGES = [
+  {
+    facingDirection: "x-",
+    dx: -1,
+    dy: 0,
+    startX: -0.5,
+    startY: 0.5,
+    endX: -0.5,
+    endY: -0.5,
+  },
+  {
+    facingDirection: "x+",
+    dx: 1,
+    dy: 0,
+    startX: 0.5,
+    startY: 0.5,
+    endX: 0.5,
+    endY: -0.5,
+  },
+  {
+    facingDirection: "y-",
+    dx: 0,
+    dy: -1,
+    startX: -0.5,
+    startY: -0.5,
+    endX: 0.5,
+    endY: -0.5,
+  },
+  {
+    facingDirection: "y+",
+    dx: 0,
+    dy: 1,
+    startX: 0.5,
+    startY: 0.5,
+    endX: -0.5,
+    endY: 0.5,
+  },
+] as const
+
+export const EDGE_MAP = {
+  "x-": EDGES.find((e) => e.facingDirection === "x-")!,
+  "x+": EDGES.find((e) => e.facingDirection === "x+")!,
+  "y-": EDGES.find((e) => e.facingDirection === "y-")!,
+  "y+": EDGES.find((e) => e.facingDirection === "y+")!,
+} as const

package/lib/solvers/GapFillSolver/getBoundsFromCorners.ts

@@ -0,0 +1,10 @@
+export const getBoundsFromCorners = (
+  corners: { x: number; y: number }[],
+): { minX: number; minY: number; maxX: number; maxY: number } => {
+  return {
+    minX: Math.min(...corners.map((c) => c.x)),
+    minY: Math.min(...corners.map((c) => c.y)),
+    maxX: Math.max(...corners.map((c) => c.x)),
+    maxY: Math.max(...corners.map((c) => c.y)),
+  }
+}

package/lib/solvers/GapFillSolver/projectToUncoveredSegments.ts

@@ -0,0 +1,92 @@
+import type { SegmentWithAdjacentEmptySpace } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
+
+const EPS = 1e-4
+
+export function projectToUncoveredSegments(
+  primaryEdge: SegmentWithAdjacentEmptySpace,
+  overlappingEdges: SegmentWithAdjacentEmptySpace[],
+): Array<SegmentWithAdjacentEmptySpace> {
+  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS
+  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS
+  if (!isHorizontal && !isVertical) return []
+
+  const axis: "x" | "y" = isHorizontal ? "x" : "y"
+  const perp: "x" | "y" = isHorizontal ? "y" : "x"
+  const lineCoord = primaryEdge.start[perp]
+
+  const p0 = primaryEdge.start[axis]
+  const p1 = primaryEdge.end[axis]
+  const pMin = Math.min(p0, p1)
+  const pMax = Math.max(p0, p1)
+
+  const clamp = (v: number) => Math.max(pMin, Math.min(pMax, v))
+
+  // 1) project each overlapping edge to an interval on the primary edge
+  const intervals: Array<{ s: number; e: number }> = []
+  for (const e of overlappingEdges) {
+    if (e === primaryEdge) continue
+
+    // only consider edges parallel + colinear (within EPS) with the primary edge
+    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS
+    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS
+    if (axis === "x" && !eIsHorizontal) continue
+    if (axis === "y" && !eIsVertical) continue
+    if (Math.abs(e.start[perp] - lineCoord) > EPS) continue
+
+    const eMin = Math.min(e.start[axis], e.end[axis])
+    const eMax = Math.max(e.start[axis], e.end[axis])
+
+    const s = clamp(eMin)
+    const t = clamp(eMax)
+    if (t - s > EPS) intervals.push({ s, e: t })
+  }
+
+  if (intervals.length === 0) {
+    // nothing covers the primary edge -> entire edge is uncovered
+    return [
+      {
+        ...primaryEdge,
+        start: { ...primaryEdge.start },
+        end: { ...primaryEdge.end },
+      },
+    ]
+  }
+
+  // 2) merge cover intervals
+  intervals.sort((a, b) => a.s - b.s)
+  const merged: Array<{ s: number; e: number }> = []
+  for (const it of intervals) {
+    const last = merged[merged.length - 1]
+    if (!last || it.s > last.e + EPS) merged.push({ ...it })
+    else last.e = Math.max(last.e, it.e)
+  }
+
+  // 3) compute uncovered intervals (complement of merged within [pMin,pMax])
+  const uncovered: Array<{ s: number; e: number }> = []
+  let cursor = pMin
+  for (const m of merged) {
+    if (m.s > cursor + EPS) uncovered.push({ s: cursor, e: m.s })
+    cursor = Math.max(cursor, m.e)
+    if (cursor >= pMax - EPS) break
+  }
+  if (pMax > cursor + EPS) uncovered.push({ s: cursor, e: pMax })
+  if (uncovered.length === 0) return []
+
+  // 4) convert uncovered intervals back to segments on the primary edge
+  return uncovered
+    .filter((u) => u.e - u.s > EPS)
+    .map((u) => {
+      const start =
+        axis === "x" ? { x: u.s, y: lineCoord } : { x: lineCoord, y: u.s }
+      const end =
+        axis === "x" ? { x: u.e, y: lineCoord } : { x: lineCoord, y: u.e }
+
+      return {
+        parent: primaryEdge.parent,
+        facingDirection: primaryEdge.facingDirection,
+        start,
+        end,
+        z: primaryEdge.z,
+      }
+    })
+}

package/lib/solvers/GapFillSolver/visuallyOffsetLine.ts

@@ -0,0 +1,32 @@
+const OFFSET_DIR_MAP = {
+  "x-": {
+    x: -1,
+    y: 0,
+  },
+  "x+": {
+    x: 1,
+    y: 0,
+  },
+  "y-": {
+    x: 0,
+    y: -1,
+  },
+  "y+": {
+    x: 0,
+    y: 1,
+  },
+} as const
+/**
+ * Visually offset a line by a given amount in a given direction
+ */
+export const visuallyOffsetLine = (
+  line: Array<{ x: number; y: number }>,
+  dir: "x-" | "x+" | "y-" | "y+",
+  amt: number,
+) => {
+  const offset = OFFSET_DIR_MAP[dir]
+  return line.map((p) => ({
+    x: p.x + offset.x * amt,
+    y: p.y + offset.y * amt,
+  }))
+}

package/lib/solvers/RectDiffSolver.ts

@@ -14,11 +14,6 @@ import {
 } from "./rectdiff/engine"
 import { rectsToMeshNodes } from "./rectdiff/rectsToMeshNodes"
 import { overlaps } from "./rectdiff/geometry"
-import type { GapFillOptions } from "./rectdiff/gapfill/types"
-import {
-  findUncoveredPoints,
-  calculateCoverage,
-} from "./rectdiff/gapfill/engine"
 
 /**
  * A streaming, one-step-per-iteration solver for capacity mesh generation.
@@ -82,34 +77,6 @@ export class RectDiffSolver extends BaseSolver {
     return { meshNodes: this._meshNodes }
   }
 
-  /** Get coverage percentage (0-1). */
-  getCoverage(sampleResolution: number = 0.05): number {
-    return calculateCoverage(
-      { sampleResolution },
-      {
-        bounds: this.state.bounds,
-        layerCount: this.state.layerCount,
-        obstaclesByLayer: this.state.obstaclesByLayer,
-        placedByLayer: this.state.placedByLayer,
-      },
-    )
-  }
-
-  /** Find uncovered points for debugging gaps. */
-  getUncoveredPoints(
-    sampleResolution: number = 0.05,
-  ): Array<{ x: number; y: number; z: number }> {
-    return findUncoveredPoints(
-      { sampleResolution },
-      {
-        bounds: this.state.bounds,
-        layerCount: this.state.layerCount,
-        obstaclesByLayer: this.state.obstaclesByLayer,
-        placedByLayer: this.state.placedByLayer,
-      },
-    )
-  }
-
   /** Get color based on z layer for visualization. */
   private getColorForZLayer(zLayers: number[]): {
     fill: string
@@ -244,6 +211,7 @@ export class RectDiffSolver extends BaseSolver {
           height: p.rect.height,
           fill: colors.fill,
           stroke: colors.stroke,
+          layer: `z${p.zLayers.join(",")}`,
           label: `free\nz:${p.zLayers.join(",")}`,
         })
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
@@ -13,14 +13,17 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.5",
     "@react-hook/resize-observer": "^2.0.2",
-    "@tscircuit/solver-utils": "^0.0.7",
+    "@tscircuit/math-utils": "^0.0.29",
+    "@tscircuit/solver-utils": "^0.0.9",
     "@types/bun": "latest",
+    "@types/rbush": "^4.0.0",
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "@types/three": "^0.181.0",
+    "@vitejs/plugin-react": "^4",
     "biome": "^0.3.3",
     "bun-match-svg": "^0.0.14",
-    "graphics-debug": "^0.0.70",
+    "graphics-debug": "^0.0.76",
     "rbush": "^4.0.1",
     "react": "18",
     "react-cosmos": "^6.2.3",
@@ -28,13 +31,13 @@
     "react-dom": "18",
     "three": "^0.181.1",
     "tsup": "^8.5.1",
-    "vite": "^6.0.11",
-    "@vitejs/plugin-react": "^4"
+    "vite": "^6.0.11"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
-    "D": "^1.0.0"
+    "D": "^1.0.0",
+    "flatbush": "^4.5.0"
   }
 }

package/tests/board-outline.test.ts

@@ -11,7 +11,7 @@ test("board outline snapshot", async () => {
   // Run to completion
   solver.solve()
 
-  const viz = solver.visualize()
+  const viz = solver.rectDiffSolver!.visualize()
   const svg = getSvgFromGraphicsObject(viz)
 
   await expect(svg).toMatchSvgSnapshot(import.meta.path)

package/tsconfig.json

@@ -7,6 +7,10 @@
     "moduleDetection": "force",
     "jsx": "react-jsx",
     "allowJs": true,
+    "paths": {
+      "lib/*": ["./lib/*"]
+    },
+    "baseUrl": ".",
 
     // Bundler mode
     "moduleResolution": "bundler",

package/vite.config.ts

@@ -1,7 +1,13 @@
 import { defineConfig } from "vite"
+import path from "node:path"
 import react from "@vitejs/plugin-react"
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [react()],
+  resolve: {
+    alias: {
+      lib: path.resolve(__dirname, "lib"),
+    },
+  },
 })

package/lib/solvers/rectdiff/gapfill/detection/deduplicateGaps.ts

@@ -1,28 +0,0 @@
-// lib/solvers/rectdiff/gapfill/detection/deduplicateGaps.ts
-import { rectsEqual } from "../../../../../utils/rectsEqual"
-import { rectsOverlap } from "../../../../../utils/rectsOverlap"
-import type { GapRegion } from "../types"
-
-export function deduplicateGaps(gaps: GapRegion[]): GapRegion[] {
-  const result: GapRegion[] = []
-
-  for (const gap of gaps) {
-    // Check if we already have a gap at the same location with overlapping layers
-    const existing = result.find(
-      (g) =>
-        rectsEqual(g.rect, gap.rect) ||
-        (rectsOverlap(g.rect, gap.rect) &&
-          gap.zLayers.some((z) => g.zLayers.includes(z))),
-    )
-
-    if (!existing) {
-      result.push(gap)
-    } else if (gap.zLayers.length > existing.zLayers.length) {
-      // Replace with the one that has more layers
-      const idx = result.indexOf(existing)
-      result[idx] = gap
-    }
-  }
-
-  return result
-}

package/lib/solvers/rectdiff/gapfill/detection/findAllGaps.ts

@@ -1,83 +0,0 @@
-// lib/solvers/rectdiff/gapfill/detection/findAllGaps.ts
-import type { XYRect } from "../../types"
-import type { GapRegion, LayerContext } from "../types"
-import { EPS } from "../../geometry"
-import { findGapsOnLayer } from "./findGapsOnLayer"
-import { rectsOverlap } from "../../../../../utils/rectsOverlap"
-import { deduplicateGaps } from "./deduplicateGaps"
-
-/**
- * Find gaps across all layers and return GapRegions with z-layer info.
- */
-export function findAllGaps(
-  {
-    scanResolution,
-    minWidth,
-    minHeight,
-  }: {
-    scanResolution: number
-    minWidth: number
-    minHeight: number
-  },
-  ctx: LayerContext,
-): GapRegion[] {
-  const { bounds, layerCount, obstaclesByLayer, placedByLayer } = ctx
-
-  // Find gaps on each layer
-  const gapsByLayer: XYRect[][] = []
-  for (let z = 0; z < layerCount; z++) {
-    const obstacles = obstaclesByLayer[z] ?? []
-    const placed = placedByLayer[z] ?? []
-    const gaps = findGapsOnLayer({ bounds, obstacles, placed, scanResolution })
-    gapsByLayer.push(gaps)
-  }
-
-  // Convert to GapRegions with z-layer info
-  const allGaps: GapRegion[] = []
-
-  for (let z = 0; z < layerCount; z++) {
-    for (const gap of gapsByLayer[z]!) {
-      // Filter out gaps that are too small
-      if (gap.width < minWidth - EPS || gap.height < minHeight - EPS) continue
-
-      // Check if this gap exists on adjacent layers too
-      const zLayers = [z]
-
-      // Look up
-      for (let zu = z + 1; zu < layerCount; zu++) {
-        const hasOverlap = gapsByLayer[zu]!.some((g) => rectsOverlap(g, gap))
-        if (hasOverlap) zLayers.push(zu)
-        else break
-      }
-
-      // Look down (if z > 0 and not already counted)
-      for (let zd = z - 1; zd >= 0; zd--) {
-        const hasOverlap = gapsByLayer[zd]!.some((g) => rectsOverlap(g, gap))
-        if (hasOverlap && !zLayers.includes(zd)) zLayers.unshift(zd)
-        else break
-      }
-
-      allGaps.push({
-        rect: gap,
-        zLayers: zLayers.sort((a, b) => a - b),
-        centerX: gap.x + gap.width / 2,
-        centerY: gap.y + gap.height / 2,
-        area: gap.width * gap.height,
-      })
-    }
-  }
-
-  // Deduplicate gaps that are essentially the same across layers
-  const deduped = deduplicateGaps(allGaps)
-
-  // Sort by priority: prefer larger gaps and multi-layer gaps
-  deduped.sort((a, b) => {
-    // Prefer multi-layer gaps
-    const layerDiff = b.zLayers.length - a.zLayers.length
-    if (layerDiff !== 0) return layerDiff
-    // Then prefer larger area
-    return b.area - a.area
-  })
-
-  return deduped
-}

package/lib/solvers/rectdiff/gapfill/detection/findGapsOnLayer.ts

@@ -1,100 +0,0 @@
-// lib/solvers/rectdiff/gapfill/detection/findGapsOnLayer.ts
-import type { XYRect } from "../../types"
-import { EPS } from "../../geometry"
-
-import { mergeUncoveredCells } from "./mergeUncoveredCells"
-
-/**
- * Sweep-line algorithm to find maximal uncovered rectangles on a single layer.
- */
-export function findGapsOnLayer({
-  bounds,
-  obstacles,
-  placed,
-  scanResolution,
-}: {
-  bounds: XYRect
-  obstacles: XYRect[]
-  placed: XYRect[]
-  scanResolution: number
-}): XYRect[] {
-  const blockers = [...obstacles, ...placed]
-
-  // Collect all unique x-coordinates
-  const xCoords = new Set<number>()
-  xCoords.add(bounds.x)
-  xCoords.add(bounds.x + bounds.width)
-
-  for (const b of blockers) {
-    if (b.x > bounds.x && b.x < bounds.x + bounds.width) {
-      xCoords.add(b.x)
-    }
-    if (b.x + b.width > bounds.x && b.x + b.width < bounds.x + bounds.width) {
-      xCoords.add(b.x + b.width)
-    }
-  }
-
-  // Also add intermediate points based on scan resolution
-  for (let x = bounds.x; x <= bounds.x + bounds.width; x += scanResolution) {
-    xCoords.add(x)
-  }
-
-  const sortedX = Array.from(xCoords).sort((a, b) => a - b)
-
-  // Similarly for y-coordinates
-  const yCoords = new Set<number>()
-  yCoords.add(bounds.y)
-  yCoords.add(bounds.y + bounds.height)
-
-  for (const b of blockers) {
-    if (b.y > bounds.y && b.y < bounds.y + bounds.height) {
-      yCoords.add(b.y)
-    }
-    if (
-      b.y + b.height > bounds.y &&
-      b.y + b.height < bounds.y + bounds.height
-    ) {
-      yCoords.add(b.y + b.height)
-    }
-  }
-
-  for (let y = bounds.y; y <= bounds.y + bounds.height; y += scanResolution) {
-    yCoords.add(y)
-  }
-
-  const sortedY = Array.from(yCoords).sort((a, b) => a - b)
-
-  // Build a grid of cells and mark which are uncovered
-  const uncoveredCells: Array<{ x: number; y: number; w: number; h: number }> =
-    []
-
-  for (let i = 0; i < sortedX.length - 1; i++) {
-    for (let j = 0; j < sortedY.length - 1; j++) {
-      const cellX = sortedX[i]!
-      const cellY = sortedY[j]!
-      const cellW = sortedX[i + 1]! - cellX
-      const cellH = sortedY[j + 1]! - cellY
-
-      if (cellW <= EPS || cellH <= EPS) continue
-
-      // Check if this cell is covered by any blocker
-      const cellCenterX = cellX + cellW / 2
-      const cellCenterY = cellY + cellH / 2
-
-      const isCovered = blockers.some(
-        (b) =>
-          cellCenterX >= b.x - EPS &&
-          cellCenterX <= b.x + b.width + EPS &&
-          cellCenterY >= b.y - EPS &&
-          cellCenterY <= b.y + b.height + EPS,
-      )
-
-      if (!isCovered) {
-        uncoveredCells.push({ x: cellX, y: cellY, w: cellW, h: cellH })
-      }
-    }
-  }
-
-  // Merge adjacent uncovered cells into maximal rectangles
-  return mergeUncoveredCells(uncoveredCells)
-}