@knowvah/dot-engine 0.1.0

package/src/ortho/maze-channels.ts

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Channel extraction and search for the ortho maze.
+ *
+ * @see lib/ortho/ortho.c:extractHChans, extractVChans, chanSearch
+ */
+
+import type { Cell, Maze, Channel, ChanItem, ChanDict, Paird } from "./types.js";
+import { MZ_HSCAN, MZ_VSCAN, MZ_ISNODE, M_LEFT, M_RIGHT, M_TOP, M_BOTTOM } from "./types.js";
+import { makeGraph } from "./rawgraph.js";
+import { CdtOset } from "./chan-dict.js";
+
+export { makeGraph };
+
+function isNode(cp: Cell): boolean {
+  return (cp.flags & MZ_ISNODE) !== 0;
+}
+
+/** dcmpid: plain double comparison (fcmp). @see lib/ortho/ortho.c:dcmpid */
+function dcmpid(a: number, b: number): number {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+/** New empty two-level channel dict (outer Dtoset keyed by v). */
+export function newChanDict(): ChanDict {
+  return new CdtOset<ChanItem, number>((it) => it.v, dcmpid);
+}
+
+/**
+ * Insert channel cp under line j — C addChan: dtmatch the chanItem for j
+ * (creating it on miss), then dtinsert cp into its inner Dtoset. When the
+ * inner insert finds an "equal" channel (chancmpid containment) it returns
+ * the existing one and the new cp is dropped (C frees it).
+ * @see lib/ortho/ortho.c:addChan
+ */
+function addChan(chdict: ChanDict, cp: Channel, j: number): void {
+  let subd = chdict.match(j);
+  if (!subd) {
+    subd = { v: j, chans: new CdtOset<Channel, Paird>((c) => c.p, chancmpid) };
+    chdict.insert(subd);
+  }
+  subd.chans.insert(cp); // existing-on-containment: cp silently dropped
+}
+
+function moveLeft(cp: Cell): Cell {
+  let cur = cp;
+  while (true) {
+    const np = cur.sides[M_LEFT];
+    if (!np) break;
+    const nextcp = np.cells[0];
+    if (!nextcp || isNode(nextcp)) break;
+    cur = nextcp;
+  }
+  return cur;
+}
+
+function moveRight(cp: Cell): Cell {
+  let cur = cp;
+  while (true) {
+    const np = cur.sides[M_RIGHT];
+    if (!np) break;
+    const nextcp = np.cells[1];
+    if (!nextcp || isNode(nextcp)) break;
+    cur.flags |= MZ_HSCAN;
+    cur = nextcp;
+  }
+  cur.flags |= MZ_HSCAN;
+  return cur;
+}
+
+function moveDown(cp: Cell): Cell {
+  let cur = cp;
+  while (true) {
+    const np = cur.sides[M_BOTTOM];
+    if (!np) break;
+    const nextcp = np.cells[0];
+    if (!nextcp || isNode(nextcp)) break;
+    cur = nextcp;
+  }
+  return cur;
+}
+
+function moveUp(cp: Cell): Cell {
+  let cur = cp;
+  while (true) {
+    const np = cur.sides[M_TOP];
+    if (!np) break;
+    const nextcp = np.cells[1];
+    if (!nextcp || isNode(nextcp)) break;
+    cur.flags |= MZ_VSCAN;
+    cur = nextcp;
+  }
+  cur.flags |= MZ_VSCAN;
+  return cur;
+}
+
+/**
+ * Extract horizontal channels from the maze.
+ * @see lib/ortho/ortho.c:extractHChans
+ */
+export function extractHChans(mp: Maze): ChanDict {
+  const hchans = newChanDict();
+  for (let i = 0; i < mp.ncells; i++) {
+    const cp = mp.cells[i];
+    if (cp.flags & MZ_HSCAN) continue;
+    const cur = moveLeft(cp);
+    const chp: Channel = { p: { p1: cur.bb.LL.x, p2: 0 }, segList: [], G: null, cp: cur };
+    cur.flags |= MZ_HSCAN;
+    const end = moveRight(cur);
+    chp.p.p2 = end.bb.UR.x;
+    addChan(hchans, chp, cur.bb.LL.y);
+  }
+  return hchans;
+}
+
+/**
+ * Extract vertical channels from the maze.
+ * @see lib/ortho/ortho.c:extractVChans
+ */
+export function extractVChans(mp: Maze): ChanDict {
+  const vchans = newChanDict();
+  for (let i = 0; i < mp.ncells; i++) {
+    const cp = mp.cells[i];
+    if (cp.flags & MZ_VSCAN) continue;
+    const cur = moveDown(cp);
+    const chp: Channel = { p: { p1: cur.bb.LL.y, p2: 0 }, segList: [], G: null, cp: cur };
+    cur.flags |= MZ_VSCAN;
+    const end = moveUp(cur);
+    chp.p.p2 = end.bb.UR.y;
+    addChan(vchans, chp, cur.bb.LL.x);
+  }
+  return vchans;
+}
+
+/**
+ * Walk channels exactly as C's assignTracks-family loops do:
+ *   for (l1 = dtflatten(chans); l1; l1 = dtlink(chans,l1))
+ *     for (l2 = dtflatten(lp); l2; l2 = dtlink(lp,l2))
+ * dtflatten right-linearises the splay tree into a sorted chain, and dtlink
+ * follows raw `.right` pointers LIVE. When the loop body performs a
+ * chanSearch (dtmatch), the dict is unflattened and re-splayed mid-walk, so
+ * the `.right` chain the walker follows is rewritten under it — C then
+ * silently SKIPS every channel a rotation moved into a left subtree. This
+ * corrupted-walk behavior is deterministic and load-bearing for the
+ * parallel-edge pass (corpus 1447_1/osage: C visits 157 of 294 channels).
+ * The generator reads `.right` lazily at each resume, reproducing it.
+ * @see lib/ortho/ortho.c:assignTracks, add_p_edges (dtflatten walks)
+ * @see src/ortho/chan-dict.ts (flatten/unflatten mechanics)
+ */
+export function* chansInOrder(chans: ChanDict): Generator<[number, Channel]> {
+  for (let l1 = chans.flatten(); l1 !== null; l1 = l1.right) {
+    const item = l1.obj;
+    for (let l2 = item.chans.flatten(); l2 !== null; l2 = l2.right) {
+      yield [item.v, l2.obj];
+    }
+  }
+}
+
+/**
+ * Interval comparison — faithful port of ortho.c:chancmpid. Two intervals are
+ * "equal" (return 0) when one CONTAINS the other (nested either way); otherwise
+ * the one with the smaller p1 is less. C's chanSearch relies on this so a
+ * segment that extends BEYOND its channel (segment ⊇ channel, e.g. an edge whose
+ * endpoint reaches out to a node/label past the channel's cell) still matches —
+ * a one-directional `chan ⊇ seg` test misses that case and drops the segment.
+ * @see lib/ortho/ortho.c:chancmpid
+ */
+function chancmpid(k1: { p1: number; p2: number }, k2: { p1: number; p2: number }): number {
+  if (k1.p1 > k2.p1) {
+    if (k1.p2 <= k2.p2) return 0;
+    return 1;
+  }
+  if (k1.p1 < k2.p1) {
+    if (k1.p2 >= k2.p2) return 0;
+    return -1;
+  }
+  return 0;
+}
+
+/**
+ * Find the channel whose interval nests with the segment (chancmpid == 0).
+ * Both lookups are C dtmatch calls: they SPLAY the dicts, which is what
+ * corrupts any dtflatten walk in progress (see chansInOrder).
+ * @see lib/ortho/ortho.c:chanSearch
+ */
+export function chanSearch(
+  chans: ChanDict,
+  commCoord: number,
+  p: { p1: number; p2: number },
+): Channel | null {
+  const chani = chans.match(commCoord);
+  if (!chani) return null;
+  return chani.chans.match(p);
+}

package/src/ortho/maze.ts

@@ -0,0 +1,311 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Maze construction — mkMaze, updateWts, markSmall, createSEdges.
+ *
+ * Faithful port of lib/ortho/maze.c.
+ *
+ * @see lib/ortho/maze.c
+ * @see lib/ortho/maze.h
+ */
+
+import type {
+  OrthoBox, OrthoGraph, OrthoNode,
+  Cell, SNode, SEdge, SGraph, Maze,
+} from "./types.js";
+import {
+  MZ_ISNODE, MZ_SMALLV, MZ_SMALLH,
+  M_RIGHT, M_TOP, M_LEFT, M_BOTTOM,
+} from "./types.js";
+import { partition } from "./partition.js";
+import { dfpCmp } from "./trap-types.js";
+import { newChanDict } from "./maze-channels.js";
+import {
+  createSGraph, createSNode, createSEdge,
+  initSEdges, gsave,
+} from "./sgraph.js";
+
+/** @see lib/ortho/maze.c:#define MARGIN 36 */
+export const MARGIN = 36;
+/** @see lib/ortho/maze.c:#define delta 1 */
+const delta = 1;
+/** @see lib/ortho/maze.c:#define mu 500 */
+const mu = 500;
+/** @see lib/ortho/maze.c:#define BIG 16384 */
+export const BIG = 16384;
+
+/**
+ * `w` and the macro result are `double` in C (both call sites declare `hsz`/
+ * `vsz` as `double`) — the expansion is real division, not integer
+ * truncation. Do not add `Math.floor`/`Math.trunc` here.
+ * @see lib/ortho/maze.c:142 #define CHANSZ(w) (((w)-3)/2)
+ */
+export function chanSz(w: number): number {
+  return (w - 3) / 2;
+}
+
+function isSmall(v: number): boolean { return chanSz(v) < 2; }
+function isNode(cp: Cell): boolean { return (cp.flags & MZ_ISNODE) !== 0; }
+
+// ─── updateWts ───────────────────────────────────────────────────────────────
+
+function isBend(g: SGraph, e: SEdge): boolean {
+  return g.nodes[e.v1].isVert !== g.nodes[e.v2].isVert;
+}
+function isHorz(g: SGraph, e: SEdge): boolean { return g.nodes[e.v1].isVert; }
+function updateWt(ep: SEdge, sz: number): void {
+  ep.cnt++;
+  if (ep.cnt > sz) { ep.cnt = 0; ep.weight += BIG; }
+}
+
+/** @see lib/ortho/maze.c:updateWts */
+export function updateWts(g: SGraph, cp: Cell, ep: SEdge): void {
+  const bend = isBend(g, ep);
+  const hsz = chanSz(cp.bb.UR.y - cp.bb.LL.y);
+  const vsz = chanSz(cp.bb.UR.x - cp.bb.LL.x);
+  const minsz = Math.min(hsz, vsz);
+  let i = 0;
+  for (; i < cp.nedges; i++) {
+    const e = cp.edges[i];
+    if (e === null || !isBend(g, e)) break;
+    updateWt(e, minsz);
+  }
+  for (; i < cp.nedges; i++) {
+    const e = cp.edges[i];
+    if (e && (bend || e === ep)) updateWt(e, isHorz(g, e) ? hsz : vsz);
+  }
+}
+
+// ─── markSmall ───────────────────────────────────────────────────────────────
+
+function propagateSmall(start: Cell | null, side: number, flag: number): void {
+  if (!start) return;
+  let ocp: Cell = start;
+  ocp.flags |= flag;
+  while (true) {
+    const onp: SNode | null = ocp.sides[side] as SNode | null;
+    if (!onp) break;
+    const next: Cell | null = (side === M_RIGHT || side === M_TOP)
+      ? onp.cells[1] : onp.cells[0];
+    if (!next || isNode(next)) break;
+    next.flags |= flag;
+    ocp = next;
+  }
+}
+
+function markSmallV(cp: Cell): void {
+  for (let i = 0; i < cp.nsides; i++) {
+    const onp = cp.sides[i];
+    if (!onp || !onp.isVert) continue;
+    if (onp.cells[0] === cp) propagateSmall(onp.cells[1], M_RIGHT, MZ_SMALLV);
+    else propagateSmall(onp.cells[0], M_LEFT, MZ_SMALLV);
+  }
+}
+
+function markSmallH(cp: Cell): void {
+  for (let i = 0; i < cp.nsides; i++) {
+    const onp = cp.sides[i];
+    if (!onp || onp.isVert) continue;
+    if (onp.cells[0] === cp) propagateSmall(onp.cells[1], M_TOP, MZ_SMALLH);
+    else propagateSmall(onp.cells[0], M_BOTTOM, MZ_SMALLH);
+  }
+}
+
+function markSmall(cp: Cell): void {
+  if (isSmall(cp.bb.UR.y - cp.bb.LL.y)) markSmallV(cp);
+  if (isSmall(cp.bb.UR.x - cp.bb.LL.x)) markSmallH(cp);
+}
+
+// ─── createSEdges ────────────────────────────────────────────────────────────
+
+function createSEdges(cp: Cell, g: SGraph): void {
+  const bb = cp.bb;
+  let hwt = delta * (bb.UR.x - bb.LL.x);
+  let vwt = delta * (bb.UR.y - bb.LL.y);
+  let wt = (hwt + vwt) / 2.0 + mu;
+  if (isSmall(bb.UR.y - bb.LL.y) && !(cp.flags & MZ_SMALLV)) { hwt = BIG; wt = BIG; }
+  if (isSmall(bb.UR.x - bb.LL.x) && !(cp.flags & MZ_SMALLH)) { vwt = BIG; wt = BIG; }
+  const L = cp.sides[M_LEFT]; const T = cp.sides[M_TOP];
+  const R = cp.sides[M_RIGHT]; const B = cp.sides[M_BOTTOM];
+  // Same six conditional edges, same order/weights as the C unrolled form.
+  // @see lib/ortho/maze.c:createSEdges
+  const pairs: [SNode | null, SNode | null, number][] = [
+    [L, T, wt], [T, R, wt], [L, B, wt], [B, R, wt], [T, B, vwt], [L, R, hwt],
+  ];
+  for (const [a, b, w] of pairs) {
+    if (a && b) cp.edges[cp.nedges++] = createSEdge(g, a, b, w);
+  }
+}
+
+// ─── search-node dict ─────────────────────────────────────────────────────────
+//
+// Mirrors C's CDT ordered set (Dtoset) keyed by the numeric point `snode.p`
+// with the C_EPS-tolerant `dfp_cmp` comparator — NOT a stringified key. `byX`
+// selects the C disc: vdict (vcmpid) orders by x-then-y, hdict (hcmpid) by
+// y-then-x. Kept sorted so findSVert = dtmatch+dtinsert and the gcell walk =
+// dtmatch+dtnext. @see lib/ortho/maze.c:vcmpid/hcmpid/findSVert
+
+interface PointDict { nodes: SNode[]; byX: boolean }
+
+/** Ordered compare of points (ax,ay) vs (bx,by) per the dict's disc. */
+function pdCmp(byX: boolean, ax: number, ay: number, bx: number, by: number): number {
+  if (byX) { const c = dfpCmp(ax, bx); return c !== 0 ? c : dfpCmp(ay, by); }
+  const c = dfpCmp(ay, by); return c !== 0 ? c : dfpCmp(ax, bx);
+}
+
+/** Binary search for (x,y): { found, idx } — idx is the match or insert point. */
+function pdSearch(pd: PointDict, x: number, y: number): { found: boolean; idx: number } {
+  let lo = 0, hi = pd.nodes.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    const n = pd.nodes[mid]!;
+    const c = pdCmp(pd.byX, n.x, n.y, x, y);
+    if (c === 0) return { found: true, idx: mid };
+    if (c < 0) lo = mid + 1; else hi = mid;
+  }
+  return { found: false, idx: lo };
+}
+
+/** @see lib/ortho/maze.c:findSVert (dtmatch; createSNode + dtinsert on miss) */
+function findSVert(g: SGraph, pd: PointDict, x: number, y: number, isVert: boolean): SNode {
+  const r = pdSearch(pd, x, y);
+  if (r.found) return pd.nodes[r.idx]!;
+  const np = createSNode(g);
+  np.isVert = isVert; np.x = x; np.y = y;
+  pd.nodes.splice(r.idx, 0, np);
+  return np;
+}
+
+// ─── mkMazeGraph helpers ──────────────────────────────────────────────────────
+
+function attachCellSides(
+  mp: Maze, g: SGraph, bb: OrthoBox, vdict: PointDict, hdict: PointDict,
+): void {
+  for (let i = 0; i < mp.ncells; i++) {
+    const cp = mp.cells[i];
+    cp.nsides = 4;
+    cp.sides = [null, null, null, null];
+    if (cp.bb.UR.x < bb.UR.x) {
+      const np = findSVert(g, vdict, cp.bb.UR.x, cp.bb.LL.y, true);
+      np.cells[0] = cp; cp.sides[M_RIGHT] = np;
+    }
+    if (cp.bb.UR.y < bb.UR.y) {
+      const np = findSVert(g, hdict, cp.bb.LL.x, cp.bb.UR.y, false);
+      np.cells[0] = cp; cp.sides[M_TOP] = np;
+    }
+    if (cp.bb.LL.x > bb.LL.x) {
+      const np = findSVert(g, vdict, cp.bb.LL.x, cp.bb.LL.y, true);
+      np.cells[1] = cp; cp.sides[M_LEFT] = np;
+    }
+    if (cp.bb.LL.y > bb.LL.y) {
+      const np = findSVert(g, hdict, cp.bb.LL.x, cp.bb.LL.y, false);
+      np.cells[1] = cp; cp.sides[M_BOTTOM] = np;
+    }
+  }
+}
+
+/**
+ * dtmatch + dtnext walk of one cell edge: start at the node equal to (sx,sy),
+ * then take in-order successors while the scan coord stays below `bound`
+ * (raw `<`, exactly as C). Returns the side nodes in sorted order.
+ * @see lib/ortho/maze.c:mkMazeGraph (the four dtmatch/dtnext loops)
+ */
+function gcellWalk(pd: PointDict, sx: number, sy: number, boundIsX: boolean, bound: number): SNode[] {
+  const out: SNode[] = [];
+  const r = pdSearch(pd, sx, sy);
+  if (!r.found) return out; // dtmatch returned NULL → empty edge
+  for (let i = r.idx; i < pd.nodes.length; i++) {
+    const np = pd.nodes[i]!;
+    if (boundIsX ? !(np.x < bound) : !(np.y < bound)) break;
+    out.push(np);
+  }
+  return out;
+}
+
+/** Append walked side nodes to `sides`, tagging each with the owning gcell. */
+function appendSide(sides: SNode[], found: SNode[], cp: Cell, cellIdx: 0 | 1): void {
+  for (const np of found) { sides.push(np); np.cells[cellIdx] = cp; }
+}
+
+function attachGcellSides(mp: Maze, hdict: PointDict, vdict: PointDict): number {
+  let maxdeg = 0;
+  for (const cp of mp.gcells) {
+    const sides: SNode[] = [];
+    appendSide(sides, gcellWalk(hdict, cp.bb.LL.x, cp.bb.LL.y, true, cp.bb.UR.x), cp, 1); // bottom
+    appendSide(sides, gcellWalk(vdict, cp.bb.LL.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 1); // left
+    appendSide(sides, gcellWalk(hdict, cp.bb.LL.x, cp.bb.UR.y, true, cp.bb.UR.x), cp, 0); // top
+    appendSide(sides, gcellWalk(vdict, cp.bb.UR.x, cp.bb.LL.y, false, cp.bb.UR.y), cp, 0); // right
+    cp.sides = sides;
+    cp.nsides = sides.length;
+    if (cp.nsides > maxdeg) maxdeg = cp.nsides;
+  }
+  return maxdeg;
+}
+
+function mkMazeGraph(mp: Maze, bb: OrthoBox): SGraph {
+  const bound = 4 * mp.ncells;
+  const g = createSGraph(bound + 2);
+  const vdict: PointDict = { nodes: [], byX: true };  // vcmpid: x then y
+  const hdict: PointDict = { nodes: [], byX: false }; // hcmpid: y then x
+  attachCellSides(mp, g, bb, vdict, hdict);
+  const maxdeg = attachGcellSides(mp, hdict, vdict);
+  for (const gc of mp.gcells) markSmall(gc);
+  g.nodes[g.nnodes].index = g.nnodes;
+  g.nodes[g.nnodes + 1].index = g.nnodes + 1;
+  initSEdges(g, maxdeg);
+  for (const cp of mp.cells) createSEdges(cp, g);
+  gsave(g);
+  return g;
+}
+
+// ─── mkMaze ──────────────────────────────────────────────────────────────────
+
+function nodeBb(n: OrthoNode): OrthoBox {
+  // C: w2 = fmax(1, ND_xsize(n)/2.0); bb = ND_coord ± (w2,h2) (maze.c:466-471).
+  // Use the caller-supplied coord/xsize/ysize when present — reconstructing
+  // them from bb re-rounds and shifts cell boundaries by ULPs (see OrthoNode).
+  const w2 = Math.max(1, (n.xsize ?? (n.bb.UR.x - n.bb.LL.x)) / 2);
+  const h2 = Math.max(1, (n.ysize ?? (n.bb.UR.y - n.bb.LL.y)) / 2);
+  const cx = n.coord ? n.coord.x : (n.bb.LL.x + n.bb.UR.x) / 2;
+  const cy = n.coord ? n.coord.y : (n.bb.LL.y + n.bb.UR.y) / 2;
+  return { LL: { x: cx - w2, y: cy - h2 }, UR: { x: cx + w2, y: cy + h2 } };
+}
+
+/** @see lib/ortho/maze.c:mkMaze */
+export function mkMaze(g: OrthoGraph): Maze {
+  const gcells: Cell[] = g.nodes.map((n) => ({
+    flags: MZ_ISNODE, nedges: 0,
+    edges: new Array(6).fill(null) as (SEdge | null)[],
+    nsides: 0, sides: [], bb: nodeBb(n),
+  }));
+  let BB: OrthoBox = {
+    LL: { x: Number.MAX_VALUE, y: Number.MAX_VALUE },
+    UR: { x: -Number.MAX_VALUE, y: -Number.MAX_VALUE },
+  };
+  for (const gc of gcells) {
+    BB = {
+      LL: { x: Math.min(BB.LL.x, gc.bb.LL.x), y: Math.min(BB.LL.y, gc.bb.LL.y) },
+      UR: { x: Math.max(BB.UR.x, gc.bb.UR.x), y: Math.max(BB.UR.y, gc.bb.UR.y) },
+    };
+  }
+  BB = {
+    LL: { x: BB.LL.x - MARGIN, y: BB.LL.y - MARGIN },
+    UR: { x: BB.UR.x + MARGIN, y: BB.UR.y + MARGIN },
+  };
+  const rects = partition(gcells, BB);
+  const cells: Cell[] = rects.map((bb) => ({
+    flags: 0, nedges: 0,
+    edges: new Array(6).fill(null) as (SEdge | null)[],
+    nsides: 0, sides: [], bb,
+  }));
+  const mp: Maze = {
+    ncells: cells.length, ngcells: gcells.length,
+    cells, gcells,
+    sg: createSGraph(0),
+    hchans: newChanDict(), vchans: newChanDict(),
+  };
+  mp.sg = mkMazeGraph(mp, BB);
+  return mp;
+}
+
+/** @see lib/ortho/maze.c:freeMaze */
+export function freeMaze(_mp: Maze): void { /* GC handled */ }