calculate-packing 0.0.36 → 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;
@@ -390,11 +391,6 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver {
      * Adjust position to avoid component bounds crossing to the inside of the outline
      */
     private adjustPositionForOutlineCollision;
-    /**
-     * Get the outward normal for the current segment by determining which side
-     * is farther from the outline centroid
-     */
-    private getOutwardNormal;
     visualize(): 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;
@@ -966,6 +998,89 @@ function pointInOutline(p, segments, rule = "even-odd") {
   }
 }
 
+// lib/OutlineSegmentCandidatePointSolver/getOutwardNormal.ts
+function getOutwardNormal(outlineSegment, fullOutline) {
+  const [p1, p2] = outlineSegment;
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) {
+    return { x: 0, y: 1 };
+  }
+  const dirX = dx / len;
+  const dirY = dy / len;
+  const left = { x: -dirY, y: dirX };
+  const right = { x: dirY, y: -dirX };
+  const mid = {
+    x: (p1.x + p2.x) / 2,
+    y: (p1.y + p2.y) / 2
+  };
+  const bbox = getOutlineBoundsWithMargin(fullOutline);
+  const scale = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) || 1;
+  const testDistance = Math.max(1e-4, 1e-3 * scale);
+  const testLeft = {
+    x: mid.x + left.x * testDistance,
+    y: mid.y + left.y * testDistance
+  };
+  const testRight = {
+    x: mid.x + right.x * testDistance,
+    y: mid.y + right.y * testDistance
+  };
+  const locLeft = pointInOutline(testLeft, fullOutline);
+  if (locLeft === "outside") {
+    return left;
+  }
+  const locRight = pointInOutline(testRight, fullOutline);
+  if (locRight === "outside") {
+    return right;
+  }
+  const verts = [];
+  if (fullOutline.length > 0) {
+    verts.push(fullOutline[0][0]);
+    for (const seg of fullOutline) {
+      verts.push(seg[1]);
+    }
+  }
+  const signedArea = (() => {
+    let a = 0;
+    for (let i = 0; i < verts.length; i++) {
+      const v1 = verts[i];
+      const v2 = verts[(i + 1) % verts.length];
+      a += v1.x * v2.y - v2.x * v1.y;
+    }
+    return a / 2;
+  })();
+  if (Math.abs(signedArea) > 1e-12) {
+    return signedArea > 0 ? right : left;
+  }
+  const center = {
+    x: (bbox.minX + bbox.maxX) / 2,
+    y: (bbox.minY + bbox.maxY) / 2
+  };
+  const away = { x: mid.x - center.x, y: mid.y - center.y };
+  const dotLeft = left.x * away.x + left.y * away.y;
+  const dotRight = right.x * away.x + right.y * away.y;
+  return dotRight >= dotLeft ? right : left;
+}
+function getOutlineBoundsWithMargin(fullOutline, margin = 0) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [p1, p2] of 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 {
+    minX: minX - margin,
+    minY: minY - margin,
+    maxX: maxX + margin,
+    maxY: maxY + margin
+  };
+}
+
 // lib/LargestRectOutsideOutlineFromPointSolver.ts
 var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver {
   fullOutline;
@@ -1356,7 +1471,10 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
       );
       return this.adjustPositionForOutlineCollision(projectedPoint);
     };
-    const outwardNormal = this.getOutwardNormal();
+    const outwardNormal = getOutwardNormal(
+      this.outlineSegment,
+      this.fullOutline
+    );
     const componentBounds = getInputComponentBounds(this.componentToPack, {
       rotationDegrees: this.componentRotationDegrees
     });
@@ -1556,7 +1674,10 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
   adjustPositionForOutlineCollision(center) {
     const tempComponent = this.createTemporaryPackedComponent(center);
     const bounds = getComponentBounds(tempComponent, 0);
-    const outwardNormal = this.getOutwardNormal();
+    const outwardNormal = getOutwardNormal(
+      this.outlineSegment,
+      this.fullOutline
+    );
     const isHorizontalNormal = Math.abs(outwardNormal.x) > Math.abs(outwardNormal.y);
     const isVerticalNormal = !isHorizontalNormal;
     if (isHorizontalNormal) {
@@ -1591,45 +1712,6 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver {
     }
     throw new Error("unreachable");
   }
-  /**
-   * Get the outward normal for the current segment by determining which side
-   * is farther from the outline centroid
-   */
-  getOutwardNormal() {
-    const [p1, p2] = this.outlineSegment;
-    const segmentX = p2.x - p1.x;
-    const segmentY = p2.y - p1.y;
-    const segmentLength = Math.hypot(segmentX, segmentY);
-    if (segmentLength === 0) {
-      return { x: 0, y: 1 };
-    }
-    const segmentDirX = segmentX / segmentLength;
-    const segmentDirY = segmentY / segmentLength;
-    const normal1X = -segmentDirY;
-    const normal1Y = segmentDirX;
-    const normal2X = segmentDirY;
-    const normal2Y = -segmentDirX;
-    const segmentMidpoint = {
-      x: (p1.x + p2.x) / 2,
-      y: (p1.y + p2.y) / 2
-    };
-    const testDistance = 1e-4;
-    const testPoint1 = {
-      x: segmentMidpoint.x + normal1X * testDistance,
-      y: segmentMidpoint.y + normal1Y * testDistance
-    };
-    const testPoint2 = {
-      x: segmentMidpoint.x + normal2X * testDistance,
-      y: segmentMidpoint.y + normal2Y * testDistance
-    };
-    if (pointInOutline(testPoint1, this.fullOutline) === "outside") {
-      return { x: normal1X, y: normal1Y };
-    }
-    if (pointInOutline(testPoint2, this.fullOutline) === "outside") {
-      return { x: normal2X, y: normal2Y };
-    }
-    throw new Error("No outward normal found");
-  }
   visualize() {
     const graphics = {
       lines: [],
@@ -1764,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;
@@ -1850,6 +1944,7 @@ function checkOverlapWithPackedComponents({
 }
 
 // lib/SingleComponentPackSolver/SingleComponentPackSolver.ts
+import { computeDistanceBetweenBoxes as computeDistanceBetweenBoxes2 } from "@tscircuit/math-utils";
 var SingleComponentPackSolver = class extends BaseSolver {
   componentToPack;
   packedComponents;
@@ -1904,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];
@@ -1944,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({
@@ -1960,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,
@@ -2192,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 = [];
@@ -2225,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;
@@ -2562,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.36",
+  "version": "0.0.38",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",