@rse/gradia 1.4.2 → 1.4.4

package/dst/gradia-api-render-edge.js

@@ -149,20 +149,43 @@ const fars = (u) => u.hairpin ? (u.mirror ? [u.posIn, u.posOut] : []) : [u.mirro
     entering one if mirrored) cross the track-following segment of b,
     and the near-side stubs of b cross the one of a (a stub touching
     the end of a segment counts too, as it would overlap a corner)  */
-const trackCrossings = (a, b) => {
+const trackCrossings = (a, b, farsA, nearsB) => {
     const within = (u, pos) => pos >= Math.min(u.posIn, u.posOut) && pos <= Math.max(u.posIn, u.posOut);
-    return fars(a).filter((pos) => within(b, pos)).length +
-        nears(b).filter((pos) => within(a, pos)).length;
+    let n = 0;
+    for (const pos of farsA)
+        if (within(b, pos))
+            n++;
+    for (const pos of nearsB)
+        if (within(a, pos))
+            n++;
+    return n;
 };
 /*  the number of collinear overlaps caused by placing user a on a
     nearer track than user b: a far-side stub of a and a near-side stub
     of b at the very same cross-axis position run on top of each other
     between the two tracks (unlike a crossing, which is still readable
     through its hop, an overlap merges the two edges visually)  */
-const trackOverlaps = (a, b) => fars(a).filter((pos) => nears(b).includes(pos)).length;
+const trackOverlaps = (farsA, nearsB) => {
+    let n = 0;
+    for (const pos of farsA)
+        for (const near of nearsB)
+            if (near === pos) {
+                n++;
+                break;
+            }
+    return n;
+};
 /*  the maximum number of users for which the crossing-minimal track
     order is determined exactly (the effort doubles with every user)  */
 const TRACK_EXACT_MAX = 14;
+/*  the maximum number of users for which the local search tries blocks
+    of any length and restarts after every improving move (beyond it,
+    the search is bounded to blocks of at most TRACK_BLOCK_MAX users and
+    at most TRACK_PASSES_MAX passes, as the restarting search grows too
+    fast with hundreds of users)  */
+const TRACK_SEARCH_MAX = 100;
+const TRACK_BLOCK_MAX = 8;
+const TRACK_PASSES_MAX = 100;
 /*  reorder the seeded track users to the order causing the fewest
     overlaps and then the fewest crossings, with ties broken toward the
     seed order: for small user sets exactly, by a dynamic programming
@@ -176,8 +199,18 @@ const minimizeCrossings = (seed) => {
     /*  the weighted cost of placing seed user i before seed user j: the
         overlaps dominate (one outweighs all crossings possible among the
         users, at most three per pair), then the crossings, and finally
-        a seed order inversion breaks ties  */
-    const cost = seed.map((a, i) => seed.map((b, j) => (trackOverlaps(a, b) * 2 * n * n + trackCrossings(a, b)) * n * n + (i > j ? 1 : 0)));
+        a seed order inversion breaks ties (the near-side and far-side
+        stubs of every user are determined once, as the matrix grows
+        quadratically with the users, and the flat matrix is a plain
+        array, so its mostly small integers stay unboxed, unlike in a
+        "Float64Array", whose doubles slow down the local search)  */
+    const nearsOf = seed.map(nears);
+    const farsOf = seed.map(fars);
+    const cost = [];
+    for (let i = 0; i < n; i++)
+        for (let j = 0; j < n; j++)
+            cost.push((trackOverlaps(farsOf[i], nearsOf[j]) * 2 * n * n +
+                trackCrossings(seed[i], seed[j], farsOf[i], nearsOf[j])) * n * n + (i > j ? 1 : 0));
     let order;
     if (n <= TRACK_EXACT_MAX) {
         const best = new Float64Array(1 << n).fill(Infinity);
@@ -191,7 +224,7 @@ const minimizeCrossings = (seed) => {
                 let total = best[rest];
                 for (let v = 0; v < n; v++)
                     if ((rest & (1 << v)) !== 0)
-                        total += cost[v][u];
+                        total += cost[v * n + u];
                 if (total < best[s]) {
                     best[s] = total;
                     last[s] = u;
@@ -210,31 +243,68 @@ const minimizeCrossings = (seed) => {
             run), until no such move remains (a single-user move is
             the block move of length one, while the longer blocks let
             groups of users pass an obstacle which none of its users
-            could pass on its own)  */
+            could pass on its own); for large user sets the search is
+            bounded instead: per block, the best move over the runs
+            behind and ahead of it is applied, and the search continues
+            with the next block instead of restarting  */
         order = seed.map((_, i) => i);
-        for (let improved = true; improved;) {
+        /*  precompute the cost change of swapping two users once:
+            diff[a * n + b] is the cost of placing user a before user b
+            minus the cost of the reverse placement  */
+        const diff = [];
+        for (let a = 0; a < n; a++)
+            for (let b = 0; b < n; b++)
+                diff.push(cost[a * n + b] - cost[b * n + a]);
+        const bounded = n > TRACK_SEARCH_MAX;
+        const maxLen = bounded ? Math.min(n - 1, TRACK_BLOCK_MAX) : n - 1;
+        const passes = bounded ? TRACK_PASSES_MAX : Infinity;
+        for (let improved = true, pass = 0; improved && pass < passes; pass++) {
             improved = false;
-            for (let len = 1; len < n && !improved; len++) {
-                for (let i = 0; i + len <= n && !improved; i++) {
+            for (let len = 1; len <= maxLen; len++) {
+                for (let i = 0; i + len <= n; i++) {
+                    let best = 0;
+                    let target = -1;
+                    let forward = true;
                     let delta = 0;
-                    for (let k = i + len; k < n && !improved; k++) {
+                    for (let k = i + len; k < n; k++) {
+                        const row = order[k] * n;
                         for (let b = i; b < i + len; b++)
-                            delta += cost[order[k]][order[b]] - cost[order[b]][order[k]];
-                        if (delta < 0) {
-                            order.splice(k - len + 1, 0, ...order.splice(i, len));
-                            improved = true;
+                            delta += diff[row + order[b]];
+                        if (delta < best) {
+                            best = delta;
+                            target = k;
+                            forward = true;
+                            if (!bounded)
+                                break;
                         }
                     }
                     delta = 0;
-                    for (let k = i - 1; k >= 0 && !improved; k--) {
+                    for (let k = i - 1; k >= 0; k--) {
+                        if (target >= 0 && !bounded)
+                            break;
+                        const other = order[k];
                         for (let b = i; b < i + len; b++)
-                            delta += cost[order[b]][order[k]] - cost[order[k]][order[b]];
-                        if (delta < 0) {
-                            order.splice(k, 0, ...order.splice(i, len));
-                            improved = true;
+                            delta += diff[order[b] * n + other];
+                        if (delta < best) {
+                            best = delta;
+                            target = k;
+                            forward = false;
+                            if (!bounded)
+                                break;
                         }
                     }
+                    if (target >= 0) {
+                        if (forward)
+                            order.splice(target - len + 1, 0, ...order.splice(i, len));
+                        else
+                            order.splice(target, 0, ...order.splice(i, len));
+                        improved = true;
+                        if (!bounded)
+                            break;
+                    }
                 }
+                if (improved && !bounded)
+                    break;
             }
         }
     }
@@ -298,9 +368,14 @@ export const computeHops = (polys) => {
             const [c, d] = [poly[m], poly[m + 1]];
             if (c[0] !== d[0])
                 continue;
-            verts.push({ owner: j, x: c[0], y1: Math.min(c[1], d[1]), y2: Math.max(c[1], d[1]) });
+            verts.push({ idx: verts.length, owner: j, x: c[0], y1: Math.min(c[1], d[1]), y2: Math.max(c[1], d[1]) });
         }
     });
+    /*  sweep the vertical segments ordered by their position, so every
+        horizontal segment only visits the ones within its own span (found
+        by a binary search), and report the crossing ones in their original
+        order of collection  */
+    const byX = verts.slice().sort((a, b) => a.x - b.x);
     return polys.map((poly, i) => {
         const result = new Map();
         for (let k = 0; k < poly.length - 1; k++) {
@@ -308,14 +383,25 @@ export const computeHops = (polys) => {
             if (a[1] !== b[1])
                 continue;
             const hy = a[1];
-            const hx1 = Math.min(a[0], b[0]);
-            const hx2 = Math.max(a[0], b[0]);
-            const xs = [];
-            for (const v of verts)
-                if (v.owner !== i && v.x > hx1 + 1 && v.x < hx2 - 1 && hy > v.y1 + 1 && hy < v.y2 - 1)
-                    xs.push(v.x);
-            if (xs.length > 0)
-                result.set(k, xs);
+            const lo = Math.min(a[0], b[0]) + 1;
+            const hi = Math.max(a[0], b[0]) - 1;
+            let l = 0;
+            let h = byX.length;
+            while (l < h) {
+                const m = (l + h) >>> 1;
+                if (byX[m].x > lo)
+                    h = m;
+                else
+                    l = m + 1;
+            }
+            const found = [];
+            for (let m = l; m < byX.length && byX[m].x < hi; m++) {
+                const v = byX[m];
+                if (v.owner !== i && hy > v.y1 + 1 && hy < v.y2 - 1)
+                    found.push(v);
+            }
+            if (found.length > 0)
+                result.set(k, found.sort((a, b) => a.idx - b.idx).map((v) => v.x));
         }
         return result;
     });

package/dst/gradia-api-render-svg.js

@@ -43,6 +43,66 @@ const ARITY_BACK = 3;
     segment of its route, as a long segment would otherwise offer far
     more candidate positions than a placement can ever need  */
 const SLIDE_MAX = 16;
+/*  a uniform grid of buckets indexing areas, so a query only visits
+    the areas of the buckets it covers instead of all areas (an area
+    spanning several buckets is visited once only, as every visit
+    stamps it, and the bucket indices are clamped, so even far-off
+    areas stay indexed, merely sharing the outermost buckets)  */
+const BUCKET = 64;
+const GRID_OFF = 1 << 20;
+const GRID_SPAN = 2 * GRID_OFF;
+const areaGrid = () => {
+    const areas = [];
+    const buckets = new Map();
+    let stamps = new Uint32Array(0);
+    let stamp = 0;
+    const bucketOf = (v) => Math.max(-GRID_OFF, Math.min(GRID_OFF - 1, Math.floor(v / BUCKET)));
+    /*  index an area and return its identifier  */
+    const add = (area) => {
+        const id = areas.length;
+        areas.push(area);
+        for (let by = bucketOf(area[1]); by <= bucketOf(area[3]); by++) {
+            for (let bx = bucketOf(area[0]); bx <= bucketOf(area[2]); bx++) {
+                const bucket = buckets.get(bx * GRID_SPAN + by);
+                if (bucket === undefined)
+                    buckets.set(bx * GRID_SPAN + by, [id]);
+                else
+                    bucket.push(id);
+            }
+        }
+        return id;
+    };
+    /*  drop an indexed area  */
+    const remove = (id) => {
+        areas[id] = undefined;
+    };
+    /*  visit every indexed area sharing a bucket with the queried area
+        once, until the visiting function signals to stop  */
+    const visit = (x1, y1, x2, y2, fn) => {
+        if (stamps.length < areas.length) {
+            const grown = new Uint32Array(Math.max(areas.length, 2 * stamps.length));
+            grown.set(stamps);
+            stamps = grown;
+        }
+        stamp++;
+        for (let by = bucketOf(y1); by <= bucketOf(y2); by++) {
+            for (let bx = bucketOf(x1); bx <= bucketOf(x2); bx++) {
+                const bucket = buckets.get(bx * GRID_SPAN + by);
+                if (bucket === undefined)
+                    continue;
+                for (const id of bucket) {
+                    if (stamps[id] === stamp)
+                        continue;
+                    stamps[id] = stamp;
+                    const area = areas[id];
+                    if (area !== undefined && fn(id, area))
+                        return;
+                }
+            }
+        }
+    };
+    return { add, remove, visit };
+};
 /*  track occupied areas (node boxes and already placed labels) to
     let subsequent labels dodge into a collision-free position, plus the
     areas merely reserved for the labels still to be placed, and the
@@ -77,6 +137,19 @@ const labelPlacer = (layout, hops, hopRadius, config) => {
         return boxes;
     });
     const lineCount = lines.reduce((n, boxes) => n + boxes.length, 0);
+    /*  index the edge line boxes, the occupied areas, and the
+        reserved areas, as the placement of every label queries them
+        for all of its candidate boxes  */
+    const lineGrid = areaGrid();
+    const owner = [];
+    lines.forEach((boxes, i) => {
+        for (const o of boxes)
+            owner[lineGrid.add(o)] = i;
+    });
+    const occupiedGrid = areaGrid();
+    for (const o of occupied)
+        occupiedGrid.add(o);
+    const reservedGrid = areaGrid();
     /*  claim the candidate box colliding with the fewest occupied
         areas and, among those, with the fewest edge lines (earlier
         candidates win ties, so the first collision-free one is taken),
@@ -87,14 +160,41 @@ const labelPlacer = (layout, hops, hopRadius, config) => {
         "dodge" unset weighs the lines not at all, as its candidates are
         ordered by a proximity which matters more than a crossed line,
         which the halo of the label keeps readable anyway  */
-    const collisions = (boxes, box) => boxes.filter((o) => box[0] < o[2] && box[2] > o[0] && box[1] < o[3] && box[3] > o[1]).length;
-    const crossings = (box, edge) => {
-        const near = [box[0] - LINE_GAP, box[1] - LINE_GAP, box[2] + LINE_GAP, box[3] + LINE_GAP];
-        return lines.reduce((n, boxes, i) => n + collisions(boxes, i === edge ? box : near), 0);
+    const hit = (o, x1, y1, x2, y2) => x1 < o[2] && x2 > o[0] && y1 < o[3] && y2 > o[1];
+    const collisions = (grid, box) => {
+        let n = 0;
+        grid.visit(box[0], box[1], box[2], box[3], (_, o) => {
+            if (hit(o, box[0], box[1], box[2], box[3]))
+                n++;
+            return false;
+        });
+        return n;
+    };
+    /*  count the edge line boxes a candidate box crosses, but stop
+        counting once the given limit is reached, as the candidate then
+        cannot win anymore (the own lines are tested against the box
+        itself, the foreign ones against the box grown by the clearance,
+        which hence also bounds the buckets to visit)  */
+    const crossings = (box, edge, limit) => {
+        const [x1, y1, x2, y2] = [box[0] - LINE_GAP, box[1] - LINE_GAP, box[2] + LINE_GAP, box[3] + LINE_GAP];
+        let n = 0;
+        lineGrid.visit(x1, y1, x2, y2, (id, o) => {
+            if (owner[id] === edge ? hit(o, box[0], box[1], box[2], box[3]) : hit(o, x1, y1, x2, y2))
+                n++;
+            return n >= limit;
+        });
+        return n;
     };
-    const reserved = [];
+    /*  reserve an area, indexed under its very object, so the claim of
+        the label it is reserved for can release it again  */
+    const reserved = new Map();
     const reserve = (box) => {
-        reserved.push(box);
+        const id = reservedGrid.add(box);
+        const ids = reserved.get(box);
+        if (ids === undefined)
+            reserved.set(box, [id]);
+        else
+            ids.push(id);
     };
     /*  a claim counts the areas reserved for the labels still to come
         like the occupied ones, so an early label yields the position a
@@ -103,15 +203,21 @@ const labelPlacer = (layout, hops, hopRadius, config) => {
         released, as that is the very area it is about to take  */
     const claim = (candidates, edge, dodge = true, own) => {
         if (own !== undefined) {
-            const k = reserved.indexOf(own);
-            if (k >= 0)
-                reserved.splice(k, 1);
+            const id = reserved.get(own)?.shift();
+            if (id !== undefined)
+                reservedGrid.remove(id);
         }
         let box = candidates[0];
         let lowest = Infinity;
         for (const c of candidates) {
-            const score = (collisions(occupied, c) + collisions(reserved, c)) * (lineCount + 1) +
-                (dodge ? crossings(c, edge) : 0);
+            /*  a candidate whose collisions alone already reach the lowest
+                score is skipped, as its line crossings, of which there are
+                at most "lineCount", can never let it win anymore  */
+            let score = (collisions(occupiedGrid, c) + collisions(reservedGrid, c)) * (lineCount + 1);
+            if (score >= lowest)
+                continue;
+            if (dodge)
+                score += crossings(c, edge, lowest - score);
             if (score < lowest) {
                 box = c;
                 lowest = score;
@@ -120,6 +226,7 @@ const labelPlacer = (layout, hops, hopRadius, config) => {
                 break;
         }
         occupied.push(box);
+        occupiedGrid.add(box);
         return box;
     };
     return { claim, reserve, occupied };

package/dst/gradia-api-type-graph.js

@@ -23,6 +23,7 @@ const LOOP_TOP = 52; /*  detour of a self-loop above its node box    */
 /*  node nudging constants  */
 const NUDGE_GAP = 24; /*  min port distance of a nudged node from its gutter tracks  */
 const NUDGE_PASSES = 3; /*  max number of node nudging passes                          */
+const NUDGE_EDGES = 300; /*  max number of edges for which nodes are nudged at all      */
 /*  snap raw node positions onto a discrete grid by clustering the
     distinct X coordinates into columns and Y coordinates into rows  */
 const snapToGrid = (nodes, rawX, rawY) => {
@@ -488,7 +489,11 @@ const routeEdges = (edges, plans, sides, boxW, boxH, cx, cy, grid, config, level
         trackPre.gutY(plans[edge].guts[0], edge) : undefined, level.fixedPort);
     const { chanX, gutY } = assignTrackCoords(edges, plans, portPos, grid, config);
     const polys = routePolys(edges, plans, portPos, boxH, cy, chanX, gutY);
-    const hops = computeHops(polys).reduce((sum, segs) => sum + Array.from(segs.values()).reduce((n, xs) => n + xs.length, 0), 0);
+    let count;
+    const hops = () => {
+        count ??= computeHops(polys).reduce((sum, segs) => sum + Array.from(segs.values()).reduce((n, xs) => n + xs.length, 0), 0);
+        return count;
+    };
     return { portPos, gutY, polys, hops };
 };
 /*  nudge nodes vertically off their row centers to straighten the
@@ -530,12 +535,17 @@ const nudgeNodes = (nodes, edges, plans, col, row, boxH, grid, nrows, dy, route)
         && row.get(edge.source) === row.get(edge.target));
     const jogs = (routing) => edges.filter((_, i) => direct[i]
         && routing.portPos.get(`${i}:s`).y !== routing.portPos.get(`${i}:t`).y).length;
-    const better = (a, b) => a.hops < b.hops || (a.hops === b.hops && jogs(a) < jogs(b));
+    const better = (a, b) => a.hops() < b.hops() || (a.hops() === b.hops() && jogs(a) < jogs(b));
     /*  try, in a few passes, for every node the shifts aligning one of
         its direct edges, and keep the best of the shifts improving the
         routing (all shifts are relative to the current position, which
         already includes the shifts of the previous passes)  */
     let current = route();
+    /*  skip the nudging on large graphs, as every tried shift re-routes
+        all edges, so its effort grows with the node count times the
+        edge count, while it only straightens a few direct edges  */
+    if (edges.length > NUDGE_EDGES)
+        return current;
     for (let pass = 0; pass < NUDGE_PASSES; pass++) {
         let changed = false;
         for (const node of nodes) {