@tscircuit/rectdiff 0.0.30 → 0.0.32

package/dist/index.d.ts

@@ -0,0 +1,381 @@
+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 {
+    layerCount: number;
+    minTraceWidth: number;
+    minViaDiameter?: number;
+    obstacles: Obstacle[];
+    connections: Array<SimpleRouteConnection>;
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    outline?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+interface Obstacle {
+    type: "rect";
+    layers: string[];
+    zLayers?: number[];
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    connectedTo: TraceId[];
+    netIsAssignable?: boolean;
+    offBoardConnectsTo?: TraceId[];
+}
+interface SimpleRouteConnection {
+    name: string;
+    netConnectionName?: string;
+    nominalTraceWidth?: number;
+    pointsToConnect: Array<{
+        x: number;
+        y: number;
+        layer: string;
+        pointId?: string;
+        pcb_port_id?: string;
+    }>;
+    externallyConnectedPointIds?: string[][];
+}
+
+type XYRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type GridFill3DOptions = {
+    gridSizes?: number[];
+    initialCellRatio?: number;
+    maxAspectRatio?: number | null;
+    minSingle: {
+        width: number;
+        height: number;
+    };
+    minMulti: {
+        width: number;
+        height: number;
+        minLayers: number;
+    };
+    preferMultiLayer?: boolean;
+    maxMultiLayerSpan?: number;
+};
+type Candidate3D = {
+    x: number;
+    y: number;
+    z: number;
+    distance: number;
+    /** Larger values mean more multi-layer potential at this seed. */
+    zSpanLen?: number;
+    /** Marked when the seed came from the edge analysis pass. */
+    isEdgeSeed?: boolean;
+};
+type Placed3D = {
+    rect: XYRect;
+    zLayers: number[];
+};
+
+type CapacityMeshNodeId = string;
+interface CapacityMeshNode {
+    capacityMeshNodeId: string;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    layer: string;
+    availableZ: number[];
+    _depth?: number;
+    _completelyInsideObstacle?: boolean;
+    _containsObstacle?: boolean;
+    _containsTarget?: boolean;
+    _targetConnectionName?: string;
+    _strawNode?: boolean;
+    _strawParentCapacityMeshNodeId?: CapacityMeshNodeId;
+    _adjacentNodeIds?: CapacityMeshNodeId[];
+    _parent?: CapacityMeshNode;
+}
+type RTreeRect = XYRect & {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    zLayers: number[];
+};
+
+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>;
+}
+
+type ExpandEdgesToEmptySpaceSolverInput = {
+    inputMeshNodes: CapacityMeshNode[];
+    segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
+    boardVoid?: {
+        boardVoidRects: XYRect[];
+        layerCount: number;
+    };
+};
+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: ExpandEdgesToEmptySpaceSolverInput);
+    _step(): void;
+    getOutput(): {
+        expandedSegments: ExpandedSegment[];
+    };
+    visualize(): Required<GraphicsObject>;
+}
+
+type GapFillSolverInput = {
+    meshNodes: CapacityMeshNode[];
+    boardVoid?: {
+        boardVoidRects: XYRect[];
+        layerCount: number;
+    };
+};
+declare class GapFillSolverPipeline extends BasePipelineSolver<GapFillSolverInput> {
+    findSegmentsWithAdjacentEmptySpaceSolver?: FindSegmentsWithAdjacentEmptySpaceSolver;
+    expandEdgesToEmptySpaceSolver?: ExpandEdgesToEmptySpaceSolver;
+    pipelineDef: PipelineStep<any>[];
+    getOutput(): {
+        outputNodes: CapacityMeshNode[];
+    };
+    initialVisualize(): GraphicsObject;
+    finalVisualize(): GraphicsObject;
+}
+
+type RectDiffSeedingSolverInput = {
+    simpleRouteJson: SimpleRouteJson;
+    obstacleIndexByLayer: Array<RBush<RTreeRect>>;
+    gridOptions?: Partial<GridFill3DOptions>;
+    boardVoidRects?: XYRect[];
+    layerNames: string[];
+    zIndexByName: Map<string, number>;
+    obstacleClearance?: number;
+};
+/**
+ * First phase of RectDiff: grid-based seeding and placement.
+ *
+ * This solver is responsible for walking all grid sizes and producing
+ * an initial set of placed rectangles.
+ */
+declare class RectDiffSeedingSolver extends BaseSolver {
+    private input;
+    private srj;
+    private layerNames;
+    private layerCount;
+    private bounds;
+    private options;
+    private boardVoidRects?;
+    private gridIndex;
+    private candidates;
+    private placed;
+    private placedIndexByLayer;
+    private hardPlacedByLayer;
+    private expansionIndex;
+    private edgeAnalysisDone;
+    private totalSeedsThisGrid;
+    private consumedSeedsThisGrid;
+    constructor(input: RectDiffSeedingSolverInput);
+    _setup(): void;
+    /** Exactly ONE grid candidate step per call. */
+    _step(): void;
+    /**
+     * One micro-step during the GRID phase: handle exactly one candidate.
+     */
+    private _stepGrid;
+    /** Compute solver progress (0 to 1) during GRID phase. */
+    computeProgress(): number;
+    /**
+     * Output the intermediate RectDiff engine data to feed into the
+     * expansion phase solver.
+     */
+    getOutput(): {
+        layerNames: string[];
+        layerCount: number;
+        bounds: XYRect;
+        options: Required<Omit<GridFill3DOptions, "gridSizes" | "maxMultiLayerSpan">> & {
+            gridSizes: number[];
+            maxMultiLayerSpan: number | undefined;
+        };
+        boardVoidRects: XYRect[] | undefined;
+        gridIndex: number;
+        candidates: Candidate3D[];
+        placed: Placed3D[];
+        expansionIndex: number;
+        edgeAnalysisDone: boolean;
+        totalSeedsThisGrid: number;
+        consumedSeedsThisGrid: number;
+        obstacles: Obstacle[];
+        obstacleClearance: number | undefined;
+    };
+    /** Visualization focused on the grid seeding phase. */
+    visualize(): GraphicsObject;
+}
+
+type RectDiffExpansionSolverInput = {
+    layerNames: string[];
+    layerCount: number;
+    bounds: XYRect;
+    options: {
+        gridSizes: number[];
+        [key: string]: any;
+    };
+    boardVoidRects: XYRect[];
+    gridIndex: number;
+    candidates: Candidate3D[];
+    placed: Placed3D[];
+    expansionIndex: number;
+    edgeAnalysisDone: boolean;
+    totalSeedsThisGrid: number;
+    consumedSeedsThisGrid: number;
+    obstacleIndexByLayer: Array<RBush<RTreeRect>>;
+    zIndexByName: Map<string, number>;
+    layerNamesCanonical: string[];
+    obstacles: Obstacle[];
+    obstacleClearance?: number;
+};
+/**
+ * Second phase of RectDiff: expand placed rects to their maximal extents.
+ *
+ * This solver takes the intermediate data produced by RectDiffSeedingSolver
+ * and runs the EXPANSION phase, then finalizes to capacity mesh nodes.
+ */
+declare class RectDiffExpansionSolver extends BaseSolver {
+    private input;
+    placedIndexByLayer: Array<RBush<RTreeRect>>;
+    _meshNodes: CapacityMeshNode[];
+    constructor(input: RectDiffExpansionSolverInput);
+    _setup(): void;
+    _step(): void;
+    private _stepExpansion;
+    private finalizeIfNeeded;
+    computeProgress(): number;
+    getOutput(): {
+        meshNodes: CapacityMeshNode[];
+    };
+    /** Simple visualization of expanded placements. */
+    visualize(): GraphicsObject;
+}
+
+type RectDiffGridSolverPipelineInput = {
+    bounds: Bounds;
+    obstacles: Obstacle[];
+    connections: SimpleRouteConnection[];
+    outline?: Pick<SimpleRouteJson, "outline">;
+    layerCount: number;
+    minTraceWidth: number;
+    obstacleClearance?: number;
+    gridOptions?: Partial<GridFill3DOptions>;
+    boardVoidRects?: XYRect[];
+    layerNames?: string[];
+    zIndexByName?: Map<string, number>;
+};
+declare class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
+    rectDiffSeedingSolver?: RectDiffSeedingSolver;
+    rectDiffExpansionSolver?: RectDiffExpansionSolver;
+    private obstacleIndexByLayer;
+    private layerNames;
+    private zIndexByName;
+    constructor(inputProblem: RectDiffGridSolverPipelineInput);
+    pipelineDef: PipelineStep<any>[];
+    getConstructorParams(): RectDiffGridSolverPipelineInput[];
+    getOutput(): {
+        meshNodes: CapacityMeshNode[];
+    };
+    visualize(): GraphicsObject;
+}
+
+interface RectDiffPipelineInput {
+    simpleRouteJson: SimpleRouteJson;
+    gridOptions?: Partial<GridFill3DOptions>;
+    obstacleClearance?: number;
+}
+declare class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
+    rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline;
+    gapFillSolver?: GapFillSolverPipeline;
+    boardVoidRects: XYRect[] | undefined;
+    zIndexByName?: Map<string, number>;
+    layerNames?: string[];
+    pipelineDef: PipelineStep<any>[];
+    _setup(): void;
+    getConstructorParams(): RectDiffPipelineInput[];
+    getOutput(): {
+        meshNodes: CapacityMeshNode[];
+    };
+    initialVisualize(): GraphicsObject;
+    finalVisualize(): GraphicsObject;
+}
+
+export { RectDiffPipeline, type RectDiffPipelineInput };