@yuneta/gobj-ui 7.23.156 → 7.23.157

package/src/treedb_layout.js

@@ -274,414 +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);
-}
-
-/************************************************************
- *  The children of every node, with each run of STACK_MIN_RUN or
- *  more consecutive LEAF children replaced by one STACK. 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. Shared by the compact tree and the radial.
- *
- *  Returns {kids_of: Map<id, [id | stack]>, stacks: Map<stack, {ids, depth}>}
- ************************************************************/
-function leaf_runs(t)
-{
-    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);
-    }
-    return {kids_of: kids_of, stacks: stacks};
-}
-
-/*  Parents before children, a stack being one child (walk_order's
- *  form, over `kids_of`).  */
-function stacked_order(t, kids_of)
-{
-    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]);
-        }
-    }
-    return order;
-}
-
-/*  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();
-
-    /*  Runs of leaf children become STACKS (leaf_runs); the contour
-     *  packing below takes a stack as one leaf of its own length, so
-     *  nothing is packed under it.  */
-    let {kids_of, stacks} = leaf_runs(t);
-    let order = stacked_order(t, kids_of);
-
-    /*  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
@@ -711,148 +303,76 @@ function extent_at(n, a)
  *
  *      ranksep   the step between rings
  *      nodesep   the gap between neighbours on a ring
- *      stack     (default true) a run of three or more LEAF children
- *                is a STACK, as in the compact tree: it asks its
- *                ring for one row of about the square root of its
- *                cards, not for every leaf -- a hall with a hundred
- *                devices no longer blows the ring up -- and lays
- *                them in rows going OUTWARD, each row as full as
- *                the room it has: rings round the parent when it is
- *                alone, a fan inside its sector when it is not.
- *                false keeps every leaf on the ring.
  ************************************************************/
 export function layout_radial(nodes, edges, opts)
 {
-    let o = Object.assign({}, DEFAULTS, {stack: true}, opts || {});
+    let o = Object.assign({}, DEFAULTS, opts || {});
     let t = spanning_tree(nodes, edges);
     let pos = new Map();
     if(!t.roots.length) {
         return pos;
     }
 
-    let runs = o.stack? leaf_runs(t) : {kids_of: t.children, stacks: new Map()};
-    let kids_of = runs.kids_of;
-    let stacks = runs.stacks;
-    let order = stacked_order(t, kids_of);
-
-    /*  A stack asks its ring for one row of about the square root of
-     *  its cards; how many each row really holds is decided once the
-     *  ring's radius is known (pass 2), by the room it has there.  */
-    for(let st of stacks.values()) {
-        st.per_row = Math.ceil(Math.sqrt(st.ids.length));
-        st.cards = st.ids.map((id) => t.by_id.get(id));
-    }
-    /*  A stack across its ring, at angle `a`: a card's width there, and
-     *  the row it asks for. Along the radius: how far one row reaches.  */
-    let stack_across = (st, a) => {
-        let w = 0;
-        for(let c of st.cards) {
-            w = Math.max(w, extent_at(c, a + Math.PI / 2));
-        }
-        return {card: w, row: st.per_row * w + (st.per_row - 1) * o.nodesep};
-    };
-    let stack_along = (st, a) => {
-        let e = 0;
-        for(let c of st.cards) {
-            e = Math.max(e, extent_at(c, a));
-        }
-        return e;
-    };
-    /*  The widest a set of cards is along the direction `th`, over
-     *  the arc a-half..a+half: a stack's cards stand anywhere in its
-     *  sector, and a card is wider slanted than square.  */
-    let widest_along = (cards, a, half) => {
-        let e = 0;
-        for(let k = 0; k <= 16; k++) {
-            let th = a - half + 2 * half * k / 16;
-            for(let c of cards) {
-                e = Math.max(e, extent_at(c, th));
-            }
-        }
-        return e;
-    };
-    let depth_of = (id) => stacks.has(id)? stacks.get(id).depth : t.depth.get(id);
-    let circ = (a, b) => {
-        let d = Math.abs(a - b) % (2 * Math.PI);
-        return (d > Math.PI)? 2 * Math.PI - d : d;
-    };
-
-    /*  What each node needs across its ring, the sector it deserves: a
-     *  card is one, a stack is one ROW of cards, a parent the sum of
-     *  its children. Post-order.  */
-    let weight = new Map();
+    /*  Leaves under each node: the sector it deserves. Post-order.  */
+    let order = walk_order(t);
+    let leaves = new Map();
     for(let i = order.length - 1; i >= 0; i--) {
         let id = order[i];
-        let st = stacks.get(id);
-        if(st) {
-            weight.set(id, st.per_row);
-            continue;
-        }
-        let kids = kids_of.get(id) || [];
+        let kids = t.children.get(id) || [];
         if(!kids.length) {
-            weight.set(id, 1);
+            leaves.set(id, 1);
             continue;
         }
         let n = 0;
         for(let kid of kids) {
-            n += weight.get(kid);
+            n += leaves.get(kid);
         }
-        weight.set(id, n);
+        leaves.set(id, n);
     }
     let total = 0;
     for(let root of t.roots) {
-        total += weight.get(root);
+        total += leaves.get(root);
     }
 
     /*  One root sits at the centre; several sit on the first ring
      *  around an empty centre, so every depth shifts out by one.  */
     let single = (t.roots.length === 1);
-    let ring_of = (id) => depth_of(id) + (single? 0 : 1);
+    let ring_of = (id) => t.depth.get(id) + (single? 0 : 1);
 
     /*  Pass 1, the ANGLES: a node's children split its sector by
-     *  their weight, and a node sits at the middle of its sector.
+     *  their leaves, and a node sits at the middle of its sector.
      *  Angles do not depend on the radii, so they come first.  */
     let angle = new Map();
-    let rings = [];         /*  ring -> [{id, angle, span, diag, ext, parent_ext}]  */
+    let rings = [];         /*  ring -> [{id, angle, diag}]  */
     /*  An explicit stack, not recursion: the sectors of a ring are
      *  sorted by angle in pass 2, so the order they are pushed in does
      *  not matter -- only that every node gets its own.  */
     let sector = (root_id, root_from, root_span, root_parent) => {
-        let todo = [{id: root_id, from: root_from, span: root_span, parent: root_parent}];
-        while(todo.length) {
-            let {id, from, span, parent} = todo.pop();
+        let stack = [{id: root_id, from: root_from, span: root_span, parent: root_parent}];
+        while(stack.length) {
+            let {id, from, span, parent} = stack.pop();
             let a = from + span / 2;
             angle.set(id, a);
             let ring = ring_of(id);
             if(!rings[ring]) {
                 rings[ring] = [];
             }
-            let st = stacks.get(id);
-            let n = st? null : t.by_id.get(id);
+            let n = t.by_id.get(id);
             rings[ring].push({
                 id: id,
                 angle: a,
-                span: span,
-                /*  How much it needs along the ring: a card's diagonal,
-                 *  a stack's first row.  */
-                diag: st? stack_across(st, a).row : Math.hypot(n.w, n.h),
+                diag: Math.hypot(n.w, n.h),
                 /*  How much of the card lies along the RADIUS at this
                  *  angle -- the projection of the rectangle on that
                  *  direction -- for itself and for the node it hangs
                  *  from, which is the one it has to clear.  */
-                /*  A stack is measured, and measures its parent, over
-                 *  the whole sector it can cover: round a parent its
-                 *  first row stands at every angle.  */
-                ext: st? widest_along(st.cards, a, Math.min(span / 2, Math.PI))
-                       : extent_at(n, a),
-                parent_ext: !parent? 0
-                    : (st? widest_along([t.by_id.get(parent)], a, Math.min(span / 2, Math.PI))
-                         : extent_at(t.by_id.get(parent), a)),
+                ext: extent_at(n, a),
+                parent_ext: parent? extent_at(t.by_id.get(parent), a) : 0,
             });
             let cursor = from;
-            for(let kid of (kids_of.get(id) || [])) {
-                let part = span * weight.get(kid) / weight.get(id);
-                todo.push({id: kid, from: cursor, span: part, parent: id});
+            for(let kid of (t.children.get(id) || [])) {
+                let part = span * leaves.get(kid) / leaves.get(id);
+                stack.push({id: kid, from: cursor, span: part, parent: id});
                 cursor += part;
             }
         }
@@ -861,15 +381,15 @@ export function layout_radial(nodes, edges, opts)
         let root = t.roots[0];
         angle.set(root, 0);
         let cursor = -Math.PI / 2;      /*  the first child at the top  */
-        for(let kid of (kids_of.get(root) || [])) {
-            let part = 2 * Math.PI * weight.get(kid) / weight.get(root);
+        for(let kid of (t.children.get(root) || [])) {
+            let part = 2 * Math.PI * leaves.get(kid) / leaves.get(root);
             sector(kid, cursor, part, root);
             cursor += part;
         }
     } else {
         let cursor = -Math.PI / 2;
         for(let root of t.roots) {
-            let part = 2 * Math.PI * weight.get(root) / total;
+            let part = 2 * Math.PI * leaves.get(root) / total;
             sector(root, cursor, part, null);
             cursor += part;
         }
@@ -893,132 +413,31 @@ export function layout_radial(nodes, edges, opts)
      *  the one it HANGS FROM, in the direction it hangs in -- the
      *  two are radially aligned, or nearly, since a child lives
      *  inside its parent's sector -- and the ring goes out far
-     *  enough for the worst of them.
-     *
-     *  Then the STACKS of the ring get their rows: each row holds as
-     *  many cards as fit in the room the stack has -- its own sector,
-     *  less what its neighbours on the ring take up -- at that row's
-     *  radius. A stack alone on its ring has the whole circle, and its
-     *  rows are rings round its parent; one between neighbours fans
-     *  out inside its sector, wider as it goes. The rows reaching out
-     *  are neighbours of the outer rings too, by the ANGLE they cover.  */
-    let fit = (list, r0) => {
-        let r = r0;
-        let sorted = list.slice().sort((a, b) => a.angle - b.angle);
-        for(let i = 0; i < sorted.length && sorted.length > 1; i++) {
-            let a = sorted[i];
-            let b = sorted[(i + 1) % sorted.length];
-            let gap = (i + 1 < sorted.length)
-                ? b.angle - a.angle
-                : b.angle + 2 * Math.PI - a.angle;
-            if(gap > 1e-9) {
-                r = Math.max(r, (a.diag / 2 + b.diag / 2 + o.nodesep) / gap);
-            }
-        }
-        return r;
-    };
+     *  enough for the worst of them.  */
     let radius = [0];
-    let reaching = [];      /*  planned stacks: {angle, half, reach}  */
     for(let ring = 1; ring < rings.length; ring++) {
-        let members = rings[ring] || [];
         let r = radius[ring - 1] + o.ranksep;
-        let band = 0;
-        for(let n of members) {
+        for(let n of (rings[ring] || [])) {
             r = Math.max(r, radius[ring - 1] + (n.parent_ext + n.ext) / 2 + o.nodesep);
-            band = Math.max(band, n.ext);
         }
-        r = fit(members, r);
-        /*  Clear the rows of the inner stacks that reach this far: by
-         *  the angle they cover, or, for a card standing in it, by
-         *  going past their reach.  */
-        for(let pass = 0; pass < 2; pass++) {
-            for(let g of reaching) {
-                if(g.reach < r - band / 2 - o.nodesep) {
-                    continue;
-                }
-                for(let m of members) {
-                    let d = circ(g.angle, m.angle);
-                    if(d > g.half + 1e-9) {
-                        r = Math.max(r, (m.diag / 2 + o.nodesep) / (d - g.half));
-                    } else {
-                        r = Math.max(r, g.reach + m.ext / 2 + o.nodesep);
-                    }
-                }
+        let list = (rings[ring] || []).slice().sort((a, b) => a.angle - b.angle);
+        for(let i = 0; i < list.length && list.length > 1; i++) {
+            let a = list[i];
+            let b = list[(i + 1) % list.length];
+            let gap = (i + 1 < list.length)
+                ? b.angle - a.angle
+                : b.angle + 2 * Math.PI - a.angle;
+            if(gap > 1e-9) {
+                r = Math.max(r, (a.diag / 2 + b.diag / 2 + o.nodesep) / gap);
             }
         }
         radius[ring] = r;
-
-        let sorted = members.slice().sort((a, b) => a.angle - b.angle);
-        for(let i = 0; i < sorted.length; i++) {
-            let m = sorted[i];
-            let st = stacks.get(m.id);
-            if(!st) {
-                continue;
-            }
-            /*  The room each side: to the neighbour, less its half and
-             *  the gap; never past the stack's own sector.  */
-            let room = m.span / 2;
-            if(sorted.length > 1) {
-                let left = sorted[(i - 1 + sorted.length) % sorted.length];
-                let right = sorted[(i + 1) % sorted.length];
-                room = Math.min(room,
-                    circ(m.angle, left.angle) - (left.diag / 2 + o.nodesep) / r,
-                    circ(m.angle, right.angle) - (right.diag / 2 + o.nodesep) / r);
-            }
-            room = Math.min(room, Math.PI);
-            /*  Measured over the whole arc it will cover, not at its
-             *  middle: round a parent a card stands at every angle,
-             *  and a 172x96 card is wider at 45 degrees than facing
-             *  down.  */
-            let across = 0;
-            let along = 0;
-            for(let k = 0; k <= 16; k++) {
-                let th = m.angle - room + 2 * room * k / 16;
-                for(let c of st.cards) {
-                    across = Math.max(across, extent_at(c, th + Math.PI / 2));
-                    along = Math.max(along, extent_at(c, th));
-                }
-            }
-            let rows = [];
-            let left_to_place = st.ids.length;
-            let rr = r;
-            let half = 0;
-            while(left_to_place > 0) {
-                let fits = Math.floor(2 * room * rr / (across + o.nodesep));
-                let cnt = Math.max(1, Math.min(left_to_place, fits));
-                rows.push({rr: rr, cnt: cnt});
-                half = Math.max(half, ((cnt * (across + o.nodesep) - o.nodesep) / 2) / rr);
-                left_to_place -= cnt;
-                rr += along + STACK_GAP;
-            }
-            st.plan = {angle: m.angle, across: across, rows: rows};
-            reaching.push({
-                angle: m.angle,
-                half: half,
-                reach: rows[rows.length - 1].rr + along / 2,
-            });
-        }
     }
 
-    /*  Pass 3, the positions: a node at its angle on its ring; a
-     *  stack's cards row by row outward, each row centred on the
-     *  stack's angle, a card's width plus the gap apart along the arc.  */
+    /*  Pass 3, the positions.  */
     for(let [id, a] of angle) {
-        let st = stacks.get(id);
-        if(!st) {
-            let r0 = radius[ring_of(id)] || 0;
-            pos.set(id, {x: r0 * Math.cos(a), y: r0 * Math.sin(a)});
-            continue;
-        }
-        let i = 0;
-        for(let row of st.plan.rows) {
-            let step = (st.plan.across + o.nodesep) / row.rr;
-            for(let j = 0; j < row.cnt; j++) {
-                let th = a + (j - (row.cnt - 1) / 2) * step;
-                pos.set(st.ids[i], {x: row.rr * Math.cos(th), y: row.rr * Math.sin(th)});
-                i++;
-            }
-        }
+        let r = radius[ring_of(id)] || 0;
+        pos.set(id, {x: r * Math.cos(a), y: r * Math.sin(a)});
     }
 
     return pos;