@knowvah/dot-engine 0.1.0

package/src/ortho/trap-query.ts

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Query-structure operations for Seidel trapezoidation:
+ * locate_endpoint, is_left_of, inserted.
+ *
+ * @see lib/ortho/trapezoid.c
+ */
+
+import {
+  T_X, T_Y, T_SINK, FIRSTPT, LASTPT,
+  S_LEFT,
+  fpEqual, equalTo, greaterThan, isValidTrap,
+  cross, TRAP_MAX,
+} from "./trap-types.js";
+import type { SegPoint, SegmentT, TrapT, QNode } from "./trap-types.js";
+
+/**
+ * Test whether point v is to the left of segment segnum.
+ * @see lib/ortho/trapezoid.c:is_left_of
+ */
+export function isLeftOf(
+  segnum: number,
+  seg: SegmentT[],
+  v: SegPoint,
+): boolean {
+  const s = seg[segnum];
+  let area: number;
+  if (greaterThan(s.v1, s.v0)) {
+    if (fpEqual(s.v1.y, v.y)) area = v.x < s.v1.x ? 1.0 : -1.0;
+    else if (fpEqual(s.v0.y, v.y)) area = v.x < s.v0.x ? 1.0 : -1.0;
+    else area = cross(s.v0, s.v1, v);
+  } else {
+    if (fpEqual(s.v1.y, v.y)) area = v.x < s.v1.x ? 1.0 : -1.0;
+    else if (fpEqual(s.v0.y, v.y)) area = v.x < s.v0.x ? 1.0 : -1.0;
+    else area = cross(s.v1, s.v0, v);
+  }
+  return area > 0.0;
+}
+
+/**
+ * Whether the given endpoint of segnum is already inserted.
+ * @see lib/ortho/trapezoid.c:inserted
+ */
+export function inserted(
+  segnum: number,
+  seg: SegmentT[],
+  whichpt: number,
+): boolean {
+  if (whichpt === FIRSTPT) return seg[seg[segnum].prev].isInserted;
+  return seg[seg[segnum].next].isInserted;
+}
+
+/** T_X branch of locateEndpoint. */
+function locateX(
+  v: SegPoint,
+  vo: SegPoint,
+  rptr: QNode,
+  seg: SegmentT[],
+  qs: QNode[],
+): number {
+  if (equalTo(v, seg[rptr.segnum].v0) || equalTo(v, seg[rptr.segnum].v1)) {
+    if (fpEqual(v.y, vo.y)) {
+      return vo.x < v.x
+        ? locateEndpoint(v, vo, rptr.left, seg, qs)
+        : locateEndpoint(v, vo, rptr.right, seg, qs);
+    }
+    return isLeftOf(rptr.segnum, seg, vo)
+      ? locateEndpoint(v, vo, rptr.left, seg, qs)
+      : locateEndpoint(v, vo, rptr.right, seg, qs);
+  }
+  return isLeftOf(rptr.segnum, seg, v)
+    ? locateEndpoint(v, vo, rptr.left, seg, qs)
+    : locateEndpoint(v, vo, rptr.right, seg, qs);
+}
+
+/**
+ * Which trapezoid contains point v?
+ * @see lib/ortho/trapezoid.c:locate_endpoint
+ */
+export function locateEndpoint(
+  v: SegPoint,
+  vo: SegPoint,
+  r: number,
+  seg: SegmentT[],
+  qs: QNode[],
+): number {
+  const rptr = qs[r];
+  switch (rptr.nodetype) {
+    case T_SINK: return rptr.trnum;
+    case T_Y:
+      if (greaterThan(v, rptr.yval)) return locateEndpoint(v, vo, rptr.right, seg, qs);
+      if (equalTo(v, rptr.yval)) {
+        return greaterThan(vo, rptr.yval)
+          ? locateEndpoint(v, vo, rptr.right, seg, qs)
+          : locateEndpoint(v, vo, rptr.left, seg, qs);
+      }
+      return locateEndpoint(v, vo, rptr.left, seg, qs);
+    case T_X: return locateX(v, vo, rptr, seg, qs);
+    default: throw new Error("locateEndpoint: unreachable");
+  }
+}
+
+/**
+ * Merge trapezoids sharing common segments on one side.
+ * @see lib/ortho/trapezoid.c:merge_trapezoids
+ */
+export function mergeTrapezoids(
+  segnum: number,
+  tfirst: number,
+  tlast: number,
+  side: number,
+  tr: TrapT[],
+  qs: QNode[],
+): void {
+  let t = tfirst;
+  while (isValidTrap(t) && greaterThanOrEq(tr[t].lo, tr[tlast].lo)) {
+    let tnext = 0;
+    const cond = checkMergeCond(t, segnum, side, tr, tnext);
+    tnext = cond.tnext;
+    if (cond.match) {
+      if (tr[t].lseg === tr[tnext].lseg && tr[t].rseg === tr[tnext].rseg) {
+        doMerge(t, tnext, tr, qs);
+      } else {
+        t = tnext;
+      }
+    } else {
+      t = tnext;
+    }
+  }
+}
+
+function checkMergeCond(
+  t: number,
+  segnum: number,
+  side: number,
+  tr: TrapT[],
+  _tnext: number,
+): { match: boolean; tnext: number } {
+  let tnext = 0;
+  let match = false;
+  if (side === S_LEFT) {
+    match =
+      (isValidTrap((tnext = tr[t].d0)) && tr[tnext].rseg === segnum) ||
+      (isValidTrap((tnext = tr[t].d1)) && tr[tnext].rseg === segnum);
+  } else {
+    match =
+      (isValidTrap((tnext = tr[t].d0)) && tr[tnext].lseg === segnum) ||
+      (isValidTrap((tnext = tr[t].d1)) && tr[tnext].lseg === segnum);
+  }
+  return { match, tnext };
+}
+
+function doMerge(t: number, tnext: number, tr: TrapT[], qs: QNode[]): void {
+  const ptnext = qs[tr[tnext].sink].parent;
+  if (qs[ptnext].left === tr[tnext].sink) qs[ptnext].left = tr[t].sink;
+  else qs[ptnext].right = tr[t].sink;
+
+  if (isValidTrap((tr[t].d0 = tr[tnext].d0))) {
+    if (tr[tr[t].d0].u0 === tnext) tr[tr[t].d0].u0 = t;
+    else if (tr[tr[t].d0].u1 === tnext) tr[tr[t].d0].u1 = t;
+  }
+  if (isValidTrap((tr[t].d1 = tr[tnext].d1))) {
+    if (tr[tr[t].d1].u0 === tnext) tr[tr[t].d1].u0 = t;
+    else if (tr[tr[t].d1].u1 === tnext) tr[tr[t].d1].u1 = t;
+  }
+  tr[t].lo = tr[tnext].lo;
+  tr[tnext].isValid = false;
+}
+
+// re-export for use by trap-segment.ts
+import { greaterThanOrEq } from "./trap-types.js";
+export { greaterThanOrEq };
+
+export { TRAP_MAX, isValidTrap };

package/src/ortho/trap-segment.ts

@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * add_segment and its helpers for Seidel trapezoidation.
+ *
+ * @see lib/ortho/trapezoid.c:add_segment
+ */
+
+import {
+  TRAP_MAX, INVALID_TRAP, isValidTrap,
+  fpEqual, equalTo, greaterThanOrEq,
+  lessThan, newQNode, newTrap,
+  T_X, T_SINK, T_Y,
+  FIRSTPT, LASTPT, S_LEFT, S_RIGHT,
+} from "./trap-types.js";
+import type { SegPoint, SegmentT, TrapT, QNode } from "./trap-types.js";
+import { isLeftOf, inserted, locateEndpoint, mergeTrapezoids } from "./trap-query.js";
+import { updateTrapezoid } from "./trap-update.js";
+
+// ─── Insert v0 endpoint ───────────────────────────────────────────────────────
+
+export function insertV0(
+  s: SegmentT,
+  seg: SegmentT[],
+  tr: TrapT[],
+  qs: QNode[],
+  segnum: number,
+): number {
+  const tu = locateEndpoint(s.v0, s.v1, s.root0, seg, qs);
+  const tl = newTrap(tr);
+  tr[tl] = { ...tr[tu] };
+  tr[tu].lo = s.v0; tr[tl].hi = s.v0;
+  tr[tu].d0 = tl;   tr[tu].d1 = INVALID_TRAP;
+  tr[tl].u0 = tu;   tr[tl].u1 = INVALID_TRAP;
+  patchLowerNeighbours(tr, tl, tu);
+  wireV0QNodes(tr, qs, tu, tl, segnum, s.v0);
+  return tl;
+}
+
+function patchLowerNeighbours(tr: TrapT[], tl: number, tu: number): void {
+  let d = tr[tl].d0;
+  if (isValidTrap(d) && tr[d].u0 === tu) tr[d].u0 = tl;
+  if (isValidTrap(d) && tr[d].u1 === tu) tr[d].u1 = tl;
+  d = tr[tl].d1;
+  if (isValidTrap(d) && tr[d].u0 === tu) tr[d].u0 = tl;
+  if (isValidTrap(d) && tr[d].u1 === tu) tr[d].u1 = tl;
+}
+
+function wireV0QNodes(
+  tr: TrapT[], qs: QNode[],
+  tu: number, tl: number,
+  segnum: number, yval: SegPoint,
+): void {
+  const i1 = newQNode(qs); const i2 = newQNode(qs);
+  const sk = tr[tu].sink;
+  qs[sk].nodetype = T_Y; qs[sk].yval = yval;
+  qs[sk].segnum = segnum; qs[sk].left = i2; qs[sk].right = i1;
+  qs[i1].nodetype = T_SINK; qs[i1].trnum = tu; qs[i1].parent = sk;
+  qs[i2].nodetype = T_SINK; qs[i2].trnum = tl; qs[i2].parent = sk;
+  tr[tu].sink = i1; tr[tl].sink = i2;
+}
+
+// ─── Insert v1 endpoint ───────────────────────────────────────────────────────
+
+export function insertV1(
+  s: SegmentT,
+  seg: SegmentT[],
+  tr: TrapT[],
+  qs: QNode[],
+  segnum: number,
+): number {
+  const tu = locateEndpoint(s.v1, s.v0, s.root1, seg, qs);
+  const tl = newTrap(tr);
+  tr[tl] = { ...tr[tu] };
+  tr[tu].lo = s.v1; tr[tl].hi = s.v1;
+  tr[tu].d0 = tl;   tr[tu].d1 = INVALID_TRAP;
+  tr[tl].u0 = tu;   tr[tl].u1 = INVALID_TRAP;
+  patchLowerNeighbours(tr, tl, tu);
+  wireV0QNodes(tr, qs, tu, tl, segnum, s.v1);
+  return tu;
+}
+
+// ─── Tribot handlers ──────────────────────────────────────────────────────────
+
+function tribotD0(
+  tr: TrapT[], seg: SegmentT[], s: SegmentT,
+  segnum: number, t: number, tn: number, isSwapped: boolean,
+): void {
+  const tmp = isSwapped ? seg[segnum].prev : seg[segnum].next;
+  if (tmp > 0 && isLeftOf(tmp, seg, s.v0)) {
+    tr[tr[t].d0].u0 = t; tr[tn].d0 = TRAP_MAX; tr[tn].d1 = TRAP_MAX;
+  } else {
+    tr[tr[tn].d0].u1 = tn; tr[t].d0 = TRAP_MAX; tr[t].d1 = TRAP_MAX;
+  }
+}
+
+function tribotD1(
+  tr: TrapT[], seg: SegmentT[], s: SegmentT,
+  segnum: number, t: number, tn: number, isSwapped: boolean,
+): void {
+  const tmp = isSwapped ? seg[segnum].prev : seg[segnum].next;
+  if (tmp > 0 && isLeftOf(tmp, seg, s.v0)) {
+    tr[tr[t].d1].u0 = t; tr[tn].d0 = TRAP_MAX; tr[tn].d1 = TRAP_MAX;
+  } else {
+    tr[tr[tn].d1].u1 = tn; tr[t].d0 = TRAP_MAX; tr[t].d1 = TRAP_MAX;
+  }
+}
+
+// ─── handleD0Only / handleD1Only ─────────────────────────────────────────────
+
+export function handleD0Only(
+  s: SegmentT, seg: SegmentT[], tr: TrapT[],
+  t: number, tn: number, tlast: number,
+  segnum: number, isSwapped: boolean, tribot: boolean,
+): void {
+  updateTrapezoid(s, seg, tr, t, tn);
+  if (atBottom(tr, t, tlast) && tribot) {
+    tribotD0(tr, seg, s, segnum, t, tn, isSwapped);
+  } else {
+    patchUsave(tr, tr[t].d0, t, tn);
+    tr[tr[t].d0].u0 = t; tr[tr[t].d0].u1 = tn;
+  }
+}
+
+export function handleD1Only(
+  s: SegmentT, seg: SegmentT[], tr: TrapT[],
+  t: number, tn: number, tlast: number,
+  segnum: number, isSwapped: boolean, tribot: boolean,
+): void {
+  updateTrapezoid(s, seg, tr, t, tn);
+  if (atBottom(tr, t, tlast) && tribot) {
+    tribotD1(tr, seg, s, segnum, t, tn, isSwapped);
+  } else {
+    patchUsave(tr, tr[t].d1, t, tn);
+    tr[tr[t].d1].u0 = t; tr[tr[t].d1].u1 = tn;
+  }
+}
+
+function atBottom(tr: TrapT[], t: number, tlast: number): boolean {
+  return fpEqual(tr[t].lo.y, tr[tlast].lo.y) &&
+         fpEqual(tr[t].lo.x, tr[tlast].lo.x);
+}
+
+function patchUsave(tr: TrapT[], d: number, t: number, tn: number): void {
+  if (isValidTrap(tr[d].u0) && isValidTrap(tr[d].u1)) {
+    if (tr[d].u0 === t) { tr[d].usave = tr[d].u1; tr[d].uside = S_LEFT; }
+    else { tr[d].usave = tr[d].u0; tr[d].uside = S_RIGHT; }
+  }
+}
+
+// ─── handleBothD ─────────────────────────────────────────────────────────────
+
+export function handleBothD(
+  s: SegmentT, seg: SegmentT[], tr: TrapT[],
+  t: number, tn: number, tlast: number, tribot: boolean,
+): number {
+  const i_d0 = computeID0(s, tr[t].lo);
+  updateTrapezoid(s, seg, tr, t, tn);
+  return routeBothD(tr, t, tn, tlast, tribot, i_d0);
+}
+
+function computeID0(s: SegmentT, lo: SegPoint): boolean {
+  if (fpEqual(lo.y, s.v0.y)) return lo.x > s.v0.x;
+  const yt = (lo.y - s.v0.y) / (s.v1.y - s.v0.y);
+  const tmppt: SegPoint = { y: lo.y, x: s.v0.x + yt * (s.v1.x - s.v0.x) };
+  return lessThan(tmppt, lo);
+}
+
+function routeBothD(
+  tr: TrapT[], t: number, tn: number,
+  tlast: number, tribot: boolean, i_d0: boolean,
+): number {
+  if (atBottom(tr, t, tlast) && tribot) {
+    tr[tr[t].d0].u0 = t; tr[tr[t].d0].u1 = TRAP_MAX;
+    tr[tr[t].d1].u0 = tn; tr[tr[t].d1].u1 = TRAP_MAX;
+    tr[tn].d0 = tr[t].d1; tr[t].d1 = TRAP_MAX; tr[tn].d1 = TRAP_MAX;
+    return tr[t].d1;
+  } else if (i_d0) {
+    tr[tr[t].d0].u0 = t; tr[tr[t].d0].u1 = tn;
+    tr[tr[t].d1].u0 = tn; tr[tr[t].d1].u1 = TRAP_MAX;
+    tr[t].d1 = TRAP_MAX;
+    return tr[t].d0;
+  } else {
+    tr[tr[t].d0].u0 = t; tr[tr[t].d0].u1 = TRAP_MAX;
+    tr[tr[t].d1].u0 = t; tr[tr[t].d1].u1 = tn;
+    tr[tn].d0 = tr[t].d1; tr[tn].d1 = TRAP_MAX;
+    return tr[t].d1;
+  }
+}
+
+// ─── swapPt ───────────────────────────────────────────────────────────────────
+
+export function swapSegEndpoints(s: SegmentT): void {
+  const tv = s.v0; s.v0 = s.v1; s.v1 = tv;
+  const tr = s.root0; s.root0 = s.root1; s.root1 = tr;
+}
+
+// ─── add_segment ─────────────────────────────────────────────────────────────
+
+/**
+ * Insert one segment into the trapezoidation.
+ * @see lib/ortho/trapezoid.c:add_segment
+ */
+export function addSegment(
+  segnum: number,
+  seg: SegmentT[],
+  tr: TrapT[],
+  qs: QNode[],
+): void {
+  const s = { ...seg[segnum] };
+  let isSwapped = false;
+  if (greaterThanOrEq(s.v1, s.v0) && !equalTo(s.v1, s.v0)) {
+    // C: if (greater_than(s.v1, s.v0)) — swap so v0 is higher
+    swapSegEndpoints(s);
+    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);
+  }
+
+  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;
+  }
+
+  threadSegment(s, seg, tr, qs, segnum, tfirst, tlast, tribot, isSwapped);
+  seg[segnum].isInserted = true;
+}
+
+function threadSegment(
+  s: SegmentT, seg: SegmentT[], tr: TrapT[], qs: QNode[],
+  segnum: number, tfirst: number, tlast: number,
+  tribot: boolean, isSwapped: boolean,
+): void {
+  let tfirstr = INVALID_TRAP;
+  let tlastr = INVALID_TRAP;
+  let t = tfirst;
+
+  while (isValidTrap(t) && greaterThanOrEq(tr[t].lo, tr[tlast].lo)) {
+    const sk = tr[t].sink;
+    const i1 = newQNode(qs); const i2 = newQNode(qs);
+    qs[sk].nodetype = T_X; qs[sk].segnum = segnum;
+    qs[sk].left = i1; qs[sk].right = i2;
+    qs[i1].nodetype = T_SINK; qs[i1].trnum = t; qs[i1].parent = sk;
+    const tn = newTrap(tr);
+    tr[tn] = { ...tr[t] }; tr[tn].isValid = true;
+    tr[t].sink = i1; tr[tn].sink = i2;
+    qs[i2].nodetype = T_SINK; qs[i2].trnum = tn; qs[i2].parent = sk;
+
+    if (t === tfirst) tfirstr = tn;
+    if (equalTo(tr[t].lo, tr[tlast].lo)) tlastr = tn;
+
+    const tSav = t; const tnSav = tn;
+    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);
+}
+
+function advanceT(
+  s: SegmentT, seg: SegmentT[], tr: TrapT[],
+  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)) {
+    handleD0Only(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
+    return tr[t].d0;
+  } else if (!isValidTrap(tr[t].d0) && isValidTrap(tr[t].d1)) {
+    handleD1Only(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
+    return tr[t].d1;
+  } else {
+    return handleBothD(s, seg, tr, t, tn, tlast, tribot);
+  }
+}
+
+// ─── find_new_roots ───────────────────────────────────────────────────────────
+
+/**
+ * Update root pointers for each segment endpoint after a batch of insertions.
+ * @see lib/ortho/trapezoid.c:find_new_roots
+ */
+export function findNewRoots(
+  segnum: number,
+  seg: SegmentT[],
+  tr: TrapT[],
+  qs: QNode[],
+): void {
+  const s = seg[segnum];
+  if (s.isInserted) return;
+  s.root0 = tr[locateEndpoint(s.v0, s.v1, s.root0, seg, qs)].sink;
+  s.root1 = tr[locateEndpoint(s.v1, s.v0, s.root1, seg, qs)].sink;
+}

package/src/ortho/trap-types.ts

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Trapezoid types and floating-point helpers for Seidel trapezoidation.
+ *
+ * @see lib/ortho/trap.h
+ */
+
+/** Tolerance for floating-point equality. @see lib/ortho/trap.h:C_EPS */
+export const C_EPS = 1e-7;
+
+/** Sentinel for unset trap indices — mirrors C SIZE_MAX. */
+export const TRAP_MAX = Number.MAX_SAFE_INTEGER;
+/** Sentinel for invalid/absent trap — mirrors C 0. */
+export const INVALID_TRAP = 0;
+
+export const S_LEFT = 1;
+export const S_RIGHT = 2;
+
+export const T_X = 1;
+export const T_Y = 2;
+export const T_SINK = 3;
+
+export const FIRSTPT = 1;
+export const LASTPT = 2;
+
+// ─── Point / segment / trapezoid structures ───────────────────────────────────
+
+export interface SegPoint {
+  x: number;
+  y: number;
+}
+
+/**
+ * A polygon boundary segment.
+ * @see lib/ortho/trap.h:segment_t
+ */
+export interface SegmentT {
+  v0: SegPoint;
+  v1: SegPoint;
+  isInserted: boolean;
+  root0: number;
+  root1: number;
+  next: number;
+  prev: number;
+}
+
+/**
+ * A trapezoid in the decomposition.
+ * @see lib/ortho/trap.h:trap_t
+ */
+export interface TrapT {
+  lseg: number;
+  rseg: number;
+  hi: SegPoint;
+  lo: SegPoint;
+  u0: number;
+  u1: number;
+  d0: number;
+  d1: number;
+  sink: number;
+  usave: number;
+  uside: number;
+  isValid: boolean;
+}
+
+/** Query-tree node. */
+export interface QNode {
+  nodetype: number;
+  segnum: number;
+  yval: SegPoint;
+  trnum: number;
+  parent: number;
+  left: number;
+  right: number;
+}
+
+// ─── Validity check ───────────────────────────────────────────────────────────
+
+/** @see lib/ortho/trap.h:is_valid_trap */
+export function isValidTrap(index: number): boolean {
+  return index !== INVALID_TRAP && index !== TRAP_MAX;
+}
+
+// ─── Floating-point helpers ───────────────────────────────────────────────────
+
+/** @see lib/ortho/trap.h:fp_equal */
+export function fpEqual(s: number, t: number): boolean {
+  return Math.abs(s - t) <= C_EPS;
+}
+
+/** @see lib/ortho/trap.h:dfp_cmp */
+export function dfpCmp(f1: number, f2: number): number {
+  const d = f1 - f2;
+  if (d < -C_EPS) return -1;
+  if (d > C_EPS) return 1;
+  return 0;
+}
+
+/** @see lib/ortho/trap.h:equal_to */
+export function equalTo(v0: SegPoint, v1: SegPoint): boolean {
+  return fpEqual(v0.y, v1.y) && fpEqual(v0.x, v1.x);
+}
+
+/** @see lib/ortho/trap.h:greater_than */
+export function greaterThan(v0: SegPoint, v1: SegPoint): boolean {
+  return v0.y > v1.y + C_EPS
+    ? true
+    : v0.y < v1.y - C_EPS
+      ? false
+      : v0.x > v1.x;
+}
+
+export function greaterThanOrEq(v0: SegPoint, v1: SegPoint): boolean {
+  return greaterThan(v0, v1) || equalTo(v0, v1);
+}
+
+export function lessThan(v0: SegPoint, v1: SegPoint): boolean {
+  return !greaterThanOrEq(v0, v1);
+}
+
+export function maxPt(v0: SegPoint, v1: SegPoint): SegPoint {
+  if (v0.y > v1.y + C_EPS) return v0;
+  if (fpEqual(v0.y, v1.y)) return v0.x > v1.x + C_EPS ? v0 : v1;
+  return v1;
+}
+
+export function minPt(v0: SegPoint, v1: SegPoint): SegPoint {
+  if (v0.y < v1.y - C_EPS) return v0;
+  if (fpEqual(v0.y, v1.y)) return v0.x < v1.x ? v0 : v1;
+  return v1;
+}
+
+// ─── Geometry helpers ─────────────────────────────────────────────────────────
+
+export function cross(v0: SegPoint, v1: SegPoint, v2: SegPoint): number {
+  return (v1.x - v0.x) * (v2.y - v0.y) - (v1.y - v0.y) * (v2.x - v0.x);
+}
+
+// ─── Array helpers ────────────────────────────────────────────────────────────
+
+export function newQNode(qs: QNode[]): number {
+  qs.push({ nodetype: 0, segnum: 0, yval: { x: 0, y: 0 }, trnum: 0, parent: 0, left: 0, right: 0 });
+  return qs.length - 1;
+}
+
+export function newTrap(tr: TrapT[]): number {
+  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 });
+  return tr.length - 1;
+}
+
+// ─── Math helpers ─────────────────────────────────────────────────────────────
+
+/**
+ * Number of times log₂ must be applied before result < 1.
+ * @see lib/ortho/trapezoid.c:math_logstar_n
+ */
+export function mathLogstarN(n: number): number {
+  let i = 0;
+  for (let v = n; v >= 1; i++) v = Math.log2(v);
+  return i - 1;
+}
+
+/**
+ * ceil(n / log^(h)(n))
+ * @see lib/ortho/trapezoid.c:math_N
+ */
+export function mathN(n: number, h: number): number {
+  let v = n;
+  for (let i = 0; i < h; i++) v = Math.log2(v);
+  return Math.ceil(n / v);
+}