calculate-packing 0.0.18 → 0.0.20

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { GraphicsObject, Point as Point$1 } from 'graphics-debug';
 import { CircuitJson } from 'circuit-json';
+import { Bounds } from '@tscircuit/math-utils';
 
 type ComponentId = string;
 type PadId = string;
@@ -42,11 +43,12 @@ interface PackedComponent extends InputComponent {
     ccwRotationDegrees?: number;
     pads: OutputPad[];
 }
+type PackPlacementStrategy = "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network";
 interface PackInput {
     components: InputComponent[];
     minGap: number;
     packOrderStrategy: "largest_to_smallest";
-    packPlacementStrategy: "shortest_connection_along_outline" | "minimum_sum_distance_to_network" | "minimum_sum_squared_distance_to_network";
+    packPlacementStrategy: PackPlacementStrategy;
     disconnectedPackDirection?: "left" | "right" | "up" | "down" | "nearest_to_center";
     packFirst?: ComponentId[];
 }
@@ -188,4 +190,43 @@ declare const getGraphicsFromPackOutput: (packOutput: PackOutput) => GraphicsObj
  */
 declare const convertPackOutputToPackInput: (packed: PackOutput) => PackInput;
 
-export { type ComponentId, type InputComponent, type InputPad, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackedComponent, type PadId, PhasedPackSolver, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };
+type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+
+type GlobalBounds = Bounds;
+declare class LargestRectOutsideOutlineFromPointSolver extends BaseSolver {
+    fullOutline: Point[];
+    origin: Point;
+    globalBounds: Bounds;
+    largestRect: Rect | null;
+    constructor(params: {
+        fullOutline: Point[];
+        origin: Point;
+        globalBounds: Bounds;
+    });
+    getConstructorParams(): {
+        fullOutline: Point[];
+        origin: Point;
+        globalBounds: Bounds;
+    };
+    _setup(): void;
+    _step(): void;
+    private computeLargestRectOutside;
+    private almostEqual;
+    private makeEdges;
+    private isVertical;
+    private isHorizontal;
+    private scanlineIntervalsAtY;
+    private clipIntervals;
+    private regionIntervalsAtY;
+    private largestRectContainingPointRegion;
+    getLargestRect(): Rect | null;
+    getLargestRectBounds(): Bounds;
+    visualize(): GraphicsObject;
+}
+
+export { type ComponentId, type GlobalBounds, type InputComponent, type InputPad, LargestRectOutsideOutlineFromPointSolver, type NetworkId, type OutputPad, type PackInput, type PackOutput, type PackPlacementStrategy, type PackedComponent, type PadId, PhasedPackSolver, type Point, type Rect, convertCircuitJsonToPackOutput, convertPackOutputToPackInput, getGraphicsFromPackOutput, pack };

package/dist/index.js

@@ -132,6 +132,69 @@ var rotatePoint = (point, angle, origin = { x: 0, y: 0 }) => {
   };
 };
 
+// lib/math/cross.ts
+var cross = (O, A, B) => (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
+
+// lib/geometry/simplify-collinear-segments.ts
+function simplifyCollinearSegments(outline, tolerance = 1e-10) {
+  if (outline.length <= 1) {
+    return outline;
+  }
+  const simplified = [];
+  let currentSegmentStart = outline[0][0];
+  let currentSegmentEnd = outline[0][1];
+  for (let i = 1; i < outline.length; i++) {
+    const nextSegment = outline[i];
+    const [nextStart, nextEnd] = nextSegment;
+    const connectionTolerance = 1e-10;
+    const isConnected = Math.abs(currentSegmentEnd.x - nextStart.x) < connectionTolerance && Math.abs(currentSegmentEnd.y - nextStart.y) < connectionTolerance;
+    if (!isConnected) {
+      simplified.push([currentSegmentStart, currentSegmentEnd]);
+      currentSegmentStart = nextStart;
+      currentSegmentEnd = nextEnd;
+      continue;
+    }
+    const crossProduct = cross(currentSegmentStart, currentSegmentEnd, nextEnd);
+    if (Math.abs(crossProduct) < tolerance) {
+      currentSegmentEnd = nextEnd;
+    } else {
+      simplified.push([currentSegmentStart, currentSegmentEnd]);
+      currentSegmentStart = nextStart;
+      currentSegmentEnd = nextEnd;
+    }
+  }
+  if (outline.length > 2) {
+    const firstSegment = simplified[0];
+    const lastSegmentCandidate = [
+      currentSegmentStart,
+      currentSegmentEnd
+    ];
+    if (firstSegment && simplified.length > 0) {
+      const connectionTolerance = 1e-10;
+      const isLastConnectedToFirst = Math.abs(currentSegmentEnd.x - firstSegment[0].x) < connectionTolerance && Math.abs(currentSegmentEnd.y - firstSegment[0].y) < connectionTolerance;
+      if (isLastConnectedToFirst) {
+        const crossProduct = cross(
+          currentSegmentStart,
+          currentSegmentEnd,
+          firstSegment[1]
+        );
+        if (Math.abs(crossProduct) < tolerance) {
+          simplified[0] = [currentSegmentStart, firstSegment[1]];
+        } else {
+          simplified.push(lastSegmentCandidate);
+        }
+      } else {
+        simplified.push(lastSegmentCandidate);
+      }
+    } else {
+      simplified.push(lastSegmentCandidate);
+    }
+  } else {
+    simplified.push([currentSegmentStart, currentSegmentEnd]);
+  }
+  return simplified;
+}
+
 // lib/constructOutlinesFromPackedComponents.ts
 var createPadPolygons = (component, minGap) => {
   return component.pads.map((pad) => {
@@ -185,7 +248,8 @@ var constructOutlinesFromPackedComponents = (components, opts = {}) => {
       ]);
       edge = edge.next;
     } while (edge !== face.first);
-    outlines.push(outline);
+    const simplifiedOutline = simplifyCollinearSegments(outline);
+    outlines.push(simplifiedOutline);
   }
   return outlines;
 };
@@ -1581,7 +1645,267 @@ var convertPackOutputToPackInput = (packed) => {
     components: strippedComponents
   };
 };
+
+// lib/LargestRectOutsideOutlineFromPointSolver.ts
+var LargestRectOutsideOutlineFromPointSolver = class extends BaseSolver {
+  fullOutline;
+  origin;
+  globalBounds;
+  largestRect = null;
+  constructor(params) {
+    super();
+    this.fullOutline = params.fullOutline;
+    this.origin = params.origin;
+    this.globalBounds = params.globalBounds;
+  }
+  getConstructorParams() {
+    return {
+      fullOutline: this.fullOutline,
+      origin: this.origin,
+      globalBounds: this.globalBounds
+    };
+  }
+  _setup() {
+  }
+  _step() {
+    this.largestRect = this.computeLargestRectOutside();
+    this.solved = true;
+  }
+  computeLargestRectOutside() {
+    const edges = this.makeEdges(this.fullOutline);
+    const bounds = {
+      x: this.globalBounds.minX,
+      y: this.globalBounds.minY,
+      w: this.globalBounds.maxX - this.globalBounds.minX,
+      h: this.globalBounds.maxY - this.globalBounds.minY
+    };
+    return this.largestRectContainingPointRegion(
+      edges,
+      this.origin,
+      bounds,
+      "outside"
+    );
+  }
+  almostEqual(a, b, eps = 1e-9) {
+    return Math.abs(a - b) <= eps;
+  }
+  makeEdges(poly) {
+    const edges = [];
+    for (let i = 0; i < poly.length; i++) {
+      const a = poly[i];
+      const b = poly[(i + 1) % poly.length];
+      if (!a || !b) continue;
+      if (this.almostEqual(a.x, b.x) && this.almostEqual(a.y, b.y)) continue;
+      edges.push([a, b]);
+    }
+    return edges;
+  }
+  isVertical(e) {
+    return this.almostEqual(e[0].x, e[1].x);
+  }
+  isHorizontal(e) {
+    return this.almostEqual(e[0].y, e[1].y);
+  }
+  scanlineIntervalsAtY(edges, y0) {
+    const xs = [];
+    for (const e of edges) {
+      if (!this.isVertical(e)) continue;
+      const y1 = e[0].y;
+      const y2 = e[1].y;
+      const x = e[0].x;
+      const ymin = Math.min(y1, y2);
+      const ymax = Math.max(y1, y2);
+      if (ymin <= y0 && y0 < ymax) {
+        xs.push(x);
+      }
+    }
+    xs.sort((a, b) => a - b);
+    const intervals = [];
+    for (let i = 0; i + 1 < xs.length; i += 2) {
+      const x1 = xs[i];
+      const x2 = xs[i + 1];
+      if (x1 !== void 0 && x2 !== void 0) {
+        intervals.push([x1, x2]);
+      }
+    }
+    return intervals;
+  }
+  clipIntervals(intervals, a, b) {
+    const out = [];
+    for (const [L, R] of intervals) {
+      const l = Math.max(a, L);
+      const r = Math.min(b, R);
+      if (r > l) out.push([l, r]);
+    }
+    return out;
+  }
+  regionIntervalsAtY(edges, y0, bx1, bx2, mode) {
+    const inside = this.clipIntervals(
+      this.scanlineIntervalsAtY(edges, y0),
+      bx1,
+      bx2
+    );
+    const outs = [];
+    let prev = bx1;
+    for (const [L, R] of inside) {
+      if (L > prev) outs.push([prev, L]);
+      prev = Math.max(prev, R);
+    }
+    if (prev < bx2) outs.push([prev, bx2]);
+    return outs;
+  }
+  largestRectContainingPointRegion(edges, p, bounds, mode) {
+    const BX1 = bounds.x;
+    const BX2 = bounds.x + bounds.w;
+    const BY1 = bounds.y;
+    const BY2 = bounds.y + bounds.h;
+    const intervals = this.regionIntervalsAtY(edges, p.y, BX1, BX2, mode);
+    const interval = intervals.find(
+      ([xL, xR]) => xL - 1e-9 <= p.x && p.x <= xR + 1e-9
+    );
+    if (!interval) return null;
+    let [X_L, X_R] = interval;
+    const xset = /* @__PURE__ */ new Set([X_L, X_R]);
+    for (const e of edges) {
+      if (!this.isVertical(e)) continue;
+      const x = e[0].x;
+      if (X_L < x && x < X_R) xset.add(x);
+    }
+    const xs = Array.from(xset).sort((a, b) => a - b);
+    const m = xs.length - 1;
+    if (m <= 0) return null;
+    const top = Array(m).fill(-Infinity);
+    const bot = Array(m).fill(Infinity);
+    for (let i = 0; i < m; i++) {
+      const xi = xs[i];
+      const xi1 = xs[i + 1];
+      if (xi === void 0 || xi1 === void 0) continue;
+      let xm = 0.5 * (xi + xi1);
+      if (xset.has(xm)) xm += 1e-6;
+      let minAbove = BY2;
+      let maxBelow = BY1;
+      for (const e of edges) {
+        if (!this.isHorizontal(e)) continue;
+        const y = e[0].y;
+        const x1 = Math.min(e[0].x, e[1].x);
+        const x2 = Math.max(e[0].x, e[1].x);
+        if (x1 - 1e-9 <= xm && xm <= x2 + 1e-9) {
+          if (y > p.y) minAbove = Math.min(minAbove, y);
+          if (y < p.y) maxBelow = Math.max(maxBelow, y);
+        }
+      }
+      if (!(maxBelow < minAbove)) {
+        top[i] = -Infinity;
+        bot[i] = Infinity;
+      } else {
+        top[i] = minAbove;
+        bot[i] = maxBelow;
+      }
+    }
+    let s0 = -1;
+    for (let i = 0; i < m; i++) {
+      const xi = xs[i];
+      const xi1 = xs[i + 1];
+      if (xi === void 0 || xi1 === void 0) continue;
+      if (xi - 1e-9 <= p.x && p.x <= xi1 + 1e-9) {
+        s0 = i;
+        break;
+      }
+    }
+    if (s0 === -1) return null;
+    let best = null;
+    let bestArea = -1;
+    for (let i = 0; i <= s0; i++) {
+      let minTop = Infinity;
+      let maxBot = -Infinity;
+      for (let j = i; j < m; j++) {
+        const topJ = top[j];
+        const botJ = bot[j];
+        if (topJ === void 0 || botJ === void 0) continue;
+        minTop = Math.min(minTop, topJ);
+        maxBot = Math.max(maxBot, botJ);
+        if (j < s0) continue;
+        const height = Math.max(0, minTop - maxBot);
+        if (height <= 0) continue;
+        const xi = xs[i];
+        const xj1 = xs[j + 1];
+        if (xi === void 0 || xj1 === void 0) continue;
+        const width = xj1 - xi;
+        const area = width * height;
+        if (area > bestArea) {
+          bestArea = area;
+          best = { x: xi, y: maxBot, w: width, h: height };
+        }
+      }
+    }
+    return best;
+  }
+  getLargestRect() {
+    if (!this.solved) {
+      this.solve();
+    }
+    return this.largestRect;
+  }
+  getLargestRectBounds() {
+    if (!this.solved) {
+      this.solve();
+    }
+    if (!this.largestRect) {
+      return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+    }
+    return {
+      minX: this.largestRect.x,
+      minY: this.largestRect.y,
+      maxX: this.largestRect.x + this.largestRect.w,
+      maxY: this.largestRect.y + this.largestRect.h
+    };
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      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];
+      if (p1 && p2) {
+        graphics.lines.push({
+          points: [p1, p2],
+          strokeColor: "rgba(0,0,0,0.5)"
+        });
+      }
+    }
+    graphics.lines.push({
+      points: [...this.fullOutline, this.fullOutline[0]],
+      strokeColor: "rgba(200, 200, 200, 0.5)",
+      strokeDash: [10, 5]
+    });
+    graphics.circles.push({
+      center: this.origin,
+      radius: 0.05,
+      fill: "#f44336",
+      label: "Origin"
+    });
+    if (this.largestRect) {
+      graphics.rects.push({
+        center: {
+          x: this.largestRect.x + this.largestRect.w / 2,
+          y: this.largestRect.y + this.largestRect.h / 2
+        },
+        width: this.largestRect.w,
+        height: this.largestRect.h,
+        fill: "rgba(0, 255, 0, 0.3)",
+        stroke: "#4CAF50",
+        label: `Largest Rectangle (Area: ${(this.largestRect.w * this.largestRect.h).toFixed(3)})`
+      });
+    }
+    return graphics;
+  }
+};
 export {
+  LargestRectOutsideOutlineFromPointSolver,
   PhasedPackSolver,
   convertCircuitJsonToPackOutput,
   convertPackOutputToPackInput,

package/package.json

@@ -2,7 +2,7 @@
   "name": "calculate-packing",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Calculate a packing layout with support for different strategy configurations",
   "scripts": {
     "start": "cosmos",
@@ -25,8 +25,10 @@
     "@types/bun": "latest",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
+    "@vitejs/plugin-react": "^5.0.0",
     "bun-match-svg": "^0.0.12",
     "circuit-json": "^0.0.220",
+    "framer-motion": "^12.23.12",
     "graphics-debug": "^0.0.62",
     "react": "^19.1.0",
     "react-cosmos": "^7.0.0",
@@ -34,7 +36,7 @@
     "react-dom": "^19.1.0",
     "tscircuit": "^0.0.562",
     "tsup": "^8.5.0",
-    "vite": "^7.0.5"
+    "vite": "^7.1.2"
   },
   "peerDependencies": {
     "typescript": "^5",