@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Scale-based overlap removal — scAdjust and the adjustNodes overlap-mode
+ * subset that reaches it.
+ *
+ * `overlap=scale` (AM_NSCALE) scales the layout uniformly so node boxes stop
+ * overlapping; `scalexy` (AM_SCALEXY) scales x and y independently;
+ * `compress` (AM_COMPRESS) scales down to remove excess space. 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).
+ *
+ * Other overlap modes (voronoi, prism, vpsc, ortho*) remain unported; with
+ * the attr unset C's getAdjustMode resolves to AM_NONE and the pass is a
+ * no-op (normalize/simpleScale only fire on rare attrs, also unported).
+ *
+ * @see lib/neatogen/constraint.c:scAdjust
+ * @see lib/neatogen/adjust.c:removeOverlapWith / getAdjustMode
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import { sepFactor } from './sep-factor.js';
+import { gvQsort } from '../../util/bsd-qsort.js';
+import { nodesInSeq } from '../dot/decomp.js';
+
+interface Pointf { x: number; y: number }
+
+/** Per-node scratch mirroring constraint.c's `info` struct. */
+interface Info {
+  pos: Pointf;
+  ll: Pointf;
+  ur: Pointf;
+  wd2: number;
+  ht2: number;
+  np: Node;
+}
+
+/** Boxes overlap (closed intervals). @see lib/neatogen/adjust.h:OVERLAP */
+function overlap(a: Info, b: Info): boolean {
+  return a.ur.x >= b.ll.x && b.ur.x >= a.ll.x && a.ur.y >= b.ll.y && b.ur.y >= a.ll.y;
+}
+
+/** @see lib/neatogen/constraint.c:sortf */
+function sortf(p: Pointf, q: Pointf): number {
+  if (p.x < q.x) return -1;
+  if (p.x > q.x) return 1;
+  if (p.y < q.y) return -1;
+  if (p.y > q.y) return 1;
+  return 0;
+}
+
+/**
+ * Per overlapping pair, the (x,y) scale factors that would separate it.
+ * aarr[0] is a {0,0} sentinel the callers overwrite/skip.
+ * @see lib/neatogen/constraint.c:mkOverlapSet
+ */
+function mkOverlapSet(nl: Info[]): Pointf[] {
+  const S: Pointf[] = [{ x: 0, y: 0 }];
+  for (let i = 0; i < nl.length; i++) {
+    const p = nl[i]!;
+    for (let j = i + 1; j < nl.length; j++) {
+      const q = nl[j]!;
+      if (!overlap(p, q)) continue;
+      const pt: Pointf = { x: 0, y: 0 };
+      if (p.pos.x === q.pos.x) pt.x = Number.POSITIVE_INFINITY;
+      else {
+        pt.x = (p.wd2 + q.wd2) / Math.abs(p.pos.x - q.pos.x);
+        if (pt.x < 1) pt.x = 1;
+      }
+      if (p.pos.y === q.pos.y) pt.y = Number.POSITIVE_INFINITY;
+      else {
+        pt.y = (p.ht2 + q.ht2) / Math.abs(p.pos.y - q.pos.y);
+        if (pt.y < 1) pt.y = 1;
+      }
+      S.push(pt);
+    }
+  }
+  return S;
+}
+
+/** Uniform scale: max over pairs of min(x,y). @see constraint.c:computeScale */
+function computeScale(aarr: Pointf[]): number {
+  let sc = 0;
+  for (let i = 1; i < aarr.length; i++) {
+    const p = aarr[i]!;
+    const v = Math.min(p.x, p.y);
+    if (v > sc) sc = v;
+  }
+  return sc;
+}
+
+/** Separate x/y scales minimizing area. @see constraint.c:computeScaleXY */
+function computeScaleXY(aarr: Pointf[]): Pointf {
+  const m = aarr.length;
+  aarr[0] = { x: 1, y: Number.POSITIVE_INFINITY };
+  const rest = aarr.slice(1);
+  gvQsort(rest, sortf);
+  for (let i = 1; i < m; i++) aarr[i] = rest[i - 1]!;
+
+  const barr: Pointf[] = new Array(m).fill(null).map(() => ({ x: 0, y: 0 }));
+  barr[m - 1] = { x: aarr[m - 1]!.x, y: 1 };
+  for (let k = m - 2; ; k--) {
+    barr[k] = { x: aarr[k]!.x, y: Math.max(aarr[k + 1]!.y, barr[k + 1]!.y) };
+    if (k === 0) break;
+  }
+
+  let best = 0;
+  let bestcost = Number.POSITIVE_INFINITY;
+  for (let k = 0; k < m; k++) {
+    const cost = barr[k]!.x * barr[k]!.y;
+    if (cost < bestcost) { bestcost = cost; best = k; }
+  }
+  return { x: barr[best]!.x, y: barr[best]!.y };
+}
+
+/** Max scale that leaves no free space; 0 if overlaps exist.
+ * @see lib/neatogen/constraint.c:compress */
+function compress(nl: Info[]): number {
+  let sc = 0;
+  for (let i = 0; i < nl.length; i++) {
+    const p = nl[i]!;
+    for (let j = i + 1; j < nl.length; j++) {
+      const q = nl[j]!;
+      if (overlap(p, q)) return 0;
+      const ptx = p.pos.x === q.pos.x
+        ? Number.POSITIVE_INFINITY
+        : (p.wd2 + q.wd2) / Math.abs(p.pos.x - q.pos.x);
+      const pty = p.pos.y === q.pos.y
+        ? Number.POSITIVE_INFINITY
+        : (p.ht2 + q.ht2) / Math.abs(p.pos.y - q.pos.y);
+      const s = pty < ptx ? pty : ptx;
+      if (s > sc) sc = s;
+    }
+  }
+  return sc;
+}
+
+/**
+ * Scale the layout (positions in ND_pos INCHES).
+ * equal > 0 → uniform scale to remove overlaps; equal = 0 → separate x/y;
+ * equal < 0 → scale DOWN to remove excess space (assumes no overlaps).
+ * @see lib/neatogen/constraint.c:767 scAdjust
+ */
+export function scAdjust(g: Graph, equal: number): number {
+  const margin = sepFactor(g);
+  let mx = margin.x;
+  let my = margin.y;
+  if (margin.doAdd) {
+    mx = mx / 72; // PS2INCH
+    my = my / 72;
+  }
+
+  const nlist: Info[] = [];
+  for (const n of nodesInSeq(g)) {
+    const w2 = margin.doAdd ? (n.info.width ?? 0) / 2 + mx : (mx * (n.info.width ?? 0)) / 2;
+    const h2 = margin.doAdd ? (n.info.height ?? 0) / 2 + my : (my * (n.info.height ?? 0)) / 2;
+    const pos: Pointf = { x: n.info.pos?.[0] ?? 0, y: n.info.pos?.[1] ?? 0 };
+    nlist.push({
+      pos,
+      ll: { x: pos.x - w2, y: pos.y - h2 },
+      ur: { x: pos.x + w2, y: pos.y + h2 },
+      wd2: w2,
+      ht2: h2,
+      np: n,
+    });
+  }
+
+  let s: Pointf;
+  if (equal < 0) {
+    const sc = compress(nlist);
+    if (sc === 0) return 0; // overlaps exist
+    s = { x: sc, y: sc };
+  } else {
+    const aarr = mkOverlapSet(nlist);
+    if (aarr.length === 1) return 0; // no overlaps
+    if (equal) {
+      const sc = computeScale(aarr);
+      s = { x: sc, y: sc };
+    } else {
+      s = computeScaleXY(aarr);
+    }
+  }
+
+  for (const p of nlist) {
+    if (!p.np.info.pos) p.np.info.pos = [0, 0];
+    p.np.info.pos[0] = s.x * p.pos.x;
+    p.np.info.pos[1] = s.y * p.pos.y;
+  }
+  return 1;
+}
+
+/**
+ * The adjustNodes overlap-mode subset reaching scAdjust; other modes are
+ * no-ops (see module doc).
+ * @see lib/neatogen/adjust.c:999 adjustNodes, :776 adjustMode table
+ */
+export function adjustNodesScale(g: Graph): number {
+  // agget falls back to the root graph's attrs for component subgraphs.
+  const flag = (g.attrs.get('overlap') ?? g.root.attrs.get('overlap') ?? '').toLowerCase();
+  if (flag === 'scale') return scAdjust(g, 1);       // AM_NSCALE
+  if (flag === 'scalexy') return scAdjust(g, 0);     // AM_SCALEXY
+  if (flag === 'compress') return scAdjust(g, -1);   // AM_COMPRESS
+  return 0; // unset -> AM_NONE; other modes unported
+}

package/src/layout/neato/sep-factor.ts

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Node/edge separation factors — expand_t, parseFactor, sepFactor,
+ * esepFactor from neatogen's adjust.c.
+ *
+ * @see lib/neatogen/adjust.c (15.0.0)
+ * @see lib/neatogen/adjust.h (15.0.0)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import { aggetGraph } from '../fdp/fdp-model.js';
+
+/** @see lib/neatogen/adjust.h:expand_t */
+export interface ExpandT {
+  x: number;
+  y: number;
+  /** Margins are absolute additions (points) rather than scale factors. */
+  doAdd: boolean;
+}
+
+/** Default esep/sep ratio. @see lib/neatogen/adjust.c:SEPFACT */
+export const SEPFACT = 0.8;
+/** Default margin in points. @see lib/neatogen/adjust.h:DFLT_MARGIN */
+export const DFLT_MARGIN = 4;
+
+/**
+ * Convert a "sep" attribute string into an ExpandT.
+ * "+x,y" becomes {x, y, doAdd:true}; "x,y" becomes
+ * {1 + x/sepfact, 1 + y/sepfact, doAdd:false}.
+ * Returns null on parse failure (C returns 0).
+ *
+ * @see lib/neatogen/adjust.c:parseFactor
+ */
+export function parseFactor(
+  s: string,
+  sepfact: number,
+  dflt: number,
+): ExpandT | null {
+  let str = s.trimStart();
+  let doAdd = false;
+  if (str.startsWith('+')) {
+    str = str.slice(1);
+    doAdd = true;
+  }
+  const pair = scanDoublePair(str);
+  if (pair === null) return null;
+  const { x, y } = pair;
+  if (doAdd) return parseAddFactor(x, y, sepfact, dflt);
+  return { x: 1.0 + x / sepfact, y: 1.0 + y / sepfact, doAdd: false };
+}
+
+/** sscanf(s, "%lf,%lf") with the i==1 → y=x fallback. */
+function scanDoublePair(str: string): { x: number; y: number } | null {
+  const numRe = String.raw`-?[0-9.]+(?:[eE][-+]?[0-9]+)?`;
+  const m = new RegExp(
+    String.raw`^\s*(${numRe})\s*(?:,\s*(${numRe}))?`,
+  ).exec(str);
+  if (m === null || m[1] === undefined) return null;
+  const x = parseFloat(m[1]);
+  if (Number.isNaN(x)) return null;
+  const y = m[2] !== undefined ? parseFloat(m[2]) : x;
+  return { x, y };
+}
+
+/** The doAdd clamping branches of parseFactor. @see adjust.c:1021-1036 */
+function parseAddFactor(
+  x: number,
+  y: number,
+  sepfact: number,
+  dflt: number,
+): ExpandT {
+  if (sepfact > 1) {
+    return { x: Math.min(dflt, x / sepfact), y: Math.min(dflt, y / sepfact), doAdd: true };
+  }
+  if (sepfact < 1) {
+    return { x: Math.max(dflt, x / sepfact), y: Math.max(dflt, y / sepfact), doAdd: true };
+  }
+  return { x, y, doAdd: true };
+}
+
+/**
+ * Node separation for overlap adjustment: "sep" attr, then "esep"
+ * scaled by 1/SEPFACT, then +4pt.
+ * @see lib/neatogen/adjust.c:sepFactor
+ */
+export function sepFactor(g: Graph): ExpandT {
+  const sep = aggetGraph(g, 'sep');
+  if (sep !== undefined) {
+    const pm = parseFactor(sep, 1.0, 0);
+    if (pm !== null) return pm;
+  }
+  const esep = aggetGraph(g, 'esep');
+  if (esep !== undefined) {
+    const pm = parseFactor(esep, SEPFACT, DFLT_MARGIN);
+    if (pm !== null) return pm;
+  }
+  return { x: DFLT_MARGIN, y: DFLT_MARGIN, doAdd: true };
+}
+
+/**
+ * Edge separation for spline routing: smaller than sepFactor so the
+ * spline code does not see overlaps the adjust pass left tight.
+ * @see lib/neatogen/adjust.c:esepFactor
+ */
+export function esepFactor(g: Graph): ExpandT {
+  const esep = aggetGraph(g, 'esep');
+  if (esep !== undefined) {
+    const pm = parseFactor(esep, 1.0, 0);
+    if (pm !== null) return pm;
+  }
+  const sep = aggetGraph(g, 'sep');
+  if (sep !== undefined) {
+    const pm = parseFactor(sep, 1.0 / SEPFACT, SEPFACT * DFLT_MARGIN);
+    if (pm !== null) return pm;
+  }
+  return { x: SEPFACT * DFLT_MARGIN, y: SEPFACT * DFLT_MARGIN, doAdd: true };
+}

package/src/layout/neato/set-aspect.ts

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * neato-family aspect-ratio handling — _neato_set_aspect and its helpers.
+ *
+ * C's graph_init parses ratio/size into GD_drawing for every engine; the
+ * spline_edges0(g, true) entry then reshapes the layout via neato_set_aspect
+ * before routing: fill/expand/value scale ND_pos (and the bb), compress and
+ * auto only normalize the origin. The dot engine has its own setAspect and
+ * never reaches this path.
+ *
+ * @see lib/neatogen/neatosplines.c:1023 _neato_set_aspect
+ * @see lib/neatogen/neatosplines.c:992 neato_translate
+ * @see lib/common/input.c (setRatio / graph_init)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { RatioKind } from '../../model/layoutParams.js';
+import { makeDrawing } from '../../model/layoutParams.js';
+import { parseDrawingSize } from '../../gvc/viewport.js';
+import { shiftEdgePoints } from '../pack/index.js';
+
+const POINTS_PER_INCH = 72;
+
+/** setRatio's ratio-attr mapping. @see lib/common/input.c:setRatio */
+function neatoRatioKind(g: Graph): { kind: RatioKind; ratio: number } | null {
+  const p = g.attrs.get('ratio');
+  if (p === undefined) return null;
+  if (p === 'auto') return { kind: 'auto', ratio: 0 };
+  if (p === 'compress') return { kind: 'compress', ratio: 0 };
+  if (p === 'expand') return { kind: 'expand', ratio: 0 };
+  if (p === 'fill') return { kind: 'fill', ratio: 0 };
+  const v = Number.parseFloat(p);
+  return v > 0 ? { kind: 'value', ratio: v } : null;
+}
+
+/**
+ * `size` attr in points (+ '!' filled flag). C's getdoubles2ptf stores the
+ * size via the POINTS() macro = ROUND(inches * 72), i.e. integer points — the
+ * value _neato_set_aspect divides by GD_bb to form the fill/expand factors.
+ * Delegates to the dot-path parser so both engines round size identically;
+ * skipping the ROUND left size as float inches*72, which perturbed the fill
+ * x-scale by ~0.17% on ratio=fill layouts (1855 under circo/twopi/osage).
+ * @see lib/common/input.c:476 getdoubles2ptf / lib/common/geom.h:62 POINTS
+ */
+function neatoSizePoints(raw: string | undefined): { x: number; y: number } | null {
+  const sz = parseDrawingSize(raw);
+  return sz ? { x: sz.x, y: sz.y } : null;
+}
+
+/**
+ * Populate g.info.drawing with the ratio/size fields _neato_set_aspect reads,
+ * mirroring graph_init's engine-neutral parse. No-op when the dot-side init
+ * already parsed a drawing.
+ */
+export function parseNeatoDrawing(g: Graph): void {
+  if (g.info.drawing !== undefined) return;
+  const rk = neatoRatioKind(g);
+  const sz = neatoSizePoints(g.attrs.get('size'));
+  if (rk === null && sz === null) return;
+  g.info.drawing = makeDrawing({
+    ratioKind: rk?.kind ?? 'none',
+    ratio: rk?.ratio ?? 0,
+    size: sz ? { x: sz.x, y: sz.y } : { x: 0, y: 0 },
+  });
+}
+
+/** Scale g's bb and every cluster bb. @see neatosplines.c (scaleBB) */
+function scaleBB(g: Graph, xf: number, yf: number): void {
+  if (g.info.bb) {
+    g.info.bb = {
+      ll: { x: g.info.bb.ll.x * xf, y: g.info.bb.ll.y * yf },
+      ur: { x: g.info.bb.ur.x * xf, y: g.info.bb.ur.y * yf },
+    };
+  }
+  for (const sub of g.info.clust ?? []) scaleBB(sub, xf, yf);
+}
+
+/** Translate cluster bbs (translateG). @see neatosplines.c:974 */
+function translateG(g: Graph, ll: { x: number; y: number }): void {
+  if (g.info.bb) {
+    g.info.bb = {
+      ll: { x: g.info.bb.ll.x - ll.x, y: g.info.bb.ll.y - ll.y },
+      ur: { x: g.info.bb.ur.x - ll.x, y: g.info.bb.ur.y - ll.y },
+    };
+  }
+  for (const sub of g.info.clust ?? []) translateG(sub, ll);
+}
+
+/**
+ * Translate the drawing so bb.LL is the origin: node pos (inches) and
+ * xlabels, routed splines, then the bb tree.
+ * @see lib/neatogen/neatosplines.c:992 neato_translate
+ */
+export function neatoTranslate(g: Graph): void {
+  const bb = g.info.bb;
+  if (!bb) return;
+  const ll = bb.ll;
+  const ox = ll.x / POINTS_PER_INCH;
+  const oy = ll.y / POINTS_PER_INCH;
+  for (const n of g.nodes.values()) {
+    if (!n.info.pos) n.info.pos = [0, 0];
+    n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
+    n.info.pos[1] = (n.info.pos[1] ?? 0) - oy;
+    const xl = n.info.xlabel as { set?: boolean; pos?: { x: number; y: number } } | undefined;
+    if (xl?.set === true && xl.pos) {
+      xl.pos = { x: xl.pos.x - ll.x, y: xl.pos.y - ll.y };
+    }
+  }
+  for (const e of g.edges) {
+    if (e.info.spl) shiftEdgePoints(e, -ll.x, -ll.y);
+  }
+  translateG(g, ll);
+}
+
+/** The fill/expand/value scale factors; null → no scaling. */
+function aspectFactors(g: Graph): { xf: number; yf: number } | null {
+  const drawing = g.info.drawing!;
+  const bb = g.info.bb!;
+  if (drawing.ratioKind === 'fill') {
+    // fill is weird because both X and Y can stretch
+    if (drawing.size.x <= 0) return null;
+    let xf = drawing.size.x / bb.ur.x;
+    let yf = drawing.size.y / bb.ur.y;
+    if (xf < 1.0 || yf < 1.0) {
+      if (xf < yf) { yf /= xf; xf = 1.0; }
+      else { xf /= yf; yf = 1.0; }
+    }
+    return { xf, yf };
+  }
+  if (drawing.ratioKind === 'expand') {
+    if (drawing.size.x <= 0) return null;
+    const xf = drawing.size.x / bb.ur.x;
+    const yf = drawing.size.y / bb.ur.y;
+    if (xf > 1.0 && yf > 1.0) {
+      const scale = Math.min(xf, yf);
+      return { xf: scale, yf: scale };
+    }
+    return null;
+  }
+  if (drawing.ratioKind === 'value') {
+    const desired = drawing.ratio;
+    const actual = bb.ur.y / bb.ur.x;
+    if (actual < desired) return { xf: 1.0, yf: desired / actual };
+    return { xf: actual / desired, yf: 1.0 };
+  }
+  return null; // auto / compress: translate only
+}
+
+/**
+ * Reshape the layout per ratio/size — assumes bb is computed and applies only
+ * on the root graph. Returns true when node positions moved.
+ * @see lib/neatogen/neatosplines.c:1023 _neato_set_aspect
+ */
+export function neatoSetAspectRatio(g: Graph): boolean {
+  if (g.root !== g) return false;
+  const drawing = g.info.drawing;
+  if (!drawing || drawing.ratioKind === 'none') return false;
+  const bb = g.info.bb;
+  if (!bb) return false;
+  let translated = false;
+  if (bb.ll.x !== 0 || bb.ll.y !== 0) {
+    translated = true;
+    neatoTranslate(g);
+  }
+  // (GD_flip normalize skipped: effective rankdir is TB for every engine on
+  // this path — neutralGraphRankdir clears flip.)
+  const f = aspectFactors(g);
+  if (f === null) return translated;
+  const { xf, yf } = f;
+  for (const n of g.nodes.values()) {
+    if (!n.info.pos) continue;
+    n.info.pos[0] = (n.info.pos[0] ?? 0) * xf;
+    n.info.pos[1] = (n.info.pos[1] ?? 0) * yf;
+  }
+  scaleBB(g, xf, yf);
+  return true;
+}