calculate-packing 0.0.21 → 0.0.23

package/dist/index.d.ts

@@ -408,7 +408,7 @@ declare class SingleComponentPackSolver extends BaseSolver {
         packedComponents: PackedComponent[];
         packPlacementStrategy: PackPlacementStrategy;
         minGap: number;
-    }[];
+    };
 }
 
 declare class PackSolver2 extends BaseSolver {
@@ -418,6 +418,7 @@ declare class PackSolver2 extends BaseSolver {
     packedComponents: PackedComponent[];
     componentToPack?: InputComponent | null | undefined;
     constructor(packInput: PackInput);
+    getConstructorParams(): PackInput;
     _setup(): void;
     private packFirstComponent;
     _step(): void;

package/dist/index.js

@@ -195,6 +195,53 @@ function simplifyCollinearSegments(outline, tolerance = 1e-10) {
   return simplified;
 }
 
+// lib/geometry/getComponentBounds.ts
+var getComponentBounds = (component, minGap = 0) => {
+  const bounds = {
+    minX: Infinity,
+    maxX: -Infinity,
+    minY: Infinity,
+    maxY: -Infinity
+  };
+  component.pads.forEach((pad) => {
+    const hw = pad.size.x / 2;
+    const hh = pad.size.y / 2;
+    const localCorners = [
+      { x: pad.offset.x - hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y - hh },
+      { x: pad.offset.x + hw, y: pad.offset.y + hh },
+      { x: pad.offset.x - hw, y: pad.offset.y + hh }
+    ];
+    localCorners.forEach((corner) => {
+      const world = rotatePoint(
+        corner,
+        component.ccwRotationOffset * Math.PI / 180
+      );
+      const x = world.x + component.center.x;
+      const y = world.y + component.center.y;
+      bounds.minX = Math.min(bounds.minX, x);
+      bounds.maxX = Math.max(bounds.maxX, x);
+      bounds.minY = Math.min(bounds.minY, y);
+      bounds.maxY = Math.max(bounds.maxY, y);
+    });
+  });
+  return {
+    minX: bounds.minX - minGap,
+    maxX: bounds.maxX + minGap,
+    minY: bounds.minY - minGap,
+    maxY: bounds.maxY + minGap
+  };
+};
+
+// lib/geometry/combineBounds.ts
+var combineBounds = (bounds) => {
+  const minX = Math.min(...bounds.map((b) => b.minX));
+  const minY = Math.min(...bounds.map((b) => b.minY));
+  const maxX = Math.max(...bounds.map((b) => b.maxX));
+  const maxY = Math.max(...bounds.map((b) => b.maxY));
+  return { minX, minY, maxX, maxY };
+};
+
 // lib/constructOutlinesFromPackedComponents.ts
 var createPadPolygons = (component, minGap) => {
   return component.pads.map((pad) => {
@@ -222,16 +269,26 @@ var createPadPolygons = (component, minGap) => {
 var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const { minGap = 0 } = opts;
   if (components.length === 0) return [];
+  const bounds = combineBounds(
+    components.map((c) => getComponentBounds(c, minGap))
+  );
   const allPadPolys = [];
   for (const component of components) {
     const padPolys = createPadPolygons(component, minGap);
     allPadPolys.push(...padPolys);
   }
   if (allPadPolys.length === 0) return [];
-  let union = allPadPolys[0];
-  for (let i = 1; i < allPadPolys.length; i++) {
-    union = Flatten.BooleanOperations.unify(union, allPadPolys[i]);
+  let A = new Flatten.Polygon(
+    new Flatten.Box(bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
+  );
+  let B = A.clone();
+  for (let i = 0; i < allPadPolys.length; i++) {
+    try {
+      A = Flatten.BooleanOperations.subtract(A, allPadPolys[i]);
+    } catch (e) {
+    }
   }
+  const union = Flatten.BooleanOperations.subtract(B, A);
   const outlines = [];
   for (const face of union.faces) {
     if (face.isHole) continue;
@@ -351,44 +408,6 @@ function findOptimalPointOnSegment({
   };
 }
 
-// lib/geometry/getComponentBounds.ts
-var getComponentBounds = (component, minGap = 0) => {
-  const bounds = {
-    minX: Infinity,
-    maxX: -Infinity,
-    minY: Infinity,
-    maxY: -Infinity
-  };
-  component.pads.forEach((pad) => {
-    const hw = pad.size.x / 2;
-    const hh = pad.size.y / 2;
-    const localCorners = [
-      { x: pad.offset.x - hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y - hh },
-      { x: pad.offset.x + hw, y: pad.offset.y + hh },
-      { x: pad.offset.x - hw, y: pad.offset.y + hh }
-    ];
-    localCorners.forEach((corner) => {
-      const world = rotatePoint(
-        corner,
-        component.ccwRotationOffset * Math.PI / 180
-      );
-      const x = world.x + component.center.x;
-      const y = world.y + component.center.y;
-      bounds.minX = Math.min(bounds.minX, x);
-      bounds.maxX = Math.max(bounds.maxX, x);
-      bounds.minY = Math.min(bounds.minY, y);
-      bounds.maxY = Math.max(bounds.maxY, y);
-    });
-  });
-  return {
-    minX: bounds.minX - minGap,
-    maxX: bounds.maxX + minGap,
-    minY: bounds.minY - minGap,
-    maxY: bounds.maxY + minGap
-  };
-};
-
 // lib/testing/createColorMapFromStrings.ts
 var createColorMapFromStrings = (strings) => {
   const colorMap = {};
@@ -2904,14 +2923,12 @@ var SingleComponentPackSolver = class extends BaseSolver {
     return this.outputPackedComponent;
   }
   getConstructorParams() {
-    return [
-      {
-        componentToPack: this.componentToPack,
-        packedComponents: this.packedComponents,
-        packPlacementStrategy: this.packPlacementStrategy,
-        minGap: this.minGap
-      }
-    ];
+    return {
+      componentToPack: this.componentToPack,
+      packedComponents: this.packedComponents,
+      packPlacementStrategy: this.packPlacementStrategy,
+      minGap: this.minGap
+    };
   }
 };
 
@@ -2925,6 +2942,9 @@ var PackSolver2 = class extends BaseSolver {
     super();
     this.packInput = packInput;
   }
+  getConstructorParams() {
+    return this.packInput;
+  }
   _setup() {
     const { components, packOrderStrategy, packFirst = [] } = this.packInput;
     this.unpackedComponentQueue = sortComponentQueue({

package/package.json

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