@knowvah/dot-engine 1.9.0 → 2.0.0

package/src/layout/neato/constraint-adjust.ts

@@ -0,0 +1,466 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Orthogonal-ordering overlap removal — cAdjust (overlap=ortho*, portho*).
+ *
+ * Builds horizontal/vertical constraint graphs over the node boxes and solves
+ * them with network simplex (a linear objective, so `rank` is reused). Based
+ * on Marriott, Stuckey, Tam and He, "Removing Node Overlapping in Graph Layout
+ * Using Constrained Optimization", Constraints 8(2):143-172, 2003 (per the C
+ * source comment). All geometry is integer points scaled by SCALE (10).
+ *
+ * Deviations from C, all structural (results identical):
+ *  - the visibility graph `vg` of mkConstraintG is a per-item adjacency array
+ *    (C builds a strict cgraph whose out-edge order — by head sequence — equals
+ *    the ascending list order used here);
+ *  - cAdjust's `switch` is a mode -> plan table (same eight cases plus the
+ *    PORTHO default);
+ *  - constrainX/constrainY share `buildConstraintGraph` for the ortho choice.
+ *
+ * @see lib/neatogen/constraint.c:cAdjust
+ */
+
+import { Graph } from '../../model/graph.js';
+import { Node } from '../../model/node.js';
+import { Edge } from '../../model/edge.js';
+import type { EdgeList } from '../../model/nodeInfo.js';
+import { DtBag } from '../../cdt/index.js';
+import { cround } from '../../common/arith.js';
+import { rank } from '../dot/ns.js';
+import { elistAppend } from '../dot/fastgr.js';
+import { nodesInSeq } from '../dot/decomp.js';
+import { sepFactor } from './sep-factor.js';
+import type { ExpandT } from './sep-factor.js';
+
+/** @see lib/neatogen/adjust.h:adjust_mode */
+export const AM_ORTHO = 5;
+export const AM_ORTHO_YX = 6;
+export const AM_ORTHOXY = 7;
+export const AM_ORTHOYX = 8;
+export const AM_PORTHO = 9;
+export const AM_PORTHO_YX = 10;
+export const AM_PORTHOXY = 11;
+export const AM_PORTHOYX = 12;
+
+/** For precision, scale up before the algorithms, then scale down. */
+const SCALE = 10;
+const SCALE2 = SCALE / 2;
+/** C `INT_MAX` (rank's maxiter) and `-INT_MAX` (mkConstraintG's sentinel). */
+const INT_MAX = 2147483647;
+/** @see lib/common/geom.h:POINTS_PER_INCH */
+const POINTS_PER_INCH = 72;
+
+interface Pt { x: number; y: number }
+interface Box { llx: number; lly: number; urx: number; ury: number }
+
+/** @see lib/neatogen/constraint.c:nitem */
+interface Nitem {
+  /** Sort key (the dtdisc key, `offsetof(nitem, val)`). */
+  val: number;
+  /** Position for sorting (integer scaled points). */
+  pos: Pt;
+  /** Base node. */
+  np: Node;
+  /** Corresponding node in the constraint graph. */
+  cnode: Node | undefined;
+  bb: Box;
+}
+
+type DistFn = (b1: Box, b2: Box) => number;
+type IntersectFn = (p: Nitem, q: Nitem) => boolean;
+type Items = DtBag<Nitem, number>;
+
+/** Constraint graph plus the strict-graph edge index (agedge find/create). */
+interface ConstraintGraph {
+  g: Graph;
+  edges: Map<Node, Map<Node, Edge>>;
+}
+
+/** @see lib/neatogen/constraint.c:cmpitem */
+function cmpitem(a: number, b: number): number {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+/** C int division truncates toward zero. */
+function idiv2(v: number): number {
+  return Math.trunc(v / 2);
+}
+
+/** @see lib/neatogen/constraint.c:distY */
+function distY(b1: Box, b2: Box): number {
+  return idiv2(b1.ury - b1.lly + (b2.ury - b2.lly));
+}
+
+/** @see lib/neatogen/constraint.c:distX */
+function distX(b1: Box, b2: Box): number {
+  return idiv2(b1.urx - b1.llx + (b2.urx - b2.llx));
+}
+
+/**
+ * True if boxes could overlap if shifted in y but don't, or if they overlap and
+ * a y move is smallest. Assumes q pos above p pos.
+ * @see lib/neatogen/constraint.c:intersectX0
+ */
+function intersectX0(p: Nitem, q: Nitem): boolean {
+  if (!(p.bb.llx <= q.bb.urx && q.bb.llx <= p.bb.urx)) return false;
+  if (p.bb.ury < q.bb.lly) return true;
+  const ydelta = distY(p.bb, q.bb) - (q.pos.y - p.pos.y);
+  const dx = q.pos.x >= p.pos.x ? q.pos.x - p.pos.x : p.pos.x - q.pos.x;
+  const xdelta = distX(p.bb, q.bb) - dx;
+  return ydelta <= xdelta;
+}
+
+/**
+ * True if boxes could overlap if shifted in x but don't, or if they overlap and
+ * an x move is smallest. Assumes q pos right of p pos.
+ * @see lib/neatogen/constraint.c:intersectY0
+ */
+function intersectY0(p: Nitem, q: Nitem): boolean {
+  if (!(p.bb.lly <= q.bb.ury && q.bb.lly <= p.bb.ury)) return false;
+  if (p.bb.urx < q.bb.llx) return true;
+  const xdelta = distX(p.bb, q.bb) - (q.pos.x - p.pos.x);
+  const dy = q.pos.y >= p.pos.y ? q.pos.y - p.pos.y : p.pos.y - q.pos.y;
+  const ydelta = distY(p.bb, q.bb) - dy;
+  return xdelta <= ydelta;
+}
+
+/** @see lib/neatogen/constraint.c:intersectY */
+function intersectY(p: Nitem, q: Nitem): boolean {
+  return p.bb.lly <= q.bb.ury && q.bb.lly <= p.bb.ury;
+}
+
+/** @see lib/neatogen/constraint.c:intersectX */
+function intersectX(p: Nitem, q: Nitem): boolean {
+  return p.bb.llx <= q.bb.urx && q.bb.llx <= p.bb.urx;
+}
+
+/** dtflatten order: ascending key, bag-internal order among equal keys. */
+function flatten(list: Items): Nitem[] {
+  const out: Nitem[] = [];
+  for (let p = list.first(); p !== undefined; p = list.next(p)) out.push(p);
+  return out;
+}
+
+function newCg(): ConstraintGraph {
+  return { g: new Graph('cg', 'strict-directed'), edges: new Map() };
+}
+
+/** agnode + agbindrec + alloc_elist for a constraint-graph node. */
+function newCgNode(cg: ConstraintGraph, name: string): Node {
+  const n = new Node(cg.g.nodes.size, name, cg.g);
+  cg.g.nodes.set(name, n);
+  n.info.in = { list: [], size: 0 };
+  n.info.out = { list: [], size: 0 };
+  return n;
+}
+
+/** Append n to GD_nlist(cg). */
+function linkNode(cg: ConstraintGraph, last: Node | undefined, n: Node): Node {
+  if (last === undefined) cg.g.info.nlist = n;
+  else last.info.next = n;
+  return n;
+}
+
+/** agedge(cg, t, h, NULL, 1): strict, returns the existing edge if any. */
+function cgEdge(cg: ConstraintGraph, t: Node, h: Node): Edge {
+  let heads = cg.edges.get(t);
+  if (heads === undefined) {
+    heads = new Map();
+    cg.edges.set(t, heads);
+  }
+  let e = heads.get(h);
+  if (e === undefined) {
+    e = new Edge(t, h, '');
+    e.info.minlen = 0;
+    heads.set(h, e);
+  }
+  return e;
+}
+
+function listOf(l: EdgeList | undefined): EdgeList {
+  if (l === undefined) throw new Error('constraint graph node has no edge list');
+  return l;
+}
+
+/** elist_append(e, ND_out(t)); elist_append(e, ND_in(h)). */
+function linkEdge(e: Edge): void {
+  elistAppend(listOf(e.tail.info.out), e);
+  elistAppend(listOf(e.head.info.in), e);
+}
+
+function cnodeOf(p: Nitem): Node {
+  if (p.cnode === undefined) throw new Error('nitem has no constraint node');
+  return p.cnode;
+}
+
+/**
+ * agfindedge(g, a, b): an a->b edge, or b->a when g is undirected.
+ * @see lib/cgraph/edge.c:agedge
+ */
+function makeHasEdge(g: Graph): (a: Node, b: Node) => boolean {
+  const undirected = g.root.kind === 'undirected' || g.root.kind === 'strict-undirected';
+  const pairs = new Map<Node, Set<Node>>();
+  for (const e of g.edges) {
+    const s = pairs.get(e.tail) ?? new Set<Node>();
+    s.add(e.head);
+    pairs.set(e.tail, s);
+  }
+  return (a, b) => pairs.get(a)?.has(b) === true || (undirected && pairs.get(b)?.has(a) === true);
+}
+
+/**
+ * For every item pair, add a constraint when `intersect` holds; no orthogonal
+ * ordering is enforced. Edges that exist in `g` get weight 100.
+ * @see lib/neatogen/constraint.c:mkNConstraintG
+ */
+function mkNConstraintG(g: Graph, list: Items, intersect: IntersectFn, dist: DistFn): ConstraintGraph {
+  const cg = newCg();
+  const flat = flatten(list);
+  let lastn: Node | undefined;
+  for (const p of flat) {
+    const n = newCgNode(cg, p.np.name);
+    p.cnode = n;
+    lastn = linkNode(cg, lastn, n);
+  }
+  const hasEdge = makeHasEdge(g);
+  const created: Edge[] = [];
+  for (let i = 0; i < flat.length; i++) {
+    const p = flat[i]!;
+    for (let j = i + 1; j < flat.length; j++) {
+      const nxp = flat[j]!;
+      if (!intersect(p, nxp)) continue;
+      const e = cgEdge(cg, cnodeOf(p), cnodeOf(nxp));
+      e.info.minlen = dist(p.bb, nxp.bb);
+      e.info.weight = hasEdge(p.np, nxp.np) ? 100 : 1;
+      created.push(e);
+    }
+  }
+  // C walks each node's cgraph out-edges (by head sequence); creation order
+  // above is already tail-major and head-ascending, which is that order.
+  for (const e of created) linkEdge(e);
+  return cg;
+}
+
+/**
+ * Chain one node per distinct val, in order, joined by SCALE-length edges.
+ * @see lib/neatogen/constraint.c:mkConstraintG (basic chain)
+ */
+function buildChain(cg: ConstraintGraph, flat: Nitem[]): void {
+  let oldval = -INT_MAX;
+  let prev: Node | undefined;
+  let n: Node | undefined;
+  let lastn: Node | undefined;
+  for (const p of flat) {
+    if (oldval !== p.val) {
+      oldval = p.val;
+      n = newCgNode(cg, p.np.name);
+      lastn = linkNode(cg, lastn, n);
+      if (prev !== undefined) {
+        const e = cgEdge(cg, prev, n);
+        e.info.minlen = SCALE;
+        e.info.weight = 1;
+        linkEdge(e);
+      }
+      prev = n;
+    }
+    p.cnode = n;
+  }
+}
+
+/**
+ * Visibility graph as per-item adjacency (head indices ascending).
+ * @see lib/neatogen/constraint.c:mkConstraintG (immediate right neighbours)
+ */
+function buildVisibility(flat: Nitem[], intersect: IntersectFn): number[][] {
+  const vg: number[][] = flat.map(() => []);
+  let oldval = -INT_MAX;
+  let nxt = flat.length;
+  for (let i = 0; i < flat.length; i++) {
+    const p = flat[i]!;
+    if (oldval !== p.val) {
+      oldval = p.val;
+      nxt = i + 1;
+      while (nxt < flat.length && flat[nxt]!.val === oldval) nxt++;
+      if (nxt >= flat.length) break;
+    }
+    for (let j = nxt; j < flat.length; j++) {
+      if (intersect(p, flat[j]!)) vg[i]!.push(j);
+    }
+  }
+  return vg;
+}
+
+/**
+ * Add a constraint edge per visibility edge, with minlen = dist.
+ * @see lib/neatogen/constraint.c:mapGraphs
+ */
+function mapGraphs(vg: number[][], flat: Nitem[], cg: ConstraintGraph, dist: DistFn): void {
+  for (let i = 0; i < flat.length; i++) {
+    const tp = flat[i]!;
+    for (const j of vg[i]!) {
+      const hp = flat[j]!;
+      const delta = dist(tp.bb, hp.bb);
+      const ce = cgEdge(cg, cnodeOf(tp), cnodeOf(hp));
+      ce.info.weight = 1;
+      if ((ce.info.minlen ?? 0) < delta) {
+        if (ce.info.minlen === 0) linkEdge(ce);
+        ce.info.minlen = delta;
+      }
+    }
+  }
+}
+
+/** @see lib/neatogen/constraint.c:mkConstraintG */
+function mkConstraintG(list: Items, intersect: IntersectFn, dist: DistFn): ConstraintGraph {
+  const cg = newCg();
+  const flat = flatten(list);
+  buildChain(cg, flat);
+  mapGraphs(buildVisibility(flat, intersect), flat, cg, dist);
+  return cg;
+}
+
+function buildConstraintGraph(
+  g: Graph, list: Items, ifn: IntersectFn, dist: DistFn, ortho: boolean,
+): ConstraintGraph {
+  return ortho ? mkConstraintG(list, ifn, dist) : mkNConstraintG(g, list, ifn, dist);
+}
+
+function newItems(): Items {
+  return new DtBag<Nitem, number>((p) => p.val, cmpitem);
+}
+
+/**
+ * Create the X constraints and solve (linear objective, so network simplex).
+ * @see lib/neatogen/constraint.c:constrainX
+ */
+function constrainX(g: Graph, nlist: Nitem[], ifn: IntersectFn, ortho: boolean): void {
+  const list = newItems();
+  for (const p of nlist) {
+    p.val = p.pos.x;
+    list.insert(p);
+  }
+  const cg = buildConstraintGraph(g, list, ifn, distX, ortho);
+  rank(cg.g, 2, INT_MAX);
+  for (const p of nlist) {
+    const newpos = cnodeOf(p).info.rank ?? 0;
+    const delta = newpos - p.pos.x;
+    p.pos.x = newpos;
+    p.bb.llx += delta;
+    p.bb.urx += delta;
+  }
+}
+
+/**
+ * See constrainX.
+ * @see lib/neatogen/constraint.c:constrainY
+ */
+function constrainY(g: Graph, nlist: Nitem[], ifn: IntersectFn, ortho: boolean): void {
+  const list = newItems();
+  for (const p of nlist) {
+    p.val = p.pos.y;
+    list.insert(p);
+  }
+  const cg = buildConstraintGraph(g, list, ifn, distY, ortho);
+  rank(cg.g, 2, INT_MAX);
+  for (const p of nlist) {
+    const newpos = cnodeOf(p).info.rank ?? 0;
+    const delta = newpos - p.pos.y;
+    p.pos.y = newpos;
+    p.bb.lly += delta;
+    p.bb.ury += delta;
+  }
+}
+
+/** @see lib/neatogen/constraint.c:overlaps (geom.h OVERLAP) */
+function overlaps(p: Nitem[]): boolean {
+  for (let i = 0; i < p.length - 1; i++) {
+    const a = p[i]!.bb;
+    for (let j = i + 1; j < p.length; j++) {
+      const b = p[j]!.bb;
+      if (a.urx >= b.llx && b.urx >= a.llx && a.ury >= b.lly && b.ury >= a.lly) return true;
+    }
+  }
+  return false;
+}
+
+/** @see lib/neatogen/constraint.c:initItem */
+function initItem(n: Node, margin: ExpandT): Nitem {
+  const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH);
+  const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH);
+  const width = n.info.width ?? 0;
+  const height = n.info.height ?? 0;
+  let w2: number;
+  let h2: number;
+  if (margin.doAdd) {
+    w2 = Math.trunc(SCALE * (cround((width / 2.0) * POINTS_PER_INCH) + margin.x));
+    h2 = Math.trunc(SCALE * (cround((height / 2.0) * POINTS_PER_INCH) + margin.y));
+  } else {
+    w2 = cround(margin.x * SCALE2 * width * POINTS_PER_INCH);
+    h2 = cround(margin.y * SCALE2 * height * POINTS_PER_INCH);
+  }
+  return {
+    val: 0,
+    pos: { x, y },
+    np: n,
+    cnode: undefined,
+    bb: { llx: x - w2, lly: y - h2, urx: x + w2, ury: y + h2 },
+  };
+}
+
+/** One cAdjust mode: which axis goes first, the first pass's test, and ortho. */
+interface Plan {
+  xFirst: boolean;
+  firstTest: IntersectFn;
+  ortho: boolean;
+}
+
+/** @see lib/neatogen/constraint.c:cAdjust (switch) */
+const PLANS: ReadonlyMap<number, Plan> = new Map([
+  [AM_ORTHOXY, { xFirst: true, firstTest: intersectY, ortho: true }],
+  [AM_ORTHOYX, { xFirst: false, firstTest: intersectX, ortho: true }],
+  [AM_ORTHO, { xFirst: true, firstTest: intersectY0, ortho: true }],
+  [AM_ORTHO_YX, { xFirst: false, firstTest: intersectX0, ortho: true }],
+  [AM_PORTHOXY, { xFirst: true, firstTest: intersectY, ortho: false }],
+  [AM_PORTHOYX, { xFirst: false, firstTest: intersectX, ortho: false }],
+  [AM_PORTHO_YX, { xFirst: false, firstTest: intersectX0, ortho: false }],
+  [AM_PORTHO, { xFirst: true, firstTest: intersectY0, ortho: false }],
+]);
+
+function runPlan(g: Graph, nlist: Nitem[], plan: Plan): void {
+  if (plan.xFirst) {
+    constrainX(g, nlist, plan.firstTest, plan.ortho);
+    constrainY(g, nlist, intersectX, plan.ortho);
+  } else {
+    constrainY(g, nlist, plan.firstTest, plan.ortho);
+    constrainX(g, nlist, intersectY, plan.ortho);
+  }
+}
+
+/**
+ * Remove node overlaps with orthogonal-ordering constraints. mode is one of
+ * the eight AM_ORTHO and AM_PORTHO values (else AM_PORTHO). Returns 1
+ * if nodes were moved, 0 if no boxes overlapped.
+ *
+ * ND_pos is in inches; positions are rounded to integer points (x SCALE) while
+ * solving, then written back.
+ * @see lib/neatogen/constraint.c:cAdjust
+ */
+export function cAdjust(g: Graph, mode: number): number {
+  const margin = sepFactor(g);
+  const nlist = nodesInSeq(g).map((n) => initItem(n, margin));
+  if (!overlaps(nlist)) return 0;
+  runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO)!);
+  for (const p of nlist) {
+    const x = p.pos.x / POINTS_PER_INCH / SCALE;
+    const y = p.pos.y / POINTS_PER_INCH / SCALE;
+    if (p.np.info.pos) {
+      p.np.info.pos[0] = x;
+      p.np.info.pos[1] = y;
+    } else {
+      p.np.info.pos = [x, y];
+    }
+  }
+  return 1;
+}

package/src/layout/neato/edge-len.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Edge lengths: scan_graph_mode's MODE_KK and MODE_SGD branches call
+ * setEdgeLen on every node, storing `len` (default 1.0) in ED_dist.
+ *
+ * @see lib/neatogen/stuff.c:setEdgeLen
+ * @see lib/neatogen/stuff.c:lenattr
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+
+/** `dfltlen` passed by scan_graph_mode. @see lib/neatogen/stuff.c:scan_graph_mode */
+export const DEFAULT_EDGE_LEN = 1.0;
+
+/**
+ * The edge's `len`, or the default when it is absent or empty; a value that
+ * does not parse as a positive number warns and falls back to the default.
+ * @see lib/neatogen/stuff.c:lenattr
+ */
+export function lenattr(ep: Edge, g: Graph): number {
+  const s = ep.attrs.get('len');
+  if (s === undefined || s === '') return DEFAULT_EDGE_LEN;
+  const val = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(s);
+  const len = val === null ? Number.NaN : parseFloat(val[0]);
+  if (Number.isNaN(len) || len < 0 || len === 0) {
+    console.warn(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+    return DEFAULT_EDGE_LEN;
+  }
+  return len;
+}
+
+/** Store every edge's length in `info.dist` (ED_dist). @see lib/neatogen/stuff.c:setEdgeLen */
+export function setEdgeLen(g: Graph): void {
+  for (const ep of g.edges) ep.info.dist = lenattr(ep, g);
+}

package/src/layout/neato/fdp-adjust.ts

@@ -17,9 +17,13 @@ import {
   MATRIX_TYPE_REAL,
 } from '../sfdp/sparse-matrix.js';
 import { removeOverlapPrism } from './overlap-prism.js';
-import { adjustNodesScale } from './sc-adjust.js';
+import { scAdjust } from './sc-adjust.js';
+import { AM_ORTHO, AM_ORTHO_YX, AM_ORTHOXY, AM_ORTHOYX, AM_PORTHO, AM_PORTHO_YX, AM_PORTHOXY, AM_PORTHOYX, cAdjust } from './constraint-adjust.js';
+import { countOverlapIn, sAdjustGraph } from './adjust-info.js';
+import { vpscAdjust } from './vpsc-adjust.js';
 import { sepFactor } from './sep-factor.js';
 import { lateDouble } from '../../common/nodeinit.js';
+import { RenderError } from '../../errors.js';
 
 /** @see lib/neatogen/adjust.c:DFLT_MARGIN (points) */
 const DFLT_MARGIN = 4;
@@ -106,19 +110,120 @@ export function fdpAdjust(g: Graph, ntry: number): void {
   }
 }
 
+/** Adjust modes, in C's enum order (modes above AM_SCALE take the early switch).
+ * @see lib/neatogen/adjust.h:AM_NONE */
+export const AM_NONE = 0;
+export const AM_VOR = 1;
+export const AM_SCALE = 2;
+export const AM_NSCALE = 3;
+export const AM_SCALEXY = 4;
+export const AM_COMPRESS = 13;
+export const AM_VPSC = 14;
+export const AM_IPSEP = 15;
+export const AM_PRISM = 16;
+
+/** @see lib/neatogen/adjust.h:adjust_data (mode, print, value) */
+export interface AdjustData {
+  mode: number;
+  print: string;
+  value: number;
+}
+
+/** `overlap` value (lowercase) to mode and print string.
+ * @see lib/neatogen/adjust.c:adjustMode */
+const ADJUST_MODES = new Map<string, readonly [number, string]>([
+  ['voronoi', [AM_VOR, 'Voronoi']],
+  ['scale', [AM_NSCALE, 'scaling']],
+  ['compress', [AM_COMPRESS, 'compress']],
+  ['vpsc', [AM_VPSC, 'vpsc']],
+  ['ipsep', [AM_IPSEP, 'ipsep']],
+  ['oscale', [AM_SCALE, 'old scaling']],
+  ['scalexy', [AM_SCALEXY, 'x and y scaling']],
+  ['ortho', [AM_ORTHO, 'orthogonal constraints']],
+  ['ortho_yx', [AM_ORTHO_YX, 'orthogonal constraints']],
+  ['orthoxy', [AM_ORTHOXY, 'xy orthogonal constraints']],
+  ['orthoyx', [AM_ORTHOYX, 'yx orthogonal constraints']],
+  ['portho', [AM_PORTHO, 'pseudo-orthogonal constraints']],
+  ['portho_yx', [AM_PORTHO_YX, 'pseudo-orthogonal constraints']],
+  ['porthoxy', [AM_PORTHOXY, 'xy pseudo-orthogonal constraints']],
+  ['porthoyx', [AM_PORTHOYX, 'yx pseudo-orthogonal constraints']],
+]);
+
 /**
- * Full adjustNodes: scale-family via scAdjust, PRISM via fdpAdjust,
- * everything else a no-op (AM_NONE, or a mode with no divergent corpus
- * coverage — see sc-adjust module doc).
- * @see lib/neatogen/adjust.c:adjustNodes / removeOverlapWith
+ * Resolve an `overlap` value to its adjust mode (the PRISM try count lands in
+ * `value`).
+ * @see lib/neatogen/adjust.c:getAdjustMode
  */
-export function adjustNodesFull(g: Graph): number {
-  const flag = g.attrs.get('overlap') ?? g.root.attrs.get('overlap');
+export function getAdjustMode(flag: string | undefined): AdjustData {
   const ntry = overlapPrismTries(flag);
-  // C removeOverlapWith: fewer than 2 nodes short-circuits every mode.
-  if (ntry !== null && g.nodes.size >= 2) {
-    fdpAdjust(g, ntry);
-    return 1;
+  if (ntry !== null) return { mode: AM_PRISM, print: 'prism', value: ntry };
+  const named = ADJUST_MODES.get((flag ?? '').toLowerCase());
+  if (named !== undefined) return { mode: named[0], print: named[1], value: 0 };
+  return { mode: AM_NONE, print: 'none', value: 0 };
+}
+
+/** Modes handled by cAdjust. @see lib/neatogen/adjust.c:removeOverlapWith */
+function isConstraintMode(mode: number): boolean {
+  return mode >= AM_ORTHO && mode <= AM_PORTHOYX;
+}
+
+/**
+ * The `am->mode > AM_SCALE` switch of removeOverlapWith. Under IPSEPCOLA (on in
+ * the reference build) ipsep is handled during layout; anything else warns.
+ * @see lib/neatogen/adjust.c:removeOverlapWith
+ */
+function adjustLate(g: Graph, am: AdjustData): number {
+  if (isConstraintMode(am.mode)) {
+    cAdjust(g, am.mode);
+    return 0;
+  }
+  switch (am.mode) {
+    case AM_NSCALE: return scAdjust(g, 1);
+    case AM_SCALEXY: return scAdjust(g, 0);
+    case AM_COMPRESS: return scAdjust(g, -1);
+    case AM_PRISM:
+      fdpAdjust(g, am.value);
+      return 0;
+    case AM_IPSEP: return 0;
+    case AM_VPSC: return vpscAdjust(g);
+    default:
+      console.warn(`Unhandled adjust option ${am.print}`);
+      return 0;
   }
-  return adjustNodesScale(g);
+}
+
+/**
+ * AM_VOR (`overlap=voronoi`) is vAdjust: it returns 0 when countOverlap finds
+ * nothing, otherwise runs the Voronoi adjuster, which is not ported (loud).
+ * @see lib/neatogen/adjust.c:vAdjust
+ */
+function adjustVoronoi(g: Graph, am: AdjustData): number {
+  if (countOverlapIn(g) === 0) return 0;
+  throw new RenderError(
+    `overlap=${(g.attrs.get('overlap') ?? g.root.attrs.get('overlap')) ?? am.print}: ` +
+      'Voronoi overlap removal is not supported yet',
+    'UNSUPPORTED_FEATURE',
+  );
+}
+
+/**
+ * Use `am` to decide if and how to remove node overlaps. normalize and
+ * simpleScale (only active with the `normalize`/`scale` attributes) are not
+ * ported (see sc-adjust module doc).
+ * @see lib/neatogen/adjust.c:removeOverlapWith
+ */
+export function removeOverlapWith(g: Graph, am: AdjustData): number {
+  if (g.nodes.size < 2) return 0;
+  if (am.mode === AM_NONE) return 0;
+  if (am.mode > AM_SCALE) return adjustLate(g, am);
+  return am.mode === AM_SCALE ? sAdjustGraph(g) : adjustVoronoi(g, am);
+}
+
+/**
+ * Remove node overlap relying on the graph's `overlap` attribute.
+ * @see lib/neatogen/adjust.c:adjustNodes / removeOverlapAs
+ */
+export function adjustNodesFull(g: Graph): number {
+  const flag = g.attrs.get('overlap') ?? g.root.attrs.get('overlap');
+  return removeOverlapWith(g, getAdjustMode(flag));
 }