@knowvah/dot-engine 1.9.0 → 2.0.1

package/src/layout/neato/sgd.ts

@@ -8,10 +8,15 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
 import type { TermSgd } from './dijkstra.js';
-import { dijkstraSgd } from './dijkstra.js';
+import { dijkstraSgd } from './sgd-dijkstra.js';
+import { setEdgeLen } from './edge-len.js';
 import { rkNewState, rkSeed, rkInterval } from '../../util/mt19937.js';
 import type { RkState } from '../../util/mt19937.js';
+import { drand48 } from '../../common/random.js';
+import { lateDouble } from '../../common/nodeinit.js';
+import { checkStart, parseStart, INIT_RANDOM, INIT_REGULAR } from './start.js';
 
 // ---------------------------------------------------------------------------
 // Model constants — @see lib/neatogen/defs.h
@@ -26,11 +31,14 @@ export const MODEL_SUBSET = 2;
 /** MDS distance model (falls back to MODEL_SHORTPATH). */
 export const MODEL_MDS = 3;
 
-/** Default tolerance (Epsilon in neato). @see lib/neatogen/sgd.c */
-const DFLT_TOLERANCE = 1e-4;
+/** Epsilon under MODE_SGD: a minimum step size, not the 1e-4 energy tolerance. @see lib/neatogen/stuff.c:scan_graph_mode */
+const SGD_EPSILON = 0.01;
 
-/** Default maximum number of SGD iterations. @see lib/neatogen/neato.h */
-const MAX_ITER = 30;
+/** MaxIter when `maxiter` is unset under MODE_SGD. @see lib/neatogen/neatoinit.c:1288 */
+const SGD_DFLT_ITERATIONS = 30;
+
+/** C's rk_seed(0, &rstate) in sgd(): the shuffle seed is fixed. @see lib/neatogen/sgd.c:215 */
+const SHUFFLE_SEED = 0;
 
 // ---------------------------------------------------------------------------
 // GraphSgd — CSR sparse-graph for Dijkstra
@@ -78,27 +86,31 @@ export function assignNodeIds(g: Graph): { nNodes: number; nEdges: number } {
 }
 
 /**
- * Append CSR entries for all non-self-loop edges incident on node `np`.
+ * Append CSR entries for all non-self-loop edges incident on node `np`
+ * (out-edges first, then in-edges, as agfstedge/agnxtedge).
  * Returns the number of edges appended.
  * @internal
  */
 export function fillNodeEdges(
-  np: import('../../model/node.js').Node,
+  np: Node,
   g: Graph,
   graph: GraphSgd,
   edgeOffset: number,
 ): number {
   let nEdges = edgeOffset;
-  for (const ep of g.edges) {
-    if (ep.tail === np && ep.head !== np) {
-      graph.targets[nEdges] = ep.head.info.id ?? 0;
-      graph.weights[nEdges] = ep.info.dist ?? 1;
-      nEdges++;
-    } else if (ep.head === np && ep.tail !== np) {
-      graph.targets[nEdges] = ep.tail.info.id ?? 0;
-      graph.weights[nEdges] = ep.info.dist ?? 1;
-      nEdges++;
-    }
+  // agfstedge/agnxtedge: every out-edge, then every in-edge, each dict ordered
+  // by (other endpoint's seq, edge seq). The order is load-bearing: dijkstra
+  // tie-breaking sets the term order that the shuffle then permutes.
+  // ND_id is assigned and setEdgeLen sets ED_dist on every edge before
+  // extractAdjacency runs (sgd() below), so both are defined here.
+  for (const ep of np.outEdges(g)) {
+    if (ep.head === np) continue;
+    graph.targets[nEdges] = ep.head.info.id!;
+    graph.weights[nEdges++] = ep.info.dist!;
+  }
+  for (const ep of np.inEdges(g)) {
+    graph.targets[nEdges] = ep.tail.info.id!;
+    graph.weights[nEdges++] = ep.info.dist!;
   }
   return nEdges;
 }
@@ -252,21 +264,25 @@ export function fisheryatesShuffle(terms: TermSgd[], state: RkState): void {
 // Initial positions
 // ---------------------------------------------------------------------------
 
+/** C hasPos: ND_pinned > 0 (P_SET from `pos=`, or P_PIN). @see lib/neatogen/stress.c:hasPos */
+function hasPos(np: Node): boolean {
+  return np.info.posSet === true || np.info.pinned === true;
+}
+
 /**
- * Assign random initial positions to unpinned nodes with no position set.
- * Uses MT19937 for deterministic, seed-controlled output.
+ * Seed drand48 from `start` (checkStart) and give every node without a
+ * position a random one. start=regular keeps the regular placement that
+ * solveModel already made (checkStart's INIT_REGULAR early return).
  *
  * @see lib/neatogen/stuff.c:initial_positions
  * @see lib/neatogen/stuff.c:randompos
  */
-export function initialPositions(g: Graph, state: RkState): void {
-  for (const [, np] of g.nodes) {
-    if (np.info.pinned === true) continue;
-    if (np.info.pos != null) continue;
-    np.info.pos = [
-      rkInterval(0xffff, state) / 0x10000,
-      rkInterval(0xffff, state) / 0x10000,
-    ];
+export function initialPositions(g: Graph, nG: number = g.nodes.size): void {
+  if (parseStart(g.root.attrs.get('start'), INIT_RANDOM).init === INIT_REGULAR) return;
+  checkStart(g, nG, INIT_RANDOM);
+  for (const np of g.nodes.values()) {
+    if (hasPos(np)) continue;
+    np.info.pos = [drand48(), drand48()];
   }
 }
 
@@ -277,7 +293,7 @@ export function initialPositions(g: Graph, state: RkState): void {
 /**
  * Compute the annealing schedule parameters from the term weights.
  *
- * eta_max = 1/w_min; eta_min = DFLT_TOLERANCE/w_max
+ * eta_max = 1/w_min; eta_min = Epsilon/w_max
  * lambda  = log(eta_max/eta_min) / (maxIter - 1)
  *
  * @see lib/neatogen/sgd.c:sgd (initialise annealing schedule)
@@ -285,6 +301,7 @@ export function initialPositions(g: Graph, state: RkState): void {
 export function computeSchedule(
   terms: TermSgd[],
   maxIter: number,
+  epsilon: number = SGD_EPSILON,
 ): { etaMax: number; lambda: number } {
   let wMin = terms[0].w;
   let wMax = terms[0].w;
@@ -293,7 +310,7 @@ export function computeSchedule(
     if (terms[ij].w > wMax) wMax = terms[ij].w;
   }
   const etaMax = 1 / wMin;
-  const etaMin = DFLT_TOLERANCE / wMax;
+  const etaMin = epsilon / wMax;
   const lambda = Math.log(etaMax / etaMin) / (maxIter - 1);
   return { etaMax, lambda };
 }
@@ -404,15 +421,15 @@ export function resolveModel(model: number): number {
   return model;
 }
 
-/** Optimisation loop: shuffle and step for MAX_ITER iterations. @see lib/neatogen/sgd.c:sgd */
+/** Optimisation loop: shuffle and step for `sched.maxIter` iterations. @see lib/neatogen/sgd.c:sgd */
 export function runSgdLoop(
   pos: Float64Array,
   terms: TermSgd[],
   unfixed: boolean[],
-  sched: { etaMax: number; lambda: number },
+  sched: { etaMax: number; lambda: number; maxIter: number },
   state: RkState,
 ): void {
-  for (let t = 0; t < MAX_ITER; t++) {
+  for (let t = 0; t < sched.maxIter; t++) {
     fisheryatesShuffle(terms, state);
     const eta = sched.etaMax * Math.exp(-sched.lambda * t);
     sgdIteration(pos, terms, unfixed, eta);
@@ -431,7 +448,8 @@ export function runSgdLoop(
  *
  * Node positions are written to `node.info.pos` ([x, y]).
  * Nodes with `node.info.pinned === true` are not moved.
- * `g.info.seed` controls the MT19937 seed (default 0).
+ * The shuffle RNG is seeded with 0 as in C; `start` seeds only the initial
+ * positions (drand48, via checkStart).
  *
  * @see lib/neatogen/sgd.c:sgd
  */
@@ -440,22 +458,27 @@ export function sgdLayout(g: Graph, model: number): void {
   const n = g.nodes.size;
   if (n === 0) return;
 
-  const state = rkNewState();
-  rkSeed(g.info.seed ?? 0, state);
-
   let idx = 0;
   for (const [, node] of g.nodes) { node.info.id = idx++; }
 
-  initialPositions(g, state);
-
+  setEdgeLen(g);
   const graph = extractAdjacency(g, resolvedModel);
   const terms = sgdBuildTerms(graph);
   if (terms.length === 0) return;
 
-  const { etaMax, lambda } = computeSchedule(terms, MAX_ITER);
+  // C: MaxIter = atoi(maxiter) else 30; Epsilon = late_double(epsilon, 1e-4)
+  // @see lib/neatogen/neatoinit.c:1283-1288
+  const maxIterAttr = g.attrs.get('maxiter');
+  const maxIter = maxIterAttr !== undefined ? parseInt(maxIterAttr, 10) || 0 : SGD_DFLT_ITERATIONS;
+  const epsilon = lateDouble(g.attrs.get('epsilon'), SGD_EPSILON, 0);
+  const { etaMax, lambda } = computeSchedule(terms, maxIter, epsilon);
+
+  initialPositions(g, n);
   const pos = posToArray(g, n);
   const unfixed = buildUnfixed(g, n);
 
-  runSgdLoop(pos, terms, unfixed, { etaMax, lambda }, state);
+  const state = rkNewState();
+  rkSeed(SHUFFLE_SEED, state);
+  runSgdLoop(pos, terms, unfixed, { etaMax, lambda, maxIter }, state);
   posFromArray(g, pos);
 }

package/src/layout/neato/simple-scale.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * The `scale` graph attribute: multiply every node position by (sx, sy)
+ * before overlap removal. removeOverlapWith runs it right after normalize,
+ * whatever the overlap mode.
+ *
+ * @see lib/neatogen/adjust.c:simpleScale
+ */
+
+import type { Graph } from '../../model/graph.js';
+import { aggetGraph } from '../fdp/fdp-model.js';
+
+/** @see lib/neatogen/adjust.c:ISZERO */
+const ISZERO = (d: number): boolean => Math.abs(d) < 0.000000001;
+
+/** One C `%lf` conversion: optional leading whitespace, then a strtod number. */
+const LF = /^\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)/;
+
+/**
+ * C `sscanf(p, "%lf,%lf", &x, &y)`: the values converted, in order (0, 1 or
+ * 2 of them). An empty string returns none — C's EOF (-1) there reads an
+ * uninitialised pointf, undefined behaviour the port defines as a no-op.
+ */
+function scanPair(p: string): number[] {
+  const m1 = LF.exec(p);
+  if (m1 === null) return [];
+  const rest = p.slice(m1[0].length);
+  if (!rest.startsWith(',')) return [parseFloat(m1[1]!)];
+  const m2 = LF.exec(rest.slice(1));
+  return m2 === null ? [parseFloat(m1[1]!)] : [parseFloat(m1[1]!), parseFloat(m2[1]!)];
+}
+
+/**
+ * Scale node positions by the `scale` attribute ("s" or "sx,sy"). Returns 1
+ * if nodes moved, else 0 (unset, unparsable, a zero factor, or 1,1).
+ * @see lib/neatogen/adjust.c:simpleScale
+ */
+export function simpleScale(g: Graph): number {
+  const p = aggetGraph(g, 'scale');
+  if (p === undefined) return 0;
+  const sc = scanPair(p);
+  if (sc.length === 0) return 0;
+  const x = sc[0]!;
+  if (ISZERO(x)) return 0;
+  const y = sc.length === 1 ? x : sc[1]!;
+  if (ISZERO(y)) return 0;
+  if (y === 1 && x === 1) return 0;
+  for (const n of g.nodes.values()) {
+    n.info.pos![0] *= x;
+    n.info.pos![1] *= y;
+  }
+  return 1;
+}

package/src/layout/neato/start.ts

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Neato `start` handling (setSeed / initRegular / checkStart) and the
+ * fail-loud checks for the neato init features this port does not have
+ * (smart init, the subset/circuit distance models, hier/ipsep modes).
+ *
+ * Each loud check sits where neato's C branches into the unported code and
+ * fires only for the modes whose C path reaches it (ADR-3).
+ *
+ * @see lib/neatogen/neatoinit.c
+ */
+
+import { RenderError } from '../../errors.js';
+import type { Graph } from '../../model/graph.js';
+import { srand48 } from '../../common/random.js';
+import { mapbool, isACluster } from '../dot/rank.js';
+import { getPack } from '../pack/index.js';
+import {
+  MODE_KK, MODE_MAJOR, MODE_HIER, MODE_IPSEP, MODE_SGD,
+  MODEL_CIRCUIT, MODEL_SUBSET,
+} from './init.js';
+
+/** @see lib/neatogen/neato.h:INIT_SELF */
+export const INIT_SELF = 0;
+/** @see lib/neatogen/neato.h:INIT_REGULAR */
+export const INIT_REGULAR = 1;
+/** @see lib/neatogen/neato.h:INIT_RANDOM */
+export const INIT_RANDOM = 2;
+
+/** @see lib/common/const.h:Spring_coeff */
+const SPRING_COEFF = 1.0;
+
+/** `start` keyword prefixes. @see lib/neatogen/neatoinit.c:SMART,REGULAR,RANDOM */
+const START_KEYWORDS: readonly (readonly [string, number])[] = [
+  ['self', INIT_SELF],
+  ['regular', INIT_REGULAR],
+  ['random', INIT_RANDOM],
+];
+
+const WARN_POS_IGNORED = 'node positions are ignored unless start=random';
+const WARN_SELF_IGNORED = 'start=0 not supported with mode=self - ignored';
+
+/**
+ * Roots already warned about start=self under KK/SGD. C warns once per process
+ * (stuff.c:330 static atomic_flag); one render is one C process here, so the
+ * flag is per root graph rather than module state (multi-diagram safety).
+ */
+const selfWarned = new WeakSet<object>();
+/** Roots already warned about the KK circuit fallback (one warning per graph). */
+const circuitWarned = new WeakSet<object>();
+
+/**
+ * Classify the `start` attribute: keyword prefix, digit-led (random), else the
+ * default. A random seed comes from the digits following the keyword; with
+ * none, C seeds from time(), which this port keeps at the default seed 1.
+ * @see lib/neatogen/neatoinit.c:setSeed
+ */
+export function parseStart(
+  p: string | undefined, dflt: number,
+): { init: number; seed: number } {
+  let init = dflt;
+  let rest = p ?? '';
+  if (rest === '') return { init, seed: 1 };
+  if (/^[A-Za-z]/.test(rest)) {
+    const kw = START_KEYWORDS.find(([k]) => rest.startsWith(k));
+    if (kw !== undefined) { init = kw[1]; rest = rest.slice(kw[0].length); }
+  } else if (/^\d/.test(rest)) {
+    init = INIT_RANDOM;
+  }
+  const seed = init === INIT_RANDOM && /^\d/.test(rest) ? parseInt(rest, 10) : 1;
+  return { init, seed };
+}
+
+/**
+ * Place the nodes on a regular polygon and mark them P_SET (positioned, not
+ * pinned), so the stress kernel's initLayout starts from them.
+ * @see lib/neatogen/neatoinit.c:initRegular
+ */
+export function initRegular(g: Graph, nG: number): void {
+  let a = 0.0;
+  const da = (2 * Math.PI) / nG;
+  for (const np of g.nodes.values()) {
+    np.info.pos = [nG * SPRING_COEFF * Math.cos(a), nG * SPRING_COEFF * Math.sin(a)];
+    np.info.posSet = true;
+    np.info.pinned = false; // C: ND_pinned = P_SET overrides P_PIN
+    a += da;
+  }
+}
+
+/**
+ * Analyse `start`: place regular nodes, seed the RNG, return the init kind.
+ * @see lib/neatogen/neatoinit.c:checkStart
+ */
+export function checkStart(
+  g: Graph, nG: number = g.nodes.size, dflt: number = INIT_RANDOM,
+): number {
+  const { init, seed } = parseStart(g.root.attrs.get('start'), dflt);
+  if (init !== INIT_RANDOM && [...g.nodes.values()].some((n) => n.attrs.has('pos'))) {
+    console.warn(WARN_POS_IGNORED);
+  }
+  if (init === INIT_REGULAR) initRegular(g, nG);
+  srand48(seed);
+  return init;
+}
+
+function unsupported(attr: string, value: string, what: string): never {
+  throw new RenderError(`${attr}=${value}: ${what} is not supported yet`, 'UNSUPPORTED_FEATURE');
+}
+
+/** Does C's ipsep branch build constraints? @see neatoinit.c:1132-1150 */
+function ipsepHasConstraints(g: Graph): boolean {
+  const dir = g.root.attrs.get('diredgeconstraints') ?? '';
+  if (mapbool(dir) || /^hier/i.test(dir)) return true;
+  if ((g.root.attrs.get('overlap') ?? '').toLowerCase() === 'ipsep') return true;
+  return [...g.root.subgraphs.values()].some((s) => s !== g.root && isACluster(s));
+}
+
+/** @see lib/neatogen/neatoinit.c:1290 (MaxIter < 0 returns before any solver) */
+function maxIterNegative(g: Graph): boolean {
+  const v = g.attrs.get('maxiter') ?? g.root.attrs.get('maxiter');
+  if (v === undefined) return false;
+  const n = parseInt(v, 10);
+  return !Number.isNaN(n) && n < 0;
+}
+
+/** @see lib/neatogen/neatoinit.c:neatoMode (DIGCOLA + IPSEPCOLA builds) */
+// A function, not a constant: init.ts and start.ts import each other, so the
+// MODE_* values are not yet initialised when this module body runs.
+const modeByName = (): ReadonlyMap<string, number> => new Map([
+  ['KK', MODE_KK], ['major', MODE_MAJOR], ['sgd', MODE_SGD],
+  ['hier', MODE_HIER], ['ipsep', MODE_IPSEP],
+]);
+
+/**
+ * Read the root `mode` attribute: empty/absent is MODE_MAJOR, an unknown value
+ * warns with C's text and is ignored. Case sensitive, as C's streq.
+ * @see lib/neatogen/neatoinit.c:neatoMode
+ */
+export function neatoMode(g: Graph): number {
+  const str = g.root.attrs.get('mode');
+  if (str === undefined || str === '') return MODE_MAJOR;
+  const mode = modeByName().get(str);
+  if (mode !== undefined) return mode;
+  console.warn(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  return MODE_MAJOR;
+}
+
+function checkMode(g: Graph, mode: number): void {
+  const value = g.root.attrs.get('mode') || (mode === MODE_HIER ? 'hier' : 'ipsep');
+  // @see lib/neatogen/neatoinit.c:1117 (stress_majorization_with_hierarchy)
+  if (mode === MODE_HIER) unsupported('mode', value, 'hierarchical stress majorization');
+  // @see lib/neatogen/neatoinit.c:1121-1170 (stress_majorization_cola)
+  if (mode === MODE_IPSEP && ipsepHasConstraints(g)) {
+    unsupported('mode', value, 'constrained (ipsep) majorization');
+  }
+}
+
+function checkStartAttr(g: Graph, mode: number): void {
+  const value = g.root.attrs.get('start');
+  if (parseStart(value, INIT_RANDOM).init !== INIT_SELF) return;
+  // @see lib/neatogen/neatoinit.c:1095, lib/neatogen/stress.c:884 (smart_ini)
+  if (mode === MODE_MAJOR || mode === MODE_IPSEP) unsupported('start', value ?? '', 'smart initialisation');
+  // @see lib/neatogen/stuff.c:330 (KK and SGD warn once and ignore it)
+  if ((mode === MODE_KK || mode === MODE_SGD) && !selfWarned.has(g.root)) {
+    selfWarned.add(g.root);
+    console.warn(WARN_SELF_IGNORED);
+  }
+}
+
+function isConnected(g: Graph): boolean {
+  const nodes = [...g.nodes.values()];
+  if (nodes.length === 0) return true;
+  const adj = new Map<unknown, unknown[]>(nodes.map((n) => [n, []]));
+  for (const e of g.edges) { adj.get(e.tail)?.push(e.head); adj.get(e.head)?.push(e.tail); }
+  const seen = new Set<unknown>([nodes[0]]);
+  const stack: unknown[] = [nodes[0]];
+  for (let n = stack.pop(); n !== undefined; n = stack.pop()) {
+    for (const m of adj.get(n) ?? []) if (!seen.has(m)) { seen.add(m); stack.push(m); }
+  }
+  return seen.size === nodes.length;
+}
+
+/** KK runs unpacked unless `pack` or `packmode` is set. @see neatoinit.c:1380-1389 */
+function kkCircuitFallsBack(g: Graph): boolean {
+  const packed = getPack(g.root, -1, 0) >= 0 || (g.root.attrs.get('packmode') ?? '') !== '';
+  return !packed && !isConnected(g.root);
+}
+
+function warnCircuitDisconnected(g: Graph): void {
+  if (circuitWarned.has(g.root)) return;
+  circuitWarned.add(g.root);
+  console.warn(
+    `graph ${g.root.name} is disconnected. Hence, the circuit model\n`
+    + 'is undefined. Reverting to the shortest path model.\n'
+    + 'Alternatively, consider running neato using -Gpack=true or decomposing\n'
+    + 'the graph into connected components.',
+  );
+}
+
+function checkModel(g: Graph, mode: number, model: number): void {
+  const value = g.root.attrs.get('model') ?? '';
+  const stressPath = mode === MODE_MAJOR || mode === MODE_KK;
+  // @see lib/neatogen/stress.c:846, lib/neatogen/neatoinit.c:1246
+  if (model === MODEL_SUBSET && stressPath) unsupported('model', value, 'the subset distance model');
+  if (model !== MODEL_CIRCUIT || !stressPath) return;
+  // @see lib/neatogen/neatoinit.c:1248-1257 (disconnected: warn + shortpath)
+  if (mode === MODE_KK && kkCircuitFallsBack(g)) { warnCircuitDisconnected(g); return; }
+  // @see lib/neatogen/stress.c:851, lib/neatogen/circuit.c:circuit_model
+  unsupported('model', value, 'the circuit distance model');
+}
+
+/**
+ * Throw UNSUPPORTED_FEATURE where neato's C would run unported init code for
+ * this mode/model/start. Call after the nG < 2 guard.
+ * @see lib/neatogen/neatoinit.c:neatoLayout
+ */
+export function assertSupported(g: Graph, mode: number, model: number): void {
+  if (maxIterNegative(g)) return;
+  checkMode(g, mode);
+  checkStartAttr(g, mode);
+  checkModel(g, mode, model);
+}

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

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * `overlap=vpsc`: the VPSC adjuster of removeOverlapWith, moved out of
+ * neato/index.ts so every engine reaches it through the shared dispatch.
+ *
+ * C works on `float` coordinates (`float *coords[2]`), so positions are rounded
+ * to float on entry and after each pass: that decides exact-touch verdicts
+ * between the x and y passes.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ * @see lib/neatogen/quad_prog_vpsc.c:removeoverlaps
+ */
+
+import type { Graph } from '../../model/graph.js';
+import {
+  newVariable,
+  deleteVariable,
+  deleteVPSC,
+  deleteConstraints,
+  solveVPSC,
+  genXConstraints,
+  genYConstraints,
+  VPSC,
+  Rectangle,
+  type Variable,
+} from '../../vpsc/index.js';
+import { sepFactor, DFLT_MARGIN } from './sep-factor.js';
+
+const POINTS_PER_INCH = 72;
+/** Widen nodes in the x pass so a horizontally resolved pair does not count as
+ * vertically overlapping. @see quad_prog_vpsc.c:generateNonoverlapConstraints */
+const X_PASS_SCALE = Math.fround(1.0001);
+
+interface Gap { x: number; y: number }
+interface VpscBox { w: number; h: number }
+type Coords = readonly [Float32Array, Float32Array];
+
+/** One Rectangle per node: size scaled by `scale`, plus half the gap per side.
+ * @see lib/neatogen/quad_prog_vpsc.c:generateNonoverlapConstraints */
+function buildRects(c: Coords, size: VpscBox[], gap: Gap, scale: number): Rectangle[] {
+  return size.map((s, i) => {
+    const hw = (scale * s.w) / 2.0 + gap.x / 2.0;
+    const hh = (scale * s.h) / 2.0 + gap.y / 2.0;
+    return new Rectangle(c[0][i]! - hw, c[0][i]! + hw, c[1][i]! - hh, c[1][i]! + hh);
+  });
+}
+
+/** Solve one axis and store the result (rounded to float) into `c[axis]`.
+ * @see lib/neatogen/quad_prog_vpsc.c:removeoverlaps */
+function solveAxis(c: Coords, size: VpscBox[], gap: Gap, axis: 0 | 1): void {
+  const rects = buildRects(c, size, gap, axis === 0 ? X_PASS_SCALE : 1);
+  const vars: Variable[] = size.map((_, i) => newVariable(i, 1.0, 1.0));
+  const cs = axis === 0 ? genXConstraints(rects, vars, true) : genYConstraints(rects, vars);
+  const vpsc = new VPSC(vars, cs);
+  solveVPSC(vpsc);
+  // solveVPSC places every variable in a block. @see quad_prog_vpsc.c:568 getVariablePos
+  vars.forEach((v, i) => {
+    c[axis][i] = v.position();
+  });
+  deleteVPSC(vpsc);
+  deleteConstraints(cs);
+  for (const v of vars) deleteVariable(v);
+}
+
+/**
+ * Remove overlaps with two VPSC passes (x then y). The gap handed to
+ * removeoverlaps is twice the separation margin (opt.gap is the gap size, not
+ * the margin): `2 * sep` when `sep` is additive, else twice DFLT_MARGIN.
+ * Returns 0 as C does.
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ */
+export function vpscAdjust(g: Graph): number {
+  const margin = sepFactor(g);
+  const gap: Gap = {
+    x: (2 * (margin.doAdd ? margin.x : DFLT_MARGIN)) / POINTS_PER_INCH,
+    y: (2 * (margin.doAdd ? margin.y : DFLT_MARGIN)) / POINTS_PER_INCH,
+  };
+  const nodes = Array.from(g.nodes.values());
+  const c: Coords = [new Float32Array(nodes.length), new Float32Array(nodes.length)];
+  // Layout has set ND_pos and node init ND_width/ND_height before any adjuster.
+  nodes.forEach((n, i) => {
+    c[0][i] = n.info.pos![0];
+    c[1][i] = n.info.pos![1];
+  });
+  const size = nodes.map((n) => ({ w: n.info.width!, h: n.info.height! }));
+  solveAxis(c, size, gap, 0);
+  solveAxis(c, size, gap, 1);
+  nodes.forEach((n, i) => {
+    n.info.pos = [c[0][i]!, c[1][i]!];
+  });
+  return 0;
+}

package/src/layout/sfdp/index.ts

@@ -31,8 +31,7 @@ import { CL_OFFSET } from '../twopi/pipeline.js';
 import { placeGraphLabel } from '../dot/position-bbox.js';
 import { gvPostprocess } from '../../common/postproc.js';
 import { aggetGraph } from '../fdp/fdp-model.js';
-import { overlapPrismTries } from '../neato/fdp-adjust.js';
-import { adjustNodesScale } from '../neato/sc-adjust.js';
+import { overlapPrismTries, adjustNodesFull } from '../neato/fdp-adjust.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import {
   type SpringElectricalControl,
@@ -85,7 +84,7 @@ export function sfdpLayoutComponent(
  * for prism/false), ctrl.initialScaling = overlap_scaling (default −4), and
  * doAdjust is false. Otherwise (scale family, AM_NONE, unported modes) sfdp's
  * in-layout removal is off (ctrl.overlap = −1) and doAdjust drives a
- * post-layout removeOverlapWith (adjustNodesScale).
+ * post-layout removeOverlapWith (adjustNodesFull).
  * @see lib/neatogen/adjust.c:graphAdjustMode / getAdjustMode (15.0.0)
  * @see lib/sfdpgen/sfdpinit.c:sfdp_layout (HAVE_GTS branch)
  */
@@ -139,7 +138,7 @@ function layoutComponents(
   for (const sg of comps) {
     // ccomps already node-induces edges (graphviz_node_induce).
     sfdpLayoutComponent(sg, ctrl, pad);
-    if (doAdjust) adjustNodesScale(sg); // removeOverlapWith (non-PRISM modes)
+    if (doAdjust) adjustNodesFull(sg); // removeOverlapWith (non-PRISM modes)
     // @see lib/sfdpgen/sfdpinit.c:284 (setEdgeType FUNCTION, per component)
     setEdgeTypeFromAttr(sg, EDGETYPE_LINE);
     splineEdgesShifted(sg);
@@ -213,7 +212,7 @@ export function sfdpLayout(g: Graph): void {
     singleComponent = comps.length === 1;
     if (singleComponent) {
       sfdpLayoutComponent(g, ctrl, pad);
-      if (doAdjust) adjustNodesScale(g); // removeOverlapWith (non-PRISM modes)
+      if (doAdjust) adjustNodesFull(g); // removeOverlapWith (non-PRISM modes)
       splineEdgesShifted(g); // C spline_edges: shift + coord sync + route
     } else {
       layoutComponents(g, comps, ctrl, pad, doAdjust);