calculate-packing 0.0.37 → 0.0.38

package/dist/index.d.ts

@@ -92,6 +92,7 @@ declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?:
         top: number;
         bottom: number;
     }>;
+    obstacles?: InputObstacle[];
 }) => PackOutput;
 
 declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;

package/dist/index.js

@@ -203,17 +203,49 @@ var createPadPolygons = (component, minGap) => {
     return { poly, bbox };
   });
 };
+var createObstaclePolygons = (obstacles, minGap) => {
+  return obstacles.map((obs) => {
+    const hw = obs.width / 2 + minGap;
+    const hh = obs.height / 2 + minGap;
+    const cx = obs.absoluteCenter.x;
+    const cy = obs.absoluteCenter.y;
+    const worldCorners = [
+      { x: cx - hw, y: cy - hh },
+      { x: cx + hw, y: cy - hh },
+      { x: cx + hw, y: cy + hh },
+      { x: cx - hw, y: cy + hh }
+    ];
+    const arr = worldCorners.map(({ x, y }) => [x, y]);
+    const poly = new Flatten.Polygon(arr);
+    const xs = worldCorners.map((p) => p.x);
+    const ys = worldCorners.map((p) => p.y);
+    const bbox = {
+      minX: Math.min(...xs),
+      minY: Math.min(...ys),
+      maxX: Math.max(...xs),
+      maxY: Math.max(...ys)
+    };
+    return { poly, bbox };
+  });
+};
 var constructOutlinesFromPackedComponents = (components, opts = {}) => {
-  const { minGap = 0 } = opts;
-  if (components.length === 0) return [];
-  const bounds = combineBounds(
-    components.map((c) => getComponentBounds(c, minGap))
-  );
+  const { minGap = 0, obstacles = [] } = opts;
+  if (components.length === 0 && obstacles.length === 0) return [];
+  const componentBounds = components.map((c) => getComponentBounds(c, minGap));
+  const obstacleBounds = obstacles.map((o) => ({
+    minX: o.absoluteCenter.x - o.width / 2 - minGap,
+    minY: o.absoluteCenter.y - o.height / 2 - minGap,
+    maxX: o.absoluteCenter.x + o.width / 2 + minGap,
+    maxY: o.absoluteCenter.y + o.height / 2 + minGap
+  }));
+  const bounds = combineBounds([...componentBounds, ...obstacleBounds]);
   const allPadShapes = [];
   for (const component of components) {
     const padShapes = createPadPolygons(component, minGap);
     allPadShapes.push(...padShapes);
   }
+  const obstacleShapes = createObstaclePolygons(obstacles, minGap);
+  allPadShapes.push(...obstacleShapes);
   if (allPadShapes.length === 0) return [];
   const areaOfBox = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
   const containsBox = (outer, inner, eps = 1e-9) => outer.minX - eps <= inner.minX && outer.minY - eps <= inner.minY && outer.maxX + eps >= inner.maxX && outer.maxY + eps >= inner.maxY;
@@ -1814,6 +1846,18 @@ var getGraphicsFromPackOutput = (packOutput) => {
     )
   );
   const colorMap = createColorMapFromStrings(allNetworkIds);
+  if (packOutput.obstacles && packOutput.obstacles.length > 0) {
+    for (const obstacle of packOutput.obstacles) {
+      rects.push({
+        center: { x: obstacle.absoluteCenter.x, y: obstacle.absoluteCenter.y },
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: "rgba(0,0,0,0.1)",
+        stroke: "#555",
+        label: obstacle.obstacleId
+      });
+    }
+  }
   for (const component of packOutput.components) {
     const bounds = getComponentBounds(component);
     const width = bounds.maxX - bounds.minX;
@@ -1900,6 +1944,7 @@ function checkOverlapWithPackedComponents({
 }
 
 // lib/SingleComponentPackSolver/SingleComponentPackSolver.ts
+import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes2 } from "@tscircuit/math-utils";
 var SingleComponentPackSolver = class extends BaseSolver {
   componentToPack;
   packedComponents;
@@ -1954,17 +1999,34 @@ var SingleComponentPackSolver = class extends BaseSolver {
       const availableRotations2 = this.componentToPack.availableRotationDegrees ?? [0, 90, 180, 270];
       const position = { x: 0, y: 0 };
       const rotation = availableRotations2[0] ?? 0;
-      this.outputPackedComponent = this.createPackedComponent(
-        position,
-        rotation
-      );
-      this.solved = true;
-      return;
+      const candidate = this.createPackedComponent(position, rotation);
+      const tooCloseToObstacles = (this.obstacles ?? []).some((obs) => {
+        const obsBox = {
+          center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
+          width: obs.width,
+          height: obs.height
+        };
+        return candidate.pads.some((p) => {
+          const padBox = {
+            center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+            width: p.size.x,
+            height: p.size.y
+          };
+          const { distance } = computeDistanceBetweenBoxes2(padBox, obsBox);
+          return distance + 1e-6 < this.minGap;
+        });
+      });
+      if (!tooCloseToObstacles) {
+        this.outputPackedComponent = candidate;
+        this.solved = true;
+        return;
+      }
     }
     this.outlines = constructOutlinesFromPackedComponents(
       this.packedComponents,
       {
-        minGap: this.minGap
+        minGap: this.minGap,
+        obstacles: this.obstacles
       }
     );
     const availableRotations = this.componentToPack.availableRotationDegrees ?? [0, 90, 180, 270];
@@ -1994,11 +2056,33 @@ var SingleComponentPackSolver = class extends BaseSolver {
       let optimalPosition;
       if (this.activeSubSolver.solved && this.activeSubSolver.optimalPosition) {
         optimalPosition = this.activeSubSolver.optimalPosition;
+        const candidateComponent = this.createPackedComponent(
+          optimalPosition,
+          rotation
+        );
         const { hasOverlap, gapDistance } = checkOverlapWithPackedComponents({
-          component: this.createPackedComponent(optimalPosition, rotation),
+          component: candidateComponent,
           packedComponents: this.packedComponents,
           minGap: this.minGap
         });
+        let minObstacleGapDistance = Infinity;
+        const tooCloseToObstacles = (this.obstacles ?? []).some((obs) => {
+          const obsBox = {
+            center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
+            width: obs.width,
+            height: obs.height
+          };
+          return candidateComponent.pads.some((p) => {
+            const padBox = {
+              center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+              width: p.size.x,
+              height: p.size.y
+            };
+            const { distance: distance2 } = computeDistanceBetweenBoxes2(padBox, obsBox);
+            minObstacleGapDistance = Math.min(minObstacleGapDistance, distance2);
+            return distance2 + 1e-6 < this.minGap;
+          });
+        });
         distance = this.calculateDistance(optimalPosition, rotation);
         if (hasOverlap) {
           this.rejectedCandidates.push({
@@ -2010,6 +2094,16 @@ var SingleComponentPackSolver = class extends BaseSolver {
             rotationIndex: this.currentRotationIndex,
             gapDistance
           });
+        } else if (tooCloseToObstacles) {
+          this.rejectedCandidates.push({
+            segment: queuedSegment.segment,
+            rotation,
+            optimalPosition,
+            distance,
+            segmentIndex: queuedSegment.segmentIndex,
+            rotationIndex: this.currentRotationIndex,
+            gapDistance: minObstacleGapDistance
+          });
         } else {
           this.candidateResults.push({
             segment: queuedSegment.segment,
@@ -2242,6 +2336,7 @@ gap_distance=${candidate.gapDistance}`,
 };
 
 // lib/PackSolver2/PackSolver2.ts
+import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes3 } from "@tscircuit/math-utils";
 var PackSolver2 = class extends BaseSolver {
   packInput;
   unpackedComponentQueue = [];
@@ -2275,7 +2370,41 @@ var PackSolver2 = class extends BaseSolver {
       }))
     };
     setPackedComponentPadCenters(newPackedComponent);
-    this.packedComponents.push(newPackedComponent);
+    const obstacles = this.packInput.obstacles ?? [];
+    const tooCloseToObstacles = obstacles.some((obs) => {
+      const obsBox = {
+        center: { x: obs.absoluteCenter.x, y: obs.absoluteCenter.y },
+        width: obs.width,
+        height: obs.height
+      };
+      return newPackedComponent.pads.some((p) => {
+        const padBox = {
+          center: { x: p.absoluteCenter.x, y: p.absoluteCenter.y },
+          width: p.size.x,
+          height: p.size.y
+        };
+        const { distance } = computeDistanceBetweenBoxes3(padBox, obsBox);
+        return distance + 1e-6 < this.packInput.minGap;
+      });
+    });
+    if (!tooCloseToObstacles) {
+      this.packedComponents.push(newPackedComponent);
+      return;
+    }
+    const fallbackSolver = new SingleComponentPackSolver({
+      packedComponents: [],
+      componentToPack: firstComponentToPack,
+      packPlacementStrategy: this.packInput.packPlacementStrategy,
+      minGap: this.packInput.minGap,
+      obstacles
+    });
+    fallbackSolver.solve();
+    const result = fallbackSolver.getResult();
+    if (result) {
+      this.packedComponents.push(result);
+    } else {
+      this.packedComponents.push(newPackedComponent);
+    }
   }
   _step() {
     if (this.solved || this.failed) return;
@@ -2612,7 +2741,8 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
     components: [],
     minGap: 0,
     packOrderStrategy: "largest_to_smallest",
-    packPlacementStrategy: "shortest_connection_along_outline"
+    packPlacementStrategy: "shortest_connection_along_outline",
+    obstacles: opts.obstacles
   };
   const tree = getCircuitJsonTree(circuitJson, {
     source_group_id: opts.source_group_id

package/package.json

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