calculate-packing 0.0.29 → 0.0.30

package/dist/index.d.ts

@@ -43,7 +43,7 @@ interface PackedComponent extends InputComponent {
     ccwRotationDegrees?: number;
     pads: OutputPad[];
 }
-type PackPlacementStrategy = "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network";
+type PackPlacementStrategy = "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network" | "minimum_closest_sum_squared_distance";
 interface PackInput {
     components: InputComponent[];
     minGap: number;
@@ -304,6 +304,72 @@ declare class MultiOffsetIrlsSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface TwoPhaseIrlsSolverParams extends Omit<MultiOffsetIrlsSolverParams, "useSquaredDistance"> {
+    /** Phase 1 convergence tolerance */
+    phase1Epsilon?: number;
+    /** Phase 2 convergence tolerance */
+    phase2Epsilon?: number;
+}
+/**
+ * Two-Phase IRLS Solver that implements the "minimum_closest_sum_squared_distance" strategy.
+ *
+ * Phase 1: Solves for minimum sum squared distance (like regular squared distance optimization)
+ * Phase 2: From the Phase 1 solution, finds the closest point to any target and optimizes
+ *          to minimize JUST the distance to that single closest point
+ */
+declare class TwoPhaseIrlsSolver extends BaseSolver {
+    offsetPadPoints: MultiOffsetIrlsSolverParams["offsetPadPoints"];
+    targetPointMap: MultiOffsetIrlsSolverParams["targetPointMap"];
+    constraintFn?: MultiOffsetIrlsSolverParams["constraintFn"];
+    currentPosition: {
+        x: number;
+        y: number;
+    };
+    optimalPosition?: {
+        x: number;
+        y: number;
+    };
+    private readonly initialPosition;
+    private readonly phase1Epsilon;
+    private readonly phase2Epsilon;
+    private readonly maxIterations;
+    private phase1Solver?;
+    private phase2Solver?;
+    private currentPhase;
+    private phase1Position?;
+    private closestTargetPadId?;
+    private closestTargetPoint?;
+    constructor(params: TwoPhaseIrlsSolverParams);
+    getConstructorParams(): TwoPhaseIrlsSolverParams;
+    _setup(): void;
+    _step(): void;
+    private stepPhase1;
+    private setupPhase2;
+    private stepPhase2;
+    /**
+     * Get the current best position
+     */
+    getBestPosition(): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get the current absolute positions for all offset pad points
+     */
+    getOffsetPadPositions(): Map<string, {
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Calculate total distance from current position to all assigned target points
+     */
+    getTotalDistance(position?: {
+        x: number;
+        y: number;
+    }): 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
@@ -319,18 +385,19 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
     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";
+    packStrategy: "minimum_sum_squared_distance_to_network" | "minimum_sum_distance_to_network" | "minimum_closest_sum_squared_distance";
     minGap: number;
     packedComponents: PackedComponent[];
     componentToPack: InputComponent;
     viableBounds?: Bounds;
     optimalPosition?: Point$3;
     irlsSolver?: MultiOffsetIrlsSolver;
+    twoPhaseIrlsSolver?: TwoPhaseIrlsSolver;
     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";
+        packStrategy: "minimum_sum_squared_distance_to_network" | "minimum_sum_distance_to_network" | "minimum_closest_sum_squared_distance";
         minGap: number;
         packedComponents: PackedComponent[];
         componentToPack: InputComponent;

package/dist/index.js

@@ -2165,6 +2165,258 @@ var MultiOffsetIrlsSolver = class extends BaseSolver {
   }
 };
 
+// lib/solver-utils/TwoPhaseIrlsSolver.ts
+var TwoPhaseIrlsSolver = class extends BaseSolver {
+  offsetPadPoints;
+  targetPointMap;
+  constraintFn;
+  currentPosition;
+  optimalPosition;
+  initialPosition;
+  phase1Epsilon;
+  phase2Epsilon;
+  maxIterations;
+  phase1Solver;
+  phase2Solver;
+  currentPhase = 1;
+  phase1Position;
+  closestTargetPadId;
+  closestTargetPoint;
+  constructor(params) {
+    super();
+    this.offsetPadPoints = [...params.offsetPadPoints];
+    this.targetPointMap = new Map(params.targetPointMap);
+    this.initialPosition = { ...params.initialPosition };
+    this.currentPosition = { ...params.initialPosition };
+    this.constraintFn = params.constraintFn;
+    this.phase1Epsilon = params.phase1Epsilon ?? params.epsilon ?? 1e-6;
+    this.phase2Epsilon = params.phase2Epsilon ?? params.epsilon ?? 1e-6;
+    this.maxIterations = params.maxIterations ?? 100;
+  }
+  getConstructorParams() {
+    return {
+      offsetPadPoints: this.offsetPadPoints.map((pad) => ({ ...pad })),
+      targetPointMap: new Map(this.targetPointMap),
+      initialPosition: this.initialPosition,
+      constraintFn: this.constraintFn,
+      phase1Epsilon: this.phase1Epsilon,
+      phase2Epsilon: this.phase2Epsilon,
+      maxIterations: this.maxIterations
+    };
+  }
+  _setup() {
+    this.currentPosition = { ...this.initialPosition };
+    this.optimalPosition = void 0;
+    this.currentPhase = 1;
+    this.phase1Position = void 0;
+    this.closestTargetPadId = void 0;
+    this.closestTargetPoint = void 0;
+    const hasTargets = Array.from(this.targetPointMap.values()).some(
+      (targets) => targets.length > 0
+    );
+    if (!hasTargets || this.offsetPadPoints.length === 0) {
+      this.optimalPosition = { ...this.currentPosition };
+      this.solved = true;
+      return;
+    }
+    this.phase1Solver = new MultiOffsetIrlsSolver({
+      offsetPadPoints: this.offsetPadPoints,
+      targetPointMap: this.targetPointMap,
+      initialPosition: this.initialPosition,
+      constraintFn: this.constraintFn,
+      epsilon: this.phase1Epsilon,
+      maxIterations: this.maxIterations,
+      useSquaredDistance: true
+      // Phase 1 uses squared distance
+    });
+    this.phase1Solver.setup();
+  }
+  _step() {
+    if (this.currentPhase === 1) {
+      this.stepPhase1();
+    } else {
+      this.stepPhase2();
+    }
+  }
+  stepPhase1() {
+    if (!this.phase1Solver) return;
+    this.phase1Solver.step();
+    this.currentPosition = this.phase1Solver.getBestPosition();
+    if (this.phase1Solver.solved) {
+      this.phase1Position = this.phase1Solver.getBestPosition();
+      this.setupPhase2();
+    } else if (this.phase1Solver.failed) {
+      this.failed = true;
+      this.error = `Phase 1 failed: ${this.phase1Solver.error}`;
+    }
+  }
+  setupPhase2() {
+    if (!this.phase1Position) return;
+    let minDistance = Infinity;
+    let closestPadId;
+    let closestTarget;
+    for (const pad of this.offsetPadPoints) {
+      const targetPoints = this.targetPointMap.get(pad.id) || [];
+      if (targetPoints.length === 0) continue;
+      const padX = this.phase1Position.x + pad.offsetX;
+      const padY = this.phase1Position.y + pad.offsetY;
+      for (const targetPoint of targetPoints) {
+        const dx = padX - targetPoint.x;
+        const dy = padY - targetPoint.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        if (distance < minDistance) {
+          minDistance = distance;
+          closestPadId = pad.id;
+          closestTarget = targetPoint;
+        }
+      }
+    }
+    this.closestTargetPadId = closestPadId;
+    this.closestTargetPoint = closestTarget;
+    if (!closestPadId || !closestTarget) {
+      this.optimalPosition = this.phase1Position;
+      this.solved = true;
+      return;
+    }
+    const phase2TargetMap = /* @__PURE__ */ new Map();
+    phase2TargetMap.set(closestPadId, [closestTarget]);
+    this.phase2Solver = new MultiOffsetIrlsSolver({
+      offsetPadPoints: this.offsetPadPoints,
+      targetPointMap: phase2TargetMap,
+      initialPosition: this.phase1Position,
+      constraintFn: this.constraintFn,
+      epsilon: this.phase2Epsilon,
+      maxIterations: this.maxIterations,
+      useSquaredDistance: false
+      // Phase 2 uses regular distance
+    });
+    this.phase2Solver.setup();
+    this.currentPhase = 2;
+  }
+  stepPhase2() {
+    if (!this.phase2Solver) return;
+    this.phase2Solver.step();
+    this.currentPosition = this.phase2Solver.getBestPosition();
+    if (this.phase2Solver.solved) {
+      this.optimalPosition = this.phase2Solver.getBestPosition();
+      this.solved = true;
+    } else if (this.phase2Solver.failed) {
+      this.failed = true;
+      this.error = `Phase 2 failed: ${this.phase2Solver.error}`;
+    }
+  }
+  /**
+   * Get the current best position
+   */
+  getBestPosition() {
+    return this.optimalPosition || this.currentPosition;
+  }
+  /**
+   * Get the current absolute positions for all offset pad points
+   */
+  getOffsetPadPositions() {
+    const currentPos = this.getBestPosition();
+    const padPositions = /* @__PURE__ */ new Map();
+    for (const pad of this.offsetPadPoints) {
+      padPositions.set(pad.id, {
+        x: currentPos.x + pad.offsetX,
+        y: currentPos.y + pad.offsetY
+      });
+    }
+    return padPositions;
+  }
+  /**
+   * Calculate total distance from current position to all assigned target points
+   */
+  getTotalDistance(position) {
+    const pos = position || this.getBestPosition();
+    let totalDistance = 0;
+    for (const pad of this.offsetPadPoints) {
+      const padPosition = {
+        x: pos.x + pad.offsetX,
+        y: pos.y + pad.offsetY
+      };
+      const targetPoints = this.targetPointMap.get(pad.id) || [];
+      for (const target of targetPoints) {
+        const dx = padPosition.x - target.x;
+        const dy = padPosition.y - target.y;
+        totalDistance += dx * dx + dy * dy;
+      }
+    }
+    return totalDistance;
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    graphics.points.push({
+      ...this.currentPosition,
+      color: this.currentPhase === 1 ? "#FF6B6B" : "#4ECDC4",
+      label: `Phase ${this.currentPhase}`
+    });
+    if (this.phase1Position && this.currentPhase === 2) {
+      graphics.points.push({
+        ...this.phase1Position,
+        color: "rgba(255, 107, 107, 0.5)",
+        label: "Phase 1 result"
+      });
+    }
+    if (this.closestTargetPoint && this.closestTargetPadId) {
+      graphics.points.push({
+        ...this.closestTargetPoint,
+        color: "#FFA500",
+        label: `Closest target (${this.closestTargetPadId})`
+      });
+      const closestPad = this.offsetPadPoints.find(
+        (p) => p.id === this.closestTargetPadId
+      );
+      if (closestPad) {
+        const currentPos = this.getBestPosition();
+        const padPos = {
+          x: currentPos.x + closestPad.offsetX,
+          y: currentPos.y + closestPad.offsetY
+        };
+        graphics.lines.push({
+          points: [padPos, this.closestTargetPoint],
+          strokeColor: "#FFA500"
+        });
+      }
+    }
+    const activeSolver = this.currentPhase === 1 ? this.phase1Solver : this.phase2Solver;
+    if (activeSolver) {
+      const solverViz = activeSolver.visualize();
+      const phaseColor = this.currentPhase === 1 ? "rgba(255, 107, 107, 0.7)" : "rgba(76, 205, 196, 0.7)";
+      if (solverViz.lines) {
+        const modifiedLines = solverViz.lines.map((line) => ({
+          ...line,
+          strokeColor: phaseColor
+        }));
+        graphics.lines.push(...modifiedLines);
+      }
+      if (solverViz.points) {
+        graphics.points.push(...solverViz.points);
+      }
+      if (solverViz.rects) {
+        graphics.rects.push(...solverViz.rects);
+      }
+      if (solverViz.circles) {
+        graphics.circles.push(...solverViz.circles);
+      }
+    }
+    if (this.optimalPosition) {
+      graphics.points.push({
+        ...this.optimalPosition,
+        color: "rgba(76, 175, 80, 0.8)",
+        label: "Final optimal position"
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/geometry/pointInOutline.ts
 var EPS = 1e-9;
 function cross2(ax, ay, bx, by) {
@@ -2309,6 +2561,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   viableBounds;
   optimalPosition;
   irlsSolver;
+  twoPhaseIrlsSolver;
   constructor(params) {
     super();
     this.outlineSegment = params.outlineSegment;
@@ -2427,29 +2680,41 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       x: (vp1.x + vp2.x) / 2,
       y: (vp1.y + vp2.y) / 2
     });
-    this.irlsSolver = new MultiOffsetIrlsSolver({
-      offsetPadPoints,
-      targetPointMap,
-      initialPosition,
-      constraintFn,
-      epsilon: 1e-6,
-      maxIterations: 50,
-      useSquaredDistance: this.packStrategy === "minimum_sum_squared_distance_to_network"
-    });
+    if (this.packStrategy === "minimum_closest_sum_squared_distance") {
+      this.twoPhaseIrlsSolver = new TwoPhaseIrlsSolver({
+        offsetPadPoints,
+        targetPointMap,
+        initialPosition,
+        constraintFn,
+        epsilon: 1e-6,
+        maxIterations: 50
+      });
+    } else {
+      this.irlsSolver = new MultiOffsetIrlsSolver({
+        offsetPadPoints,
+        targetPointMap,
+        initialPosition,
+        constraintFn,
+        epsilon: 1e-6,
+        maxIterations: 50,
+        useSquaredDistance: this.packStrategy === "minimum_sum_squared_distance_to_network"
+      });
+    }
   }
   _step() {
-    if (!this.irlsSolver) {
+    const activeSolver = this.irlsSolver || this.twoPhaseIrlsSolver;
+    if (!activeSolver) {
       this.solved = true;
       return;
     }
-    this.irlsSolver.step();
-    if (this.irlsSolver.solved) {
-      const rawPosition = this.irlsSolver.getBestPosition();
+    activeSolver.step();
+    if (activeSolver.solved) {
+      const rawPosition = activeSolver.getBestPosition();
       this.optimalPosition = rawPosition;
       this.solved = true;
-    } else if (this.irlsSolver.failed) {
+    } else if (activeSolver.failed) {
       this.failed = true;
-      this.error = this.irlsSolver.error;
+      this.error = activeSolver.error;
     }
   }
   /**
@@ -2672,7 +2937,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
         });
       }
     }
-    const pos = this.optimalPosition ?? this.irlsSolver?.currentPosition ?? {
+    const pos = this.optimalPosition ?? this.irlsSolver?.currentPosition ?? this.twoPhaseIrlsSolver?.currentPosition ?? {
       x: 0,
       y: 0
     };
@@ -2702,13 +2967,14 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
         }
       }
     }
-    if (this.irlsSolver) {
-      const currentPos = this.irlsSolver.currentPosition;
+    const activeSolver = this.irlsSolver || this.twoPhaseIrlsSolver;
+    if (activeSolver) {
+      const currentPos = activeSolver.currentPosition;
       graphics.points.push({
         ...currentPos,
         color: "#f44336"
       });
-      const solverViz = this.irlsSolver.visualize();
+      const solverViz = activeSolver.visualize();
       if (solverViz.lines) {
         graphics.lines.push(...solverViz.lines);
       }
@@ -2871,7 +3137,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
         outlineSegment: queuedSegment.segment,
         fullOutline: queuedSegment.fullOutline,
         componentRotationDegrees: rotation,
-        packStrategy: "minimum_sum_squared_distance_to_network",
+        packStrategy: this.packPlacementStrategy === "minimum_closest_sum_squared_distance" ? "minimum_closest_sum_squared_distance" : "minimum_sum_squared_distance_to_network",
         minGap: this.minGap,
         packedComponents: this.packedComponents,
         componentToPack: this.componentToPack
@@ -2900,7 +3166,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
   calculateDistance(position, rotation) {
     const tempComponent = this.createPackedComponent(position, rotation);
     let totalDistance = 0;
-    const useSquaredDistance = this.packPlacementStrategy === "minimum_sum_squared_distance_to_network";
+    const useSquaredDistance = this.packPlacementStrategy === "minimum_sum_squared_distance_to_network" || this.packPlacementStrategy === "minimum_closest_sum_squared_distance";
     for (const pad of tempComponent.pads) {
       let minDistanceToNetwork = Infinity;
       for (const packedComponent of this.packedComponents) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",