@knowvah/dot-engine 0.1.0

package/src/layout/pack/poly-pack.ts

@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Polyomino-based rectangle packing algorithm.
+ *
+ * Based on "Disconnected Graph Layout and the Polyomino Packing Approach",
+ * K. Freivalds et al., GD'01, LNCS 2265, pp. 378-391.
+ *
+ * @see lib/pack/pack.c:polyRects
+ * @see lib/pack/pack.c:computeStep
+ * @see lib/pack/pack.c:placeGraph
+ * @see lib/pack/pack.c:fits
+ */
+
+import type { Box, Point } from '../../model/geom.js';
+import type { PackInfo } from './types.js';
+import { spiralSearch } from './spiral-search.js';
+import { gvQsort } from '../../util/bsd-qsort.js';
+import { cround } from '../../common/arith.js';
+
+/** Max average polyomino size constant. @see lib/pack/pack.c:C */
+const C = 100;
+
+/** Grid cell coverage info for one rectangle. */
+export interface GInfo {
+  perim: number;
+  cells: Point[];
+  index: number;
+}
+
+/** A set of occupied grid cells (string-keyed for O(1) lookup). */
+export type PointSet = Set<string>;
+
+/**
+ * Encode a grid point as a canonical string key.
+ *
+ * C keys its PointSet dict on the `pointf` cell itself (exact double compare,
+ * no rounding). Every cell coordinate reaching here is an exact integer grid
+ * index produced by genBox's `cround(cval(...))`, so the rounding mode is
+ * unobservable; `cround` is used only so no `Math.round` survives in a layout
+ * coordinate path.
+ * @see lib/common/pointset.h:45 (insertPS/inPS take pointf)
+ */
+export function psKey(x: number, y: number): string {
+  return `${cround(x)},${cround(y)}`;
+}
+
+/** Check if a cell is in the point set. @see lib/pack/pack.c:inPS */
+export function inPS(ps: PointSet, p: Point): boolean {
+  return ps.has(psKey(p.x, p.y));
+}
+
+/** Insert a cell into the point set. @see lib/pack/pack.c:insertPS */
+export function insertPS(ps: PointSet, p: Point): void {
+  ps.add(psKey(p.x, p.y));
+}
+
+/**
+ * Compute the polyomino grid step size (positive root of quadratic).
+ *
+ * @see lib/pack/pack.c:computeStep
+ */
+export function computeStep(ng: number, bbs: Box[], margin: number): number {
+  let b = 0;
+  let c = 0;
+  const a = C * ng - 1;
+  for (let i = 0; i < ng; i++) {
+    const bb = bbs[i];
+    if (bb === undefined) continue;
+    const W = bb.ur.x - bb.ll.x + 2 * margin;
+    const H = bb.ur.y - bb.ll.y + 2 * margin;
+    b -= W + H;
+    c -= W * H;
+  }
+  const d = b * b - 4.0 * a * c;
+  if (d < 0) return 1;
+  const root = Math.floor((-b + Math.sqrt(d)) / (2 * a));
+  return root <= 0 ? 1 : root;
+}
+
+/**
+ * Number of grid cells required to cover length x at cell size s.
+ *
+ * @see lib/pack/pack.c:GRID
+ */
+export function gridCells(x: number, s: number): number {
+  return Math.ceil(x / s);
+}
+
+/**
+ * Grid cell index containing coordinate v at cell size s.
+ *
+ * C's `CVAL` macro is applied to the DOUBLE `pointf` fields inside `CELL`
+ * (genBox), so the division is floating-point — it yields a fractional cell
+ * coordinate that genBox then rounds (see {@link cround}). Modelling it with
+ * integer/truncating division (the previous `Math.floor`/`Math.trunc` form)
+ * diverges: e.g. `CVAL(-4, 5)` is `((-4+1)/5)-1 = -1.6` (→ round -2), not
+ * `-1`. That shrank every packed box's footprint by a cell on the negative
+ * side, packing the osage pack_neato2 grid tighter than native.
+ *
+ * @see lib/pack/pack.c:CVAL / CELL
+ */
+export function cval(v: number, s: number): number {
+  return v >= 0 ? v / s : (v + 1) / s - 1;
+}
+
+/** Parameters for genBox. */
+export interface GenBoxParams {
+  bb: Box;
+  ssize: number;
+  margin: number;
+  idx: number;
+}
+
+/**
+ * Generate the grid cell coverage for a bounding box.
+ *
+ * @see lib/pack/pack.c:genBox
+ */
+export function genBox(p: GenBoxParams): GInfo {
+  const { bb, ssize, margin, idx } = p;
+  // C rounds the box corners first, then measures the cell region relative to
+  // `center` (always the origin under polyRects/osage): LL = center - margin,
+  // UR = center + (roundedWidth/Height) + margin. Each corner is mapped to a
+  // grid cell by CELL (CVAL on the double coordinate) and then round()ed.
+  // @see lib/pack/pack.c:genBox
+  const w = cround(bb.ur.x) - cround(bb.ll.x);
+  const h = cround(bb.ur.y) - cround(bb.ll.y);
+  const llx = cround(cval(-margin, ssize));
+  const lly = cround(cval(-margin, ssize));
+  const urx = cround(cval(w + margin, ssize));
+  const ury = cround(cval(h + margin, ssize));
+  const cells: Point[] = [];
+  for (let x = llx; x <= urx; x++) {
+    for (let y = lly; y <= ury; y++) {
+      cells.push({ x, y });
+    }
+  }
+  const W = gridCells(bb.ur.x - bb.ll.x + 2 * margin, ssize);
+  const H = gridCells(bb.ur.y - bb.ll.y + 2 * margin, ssize);
+  return { perim: W + H, cells, index: idx };
+}
+
+/** Context passed to fits() and placeGraph(). */
+export interface PlaceCtx {
+  ps: PointSet;
+  step: number;
+  bbs: Box[];
+}
+
+/**
+ * Test whether any shifted cell collides with the occupied set.
+ * Returns true if there is a collision (polyomino does NOT fit).
+ *
+ * @see lib/pack/pack.c:fits (collision check loop)
+ */
+export function hasCollision(cells: Point[], dx: number, dy: number, ps: PointSet): boolean {
+  for (let i = 0; i < cells.length; i++) {
+    const cell = cells[i];
+    if (cell !== undefined && inPS(ps, { x: cell.x + dx, y: cell.y + dy })) return true;
+  }
+  return false;
+}
+
+/**
+ * Mark all shifted cells as occupied in the point set.
+ *
+ * @see lib/pack/pack.c:fits (cell insertion loop)
+ */
+export function markCells(cells: Point[], dx: number, dy: number, ps: PointSet): void {
+  for (let i = 0; i < cells.length; i++) {
+    const cell = cells[i];
+    if (cell !== undefined) insertPS(ps, { x: cell.x + dx, y: cell.y + dy });
+  }
+}
+
+/**
+ * Test if a polyomino fits at (x,y); if so, record placement and fill cells.
+ *
+ * @see lib/pack/pack.c:fits
+ */
+export function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): Point | null {
+  if (hasCollision(info.cells, x, y, ctx.ps)) return null;
+  const bb = ctx.bbs[info.index];
+  if (bb === undefined) return null;
+  // C rounds the component's LL with round() — half AWAY from zero. Component
+  // bounding boxes are negative for every center-origin engine (neato/circo/
+  // twopi/sfdp), so a `.5` LL is ordinary and Math.round would translate the
+  // whole placed component by 1pt.
+  // @see lib/pack/pack.c:435-438 (fits: `const pointf LL = {.x = round(...)}`)
+  const place: Point = {
+    x: ctx.step * x - cround(bb.ll.x),
+    y: ctx.step * y - cround(bb.ll.y),
+  };
+  markCells(info.cells, x, y, ctx.ps);
+  return place;
+}
+
+/**
+ * Try centered placement for the first graph (i === 0).
+ *
+ * @see lib/pack/pack.c:placeGraph (i==0 branch)
+ */
+export function tryCenter(info: GInfo, ctx: PlaceCtx, margin: number): Point | null {
+  const bb = ctx.bbs[info.index];
+  if (bb === undefined) return null;
+  const W = gridCells(bb.ur.x - bb.ll.x + 2 * margin, ctx.step);
+  const H = gridCells(bb.ur.y - bb.ll.y + 2 * margin, ctx.step);
+  return fits(-Math.floor(W / 2), -Math.floor(H / 2), info, ctx);
+}
+
+/**
+ * Search concentric square spiral for a placement of the polyomino.
+ *
+ * @see lib/pack/pack.c:placeGraph
+ */
+export function placeGraph(i: number, info: GInfo, ctx: PlaceCtx, margin: number): Point {
+  if (i === 0) {
+    const p = tryCenter(info, ctx, margin);
+    if (p !== null) return p;
+  }
+  const p0 = fits(0, 0, info, ctx);
+  if (p0 !== null) return p0;
+  const bb = ctx.bbs[info.index];
+  const wide = bb !== undefined &&
+    Math.ceil(bb.ur.x - bb.ll.x) >= Math.ceil(bb.ur.y - bb.ll.y);
+  return spiralSearch(info, ctx, wide);
+}
+
+/**
+ * Sort GInfo by descending perimeter.
+ *
+ * @see lib/pack/pack.c:cmpf
+ */
+export function cmpByGPerimeter(a: GInfo, b: GInfo): number {
+  return b.perim - a.perim;
+}
+
+/**
+ * Pack rectangles using polyomino placement.
+ * Returns translation points indexed by original rectangle index.
+ *
+ * @see lib/pack/pack.c:polyRects
+ */
+export function polyRects(ng: number, bbs: Box[], pinfo: PackInfo): Point[] | null {
+  const step = computeStep(ng, bbs, pinfo.margin);
+  if (step <= 0) return null;
+  const infos: GInfo[] = [];
+  for (let i = 0; i < ng; i++) {
+    const bb = bbs[i];
+    if (bb === undefined) continue;
+    infos.push(genBox({ bb, ssize: step, margin: pinfo.margin, idx: i }));
+  }
+  // C `pack.c` sorts these via `qsort(cmpf)` (UNSTABLE); cmpf returns 0 on equal
+  // perimeter, so the tie order of equal-perimeter components is decided by libc
+  // qsort, not insertion order. Match it. @see util/bsd-qsort.ts
+  const sorted = gvQsort([...infos], cmpByGPerimeter);
+  const ctx: PlaceCtx = { ps: new Set(), step, bbs };
+  const places: Point[] = new Array<Point>(ng).fill({ x: 0, y: 0 });
+  for (let i = 0; i < sorted.length; i++) {
+    const info = sorted[i];
+    if (info === undefined) continue;
+    places[info.index] = placeGraph(i, info, ctx, pinfo.margin);
+  }
+  return places;
+}

package/src/layout/pack/poly-place.ts

@@ -0,0 +1,426 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Polyomino-based packing of laid-out graphs (components), a port of
+ * the l_node/l_clust/l_graph modes of putGraphs.
+ *
+ * Each graph is approximated by the set of grid cells ("polyomino")
+ * covered by its nodes and edges (or its bounding box in l_graph
+ * mode); polyominoes are then placed largest-first on concentric
+ * rings around the origin.
+ *
+ * @see lib/pack/pack.c (Freivalds et al., GD 2002 polyomino packing)
+ */
+
+import type { Box, Point } from '../../model/geom.js';
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { PackInfo } from './types.js';
+import { PackMode } from './types.js';
+import { cround } from '../../common/arith.js';
+import { gvQsort } from '../../util/bsd-qsort.js';
+
+/** Max. avg. polyomino size. @see lib/pack/pack.c:C */
+const C_AVG = 100;
+
+/** Cells required by size x at cell size s. @see lib/pack/pack.c:GRID */
+function grid(x: number, s: number): number {
+  return Math.ceil(x / s);
+}
+
+/** Cell index of coordinate v (double arithmetic). @see lib/pack/pack.c:CVAL */
+function cval(v: number, s: number): number {
+  return v >= 0 ? v / s : (v + 1) / s - 1;
+}
+
+/** Map a point to its containing cell. @see lib/pack/pack.c:CELL */
+function cell(p: Point, s: number): Point {
+  return { x: cval(p.x, s), y: cval(p.y, s) };
+}
+
+/** Integer point set. @see lib/common/pointset.c */
+class PointSet {
+  private readonly m = new Map<string, Point>();
+  add(x: number, y: number): void {
+    this.m.set(`${x},${y}`, { x, y });
+  }
+  has(p: Point): boolean {
+    return this.m.has(`${p.x},${p.y}`);
+  }
+  points(): Point[] {
+    return [...this.m.values()];
+  }
+  get size(): number {
+    return this.m.size;
+  }
+}
+
+/** Polyomino info for one graph. @see lib/pack/pack.c:ginfo */
+interface GInfo {
+  perim: number;
+  cells: Point[];
+  index: number;
+}
+
+/**
+ * Grid step size: positive root of the quadratic over total cell area.
+ * @see lib/pack/pack.c:computeStep
+ */
+export function computeStep(bbs: Box[], margin: number): number {
+  const a = C_AVG * bbs.length - 1;
+  let b = 0;
+  let c = 0;
+  for (const bb of bbs) {
+    const W = bb.ur.x - bb.ll.x + 2 * margin;
+    const H = bb.ur.y - bb.ll.y + 2 * margin;
+    b -= W + H;
+    c -= W * H;
+  }
+  const r = Math.sqrt(b * b - 4 * a * c);
+  const root = Math.trunc((-b + r) / (2 * a));
+  return root === 0 ? 1 : root;
+}
+
+/** Bresenham state for one rasterised line. */
+interface LineState {
+  x: number; y: number; x2: number; y2: number;
+  ax: number; ay: number; sx: number; sy: number;
+}
+
+/** X-dominant Bresenham sweep. @see pack.c:fillLine */
+function lineXDominant(st: LineState, ps: PointSet): void {
+  let d = st.ay - (st.ax >> 1);
+  for (;;) {
+    ps.add(st.x, st.y);
+    if (st.x === st.x2) return;
+    if (d >= 0) { st.y += st.sy; d -= st.ax; }
+    st.x += st.sx;
+    d += st.ay;
+  }
+}
+
+/** Y-dominant Bresenham sweep. @see pack.c:fillLine */
+function lineYDominant(st: LineState, ps: PointSet): void {
+  let d = st.ax - (st.ay >> 1);
+  for (;;) {
+    ps.add(st.x, st.y);
+    if (st.y === st.y2) return;
+    if (d >= 0) { st.x += st.sx; d -= st.ay; }
+    st.y += st.sy;
+    d += st.ax;
+  }
+}
+
+/** Mark cells crossed by the cell-space line p-q (Bresenham). @see pack.c:fillLine */
+function fillLine(p: Point, q: Point, ps: PointSet): void {
+  const x = cround(p.x);
+  const y = cround(p.y);
+  const x2 = cround(q.x);
+  const y2 = cround(q.y);
+  const dx = x2 - x;
+  const dy = y2 - y;
+  const st: LineState = {
+    x, y, x2, y2,
+    ax: Math.abs(dx) << 1, ay: Math.abs(dy) << 1,
+    sx: dx > 0 ? 1 : -1, sy: dy > 0 ? 1 : -1,
+  };
+  if (st.ax > st.ay) lineXDominant(st, ps);
+  else lineYDominant(st, ps);
+}
+
+/** Mark all cells in the inclusive cell-rect [LL, UR]. */
+function fillRect(LL: Point, UR: Point, ps: PointSet): void {
+  for (let x = LL.x; x <= UR.x; x++) {
+    for (let y = LL.y; y <= UR.y; y++) ps.add(x, y);
+  }
+}
+
+/** Rounded cell for a translated point. */
+function roundedCell(p: Point, ssize: number): Point {
+  const c = cell(p, ssize);
+  return { x: cround(c.x), y: cround(c.y) };
+}
+
+/**
+ * Mark cells crossed by edge e. With doS and a routed spline present, follow
+ * the spline control points (self-loops and curved edges bulge past the
+ * straight tail-to-head chord, adding cells the packer must respect); else a
+ * straight tail-to-head line. neato/twopi component packing set doSplines=true,
+ * so the spline branch is live — omitting it undercounts the polyomino and lets
+ * a neighbouring component pack one grid cell too close.
+ * @see lib/pack/pack.c:fillEdge
+ */
+function fillEdge(
+  e: Edge, p: Point, ps: PointSet, off: Point, ssize: number, doS: boolean,
+): void {
+  const spl = e.info.spl;
+  // C: `if (!doS || !ED_spl(e))` — straight segment tail cell -> head cell.
+  if (!doS || spl === undefined) {
+    const hc = e.head.info.coord ?? { x: 0, y: 0 };
+    const hpt = roundedCell({ x: hc.x + off.x, y: hc.y + off.y }, ssize);
+    fillLine(p, hpt, ps);
+    return;
+  }
+  const cellOf = (q: Point): Point => roundedCell({ x: q.x + off.x, y: q.y + off.y }, ssize);
+  for (let j = 0; j < spl.size; j++) {
+    const bz = spl.list[j];
+    if (bz === undefined) continue;
+    let pt: Point;
+    let hpt: Point;
+    let k: number;
+    if (bz.sflag) {
+      pt = cellOf(bz.sp);
+      hpt = cellOf(bz.list[0]!);
+      k = 1;
+    } else {
+      pt = cellOf(bz.list[0]!);
+      hpt = cellOf(bz.list[1]!);
+      k = 2;
+    }
+    fillLine(pt, hpt, ps);
+    for (; k < bz.size; k++) {
+      pt = hpt;
+      hpt = cellOf(bz.list[k]!);
+      fillLine(pt, hpt, ps);
+    }
+    if (bz.eflag) {
+      pt = hpt;
+      hpt = cellOf(bz.ep);
+      fillLine(pt, hpt, ps);
+    }
+  }
+}
+
+/**
+ * Polyomino from a graph's bounding box only (l_graph mode).
+ * @see lib/pack/pack.c:genBox
+ */
+function genBox(bb0: Box, ssize: number, margin: number, center: Point): GInfo {
+  const ps = new PointSet();
+  const bbW = cround(bb0.ur.x) - cround(bb0.ll.x);
+  const bbH = cround(bb0.ur.y) - cround(bb0.ll.y);
+  const LL = roundedCell({ x: center.x - margin, y: center.y - margin }, ssize);
+  const UR = roundedCell({ x: center.x + bbW + margin, y: center.y + bbH + margin }, ssize);
+  fillRect(LL, UR, ps);
+  return {
+    cells: ps.points(),
+    perim: grid(bb0.ur.x - bb0.ll.x + 2 * margin, ssize)
+      + grid(bb0.ur.y - bb0.ll.y + 2 * margin, ssize),
+    index: 0,
+  };
+}
+
+/** Shared cover-pass parameters. */
+interface CoverCtx {
+  eg: Graph;
+  ps: PointSet;
+  off: Point;
+  ssize: number;
+  margin: number;
+  doSplines: boolean;
+}
+
+/** Cover one node's box and its out-edges. @see pack.c:genPoly (node loop body) */
+function coverNode(n: Node, ctx: CoverCtx): void {
+  const c = n.info.coord ?? { x: 0, y: 0 };
+  const pt = { x: cround(c.x) + ctx.off.x, y: cround(c.y) + ctx.off.y };
+  const s2 = {
+    x: cround(ctx.margin + (n.info.lw + n.info.rw) / 2),
+    y: cround(ctx.margin + n.info.ht / 2),
+  };
+  const LL = roundedCell({ x: pt.x - s2.x, y: pt.y - s2.y }, ctx.ssize);
+  const UR = roundedCell({ x: pt.x + s2.x, y: pt.y + s2.y }, ctx.ssize);
+  fillRect(LL, UR, ctx.ps);
+  const cpt = roundedCell(pt, ctx.ssize);
+  for (const e of n.outEdges(ctx.eg)) {
+    fillEdge(e, cpt, ctx.ps, ctx.off, ctx.ssize, ctx.doSplines);
+  }
+}
+
+/**
+ * Polyomino from a graph's nodes and edges (l_node mode; the l_clust
+ * top-cluster special case is not ported — no packing caller has
+ * clusters inside components yet).
+ * @see lib/pack/pack.c:genPoly
+ */
+function genPoly(
+  root: Graph, g: Graph, bb: Box, ssize: number, pinfo: PackInfo, center: Point,
+): GInfo {
+  const ps = new PointSet();
+  // C: dx = center.x - round(GD_bb(g).LL.x) (pack.c:genPoly). center is (0,0)
+  // for free packing and the fixed-component bb midpoint when a pinned graph
+  // is present — it shifts every component's grid phase identically so the
+  // polyomino cell counts (and thus perimeters and sort order) match C.
+  const ctx: CoverCtx = {
+    eg: root,
+    ps,
+    off: { x: center.x - cround(bb.ll.x), y: center.y - cround(bb.ll.y) },
+    ssize,
+    margin: pinfo.margin,
+    doSplines: pinfo.doSplines,
+  };
+  for (const n of g.nodes.values()) coverNode(n, ctx);
+  return {
+    cells: ps.points(),
+    perim: grid(bb.ur.x - bb.ll.x + 2 * pinfo.margin, ssize)
+      + grid(bb.ur.y - bb.ll.y + 2 * pinfo.margin, ssize),
+    index: 0,
+  };
+}
+
+/**
+ * Try the polyomino at cell (x, y); on success occupy the cells and
+ * record the placement offset.
+ * @see lib/pack/pack.c:fits
+ */
+/** Shared placement state. */
+interface PlaceCtx {
+  ps: PointSet;
+  places: Point[];
+  step: number;
+  margin: number;
+  bbs: Box[];
+}
+
+function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): boolean {
+  for (const c of info.cells) {
+    if (ctx.ps.has({ x: c.x + x, y: c.y + y })) return false;
+  }
+  const bb = ctx.bbs[info.index]!;
+  const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
+  ctx.places[info.index] = { x: ctx.step * x - LL.x, y: ctx.step * y - LL.y };
+  for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
+  return true;
+}
+
+/** Ring candidates for wide graphs (W >= H). @see pack.c:placeGraph */
+function* ringWide(bnd: number): Generator<[number, number]> {
+  let x = 0;
+  let y = -bnd;
+  for (; x < bnd; x++) yield [x, y];
+  for (; y < bnd; y++) yield [x, y];
+  for (; x > -bnd; x--) yield [x, y];
+  for (; y > -bnd; y--) yield [x, y];
+  for (; x < 0; x++) yield [x, y];
+}
+
+/** Ring candidates for tall graphs (W < H). @see pack.c:placeGraph */
+function* ringTall(bnd: number): Generator<[number, number]> {
+  let y = 0;
+  let x = -bnd;
+  for (; y > -bnd; y--) yield [x, y];
+  for (; x < bnd; x++) yield [x, y];
+  for (; y < bnd; y++) yield [x, y];
+  for (; x > -bnd; x--) yield [x, y];
+  for (; y > 0; y--) yield [x, y];
+}
+
+/**
+ * Position a fixed (pinned) graph. Its polyomino was generated where it will
+ * be (via the center offset in genPoly), so the final translation is just
+ * -center and its cells are occupied as-is.
+ * @see lib/pack/pack.c:placeFixed
+ */
+function placeFixed(info: GInfo, ctx: PlaceCtx, center: Point): void {
+  ctx.places[info.index] = { x: -center.x, y: -center.y };
+  for (const c of info.cells) ctx.ps.add(c.x, c.y);
+}
+
+/**
+ * Place one polyomino on concentric rings out from the origin; the
+ * first (largest) graph is centered on the origin when possible.
+ * @see lib/pack/pack.c:placeGraph
+ */
+function placeGraph(i: number, info: GInfo, ctx: PlaceCtx): void {
+  const bb = ctx.bbs[info.index]!;
+  if (i === 0) {
+    const W = grid(bb.ur.x - bb.ll.x + 2 * ctx.margin, ctx.step);
+    const H = grid(bb.ur.y - bb.ll.y + 2 * ctx.margin, ctx.step);
+    if (fits(-Math.trunc(W / 2), -Math.trunc(H / 2), info, ctx)) return;
+  }
+  if (fits(0, 0, info, ctx)) return;
+  const wide = Math.ceil(bb.ur.x - bb.ll.x) >= Math.ceil(bb.ur.y - bb.ll.y);
+  for (let bnd = 1; ; bnd++) {
+    const ring = wide ? ringWide(bnd) : ringTall(bnd);
+    for (const [x, y] of ring) {
+      if (fits(x, y, info, ctx)) return;
+    }
+  }
+}
+
+/**
+ * Polyomino packing of pre-laid-out graphs. Returns the translation
+ * point for each graph (indexed like gs). When pinfo.fixed is set, the
+ * fixed (pinned) components stay put and the rest pack around them.
+ * @see lib/pack/pack.c:polyGraphs
+ */
+export function polyGraphs(
+  gs: Graph[], root: Graph, pinfo: PackInfo, bbs: Box[],
+): Point[] | null {
+  if (gs.length === 0) return null;
+  const stepSize = computeStep(bbs, pinfo.margin);
+  if (stepSize <= 0) return null;
+  // Fixed (pinned) protocol: when some components carry a pinned node, C keeps
+  // them put and packs the rest around them. center = midpoint of the union of
+  // the fixed components' (rounded) bboxes; (0,0) for free packing.
+  // @see lib/pack/pack.c:putGraphs (fixed_bb / center / placeFixed)
+  const fixed = pinfo.fixed;
+  const center = { x: 0, y: 0 };
+  if (fixed) {
+    let fixedBB: Box | null = null;
+    for (let i = 0; i < gs.length; i++) {
+      if (!fixed[i]) continue;
+      const b = bbs[i]!;
+      const rb: Box = {
+        ll: { x: cround(b.ll.x), y: cround(b.ll.y) },
+        ur: { x: cround(b.ur.x), y: cround(b.ur.y) },
+      };
+      fixedBB = fixedBB === null ? rb : {
+        ll: { x: Math.min(rb.ll.x, fixedBB.ll.x), y: Math.min(rb.ll.y, fixedBB.ll.y) },
+        ur: { x: Math.max(rb.ur.x, fixedBB.ur.x), y: Math.max(rb.ur.y, fixedBB.ur.y) },
+      };
+    }
+    if (fixedBB) {
+      center.x = cround((fixedBB.ll.x + fixedBB.ur.x) / 2);
+      center.y = cround((fixedBB.ll.y + fixedBB.ur.y) / 2);
+    }
+  }
+  const info: GInfo[] = gs.map((g, i) => {
+    const gi = pinfo.mode === PackMode.Graph
+      ? genBox(bbs[i]!, stepSize, pinfo.margin, center)
+      : genPoly(root, g, bbs[i]!, stepSize, pinfo, center);
+    gi.index = i;
+    return gi;
+  });
+  // descending by perimeter (C qsort with flipped comparator); cmpf returns 0 on
+  // equal perimeter, so the tie order is qsort's, not insertion order. @see util/bsd-qsort.ts
+  const sinfo = gvQsort([...info], (a, b) => b.perim - a.perim);
+  const ctx: PlaceCtx = {
+    ps: new PointSet(),
+    places: gs.map(() => ({ x: 0, y: 0 })),
+    step: stepSize,
+    margin: pinfo.margin,
+    bbs,
+  };
+  if (fixed) {
+    // C indexes `fixed` by the SORTED loop position i, not sinfo[i].index — an
+    // original-vs-sorted-index mismatch in pack.c that is load-bearing: the
+    // component at sorted position k is treated as fixed iff fixed[k]. With
+    // fixed = [true,false,…], that fixes the LARGEST component (sorted first)
+    // at -center, not the pinned one, and the pinned component is packed
+    // normally at its sorted position. Replicate the quirk exactly.
+    // @see lib/pack/pack.c:putGraphs (fixed placement loops)
+    for (let i = 0; i < sinfo.length; i++) {
+      if (fixed[i]) placeFixed(sinfo[i]!, ctx, center);
+    }
+    for (let i = 0; i < sinfo.length; i++) {
+      if (!fixed[i]) placeGraph(i, sinfo[i]!, ctx);
+    }
+  } else {
+    for (let i = 0; i < sinfo.length; i++) {
+      placeGraph(i, sinfo[i]!, ctx);
+    }
+  }
+  return ctx.places;
+}