@tscircuit/rectdiff 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import * as _tscircuit_solver_utils from '@tscircuit/solver-utils';
-import { BaseSolver, BasePipelineSolver } from '@tscircuit/solver-utils';
+import { BaseSolver, BasePipelineSolver, PipelineStep } from '@tscircuit/solver-utils';
 import { GraphicsObject } from 'graphics-debug';
+import Flatbush from 'flatbush';
+import RBush from 'rbush';
+import { Bounds } from '@tscircuit/math-utils';
 
 type TraceId = string;
 interface SimpleRouteJson {
@@ -107,32 +109,115 @@ declare class RectDiffSolver extends BaseSolver {
     getOutput(): {
         meshNodes: CapacityMeshNode[];
     };
-    /** Get coverage percentage (0-1). */
-    getCoverage(sampleResolution?: number): number;
-    /** Find uncovered points for debugging gaps. */
-    getUncoveredPoints(sampleResolution?: number): Array<{
-        x: number;
-        y: number;
-        z: number;
-    }>;
     /** Get color based on z layer for visualization. */
     private getColorForZLayer;
     /** Streaming visualization: board + obstacles + current placements. */
     visualize(): GraphicsObject;
 }
 
+interface SegmentWithAdjacentEmptySpace {
+    parent: CapacityMeshNode;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    z: number;
+    facingDirection: "x+" | "x-" | "y+" | "y-";
+}
+/**
+ * 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
+ */
+declare class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
+    private input;
+    allEdges: Array<SegmentWithAdjacentEmptySpace>;
+    unprocessedEdges: Array<SegmentWithAdjacentEmptySpace>;
+    segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
+    edgeSpatialIndex: Flatbush;
+    lastCandidateEdge: SegmentWithAdjacentEmptySpace | null;
+    lastOverlappingEdges: Array<SegmentWithAdjacentEmptySpace> | null;
+    lastUncoveredSegments: Array<SegmentWithAdjacentEmptySpace> | null;
+    constructor(input: {
+        meshNodes: CapacityMeshNode[];
+    });
+    _step(): void;
+    getOutput(): {
+        segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
+    };
+    visualize(): Required<GraphicsObject>;
+}
+
+interface ExpandedSegment {
+    segment: SegmentWithAdjacentEmptySpace;
+    newNode: CapacityMeshNode;
+}
+declare class ExpandEdgesToEmptySpaceSolver extends BaseSolver {
+    private input;
+    unprocessedSegments: Array<SegmentWithAdjacentEmptySpace>;
+    expandedSegments: Array<ExpandedSegment>;
+    lastSegment: SegmentWithAdjacentEmptySpace | null;
+    lastSearchBounds: Bounds | null;
+    lastCollidingNodes: CapacityMeshNode[] | null;
+    lastSearchCorner1: {
+        x: number;
+        y: number;
+    } | null;
+    lastSearchCorner2: {
+        x: number;
+        y: number;
+    } | null;
+    lastExpandedSegment: ExpandedSegment | null;
+    rectSpatialIndex: RBush<CapacityMeshNode>;
+    constructor(input: {
+        inputMeshNodes: CapacityMeshNode[];
+        segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
+    });
+    _step(): void;
+    getOutput(): {
+        expandedSegments: ExpandedSegment[];
+    };
+    visualize(): Required<GraphicsObject>;
+}
+
+declare class GapFillSolverPipeline extends BasePipelineSolver<{
+    meshNodes: CapacityMeshNode[];
+}> {
+    findSegmentsWithAdjacentEmptySpaceSolver?: FindSegmentsWithAdjacentEmptySpaceSolver;
+    expandEdgesToEmptySpaceSolver?: ExpandEdgesToEmptySpaceSolver;
+    pipelineDef: PipelineStep<any>[];
+    getOutput(): {
+        outputNodes: CapacityMeshNode[];
+    };
+    initialVisualize(): GraphicsObject;
+    finalVisualize(): GraphicsObject;
+}
+
 interface RectDiffPipelineInput {
     simpleRouteJson: SimpleRouteJson;
     gridOptions?: Partial<GridFill3DOptions>;
 }
 declare class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
     rectDiffSolver?: RectDiffSolver;
-    pipelineDef: _tscircuit_solver_utils.PipelineStep<RectDiffSolver>[];
+    gapFillSolver?: GapFillSolverPipeline;
+    pipelineDef: PipelineStep<any>[];
     getConstructorParams(): RectDiffPipelineInput[];
     getOutput(): {
         meshNodes: CapacityMeshNode[];
     };
-    visualize(): GraphicsObject;
+    initialVisualize(): GraphicsObject;
+    finalVisualize(): GraphicsObject;
 }
 
 export { RectDiffPipeline, type RectDiffPipelineInput };