calculate-packing 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -43,7 +43,7 @@ interface PackInput {
     components: InputComponent[];
     minGap: number;
     packOrderStrategy: "largest_to_smallest";
-    packPlacementStrategy: "shortest_connection_along_outline";
+    packPlacementStrategy: "shortest_connection_along_outline" | "minimum_sum_distance_to_network";
     disconnectedPackDirection?: "left" | "right" | "up" | "down" | "nearest_to_center";
     packFirst?: ComponentId[];
 }
@@ -140,6 +140,7 @@ declare class PackSolver extends BaseSolver {
     /** 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?: {

package/dist/index.js

@@ -354,6 +354,271 @@ function computeNearestPointOnSegmentForSegmentSet(segmentA, segmentSet) {
 
 // lib/PackSolver/PackSolver.ts
 import { computeDistanceBetweenBoxes } from "@tscircuit/math-utils";
+
+// lib/PackSolver/translationOptimizer.ts
+function computeTranslationBounds(component, initialCenter, packedComponents, minGap) {
+  const componentBounds = getComponentBounds(component, 0);
+  const componentWidth = componentBounds.maxX - componentBounds.minX;
+  const componentHeight = componentBounds.maxY - componentBounds.minY;
+  let minX = Number.NEGATIVE_INFINITY;
+  let maxX = Number.POSITIVE_INFINITY;
+  let minY = Number.NEGATIVE_INFINITY;
+  let maxY = Number.POSITIVE_INFINITY;
+  for (const packedComp of packedComponents) {
+    const packedBounds = getComponentBounds(packedComp, 0);
+    const packedWidth = packedBounds.maxX - packedBounds.minX;
+    const packedHeight = packedBounds.maxY - packedBounds.minY;
+    const minCenterDistanceX = minGap + (componentWidth + packedWidth) / 2;
+    const minCenterDistanceY = minGap + (componentHeight + packedHeight) / 2;
+    const packedCenterX = packedComp.center.x;
+    const packedCenterY = packedComp.center.y;
+    const leftBound = packedCenterX - minCenterDistanceX;
+    const rightBound = packedCenterX + minCenterDistanceX;
+    const bottomBound = packedCenterY - minCenterDistanceY;
+    const topBound = packedCenterY + minCenterDistanceY;
+    if (Math.abs(packedCenterX - initialCenter.x) > Math.abs(packedCenterY - initialCenter.y)) {
+      if (packedCenterX < initialCenter.x) {
+        minX = Math.max(minX, rightBound);
+      } else {
+        maxX = Math.min(maxX, leftBound);
+      }
+    } else {
+      if (packedCenterY < initialCenter.y) {
+        minY = Math.max(minY, topBound);
+      } else {
+        maxY = Math.min(maxY, bottomBound);
+      }
+    }
+  }
+  const maxTranslation = 5;
+  minX = Math.max(minX, initialCenter.x - maxTranslation);
+  maxX = Math.min(maxX, initialCenter.x + maxTranslation);
+  minY = Math.max(minY, initialCenter.y - maxTranslation);
+  maxY = Math.min(maxY, initialCenter.y + maxTranslation);
+  return { minX, maxX, minY, maxY };
+}
+function calculateSumDistance(component, candidateCenter, packedComponents) {
+  const packedPads = packedComponents.flatMap((c) => c.pads);
+  const connectedPads = component.pads.filter(
+    (pad) => packedPads.some((pp) => pp.networkId === pad.networkId)
+  );
+  if (connectedPads.length === 0) return 0;
+  let sumDistance = 0;
+  for (const pad of connectedPads) {
+    const padAbsolutePos = {
+      x: candidateCenter.x + pad.offset.x,
+      y: candidateCenter.y + pad.offset.y
+    };
+    const sameNetPads = packedPads.filter(
+      (pp) => pp.networkId === pad.networkId
+    );
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (const packedPad of sameNetPads) {
+      const distance = Math.hypot(
+        padAbsolutePos.x - packedPad.absoluteCenter.x,
+        padAbsolutePos.y - packedPad.absoluteCenter.y
+      );
+      if (distance < minDistance) {
+        minDistance = distance;
+      }
+    }
+    sumDistance += minDistance === Number.POSITIVE_INFINITY ? 0 : minDistance;
+  }
+  return sumDistance;
+}
+function checkOverlap(component, candidateCenter, packedComponents, minGap) {
+  const tempComponent = {
+    ...component,
+    center: candidateCenter,
+    pads: component.pads.map((p) => ({
+      ...p,
+      absoluteCenter: {
+        x: candidateCenter.x + p.offset.x,
+        y: candidateCenter.y + p.offset.y
+      }
+    }))
+  };
+  const componentBounds = getComponentBounds(tempComponent, 0);
+  const componentBox = {
+    center: {
+      x: (componentBounds.minX + componentBounds.maxX) / 2,
+      y: (componentBounds.minY + componentBounds.maxY) / 2
+    },
+    width: componentBounds.maxX - componentBounds.minX,
+    height: componentBounds.maxY - componentBounds.minY
+  };
+  for (const packedComp of packedComponents) {
+    const packedBounds = getComponentBounds(packedComp, 0);
+    const packedBox = {
+      center: {
+        x: (packedBounds.minX + packedBounds.maxX) / 2,
+        y: (packedBounds.minY + packedBounds.maxY) / 2
+      },
+      width: packedBounds.maxX - packedBounds.minX,
+      height: packedBounds.maxY - packedBounds.minY
+    };
+    const centerDistance = Math.hypot(
+      componentBox.center.x - packedBox.center.x,
+      componentBox.center.y - packedBox.center.y
+    );
+    const minRequiredDistance = minGap + (componentBox.width + packedBox.width) / 2;
+    if (centerDistance < minRequiredDistance) {
+      return true;
+    }
+  }
+  return false;
+}
+function clampToBounds(p, b) {
+  return {
+    x: Math.min(Math.max(p.x, b.minX), b.maxX),
+    y: Math.min(Math.max(p.y, b.minY), b.maxY)
+  };
+}
+function dist(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.hypot(dx, dy);
+}
+function backtrackToFeasible(from, to, isFeasible, maxTrials = 20) {
+  let lo = 0;
+  let hi = 1;
+  let best = null;
+  for (let i = 0; i < maxTrials; i++) {
+    const t = (lo + hi) / 2;
+    const cand = {
+      x: from.x + (to.x - from.x) * t,
+      y: from.y + (to.y - from.y) * t
+    };
+    if (isFeasible(cand)) {
+      best = cand;
+      lo = t;
+    } else {
+      hi = t;
+    }
+  }
+  return best ?? from;
+}
+function geometricMedianConstrained(targets, start, bounds, maxIter = 100, tol = 1e-4) {
+  let c = clampToBounds(start, bounds);
+  const eps = 1e-9;
+  for (let k = 0; k < maxIter; k++) {
+    for (const p of targets) {
+      if (dist(c, p) <= eps) return clampToBounds(p, bounds);
+    }
+    let numX = 0;
+    let numY = 0;
+    let den = 0;
+    for (const p of targets) {
+      const d = dist(c, p);
+      const w = 1 / Math.max(d, eps);
+      numX += p.x * w;
+      numY += p.y * w;
+      den += w;
+    }
+    if (den === 0) break;
+    const next = clampToBounds({ x: numX / den, y: numY / den }, bounds);
+    if (dist(next, c) < tol) return next;
+    c = next;
+  }
+  return c;
+}
+function optimizeTranslationForMinimumSum(context) {
+  const { component, initialCenter, packedComponents, minGap } = context;
+  const bounds = computeTranslationBounds(
+    component,
+    initialCenter,
+    packedComponents,
+    minGap
+  );
+  if (bounds.minX >= bounds.maxX || bounds.minY >= bounds.maxY) {
+    return initialCenter;
+  }
+  const packedPads = packedComponents.flatMap((c) => c.pads);
+  const connectedPads = component.pads.filter(
+    (pad) => packedPads.some((pp) => pp.networkId === pad.networkId)
+  );
+  if (connectedPads.length === 0) return initialCenter;
+  const assignTargets = (center2) => {
+    const results = [];
+    for (const pad of connectedPads) {
+      const padAbs = { x: center2.x + pad.offset.x, y: center2.y + pad.offset.y };
+      let best = null;
+      for (let j = 0; j < packedPads.length; j++) {
+        const pp = packedPads[j];
+        if (!pp || pp.networkId !== pad.networkId) continue;
+        const d = Math.hypot(
+          padAbs.x - pp.absoluteCenter.x,
+          padAbs.y - pp.absoluteCenter.y
+        );
+        if (!best || d < dist(padAbs, best.p)) {
+          best = {
+            p: {
+              x: pp.absoluteCenter.x - pad.offset.x,
+              y: pp.absoluteCenter.y - pad.offset.y
+            },
+            key: `${pad.networkId}:${j}`
+          };
+        }
+      }
+      if (best) results.push({ targets: best.p, key: best.key });
+    }
+    return results;
+  };
+  let center = clampToBounds(initialCenter, bounds);
+  let prevAssignSignature = "";
+  const maxOuterIters = 30;
+  const tolMove = 1e-3;
+  if (checkOverlap(component, center, packedComponents, minGap)) {
+    const mid = {
+      x: (bounds.minX + bounds.maxX) / 2,
+      y: (bounds.minY + bounds.maxY) / 2
+    };
+    center = backtrackToFeasible(
+      center,
+      mid,
+      (p) => !checkOverlap(component, p, packedComponents, minGap)
+    );
+  }
+  for (let iter = 0; iter < maxOuterIters; iter++) {
+    const assignments = assignTargets(center);
+    if (assignments.length === 0) return initialCenter;
+    const signature = assignments.map((a) => a.key).join("|");
+    const targets = assignments.map((a) => a.targets);
+    const proposed = geometricMedianConstrained(
+      targets,
+      center,
+      bounds,
+      100,
+      1e-4
+    );
+    let next = proposed;
+    if (checkOverlap(component, next, packedComponents, minGap)) {
+      next = backtrackToFeasible(
+        center,
+        proposed,
+        (p) => !checkOverlap(component, p, packedComponents, minGap)
+      );
+    }
+    if (signature === prevAssignSignature && dist(next, center) < tolMove) {
+      center = next;
+      break;
+    }
+    prevAssignSignature = signature;
+    center = next;
+  }
+  const initCost = calculateSumDistance(
+    component,
+    initialCenter,
+    packedComponents
+  );
+  const finalCost = calculateSumDistance(component, center, packedComponents);
+  if (finalCost > initCost && !checkOverlap(component, initialCenter, packedComponents, minGap)) {
+    return initialCenter;
+  }
+  return center;
+}
+
+// lib/PackSolver/PackSolver.ts
 var PackSolver = class extends BaseSolver {
   packInput;
   unpackedComponentQueue;
@@ -365,8 +630,19 @@ var PackSolver = class extends BaseSolver {
     this.packInput = input;
   }
   _setup() {
-    const { components, packOrderStrategy } = this.packInput;
+    const { components, packOrderStrategy, packFirst = [] } = this.packInput;
+    const packFirstMap = /* @__PURE__ */ new Map();
+    packFirst.forEach((componentId, index) => {
+      packFirstMap.set(componentId, index);
+    });
     this.unpackedComponentQueue = [...components].sort((a, b) => {
+      const aPackFirstIndex = packFirstMap.get(a.componentId);
+      const bPackFirstIndex = packFirstMap.get(b.componentId);
+      if (aPackFirstIndex !== void 0 && bPackFirstIndex !== void 0) {
+        return aPackFirstIndex - bPackFirstIndex;
+      }
+      if (aPackFirstIndex !== void 0) return -1;
+      if (bPackFirstIndex !== void 0) return 1;
       if (packOrderStrategy === "largest_to_smallest") {
         return b.pads.length - a.pads.length;
       }
@@ -376,7 +652,11 @@ var PackSolver = class extends BaseSolver {
   }
   _step() {
     if (this.solved) return;
-    const { minGap = 0, disconnectedPackDirection = "nearest_to_center" } = this.packInput;
+    const {
+      minGap = 0,
+      disconnectedPackDirection = "nearest_to_center",
+      packPlacementStrategy = "shortest_connection_along_outline"
+    } = this.packInput;
     if (this.unpackedComponentQueue.length === 0) {
       this.solved = true;
       return;
@@ -442,32 +722,67 @@ var PackSolver = class extends BaseSolver {
     }
     let smallestDistance = Number.POSITIVE_INFINITY;
     let bestPoints = [];
-    for (const outline of outlines) {
-      for (const outlineSegment of outline) {
-        for (const sharedNetworkId of sharedNetworkIds) {
-          const alreadyPackedSegments = networkIdToAlreadyPackedSegments.get(sharedNetworkId);
-          if (!alreadyPackedSegments) continue;
-          const {
-            nearestPoint: nearestPointOnOutlineToAlreadyPackedSegments,
-            dist: outlineToAlreadyPackedSegmentsDist
-          } = computeNearestPointOnSegmentForSegmentSet(
-            outlineSegment,
-            alreadyPackedSegments
-          );
-          if (outlineToAlreadyPackedSegmentsDist < smallestDistance + 1e-6) {
-            if (outlineToAlreadyPackedSegmentsDist < smallestDistance - 1e-6) {
-              bestPoints = [
-                {
+    if (packPlacementStrategy === "minimum_sum_distance_to_network") {
+      for (const outline of outlines) {
+        for (const outlineSegment of outline) {
+          const samplePoints = [
+            outlineSegment[0],
+            {
+              x: (outlineSegment[0].x + outlineSegment[1].x) / 2,
+              y: (outlineSegment[0].y + outlineSegment[1].y) / 2
+            },
+            outlineSegment[1]
+          ];
+          for (const samplePoint of samplePoints) {
+            for (const sharedNetworkId of sharedNetworkIds) {
+              const sumDistance = this.computeSumDistanceForPosition(
+                newPackedComponent,
+                samplePoint,
+                sharedNetworkId
+              );
+              if (sumDistance < smallestDistance + 1e-6) {
+                if (sumDistance < smallestDistance - 1e-6) {
+                  bestPoints = [{ ...samplePoint, networkId: sharedNetworkId }];
+                  smallestDistance = sumDistance;
+                } else {
+                  bestPoints.push({
+                    ...samplePoint,
+                    networkId: sharedNetworkId
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      for (const outline of outlines) {
+        for (const outlineSegment of outline) {
+          for (const sharedNetworkId of sharedNetworkIds) {
+            const alreadyPackedSegments = networkIdToAlreadyPackedSegments.get(sharedNetworkId);
+            if (!alreadyPackedSegments) continue;
+            const {
+              nearestPoint: nearestPointOnOutlineToAlreadyPackedSegments,
+              dist: outlineToAlreadyPackedSegmentsDist
+            } = computeNearestPointOnSegmentForSegmentSet(
+              outlineSegment,
+              alreadyPackedSegments
+            );
+            if (outlineToAlreadyPackedSegmentsDist < smallestDistance + 1e-6) {
+              if (outlineToAlreadyPackedSegmentsDist < smallestDistance - 1e-6) {
+                bestPoints = [
+                  {
+                    ...nearestPointOnOutlineToAlreadyPackedSegments,
+                    networkId: sharedNetworkId
+                  }
+                ];
+                smallestDistance = outlineToAlreadyPackedSegmentsDist;
+              } else {
+                bestPoints.push({
                   ...nearestPointOnOutlineToAlreadyPackedSegments,
                   networkId: sharedNetworkId
-                }
-              ];
-              smallestDistance = outlineToAlreadyPackedSegmentsDist;
-            } else {
-              bestPoints.push({
-                ...nearestPointOnOutlineToAlreadyPackedSegments,
-                networkId: sharedNetworkId
-              });
+                });
+              }
             }
           }
         }
@@ -510,25 +825,65 @@ var PackSolver = class extends BaseSolver {
           ccwRotationOffset: angle,
           pads: transformedPads
         };
-        this.lastEvaluatedPositionShadows?.push(tempComponent);
+        this.lastEvaluatedPositionShadows?.push({ ...tempComponent });
         if (this.checkOverlapWithPackedComponents(tempComponent)) continue;
         let cost = 0;
-        for (const tp of transformedPads) {
-          const sameNetPads = packedPads.filter(
-            (pp) => pp.networkId === tp.networkId
-          );
-          if (!sameNetPads.length) continue;
-          let bestD = Infinity;
-          for (const pp of sameNetPads) {
-            const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
-            const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
-            const d = Math.hypot(dx, dy);
-            if (d < bestD) bestD = d;
+        if (packPlacementStrategy === "minimum_sum_distance_to_network") {
+          const optimizedCenter = optimizeTranslationForMinimumSum({
+            component: tempComponent,
+            initialCenter: candidateCenter,
+            packedComponents: this.packedComponents,
+            minGap
+          });
+          const optimizedTransformedPads = newPackedComponent.pads.map((p) => {
+            const ro = rotatePoint(p.offset, angle);
+            return {
+              ...p,
+              absoluteCenter: {
+                x: optimizedCenter.x + ro.x,
+                y: optimizedCenter.y + ro.y
+              }
+            };
+          });
+          tempComponent.center = optimizedCenter;
+          tempComponent.pads = optimizedTransformedPads;
+          if (optimizedCenter.x !== candidateCenter.x || optimizedCenter.y !== candidateCenter.y) {
+            this.lastEvaluatedPositionShadows?.push({ ...tempComponent });
+          }
+          if (this.checkOverlapWithPackedComponents(tempComponent)) continue;
+          for (const tp of optimizedTransformedPads) {
+            const sameNetPads = packedPads.filter(
+              (pp) => pp.networkId === tp.networkId
+            );
+            if (!sameNetPads.length) continue;
+            let bestD = Infinity;
+            for (const pp of sameNetPads) {
+              const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
+              const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
+              const d = Math.hypot(dx, dy);
+              if (d < bestD) bestD = d;
+            }
+            cost += bestD === Infinity ? 0 : bestD;
+          }
+        } else {
+          for (const tp of transformedPads) {
+            const sameNetPads = packedPads.filter(
+              (pp) => pp.networkId === tp.networkId
+            );
+            if (!sameNetPads.length) continue;
+            let bestD = Infinity;
+            for (const pp of sameNetPads) {
+              const dx = tp.absoluteCenter.x - pp.absoluteCenter.x;
+              const dy = tp.absoluteCenter.y - pp.absoluteCenter.y;
+              const d = Math.hypot(dx, dy);
+              if (d < bestD) bestD = d;
+            }
+            cost += bestD;
           }
-          cost += bestD;
         }
         if (!bestCandidate || cost < bestCandidate.cost) {
-          bestCandidate = { center: candidateCenter, angle, cost };
+          const finalCenter = packPlacementStrategy === "minimum_sum_distance_to_network" ? tempComponent.center : candidateCenter;
+          bestCandidate = { center: finalCenter, angle, cost };
         }
       }
       if (bestCandidate) {
@@ -599,12 +954,6 @@ var PackSolver = class extends BaseSolver {
       }))
     );
     if (!pts.length) return { x: 0, y: 0 };
-    const cmp = {
-      left: (p, v) => p.x < v,
-      right: (p, v) => p.x > v,
-      down: (p, v) => p.y < v,
-      up: (p, v) => p.y > v
-    };
     if (dir !== "nearest_to_center") {
       const extreme = dir === "left" || dir === "down" ? Math.min : Math.max;
       const key = dir === "left" || dir === "right" ? "x" : "y";
@@ -707,6 +1056,35 @@ d=${this.lastBestPointsResult.distance}`
   getResult() {
     return this.packedComponents;
   }
+  computeSumDistanceForPosition(component, position, targetNetworkId) {
+    const componentPadsOnNetwork = component.pads.filter(
+      (p) => p.networkId === targetNetworkId
+    );
+    if (componentPadsOnNetwork.length === 0) return 0;
+    const packedPadsOnNetwork = this.packedComponents.flatMap(
+      (c) => c.pads.filter((p) => p.networkId === targetNetworkId)
+    );
+    if (packedPadsOnNetwork.length === 0) return 0;
+    let sumDistance = 0;
+    for (const componentPad of componentPadsOnNetwork) {
+      const padPosition = {
+        x: position.x + componentPad.offset.x,
+        y: position.y + componentPad.offset.y
+      };
+      let minDistance = Number.POSITIVE_INFINITY;
+      for (const packedPad of packedPadsOnNetwork) {
+        const distance = Math.hypot(
+          padPosition.x - packedPad.absoluteCenter.x,
+          padPosition.y - packedPad.absoluteCenter.y
+        );
+        if (distance < minDistance) {
+          minDistance = distance;
+        }
+      }
+      sumDistance += minDistance === Number.POSITIVE_INFINITY ? 0 : minDistance;
+    }
+    return sumDistance;
+  }
 };
 
 // lib/pack.ts

package/package.json

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