@knowvah/dot-engine 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Faithful TypeScript port of Graphviz (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork) — no C: no native binary, no WASM. Oracle-verified against the C implementation, runs in the browser.",
   "keywords": [
     "graphviz",

package/src/layout/fdp/normalize.ts

@@ -34,12 +34,12 @@ function angleSet(g: Graph): number | null {
   if (a === undefined || a === '') return null;
   const ang = parseAngle(a);
   if (ang === null) return null;
-  return wrapDegrees(ang) * (Math.PI / 180);
+  return (wrapDegrees(ang) / 180.0) * Math.PI; // RADIANS(a) = a/180.0*M_PI
 }
 
-/** strtod with the mapbool fallback of angleSet. */
+/** strtod (leading whitespace, sign) with the mapbool fallback of angleSet. */
 function parseAngle(a: string): number | null {
-  const m = /^-?[\d.]+(?:[eE][-+]?\d+)?/.exec(a);
+  const m = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/.exec(a);
   if (m !== null) return parseFloat(m[0]);
   /* no number */
   return mapbool(a) ? 0.0 : null;
@@ -55,34 +55,38 @@ function wrapDegrees(ang: number): number {
 /**
  * If "normalize" is set, move the first node to the origin, then
  * rotate the layout so the first edge sits at the given angle.
+ * Returns 1 if nodes moved, else 0.
  * @see lib/neatogen/adjust.c:normalize (15.0.0)
  */
-export function normalizeG(g: Graph): void {
+export function normalizeG(g: Graph): number {
   const phi0 = angleSet(g);
-  if (phi0 === null) return;
+  if (phi0 === null) return 0;
 
   const nodes = [...g.nodes.values()];
   const first = nodes[0];
-  if (first === undefined) return;
+  if (first === undefined) return 0;
   const px = first.info.pos![0]!;
   const py = first.info.pos![1]!;
   for (const v of nodes) {
     v.info.pos![0]! -= px;
     v.info.pos![1]! -= py;
   }
+  const ret = px || py ? 1 : 0;
 
   let e = null;
   for (const v of nodes) {
     const out = v.outEdges(g);
     if (out.length > 0) { e = out[0]!; break; }
   }
-  if (e === null) return;
+  if (e === null) return ret;
 
   /* rotation necessary; pos => ccw */
   const phi = phi0 - Math.atan2(
     e.head.info.pos![1]! - e.tail.info.pos![1]!,
     e.head.info.pos![0]! - e.tail.info.pos![0]!);
-  if (phi) rotateAll(nodes, e.tail, phi);
+  if (!phi) return ret;
+  rotateAll(nodes, e.tail, phi);
+  return 1;
 }
 
 /** Rotate all positions by phi about the orig node. */

package/src/layout/fdp/xlayout.ts

@@ -32,6 +32,7 @@ import {
 } from './fdp-model.js';
 import { coincidentDelta } from './tlayout.js';
 import { normalizeG } from './normalize.js';
+import { simpleScale } from '../neato/simple-scale.js';
 
 /** @see lib/fdpgen/xlayout.c:DFLT_overlap */
 const DFLT_OVERLAP = '9:prism';
@@ -314,14 +315,14 @@ export function fdpXLayout(g: Graph, xpms: XParams): void {
  *   scale family (scale/scalexy/compress) → scAdjust;
  *   AM_NONE ('' / 'true') and unported modes (voronoi) → no-op.
  * normalize reads "normalize" and simpleScale reads "scale"; deriveGraph
- * copies only overlap/sep/K, so both are faithfully dead here (as noted in
- * normalize.ts / sc-adjust.ts) unless set on the derived chain — simpleScale
- * follows the project's decision to leave it unported.
+ * copies only overlap/sep/K, so both are faithfully dead here unless set on
+ * the derived chain (native fdp ignores both attributes).
  * @see lib/neatogen/adjust.c:removeOverlapAs / removeOverlapWith / getAdjustMode
  */
 function removeOverlapAs(g: Graph, flag: string): void {
   if (g.nodes.size < 2) return; // removeOverlapWith: <2 nodes short-circuits
-  normalizeG(g); // removeOverlapWith runs normalize before the mode switch
+  normalizeG(g); // removeOverlapWith runs normalize + simpleScale first
+  simpleScale(g);
   const ntry = overlapPrismTries(flag);
   if (ntry !== null) {
     fdpAdjust(g, ntry); // AM_PRISM

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

@@ -18,6 +18,8 @@ import {
 } from '../sfdp/sparse-matrix.js';
 import { removeOverlapPrism } from './overlap-prism.js';
 import { scAdjust } from './sc-adjust.js';
+import { simpleScale } from './simple-scale.js';
+import { normalizeG } from '../fdp/normalize.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';
@@ -208,15 +210,16 @@ function adjustVoronoi(g: Graph, am: AdjustData): number {
 
 /**
  * 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).
+ * simpleScale run first, whatever the mode (the `normalize` / `scale`
+ * attributes); returns non-zero if nodes moved.
  * @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);
+  const nret = normalizeG(g) + simpleScale(g);
+  if (am.mode === AM_NONE) return nret;
+  if (am.mode > AM_SCALE) return nret + adjustLate(g, am);
+  return nret + (am.mode === AM_SCALE ? sAdjustGraph(g) : adjustVoronoi(g, am));
 }
 
 /**

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

@@ -11,9 +11,8 @@
  * 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).
+ * Dispatched from removeOverlapWith (fdp-adjust.ts) for overlap=scale,
+ * scalexy and compress.
  *
  * @see lib/neatogen/constraint.c:scAdjust
  * @see lib/neatogen/adjust.c:removeOverlapWith / getAdjustMode
@@ -191,16 +190,3 @@ export function scAdjust(g: Graph, equal: number): number {
   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/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;
+}