@knowvah/dot-engine 2.6.2 → 2.6.3

package/src/layout/circo/position.ts

@@ -15,6 +15,7 @@ import type { Block, SubGraph, CircState } from './blocks.js';
 import { blkParent, setCoalesced, FLAGS_ISPARENT } from './blocks.js';
 import { applyDelta, getRotation } from './position-helpers.js';
 import { layoutBlock } from './blockpath.js';
+import { fma } from '../../common/fma.js';
 
 export type PosState = {
   radius: number; subtreeR: number; nodeAngle: number;
@@ -48,10 +49,14 @@ export function getInfo(pi: PosInfo, stp: PosState, minDist: number): number {
   return maxR;
 }
 
-/** @see lib/circogen/circpos.c:setInfo */
+/**
+ * The numerator is one clang-contracted fmadd: p0.diameter * p1.minRadius
+ * added to the rounded p1.diameter * p0.minRadius (objdump of `_doBlock`).
+ * @see lib/circogen/circpos.c:setInfo
+ */
 export function setInfo(p0: PosInfo, p1: PosInfo, delta: number): void {
   const t = Math.max(
-    (p0.diameter * p1.minRadius + p1.diameter * p0.minRadius)
+    fma(p0.diameter, p1.minRadius, p1.diameter * p0.minRadius)
       / (2 * delta * p0.minRadius * p1.minRadius), 1,
   );
   p0.scale = Math.max(p0.scale, t);
@@ -63,9 +68,25 @@ export function placeChild(child: Block, ca: number, ctx: PlaceCtx): number {
   const dx = ctx.childRadius * Math.cos(ca);
   const dy = ctx.childRadius * Math.sin(ca);
   applyDelta(child, dx, dy, getRotation(child, dx, dy, ca));
-  return ctx.length === 1
-    ? ca + ctx.incAngle + ctx.mindistAngle
-    : ca + ctx.incAngle + ctx.mindistAngle / 2;
+  return nextChildAngle(ca, ctx.incAngle, ctx.mindistAngle, ctx.length);
+}
+
+/**
+ * The angle after placing a child. C's `childAngle += incidentAngle +
+ * mindistAngle` (or `+ mindistAngle / 2`) adds the right-hand sum last.
+ * @see lib/circogen/circpos.c:positionChildren
+ */
+export function nextChildAngle(ca: number, inc: number, mda: number, length: number): number {
+  return length === 1 ? ca + (inc + mda) : ca + (inc + mda / 2);
+}
+
+/**
+ * Circumference left over on a length-1 block's child circle: C's
+ * `2 * M_PI * childRadius - info->diameter`, contracted to one fnmsub.
+ * @see lib/circogen/circpos.c:positionChildren
+ */
+export function leftoverArc(childRadius: number, diameter: number): number {
+  return fma(2 * Math.PI, childRadius, -diameter);
 }
 
 /** Advance child angle for length===1 blocks; updates firstAngle/lastAngle. */
@@ -81,7 +102,7 @@ export function advanceAngleL1(
 /** Advance child angle for multi-node blocks. */
 export function advanceAngleLN(ca: number, inc: number, mda: number, total: number, theta: number): number {
   if (total === 1) return theta;
-  return ca + inc + mda / 2;
+  return ca + (inc + mda / 2); // C: childAngle += incidentAngle + mindistAngle / 2
 }
 
 /** Write psi midpoint angle to node alg when conditions are met. */
@@ -101,7 +122,7 @@ export function positionChildren(pi: PosInfo, stp: PosState, length: number, min
   if (length === 1) {
     cr = Math.max(cr, pi.diameter / (2 * Math.PI));
     // C redistributes leftover circumference into min_dist.
-    const d = 2 * Math.PI * cr - pi.diameter;
+    const d = leftoverArc(cr, pi.diameter);
     if (d > 0) md += d / pi.childCount;
   }
   stp.subtreeR = Math.max(stp.subtreeR, cr + pi.maxRadius);

package/src/layout/dot/ortho-adapter.ts

@@ -16,6 +16,7 @@ import type { Edge } from '../../model/edge.js';
 import { buildOutEdgeIndex } from '../../model/node.js';
 import { dotRoot } from './mincross-utils.js';
 import { nodesInSeq } from './decomp.js';
+import { PointSet } from '../../common/pointset.js';
 import { clipAndInstall } from '../../common/splines-clip.js';
 import { buildDotSinfo } from './self-loop.js';
 import { orthoEdges } from '../../ortho/index.js';
@@ -49,11 +50,27 @@ function buildNodes(nodeArr: Node[]): OrthoNodeArr {
   }));
 }
 
+/**
+ * Concentrate dedup: true when the unordered (tail, head) pair is already in
+ * `ps`; otherwise records it. C normalises AGSEQ(tail)/AGSEQ(head) to
+ * (min, max) and makes one isInPS/addPS pair on it.
+ * @see lib/ortho/ortho.c:1221-1229 (orthoEdges Concentrate PS)
+ */
+function isConcentrateDup(ps: PointSet, e: Edge): boolean {
+  const ti = e.tail.id;
+  const hi = e.head.id;
+  const lo = ti <= hi ? ti : hi;
+  const up = ti <= hi ? hi : ti;
+  if (ps.isInPS(lo, up)) return true;
+  ps.addPS(lo, up);
+  return false;
+}
+
 /**
  * Gather edges to route, mirroring C's ortho gather loop exactly:
  * iterate nodes in agfstnode (creation/seq) order, then each node's out-edges
  * in agfstout order. When `concentrate` is set, dedup by the UNORDERED node
- * pair via a point-set — the first edge between a pair (in either direction)
+ * pair via a `PointSet` — the first edge between a pair (in either direction)
  * is routed; any later edge sharing that pair (the reverse of a 2-cycle, or a
  * parallel multi-edge) is skipped. This is ortho's own concentrate mechanism,
  * distinct from class2's `edge_type == IGNORED` marking, and the keep-first
@@ -70,19 +87,13 @@ function buildEdges(
   const nodeIndex = new Map<Node, number>();
   nodeArr.forEach((n, i) => nodeIndex.set(n, i));
   const outIndex = buildOutEdgeIndex(g);
-  const seen = new Set<string>();
+  const ps = concentrate ? new PointSet() : null;
   const result: TaggedOrthoEdge[] = [];
   for (const n of nodeArr) {
     const oes = outIndex.get(n);
     if (oes === undefined) continue;
     for (const e of oes) {
-      if (concentrate) {
-        const ti = e.tail.id;
-        const hi = e.head.id;
-        const key = ti <= hi ? `${ti},${hi}` : `${hi},${ti}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-      }
+      if (ps !== null && isConcentrateDup(ps, e)) continue;
       result.push({
         tail: orthoNodes[nodeIndex.get(e.tail)!],
         head: orthoNodes[nodeIndex.get(e.head)!],

package/src/layout/neato/multispline.ts

@@ -333,6 +333,18 @@ function chainOf(e: Edge): Edge[] {
   return list;
 }
 
+/**
+ * agwarningf at each genroute failure site (Graphviz prefixes "Warning: ");
+ * returns genroute's failure code 1.
+ * @see multispline.c:genroute
+ */
+function warnNoControlPoints(e: Edge): number {
+  console.warn(
+    `Warning: Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
+  );
+  return 1;
+}
+
 /**
  * Generate splines for e and cohorts through the corridor polygon.
  * Edges run from polygon index 0 to t. Returns 0 on success.
@@ -350,7 +362,7 @@ function genroute(
   const head = e.head;
 
   const pl = shortestPath({ ps: trip.ps }, eps);
-  if (pl === null) return 1;
+  if (pl === null) return warnNoControlPoints(e);
 
   if (pl.length === 2) {
     // C passes doPolyline (0/1) AS the edge type — so the polyline case
@@ -365,7 +377,7 @@ function genroute(
 
   if (mult === 1 || concentrate) {
     const spl = routeMember(trip.ps, t, pl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(e);
     finishEdge(e, spl, e.head !== head);
     return 0;
   }
@@ -374,7 +386,7 @@ function genroute(
   const cpts: Point[][] = [];
   for (let i = 0; i + 2 < pl.length; i++) {
     const cp = mkCtrlPts(t, mult + 1, pl[i]!, pl[i + 1]!, pl[i + 2]!, trip);
-    if (cp === null) return 1;
+    if (cp === null) return warnNoControlPoints(e);
     cpts.push(cp);
   }
 
@@ -390,10 +402,10 @@ function genroute(
       poly[pn - j] = cpts[j - 1]![i + 1]!;
     }
     const mmpl = shortestPath({ ps: poly }, eps);
-    if (mmpl === null) return 1;
+    if (mmpl === null) return warnNoControlPoints(cur);
 
     const spl = routeMember(poly, pl.length - 1, mmpl, doPolyline);
-    if (spl === null) return 1;
+    if (spl === null) return warnNoControlPoints(cur);
     finishEdge(cur, spl, cur.head !== head);
 
     cur = cur.info.to_virt;

package/src/layout/pack/poly-pack.ts

@@ -17,6 +17,7 @@ import type { PackInfo } from './types.js';
 import { spiralSearch } from './spiral-search.js';
 import { gvQsort } from '../../util/bsd-qsort.js';
 import { cround } from '../../common/arith.js';
+import { PointSet } from '../../common/pointset.js';
 import { d2i } from '../../util/math.js';
 
 /** Max average polyomino size constant. @see lib/pack/pack.c:C */
@@ -29,33 +30,6 @@ export interface GInfo {
   index: number;
 }
 
-/** A set of occupied grid cells (string-keyed for O(1) lookup). */
-export type PointSet = Set<string>;
-
-/**
- * Encode a grid point as a canonical string key.
- *
- * C keys its PointSet dict on the `pointf` cell itself (exact double compare,
- * no rounding). Every cell coordinate reaching here is an exact integer grid
- * index produced by genBox's `cround(cval(...))`, so the rounding mode is
- * unobservable; `cround` is used only so no `Math.round` survives in a layout
- * coordinate path.
- * @see lib/common/pointset.h:45 (insertPS/inPS take pointf)
- */
-export function psKey(x: number, y: number): string {
-  return `${cround(x)},${cround(y)}`;
-}
-
-/** Check if a cell is in the point set. @see lib/pack/pack.c:inPS */
-export function inPS(ps: PointSet, p: Point): boolean {
-  return ps.has(psKey(p.x, p.y));
-}
-
-/** Insert a cell into the point set. @see lib/pack/pack.c:insertPS */
-export function insertPS(ps: PointSet, p: Point): void {
-  ps.add(psKey(p.x, p.y));
-}
-
 /**
  * Compute the polyomino grid step size (positive root of quadratic).
  *
@@ -167,7 +141,7 @@ export interface PlaceCtx {
 export function hasCollision(cells: Point[], dx: number, dy: number, ps: PointSet): boolean {
   for (let i = 0; i < cells.length; i++) {
     const cell = cells[i];
-    if (cell !== undefined && inPS(ps, { x: cell.x + dx, y: cell.y + dy })) return true;
+    if (cell !== undefined && ps.inPS({ x: cell.x + dx, y: cell.y + dy })) return true;
   }
   return false;
 }
@@ -175,12 +149,12 @@ export function hasCollision(cells: Point[], dx: number, dy: number, ps: PointSe
 /**
  * Mark all shifted cells as occupied in the point set.
  *
- * @see lib/pack/pack.c:fits (cell insertion loop)
+ * @see lib/pack/pack.c:fits (cell insertion loop; `addPS`)
  */
 export function markCells(cells: Point[], dx: number, dy: number, ps: PointSet): void {
   for (let i = 0; i < cells.length; i++) {
     const cell = cells[i];
-    if (cell !== undefined) insertPS(ps, { x: cell.x + dx, y: cell.y + dy });
+    if (cell !== undefined) ps.addPS(cell.x + dx, cell.y + dy);
   }
 }
 
@@ -268,7 +242,7 @@ export function polyRects(ng: number, bbs: Box[], pinfo: PackInfo): Point[] | nu
   // perimeter, so the tie order of equal-perimeter components is decided by libc
   // qsort, not insertion order. Match it. @see util/bsd-qsort.ts
   const sorted = gvQsort([...infos], cmpByGPerimeter);
-  const ctx: PlaceCtx = { ps: new Set(), step, bbs };
+  const ctx: PlaceCtx = { ps: new PointSet(), step, bbs };
   const places: Point[] = new Array<Point>(ng).fill({ x: 0, y: 0 });
   for (let i = 0; i < sorted.length; i++) {
     const info = sorted[i];

package/src/pathplan/shortest.ts

@@ -250,9 +250,22 @@ class ShortestHelper {
     ShortestHelper.connectAll(tris);
     const ftrii = ShortestHelper.findTri(tris, eps[0]);
     const ltrii = ShortestHelper.findTri(tris, eps[1]);
-    if (ftrii === NO_TRI || ltrii === NO_TRI) return null;
+    // C finds the first triangle, fails if none, and only then looks for the
+    // last one (shortest.c:178-204), so the two messages are exclusive.
+    if (ftrii === NO_TRI) {
+      console.warn('source point not in any triangle');
+      return null;
+    }
+    if (ltrii === NO_TRI) {
+      console.warn('destination point not in any triangle');
+      return null;
+    }
     if (ftrii === ltrii) return [eps[0], eps[1]];
-    if (!ShortestHelper.markPath(tris, ftrii, ltrii)) return [eps[0], eps[1]];
+    if (!ShortestHelper.markPath(tris, ftrii, ltrii)) {
+      console.warn('cannot find triangle path');
+      // C: a straight line is better than failing
+      return [eps[0], eps[1]];
+    }
     const epnls: [PNL, PNL] = [{ pp: eps[0], link: null }, { pp: eps[1], link: null }];
     const dq = ShortestHelper.initDeque(pnlps.length);
     ShortestHelper.add2dq(dq, DQ_FRONT, epnls[0]);