@knowvah/dot-engine 2.7.1 → 2.8.0

package/src/gvc/usershape.ts

@@ -63,3 +63,43 @@ export function imageIsSupplied(name: string, sizer?: ImageSizer, resolver?: Ima
 export function imageOpenWarning(name: string): string {
   return `${STRERROR_ENOENT} while opening ${name}`;
 }
+
+/** @see lib/gvc/gvusershape.c:DEFAULT_DPI */
+export const DEFAULT_DPI = 96;
+/** @see lib/common/geom.h:POINTS_PER_INCH */
+const POINTS_PER_INCH = 72;
+
+/**
+ * The graph's `dpi` as `gvusershape_size` reads it: GD_drawing->dpi is
+ * late_double(dpi, resolution, 0) (input.c:705), and a value below 1 means
+ * the 96 default.
+ * @see lib/common/input.c:graph_init (dpi), lib/gvc/gvusershape.c:gvusershape_size
+ */
+export function usershapeDpi(attrs: ReadonlyMap<string, string>): number {
+  const lateDouble = (s: string | undefined, dflt: number): number => {
+    if (s === undefined || s === '') return dflt;
+    const v = Number(s);
+    return Number.isNaN(v) || s.trim() === '' ? dflt : Math.max(v, 0);
+  };
+  const dpi = lateDouble(attrs.get('dpi'), lateDouble(attrs.get('resolution'), 0));
+  return dpi >= 1 ? dpi : DEFAULT_DPI;
+}
+
+/**
+ * Image size in points: `gvusershape_size`. The caller's sizer reports pixels;
+ * the result is `(int)(px * 72 / dpi)` (the file's own dpi is unknown to a
+ * sizer, so `us->dpi` is 0 as for most formats). Null stands for C's (-1,-1):
+ * empty name or an image nobody supplies.
+ * @see lib/gvc/gvusershape.c:gvusershape_size, gvusershape_size_dpi
+ */
+export function usershapeSizePts(
+  name: string | undefined, dpi: number, sizer?: ImageSizer,
+): { x: number; y: number } | null {
+  if (name === undefined || name === '') return null;
+  const px = sizer !== undefined ? sizer(name) : findImageSize(name);
+  if (px === null) return null;
+  return {
+    x: Math.trunc((px.w * POINTS_PER_INCH) / dpi),
+    y: Math.trunc((px.h * POINTS_PER_INCH) / dpi),
+  };
+}

package/src/layout/circo/index.ts

@@ -18,6 +18,7 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { LayoutEngine } from '../../gvc/context.js';
 import { circoInitGraph, freeNData } from './init.js';
 import { circoLayout } from './circular.js';
@@ -72,6 +73,9 @@ export function circoLayoutFull(g: Graph): void {
 
 /** @see lib/circogen/circularinit.c:circo_cleanup */
 export function circoCleanup(g: Graph): void {
+  if (g.nodes.size === 0) return; // C: g is empty
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
   // Derived graph was stored in g.info.alg during circoLayout; clear it.
   g.info.alg = undefined;
   g.info.neato_nlist = undefined;

package/src/layout/dot/init.ts

@@ -275,6 +275,35 @@ export function removeFill(g: Graph): void {
 // dotCleanup
 // ---------------------------------------------------------------------------
 
+/**
+ * The label frees shared by every engine's per-edge cleanup.
+ * @see lib/common/utils.c:gv_cleanup_edge
+ */
+export function gvCleanupEdgeLabels(e: Edge): void {
+  e.info.label = undefined;
+  e.info.xlabel = undefined;
+  e.info.head_label = undefined;
+  e.info.tail_label = undefined;
+}
+
+/**
+ * The label frees shared by every non-dot engine's per-node cleanup.
+ * @see lib/common/utils.c:gv_cleanup_node
+ */
+export function gvCleanupNodeLabels(n: Node): void {
+  n.info.label = undefined;
+  n.info.xlabel = undefined;
+}
+
+/**
+ * Frees non-root subgraph labels, recursing into every subgraph first.
+ * @see lib/dotgen/dotinit.c:dot_cleanup_graph
+ */
+function dotCleanupGraph(g: Graph): void {
+  for (const subg of g.subgraphs.values()) dotCleanupGraph(subg);
+  if (g !== g.root) g.info.label = undefined;
+}
+
 /**
  * Clears all edge lists and linked-list pointers from nodes in the fast-graph,
  * releasing layout state without destroying the underlying graph structure.
@@ -284,6 +313,9 @@ export function removeFill(g: Graph): void {
  * @see lib/dotgen/dotinit.c:dot_cleanup
  */
 export function dotCleanup(g: Graph): void {
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge (all out-edges)
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // dot_cleanup_node
+  dotCleanupGraph(g);
   let n: Node | undefined = g.info.nlist;
   while (n !== undefined) {
     const next: Node | undefined = n.info.next;

package/src/layout/dot/splines.ts

@@ -27,6 +27,7 @@ import { routeEdgeGroups } from './splines-groups.js';
 import { placePortLabels, placeRegularEdgeLabels, setEdgeLabelPos } from './splines-label.js';
 import { nodesInSeq } from './decomp.js';
 import { agerrLineOn } from '../../common/agerr.js';
+import { setState, GVSPLINES } from '../../common/layout-state.js';
 
 // ---------------------------------------------------------------------------
 // Edge-type flag constants
@@ -462,6 +463,7 @@ function orthoDispatch(g: Graph): number {
   // are placed via place_portlabel for ortho too. Skipping this left the
   // labels unset, so the xlabels pass placed them instead (144_ortho).
   placePortLabels(g);
+  setState(GVSPLINES); // @see dotsplines.c:477 (reached via goto finish)
   g.info.edgeLabelsDone = true;
   return 0;
 }
@@ -487,6 +489,7 @@ function finalizeSplines(g: Graph, et: number, normalize: boolean): void {
   if (normalize) edgeNormalize(g);
   if (et !== EDGETYPE_CURVED) routeDotEdges(g);
   placePortLabels(g);
+  setState(GVSPLINES); // @see dotsplines.c:477
   g.info.edgeLabelsDone = true; // @see dotsplines.c:471 (EdgeLabelsDone = 1)
 }
 

package/src/layout/fdp/init.ts

@@ -14,6 +14,7 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import { commonInitNodeEdge, lateDouble, layoutMeasurer } from '../../common/nodeinit.js';
@@ -99,12 +100,28 @@ export function fdpInitNodeEdge(g: Graph): void {
   initialPositions(g);
 }
 
+/**
+ * Frees each cluster label, recursively.
+ * @see lib/fdpgen/fdpinit.c:cleanup_subgs
+ */
+function fdpCleanupSubgs(g: Graph): void {
+  const nClust = g.info.n_cluster ?? 0;
+  for (let i = 1; i <= nClust; i++) {
+    const subg = g.info.clust![i - 1];
+    subg.info.label = undefined;
+    fdpCleanupSubgs(subg);
+  }
+}
+
 /**
  * Release fdp layout state (gv_cleanup analogue; the render pipeline
  * runs before cleanup per the M2 ordering fix).
  * @see lib/fdpgen/fdpinit.c:fdp_cleanup
  */
 export function fdpCleanup(g: Graph): void {
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
+  fdpCleanupSubgs(g);
   for (const n of g.nodes.values()) {
     n.info.alg = undefined;
     n.info.pos = undefined;

package/src/layout/neato/conjgrad-mkernel.ts

@@ -6,9 +6,8 @@
  * C statement `a += b * c` on floats is one `fmadd`/`fmla` (clang's default
  * contraction), and a reduction the vectoriser took in blocks of 16 rounds
  * the products of those leading elements before its in-order adds (strict FP
- * forbids reassociation) while the scalar remainder is fused. `stress-kernel.ts`
- * keeps the unfused rounding of these loops; the constrained-majorization driver
- * needs the oracle's bits.
+ * forbids reassociation) while the scalar remainder is fused. These kernels run
+ * `stress_majorization_kD_mkernel` and the constrained-majorization driver.
  *
  * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
  * @see lib/neatogen/matrix_ops.c:right_mult_with_vector_ff

package/src/layout/neato/constrained-majorization.ts

@@ -14,6 +14,7 @@
  * @see lib/neatogen/constrained_majorization.c
  */
 
+import { fma } from '../../common/fma.js';
 import { RenderError } from '../../errors.js';
 import type { Node } from '../../model/node.js';
 import { conjugateGradientMkernelFused, rightMultWithVectorFFFused } from './conjgrad-mkernel.js';
@@ -21,7 +22,7 @@ import { computeHierarchy, type Hierarchy } from './compute-hierarchy.js';
 import type { VtxData } from './dijkstra.js';
 import { MODEL_CIRCUIT, MODEL_MDS, MODEL_SUBSET } from './init.js';
 import {
-  fma, invertSqrtVec, invertVec, orthog1, sqrtVecF, squareVec, vectorsInnerProductF,
+  invertSqrtVec, invertVec, orthog1, sqrtVecF, squareVec, vectorsInnerProductF,
 } from './matrix-ops.js';
 import type { DirectedVtxData } from './opt-arrangement.js';
 import { computeYCoords } from './opt-arrangement.js';

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

@@ -8,12 +8,33 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { agNameOf } from '../../model/cgraph-ops.js';
 import type { Edge } from '../../model/edge.js';
 import { agwarningf } from '../../common/agerr.js';
+import { buildOutEdgeIndex } from '../../model/node.js';
 
 /** `dfltlen` passed by scan_graph_mode. @see lib/neatogen/stuff.c:scan_graph_mode */
 export const DEFAULT_EDGE_LEN = 1.0;
 
+/** sscanf("%lf") number prefix: decimal, hex, inf/infinity, nan (case-insensitive). */
+const DOUBLE_PREFIX =
+  /^\s*([+-]?)(0x(?:[\da-f]+\.?[\da-f]*|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?|inf(?:inity)?|nan(?:\([\w]*\))?)/i;
+
+/** `sscanf(s, "%lf", &v)`: the parsed value (NaN for "nan"), or null when nothing scans. */
+function scanDouble(s: string): number | null {
+  const m = DOUBLE_PREFIX.exec(s);
+  if (m === null) return null;
+  const body = m[2]!.toLowerCase();
+  const sign = m[1] === '-' ? -1 : 1;
+  if (body.startsWith('nan')) return Number.NaN;
+  if (body.startsWith('inf')) return sign * Infinity;
+  if (!body.startsWith('0x')) return sign * parseFloat(body);
+  const [mant, exp] = body.slice(2).split('p');
+  const [ip = '', fp = ''] = mant!.split('.');
+  const digits = parseInt(ip + fp || '0', 16);
+  return sign * digits * 2 ** (Number(exp ?? 0) - 4 * fp.length);
+}
+
 /**
  * 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.
@@ -22,16 +43,27 @@ export const DEFAULT_EDGE_LEN = 1.0;
 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) {
-    agwarningf(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+  const len = scanDouble(s);
+  if (len === null || len < 0 || len === 0) {
+    agwarningf(`bad edge len "${s}" in ${agNameOf(g)} - 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);
+/**
+ * Store every edge's length in `info.dist` (ED_dist), visiting nodes in order and each
+ * node's out-edges in `agfstout` order as scan_graph_mode does; returns the total length.
+ * @see lib/neatogen/stuff.c:setEdgeLen
+ */
+export function setEdgeLen(g: Graph): number {
+  const out = buildOutEdgeIndex(g);
+  let total = 0;
+  for (const np of g.nodes.values()) {
+    for (const ep of out.get(np) ?? []) {
+      ep.info.dist = lenattr(ep, g);
+      total += ep.info.dist;
+    }
+  }
+  return total;
 }

package/src/layout/neato/init.ts

@@ -11,12 +11,14 @@
 
 import type { ShapeDesc } from '../../common/types.js';
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import type { VtxData } from './dijkstra.js';
 import {
   DFLT_ITERATIONS,
   OPT_SMART_INIT as STRESS_OPT_SMART_INIT,
+  checkExp,
   MODEL_MDS as STRESS_MODEL_MDS,
   MODEL_CIRCUIT as STRESS_MODEL_CIRCUIT,
   MODEL_SUBSET as STRESS_MODEL_SUBSET,
@@ -26,6 +28,7 @@ import { kkNeato } from './kk.js';
 import {
   checkStart, assertSupported, parseStart, INIT_RANDOM, INIT_REGULAR, INIT_SELF,
 } from './start.js';
+import { setEdgeLen } from './edge-len.js';
 import { makeGraphDataC, graphHasLen } from './make-graph-data.js';
 import type { DirectedVtxData } from './opt-arrangement.js';
 import { stressMajorizationWithHierarchy } from './constrained-majorization.js';
@@ -37,7 +40,6 @@ import {
   computeApspPacked,
   computeWeightedApspPacked,
   stressMajorizationKDMkernel,
-  OPT_EXP_FLAG,
 } from './stress-kernel.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import { inputscaleDivisor } from '../../common/utils-inputscale.js';
@@ -373,18 +375,19 @@ function solveStress(
   const weighted = haveLen && mode !== MODE_IPSEP;
   const Dij = weighted ? computeWeightedApspPacked(vtx, n) : computeApspPacked(vtx, n);
   return stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
-    dim: DFLT_DIM, opts, maxi, epsilon,
+    dim: DFLT_DIM, opts, maxi, epsilon, cola: mode === MODE_IPSEP,
   });
 }
 
 /** Run stress majorization and write positions back. @see lib/neatogen/neatoinit.c:majorization */
 export function runMajorization(g: Graph, mode: number, model: number): void {
   const nodeList = assignNodeIds(g);
+  setEdgeLen(g); // scan_graph_mode else-branch: ED_dist for major/hier/ipsep
   const n = nodeList.length;
   const haveLen = graphHasLen(g);
   // C: srand48(seed) immediately before initLayout draws; hier starts from self
   const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
-  const opts = init === INIT_SELF ? OPT_EXP_FLAG | STRESS_OPT_SMART_INIT : OPT_EXP_FLAG;
+  const opts = checkExp(g) | (init === INIT_SELF ? STRESS_OPT_SMART_INIT : 0);
   const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
   const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
   const dCoords = [new Float64Array(n), new Float64Array(n)];
@@ -489,6 +492,8 @@ export function neatoSetAspect(g: Graph): void {
  * @see lib/neatogen/neatoinit.c:neato_cleanup
  */
 export function neatoCleanup(g: Graph): void {
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
   for (const [, n] of g.nodes) {
     n.info.pos = undefined;
     n.info.pinned = undefined;

package/src/layout/neato/kk.ts

@@ -17,6 +17,7 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { agNameOf } from '../../model/cgraph-ops.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import { buildOutEdgeIndex } from '../../model/node.js';
@@ -290,7 +291,7 @@ function moveNode(st: KkState, m: number): void {
 function solveModel(g: Graph, st: KkState): void {
   for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
   if (st.move === st.maxIter) {
-    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
   }
 }
 

package/src/layout/neato/make-graph-data.ts

@@ -6,7 +6,6 @@
  * @see lib/neatogen/neatoinit.c
  */
 
-import { lateDouble } from '../../common/nodeinit.js';
 import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { DirectedVtxData } from './opt-arrangement.js';
@@ -129,7 +128,7 @@ function addNeighbours(g: Graph, np: Node, entry: DirectedVtxData, o: GraphDataO
     if (ep.head === ep.tail) continue;
     const vp = ep.tail === np ? ep.head : ep.tail;
     const vid = vp.info.id!;
-    const dist = o.haveLen ? lateDouble(ep.attrs.get('len'), 1.0, 0) : 1.0;
+    const dist = o.haveLen ? (ep.info.dist ?? 0) : 1.0; // ED_dist (calloc 0)
     const idx = seen.get(vid);
     if (idx !== undefined) {
       if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx]!, dist);

package/src/layout/neato/matrix-ops.ts

@@ -11,21 +11,11 @@
  */
 
 import { crand } from '../../common/crand.js';
-import { fma as softFma } from '../../common/fma.js';
+import { fma } from '../../common/fma.js';
 import type { VtxData } from './dijkstra.js';
 
 const fr = Math.fround;
 
-/**
- * fmadd: round(a * b + c) once. `common/fma` splits operands (Dekker), which
- * turns an infinite operand into NaN where the hardware fmadd gives inf, so
- * non-finite products and addends take the plain expression (exact then).
- */
-export function fma(a: number, b: number, c: number): number {
-  const p = a * b;
-  return Number.isFinite(p) && Number.isFinite(c) ? softFma(a, b, c) : p + c;
-}
-
 /** Subtract the mean (double precision). @see matrix_ops.c:orthog1 */
 export function orthog1(n: number, vec: Float64Array): void {
   let sum = 0;

package/src/layout/neato/smart-ini-x.ts

@@ -11,13 +11,13 @@
  */
 
 import { crand } from '../../common/crand.js';
+import { fma } from '../../common/fma.js';
 import { conjugateGradientF } from './conjgrad.js';
 import type { VtxData } from './dijkstra.js';
 import { computeApsp } from './kkutils.js';
 import {
   BLOCK_NONE,
   copyVector,
-  fma,
   innerProduct,
   norm,
   scadd,

package/src/layout/neato/splines.ts

@@ -21,6 +21,7 @@ import type { SplineInfo, PolygonT, TextlabelT } from '../../common/types.js';
 import { polygonOutlineRing } from '../../common/poly-sizing.js';
 import { fma, fms } from '../../common/fma.js';
 import { ShapeKind } from '../../common/types.js';
+import { setState, GVSPLINES } from '../../common/layout-state.js';
 import { esepFactor, type ExpandT } from './sep-factor.js';
 import { libmCos, libmSin } from '../../common/libm-trig.js';
 import type { Poly, VConfig } from '../../pathplan/types.js';
@@ -821,10 +822,11 @@ export function splineEdges(g: Graph): void {
   }
   // C splineEdges wrapper: coalesce equivalent edges before routing.
   coalesceEdges(g);
-  if (edgetype === EDGETYPE_LINE) { RoutingHelper.straight(g, edgetype); return; }
+  if (edgetype === EDGETYPE_LINE) { RoutingHelper.straight(g, edgetype); setState(GVSPLINES); return; }
   // C: margin = esepFactor(g) — the edge separation, default {3.2, 3.2, add}.
   // @see lib/neatogen/neatosplines.c:746
   splineEdgesImpl(g, esepFactor(g), edgetype);
+  setState(GVSPLINES); // State = GVSPLINES, neatosplines.c:778 (also the LINE path)
 }
 
 // ---------------------------------------------------------------------------

package/src/layout/neato/start.ts

@@ -14,6 +14,7 @@
  */
 
 import { RenderError } from '../../errors.js';
+import { agNameOf } from '../../model/cgraph-ops.js';
 import type { Graph } from '../../model/graph.js';
 import { srand48 } from '../../common/random.js';
 import { registerRenderState } from '../../common/render-state.js';
@@ -147,7 +148,7 @@ export function neatoMode(g: Graph): number {
   if (str === undefined || str === '') return MODE_MAJOR;
   const mode = modeByName().get(str);
   if (mode !== undefined) return mode;
-  agwarningf(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  agwarningf(`Illegal value ${str} for attribute "mode" in graph ${agNameOf(g.root)} - ignored`);
   return MODE_MAJOR;
 }
 
@@ -195,7 +196,7 @@ function warnCircuitDisconnected(g: Graph): void {
   circuitWarned.add(g.root);
   agerrLineOn(
     'warn',
-    `graph ${g.root.name} is disconnected. Hence, the circuit model\n`
+    `graph ${agNameOf(g.root)} 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.',