@yuneta/gobj-ui 7.23.155 → 7.23.157

package/src/treedb_elbow.test.js

@@ -7,10 +7,8 @@
  ***********************************************************************/
 import { describe, test, expect } from "vitest";
 import {
-    elbow_lane, elbow_points, elbow_route, elbow_path_hits, elbow_rank, elbow_combs,
-    curve_hits, rounded_path, ELBOW_STEP, ELBOW_CLEAR,
+    elbow_lane, elbow_points, elbow_route, elbow_path_hits, ELBOW_STEP, ELBOW_CLEAR,
 } from "./treedb_elbow.js";
-import { layout_compact } from "./treedb_layout.js";
 
 /*  Two cards 100x40: A on top, B one row below it.  */
 const A = {x1: 0, y1: 0, x2: 100, y2: 40};
@@ -167,239 +165,6 @@ describe("the route round the other cards", () => {
     });
 });
 
-describe("edges sharing an end are staggered", () => {
-    test("the rank is farthest first, a tie to the edge made first", () => {
-        let items = [{id: "e-3", span: 10}, {id: "e-1", span: 300}, {id: "e-2", span: 10}];
-        expect(elbow_rank(items, "e-1")).toEqual({rank: 0, count: 3});
-        expect(elbow_rank(items, "e-2")).toEqual({rank: 1, count: 3});
-        expect(elbow_rank(items, "e-3")).toEqual({rank: 2, count: 3});
-    });
-
-    /*  One parent on top (port at x 50, bottom at 40) and a row of
-     *  children below (tops at 130).  */
-    const P = {x1: 0, y1: 0, x2: 100, y2: 40};
-    const PORT = [50, 40];
-    const KIDS = [50, 160, 290, 420, -120].map((x, i) => ({
-        id: `e-${i + 1}`, x: x, box: {x1: x - 50, y1: 130, x2: x + 50, y2: 170},
-    }));
-    const channel_of = (kid) => {
-        let items = KIDS.map((k) => ({id: k.id, span: Math.abs(k.x - PORT[0])}));
-        let dep = elbow_rank(items, kid.id);
-        return elbow_points(PORT, [kid.x, 130], P, kid.box, 0, true, {dep: dep})[0][1];
-    };
-
-    test("the children of one port turn each at its own height, inside the channel", () => {
-        let ys = KIDS.map(channel_of);
-        expect(new Set(ys).size).toBe(KIDS.length);
-        for(let y of ys) {
-            expect(y).toBeGreaterThan(40);
-            expect(y).toBeLessThan(130);
-        }
-    });
-
-    test("the farthest turns highest, and the lines of one port do not cross", () => {
-        let y = Object.fromEntries(KIDS.map((k) => [k.id, channel_of(k)]));
-        expect(y["e-4"]).toBeLessThan(y["e-2"]);        /*  420 is farther than 160  */
-        /*  A crossing: one edge's drop (at its child's x, from its turn
-         *  down to the row) cut by another's run (from the port to its
-         *  child, at its own turn).  */
-        for(let a of KIDS) {
-            for(let b of KIDS) {
-                if(a === b) {
-                    continue;
-                }
-                let lo = Math.min(PORT[0], b.x);
-                let hi = Math.max(PORT[0], b.x);
-                let cuts = a.x > lo && a.x < hi && y[b.id] > y[a.id] && y[b.id] < 130;
-                expect(cuts).toBe(false);
-            }
-        }
-    });
-
-    test("the parents of one card: the farthest turns lowest, and they do not cross", () => {
-        /*  Parents on top at these x (port at the middle of each bottom),
-         *  one child below at x 200 whose fkeys all enter at its top.  */
-        const C = {x1: 150, y1: 130, x2: 250, y2: 170};
-        const T0 = [200, 130];
-        const PARENTS = [0, 120, 330, 560].map((x, i) => ({id: `p-${i + 1}`, x: x}));
-        let items = PARENTS.map((p) => ({id: p.id, span: Math.abs(p.x - T0[0])}));
-        let y = {};
-        for(let p of PARENTS) {
-            let box = {x1: p.x - 50, y1: 0, x2: p.x + 50, y2: 40};
-            let arr = elbow_rank(items, p.id);
-            y[p.id] = elbow_points([p.x, 40], T0, box, C, 0, true, {arr: arr})[0][1];
-        }
-        expect(new Set(Object.values(y)).size).toBe(PARENTS.length);
-        expect(y["p-4"]).toBeGreaterThan(y["p-2"]);     /*  560 is farther than 120  */
-        /*  A crossing: one parent's drop (at its x, from its row down to
-         *  its turn) cut by another's run (from its x to the child).  */
-        for(let a of PARENTS) {
-            for(let b of PARENTS) {
-                if(a === b) {
-                    continue;
-                }
-                let lo = Math.min(b.x, T0[0]);
-                let hi = Math.max(b.x, T0[0]);
-                let cuts = a.x > lo && a.x < hi && y[b.id] > 40 && y[b.id] < y[a.id];
-                expect(cuts).toBe(false);
-            }
-        }
-    });
-
-    test("a routed edge leaves and reaches its ports sideways, sharing only the stub", () => {
-        /*  A same-row edge from A to C, with D standing between them:
-         *  it is routed. It must not run down the column over C's
-         *  port, which is where a forward edge into C drops.  */
-        const A2 = {x1: 0, y1: 200, x2: 100, y2: 240};
-        const D2 = {x1: 150, y1: 180, x2: 250, y2: 260};
-        const C2 = {x1: 300, y1: 200, x2: 400, y2: 240};
-        let s = [50, 240];
-        let t = [350, 200];
-        let boxes = [A2, D2, C2];
-        let route = elbow_route(s, t, A2, C2, 0, true, boxes);
-        expect(route.length).toBeGreaterThan(2);
-        expect(elbow_path_hits([s, ...route, t], boxes, A2, C2)).toBe(false);
-        let a = route[0];
-        let z = route[route.length - 1];
-        expect(route[1][1]).toBe(a[1]);                     /*  leaves a sideways  */
-        expect(route[route.length - 2][1]).toBe(z[1]);      /*  reaches z sideways  */
-        expect(t[1] - z[1]).toBeLessThan(20);               /*  the stub is short  */
-    });
-
-    test("an end shared by nobody keeps the middle", () => {
-        let one = {rank: 0, count: 1};
-        expect(elbow_points(PORT, [160, 130], P, KIDS[1].box, 0, true, {dep: one, arr: one}))
-            .toEqual(elbow_points(PORT, [160, 130], P, KIDS[1].box, 0, true));
-    });
-});
-
-describe("the comb of a stack", () => {
-    /*  A parent over eight leaves, laid out by the compact tree (a
-     *  stack: four rows of two). Boxes as the graph measures them,
-     *  with 14px ports sticking 7px out of the top and bottom.  */
-    const P = {id: "p", w: 172, h: 96};
-    const LEAVES = [0, 1, 2, 3, 4, 5, 6, 7].map((i) => ({id: `l${i}`, w: 116, h: 40}));
-    const pos = layout_compact([P, ...LEAVES], LEAVES.map((l) => ({source: "p", target: l.id})),
-                               {nodesep: 18, ranksep: 90});
-    const box = (n) => {
-        let c = pos.get(n.id);
-        return {x1: c.x - n.w / 2, y1: c.y - n.h / 2 - 7, x2: c.x + n.w / 2, y2: c.y + n.h / 2 + 7};
-    };
-    const BOX_P = box(P);
-    const PORT = [pos.get("p").x, pos.get("p").y + 48];
-    const targets = LEAVES.map((l, i) => ({id: `e-${i + 1}`, box: box(l), leaf: l}));
-    const combs = elbow_combs(targets.map((t) => ({id: t.id, box: t.box})), true);
-    const paths = targets.map((t) => {
-        let comb = combs.get(t.id) || null;
-        let items = targets.map((u) => {
-            let c = combs.get(u.id);
-            let far = c? c.lane : pos.get(u.leaf.id).x;
-            return {id: u.id, span: Math.abs(far - PORT[0])};
-        });
-        let end = [pos.get(t.leaf.id).x, t.box.y1 + 7];
-        let pts = elbow_points(PORT, end, BOX_P, t.box, 0, true,
-                               {dep: elbow_rank(items, t.id), comb: comb});
-        return {id: t.id, box: t.box, full: [PORT, ...pts, end]};
-    });
-
-    test("only the cards under another card get a comb", () => {
-        expect(combs.size).toBe(6);
-        expect(combs.has("e-1")).toBe(false);
-        expect(combs.has("e-2")).toBe(false);
-    });
-
-    test("no line crosses a card", () => {
-        let all = [BOX_P, ...targets.map((t) => t.box)];
-        for(let p of paths) {
-            expect(elbow_path_hits(p.full, all, BOX_P, p.box)).toBe(false);
-        }
-    });
-
-    test("no two lines lie on each other past the stub of the port", () => {
-        /*  Two axis-aligned segments overlap when they are on one line
-         *  and share more than a point of it.  */
-        let overlap = (a, b, c, d) => {
-            let va = a[0] === b[0];
-            let vc = c[0] === d[0];
-            let ha = a[1] === b[1];
-            let hc = c[1] === d[1];
-            if(va && vc && Math.abs(a[0] - c[0]) < 0.5) {
-                return Math.min(Math.max(a[1], b[1]), Math.max(c[1], d[1])) -
-                       Math.max(Math.min(a[1], b[1]), Math.min(c[1], d[1])) > 0.5;
-            }
-            if(ha && hc && Math.abs(a[1] - c[1]) < 0.5) {
-                return Math.min(Math.max(a[0], b[0]), Math.max(c[0], d[0])) -
-                       Math.max(Math.min(a[0], b[0]), Math.min(c[0], d[0])) > 0.5;
-            }
-            return false;
-        };
-        for(let i = 0; i < paths.length; i++) {
-            for(let j = i + 1; j < paths.length; j++) {
-                let A = paths[i].full;
-                let B = paths[j].full;
-                for(let m = 1; m + 1 < A.length; m++) {
-                    for(let n = 1; n + 1 < B.length; n++) {
-                        expect(overlap(A[m], A[m + 1], B[n], B[n + 1])).toBe(false);
-                    }
-                }
-            }
-        }
-    });
-
-    test("a comb is drawn as laid out, not routed", () => {
-        let t = targets[6];
-        let c = combs.get(t.id);
-        let end = [pos.get(t.leaf.id).x, t.box.y1 + 7];
-        let st = {comb: c};
-        expect(elbow_route(PORT, end, BOX_P, t.box, 0, true, [BOX_P, ...targets.map((u) => u.box)], st))
-            .toEqual(elbow_points(PORT, end, BOX_P, t.box, 0, true, st));
-    });
-});
-
-describe("a curve that would cross a card", () => {
-    /*  Whole-node boxes (ports 7px out of top and bottom).  */
-    const PB = {x1: 0, y1: -7, x2: 172, y2: 103};         /*  a parent  */
-    const R0 = {x1: 0, y1: 183, x2: 116, y2: 237};        /*  row 0 of a stack  */
-    const R1 = {x1: 0, y1: 277, x2: 116, y2: 331};        /*  row 1, under it  */
-    const SIB = {x1: 200, y1: -7, x2: 372, y2: 103};      /*  the parent's sibling  */
-    const S = [86, 96];
-
-    /*  The cubic G6 draws between two vertical ports: tangents along
-     *  the line, as its default curveOffset gives.  */
-    const cubic = (s, t) => [["M", s[0], s[1]],
-                             ["C", s[0], (s[1] + t[1]) / 2, t[0], (s[1] + t[1]) / 2, t[0], t[1]]];
-
-    test("a curve into a card of the next row crosses nothing", () => {
-        expect(curve_hits(cubic(S, [58, 190]), [PB, R0, R1, SIB], PB, R0)).toBe(false);
-    });
-
-    test("a curve into a lower row of a stack crosses the card above it", () => {
-        expect(curve_hits(cubic(S, [58, 284]), [PB, R0, R1, SIB], PB, R1)).toBe(true);
-    });
-
-    test("a curve that passes NEAR a card, beside its ports, does not count", () => {
-        /*  N0 in the target row with its port poking 7px up, beside
-         *  where the curve lands; the rectangle round the curve took it.  */
-        const T0 = {x1: 250, y1: 183, x2: 366, y2: 237};
-        const N0 = {x1: 120, y1: 183, x2: 236, y2: 237};
-        expect(curve_hits(cubic(S, [308, 190]), [PB, SIB, T0, N0], PB, T0)).toBe(false);
-    });
-
-    test("the rounded path: a straight line is one run", () => {
-        expect(rounded_path([[0, 0], [0, 100]], 24)).toEqual([["M", 0, 0], ["L", 0, 100]]);
-    });
-
-    test("the rounded path: each corner a quadratic, never past half a short run", () => {
-        let path = rounded_path([[0, 0], [0, 60], [100, 60], [100, 70]], 24);
-        expect(path[0]).toEqual(["M", 0, 0]);
-        expect(path[1]).toEqual(["L", 0, 36]);                  /*  24 before the corner  */
-        expect(path[2]).toEqual(["Q", 0, 60, 24, 60]);
-        expect(path[3]).toEqual(["L", 95, 60]);                 /*  the last run is 10: r = 5  */
-        expect(path[4]).toEqual(["Q", 100, 60, 100, 65]);
-        expect(path[5]).toEqual(["L", 100, 70]);
-    });
-});
-
 describe("the ports are obstacles too", () => {
     /*  Whole-node boxes: a port of 14px sticks 7px out of the bottom
      *  and the top of each card.  */

package/src/treedb_layout.js

@@ -274,396 +274,6 @@ function tidy_tree_lr(nodes, edges, o)
     return pos;
 }
 
-/************************************************************
- *  The compact tree.
- *
- *  The tidy tree above gives every subtree its whole BLOCK: open a
- *  hall with twenty-four devices and its block widens, and with it
- *  every block above it, so the siblings of its ancestors move apart
- *  at depths where nothing of theirs touches. This one keeps the
- *  CONTOUR of each subtree instead -- its outline on each side, depth
- *  by depth -- and slides every sibling against the outline of the
- *  ones before it. A folded region then sits as close to an open one
- *  as their cards allow at each depth, which is what a folded treedb
- *  is: one branch open among closed ones.
- *
- *  Same spanning tree, same order, same rows as the tidy tree: only
- *  the packing across the depths differs, so switching between the
- *  two moves cards sideways and never reorders them.
- *
- *  And a run of three or more LEAF children -- a hall's devices, a
- *  region's places when none is open -- is STACKED: two columns
- *  under the parent with a corridor between them, row after row.
- *  That is what makes it compact when a whole level is open, where
- *  the contour alone gains nothing: every parent needed the whole
- *  row of its children beside it. The tree grows taller instead of
- *  wider. Its elbow edges run down the corridor (elbow_combs).
- *
- *  The contour arithmetic is Moen's ("Drawing dynamic trees", IEEE
- *  Software, 1990) in the form mxGraph gave it in mxCompactTreeLayout
- *  -- Copyright (c) 2006-2015 JGraph Ltd, Apache License 2.0 -- read in
- *  maxGraph's CompactTreeLayout.ts: leaf, join, merge, offset and
- *  bridge below follow that form. What is ours: it runs on the
- *  spanning tree of a FOREST, every depth is a row as wide as its
- *  widest card (mxGraph's `alignRanks`), several roots sit side by
- *  side, and there is no recursion.
- ************************************************************/
-export function layout_compact(nodes, edges, opts)
-{
-    let o = Object.assign({}, DEFAULTS, opts || {});
-    if(o.direction === "LR") {
-        return compact_tree_lr(nodes, edges, o);
-    }
-    let transposed = nodes.map((n) => Object.assign({}, n, {w: n.h, h: n.w}));
-    let lr = compact_tree_lr(transposed, edges, o);
-    let pos = new Map();
-    for(let [id, p] of lr) {
-        pos.set(id, {x: p.y, y: p.x});
-    }
-    return pos;
-}
-
-/*  One segment of a contour: a step of `dx` along the depth and `dy`
- *  across it, then the next segment.  */
-function contour_line(dx, dy, next)
-{
-    return {dx: dx, dy: dy, next: next || null};
-}
-
-/*  How far the segment (a1, a2) at (p1, p2) has to move across to
- *  clear the segment (b1, b2) at the origin.  */
-function contour_offset(p1, p2, a1, a2, b1, b2)
-{
-    if(b1 <= p1 || p1 + a1 <= 0) {
-        return 0;
-    }
-    let d;
-    let t = b1 * a2 - a1 * b2;
-    if(t > 0) {
-        if(p1 < 0) {
-            d = (p1 * a2) / a1 - p2;
-        } else if(p1 > 0) {
-            d = (p1 * b2) / b1 - p2;
-        } else {
-            d = -p2;
-        }
-    } else if(b1 < p1 + a1) {
-        d = b2 - (p2 + ((b1 - p1) * a2) / a1);
-    } else if(b1 > p1 + a1) {
-        d = ((a1 + p1) * b2) / b1 - (p2 + a2);
-    } else {
-        d = b2 - (p2 + a2);
-    }
-    return (d > 0)? d : 0;
-}
-
-function contour_bridge(line1, x1, y1, line2, x2, y2)
-{
-    let dx = x2 + line2.dx - x1;
-    let dy = (line2.dx === 0)? line2.dy : (dx * line2.dy) / line2.dx;
-    let r = contour_line(dx, dy, line2.next);
-    line1.next = contour_line(0, y2 + line2.dy - dy - y1, r);
-    return r;
-}
-
-/*  Slide contour `p2` against `p1` until they clear; returns how far,
- *  and leaves in `p1` the outline of the two together.  */
-function contour_merge(p1, p2)
-{
-    let x = 0;
-    let y = 0;
-    let total = 0;
-    let upper = p1.lower_head;
-    let lower = p2.upper_head;
-
-    while(lower && upper) {
-        let d = contour_offset(x, y, lower.dx, lower.dy, upper.dx, upper.dy);
-        y += d;
-        total += d;
-        if(x + lower.dx <= upper.dx) {
-            x += lower.dx;
-            y += lower.dy;
-            lower = lower.next;
-        } else {
-            x -= upper.dx;
-            y -= upper.dy;
-            upper = upper.next;
-        }
-    }
-
-    if(lower) {
-        let b = contour_bridge(p1.upper_tail, 0, 0, lower, x, y);
-        p1.upper_tail = b.next? p2.upper_tail : b;
-        p1.lower_tail = p2.lower_tail;
-    } else {
-        let b = contour_bridge(p2.lower_tail, x, y, upper, 0, 0);
-        if(!b.next) {
-            p1.lower_tail = b;
-        }
-    }
-    p1.lower_head = p2.lower_head;
-    return total;
-}
-
-/*  How the compact tree STACKS a run of leaf children: two columns
- *  under their parent, a CORRIDOR between them that the elbow edges
- *  run down (treedb_elbow.js, elbow_combs), a gap between the rows
- *  that they turn into. The corridor is sized here from how many
- *  lines will run down it; the edges count the lanes from where the
- *  cards stand.  */
-export const STACK_MIN_RUN = 3;        /*  shorter runs stay in the row  */
-export const STACK_GAP = 40;           /*  between two rows of a stack  */
-export const STACK_LANE_PAD = 10;      /*  from a column to its first lane  */
-export const STACK_LANE_STEP = 6;      /*  between two lanes  */
-export const STACK_TRUNK_MIN = 36;
-
-/*  The corridor of a stack of `k` cards: every card below the first
- *  row gets a lane.  */
-export function stack_trunk_width(k)
-{
-    let lanes = Math.max(0, k - 2);
-    return Math.max(STACK_TRUNK_MIN,
-                    2 * STACK_LANE_PAD + Math.max(0, lanes - 1) * STACK_LANE_STEP);
-}
-
-/*  A stack in the LR frame (depth along x, siblings along y): `side`
- *  is how far each column reaches across, `starts`/`row_len` where
- *  each row begins and how long it is along the depth. Its first row
- *  IS the depth's column, so it lines up with every other card there.  */
-function stack_geometry(t, st, col_x, col_w)
-{
-    let d = st.depth;
-    let k = st.ids.length;
-    let rows = Math.ceil(k / 2);
-    let side = [0, 0];
-    let row_len = [];
-    for(let i = 0; i < k; i++) {
-        let n = t.by_id.get(st.ids[i]);
-        let r = Math.floor(i / 2);
-        side[i % 2] = Math.max(side[i % 2], n.h);
-        row_len[r] = Math.max(row_len[r] || 0, n.w);
-    }
-    row_len[0] = col_w[d];
-    let trunk = stack_trunk_width(k);
-    let starts = [col_x[d]];
-    for(let r = 1; r < rows; r++) {
-        starts[r] = starts[r - 1] + row_len[r - 1] + STACK_GAP;
-    }
-    return {
-        side: side,
-        trunk: trunk,
-        starts: starts,
-        row_len: row_len,
-        len: starts[rows - 1] + row_len[rows - 1] - col_x[d],
-        ext: side[0] + trunk + side[1],
-    };
-}
-
-/*  The cards of a stack whose block starts across at `top`: row by
- *  row, the first of each row against the corridor from one side,
- *  the second against it from the other.  */
-function place_stack(t, st, g, top, pos)
-{
-    for(let i = 0; i < st.ids.length; i++) {
-        let n = t.by_id.get(st.ids[i]);
-        let r = Math.floor(i / 2);
-        let across = (i % 2 === 0)
-            ? top + g.side[0] - n.h / 2
-            : top + g.side[0] + g.trunk + n.h / 2;
-        pos.set(st.ids[i], {x: g.starts[r] + g.row_len[r] / 2, y: across});
-    }
-}
-
-function compact_tree_lr(nodes, edges, o)
-{
-    let t = spanning_tree(nodes, edges);
-    let pos = new Map();
-
-    /*  A run of STACK_MIN_RUN or more consecutive LEAF children is laid
-     *  out as one block, a STACK. The contour packing below takes the
-     *  block as one leaf of its own length, so nothing is packed under
-     *  it. Runs, not all the leaves of a parent: the children keep
-     *  their order. A stack's key is an OBJECT, so it can never be
-     *  taken for a node id, which is a string.  */
-    let kids_of = new Map();
-    let stacks = new Map();
-    for(let [id, kids] of t.children) {
-        let out = [];
-        let run = [];
-        let flush = () => {
-            if(run.length >= STACK_MIN_RUN) {
-                let key = {stack: stacks.size};
-                stacks.set(key, {ids: run, depth: t.depth.get(run[0])});
-                out.push(key);
-            } else {
-                out.push(...run);
-            }
-            run = [];
-        };
-        for(let kid of kids) {
-            if((t.children.get(kid) || []).length === 0) {
-                run.push(kid);
-            } else {
-                flush();
-                out.push(kid);
-            }
-        }
-        flush();
-        kids_of.set(id, out);
-    }
-
-    /*  Parents before children, a stack being one child.  */
-    let order = [];
-    let todo = t.roots.slice().reverse();
-    while(todo.length) {
-        let id = todo.pop();
-        order.push(id);
-        let kids = kids_of.get(id) || [];
-        for(let i = kids.length - 1; i >= 0; i--) {
-            todo.push(kids[i]);
-        }
-    }
-
-    /*  Columns, as in the tidy tree: a depth is as wide as its widest
-     *  card, and a column's gap is `ranksep`.  */
-    let col_w = [];
-    for(let [id, d] of t.depth) {
-        col_w[d] = Math.max(col_w[d] || 0, t.by_id.get(id).w);
-    }
-    let col_x = [];
-    let x = 0;
-    for(let d = 0; d < col_w.length; d++) {
-        col_x[d] = x;
-        x += (col_w[d] || 0) + o.ranksep;
-    }
-
-    /*  mxGraph's nodeDistance is padding on EACH side of a card, so two
-     *  neighbours end `nodesep` apart; its levelDistance is what is
-     *  left of the column gap after that padding.  */
-    let pad = o.nodesep / 2;
-    let dist = o.nodesep;
-    let level_distance = o.ranksep - pad;
-
-    /*  `len` along the depth (the column's width: the rows are aligned;
-     *  a stack's own length), `ext` across it.  */
-    let tn = new Map();
-    for(let id of order) {
-        let st = stacks.get(id);
-        if(st) {
-            let g = stack_geometry(t, st, col_x, col_w);
-            tn.set(id, {len: g.len, ext: g.ext, geom: g, off_x: 0, off_y: 0, y: 0, contour: null});
-        } else {
-            tn.set(id, {
-                len: col_w[t.depth.get(id)],
-                ext: t.by_id.get(id).h,
-                off_x: 0,
-                off_y: 0,
-                y: 0,
-                contour: null,
-            });
-        }
-    }
-
-    /*  Contours, children before parents.  */
-    for(let i = order.length - 1; i >= 0; i--) {
-        let id = order[i];
-        let n = tn.get(id);
-        let kids = kids_of.get(id) || [];
-
-        if(!kids.length) {
-            let upper = contour_line(n.len + dist, 0);
-            let lower_tail = contour_line(0, -n.ext - dist);
-            n.contour = {
-                upper_head: upper,
-                upper_tail: upper,
-                lower_tail: lower_tail,
-                lower_head: contour_line(n.len + dist, 0, lower_tail),
-            };
-            continue;
-        }
-
-        /*  join: the children side by side, each slid against the
-         *  outline of the ones before it.  */
-        let first = tn.get(kids[0]);
-        n.contour = first.contour;
-        let h = first.ext + dist;
-        let span = h;
-        for(let k = 1; k < kids.length; k++) {
-            let kid = tn.get(kids[k]);
-            let d = contour_merge(n.contour, kid.contour);
-            kid.off_y = d + h;
-            kid.off_x = 0;
-            h = kid.ext + dist;
-            span += d + h;
-        }
-
-        /*  attach: the parent centred across the span of its children,
-         *  one column before them.  */
-        let gap = pad + level_distance;
-        let y2 = (span - n.ext) / 2 - pad;
-        let y1 = y2 + n.ext + 2 * pad - span;
-        first.off_x = gap + n.len;
-        first.off_y = y1;
-        n.contour.upper_head = contour_line(n.len, 0,
-                                   contour_line(gap, y1, n.contour.upper_head));
-        n.contour.lower_head = contour_line(n.len, 0,
-                                   contour_line(gap, y2, n.contour.lower_head));
-    }
-
-    /*  Positions across, parents before children: the first child at
-     *  its offset from the parent, each next one at its offset from
-     *  the one before.  */
-    let root_of = new Map();
-    for(let id of order) {
-        let n = tn.get(id);
-        if(!root_of.has(id)) {
-            root_of.set(id, id);
-        }
-        let kids = kids_of.get(id) || [];
-        if(!kids.length) {
-            continue;
-        }
-        let running = n.y + tn.get(kids[0]).off_y;
-        tn.get(kids[0]).y = running;
-        root_of.set(kids[0], root_of.get(id));
-        for(let k = 1; k < kids.length; k++) {
-            let kid = tn.get(kids[k]);
-            kid.y = running + kid.off_y;
-            running = kid.y;
-            root_of.set(kids[k], root_of.get(id));
-        }
-    }
-
-    /*  Several roots: each tree after the one before, by its extent.  */
-    let lo = new Map();
-    let hi = new Map();
-    for(let id of order) {
-        let r = root_of.get(id);
-        let n = tn.get(id);
-        lo.set(r, Math.min(lo.has(r)? lo.get(r) : Infinity, n.y));
-        hi.set(r, Math.max(hi.has(r)? hi.get(r) : -Infinity, n.y + n.ext));
-    }
-    let shift = new Map();
-    let top = 0;
-    for(let r of t.roots) {
-        shift.set(r, top - lo.get(r));
-        top += hi.get(r) - lo.get(r) + o.nodesep * 2;
-    }
-
-    for(let id of order) {
-        let n = tn.get(id);
-        let y = n.y + shift.get(root_of.get(id));
-        let st = stacks.get(id);
-        if(st) {
-            place_stack(t, st, n.geom, y, pos);
-            continue;
-        }
-        let d = t.depth.get(id);
-        pos.set(id, {x: col_x[d] + col_w[d] / 2, y: y + n.ext / 2});
-    }
-    return pos;
-}
-
 /*  How much of a card lies along the direction `a`: the projection
  *  of its rectangle on that direction. Full width when the card is
  *  read along its width, full height across it, and the honest