ntk 8.17.8 → 8.18.1

package/lib/trapezoid.js

@@ -1,13 +1,25 @@
 // Trapezoidal decomposition of flattened closed polygons (non-zero winding
 // by default, even-odd optionally), producing XRender AddTraps data.
 //
-// A horizontal slab sweep: slab boundaries are the sorted unique vertex y
-// coordinates, so edges never cross inside a slab (self-intersecting input —
-// e.g. overlapping composite-glyph contours — degrades gracefully to a
-// near-correct fill instead of failing). Spans where the winding number is
-// non-zero become trapezoids; a span whose left/right edges continue through
-// consecutive slabs is merged into a single tall trapezoid, which is what
-// keeps the output at roughly one trapezoid per outline edge.
+// A horizontal slab sweep. Slab boundaries are the sorted unique vertex y
+// coordinates, and where two edges cross inside a slab the slab is split at
+// the crossing, so that within every slab the active edges keep one
+// left-to-right order from top to bottom. Spans between them are then true
+// trapezoids, and self-intersecting input — a pentagram, two crossed bars,
+// overlapping composite-glyph contours — is filled exactly by its rule.
+// Spans where the rule says "inside" become trapezoids; a span whose
+// left/right edges continue through consecutive slabs is merged into a
+// single tall trapezoid, which is what keeps the output at roughly one
+// trapezoid per outline edge (plus a few per crossing).
+//
+// Crossings are found the way a Bentley-Ottmann sweep finds them: the first
+// change of order below a line is always between two edges adjacent on it,
+// so each step takes the earliest crossing of an adjacent pair whose order
+// is reversed at the slab's bottom, cuts there and swaps the pair. Every
+// swap removes one inversion of the bottom order, so the loop ends however
+// the floats round. Differences within a hair of the input's magnitude —
+// collinear edges, crossings right at a slab's top or bottom — are rounding,
+// not geometry: they cause no split and cut no sliver.
 //
 // Output is the flat number list node-x11's Render.AddTraps expects:
 // 6 values per trapezoid — top spanfix (left x, right x, y) then bottom
@@ -25,7 +37,9 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
   const evenodd = rule === 'evenodd';
   // collect non-horizontal edges, normalized to y0 < y1 with winding dir
   const edges = [];
-  const ys = [];
+  let ys = [];
+  // the largest coordinate magnitude, which sets the rounding noise
+  let reach = 1;
   for (const poly of polys) {
     const n = poly.length / 2;
     for (let i = 0; i < n; ++i) {
@@ -35,24 +49,34 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
       const bx = poly[j * 2] + dx;
       const by = poly[j * 2 + 1] + dy;
       if (ay === by) continue;
+      const slope = (bx - ax) / (by - ay);
       edges.push(
         ay < by
-          ? { x0: ax, y0: ay, x1: bx, y1: by, dir: 1, xa: 0, xb: 0 }
-          : { x0: bx, y0: by, x1: ax, y1: ay, dir: -1, xa: 0, xb: 0 }
+          ? { x0: ax, y0: ay, y1: by, slope, dir: 1, xt: 0, xb: 0, xc: 0 }
+          : { x0: bx, y0: by, y1: ay, slope, dir: -1, xt: 0, xb: 0, xc: 0 }
       );
       ys.push(ay, by);
+      const m = Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by));
+      if (m > reach) reach = m;
     }
   }
   if (edges.length === 0) return out;
+  // ~256 ulps of the largest coordinate: far above what evaluating an edge
+  // at a height rounds by, far below a 16.16 fixed-point step at any
+  // coordinate that fits one
+  const eps = reach * 2 ** -44;
 
-  ys.sort((a, b) => a - b);
+  // a typed array sorts numerically without a comparator call per step
+  ys = Float64Array.from(ys).sort();
   edges.sort((a, b) => a.y0 - b.y0);
 
   const active = [];
   let nextEdge = 0;
-  // spans open from the previous slab, for vertical merging:
-  // { l: leftEdge, r: rightEdge, at: index of the trap in `out` }
+  // spans open from the previous slab, for vertical merging, and the ones
+  // this slab opens: flat [leftEdge, rightEdge, index of the trap in `out`]
+  // triples, two buffers that trade places every slab
   let prevSpans = [];
+  let spans = [];
 
   for (let yi = 0; yi < ys.length - 1; ++yi) {
     const ya = ys[yi];
@@ -60,64 +84,128 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
     if (yb === ya) continue;
 
     // update the active edge list for this slab
-    for (let i = active.length - 1; i >= 0; --i) {
-      if (active[i].y1 <= ya) active.splice(i, 1);
+    let kept = 0;
+    for (let i = 0; i < active.length; ++i) {
+      if (active[i].y1 > ya) active[kept++] = active[i];
     }
+    active.length = kept;
     while (nextEdge < edges.length && edges[nextEdge].y0 <= ya) {
       if (edges[nextEdge].y1 > ya) active.push(edges[nextEdge]);
       nextEdge++;
     }
     if (active.length === 0) {
-      prevSpans = [];
+      prevSpans.length = 0;
       continue;
     }
 
-    // x at slab top/bottom for each active edge; sort left-to-right
-    for (const e of active) {
-      const inv = (e.x1 - e.x0) / (e.y1 - e.y0);
-      e.xa = e.x0 + (ya - e.y0) * inv;
-      e.xb = e.x0 + (yb - e.y0) * inv;
+    // x at slab top/bottom for each active edge; sort left-to-right just
+    // below the top (edges leaving one point go by where they are headed)
+    for (let i = 0; i < active.length; ++i) {
+      const e = active[i];
+      e.xt = e.x0 + (ya - e.y0) * e.slope;
+      e.xb = e.x0 + (yb - e.y0) * e.slope;
+    }
+    // a slab holds a handful of edges, mostly in last slab's order: an
+    // insertion sort, stable as Array#sort is, so the order is the same
+    for (let i = 1; i < active.length; ++i) {
+      const e = active[i];
+      let j = i - 1;
+      while (j >= 0 && (active[j].xt - e.xt || active[j].xb - e.xb) > 0) {
+        active[j + 1] = active[j];
+        --j;
+      }
+      active[j + 1] = e;
     }
-    active.sort((a, b) => a.xa + a.xb - (b.xa + b.xb));
 
-    // emit a span per maximal interior interval; interiority is decided by
-    // the fill rule (non-zero winding, or crossing parity for even-odd)
-    const spans = [];
-    let winding = 0;
-    let crossings = 0;
-    let left = null;
-    for (const e of active) {
-      const wasInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
-      winding += e.dir;
-      crossings++;
-      const isInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
-      if (!wasInside && isInside) {
-        left = e;
-      } else if (wasInside && !isInside && left) {
-        // merge with a span from the previous slab bounded by the same edges
-        let merged = false;
-        for (const p of prevSpans) {
-          if (p.l === left && p.r === e && out[p.at + 5] === ya) {
-            out[p.at + 3] = left.xb;
-            out[p.at + 4] = e.xb;
-            out[p.at + 5] = yb;
-            spans.push(p);
-            merged = true;
-            break;
-          }
+    // cut the slab at each crossing, top to bottom; `y` is where the part
+    // still to emit starts, and `xt` each edge's x there
+    let y = ya;
+    for (;;) {
+      let yc = yb;
+      let k = -1;
+      for (let i = 0; i + 1 < active.length; ++i) {
+        const a = active[i];
+        const b = active[i + 1];
+        // how far `a` ends up right of `b`, and how far left of it it starts
+        const over = a.xb - b.xb;
+        if (!(over > eps)) continue;
+        const gap = b.xt - a.xt;
+        const at = gap > 0 ? y + (yb - y) * (gap / (gap + over)) : y;
+        if (at < yc) {
+          yc = at;
+          k = i;
         }
-        if (!merged && (e.xa > left.xa || e.xb > left.xb)) {
-          spans.push({ l: left, r: e, at: out.length });
-          out.push(left.xa, e.xa, ya, left.xb, e.xb, yb);
+      }
+      if (k < 0 || yc >= yb - eps) {
+        emitSpans(active, y, yb, true, evenodd, prevSpans, spans, out);
+        [prevSpans, spans] = [spans, prevSpans];
+        break;
+      }
+      if (yc > y + eps) {
+        for (let i = 0; i < active.length; ++i) {
+          const e = active[i];
+          e.xc = e.x0 + (yc - e.y0) * e.slope;
         }
-        left = null;
+        emitSpans(active, y, yc, false, evenodd, prevSpans, spans, out);
+        [prevSpans, spans] = [spans, prevSpans];
+        for (let i = 0; i < active.length; ++i) active[i].xt = active[i].xc;
+        y = yc;
       }
+      const a = active[k];
+      active[k] = active[k + 1];
+      active[k + 1] = a;
     }
-    prevSpans = spans;
   }
   return out;
 }
 
+/**
+ * Emit a span per maximal interior interval of the slab `ya`..`yb`;
+ * interiority is decided by the fill rule (non-zero winding, or crossing
+ * parity for even-odd). Each edge is at `xt` at the top, and at the bottom
+ * at `xb` when this is the `last` part of its vertex slab, else at `xc`. A
+ * span bounded by the same two edges as one ending at `ya` extends that
+ * trapezoid instead. The spans go into `spans`, emptied first, for the next
+ * slab to merge with.
+ */
+function emitSpans(active, ya, yb, last, evenodd, prevSpans, spans, out) {
+  spans.length = 0;
+  let winding = 0;
+  let crossings = 0;
+  let left = null;
+  for (let i = 0; i < active.length; ++i) {
+    const e = active[i];
+    const wasInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
+    winding += e.dir;
+    crossings++;
+    const isInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
+    if (!wasInside && isInside) {
+      left = e;
+    } else if (wasInside && !isInside && left) {
+      const lb = last ? left.xb : left.xc;
+      const rb = last ? e.xb : e.xc;
+      // merge with a span from the previous slab bounded by the same edges
+      let merged = false;
+      for (let p = 0; p < prevSpans.length; p += 3) {
+        const at = prevSpans[p + 2];
+        if (prevSpans[p] === left && prevSpans[p + 1] === e && out[at + 5] === ya) {
+          out[at + 3] = lb;
+          out[at + 4] = rb;
+          out[at + 5] = yb;
+          spans.push(left, e, at);
+          merged = true;
+          break;
+        }
+      }
+      if (!merged && (e.xt > left.xt || rb > lb)) {
+        spans.push(left, e, out.length);
+        out.push(left.xt, e.xt, ya, lb, rb, yb);
+      }
+      left = null;
+    }
+  }
+}
+
 /** area covered by a trapezoid list (useful for tests/diagnostics) */
 export function trapArea(traps) {
   let area = 0;