calculate-packing 0.0.12 → 0.0.13

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GraphicsObject, Point } from 'graphics-debug';
+import { GraphicsObject, Point as Point$1 } from 'graphics-debug';
 import { CircuitJson } from 'circuit-json';
 
 type ComponentId = string;
@@ -36,6 +36,7 @@ interface PackedComponent extends InputComponent {
         x: number;
         y: number;
     };
+    /** Rotation in degrees (counterclockwise) */
     ccwRotationOffset: number;
     pads: OutputPad[];
 }
@@ -43,7 +44,7 @@ interface PackInput {
     components: InputComponent[];
     minGap: number;
     packOrderStrategy: "largest_to_smallest";
-    packPlacementStrategy: "shortest_connection_along_outline" | "minimum_sum_distance_to_network";
+    packPlacementStrategy: "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network";
     disconnectedPackDirection?: "left" | "right" | "up" | "down" | "nearest_to_center";
     packFirst?: ComponentId[];
 }
@@ -101,46 +102,66 @@ declare class BaseSolver {
     preview(): GraphicsObject;
 }
 
-/**
- * The pack algorithm performs the following steps:
- * 1. Sort the components using the packOrderStrategy
- * 2. Select the next component to pack
- * 3. If the first component, pack at center (0,0) and go to step 2
- * 4. Compute the outline of all packed components with a gap of minGap + max(pad.width, pad.height)/2
- * 5. Find the point along the outline that minimizes the distance of the pad
- *    centers within a networkId. If no shared pads, pack to the defaultPackDirection
- * 6. Add the component at the selected point, with it's pad at the position
- *    minimizing the distance between the pad centers
- * 7. To determine the component rotation, find the minimum distance between pad
- *    centers for the remaining pads at each possible rotation (making sure that
- *    we never pack such that two pads overlap)
- * 8. Go to step 2 until all components are packed
- */
-declare class PackSolver extends BaseSolver {
+type Point = {
+    x: number;
+    y: number;
+};
+type Segment = [Point, Point];
+
+type PackingPhase = "idle" | "show_candidate_points" | "show_rotations" | "show_final_placement";
+interface RotationTrial extends PackedComponent {
+    cost: number;
+    anchorType: "pad" | "center";
+    anchorPadId?: string;
+    hasOverlap: boolean;
+}
+declare class PhasedPackSolver extends BaseSolver {
     packInput: PackInput;
     unpackedComponentQueue: InputComponent[];
     packedComponents: PackedComponent[];
+    currentPhase: PackingPhase;
+    currentComponent?: InputComponent;
+    phaseData: {
+        candidatePoints?: Array<Point$1 & {
+            networkId: NetworkId;
+            distance: number;
+        }>;
+        goodCandidates?: Array<Point$1 & {
+            networkId: NetworkId;
+        }>;
+        bestDistance?: number;
+        rotationTrials?: Array<RotationTrial>;
+        selectedRotation?: PackedComponent;
+        outlines?: Segment[][];
+    };
     lastBestPointsResult?: {
-        bestPoints: (Point & {
+        goodCandidates: (Point$1 & {
             networkId: NetworkId;
         })[];
         distance: number;
     };
     lastEvaluatedPositionShadows?: Array<PackedComponent>;
+    lastCandidatePoints?: Array<Point$1 & {
+        networkId: NetworkId;
+        distance: number;
+    }>;
     constructor(input: PackInput);
     _setup(): void;
     _step(): void;
+    private placeFirstComponent;
+    private computeCandidatePoints;
+    private computeRotationTrials;
+    private selectBestRotation;
+    private finalizeComponentPlacement;
+    /** Visualize the current packing state based on the current phase */
+    visualize(): GraphicsObject;
+    private visualizeCandidatePoints;
+    private visualizeRotationTrials;
+    private visualizeFinalPlacement;
     getConstructorParams(): PackInput[];
+    getResult(): PackedComponent[];
     private getCandidateAngles;
     private checkOverlapWithPackedComponents;
-    private computeGlobalCenter;
-    private findBestPointForDisconnected;
-    private placeComponentAtPoint;
-    private placeComponentDisconnected;
-    /** Visualize the current packing state – components are omitted, only the outline is shown. */
-    visualize(): GraphicsObject;
-    getResult(): PackedComponent[];
-    private computeSumDistanceForPosition;
 }
 
 declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?: {
@@ -164,4 +185,4 @@ declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObj
  */
 declare const convertPackOutputToPackInput: (packed: PackOutput) => PackInput;
 
-export { type ComponentId, type InputComponent, type InputPad, type NetworkId, type OutputPad, type PackInput, type PackOutput, PackSolver, type PackedComponent, type PadId, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };
+export { type ComponentId, type InputComponent, type InputPad, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackedComponent, type PadId, PhasedPackSolver, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };