calculate-packing 0.0.56 → 0.0.58

package/dist/index.d.ts

@@ -138,17 +138,17 @@ type Rect = {
 
 type GlobalBounds = Bounds;
 declare class LargestRectOutsideOutlineFromPointSolver extends BaseSolver$1 {
-    fullOutline: Point$1[];
+    ccwFullOutline: Point$1[];
     origin: Point$1;
     globalBounds: Bounds;
     largestRect: Rect | null;
     constructor(params: {
-        fullOutline: Point$1[];
+        ccwFullOutline: Point$1[];
         origin: Point$1;
         globalBounds: Bounds;
     });
     getConstructorParams(): {
-        fullOutline: Point$1[];
+        ccwFullOutline: Point$1[];
         origin: Point$1;
         globalBounds: Bounds;
     };
@@ -367,7 +367,7 @@ declare class TwoPhaseIrlsSolver extends BaseSolver {
 declare class OutlineSegmentCandidatePointSolver extends BaseSolver$1 {
     outlineSegment: [Point$2, Point$2];
     viableOutlineSegment: [Point$2, Point$2] | null;
-    fullOutline: [Point$2, Point$2][];
+    ccwFullOutline: [Point$2, Point$2][];
     componentRotationDegrees: number;
     packStrategy: PackPlacementStrategy;
     minGap: number;
@@ -385,7 +385,7 @@ declare class OutlineSegmentCandidatePointSolver extends BaseSolver$1 {
     twoPhaseIrlsSolver?: TwoPhaseIrlsSolver;
     constructor(params: {
         outlineSegment: [Point$2, Point$2];
-        fullOutline: [Point$2, Point$2][];
+        ccwFullOutline: [Point$2, Point$2][];
         componentRotationDegrees: number;
         packStrategy: PackPlacementStrategy;
         minGap: number;
@@ -434,7 +434,7 @@ interface QueuedOutlineSegment {
     segment: Segment;
     availableRotations: number[];
     segmentIndex: number;
-    fullOutline: Segment[];
+    ccwFullOutline: Segment[];
 }
 interface CandidateResult {
     segment: Segment;

package/dist/index.js

@@ -1014,7 +1014,7 @@ function pointInOutline(p, segments, rule = "even-odd") {
 }
 
 // lib/OutlineSegmentCandidatePointSolver/getOutwardNormal.ts
-function getOutwardNormal(outlineSegment, fullOutline) {
+function getOutwardNormal(outlineSegment, ccwFullOutline) {
   const [p1, p2] = outlineSegment;
   const dx = p2.x - p1.x;
   const dy = p2.y - p1.y;
@@ -1030,7 +1030,7 @@ function getOutwardNormal(outlineSegment, fullOutline) {
     x: (p1.x + p2.x) / 2,
     y: (p1.y + p2.y) / 2
   };
-  const bbox = getOutlineBoundsWithMargin(fullOutline);
+  const bbox = getOutlineBoundsWithMargin(ccwFullOutline);
   const scale = Math.max(bbox.maxX - bbox.minX, bbox.maxY - bbox.minY) || 1;
   const testDistance = Math.max(1e-4, 1e-3 * scale);
   const testLeft = {
@@ -1041,18 +1041,18 @@ function getOutwardNormal(outlineSegment, fullOutline) {
     x: mid.x + right.x * testDistance,
     y: mid.y + right.y * testDistance
   };
-  const locLeft = pointInOutline(testLeft, fullOutline);
+  const locLeft = pointInOutline(testLeft, ccwFullOutline);
   if (locLeft === "outside") {
     return left;
   }
-  const locRight = pointInOutline(testRight, fullOutline);
+  const locRight = pointInOutline(testRight, ccwFullOutline);
   if (locRight === "outside") {
     return right;
   }
   const verts = [];
-  if (fullOutline.length > 0) {
-    verts.push(fullOutline[0][0]);
-    for (const seg of fullOutline) {
+  if (ccwFullOutline.length > 0) {
+    verts.push(ccwFullOutline[0][0]);
+    for (const seg of ccwFullOutline) {
       verts.push(seg[1]);
     }
   }
@@ -1077,12 +1077,12 @@ function getOutwardNormal(outlineSegment, fullOutline) {
   const dotRight = right.x * away.x + right.y * away.y;
   return dotRight >= dotLeft ? right : left;
 }
-function getOutlineBoundsWithMargin(fullOutline, margin = 0) {
+function getOutlineBoundsWithMargin(ccwFullOutline, margin = 0) {
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
-  for (const [p1, p2] of fullOutline) {
+  for (const [p1, p2] of ccwFullOutline) {
     minX = Math.min(minX, p1.x, p2.x);
     minY = Math.min(minY, p1.y, p2.y);
     maxX = Math.max(maxX, p1.x, p2.x);
@@ -1099,19 +1099,19 @@ function getOutlineBoundsWithMargin(fullOutline, margin = 0) {
 // lib/LargestRectOutsideOutlineFromPointSolver.ts
 import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
 var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
-  fullOutline;
+  ccwFullOutline;
   origin;
   globalBounds;
   largestRect = null;
   constructor(params) {
     super();
-    this.fullOutline = params.fullOutline;
+    this.ccwFullOutline = params.ccwFullOutline;
     this.origin = params.origin;
     this.globalBounds = params.globalBounds;
   }
   getConstructorParams() {
     return {
-      fullOutline: this.fullOutline,
+      ccwFullOutline: this.ccwFullOutline,
       origin: this.origin,
       globalBounds: this.globalBounds
     };
@@ -1123,7 +1123,7 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
     this.solved = true;
   }
   computeLargestRectOutside() {
-    const edges = this.makeEdges(this.fullOutline);
+    const edges = this.makeEdges(this.ccwFullOutline);
     const bounds = {
       x: this.globalBounds.minX,
       y: this.globalBounds.minY,
@@ -1318,9 +1318,9 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
       rects: [],
       circles: []
     };
-    for (let i = 0; i < this.fullOutline.length; i++) {
-      const p1 = this.fullOutline[i];
-      const p2 = this.fullOutline[(i + 1) % this.fullOutline.length];
+    for (let i = 0; i < this.ccwFullOutline.length; i++) {
+      const p1 = this.ccwFullOutline[i];
+      const p2 = this.ccwFullOutline[(i + 1) % this.ccwFullOutline.length];
       if (p1 && p2) {
         graphics.lines.push({
           points: [p1, p2],
@@ -1329,7 +1329,7 @@ var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver2 {
       }
     }
     graphics.lines.push({
-      points: [...this.fullOutline, this.fullOutline[0]],
+      points: [...this.ccwFullOutline, this.ccwFullOutline[0]],
       strokeColor: "rgba(200, 200, 200, 0.5)",
       strokeDash: [10, 5]
     });
@@ -1446,7 +1446,7 @@ function isPointInPolygon(point, polygon) {
 var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
   outlineSegment;
   viableOutlineSegment = null;
-  fullOutline;
+  ccwFullOutline;
   // The entire outline containing the segment
   componentRotationDegrees;
   packStrategy;
@@ -1463,7 +1463,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
   constructor(params) {
     super();
     this.outlineSegment = params.outlineSegment;
-    this.fullOutline = params.fullOutline;
+    this.ccwFullOutline = params.ccwFullOutline;
     this.componentRotationDegrees = params.componentRotationDegrees;
     this.packStrategy = params.packStrategy;
     this.minGap = params.minGap;
@@ -1476,7 +1476,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
   getConstructorParams() {
     return {
       outlineSegment: this.outlineSegment,
-      fullOutline: this.fullOutline,
+      ccwFullOutline: this.ccwFullOutline,
       componentRotationDegrees: this.componentRotationDegrees,
       packStrategy: this.packStrategy,
       minGap: this.minGap,
@@ -1492,7 +1492,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
     let minY = Infinity;
     let maxX = -Infinity;
     let maxY = -Infinity;
-    for (const [p1, p2] of this.fullOutline) {
+    for (const [p1, p2] of this.ccwFullOutline) {
       minX = Math.min(minX, p1.x, p2.x);
       minY = Math.min(minY, p1.y, p2.y);
       maxX = Math.max(maxX, p1.x, p2.x);
@@ -1518,7 +1518,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
     };
     const outwardNormal = getOutwardNormal(
       this.outlineSegment,
-      this.fullOutline
+      this.ccwFullOutline
     );
     const componentBounds = getInputComponentBounds(this.componentToPack, {
       rotationDegrees: this.componentRotationDegrees
@@ -1530,7 +1530,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
       ) * 2 + this.minGap * 2
     });
     const largestRectSolverParams = {
-      fullOutline: this.fullOutline.flatMap(([p]) => p),
+      ccwFullOutline: this.ccwFullOutline.flatMap(([p]) => p),
       globalBounds: packedComponentBoundsWithMargin,
       origin: {
         x: (p1.x + p2.x) / 2 + outwardNormal.x * 1e-4,
@@ -1740,7 +1740,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
     const bounds = getComponentBounds(tempComponent, 0);
     const outwardNormal = getOutwardNormal(
       this.outlineSegment,
-      this.fullOutline
+      this.ccwFullOutline
     );
     const isHorizontalNormal = Math.abs(outwardNormal.x) > Math.abs(outwardNormal.y);
     const isVerticalNormal = !isHorizontalNormal;
@@ -1873,7 +1873,7 @@ var OutlineSegmentCandidatePointSolver = class extends BaseSolver3 {
       strokeColor: "rgba(255,0,0,1)",
       strokeDash: "3 3"
     });
-    for (const [p1, p2] of this.fullOutline) {
+    for (const [p1, p2] of this.ccwFullOutline) {
       graphics.lines.push({
         points: [p1, p2],
         strokeColor: "rgba(0,0,0,0.5)",
@@ -2177,7 +2177,7 @@ var SingleComponentPackSolver = class extends BaseSolver4 {
           availableRotations: [...availableRotations],
           segmentIndex: segmentIndex * 1e3 + i,
           // Unique index across all outlines
-          fullOutline: outline
+          ccwFullOutline: outline
           // Pass the entire outline containing this segment
         });
       }
@@ -2311,7 +2311,7 @@ var SingleComponentPackSolver = class extends BaseSolver4 {
       const rotation = queuedSegment.availableRotations[this.currentRotationIndex];
       this.activeSubSolver = new OutlineSegmentCandidatePointSolver({
         outlineSegment: queuedSegment.segment,
-        fullOutline: queuedSegment.fullOutline,
+        ccwFullOutline: queuedSegment.ccwFullOutline,
         componentRotationDegrees: rotation,
         packStrategy: this.packPlacementStrategy,
         minGap: this.minGap,
@@ -3110,12 +3110,30 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
     return `unnamed${unnamedCounter++}`;
   };
   const topLevelNodes = tree.childNodes ?? [];
+  const collectRelativeToGroupAnchorComponents = (node) => {
+    const relativeComponents2 = [];
+    if (node.nodeType === "component") {
+      const pcbComponent = node.otherChildElements.find(
+        (e) => e.type === "pcb_component"
+      );
+      if (pcbComponent && pcbComponent.position_mode === "relative_to_group_anchor") {
+        relativeComponents2.push(pcbComponent);
+      }
+    }
+    for (const child of node.childNodes ?? []) {
+      relativeComponents2.push(...collectRelativeToGroupAnchorComponents(child));
+    }
+    return relativeComponents2;
+  };
   for (const node of topLevelNodes) {
     if (node.nodeType === "component") {
       const pcbComponent = node.otherChildElements.find(
         (e) => e.type === "pcb_component"
       );
       if (!pcbComponent) continue;
+      if (pcbComponent.position_mode === "relative_to_group_anchor") {
+        continue;
+      }
       let shouldAddInnerObstaclesForComp = opts.shouldAddInnerObstacles;
       if (pcbComponent.obstructs_within_bounds === false) {
         shouldAddInnerObstaclesForComp = false;
@@ -3146,6 +3164,32 @@ var convertCircuitJsonToPackOutput = (circuitJson, opts = {}) => {
       );
     }
   }
+  const relativeComponents = topLevelNodes.flatMap(
+    (node) => collectRelativeToGroupAnchorComponents(node)
+  );
+  for (const pcbComponent of relativeComponents) {
+    const padInfos = extractPadInfos(pcbComponent, db, getNetworkId);
+    if (padInfos.length === 0) continue;
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const pad of padInfos) {
+      minX = Math.min(minX, pad.absoluteCenter.x - pad.size.x / 2);
+      maxX = Math.max(maxX, pad.absoluteCenter.x + pad.size.x / 2);
+      minY = Math.min(minY, pad.absoluteCenter.y - pad.size.y / 2);
+      maxY = Math.max(maxY, pad.absoluteCenter.y + pad.size.y / 2);
+    }
+    const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+    const width = maxX - minX;
+    const height = maxY - minY;
+    packOutput.obstacles.push({
+      obstacleId: pcbComponent.pcb_component_id,
+      absoluteCenter: center,
+      width,
+      height
+    });
+  }
   for (const element of elementsOutsideTree) {
     if (element.type === "pcb_plated_hole" && element.shape === "circular_hole_with_rect_pad") {
       const { rect_pad_height, rect_pad_width, x, y } = element;

package/package.json

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