calculate-packing 0.0.32 → 0.0.33

package/dist/index.js

@@ -250,12 +250,22 @@ var createPadPolygons = (component, minGap) => {
         corner,
         component.ccwRotationOffset * Math.PI / 180
       );
-      return [
-        rotated.x + component.center.x,
-        rotated.y + component.center.y
-      ];
+      return {
+        x: rotated.x + component.center.x,
+        y: rotated.y + component.center.y
+      };
     });
-    return new Flatten.Polygon(worldCorners);
+    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 = {}) => {
@@ -264,23 +274,61 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const bounds = combineBounds(
     components.map((c) => getComponentBounds(c, minGap))
   );
-  const allPadPolys = [];
+  const allPadShapes = [];
   for (const component of components) {
-    const padPolys = createPadPolygons(component, minGap);
-    allPadPolys.push(...padPolys);
+    const padShapes = createPadPolygons(component, minGap);
+    allPadShapes.push(...padShapes);
+  }
+  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;
+  const sortedByAreaDesc = [...allPadShapes].sort(
+    (a, b) => areaOfBox(b.bbox) - areaOfBox(a.bbox)
+  );
+  const filteredPadShapes = [];
+  for (const shape of sortedByAreaDesc) {
+    const w = shape.bbox.maxX - shape.bbox.minX;
+    const h = shape.bbox.maxY - shape.bbox.minY;
+    if (!(w > 1e-12 && h > 1e-12)) continue;
+    let contained = false;
+    for (const kept of filteredPadShapes) {
+      if (containsBox(kept.bbox, shape.bbox)) {
+        contained = true;
+        break;
+      }
+    }
+    if (!contained) filteredPadShapes.push(shape);
   }
-  if (allPadPolys.length === 0) return [];
+  const keptPadPolys = filteredPadShapes.map((s) => s.poly);
   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++) {
+  const B = A.clone();
+  for (let i = 0; i < keptPadPolys.length; i++) {
     try {
-      A = Flatten.BooleanOperations.subtract(A, allPadPolys[i]);
+      A = Flatten.BooleanOperations.subtract(A, keptPadPolys[i]);
     } catch (e) {
     }
   }
-  const union = Flatten.BooleanOperations.subtract(B, A);
+  let union = null;
+  try {
+    union = Flatten.BooleanOperations.subtract(B, A);
+  } catch (e) {
+    try {
+      if (keptPadPolys.length > 0) {
+        let U = keptPadPolys[0];
+        for (let i = 1; i < keptPadPolys.length; i++) {
+          try {
+            U = Flatten.BooleanOperations.unify(U, keptPadPolys[i]);
+          } catch {
+          }
+        }
+        union = U;
+      }
+    } catch {
+      union = null;
+    }
+  }
   const outlines = [];
   for (const face of union.faces) {
     if (face.isHole) continue;

package/package.json

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