@tscircuit/rectdiff 0.0.10 → 0.0.11

package/lib/RectDiffPipeline.ts

@@ -1,10 +1,15 @@
-import { BasePipelineSolver, definePipelineStep } from "@tscircuit/solver-utils"
+import {
+  BasePipelineSolver,
+  definePipelineStep,
+  type PipelineStep,
+} from "@tscircuit/solver-utils"
 import type { SimpleRouteJson } from "./types/srj-types"
 import type { GridFill3DOptions } from "./solvers/rectdiff/types"
 import { RectDiffSolver } from "./solvers/RectDiffSolver"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { createBaseVisualization } from "./solvers/rectdiff/visualization"
+import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
 
 export interface RectDiffPipelineInput {
   simpleRouteJson: SimpleRouteJson
@@ -13,15 +18,16 @@ export interface RectDiffPipelineInput {
 
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffSolver?: RectDiffSolver
+  gapFillSolver?: GapFillSolverPipeline
 
-  override pipelineDef = [
+  override pipelineDef: PipelineStep<any>[] = [
     definePipelineStep(
       "rectDiffSolver",
       RectDiffSolver,
-      (instance) => [
+      (rectDiffPipeline) => [
         {
-          simpleRouteJson: instance.inputProblem.simpleRouteJson,
-          gridOptions: instance.inputProblem.gridOptions,
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          gridOptions: rectDiffPipeline.inputProblem.gridOptions,
         },
       ],
       {
@@ -30,6 +36,16 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       },
     ),
+    definePipelineStep(
+      "gapFillSolver",
+      GapFillSolverPipeline,
+      (rectDiffPipeline: RectDiffPipeline) => [
+        {
+          meshNodes:
+            rectDiffPipeline.rectDiffSolver?.getOutput().meshNodes ?? [],
+        },
+      ],
+    ),
   ]
 
   override getConstructorParams() {
@@ -37,19 +53,69 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
-    return this.getSolver<RectDiffSolver>("rectDiffSolver")!.getOutput()
+    const gapFillOutput = this.gapFillSolver?.getOutput()
+    if (gapFillOutput) {
+      return { meshNodes: gapFillOutput.outputNodes }
+    }
+    return this.rectDiffSolver!.getOutput()
   }
 
-  override visualize(): GraphicsObject {
-    const solver = this.getSolver<RectDiffSolver>("rectDiffSolver")
-    if (solver) {
-      return solver.visualize()
+  override initialVisualize(): GraphicsObject {
+    console.log("RectDiffPipeline - initialVisualize")
+    const graphics = createBaseVisualization(
+      this.inputProblem.simpleRouteJson,
+      "RectDiffPipeline - Initial",
+    )
+
+    // Show initial mesh nodes from rectDiffSolver if available
+    const initialNodes = this.rectDiffSolver?.getOutput().meshNodes ?? []
+    for (const node of initialNodes) {
+      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"),
+      })
     }
 
-    // Show board and obstacles even before solver is initialized
-    return createBaseVisualization(
+    return graphics
+  }
+
+  override finalVisualize(): GraphicsObject {
+    const graphics = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
-      "RectDiff Pipeline (not started)",
+      "RectDiffPipeline - Final",
+    )
+
+    const { meshNodes: outputNodes } = this.getOutput()
+    const initialNodeIds = new Set(
+      (this.rectDiffSolver?.getOutput().meshNodes ?? []).map(
+        (n) => n.capacityMeshNodeId,
+      ),
     )
+
+    for (const node of outputNodes) {
+      const isExpanded = !initialNodeIds.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/ExpandEdgesToEmptySpaceSolver.ts

@@ -0,0 +1,284 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { SegmentWithAdjacentEmptySpace } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
+import type { GraphicsObject } from "graphics-debug"
+import RBush from "rbush"
+import { EDGE_MAP, EDGES } from "./edge-constants"
+import { getBoundsFromCorners } from "./getBoundsFromCorners"
+import type { Bounds } from "@tscircuit/math-utils"
+import { midpoint, segmentToBoxMinDistance } from "@tscircuit/math-utils"
+
+const EPS = 1e-4
+
+export interface ExpandedSegment {
+  segment: SegmentWithAdjacentEmptySpace
+  newNode: CapacityMeshNode
+}
+
+export class ExpandEdgesToEmptySpaceSolver extends BaseSolver {
+  unprocessedSegments: Array<SegmentWithAdjacentEmptySpace> = []
+  expandedSegments: Array<ExpandedSegment> = []
+
+  lastSegment: SegmentWithAdjacentEmptySpace | null = null
+  lastSearchBounds: Bounds | null = null
+  lastCollidingNodes: CapacityMeshNode[] | null = null
+  lastSearchCorner1: { x: number; y: number } | null = null
+  lastSearchCorner2: { x: number; y: number } | null = null
+  lastExpandedSegment: ExpandedSegment | null = null
+
+  rectSpatialIndex: RBush<CapacityMeshNode>
+
+  constructor(
+    private input: {
+      inputMeshNodes: CapacityMeshNode[]
+      segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>
+    },
+  ) {
+    super()
+    this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace]
+    this.rectSpatialIndex = new RBush<CapacityMeshNode>()
+    this.rectSpatialIndex.load(
+      this.input.inputMeshNodes.map((n) => ({
+        ...n,
+        minX: n.center.x - n.width / 2,
+        minY: n.center.y - n.height / 2,
+        maxX: n.center.x + n.width / 2,
+        maxY: n.center.y + n.height / 2,
+      })),
+    )
+  }
+
+  override _step() {
+    if (this.unprocessedSegments.length === 0) {
+      this.solved = true
+      return
+    }
+
+    const segment = this.unprocessedSegments.shift()!
+    this.lastSegment = segment
+
+    const { dx, dy } = EDGE_MAP[segment.facingDirection]
+
+    // Determine the largest empty space that can be created by creating a rect
+    // that grows in segment.facingDirection by progressively expanding the
+    // bounds that we search for empty space. As soon as any rect appears in our
+    // bounds we know the maximum size of the empty space that can be created.
+
+    const deltaStartEnd = {
+      x: segment.end.x - segment.start.x,
+      y: segment.end.y - segment.start.y,
+    }
+    const segLength = Math.sqrt(deltaStartEnd.x ** 2 + deltaStartEnd.y ** 2)
+    const normDeltaStartEnd = {
+      x: deltaStartEnd.x / segLength,
+      y: deltaStartEnd.y / segLength,
+    }
+
+    let collidingNodes: CapacityMeshNode[] | null = null
+    let searchDistance = 1
+    const searchCorner1 = {
+      x: segment.start.x + dx * EPS + normDeltaStartEnd.x * EPS * 10,
+      y: segment.start.y + dy * EPS + normDeltaStartEnd.y * EPS * 10,
+    }
+    const searchCorner2 = {
+      x: segment.end.x + dx * EPS - normDeltaStartEnd.x * EPS * 10,
+      y: segment.end.y + dy * EPS - normDeltaStartEnd.y * EPS * 10,
+    }
+    this.lastSearchCorner1 = searchCorner1
+    this.lastSearchCorner2 = searchCorner2
+    while (
+      (!collidingNodes || collidingNodes.length === 0) &&
+      searchDistance < 1000
+    ) {
+      const searchBounds = getBoundsFromCorners([
+        searchCorner1,
+        searchCorner2,
+        {
+          x: searchCorner1.x + dx * searchDistance,
+          y: searchCorner1.y + dy * searchDistance,
+        },
+        {
+          x: searchCorner2.x + dx * searchDistance,
+          y: searchCorner2.y + dy * searchDistance,
+        },
+      ])
+      this.lastSearchBounds = searchBounds
+      collidingNodes = this.rectSpatialIndex
+        .search(searchBounds)
+        .filter((n) => n.availableZ.includes(segment.z))
+        .filter(
+          (n) => n.capacityMeshNodeId !== segment.parent.capacityMeshNodeId,
+        )
+
+      searchDistance *= 4
+    }
+
+    if (!collidingNodes || collidingNodes.length === 0) {
+      // TODO, this means we need to expand the node to the boundary
+      return
+    }
+    this.lastCollidingNodes = collidingNodes
+
+    // Determine the expand distance from the colliding nodes
+    let smallestDistance = Infinity
+    for (const node of collidingNodes) {
+      const distance = segmentToBoxMinDistance(segment.start, segment.end, node)
+      if (distance < smallestDistance) {
+        smallestDistance = distance
+      }
+    }
+    const expandDistance = smallestDistance
+
+    const nodeBounds = getBoundsFromCorners([
+      segment.start,
+      segment.end,
+      {
+        x: segment.start.x + dx * expandDistance,
+        y: segment.start.y + dy * expandDistance,
+      },
+      {
+        x: segment.end.x + dx * expandDistance,
+        y: segment.end.y + dy * expandDistance,
+      },
+    ])
+    const nodeCenter = {
+      x: (nodeBounds.minX + nodeBounds.maxX) / 2,
+      y: (nodeBounds.minY + nodeBounds.maxY) / 2,
+    }
+    const nodeWidth = nodeBounds.maxX - nodeBounds.minX
+    const nodeHeight = nodeBounds.maxY - nodeBounds.minY
+
+    const expandedSegment = {
+      segment,
+      newNode: {
+        capacityMeshNodeId: `new-${segment.parent.capacityMeshNodeId}-${this.expandedSegments.length}`,
+        center: nodeCenter,
+        width: nodeWidth,
+        height: nodeHeight,
+        availableZ: [segment.z],
+        layer: segment.parent.layer,
+      },
+    }
+    this.lastExpandedSegment = expandedSegment
+
+    if (nodeWidth < EPS || nodeHeight < EPS) {
+      // Node is too small, skipping
+      return
+    }
+
+    this.expandedSegments.push(expandedSegment)
+    this.rectSpatialIndex.insert({
+      ...expandedSegment.newNode,
+      ...nodeBounds,
+    })
+  }
+
+  override getOutput() {
+    return {
+      expandedSegments: this.expandedSegments,
+    }
+  }
+
+  override visualize() {
+    const graphics: Required<GraphicsObject> = {
+      title: "ExpandEdgesToEmptySpace",
+      coordinateSystem: "cartesian" as const,
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: [],
+    }
+
+    // Draw capacity mesh nodes with gray, faded rects
+    for (const node of this.input.inputMeshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`,
+        ].join("\n"),
+      })
+    }
+
+    // for (const segment of this.unprocessedSegments) {
+    //   graphics.lines.push({
+    //     points: [segment.start, segment.end],
+    //     strokeColor: "rgba(0, 0, 255, 0.5)",
+    //   })
+    // }
+
+    for (const { newNode } of this.expandedSegments) {
+      graphics.rects.push({
+        center: newNode.center,
+        width: newNode.width,
+        height: newNode.height,
+        fill: "green",
+        label: `expandedSegment (z=${newNode.availableZ.join(",")})`,
+        layer: `z${newNode.availableZ.join(",")}`,
+      })
+    }
+
+    if (this.lastSegment) {
+      graphics.lines.push({
+        points: [this.lastSegment.start, this.lastSegment.end],
+        strokeColor: "rgba(0, 0, 255, 0.5)",
+      })
+    }
+
+    if (this.lastSearchBounds) {
+      graphics.rects.push({
+        center: {
+          x: (this.lastSearchBounds.minX + this.lastSearchBounds.maxX) / 2,
+          y: (this.lastSearchBounds.minY + this.lastSearchBounds.maxY) / 2,
+        },
+        width: this.lastSearchBounds.maxX - this.lastSearchBounds.minX,
+        height: this.lastSearchBounds.maxY - this.lastSearchBounds.minY,
+        fill: "rgba(0, 0, 255, 0.25)",
+      })
+    }
+
+    if (this.lastSearchCorner1 && this.lastSearchCorner2) {
+      graphics.points.push({
+        x: this.lastSearchCorner1.x,
+        y: this.lastSearchCorner1.y,
+        color: "rgba(0, 0, 255, 0.5)",
+        label: ["searchCorner1", `z=${this.lastSegment?.z}`].join("\n"),
+      })
+      graphics.points.push({
+        x: this.lastSearchCorner2.x,
+        y: this.lastSearchCorner2.y,
+        color: "rgba(0, 0, 255, 0.5)",
+        label: ["searchCorner2", `z=${this.lastSegment?.z}`].join("\n"),
+      })
+    }
+
+    if (this.lastExpandedSegment) {
+      graphics.rects.push({
+        center: this.lastExpandedSegment.newNode.center,
+        width: this.lastExpandedSegment.newNode.width,
+        height: this.lastExpandedSegment.newNode.height,
+        fill: "purple",
+        label: `expandedSegment (z=${this.lastExpandedSegment.segment.z})`,
+      })
+    }
+
+    if (this.lastCollidingNodes) {
+      for (const node of this.lastCollidingNodes) {
+        graphics.rects.push({
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          fill: "rgba(255, 0, 0, 0.5)",
+        })
+      }
+    }
+
+    return graphics
+  }
+}

package/lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts

@@ -0,0 +1,213 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import Flatbush from "flatbush"
+import type { GraphicsObject, NinePointAnchor } from "graphics-debug"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import { projectToUncoveredSegments } from "./projectToUncoveredSegments"
+import { EDGES } from "./edge-constants"
+import { visuallyOffsetLine } from "./visuallyOffsetLine"
+import { midpoint } from "@tscircuit/math-utils"
+
+export interface SegmentWithAdjacentEmptySpace {
+  parent: CapacityMeshNode
+  start: { x: number; y: number }
+  end: { x: number; y: number }
+  z: number
+  facingDirection: "x+" | "x-" | "y+" | "y-"
+}
+
+const EPS = 1e-4
+
+/**
+ * Find edges with adjacent empty space in the mesh
+ *
+ * Do this by iterating over each edge of the rect (each step is one edge)
+ * and checking if the is completely covered by any other edge
+ *
+ * If it is completely covered, then it doesn't have an adjacent empty space,
+ * continue
+ *
+ * If it is partially uncovered, then divide it into uncovered segments and add
+ * each uncovered segment as a new edge with an adjacent empty space
+ */
+export class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
+  allEdges: Array<SegmentWithAdjacentEmptySpace>
+  unprocessedEdges: Array<SegmentWithAdjacentEmptySpace> = []
+
+  segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace> = []
+
+  edgeSpatialIndex: Flatbush
+
+  lastCandidateEdge: SegmentWithAdjacentEmptySpace | null = null
+  lastOverlappingEdges: Array<SegmentWithAdjacentEmptySpace> | null = null
+  lastUncoveredSegments: Array<SegmentWithAdjacentEmptySpace> | null = null
+
+  constructor(
+    private input: {
+      meshNodes: CapacityMeshNode[]
+    },
+  ) {
+    super()
+    for (const node of this.input.meshNodes) {
+      for (const edge of EDGES) {
+        let start = {
+          x: node.center.x + node.width * edge.startX,
+          y: node.center.y + node.height * edge.startY,
+        }
+        let end = {
+          x: node.center.x + node.width * edge.endX,
+          y: node.center.y + node.height * edge.endY,
+        }
+
+        // Ensure start.x < end.x and if x is the same, ensure start.y < end.y
+        if (start.x > end.x) {
+          ;[start, end] = [end, start]
+        }
+        if (Math.abs(start.x - end.x) < EPS && start.y > end.y) {
+          ;[start, end] = [end, start]
+        }
+
+        for (const z of node.availableZ) {
+          this.unprocessedEdges.push({
+            parent: node,
+            start,
+            end,
+            facingDirection: edge.facingDirection,
+            z,
+          })
+        }
+      }
+    }
+    this.allEdges = [...this.unprocessedEdges]
+
+    this.edgeSpatialIndex = new Flatbush(this.allEdges.length)
+    for (const edge of this.allEdges) {
+      this.edgeSpatialIndex.add(
+        edge.start.x,
+        edge.start.y,
+        edge.end.x,
+        edge.end.y,
+      )
+    }
+    this.edgeSpatialIndex.finish()
+  }
+
+  override _step() {
+    if (this.unprocessedEdges.length === 0) {
+      this.solved = true
+      this.lastCandidateEdge = null
+      this.lastOverlappingEdges = null
+      this.lastUncoveredSegments = null
+      return
+    }
+
+    const candidateEdge = this.unprocessedEdges.shift()!
+    this.lastCandidateEdge = candidateEdge
+
+    // Find all edges that are nearby
+    const nearbyEdges = this.edgeSpatialIndex.search(
+      candidateEdge.start.x - EPS,
+      candidateEdge.start.y - EPS,
+      candidateEdge.end.x + EPS,
+      candidateEdge.end.y + EPS,
+    )
+
+    const overlappingEdges = nearbyEdges
+      .map((i) => this.allEdges[i]!)
+      .filter((e) => e.z === candidateEdge.z)
+    this.lastOverlappingEdges = overlappingEdges
+
+    const uncoveredSegments = projectToUncoveredSegments(
+      candidateEdge,
+      overlappingEdges,
+    )
+    this.lastUncoveredSegments = uncoveredSegments
+    this.segmentsWithAdjacentEmptySpace.push(...uncoveredSegments)
+  }
+
+  override getOutput(): {
+    segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>
+  } {
+    return {
+      segmentsWithAdjacentEmptySpace: this.segmentsWithAdjacentEmptySpace,
+    }
+  }
+
+  override visualize() {
+    const graphics: Required<GraphicsObject> = {
+      title: "FindSegmentsWithAdjacentEmptySpace",
+      coordinateSystem: "cartesian" as const,
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: [],
+    }
+
+    // Draw the capacity mesh nodes with gray, faded rects
+    for (const node of this.input.meshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.1)",
+      })
+    }
+
+    for (const unprocessedEdge of this.unprocessedEdges) {
+      graphics.lines.push({
+        points: visuallyOffsetLine(
+          [unprocessedEdge.start, unprocessedEdge.end],
+          unprocessedEdge.facingDirection,
+          -0.1,
+        ),
+        strokeColor: "rgba(0, 0, 255, 0.5)",
+        strokeDash: "5 5",
+      })
+    }
+
+    for (const edge of this.segmentsWithAdjacentEmptySpace) {
+      graphics.lines.push({
+        points: [edge.start, edge.end],
+        strokeColor: "rgba(0,255,0, 0.5)",
+      })
+    }
+
+    if (this.lastCandidateEdge) {
+      graphics.lines.push({
+        points: [this.lastCandidateEdge.start, this.lastCandidateEdge.end],
+        strokeColor: "blue",
+      })
+    }
+
+    if (this.lastOverlappingEdges) {
+      for (const edge of this.lastOverlappingEdges) {
+        graphics.lines.push({
+          points: visuallyOffsetLine(
+            [edge.start, edge.end],
+            edge.facingDirection,
+            0.05,
+          ),
+          strokeColor: "red",
+          strokeDash: "2 2",
+        })
+      }
+    }
+
+    if (this.lastUncoveredSegments) {
+      for (const edge of this.lastUncoveredSegments) {
+        graphics.lines.push({
+          points: visuallyOffsetLine(
+            [edge.start, edge.end],
+            edge.facingDirection,
+            -0.05,
+          ),
+          strokeColor: "green",
+          strokeDash: "2 2",
+        })
+      }
+    }
+
+    return graphics
+  }
+}