@knowvah/dot-engine 2.6.1 → 2.6.3

package/src/layout/circo/position-helpers.ts

@@ -12,12 +12,18 @@
 import type { Node } from '../../model/node.js';
 import type { Block } from './blocks.js';
 import { isCoalesced } from './blocks.js';
+import { fma } from '../../common/fma.js';
+import { libmHypot } from '../../common/libm-hypot.js';
 
-/** 2-D rotation of (x,y) by (cosR, sinR). */
+/**
+ * 2-D rotation of (x,y) by (cosR, sinR). clang contracts both lines into
+ * fmadd: X = x*cosR + (-sinR*y), Y = x*sinR + cosR*y (objdump of
+ * `_applyDelta`).
+ */
 export function rotatePoint(
   x: number, y: number, cosR: number, sinR: number,
 ): [number, number] {
-  return [x * cosR - y * sinR, x * sinR + y * cosR];
+  return [fma(x, cosR, -sinR * y), fma(x, sinR, cosR * y)];
 }
 
 /** Read psi from a node's alg field (set during Pass 4). */
@@ -27,7 +33,7 @@ export function nodePsi(n: Node): number {
 
 /** getRotation: single-node block with preset parent_pos. */
 export function rotFromParentPos(sn: Block, theta: number): number {
-  let r = theta + Math.PI - sn.parentPos;
+  let r = theta + (Math.PI - sn.parentPos); // C: theta += M_PI - parent_pos
   if (r < 0) r += 2 * Math.PI;
   return r;
 }
@@ -35,16 +41,19 @@ export function rotFromParentPos(sn: Block, theta: number): number {
 /** Find the node in sn closest to origin after translation by (x,y). */
 export function closestNode(sn: Block, x: number, y: number, skip: Node): Node {
   let best = skip;
-  let bestDist = Math.hypot(skip.info.pos![0]! + x, skip.info.pos![1]! + y);
+  let bestDist = libmHypot(skip.info.pos![0]! + x, skip.info.pos![1]! + y);
   for (const dn of sn.subGraph.nodes) {
     if (dn.orig === skip) continue;
-    const d = Math.hypot(dn.orig.info.pos![0]! + x, dn.orig.info.pos![1]! + y);
+    const d = libmHypot(dn.orig.info.pos![0]! + x, dn.orig.info.pos![1]! + y);
     if (d < bestDist) { bestDist = d; best = dn.orig; }
   }
   return best;
 }
 
-/** getRotation: COALESCED block — off-center trigonometric correction. */
+/**
+ * getRotation: COALESCED block whose neighbor lies right of -r — off-center
+ * trigonometric correction. C: `theta += M_PI / 2.0 - phi - asin(...)`.
+ */
 export function rotCoalesced(
   sn: Block, x: number, y: number, nbr: Node, theta: number,
 ): number {
@@ -52,26 +61,28 @@ export function rotCoalesced(
   const r = sn.radius - rho;
   const nx = nbr.info.pos![0]!;
   const ny = nbr.info.pos![1]!;
-  if (-r >= nx) {
-    const phi = Math.atan2(ny, nx);
-    return theta + Math.PI - phi - nodePsi(nbr);
-  }
-  const R = Math.hypot(x, y);
+  const R = libmHypot(x, y);
   const phi = Math.atan2(ny, nx + r);
   const l = r - rho / Math.cos(phi);
-  return theta + Math.PI / 2 - phi - Math.asin((l / R) * Math.cos(phi));
+  return theta + ((Math.PI / 2 - phi) - Math.asin((l / R) * Math.cos(phi)));
 }
 
-/** getRotation: general multi-node non-coalesced block. */
+/**
+ * getRotation when the neighbor is not the node closest to the parent: the
+ * coalesced correction when `COALESCED(sn) && -r < n_x`, else the
+ * origin-centred rotation `theta += M_PI - phi - PSI`, wrapped past 2*M_PI.
+ * @see lib/circogen/circpos.c:getRotation
+ */
 export function rotGeneral(
   sn: Block, x: number, y: number, nbr: Node, theta: number,
 ): number {
   if (closestNode(sn, x, y, nbr) === nbr) return 0;
-  if (isCoalesced(sn)) return rotCoalesced(sn, x, y, nbr, theta);
+  const r = sn.radius - sn.rad0;
+  if (isCoalesced(sn) && -r < nbr.info.pos![0]!) return rotCoalesced(sn, x, y, nbr, theta);
   const phi = Math.atan2(nbr.info.pos![1]!, nbr.info.pos![0]!);
-  let r = theta + Math.PI - phi - nodePsi(nbr);
-  if (r > 2 * Math.PI) r -= 2 * Math.PI;
-  return r;
+  let t = theta + ((Math.PI - phi) - nodePsi(nbr));
+  if (t > 2 * Math.PI) t -= 2 * Math.PI;
+  return t;
 }
 
 /**

package/src/layout/circo/position.ts

@@ -15,6 +15,7 @@ import type { Block, SubGraph, CircState } from './blocks.js';
 import { blkParent, setCoalesced, FLAGS_ISPARENT } from './blocks.js';
 import { applyDelta, getRotation } from './position-helpers.js';
 import { layoutBlock } from './blockpath.js';
+import { fma } from '../../common/fma.js';
 
 export type PosState = {
   radius: number; subtreeR: number; nodeAngle: number;
@@ -48,10 +49,14 @@ export function getInfo(pi: PosInfo, stp: PosState, minDist: number): number {
   return maxR;
 }
 
-/** @see lib/circogen/circpos.c:setInfo */
+/**
+ * The numerator is one clang-contracted fmadd: p0.diameter * p1.minRadius
+ * added to the rounded p1.diameter * p0.minRadius (objdump of `_doBlock`).
+ * @see lib/circogen/circpos.c:setInfo
+ */
 export function setInfo(p0: PosInfo, p1: PosInfo, delta: number): void {
   const t = Math.max(
-    (p0.diameter * p1.minRadius + p1.diameter * p0.minRadius)
+    fma(p0.diameter, p1.minRadius, p1.diameter * p0.minRadius)
       / (2 * delta * p0.minRadius * p1.minRadius), 1,
   );
   p0.scale = Math.max(p0.scale, t);
@@ -63,9 +68,25 @@ export function placeChild(child: Block, ca: number, ctx: PlaceCtx): number {
   const dx = ctx.childRadius * Math.cos(ca);
   const dy = ctx.childRadius * Math.sin(ca);
   applyDelta(child, dx, dy, getRotation(child, dx, dy, ca));
-  return ctx.length === 1
-    ? ca + ctx.incAngle + ctx.mindistAngle
-    : ca + ctx.incAngle + ctx.mindistAngle / 2;
+  return nextChildAngle(ca, ctx.incAngle, ctx.mindistAngle, ctx.length);
+}
+
+/**
+ * The angle after placing a child. C's `childAngle += incidentAngle +
+ * mindistAngle` (or `+ mindistAngle / 2`) adds the right-hand sum last.
+ * @see lib/circogen/circpos.c:positionChildren
+ */
+export function nextChildAngle(ca: number, inc: number, mda: number, length: number): number {
+  return length === 1 ? ca + (inc + mda) : ca + (inc + mda / 2);
+}
+
+/**
+ * Circumference left over on a length-1 block's child circle: C's
+ * `2 * M_PI * childRadius - info->diameter`, contracted to one fnmsub.
+ * @see lib/circogen/circpos.c:positionChildren
+ */
+export function leftoverArc(childRadius: number, diameter: number): number {
+  return fma(2 * Math.PI, childRadius, -diameter);
 }
 
 /** Advance child angle for length===1 blocks; updates firstAngle/lastAngle. */
@@ -81,7 +102,7 @@ export function advanceAngleL1(
 /** Advance child angle for multi-node blocks. */
 export function advanceAngleLN(ca: number, inc: number, mda: number, total: number, theta: number): number {
   if (total === 1) return theta;
-  return ca + inc + mda / 2;
+  return ca + (inc + mda / 2); // C: childAngle += incidentAngle + mindistAngle / 2
 }
 
 /** Write psi midpoint angle to node alg when conditions are met. */
@@ -101,7 +122,7 @@ export function positionChildren(pi: PosInfo, stp: PosState, length: number, min
   if (length === 1) {
     cr = Math.max(cr, pi.diameter / (2 * Math.PI));
     // C redistributes leftover circumference into min_dist.
-    const d = 2 * Math.PI * cr - pi.diameter;
+    const d = leftoverArc(cr, pi.diameter);
     if (d > 0) md += d / pi.childCount;
   }
   stp.subtreeR = Math.max(stp.subtreeR, cr + pi.maxRadius);

package/src/layout/dot/ortho-adapter.ts

@@ -16,6 +16,7 @@ import type { Edge } from '../../model/edge.js';
 import { buildOutEdgeIndex } from '../../model/node.js';
 import { dotRoot } from './mincross-utils.js';
 import { nodesInSeq } from './decomp.js';
+import { PointSet } from '../../common/pointset.js';
 import { clipAndInstall } from '../../common/splines-clip.js';
 import { buildDotSinfo } from './self-loop.js';
 import { orthoEdges } from '../../ortho/index.js';
@@ -49,11 +50,27 @@ function buildNodes(nodeArr: Node[]): OrthoNodeArr {
   }));
 }
 
+/**
+ * Concentrate dedup: true when the unordered (tail, head) pair is already in
+ * `ps`; otherwise records it. C normalises AGSEQ(tail)/AGSEQ(head) to
+ * (min, max) and makes one isInPS/addPS pair on it.
+ * @see lib/ortho/ortho.c:1221-1229 (orthoEdges Concentrate PS)
+ */
+function isConcentrateDup(ps: PointSet, e: Edge): boolean {
+  const ti = e.tail.id;
+  const hi = e.head.id;
+  const lo = ti <= hi ? ti : hi;
+  const up = ti <= hi ? hi : ti;
+  if (ps.isInPS(lo, up)) return true;
+  ps.addPS(lo, up);
+  return false;
+}
+
 /**
  * Gather edges to route, mirroring C's ortho gather loop exactly:
  * iterate nodes in agfstnode (creation/seq) order, then each node's out-edges
  * in agfstout order. When `concentrate` is set, dedup by the UNORDERED node
- * pair via a point-set — the first edge between a pair (in either direction)
+ * pair via a `PointSet` — the first edge between a pair (in either direction)
  * is routed; any later edge sharing that pair (the reverse of a 2-cycle, or a
  * parallel multi-edge) is skipped. This is ortho's own concentrate mechanism,
  * distinct from class2's `edge_type == IGNORED` marking, and the keep-first
@@ -70,19 +87,13 @@ function buildEdges(
   const nodeIndex = new Map<Node, number>();
   nodeArr.forEach((n, i) => nodeIndex.set(n, i));
   const outIndex = buildOutEdgeIndex(g);
-  const seen = new Set<string>();
+  const ps = concentrate ? new PointSet() : null;
   const result: TaggedOrthoEdge[] = [];
   for (const n of nodeArr) {
     const oes = outIndex.get(n);
     if (oes === undefined) continue;
     for (const e of oes) {
-      if (concentrate) {
-        const ti = e.tail.id;
-        const hi = e.head.id;
-        const key = ti <= hi ? `${ti},${hi}` : `${hi},${ti}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-      }
+      if (ps !== null && isConcentrateDup(ps, e)) continue;
       result.push({
         tail: orthoNodes[nodeIndex.get(e.tail)!],
         head: orthoNodes[nodeIndex.get(e.head)!],

package/src/layout/neato/multispline.ts

@@ -333,6 +333,18 @@ function chainOf(e: Edge): Edge[] {
   return list;
 }
 
+/**
+ * agwarningf at each genroute failure site (Graphviz prefixes "Warning: ");
+ * returns genroute's failure code 1.
+ * @see multispline.c:genroute
+ */
+function warnNoControlPoints(e: Edge): number {
+  console.warn(
+    `Warning: Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
+  );
+  return 1;
+}
+
 /**
  * Generate splines for e and cohorts through the corridor polygon.
  * Edges run from polygon index 0 to t. Returns 0 on success.
@@ -350,7 +362,7 @@ function genroute(
   const head = e.head;
 
   const pl = shortestPath({ ps: trip.ps }, eps);
-  if (pl === null) return 1;
+  if (pl === null) return warnNoControlPoints(e);
 
   if (pl.length === 2) {
     // C passes doPolyline (0/1) AS the edge type — so the polyline case
@@ -365,7 +377,7 @@ function genroute(
 
   if (mult === 1 || concentrate) {
     const spl = routeMember(trip.ps, t, pl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(e);
     finishEdge(e, spl, e.head !== head);
     return 0;
   }
@@ -374,7 +386,7 @@ function genroute(
   const cpts: Point[][] = [];
   for (let i = 0; i + 2 < pl.length; i++) {
     const cp = mkCtrlPts(t, mult + 1, pl[i]!, pl[i + 1]!, pl[i + 2]!, trip);
-    if (cp === null) return 1;
+    if (cp === null) return warnNoControlPoints(e);
     cpts.push(cp);
   }
 
@@ -390,10 +402,10 @@ function genroute(
       poly[pn - j] = cpts[j - 1]![i + 1]!;
     }
     const mmpl = shortestPath({ ps: poly }, eps);
-    if (mmpl === null) return 1;
+    if (mmpl === null) return warnNoControlPoints(cur);
 
     const spl = routeMember(poly, pl.length - 1, mmpl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(cur);
     finishEdge(cur, spl, cur.head !== head);
 
     cur = cur.info.to_virt;

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

@@ -17,6 +17,7 @@ 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';
+import { PointSet } from '../../common/pointset.js';
 import { d2i } from '../../util/math.js';
 
 /** Max average polyomino size constant. @see lib/pack/pack.c:C */
@@ -29,33 +30,6 @@ export interface GInfo {
   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).
  *
@@ -167,7 +141,7 @@ export interface PlaceCtx {
 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;
+    if (cell !== undefined && ps.inPS({ x: cell.x + dx, y: cell.y + dy })) return true;
   }
   return false;
 }
@@ -175,12 +149,12 @@ export function hasCollision(cells: Point[], dx: number, dy: number, ps: PointSe
 /**
  * Mark all shifted cells as occupied in the point set.
  *
- * @see lib/pack/pack.c:fits (cell insertion loop)
+ * @see lib/pack/pack.c:fits (cell insertion loop; `addPS`)
  */
 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 });
+    if (cell !== undefined) ps.addPS(cell.x + dx, cell.y + dy);
   }
 }
 
@@ -268,7 +242,7 @@ export function polyRects(ng: number, bbs: Box[], pinfo: PackInfo): Point[] | nu
   // 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 ctx: PlaceCtx = { ps: new PointSet(), 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];

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

@@ -21,6 +21,7 @@ import { PackMode } from './types.js';
 import { cround } from '../../common/arith.js';
 import { d2i } from '../../util/math.js';
 import { gvQsort } from '../../util/bsd-qsort.js';
+import { PointSet } from '../../common/pointset.js';
 
 /** Max. avg. polyomino size. @see lib/pack/pack.c:C */
 const C_AVG = 100;
@@ -40,23 +41,6 @@ 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;
@@ -96,7 +80,7 @@ interface LineState {
 function lineXDominant(st: LineState, ps: PointSet): void {
   let d = st.ay - (st.ax >> 1);
   for (;;) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.x === st.x2) return;
     if (d >= 0) { st.y += st.sy; d -= st.ax; }
     st.x += st.sx;
@@ -108,7 +92,7 @@ function lineXDominant(st: LineState, ps: PointSet): void {
 function lineYDominant(st: LineState, ps: PointSet): void {
   let d = st.ax - (st.ay >> 1);
   for (;;) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.y === st.y2) return;
     if (d >= 0) { st.x += st.sx; d -= st.ay; }
     st.y += st.sy;
@@ -136,7 +120,7 @@ function fillLine(p: Point, q: Point, ps: PointSet): void {
 /** 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);
+    for (let y = LL.y; y <= UR.y; y++) ps.addPS(x, y);
   }
 }
 
@@ -208,7 +192,7 @@ function genBox(bb0: Box, ssize: number, margin: number, center: Point): GInfo {
   const UR = roundedCell({ x: center.x + bbW + margin, y: center.y + bbH + margin }, ssize);
   fillRect(LL, UR, ps);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     perim: grid(bb0.ur.x - bb0.ll.x + 2 * margin, ssize)
       + grid(bb0.ur.y - bb0.ll.y + 2 * margin, ssize),
     index: 0,
@@ -266,7 +250,7 @@ function genPoly(
   };
   for (const n of g.nodes.values()) coverNode(n, ctx);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     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,
@@ -289,7 +273,7 @@ interface PlaceCtx {
 
 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;
+    if (ctx.ps.isInPS(c.x + x, c.y + y)) return false;
   }
   const bb = ctx.bbs[info.index]!;
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
@@ -297,30 +281,44 @@ function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): boolean {
   // is widened to double (objdump of libgvc `_fits`). Matters only once
   // computeStep has saturated at INT_MAX.
   ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
-  for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
+  for (const c of info.cells) ctx.ps.addPS(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 cursor, shared by the legs of one ring as C shares its x and y. */
+interface Cursor {
+  x: number;
+  y: number;
+}
+
+/**
+ * One straight leg of a ring: step (dx, dy) from the cursor until the moving
+ * coordinate reaches `end`, trying each cell. Every leg starts on the
+ * `end` side's integer lattice with a unit step, so `!== end` stops where C's
+ * `<`/`>` bound does.
+ * @see pack.c:placeGraph (one of the five loops per ring)
+ */
+function leg(c: Cursor, dx: number, dy: number, end: number, info: GInfo, ctx: PlaceCtx): boolean {
+  for (; (dx !== 0 ? c.x : c.y) !== end; c.x += dx, c.y += dy) {
+    if (fits(c.x, c.y, info, ctx)) return true;
+  }
+  return false;
 }
 
-/** 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];
+/** Ring `bnd` for wide graphs (W >= H). @see pack.c:placeGraph */
+function ringWide(bnd: number, info: GInfo, ctx: PlaceCtx): boolean {
+  const c = { x: 0, y: -bnd };
+  return leg(c, 1, 0, bnd, info, ctx) || leg(c, 0, 1, bnd, info, ctx)
+    || leg(c, -1, 0, -bnd, info, ctx) || leg(c, 0, -1, -bnd, info, ctx)
+    || leg(c, 1, 0, 0, info, ctx);
+}
+
+/** Ring `bnd` for tall graphs (W < H). @see pack.c:placeGraph */
+function ringTall(bnd: number, info: GInfo, ctx: PlaceCtx): boolean {
+  const c = { x: -bnd, y: 0 };
+  return leg(c, 0, -1, -bnd, info, ctx) || leg(c, 1, 0, bnd, info, ctx)
+    || leg(c, 0, 1, bnd, info, ctx) || leg(c, -1, 0, -bnd, info, ctx)
+    || leg(c, 0, -1, 0, info, ctx);
 }
 
 /**
@@ -331,7 +329,7 @@ function* ringTall(bnd: number): Generator<[number, number]> {
  */
 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);
+  for (const c of info.cells) ctx.ps.addPS(c.x, c.y);
 }
 
 /**
@@ -349,10 +347,7 @@ function placeGraph(i: number, info: GInfo, ctx: PlaceCtx): void {
   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;
-    }
+    if (wide ? ringWide(bnd, info, ctx) : ringTall(bnd, info, ctx)) return;
   }
 }
 

package/src/pathplan/shortest.ts

@@ -250,9 +250,22 @@ class ShortestHelper {
     ShortestHelper.connectAll(tris);
     const ftrii = ShortestHelper.findTri(tris, eps[0]);
     const ltrii = ShortestHelper.findTri(tris, eps[1]);
-    if (ftrii === NO_TRI || ltrii === NO_TRI) return null;
+    // C finds the first triangle, fails if none, and only then looks for the
+    // last one (shortest.c:178-204), so the two messages are exclusive.
+    if (ftrii === NO_TRI) {
+      console.warn('source point not in any triangle');
+      return null;
+    }
+    if (ltrii === NO_TRI) {
+      console.warn('destination point not in any triangle');
+      return null;
+    }
     if (ftrii === ltrii) return [eps[0], eps[1]];
-    if (!ShortestHelper.markPath(tris, ftrii, ltrii)) return [eps[0], eps[1]];
+    if (!ShortestHelper.markPath(tris, ftrii, ltrii)) {
+      console.warn('cannot find triangle path');
+      // C: a straight line is better than failing
+      return [eps[0], eps[1]];
+    }
     const epnls: [PNL, PNL] = [{ pp: eps[0], link: null }, { pp: eps[1], link: null }];
     const dq = ShortestHelper.initDeque(pnlps.length);
     ShortestHelper.add2dq(dq, DQ_FRONT, epnls[0]);