calculate-packing 0.0.22 → 0.0.24

package/dist/index.d.ts

@@ -233,9 +233,16 @@ interface Point {
     x: number;
     y: number;
 }
-interface IrlsSolverParams {
-    /** Target points to minimize distance to */
-    targetPoints: Point[];
+interface OffsetPadPoint {
+    id: string;
+    offsetX: number;
+    offsetY: number;
+}
+interface MultiOffsetIrlsSolverParams {
+    /** Offset pad points relative to the current position */
+    offsetPadPoints: OffsetPadPoint[];
+    /** Map from offset pad ID to array of target points it should minimize distance to */
+    targetPointMap: Map<string, Point[]>;
     /** Initial position for the algorithm */
     initialPosition: Point;
     /** Optional constraint function that maps a point to the nearest valid position */
@@ -248,22 +255,25 @@ interface IrlsSolverParams {
     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).
+ * Multi-Offset IRLS (Iteratively Reweighted Least Squares) Solver
+ * Extends the Weiszfeld algorithm to optimize a single position that minimizes
+ * the total distance from multiple offset pad points to their assigned 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.
+ * The offset pad points are positioned relative to the current position, and the
+ * algorithm finds the optimal position that minimizes the sum of distances from
+ * each offset pad to its assigned target points.
  */
-declare class IrlsSolver extends BaseSolver {
-    targetPoints: Point[];
+declare class MultiOffsetIrlsSolver extends BaseSolver {
+    offsetPadPoints: OffsetPadPoint[];
+    targetPointMap: Map<string, Point[]>;
     currentPosition: Point;
     constraintFn?: (point: Point) => Point;
     epsilon: number;
     useSquaredDistance: boolean;
     optimalPosition?: Point;
     private readonly initialPosition;
-    constructor(params: IrlsSolverParams);
-    getConstructorParams(): IrlsSolverParams;
+    constructor(params: MultiOffsetIrlsSolverParams);
+    getConstructorParams(): MultiOffsetIrlsSolverParams;
     _setup(): void;
     _step(): void;
     /**
@@ -271,9 +281,21 @@ declare class IrlsSolver extends BaseSolver {
      */
     getBestPosition(): Point;
     /**
-     * Calculate total distance from current position to all target points
+     * Get the current absolute positions for all offset pad points
+     */
+    getOffsetPadPositions(): Map<string, Point>;
+    /**
+     * Get the absolute position for a specific offset pad point
+     */
+    getOffsetPadPosition(padId: string): Point | undefined;
+    /**
+     * Calculate total distance from current position to all assigned target points
      */
     getTotalDistance(position?: Point): number;
+    /**
+     * Calculate total distance for a specific offset pad point
+     */
+    getDistanceForPad(padId: string, position?: Point): number;
     computeProgress(): number;
     visualize(): GraphicsObject;
 }
@@ -299,7 +321,7 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
     componentToPack: InputComponent;
     viableBounds?: Bounds;
     optimalPosition?: Point$3;
-    irlsSolver?: IrlsSolver;
+    irlsSolver?: MultiOffsetIrlsSolver;
     constructor(params: {
         outlineSegment: [Point$3, Point$3];
         fullOutline: [Point$3, Point$3][];
@@ -310,15 +332,15 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
         componentToPack: InputComponent;
     });
     getConstructorParams(): ConstructorParameters<typeof OutlineSegmentCandidatePointSolver>[0];
-    _getPackedComponentBounds(params?: {
+    _getOutlineBoundsWithMargin(params?: {
         margin?: number;
     }): Bounds;
     _setup(): void;
     _step(): void;
     /**
-     * Get target points from network connections, considering the component's rotation
+     * Get pad offset points and target point mappings for network connections
      */
-    private getNetworkTargetPoints;
+    private getNetworkTargetPointMappings;
     /**
      * Project a point onto the outline segment
      */

package/dist/index.js

@@ -1,43 +1,30 @@
 // lib/PackSolver/checkOverlapWithPackedComponents.ts
+import { computeDistanceBetweenBoxes } from "@tscircuit/math-utils";
 function checkOverlapWithPackedComponents({
   component,
   packedComponents,
   minGap
 }) {
-  for (const componentPad of component.pads) {
-    for (const packedComponent of packedComponents) {
-      for (const packedPad of packedComponent.pads) {
-        const comp1Bounds = {
-          left: componentPad.absoluteCenter.x - componentPad.size.x / 2,
-          right: componentPad.absoluteCenter.x + componentPad.size.x / 2,
-          bottom: componentPad.absoluteCenter.y - componentPad.size.y / 2,
-          top: componentPad.absoluteCenter.y + componentPad.size.y / 2
-        };
-        const comp2Bounds = {
-          left: packedPad.absoluteCenter.x - packedPad.size.x / 2,
-          right: packedPad.absoluteCenter.x + packedPad.size.x / 2,
-          bottom: packedPad.absoluteCenter.y - packedPad.size.y / 2,
-          top: packedPad.absoluteCenter.y + packedPad.size.y / 2
-        };
-        const xOverlap = comp1Bounds.right > comp2Bounds.left && comp2Bounds.right > comp1Bounds.left;
-        const yOverlap = comp1Bounds.top > comp2Bounds.bottom && comp2Bounds.top > comp1Bounds.bottom;
-        if (xOverlap && yOverlap) {
-          return true;
-        }
-        if (!xOverlap || !yOverlap) {
-          const xGap = xOverlap ? 0 : Math.min(
-            Math.abs(comp1Bounds.left - comp2Bounds.right),
-            Math.abs(comp2Bounds.left - comp1Bounds.right)
-          );
-          const yGap = yOverlap ? 0 : Math.min(
-            Math.abs(comp1Bounds.bottom - comp2Bounds.top),
-            Math.abs(comp2Bounds.bottom - comp1Bounds.top)
-          );
-          const actualGap = Math.max(xGap, yGap);
-          if (actualGap < minGap) {
-            return true;
-          }
-        }
+  const allPackedPadBoxes = packedComponents.flatMap(
+    (c) => c.pads.map((p) => ({
+      center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+      width: p.size.x,
+      height: p.size.y
+    }))
+  );
+  const newComponentPadBoxes = component.pads.map((p) => ({
+    center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+    width: p.size.x,
+    height: p.size.y
+  }));
+  for (const newComponentPadBox of newComponentPadBoxes) {
+    for (const packedPadBox of allPackedPadBoxes) {
+      const { distance: boxDist } = computeDistanceBetweenBoxes(
+        newComponentPadBox,
+        packedPadBox
+      );
+      if (boxDist < minGap) {
+        return true;
       }
     }
   }
@@ -195,6 +182,53 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
   return simplified;
 }
 
+// lib/geometry/getComponentBounds.ts
+var getComponentBounds = (component, minGap = 0) => {
+  const bounds = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minY: Infinity,
+    maxY: -Infinity
+  };
+  component.pads.forEach((pad) => {
+    const hw = pad.size.x / 2;
+    const hh = pad.size.y / 2;
+    const localCorners = [
+      { x: pad.offset.x - hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y + hh },
+      { x: pad.offset.x - hw, y: pad.offset.y + hh }
+    ];
+    localCorners.forEach((corner) => {
+      const world = rotatePoint(
+        corner,
+        component.ccwRotationOffset * Math.PI / 180
+      );
+      const x = world.x + component.center.x;
+      const y = world.y + component.center.y;
+      bounds.minX = Math.min(bounds.minX, x);
+      bounds.maxX = Math.max(bounds.maxX, x);
+      bounds.minY = Math.min(bounds.minY, y);
+      bounds.maxY = Math.max(bounds.maxY, y);
+    });
+  });
+  return {
+    minX: bounds.minX - minGap,
+    maxX: bounds.maxX + minGap,
+    minY: bounds.minY - minGap,
+    maxY: bounds.maxY + minGap
+  };
+};
+
+// lib/geometry/combineBounds.ts
+var combineBounds = (bounds) => {
+  const minX = Math.min(...bounds.map((b) => b.minX));
+  const minY = Math.min(...bounds.map((b) => b.minY));
+  const maxX = Math.max(...bounds.map((b) => b.maxX));
+  const maxY = Math.max(...bounds.map((b) => b.maxY));
+  return { minX, minY, maxX, maxY };
+};
+
 // lib/constructOutlinesFromPackedComponents.ts
 var createPadPolygons = (component, minGap) => {
   return component.pads.map((pad) => {
@@ -222,16 +256,26 @@ var createPadPolygons = (component, minGap) => {
 var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const { minGap = 0 } = opts;
   if (components.length === 0) return [];
+  const bounds = combineBounds(
+    components.map((c) => getComponentBounds(c, minGap))
+  );
   const allPadPolys = [];
   for (const component of components) {
     const padPolys = createPadPolygons(component, minGap);
     allPadPolys.push(...padPolys);
   }
   if (allPadPolys.length === 0) return [];
-  let union = allPadPolys[0];
-  for (let i = 1; i < allPadPolys.length; i++) {
-    union = Flatten.BooleanOperations.unify(union, allPadPolys[i]);
+  let A = new Flatten.Polygon(
+    new Flatten.Box(bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
+  );
+  let B = A.clone();
+  for (let i = 0; i < allPadPolys.length; i++) {
+    try {
+      A = Flatten.BooleanOperations.subtract(A, allPadPolys[i]);
+    } catch (e) {
+    }
   }
+  const union = Flatten.BooleanOperations.subtract(B, A);
   const outlines = [];
   for (const face of union.faces) {
     if (face.isHole) continue;
@@ -351,44 +395,6 @@ function findOptimalPointOnSegment({
   };
 }
 
-// lib/geometry/getComponentBounds.ts
-var getComponentBounds = (component, minGap = 0) => {
-  const bounds = {
-    minX: Infinity,
-    maxX: -Infinity,
-    minY: Infinity,
-    maxY: -Infinity
-  };
-  component.pads.forEach((pad) => {
-    const hw = pad.size.x / 2;
-    const hh = pad.size.y / 2;
-    const localCorners = [
-      { x: pad.offset.x - hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y + hh },
-      { x: pad.offset.x - hw, y: pad.offset.y + hh }
-    ];
-    localCorners.forEach((corner) => {
-      const world = rotatePoint(
-        corner,
-        component.ccwRotationOffset * Math.PI / 180
-      );
-      const x = world.x + component.center.x;
-      const y = world.y + component.center.y;
-      bounds.minX = Math.min(bounds.minX, x);
-      bounds.maxX = Math.max(bounds.maxX, x);
-      bounds.minY = Math.min(bounds.minY, y);
-      bounds.maxY = Math.max(bounds.maxY, y);
-    });
-  });
-  return {
-    minX: bounds.minX - minGap,
-    maxX: bounds.maxX + minGap,
-    minY: bounds.minY - minGap,
-    maxY: bounds.maxY + minGap
-  };
-};
-
 // lib/testing/createColorMapFromStrings.ts
 var createColorMapFromStrings = (strings) => {
   const colorMap = {};
@@ -1914,9 +1920,10 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver {
 // lib/OutlineSegmentCandidatePointSolver/OutlineSegmentCandidatePointSolver.ts
 import { clamp as clamp2 } from "@tscircuit/math-utils";
 
-// lib/solver-utils/IrlsSolver.ts
-var IrlsSolver = class extends BaseSolver {
-  targetPoints;
+// lib/solver-utils/MultiOffsetIrlsSolver.ts
+var MultiOffsetIrlsSolver = class extends BaseSolver {
+  offsetPadPoints;
+  targetPointMap;
   currentPosition;
   constraintFn;
   epsilon;
@@ -1925,7 +1932,8 @@ var IrlsSolver = class extends BaseSolver {
   initialPosition;
   constructor(params) {
     super();
-    this.targetPoints = params.targetPoints;
+    this.offsetPadPoints = [...params.offsetPadPoints];
+    this.targetPointMap = new Map(params.targetPointMap);
     this.initialPosition = { ...params.initialPosition };
     this.currentPosition = { ...params.initialPosition };
     this.constraintFn = params.constraintFn;
@@ -1935,7 +1943,8 @@ var IrlsSolver = class extends BaseSolver {
   }
   getConstructorParams() {
     return {
-      targetPoints: this.targetPoints,
+      offsetPadPoints: this.offsetPadPoints.map((pad) => ({ ...pad })),
+      targetPointMap: new Map(this.targetPointMap),
       initialPosition: this.initialPosition,
       constraintFn: this.constraintFn,
       epsilon: this.epsilon,
@@ -1946,30 +1955,43 @@ var IrlsSolver = class extends BaseSolver {
   _setup() {
     this.currentPosition = { ...this.initialPosition };
     this.optimalPosition = void 0;
-    if (this.targetPoints.length === 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;
     }
   }
   _step() {
-    if (this.targetPoints.length === 0) return;
+    if (this.offsetPadPoints.length === 0) return;
     const { x: currentX, y: currentY } = this.currentPosition;
     let weightedSumX = 0;
     let weightedSumY = 0;
     let totalWeight = 0;
-    for (const targetPoint of this.targetPoints) {
-      const dx2 = currentX - targetPoint.x;
-      const dy2 = currentY - targetPoint.y;
-      const distance = Math.sqrt(dx2 * dx2 + dy2 * dy2);
-      let weight;
-      if (this.useSquaredDistance) {
-        weight = 1;
-      } else {
-        weight = distance < this.epsilon ? 1e6 : 1 / distance;
+    for (const pad of this.offsetPadPoints) {
+      const targetPoints = this.targetPointMap.get(pad.id) || [];
+      if (targetPoints.length === 0) continue;
+      const padX = currentX + pad.offsetX;
+      const padY = currentY + pad.offsetY;
+      for (const targetPoint of targetPoints) {
+        const dx2 = padX - targetPoint.x;
+        const dy2 = padY - targetPoint.y;
+        const distance = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+        let weight;
+        if (this.useSquaredDistance) {
+          weight = 1;
+        } else {
+          weight = distance < this.epsilon ? 1e6 : 1 / distance;
+        }
+        const targetForCurrentPos = {
+          x: targetPoint.x - pad.offsetX,
+          y: targetPoint.y - pad.offsetY
+        };
+        weightedSumX += weight * targetForCurrentPos.x;
+        weightedSumY += weight * targetForCurrentPos.y;
+        totalWeight += weight;
       }
-      weightedSumX += weight * targetPoint.x;
-      weightedSumY += weight * targetPoint.y;
-      totalWeight += weight;
     }
     const newPosition = {
       x: totalWeight > 0 ? weightedSumX / totalWeight : currentX,
@@ -1993,13 +2015,65 @@ var IrlsSolver = class extends BaseSolver {
     return this.optimalPosition || this.currentPosition;
   }
   /**
-   * Calculate total distance from current position to all target points
+   * 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;
+  }
+  /**
+   * Get the absolute position for a specific offset pad point
+   */
+  getOffsetPadPosition(padId) {
+    const positions = this.getOffsetPadPositions();
+    return positions.get(padId);
+  }
+  /**
+   * Calculate total distance from current position to all assigned target points
    */
   getTotalDistance(position) {
-    const pos = position || this.currentPosition;
-    return this.targetPoints.reduce((sum, target) => {
-      const dx = pos.x - target.x;
-      const dy = pos.y - target.y;
+    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;
+        if (this.useSquaredDistance) {
+          totalDistance += dx * dx + dy * dy;
+        } else {
+          totalDistance += Math.sqrt(dx * dx + dy * dy);
+        }
+      }
+    }
+    return totalDistance;
+  }
+  /**
+   * Calculate total distance for a specific offset pad point
+   */
+  getDistanceForPad(padId, position) {
+    const pos = position || this.getBestPosition();
+    const pad = this.offsetPadPoints.find((p) => p.id === padId);
+    if (!pad) return 0;
+    const padPosition = {
+      x: pos.x + pad.offsetX,
+      y: pos.y + pad.offsetY
+    };
+    const targetPoints = this.targetPointMap.get(padId) || [];
+    return targetPoints.reduce((sum, target) => {
+      const dx = padPosition.x - target.x;
+      const dy = padPosition.y - target.y;
       if (this.useSquaredDistance) {
         return sum + (dx * dx + dy * dy);
       } else {
@@ -2008,7 +2082,7 @@ var IrlsSolver = class extends BaseSolver {
     }, 0);
   }
   computeProgress() {
-    if (this.targetPoints.length === 0) return 1;
+    if (this.offsetPadPoints.length === 0) return 1;
     const initialDistance = this.getTotalDistance(this.initialPosition);
     const currentDistance = this.getTotalDistance();
     if (initialDistance === 0) return 1;
@@ -2022,26 +2096,52 @@ var IrlsSolver = class extends BaseSolver {
       rects: [],
       circles: []
     };
-    for (const point of this.targetPoints) {
+    const colors = [
+      "#4CAF50",
+      "#2196F3",
+      "#FF9800",
+      "#9C27B0",
+      "#F44336",
+      "#607D8B"
+    ];
+    const currentPos = this.getBestPosition();
+    for (let i = 0; i < this.offsetPadPoints.length; i++) {
+      const pad = this.offsetPadPoints[i];
+      if (!pad) continue;
+      const color = colors[i % colors.length];
+      const targetPoints = this.targetPointMap.get(pad.id) || [];
+      const padPosition = {
+        x: currentPos.x + pad.offsetX,
+        y: currentPos.y + pad.offsetY
+      };
+      for (const point of targetPoints) {
+        graphics.points.push({
+          ...point,
+          color
+        });
+      }
+      for (const point of targetPoints) {
+        graphics.lines.push({
+          points: [padPosition, point],
+          strokeColor: color
+        });
+      }
       graphics.points.push({
-        ...point,
-        color: "#4CAF50"
+        x: padPosition.x,
+        y: padPosition.y,
+        color
       });
     }
     graphics.points.push({
       ...this.currentPosition,
       color: "#f44336"
+      // Red like in IrlsSolver
     });
-    for (const point of this.targetPoints) {
-      graphics.lines.push({
-        points: [this.currentPosition, point],
-        strokeColor: "#666"
-      });
-    }
     if (this.optimalPosition) {
       graphics.points.push({
         ...this.optimalPosition,
         color: "rgba(76, 175, 80, 0.3)"
+        // Semi-transparent green like in IrlsSolver
       });
     }
     return graphics;
@@ -2213,31 +2313,27 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       componentToPack: this.componentToPack
     };
   }
-  _getPackedComponentBounds(params = {}) {
-    const bounds = this.packedComponents.reduce(
-      (acc, component) => {
-        const componentBounds = getComponentBounds(component, 0);
-        return {
-          minX: Math.min(acc.minX, componentBounds.minX),
-          minY: Math.min(acc.minY, componentBounds.minY),
-          maxX: Math.max(acc.maxX, componentBounds.maxX),
-          maxY: Math.max(acc.maxY, componentBounds.maxY)
-        };
-      },
-      { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }
-    );
-    if (params?.margin) {
-      return {
-        minX: bounds.minX - params.margin,
-        minY: bounds.minY - params.margin,
-        maxX: bounds.maxX + params.margin,
-        maxY: bounds.maxY + params.margin
-      };
+  _getOutlineBoundsWithMargin(params = {}) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const [p1, p2] of this.fullOutline) {
+      minX = Math.min(minX, p1.x, p2.x);
+      minY = Math.min(minY, p1.y, p2.y);
+      maxX = Math.max(maxX, p1.x, p2.x);
+      maxY = Math.max(maxY, p1.y, p2.y);
     }
-    return bounds;
+    const margin = params.margin ?? 0;
+    return {
+      minX: minX - margin,
+      minY: minY - margin,
+      maxX: maxX + margin,
+      maxY: maxY + margin
+    };
   }
   _setup() {
-    const targetPoints = this.getNetworkTargetPoints();
+    const { offsetPadPoints, targetPointMap } = this.getNetworkTargetPointMappings();
     const [p1, p2] = this.outlineSegment;
     const constraintFn = (point) => {
       const projectedPoint = this.projectPointOntoSegment(
@@ -2250,11 +2346,11 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     const componentBounds = getInputComponentBounds(this.componentToPack, {
       rotationDegrees: this.componentRotationDegrees
     });
-    const packedComponentBoundsWithMargin = this._getPackedComponentBounds({
+    const packedComponentBoundsWithMargin = this._getOutlineBoundsWithMargin({
       margin: Math.max(
         componentBounds.maxX - componentBounds.minX,
         componentBounds.maxY - componentBounds.minY
-      ) * 2
+      ) * 2 + this.minGap * 2
     });
     const largestRectSolverParams = {
       fullOutline: this.fullOutline.flatMap(([p]) => p),
@@ -2314,14 +2410,14 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       x: (vp1.x + vp2.x) / 2,
       y: (vp1.y + vp2.y) / 2
     });
-    this.irlsSolver = new IrlsSolver({
-      targetPoints,
+    this.irlsSolver = new MultiOffsetIrlsSolver({
+      offsetPadPoints,
+      targetPointMap,
       initialPosition,
       constraintFn,
       epsilon: 1e-6,
       maxIterations: 50,
-      useSquaredDistance: true
-      // this.packStrategy === "minimum_sum_squared_distance_to_network",
+      useSquaredDistance: this.packStrategy === "minimum_sum_squared_distance_to_network"
     });
   }
   _step() {
@@ -2340,20 +2436,28 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     }
   }
   /**
-   * Get target points from network connections, considering the component's rotation
+   * Get pad offset points and target point mappings for network connections
    */
-  getNetworkTargetPoints() {
-    const targetPoints = [];
+  getNetworkTargetPointMappings() {
     const rotatedPads = this.getRotatedComponentPads();
-    const componentNetworkIds = new Set(rotatedPads.map((pad) => pad.networkId));
-    for (const packedComponent of this.packedComponents) {
-      for (const pad of packedComponent.pads) {
-        if (componentNetworkIds.has(pad.networkId)) {
-          targetPoints.push(pad.absoluteCenter);
+    const offsetPadPoints = rotatedPads.map((pad) => ({
+      id: pad.padId,
+      offsetX: pad.offset.x,
+      offsetY: pad.offset.y
+    }));
+    const targetPointMap = /* @__PURE__ */ new Map();
+    for (const pad of rotatedPads) {
+      const targetPoints = [];
+      for (const packedComponent of this.packedComponents) {
+        for (const packedPad of packedComponent.pads) {
+          if (packedPad.networkId === pad.networkId) {
+            targetPoints.push(packedPad.absoluteCenter);
+          }
         }
       }
+      targetPointMap.set(pad.padId, targetPoints);
     }
-    return targetPoints;
+    return { offsetPadPoints, targetPointMap };
   }
   /**
    * Project a point onto the outline segment
@@ -2579,13 +2683,6 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       }
     }
     if (this.irlsSolver) {
-      const targetPoints = this.getNetworkTargetPoints();
-      for (const point of targetPoints) {
-        graphics.points.push({
-          ...point,
-          color: "#4CAF50"
-        });
-      }
       const currentPos = this.irlsSolver.currentPosition;
       graphics.points.push({
         ...currentPos,
@@ -2700,6 +2797,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
     this.currentRotationIndex = 0;
   }
   executeSegmentCandidatePhase() {
+    console.log("executeSegmentCandidatePhase");
     if (this.activeSubSolver?.solved || this.activeSubSolver?.failed) {
       const queuedSegment = this.queuedOutlineSegments[this.currentSegmentIndex];
       const rotation = queuedSegment.availableRotations[this.currentRotationIndex];
@@ -2707,15 +2805,23 @@ var SingleComponentPackSolver = class extends BaseSolver {
       let optimalPosition;
       if (this.activeSubSolver.solved && this.activeSubSolver.optimalPosition) {
         optimalPosition = this.activeSubSolver.optimalPosition;
-        distance = this.calculateDistance(optimalPosition, rotation);
-        this.candidateResults.push({
-          segment: queuedSegment.segment,
-          rotation,
-          optimalPosition,
-          distance,
-          segmentIndex: queuedSegment.segmentIndex,
-          rotationIndex: this.currentRotationIndex
+        const hasOverlap = checkOverlapWithPackedComponents({
+          component: this.createPackedComponent(optimalPosition, rotation),
+          packedComponents: this.packedComponents,
+          minGap: this.minGap
         });
+        console.log("hasOverlap", hasOverlap);
+        if (!hasOverlap) {
+          distance = this.calculateDistance(optimalPosition, rotation);
+          this.candidateResults.push({
+            segment: queuedSegment.segment,
+            rotation,
+            optimalPosition,
+            distance,
+            segmentIndex: queuedSegment.segmentIndex,
+            rotationIndex: this.currentRotationIndex
+          });
+        }
       }
       this.currentRotationIndex++;
       this.activeSubSolver = void 0;

package/package.json

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