calculate-packing 0.0.37 → 0.0.39

package/dist/index.d.ts

@@ -56,6 +56,12 @@ type PackPlacementStrategy = "shortest_connection_along_outline" | "minimum_sum_
 interface PackInput {
     components: InputComponent[];
     obstacles?: InputObstacle[];
+    bounds?: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
     minGap: number;
     packOrderStrategy: "largest_to_smallest";
     packPlacementStrategy: PackPlacementStrategy;
@@ -92,6 +98,7 @@ declare const convertCircuitJsonToPackOutput: (circuitJson: CircuitJson, opts?:
         top: number;
         bottom: number;
     }>;
+    obstacles?: InputObstacle[];
 }) => PackOutput;
 
 declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObject;
@@ -351,6 +358,7 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
     packedComponents: PackedComponent[];
     componentToPack: InputComponent;
     viableBounds?: Bounds;
+    globalBounds?: Bounds;
     optimalPosition?: Point$2;
     irlsSolver?: MultiOffsetIrlsSolver;
     twoPhaseIrlsSolver?: TwoPhaseIrlsSolver;
@@ -363,6 +371,7 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
         packedComponents: PackedComponent[];
         componentToPack: InputComponent;
         obstacles?: InputObstacle[];
+        globalBounds?: Bounds;
     });
     getConstructorParams(): ConstructorParameters<typeof OutlineSegmentCandidatePointSolver>[0];
     _getOutlineBoundsWithMargin(params?: {
@@ -439,12 +448,14 @@ declare class SingleComponentPackSolver extends BaseSolver {
     }>;
     bestCandidate?: CandidateResult;
     outputPackedComponent?: PackedComponent;
+    bounds?: Bounds;
     constructor(params: {
         componentToPack: InputComponent;
         packedComponents: PackedComponent[];
         packPlacementStrategy: PackPlacementStrategy;
         minGap?: number;
         obstacles?: InputObstacle[];
+        bounds?: Bounds;
     });
     _setup(): void;
     _step(): void;
@@ -464,6 +475,7 @@ declare class SingleComponentPackSolver extends BaseSolver {
         packPlacementStrategy: PackPlacementStrategy;
         minGap: number;
         obstacles: InputObstacle[];
+        bounds: Bounds | undefined;
     };
 }
 

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;
@@ -1384,6 +1416,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   packedComponents;
   componentToPack;
   viableBounds;
+  globalBounds;
   optimalPosition;
   irlsSolver;
   twoPhaseIrlsSolver;
@@ -1397,6 +1430,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     this.packedComponents = params.packedComponents;
     this.componentToPack = params.componentToPack;
     this.obstacles = params.obstacles ?? [];
+    this.globalBounds = params.globalBounds;
   }
   getConstructorParams() {
     return {
@@ -1407,7 +1441,8 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       minGap: this.minGap,
       packedComponents: this.packedComponents,
       componentToPack: this.componentToPack,
-      obstacles: this.obstacles
+      obstacles: this.obstacles,
+      globalBounds: this.globalBounds
     };
   }
   _getOutlineBoundsWithMargin(params = {}) {
@@ -1699,6 +1734,19 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
         });
       }
     }
+    if (this.globalBounds) {
+      graphics.lines.push({
+        points: [
+          { x: this.globalBounds.minX, y: this.globalBounds.minY },
+          { x: this.globalBounds.minX, y: this.globalBounds.maxY },
+          { x: this.globalBounds.maxX, y: this.globalBounds.maxY },
+          { x: this.globalBounds.maxX, y: this.globalBounds.minY },
+          { x: this.globalBounds.minX, y: this.globalBounds.minY }
+        ],
+        strokeColor: "rgba(255,0,255,0.5)",
+        strokeDash: "2 2"
+      });
+    }
     if (this.viableBounds) {
       graphics.rects.push({
         center: {
@@ -1814,6 +1862,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 +1960,7 @@ function checkOverlapWithPackedComponents({
 }
 
 // lib/SingleComponentPackSolver/SingleComponentPackSolver.ts
+import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes2 } from "@tscircuit/math-utils";
 var SingleComponentPackSolver = class extends BaseSolver {
   componentToPack;
   packedComponents;
@@ -1917,6 +1978,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
   rejectedCandidates = [];
   bestCandidate;
   outputPackedComponent;
+  bounds;
   constructor(params) {
     super();
     this.componentToPack = params.componentToPack;
@@ -1924,6 +1986,7 @@ var SingleComponentPackSolver = class extends BaseSolver {
     this.packPlacementStrategy = params.packPlacementStrategy;
     this.minGap = params.minGap ?? 0;
     this.obstacles = params.obstacles ?? [];
+    this.bounds = params.bounds;
   }
   _setup() {
     super._setup();
@@ -1954,17 +2017,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 +2074,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 +2112,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,
@@ -2044,7 +2156,8 @@ var SingleComponentPackSolver = class extends BaseSolver {
         minGap: this.minGap,
         packedComponents: this.packedComponents,
         componentToPack: this.componentToPack,
-        obstacles: this.obstacles
+        obstacles: this.obstacles,
+        globalBounds: this.bounds
       });
       this.activeSubSolver.setup();
       break;
@@ -2130,6 +2243,19 @@ var SingleComponentPackSolver = class extends BaseSolver {
         });
       }
     }
+    if (this.bounds) {
+      graphics.lines.push({
+        points: [
+          { x: this.bounds.minX, y: this.bounds.minY },
+          { x: this.bounds.minX, y: this.bounds.maxY },
+          { x: this.bounds.maxX, y: this.bounds.maxY },
+          { x: this.bounds.maxX, y: this.bounds.minY },
+          { x: this.bounds.minX, y: this.bounds.minY }
+        ],
+        strokeColor: "rgba(0,0,0,0.5)",
+        strokeDash: "2 2"
+      });
+    }
     switch (this.currentPhase) {
       case "outline":
         this.visualizeOutlinePhase(graphics);
@@ -2236,12 +2362,14 @@ gap_distance=${candidate.gapDistance}`,
       packedComponents: this.packedComponents,
       packPlacementStrategy: this.packPlacementStrategy,
       minGap: this.minGap,
-      obstacles: this.obstacles
+      obstacles: this.obstacles,
+      bounds: this.bounds
     };
   }
 };
 
 // lib/PackSolver2/PackSolver2.ts
+import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes3 } from "@tscircuit/math-utils";
 var PackSolver2 = class extends BaseSolver {
   packInput;
   unpackedComponentQueue = [];
@@ -2275,7 +2403,42 @@ 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,
+      bounds: this.packInput.bounds
+    });
+    fallbackSolver.solve();
+    const result = fallbackSolver.getResult();
+    if (result) {
+      this.packedComponents.push(result);
+    } else {
+      this.packedComponents.push(newPackedComponent);
+    }
   }
   _step() {
     if (this.solved || this.failed) return;
@@ -2302,7 +2465,8 @@ var PackSolver2 = class extends BaseSolver {
         componentToPack: this.componentToPack,
         packPlacementStrategy: this.packInput.packPlacementStrategy,
         minGap: this.packInput.minGap,
-        obstacles: this.packInput.obstacles ?? []
+        obstacles: this.packInput.obstacles ?? [],
+        bounds: this.packInput.bounds
       });
       this.activeSubSolver.setup();
     }
@@ -2357,6 +2521,19 @@ var PackSolver2 = class extends BaseSolver {
         });
       }
     }
+    if (this.packInput.bounds) {
+      graphics.lines.push({
+        points: [
+          { x: this.packInput.bounds.minX, y: this.packInput.bounds.minY },
+          { x: this.packInput.bounds.minX, y: this.packInput.bounds.maxY },
+          { x: this.packInput.bounds.maxX, y: this.packInput.bounds.maxY },
+          { x: this.packInput.bounds.maxX, y: this.packInput.bounds.minY },
+          { x: this.packInput.bounds.minX, y: this.packInput.bounds.minY }
+        ],
+        strokeColor: "rgba(0,0,0,0.5)",
+        strokeDash: "2 2"
+      });
+    }
     if (this.packedComponents.length === 0) {
       for (const component of this.unpackedComponentQueue) {
         for (const pad of component.pads) {
@@ -2612,7 +2789,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.39",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",