@knowvah/dot-engine 2.3.0 → 2.4.0

package/src/ortho/trap-segment.ts

@@ -198,6 +198,7 @@ export function swapSegEndpoints(s: SegmentT): void {
 
 /**
  * Insert one segment into the trapezoidation.
+ * @returns 0 on success, -1 when threading met an invalid trapezoid (16.1)
  * @see lib/ortho/trapezoid.c:add_segment
  */
 export function addSegment(
@@ -205,7 +206,7 @@ export function addSegment(
   seg: SegmentT[],
   tr: TrapT[],
   qs: QNode[],
-): void {
+): number {
   const s = { ...seg[segnum] };
   let isSwapped = false;
   if (greaterThanOrEq(s.v1, s.v0) && !equalTo(s.v1, s.v0)) {
@@ -214,31 +215,49 @@ export function addSegment(
     isSwapped = true;
   }
 
-  let tfirst: number;
-  if (!inserted(segnum, seg, isSwapped ? LASTPT : FIRSTPT)) {
-    tfirst = insertV0(s, seg, tr, qs, segnum);
-  } else {
-    tfirst = locateEndpoint(s.v0, s.v1, s.root0, seg, qs);
-  }
+  const ctx: ThreadCtx = { s, seg, tr, qs, segnum, tribot: false, isSwapped };
+  const tfirst = firstTrap(ctx);
+  const tlast = lastTrap(ctx);
+  if (threadSegment(ctx, tfirst, tlast) !== 0) return -1;
+  seg[segnum].isInserted = true;
+  return 0;
+}
 
-  let tlast: number;
-  let tribot = false;
-  if (!inserted(segnum, seg, isSwapped ? FIRSTPT : LASTPT)) {
-    tlast = insertV1(s, seg, tr, qs, segnum);
-  } else {
-    tlast = locateEndpoint(s.v1, s.v0, s.root1, seg, qs);
-    tribot = true;
+/** add_segment locals the threading loop reads (one C stack frame). */
+interface ThreadCtx {
+  s: SegmentT; seg: SegmentT[]; tr: TrapT[]; qs: QNode[];
+  segnum: number; tribot: boolean; isSwapped: boolean;
+}
+
+/** add_segment: insert v0 in the tree, or locate it if already present. */
+function firstTrap(c: ThreadCtx): number {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? LASTPT : FIRSTPT)) {
+    return insertV0(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
+  return locateEndpoint(c.s.v0, c.s.v1, c.s.root0, c.seg, c.qs);
+}
 
-  threadSegment(s, seg, tr, qs, segnum, tfirst, tlast, tribot, isSwapped);
-  seg[segnum].isInserted = true;
+/**
+ * add_segment: insert v1 in the tree, or (v1 already present) get the
+ * lowermost intersecting trapezoid and mark the bottom as a triangle.
+ */
+function lastTrap(c: ThreadCtx): number {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? FIRSTPT : LASTPT)) {
+    return insertV1(c.s, c.seg, c.tr, c.qs, c.segnum);
+  }
+  c.tribot = true;
+  return locateEndpoint(c.s.v1, c.s.v0, c.s.root1, c.seg, c.qs);
 }
 
-function threadSegment(
-  s: SegmentT, seg: SegmentT[], tr: TrapT[], qs: QNode[],
-  segnum: number, tfirst: number, tlast: number,
-  tribot: boolean, isSwapped: boolean,
-): void {
+/**
+ * Split every trapezoid s crosses, top to bottom, then merge both sides.
+ * Returns -1 (after C's stderr line) when a crossed trapezoid has no valid
+ * lower neighbour — graphviz 16.1 (3c01aaeb4) returns from add_segment there;
+ * 15.x printed "add_segment: error" and broke out of the loop.
+ * @see lib/ortho/trapezoid.c:add_segment (threading loop)
+ */
+function threadSegment(c: ThreadCtx, tfirst: number, tlast: number): number {
+  const { s, seg, tr, qs, segnum, tribot, isSwapped } = c;
   let tfirstr = INVALID_TRAP;
   let tlastr = INVALID_TRAP;
   let t = tfirst;
@@ -258,12 +277,17 @@ function threadSegment(
     if (equalTo(tr[t].lo, tr[tlast].lo)) tlastr = tn;
 
     const tSav = t; const tnSav = tn;
+    if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) { // error
+      console.error("trapezoid segment construction failed");
+      return -1;
+    }
     t = advanceT(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
     tr[tSav].rseg = segnum; tr[tnSav].lseg = segnum;
   }
 
   mergeTrapezoids(segnum, tfirst, tlast, S_LEFT, tr, qs);
   mergeTrapezoids(segnum, tfirstr, tlastr, S_RIGHT, tr, qs);
+  return 0;
 }
 
 function advanceT(
@@ -271,9 +295,8 @@ function advanceT(
   t: number, tn: number, tlast: number,
   segnum: number, isSwapped: boolean, tribot: boolean,
 ): number {
-  if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
-    return INVALID_TRAP; // error
-  } else if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+  // The "neither below is valid" error case returns from threadSegment first.
+  if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
     handleD0Only(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
     return tr[t].d0;
   } else if (!isValidTrap(tr[t].d0) && isValidTrap(tr[t].d1)) {

package/src/ortho/trapezoid.ts

@@ -31,29 +31,20 @@ export function constructTrapezoids(
   permute: number[],
 ): TrapT[] {
   const qs: QNode[] = [];
-  const tr: TrapT[] = [];
-  // index 0 is a sentinel (invalid trap)
-  tr.push({
-    lseg: 0, rseg: 0,
-    hi: { x: 0, y: 0 }, lo: { x: 0, y: 0 },
-    u0: 0, u1: 0, d0: 0, d1: 0,
-    sink: 0, usave: 0, uside: 0, isValid: false,
-  });
+  const tr: TrapT[] = [sentinelTrap()];
 
   let segi = 0;
   const root = initQueryStructure(permute[segi++], seg, tr, qs);
+  seedRoots(nseg, seg, root);
 
-  for (let i = 1; i <= nseg; i++) {
-    seg[i].root0 = root;
-    seg[i].root1 = root;
-  }
-
+  // C (16.1, 3660b260e): an add_segment failure LIST_FREEs the trapezoid list
+  // and jumps to `done`, so the caller receives an EMPTY list.
   const logstar = mathLogstarN(nseg);
   for (let h = 1; h <= logstar; h++) {
     const lo = mathN(nseg, h - 1) + 1;
     const hi = mathN(nseg, h);
     for (let i = lo; i <= hi; i++) {
-      addSegment(permute[segi++], seg, tr, qs);
+      if (addSegment(permute[segi++], seg, tr, qs) !== 0) return [];
     }
     for (let i = 1; i <= nseg; i++) {
       findNewRoots(i, seg, tr, qs);
@@ -62,12 +53,30 @@ export function constructTrapezoids(
 
   const remaining = mathN(nseg, logstar) + 1;
   for (let i = remaining; i <= nseg; i++) {
-    addSegment(permute[segi++], seg, tr, qs);
+    if (addSegment(permute[segi++], seg, tr, qs) !== 0) return [];
   }
 
   return tr;
 }
 
+/** Index 0 of the trapezoid list is a sentinel (invalid trap). */
+function sentinelTrap(): TrapT {
+  return {
+    lseg: 0, rseg: 0,
+    hi: { x: 0, y: 0 }, lo: { x: 0, y: 0 },
+    u0: 0, u1: 0, d0: 0, d1: 0,
+    sink: 0, usave: 0, uside: 0, isValid: false,
+  };
+}
+
+/** construct_trapezoids: every segment starts at the initial query root. */
+function seedRoots(nseg: number, seg: SegmentT[], root: number): void {
+  for (let i = 1; i <= nseg; i++) {
+    seg[i].root0 = root;
+    seg[i].root1 = root;
+  }
+}
+
 // ─── init_query_structure ─────────────────────────────────────────────────────
 
 import {