calculate-packing 0.0.16 → 0.0.18

package/dist/index.d.ts

@@ -36,8 +36,10 @@ interface PackedComponent extends InputComponent {
         x: number;
         y: number;
     };
-    /** Rotation in degrees (counterclockwise) */
+    /** @deprecated Rotation in degrees (counterclockwise) */
     ccwRotationOffset: number;
+    /** Rotation in degrees (counterclockwise) - output field */
+    ccwRotationDegrees?: number;
     pads: OutputPad[];
 }
 interface PackInput {

package/dist/index.js

@@ -415,47 +415,6 @@ var getSegmentsFromPad = (pad, { padding = 0 } = {}) => {
   return segments;
 };
 
-// lib/PackSolver/computeGlobalCenter.ts
-function computeGlobalCenter(packedComponents) {
-  if (!packedComponents.length) return { x: 0, y: 0 };
-  const sum = packedComponents.reduce(
-    (acc, component) => ({
-      x: acc.x + component.center.x,
-      y: acc.y + component.center.y
-    }),
-    { x: 0, y: 0 }
-  );
-  return {
-    x: sum.x / packedComponents.length,
-    y: sum.y / packedComponents.length
-  };
-}
-
-// lib/PackSolver/findBestPointForDisconnected.ts
-function findBestPointForDisconnected({
-  outlines,
-  direction,
-  packedComponents
-}) {
-  const points = outlines.flatMap(
-    (outline) => outline.map(([p1, p2]) => ({
-      x: (p1.x + p2.x) / 2,
-      y: (p1.y + p2.y) / 2
-    }))
-  );
-  if (!points.length) return { x: 0, y: 0 };
-  if (direction !== "nearest_to_center") {
-    const extreme = direction === "left" || direction === "down" ? Math.min : Math.max;
-    const key = direction === "left" || direction === "right" ? "x" : "y";
-    const target = extreme(...points.map((p) => p[key]));
-    return points.find((p) => p[key] === target);
-  }
-  const center = computeGlobalCenter(packedComponents);
-  return points.reduce(
-    (best, point) => Math.hypot(point.x - center.x, point.y - center.y) < Math.hypot(best.x - center.x, best.y - center.y) ? point : best
-  );
-}
-
 // lib/PackSolver/setPackedComponentPadCenters.ts
 var setPackedComponentPadCenters = (packedComponent) => {
   packedComponent.pads = packedComponent.pads.map((pad) => {
@@ -477,66 +436,6 @@ var setPackedComponentPadCenters = (packedComponent) => {
   });
 };
 
-// lib/PackSolver/placeComponentAtPoint.ts
-function placeComponentAtPoint({
-  component,
-  point,
-  candidateAngles,
-  checkOverlap
-}) {
-  const evaluatedPositionShadows = [];
-  for (const angle of candidateAngles) {
-    const pads = component.pads.map((pad) => {
-      const rotatedOffset = rotatePoint(pad.offset, angle * Math.PI / 180);
-      return {
-        ...pad,
-        absoluteCenter: {
-          x: point.x + rotatedOffset.x,
-          y: point.y + rotatedOffset.y
-        }
-      };
-    });
-    const candidate = {
-      ...component,
-      center: point,
-      ccwRotationOffset: angle,
-      pads
-    };
-    evaluatedPositionShadows.push(candidate);
-    if (!checkOverlap(candidate)) {
-      Object.assign(component, candidate);
-      setPackedComponentPadCenters(component);
-      return evaluatedPositionShadows;
-    }
-  }
-  component.center = point;
-  component.ccwRotationOffset = 0;
-  setPackedComponentPadCenters(component);
-  return evaluatedPositionShadows;
-}
-
-// lib/PackSolver/placeComponentDisconnected.ts
-function placeComponentDisconnected({
-  component,
-  outlines,
-  direction,
-  packedComponents,
-  candidateAngles,
-  checkOverlap
-}) {
-  const targetPoint = findBestPointForDisconnected({
-    outlines,
-    direction,
-    packedComponents
-  });
-  return placeComponentAtPoint({
-    component,
-    point: targetPoint,
-    candidateAngles,
-    checkOverlap
-  });
-}
-
 // lib/PackSolver/sortComponentQueue.ts
 function sortComponentQueue({
   components,
@@ -799,26 +698,7 @@ var PhasedPackSolver = class extends BaseSolver {
         (id) => networkIdsInNewPackedComponent.has(id)
       )
     );
-    if (sharedNetworkIds.size === 0) {
-      this.phaseData.candidatePoints = [];
-      this.phaseData.goodCandidates = [];
-      const shadows = placeComponentDisconnected({
-        component: newPackedComponent,
-        outlines,
-        direction: disconnectedPackDirection,
-        packedComponents: this.packedComponents,
-        candidateAngles: this.getCandidateAngles(newPackedComponent),
-        checkOverlap: (comp) => this.checkOverlapWithPackedComponents(comp)
-      });
-      this.phaseData.selectedRotation = newPackedComponent;
-      this.phaseData.rotationTrials = shadows.map((s) => ({
-        ...s,
-        cost: 0,
-        anchorType: "center",
-        hasOverlap: false
-      }));
-      return;
-    }
+    const isDisconnected = sharedNetworkIds.size === 0;
     const candidatePoints = [];
     const goodCandidates = [];
     let smallestDistance = Number.POSITIVE_INFINITY;
@@ -827,19 +707,81 @@ var PhasedPackSolver = class extends BaseSolver {
       const [p1, p2] = segment;
       return `${p1.x.toFixed(6)},${p1.y.toFixed(6)}-${p2.x.toFixed(6)},${p2.y.toFixed(6)}`;
     };
+    const packedClusterCenter = this.packedComponents.length > 0 ? {
+      x: this.packedComponents.reduce((sum, c) => sum + c.center.x, 0) / this.packedComponents.length,
+      y: this.packedComponents.reduce((sum, c) => sum + c.center.y, 0) / this.packedComponents.length
+    } : { x: 0, y: 0 };
     const networkIdToAlreadyPackedSegments = /* @__PURE__ */ new Map();
-    for (const sharedNetworkId of sharedNetworkIds) {
-      const segments = [];
-      for (const packedComponent of this.packedComponents) {
-        for (const pad of packedComponent.pads) {
-          if (pad.networkId === sharedNetworkId) {
-            segments.push(...getSegmentsFromPad(pad));
+    if (!isDisconnected) {
+      for (const sharedNetworkId of sharedNetworkIds) {
+        const segments = [];
+        for (const packedComponent of this.packedComponents) {
+          for (const pad of packedComponent.pads) {
+            if (pad.networkId === sharedNetworkId) {
+              segments.push(...getSegmentsFromPad(pad));
+            }
           }
         }
+        networkIdToAlreadyPackedSegments.set(sharedNetworkId, segments);
       }
-      networkIdToAlreadyPackedSegments.set(sharedNetworkId, segments);
     }
-    if (packPlacementStrategy === "minimum_sum_distance_to_network" || packPlacementStrategy === "minimum_sum_squared_distance_to_network") {
+    if (isDisconnected) {
+      for (const outline of outlines) {
+        for (const outlineSegment of outline) {
+          const [p1, p2] = outlineSegment;
+          for (let t = 0; t <= 1; t += 0.1) {
+            const sampledPoint = {
+              x: p1.x + t * (p2.x - p1.x),
+              y: p1.y + t * (p2.y - p1.y)
+            };
+            let distance = 0;
+            if (disconnectedPackDirection === "nearest_to_center") {
+              distance = Math.sqrt(
+                Math.pow(sampledPoint.x - packedClusterCenter.x, 2) + Math.pow(sampledPoint.y - packedClusterCenter.y, 2)
+              );
+            } else if (disconnectedPackDirection === "left") {
+              distance = sampledPoint.x;
+              distance += 1e-3 * Math.abs(sampledPoint.y - packedClusterCenter.y);
+            } else if (disconnectedPackDirection === "right") {
+              distance = -sampledPoint.x;
+              distance += 1e-3 * Math.abs(sampledPoint.y - packedClusterCenter.y);
+            } else if (disconnectedPackDirection === "up") {
+              distance = -sampledPoint.y;
+              distance += 1e-3 * Math.abs(sampledPoint.x - packedClusterCenter.x);
+            } else if (disconnectedPackDirection === "down") {
+              distance = sampledPoint.y;
+              distance += 1e-3 * Math.abs(sampledPoint.x - packedClusterCenter.x);
+            }
+            const point = {
+              ...sampledPoint,
+              networkId: "disconnected",
+              distance
+            };
+            candidatePoints.push(point);
+            const segmentKey = getSegmentKey(outlineSegment);
+            const currentSegmentBest = segmentBestPoints.get(segmentKey);
+            if (!currentSegmentBest || distance < currentSegmentBest.distance) {
+              segmentBestPoints.set(segmentKey, {
+                point: {
+                  ...sampledPoint,
+                  networkId: "disconnected"
+                },
+                distance
+              });
+            }
+            if (distance < smallestDistance + 1e-6) {
+              if (distance < smallestDistance - 1e-6) {
+                goodCandidates.length = 0;
+                goodCandidates.push(point);
+                smallestDistance = distance;
+              } else {
+                goodCandidates.push(point);
+              }
+            }
+          }
+        }
+      }
+    } else if (packPlacementStrategy === "minimum_sum_distance_to_network" || packPlacementStrategy === "minimum_sum_squared_distance_to_network") {
       for (const outline of outlines) {
         for (const outlineSegment of outline) {
           const [p1, p2] = outlineSegment;
@@ -933,45 +875,47 @@ var PhasedPackSolver = class extends BaseSolver {
         }
       }
     }
-    for (const sharedNetworkId of sharedNetworkIds) {
-      for (const outline of outlines) {
-        for (const outlineSegment of outline) {
-          const [p1, p2] = outlineSegment;
-          for (let t = 0; t <= 1; t += 0.2) {
-            const sampledPoint = {
-              x: p1.x + t * (p2.x - p1.x),
-              y: p1.y + t * (p2.y - p1.y)
-            };
-            let distance = 0;
-            const componentPadsOnNetwork = newPackedComponent.pads.filter(
-              (p) => p.networkId === sharedNetworkId
-            );
-            for (const _ of componentPadsOnNetwork) {
-              let minDist = Number.POSITIVE_INFINITY;
-              for (const packedComponent of this.packedComponents) {
-                for (const packedPad of packedComponent.pads) {
-                  if (packedPad.networkId === sharedNetworkId) {
-                    const dx = sampledPoint.x - packedPad.absoluteCenter.x;
-                    const dy = sampledPoint.y - packedPad.absoluteCenter.y;
-                    const dist = Math.sqrt(dx * dx + dy * dy);
-                    minDist = Math.min(minDist, dist);
+    if (!isDisconnected) {
+      for (const sharedNetworkId of sharedNetworkIds) {
+        for (const outline of outlines) {
+          for (const outlineSegment of outline) {
+            const [p1, p2] = outlineSegment;
+            for (let t = 0; t <= 1; t += 0.2) {
+              const sampledPoint = {
+                x: p1.x + t * (p2.x - p1.x),
+                y: p1.y + t * (p2.y - p1.y)
+              };
+              let distance = 0;
+              const componentPadsOnNetwork = newPackedComponent.pads.filter(
+                (p) => p.networkId === sharedNetworkId
+              );
+              for (const _ of componentPadsOnNetwork) {
+                let minDist = Number.POSITIVE_INFINITY;
+                for (const packedComponent of this.packedComponents) {
+                  for (const packedPad of packedComponent.pads) {
+                    if (packedPad.networkId === sharedNetworkId) {
+                      const dx = sampledPoint.x - packedPad.absoluteCenter.x;
+                      const dy = sampledPoint.y - packedPad.absoluteCenter.y;
+                      const dist = Math.sqrt(dx * dx + dy * dy);
+                      minDist = Math.min(minDist, dist);
+                    }
                   }
                 }
+                distance += minDist;
+              }
+              const point = {
+                ...sampledPoint,
+                networkId: sharedNetworkId,
+                distance
+              };
+              candidatePoints.push(point);
+              if (distance < smallestDistance) {
+                smallestDistance = distance;
+                goodCandidates.length = 0;
+                goodCandidates.push(point);
+              } else if (distance === smallestDistance) {
+                goodCandidates.push(point);
               }
-              distance += minDist;
-            }
-            const point = {
-              ...sampledPoint,
-              networkId: sharedNetworkId,
-              distance
-            };
-            candidatePoints.push(point);
-            if (distance < smallestDistance) {
-              smallestDistance = distance;
-              goodCandidates.length = 0;
-              goodCandidates.push(point);
-            } else if (distance === smallestDistance) {
-              goodCandidates.push(point);
             }
           }
         }
@@ -1023,6 +967,14 @@ var PhasedPackSolver = class extends BaseSolver {
         }
       }
     }
+    const isDisconnected = this.phaseData.goodCandidates.some(
+      (c) => c.networkId === "disconnected"
+    );
+    const packedClusterCenter = this.packedComponents.length > 0 ? {
+      x: this.packedComponents.reduce((sum, c) => sum + c.center.x, 0) / this.packedComponents.length,
+      y: this.packedComponents.reduce((sum, c) => sum + c.center.y, 0) / this.packedComponents.length
+    } : { x: 0, y: 0 };
+    const { disconnectedPackDirection = "nearest_to_center" } = this.packInput;
     const useSquaredDistance = this.packInput.packPlacementStrategy === "minimum_sum_squared_distance_to_network";
     for (const angle of candidateAngles) {
       for (const point of this.phaseData.goodCandidates) {
@@ -1045,20 +997,40 @@ var PhasedPackSolver = class extends BaseSolver {
           setPackedComponentPadCenters(trial);
           const hasOverlap = this.checkOverlapWithPackedComponents(trial);
           let cost = 0;
-          for (const pad of trial.pads) {
-            let minDist = Number.POSITIVE_INFINITY;
-            for (const packedComp of this.packedComponents) {
-              for (const packedPad of packedComp.pads) {
-                if (packedPad.networkId === pad.networkId) {
-                  const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
-                  const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
-                  const dist = Math.sqrt(dx * dx + dy * dy);
-                  minDist = Math.min(minDist, dist);
+          if (isDisconnected) {
+            if (disconnectedPackDirection === "nearest_to_center") {
+              cost = Math.sqrt(
+                Math.pow(componentCenter.x - packedClusterCenter.x, 2) + Math.pow(componentCenter.y - packedClusterCenter.y, 2)
+              );
+            } else if (disconnectedPackDirection === "left") {
+              cost = componentCenter.x;
+              cost += 1e-3 * Math.abs(componentCenter.y - packedClusterCenter.y);
+            } else if (disconnectedPackDirection === "right") {
+              cost = -componentCenter.x;
+              cost += 1e-3 * Math.abs(componentCenter.y - packedClusterCenter.y);
+            } else if (disconnectedPackDirection === "up") {
+              cost = -componentCenter.y;
+              cost += 1e-3 * Math.abs(componentCenter.x - packedClusterCenter.x);
+            } else if (disconnectedPackDirection === "down") {
+              cost = componentCenter.y;
+              cost += 1e-3 * Math.abs(componentCenter.x - packedClusterCenter.x);
+            }
+          } else {
+            for (const pad of trial.pads) {
+              let minDist = Number.POSITIVE_INFINITY;
+              for (const packedComp of this.packedComponents) {
+                for (const packedPad of packedComp.pads) {
+                  if (packedPad.networkId === pad.networkId) {
+                    const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
+                    const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    minDist = Math.min(minDist, dist);
+                  }
                 }
               }
-            }
-            if (minDist < Number.POSITIVE_INFINITY) {
-              cost += useSquaredDistance ? minDist * minDist : minDist;
+              if (minDist < Number.POSITIVE_INFINITY) {
+                cost += useSquaredDistance ? minDist * minDist : minDist;
+              }
             }
           }
           rotationTrials.push({
@@ -1075,20 +1047,40 @@ var PhasedPackSolver = class extends BaseSolver {
         setPackedComponentPadCenters(centerTrial);
         const centerHasOverlap = this.checkOverlapWithPackedComponents(centerTrial);
         let centerCost = 0;
-        for (const pad of centerTrial.pads) {
-          let minDist = Number.POSITIVE_INFINITY;
-          for (const packedComp of this.packedComponents) {
-            for (const packedPad of packedComp.pads) {
-              if (packedPad.networkId === pad.networkId) {
-                const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
-                const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
-                const dist = Math.sqrt(dx * dx + dy * dy);
-                minDist = Math.min(minDist, dist);
+        if (isDisconnected) {
+          if (disconnectedPackDirection === "nearest_to_center") {
+            centerCost = Math.sqrt(
+              Math.pow(centerTrial.center.x - packedClusterCenter.x, 2) + Math.pow(centerTrial.center.y - packedClusterCenter.y, 2)
+            );
+          } else if (disconnectedPackDirection === "left") {
+            centerCost = centerTrial.center.x;
+            centerCost += 1e-3 * Math.abs(centerTrial.center.y - packedClusterCenter.y);
+          } else if (disconnectedPackDirection === "right") {
+            centerCost = -centerTrial.center.x;
+            centerCost += 1e-3 * Math.abs(centerTrial.center.y - packedClusterCenter.y);
+          } else if (disconnectedPackDirection === "up") {
+            centerCost = -centerTrial.center.y;
+            centerCost += 1e-3 * Math.abs(centerTrial.center.x - packedClusterCenter.x);
+          } else if (disconnectedPackDirection === "down") {
+            centerCost = centerTrial.center.y;
+            centerCost += 1e-3 * Math.abs(centerTrial.center.x - packedClusterCenter.x);
+          }
+        } else {
+          for (const pad of centerTrial.pads) {
+            let minDist = Number.POSITIVE_INFINITY;
+            for (const packedComp of this.packedComponents) {
+              for (const packedPad of packedComp.pads) {
+                if (packedPad.networkId === pad.networkId) {
+                  const dx = pad.absoluteCenter.x - packedPad.absoluteCenter.x;
+                  const dy = pad.absoluteCenter.y - packedPad.absoluteCenter.y;
+                  const dist = Math.sqrt(dx * dx + dy * dy);
+                  minDist = Math.min(minDist, dist);
+                }
               }
             }
-          }
-          if (minDist < Number.POSITIVE_INFINITY) {
-            centerCost += useSquaredDistance ? minDist * minDist : minDist;
+            if (minDist < Number.POSITIVE_INFINITY) {
+              centerCost += useSquaredDistance ? minDist * minDist : minDist;
+            }
           }
         }
         rotationTrials.push({
@@ -1326,7 +1318,10 @@ var PhasedPackSolver = class extends BaseSolver {
     return [this.packInput];
   }
   getResult() {
-    return this.packedComponents;
+    return this.packedComponents.map((component) => ({
+      ...component,
+      ccwRotationDegrees: component.ccwRotationOffset
+    }));
   }
   /* ---------- small helpers ------------------------------------------------ */
   getCandidateAngles(c) {
@@ -1347,7 +1342,7 @@ var pack = (input) => {
   solver.solve();
   return {
     ...input,
-    components: solver.packedComponents
+    components: solver.getResult()
   };
 };
 

package/package.json

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