calculate-packing 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { GraphicsObject, Point as Point$1 } from 'graphics-debug';
+import { GraphicsObject, Point as Point$2 } from 'graphics-debug';
 import { CircuitJson } from 'circuit-json';
-import { Bounds } from '@tscircuit/math-utils';
+import { Bounds, Point as Point$3 } from '@tscircuit/math-utils';
 
 type ComponentId = string;
 type PadId = string;
@@ -107,11 +107,11 @@ declare class BaseSolver {
     noisySolve(): void;
 }
 
-type Point = {
+type Point$1 = {
     x: number;
     y: number;
 };
-type Segment = [Point, Point];
+type Segment = [Point$1, Point$1];
 
 type PackingPhase = "idle" | "show_candidate_points" | "show_rotations" | "show_final_placement";
 interface RotationTrial extends PackedComponent {
@@ -127,11 +127,11 @@ declare class PhasedPackSolver extends BaseSolver {
     currentPhase: PackingPhase;
     currentComponent?: InputComponent;
     phaseData: {
-        candidatePoints?: Array<Point$1 & {
+        candidatePoints?: Array<Point$2 & {
             networkId: NetworkId;
             distance: number;
         }>;
-        goodCandidates?: Array<Point$1 & {
+        goodCandidates?: Array<Point$2 & {
             networkId: NetworkId;
         }>;
         bestDistance?: number;
@@ -140,13 +140,13 @@ declare class PhasedPackSolver extends BaseSolver {
         outlines?: Segment[][];
     };
     lastBestPointsResult?: {
-        goodCandidates: (Point$1 & {
+        goodCandidates: (Point$2 & {
             networkId: NetworkId;
         })[];
         distance: number;
     };
     lastEvaluatedPositionShadows?: Array<PackedComponent>;
-    lastCandidatePoints?: Array<Point$1 & {
+    lastCandidatePoints?: Array<Point$2 & {
         networkId: NetworkId;
         distance: number;
     }>;
@@ -199,18 +199,18 @@ type Rect = {
 
 type GlobalBounds = Bounds;
 declare class LargestRectOutsideOutlineFromPointSolver extends BaseSolver {
-    fullOutline: Point[];
-    origin: Point;
+    fullOutline: Point$1[];
+    origin: Point$1;
     globalBounds: Bounds;
     largestRect: Rect | null;
     constructor(params: {
-        fullOutline: Point[];
-        origin: Point;
+        fullOutline: Point$1[];
+        origin: Point$1;
         globalBounds: Bounds;
     });
     getConstructorParams(): {
-        fullOutline: Point[];
-        origin: Point;
+        fullOutline: Point$1[];
+        origin: Point$1;
         globalBounds: Bounds;
     };
     _setup(): void;
@@ -229,4 +229,200 @@ declare class LargestRectOutsideOutlineFromPointSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-export { type ComponentId, type GlobalBounds, type InputComponent, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, type PackedComponent, type PadId, PhasedPackSolver, type Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };
+interface Point {
+    x: number;
+    y: number;
+}
+interface IrlsSolverParams {
+    /** Target points to minimize distance to */
+    targetPoints: Point[];
+    /** Initial position for the algorithm */
+    initialPosition: Point;
+    /** Optional constraint function that maps a point to the nearest valid position */
+    constraintFn?: (point: Point) => Point;
+    /** Convergence tolerance */
+    epsilon?: number;
+    /** Maximum iterations before giving up */
+    maxIterations?: number;
+    /** Whether to use squared distances (for sum of squared distances optimization) */
+    useSquaredDistance?: boolean;
+}
+/**
+ * IRLS (Iteratively Reweighted Least Squares) Solver using the Weiszfeld algorithm
+ * to find the geometric median (point that minimizes sum of distances to target points).
+ *
+ * This solver can be used as a subsolver in other optimization problems where
+ * you need to find the optimal position that minimizes total distance to a set of points.
+ */
+declare class IrlsSolver extends BaseSolver {
+    targetPoints: Point[];
+    currentPosition: Point;
+    constraintFn?: (point: Point) => Point;
+    epsilon: number;
+    useSquaredDistance: boolean;
+    optimalPosition?: Point;
+    private readonly initialPosition;
+    constructor(params: IrlsSolverParams);
+    getConstructorParams(): IrlsSolverParams;
+    _setup(): void;
+    _step(): void;
+    /**
+     * Get the current best position
+     */
+    getBestPosition(): Point;
+    /**
+     * Calculate total distance from current position to all target points
+     */
+    getTotalDistance(position?: Point): number;
+    computeProgress(): number;
+    visualize(): GraphicsObject;
+}
+
+/**
+ * Given a single segment on the outline, the component's rotation, compute the
+ * optimal position for the rotated component (the position that minimizes the
+ * packStrategy, generally minimizing the sum of the distances to other pads in
+ * the network)
+ *
+ * To do this, we use the IRLS/Weiszfeld Weighted Least Squares algorithm, look
+ * at the site/algorithm-visualizations/irls-weiszfeld-algorithm.page.tsx for
+ * an interactive visualization of how it works.
+ */
+declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
+    outlineSegment: [Point$3, Point$3];
+    viableOutlineSegment: [Point$3, Point$3] | null;
+    fullOutline: [Point$3, Point$3][];
+    componentRotationDegrees: number;
+    packStrategy: "minimum_sum_squared_distance_to_network" | "minimum_sum_distance_to_network";
+    minGap: number;
+    packedComponents: PackedComponent[];
+    componentToPack: InputComponent;
+    viableBounds?: Bounds;
+    optimalPosition?: Point$3;
+    irlsSolver?: IrlsSolver;
+    constructor(params: {
+        outlineSegment: [Point$3, Point$3];
+        fullOutline: [Point$3, Point$3][];
+        componentRotationDegrees: number;
+        packStrategy: "minimum_sum_squared_distance_to_network" | "minimum_sum_distance_to_network";
+        minGap: number;
+        packedComponents: PackedComponent[];
+        componentToPack: InputComponent;
+    });
+    getConstructorParams(): ConstructorParameters<typeof OutlineSegmentCandidatePointSolver>[0];
+    _getPackedComponentBounds(params?: {
+        margin?: number;
+    }): Bounds;
+    _setup(): void;
+    _step(): void;
+    /**
+     * Get target points from network connections, considering the component's rotation
+     */
+    private getNetworkTargetPoints;
+    /**
+     * Project a point onto the outline segment
+     */
+    private projectPointOntoSegment;
+    /**
+     * Get rotated pads for the component being placed
+     */
+    private getRotatedComponentPads;
+    /**
+     * Create a temporary PackedComponent with the given center position and applied rotation
+     */
+    private createTemporaryPackedComponent;
+    /**
+     * Adjust position to avoid component bounds crossing to the inside of the outline
+     */
+    private adjustPositionForOutlineCollision;
+    /**
+     * Get the outward normal for the current segment by determining which side
+     * is farther from the outline centroid
+     */
+    private getOutwardNormal;
+    visualize(): GraphicsObject;
+}
+
+type Phase = "outline" | "segment_candidate" | "evaluate";
+interface QueuedOutlineSegment {
+    segment: Segment;
+    availableRotations: number[];
+    segmentIndex: number;
+    fullOutline: Segment[];
+}
+interface CandidateResult {
+    segment: Segment;
+    rotation: number;
+    optimalPosition?: Point$2;
+    distance: number;
+    segmentIndex: number;
+    rotationIndex: number;
+}
+/**
+ * Packs a single component given a set of already packed components.
+ *
+ * Runs subsolvers and operates in several phases:
+ * Phase 1: Compute outline (visualization shows outline)
+ * Phase 2: Compute candidate point for each segment by finding the optimal
+ *          point on each segment of the outline for each rotation-segment pair.
+ *          (visualization shows candidate point for active segment using the
+ *           visualize method of the OutlineSegmentCandidatePointSolver)
+ * Phase 3: Score the points. Show the points in visualization with a "step"
+ *          where step=0 is the best point (lowest distance) and step=N is the
+ *          worst point.
+ */
+declare class SingleComponentPackSolver extends BaseSolver {
+    componentToPack: InputComponent;
+    packedComponents: PackedComponent[];
+    packPlacementStrategy: PackPlacementStrategy;
+    minGap: number;
+    currentPhase: Phase;
+    outlines: Segment[][];
+    queuedOutlineSegments: QueuedOutlineSegment[];
+    currentSegmentIndex: number;
+    currentRotationIndex: number;
+    activeSubSolver?: OutlineSegmentCandidatePointSolver | null;
+    candidateResults: CandidateResult[];
+    bestCandidate?: CandidateResult;
+    outputPackedComponent?: PackedComponent;
+    constructor(params: {
+        componentToPack: InputComponent;
+        packedComponents: PackedComponent[];
+        packPlacementStrategy: PackPlacementStrategy;
+        minGap?: number;
+    });
+    _setup(): void;
+    _step(): void;
+    private executeOutlinePhase;
+    private executeSegmentCandidatePhase;
+    private executeEvaluatePhase;
+    private calculateDistance;
+    private createPackedComponent;
+    visualize(): GraphicsObject;
+    private visualizeOutlinePhase;
+    private visualizeSegmentCandidatePhase;
+    private visualizeEvaluatePhase;
+    getResult(): PackedComponent | undefined;
+    getConstructorParams(): {
+        componentToPack: InputComponent;
+        packedComponents: PackedComponent[];
+        packPlacementStrategy: PackPlacementStrategy;
+        minGap: number;
+    };
+}
+
+declare class PackSolver2 extends BaseSolver {
+    activeSubSolver: SingleComponentPackSolver | null | undefined;
+    packInput: PackInput;
+    unpackedComponentQueue: InputComponent[];
+    packedComponents: PackedComponent[];
+    componentToPack?: InputComponent | null | undefined;
+    constructor(packInput: PackInput);
+    getConstructorParams(): PackInput;
+    _setup(): void;
+    private packFirstComponent;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+export { type ComponentId, type GlobalBounds, type InputComponent, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, PackSolver2, type PackedComponent, type PadId, PhasedPackSolver, type Point$1 as Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };