@tscircuit/rectdiff 0.0.10 → 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

@@ -211,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.10",
+  "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"),
+    },
+  },
 })