calculate-packing 0.0.14 → 0.0.16

package/dist/index.d.ts

@@ -100,6 +100,7 @@ declare class BaseSolver {
      * progress
      */
     preview(): GraphicsObject;
+    noisySolve(): void;
 }
 
 type Point = {

package/dist/index.js

@@ -132,61 +132,42 @@ var rotatePoint = (point, angle, origin = { x: 0, y: 0 }) => {
   };
 };
 
-// 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;
+// lib/constructOutlinesFromPackedComponents.ts
+var createPadPolygons = (component, minGap) => {
+  return component.pads.map((pad) => {
+    const hw = pad.size.x / 2 + minGap;
+    const hh = pad.size.y / 2 + minGap;
     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(
+    const worldCorners = localCorners.map((corner) => {
+      const rotated = 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 [
+        rotated.x + component.center.x,
+        rotated.y + component.center.y
+      ];
     });
+    return new Flatten.Polygon(worldCorners);
   });
-  return {
-    minX: bounds.minX - minGap,
-    maxX: bounds.maxX + minGap,
-    minY: bounds.minY - minGap,
-    maxY: bounds.maxY + minGap
-  };
 };
-
-// lib/constructOutlinesFromPackedComponents.ts
 var constructOutlinesFromPackedComponents = (components, opts = {}) => {
   const { minGap = 0 } = opts;
   if (components.length === 0) return [];
-  const rectPolys = components.map((c) => {
-    const b = getComponentBounds(c, minGap);
-    return new Flatten.Polygon([
-      [b.minX, b.minY],
-      [b.maxX, b.minY],
-      [b.maxX, b.maxY],
-      [b.minX, b.maxY]
-    ]);
-  });
-  if (rectPolys.length === 0) return [];
-  let union = rectPolys[0];
-  for (let i = 1; i < rectPolys.length; i++) {
-    union = Flatten.BooleanOperations.unify(union, rectPolys[i]);
+  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]);
   }
   const outlines = [];
   for (const face of union.faces) {
@@ -306,6 +287,44 @@ 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 = {};
@@ -543,6 +562,22 @@ function sortComponentQueue({
   });
 }
 
+// lib/solver-utils/makeNumbersRounded.ts
+var makeNumbersRounded = (obj) => {
+  if (typeof obj === "number") {
+    return Math.round(obj * 100) / 100;
+  }
+  if (typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        makeNumbersRounded(value)
+      ])
+    );
+  }
+  return obj;
+};
+
 // lib/solver-utils/BaseSolver.ts
 var BaseSolver = class {
   MAX_ITERATIONS = 1e3;
@@ -631,6 +666,15 @@ var BaseSolver = class {
       circles: []
     };
   }
+  noisySolve() {
+    const startTime = Date.now();
+    while (!this.solved && !this.failed) {
+      this.step();
+      console.log(JSON.stringify(makeNumbersRounded(this.visualize())));
+    }
+    const endTime = Date.now();
+    this.timeToSolve = endTime - startTime;
+  }
 };
 
 // lib/PackSolver/PhasedPackSolver.ts
@@ -733,11 +777,16 @@ var PhasedPackSolver = class extends BaseSolver {
     const padMargins = newPackedComponent.pads.map(
       (p) => Math.max(p.size.x, p.size.y) / 2
     );
-    const additionalGap = Math.max(...padMargins);
-    const outlines = constructOutlinesFromPackedComponents(
-      this.packedComponents,
-      { minGap: minGap + additionalGap }
-    );
+    const maxPadMargin = Math.max(...padMargins);
+    const minPadMargin = Math.min(...padMargins);
+    const outlines = [
+      ...constructOutlinesFromPackedComponents(this.packedComponents, {
+        minGap: minGap + minPadMargin
+      }),
+      ...constructOutlinesFromPackedComponents(this.packedComponents, {
+        minGap: minGap + maxPadMargin
+      })
+    ];
     this.phaseData.outlines = outlines;
     const networkIdsInPackedComponents = new Set(
       this.packedComponents.flatMap((c) => c.pads.map((p) => p.networkId))

package/package.json

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