@johnmorrisdotca/kyogijo-stadiums 0.45.2 → 0.46.0

package/dist/venue.real.js

@@ -4,11 +4,14 @@
 // membrane from the rim of the walls to a crown, which never opens), or no roof at all (Koshien Stadium's). All are asked for with the roof (`venue: { roof: true }`) and give way to the eye as the other walls do.
 // Pure: data in, planes out.
 import { rayAt } from "./crowd.js";
-import { n, shy, wall } from "./turn.kit.js";
+import { bar, box, n, pole, shy, wall } from "./turn.kit.js";
 import { pointList, raked } from "./venue.geom.js";
+import { edgeDistance, inside } from "./venues.geo.js";
 /** How far a lid rises from its edge towards the middle, and how far a saddle's high ends stand over its low sides, in feet (ours: the sources give a roof's kind, not its height). */
 export const LID_RISE = 22;
 export const SADDLE_RISE = 30;
+/** How far a barrel vault's crown stands over its springing at the long sides, in feet (ours: the article says the roof looks like a Quonset hut, not how high it rises). */
+export const BARREL_RISE = 34;
 /** The saddle's share of its rise at a point (0 at the middle of a side, 1 at the middle of an end): half a saddle's way from one to the other, as a hyperbolic paraboloid (u squared less v squared) lies over the building's box. */
 export function saddleAt(real, [x, y]) {
     const xs = real.footprint.map((p) => p[0]);
@@ -18,8 +21,108 @@ export function saddleAt(real, [x, y]) {
     const s = ((x - cx) / hx) ** 2 - ((y - cy) / hy) ** 2;
     return (1 + Math.max(-1, Math.min(1, s))) / 2;
 }
+/** The barrel vault's share of its rise at a point (0 at the springing along each long side, 1 over the middle line): a round arch over the building's short axis, the quarter of a circle's rise at each step in from the side. */
+export function barrelAt(real, [, y]) {
+    const ys = real.footprint.map((p) => p[1]);
+    const [cy, hy] = [(Math.min(...ys) + Math.max(...ys)) / 2, (Math.max(...ys) - Math.min(...ys)) / 2];
+    const v = Math.min(1, Math.abs((y - cy) / hy));
+    return Math.sqrt(1 - v * v);
+}
 /** The height of the roof over a point of the building's edge, above the surface, in feet. */
-export const roofAt = (real, p) => real.edge + (real.roof === "saddle" ? SADDLE_RISE * saddleAt(real, p) : 0);
+export const roofAt = (real, p) => real.edge + (real.roof === "saddle" ? SADDLE_RISE * saddleAt(real, p) : real.roof === "barrel" ? BARREL_RISE * barrelAt(real, p) : 0);
+/** How near a wall must stand to a canopy's outline to be the wall under it, in feet. */
+const CANOPY_REACH = 50;
+/** The height of the wall of a building under canopies at a point of its rim: where a canopy is over it, the canopy's back edge, which the wall carries up to (the outside of Lumen Field's roofs is one curved face to the ground); elsewhere the rim's own height. */
+export function wallAt(real, p) {
+    if (real.roof !== "canopy" || real.canopies === undefined)
+        return roofAt(real, p);
+    let top = roofAt(real, p);
+    for (const canopy of real.canopies)
+        if (inside(canopy.ring, p) || edgeDistance(canopy.ring, p) < CANOPY_REACH)
+            top = Math.max(top, canopy.low + canopy.rise);
+    return top;
+}
+/** How many rings the leaning tower's shaft is cut into, how far its foot stands wider than the shaft over it (a plinth), and the observatory's width over the shaft's top, its height and the share of it that is glass (ours). */
+const TOWER_RINGS = 12;
+const TOWER_PLINTH = { wide: 1.3, high: 26 };
+const TOWER_CAP = { wide: 1.5, high: 40 };
+/**
+ * A tower that leans and curves: a square shaft of horizontal sections that tapers from a broad foot on the ground to a narrow top, along a curve that runs from the foot to the top (the line the map gives of its funicular), its
+ * back curving up from a flatter foot to the inclination the article gives at the top; a plinth where it meets the ground, the dark slits down its sloped back, an observatory of dark and glass bands on its top and, with `cables`,
+ * thin lines from the observatory to the roof. Each face of a ring is a trapezoid on a plane through its corners, so that the faces meet along their edges. The foot and the top and their height are the sources'; the curve, the
+ * widths, the slits, the plinth and the observatory are ours.
+ */
+export function towerPlanes(tower, z, cables = []) {
+    const [bx, by] = tower.base;
+    const [tx, ty] = tower.top;
+    const run = Math.hypot(tx - bx, ty - by) || 1;
+    const d = [(tx - bx) / run, (ty - by) / run];
+    const a = [-d[1], d[0]];
+    const [w0, w1] = tower.width;
+    const H = tower.height - TOWER_CAP.high;
+    // The curve in the plane of the lean (run along the axis, height): a quadratic from the foot to the top whose tangent at the top rises at the article's inclination.
+    const lean = Math.tan((tower.angle * Math.PI) / 180);
+    const reach = Math.min(H * 0.12, run * 0.12);
+    const control = [run - reach / lean, H - reach];
+    const at = (t) => [2 * t * (1 - t) * control[0] + t * t * run, 2 * t * (1 - t) * control[1] + t * t * H];
+    const wide = (t) => w1 + (w0 - w1) * (1 - t) ** 1.15;
+    const offsets = [[-1, -1], [1, -1], [1, 1], [-1, 1]];
+    const ring = (centre, height, w, k) => [bx + d[0] * centre[0] + (a[0] * offsets[k][0] + d[0] * offsets[k][1]) * (w / 2), by + d[1] * centre[0] + (a[1] * offsets[k][0] + d[1] * offsets[k][1]) * (w / 2), z + height];
+    const planes = [];
+    const face = (id, o, u, v, svg) => {
+        // (A wall, not a mast: the lower tiers leave out the small parts, and a tower 165 metres high is not one.)
+        planes.push({ id, kind: "wall", o, u, v, svg });
+    };
+    for (let i = 0; i < TOWER_RINGS; i += 1) {
+        const [t0, t1] = [i / TOWER_RINGS, (i + 1) / TOWER_RINGS];
+        const [p0, p1] = [at(t0), at(t1)];
+        const [wa, wb] = [wide(t0), wide(t1)];
+        for (let k = 0; k < 4; k += 1) {
+            const o = ring([p0[0], 0], p0[1], wa, k);
+            const up = ring([p1[0], 0], p1[1], wb, k);
+            const next = ring([p0[0], 0], p0[1], wa, (k + 1) % 4);
+            const u = [up[0] - o[0], up[1] - o[1], up[2] - o[2]];
+            const v = [next[0] - o[0], next[1] - o[1], next[2] - o[2]];
+            const [lu, lv] = [Math.hypot(...u), Math.hypot(...v)];
+            const r = wb / wa;
+            // The sloped back (the face away from the lean) has the two long dark slits down it, a few rings clear of the foot and of the top.
+            const slit = (f0, f1) => `<polygon class="u-tower-slit" points="0 ${n(f0 * lv)} ${n(lu)} ${n(f0 * lv * r)} ${n(lu)} ${n(f1 * lv * r)} 0 ${n(f1 * lv)}"/>`;
+            const slits = k === 0 && i >= 2 && i < TOWER_RINGS - 1 ? `${slit(0.24, 0.31)}${slit(0.62, 0.69)}` : "";
+            face(`tower-${i}-${k}`, o, u, v, `<polygon class="u-tower" points="0 0 ${n(lu)} 0 ${n(lu)} ${n(lv * r)} 0 ${n(lv)}"/>${slits}`);
+        }
+    }
+    // The plinth where the foot meets the ground: a low block wider than the shaft, with its top.
+    {
+        const wp = w0 * TOWER_PLINTH.wide;
+        for (let k = 0; k < 4; k += 1) {
+            const o = ring([0, 0], 0, wp, k);
+            const next = ring([0, 0], 0, wp, (k + 1) % 4);
+            const v = [next[0] - o[0], next[1] - o[1], 0];
+            face(`tower-foot-${k}`, o, [0, 0, TOWER_PLINTH.high], v, `<rect class="u-tower-foot" width="${n(TOWER_PLINTH.high)}" height="${n(Math.hypot(v[0], v[1]))}"/>`);
+        }
+        const o = ring([0, 0], TOWER_PLINTH.high, wp, 0);
+        const [c1, c3] = [ring([0, 0], TOWER_PLINTH.high, wp, 1), ring([0, 0], TOWER_PLINTH.high, wp, 3)];
+        face("tower-foot-top", o, [c1[0] - o[0], c1[1] - o[1], 0], [c3[0] - o[0], c3[1] - o[1], 0], `<rect class="u-tower-foot" width="${n(wp)}" height="${n(wp)}"/>`);
+    }
+    // The observatory on the top: a block a little wider than the shaft there, its walls dark, with a band of glass round it, and a flat roof.
+    const [topAt, topW] = [at(1), wide(1) * TOWER_CAP.wide];
+    for (let k = 0; k < 4; k += 1) {
+        const o = ring([topAt[0], 0], topAt[1], topW, k);
+        const next = ring([topAt[0], 0], topAt[1], topW, (k + 1) % 4);
+        const v = [next[0] - o[0], next[1] - o[1], 0];
+        const lv = Math.hypot(v[0], v[1]);
+        face(`tower-cap-${k}`, o, [0, 0, TOWER_CAP.high], v, `<rect class="u-tower-cap" width="${n(TOWER_CAP.high)}" height="${n(lv)}"/><rect class="u-tower-glass" x="${n(TOWER_CAP.high * 0.3)}" width="${n(TOWER_CAP.high * 0.45)}" height="${n(lv)}"/>`);
+    }
+    {
+        const o = ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 0);
+        const [c1, c3] = [ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 1), ring([topAt[0], 0], topAt[1] + TOWER_CAP.high, topW, 3)];
+        face("tower-cap-top", o, [c1[0] - o[0], c1[1] - o[1], 0], [c3[0] - o[0], c3[1] - o[1], 0], `<rect class="u-tower-cap" width="${n(topW)}" height="${n(topW)}"/>`);
+    }
+    // The cables that held the roof, from the observatory to the roof: thin lines.
+    const from = ring([topAt[0], 0], topAt[1] + TOWER_CAP.high * 0.4, 0, 0);
+    cables.forEach((to, i) => planes.push(...bar(`tower-cable-${i}`, "mast", from, to, 1.2, "u-tower-cable")));
+    return planes;
+}
 /** The point where a ray from `from` first meets a polygon, or `undefined`. */
 export function firstHit(poly, from, angle) {
     const [dx, dy] = [Math.cos(angle), Math.sin(angle)];
@@ -107,11 +210,16 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
         if (long < 1)
             return;
-        const high = lift + (real.wall ?? roofAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]));
-        planes.push({ ...shy(wall(`shell-${i}`, "wall", a[0], a[1], b[0], b[1], 0, high, `<rect class="${real.ivy === true ? "u-shell u-ivy" : "u-shell"}" width="${n(long)}" height="${n(high)}"/>${real.podium === undefined ? "" : podiumBands(long, high, real.podium)}`), centre), fadeTo: 0.02 });
+        const high = lift + (real.wall ?? wallAt(real, [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]));
+        planes.push({ ...shy(wall(`shell-${i}`, "wall", a[0], a[1], b[0], b[1], 0, high, `<rect class="${real.ivy === true ? "u-shell u-ivy" : real.brick === true ? "u-shell u-brick" : "u-shell"}" width="${n(long)}" height="${n(high)}"/>${real.podium === undefined ? "" : podiumBands(long, high, real.podium)}`), centre), fadeTo: 0.02 });
     });
     if (parts.walls && planes.length > 0)
         items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
+    if (parts.walls && real.towers !== undefined) {
+        const towers = real.towers.flatMap((tower, i) => endTowerPlanes(tower, i, lift, c));
+        if (towers.length > 0)
+            items.push({ id: "endtower", kind: "walls", at: centre, height: Math.max(...real.towers.map((t) => t.height)) + lift, planes: towers });
+    }
     if (parts.roof && real.roof === "canopy" && real.canopies !== undefined) {
         const planes = canopyRoof(real.canopies, c, lift, steps);
         if (planes.length > 0)
@@ -119,7 +227,15 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         return items;
     }
     if (parts.roof && real.roof === "dome" && real.dome !== undefined) {
-        const planes = domeRoof(real.dome, lift, steps);
+        // The cables run from the tower to the middle of the roof and a third of the way out each side of it.
+        const rim = real.dome.rim;
+        const mid = [rim.reduce((t, p) => t + p[0], 0) / rim.length, rim.reduce((t, p) => t + p[1], 0) / rim.length];
+        const reach = Math.max(...rim.map((p) => Math.hypot(p[0] - mid[0], p[1] - mid[1]))) / 3;
+        const across = real.tower === undefined ? [0, 0] : [-(real.tower.top[1] - real.tower.base[1]), real.tower.top[0] - real.tower.base[0]];
+        const long = Math.hypot(across[0], across[1]) || 1;
+        const high = lift + real.dome.low + (real.dome.crown - real.dome.low) * (1 - 0.1);
+        const cables = [[mid[0], mid[1], lift + real.dome.crown], ...[-1, 1].map((side) => [mid[0] + (across[0] / long) * reach * side, mid[1] + (across[1] / long) * reach * side, high])];
+        const planes = [...domeRoof(real.dome, lift, steps), ...(real.tower === undefined ? [] : towerPlanes(real.tower, lift, cables))];
         if (planes.length > 0)
             items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(planes), planes });
         return items;
@@ -142,7 +258,7 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         const angle = (2 * Math.PI * k) / steps;
         return crown === undefined ? rayAt(top.hole, c[0], c[1], angle) : firstHit(crown.opening, c, angle) ?? rayAt(top.hole, c[0], c[1], angle);
     });
-    const rise = real.roof === "saddle" || real.roof === "cable" ? 0 : LID_RISE;
+    const rise = real.roof === "saddle" || real.roof === "barrel" || real.roof === "cable" ? 0 : LID_RISE;
     const zOf = (p, inward) => lift + roofAt(real, p) + (inward ? (crown === undefined ? rise : crown.rise) : 0);
     for (let k = 0; k < steps; k += 1) {
         const [a, b] = [rim[k], rim[(k + 1) % steps]];
@@ -228,7 +344,7 @@ function span(poly, from, angle) {
  * A piece of roof between two rays: the quad `[inner a, inner b, outer b, outer a]` at the heights given, as a plane that gives way to the eye. A quad whose edges are not parallel is not flat at those heights, so
  * with `exact` it is two triangles, each a plane through its corners.
  */
-function piece(id, quad, heights, c, cables, exact = false) {
+function piece(id, quad, heights, c, cables, exact = false, cls = "u-roof") {
     const [ai, bi, b, a] = quad;
     const [ex, ey] = [b[0] - a[0], b[1] - a[1]];
     const el = Math.hypot(ex, ey);
@@ -238,7 +354,7 @@ function piece(id, quad, heights, c, cables, exact = false) {
         const slope = slopeThrough(poly.map((p, i) => [p[0], p[1], hs[i]]));
         const mid = [poly.reduce((s, p) => s + p[0], 0) / poly.length, poly.reduce((s, p) => s + p[1], 0) / poly.length];
         const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]) || 1;
-        const paint = (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>${cable ? `<path class="u-cable" d="M${n(corners[0][0])} ${n(corners[0][1])}L${n(corners[3][0])} ${n(corners[3][1])}"/>` : ""}`;
+        const paint = (corners) => `<polygon class="${cls}" points="${pointList(corners)}"/>${cable ? `<path class="u-cable" d="M${n(corners[0][0])} ${n(corners[0][1])}L${n(corners[3][0])} ${n(corners[3][1])}"/>` : ""}`;
         const plane = raked(name, "roof", poly, slope, [ex / el, ey / el], paint);
         return plane === undefined ? [] : [{ ...plane, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] }];
     };
@@ -248,24 +364,69 @@ function piece(id, quad, heights, c, cables, exact = false) {
 }
 /** How far a canopy's low edge, the field's side of it, stands under its high edge: the OpenStreetMap roof's `roof:height` is the rise, and the canopy rises to the back of the stands (ours: the sources do not say which way it slopes). */
 export const CANOPY_NOTE = "low over the field, high over the back of the stands";
+/** How many strips a canopy is cut into from the field's side to the back, so that a curved roof is a curve (ours: the drawing's pieces are flat). */
+export const CANOPY_STRIPS = 3;
+/** From this many rays round the middle on, a canopy is cut by every other one. */
+export const CANOPY_FINE = 48;
+/** The share of a canopy's rise at a share of the way from the field's side to the back: a straight slope, or for OpenStreetMap's `roof:shape=round` a convex arc, a quarter of a circle, steep at the field's edge and levelling over the back of the stands. */
+export function canopyRiseAt(shape, t) {
+    return shape === "round" ? Math.sin((Math.max(0, Math.min(1, t)) * Math.PI) / 2) : t;
+}
+const between = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 /**
- * Canopies over some of the stands (Lumen Field's two, one each side of the field): each OpenStreetMap roof outline is cut by the rays from the middle of the field into the strips between them, the edge towards
- * the field low and the edge towards the back of the stands `rise` higher.
+ * Canopies over some of the stands (Lumen Field's two, one each side of the field): each OpenStreetMap roof outline is cut by the rays from the middle of the field into the strips between them, and each strip across, from
+ * the edge towards the field, low, to the edge towards the back of the stands, `rise` higher, into `CANOPY_STRIPS` pieces that follow the roof's shape: a straight slope, or a round arc where OpenStreetMap says `round`.
  */
 function canopyRoof(canopies, c, lift, steps) {
     const planes = [];
     canopies.forEach((canopy, ci) => {
         const spans = Array.from({ length: steps }, (_, k) => span(canopy.ring, c, (2 * Math.PI * k) / steps));
-        for (let k = 0; k < steps; k += 1) {
-            const [s, t] = [spans[k], spans[(k + 1) % steps]];
+        // Every other ray of a fine cut: a canopy is long and gently curved, and each ray is a piece across its three strips (the plane budget of a district counts them).
+        const stride = steps >= CANOPY_FINE ? 2 : 1;
+        for (let k = 0; k < steps; k += stride) {
+            const [s, t] = [spans[k], spans[(k + stride) % steps]];
             if (s === undefined || t === undefined)
                 continue;
-            const [lo, hi] = [lift + canopy.low, lift + canopy.low + canopy.rise];
-            planes.push(...piece(`roof-c${ci}-${k}`, [s[0], t[0], t[1], s[1]], [lo, lo, hi, hi], c, false, true));
+            for (let j = 0; j < CANOPY_STRIPS; j += 1) {
+                const [u0, u1] = [j / CANOPY_STRIPS, (j + 1) / CANOPY_STRIPS];
+                const [z0, z1] = [lift + canopy.low + canopy.rise * canopyRiseAt(canopy.shape, u0), lift + canopy.low + canopy.rise * canopyRiseAt(canopy.shape, u1)];
+                planes.push(...piece(`roof-c${ci}-${k}-${j}`, [between(s[0], s[1], u0), between(t[0], t[1], u0), between(t[0], t[1], u1), between(s[0], s[1], u1)], [z0, z0, z1, z1], c, false, false, "u-roof u-canopy"));
+            }
         }
     });
     return planes;
 }
+/** How wide the scoreboard on a tower's face is and how tall, as shares of the face, and how far it stands out from it, in feet (ours: the article says the scoreboard is vertical, not how large). */
+export const TOWER_BOARD = { wide: 0.62, tall: 0.46, from: 0.55, out: 0.4 };
+/**
+ * A tower standing apart from the bowl: a box on its outline, four faces and a flat top, that gives way to the eye as a wall does (a tall tower between the eye and the field is cut away, whole from above), with the scoreboard
+ * on the face towards the field, a dark panel high on it and divided into its rows of lamps.
+ */
+export function endTowerPlanes(tower, index, lift, centre) {
+    const xs = tower.ring.map((p) => p[0]);
+    const ys = tower.ring.map((p) => p[1]);
+    const [x0, x1, y0, y1] = [Math.min(...xs), Math.max(...xs), Math.min(...ys), Math.max(...ys)];
+    const top = lift + tower.height;
+    const parts = box(`endtower-${index}`, "wall", { x0, y0, x1, y1 }, top, "u-endtower");
+    const planes = parts.map((p) => (p.id.endsWith("-top") ? p : { ...shy(p, centre), fadeTo: 0.25 }));
+    // The scoreboard: on the face that looks at the field, a little proud of it.
+    const [fx, fy] = tower.face;
+    const [w, h] = fx !== 0 ? [y1 - y0, top] : [x1 - x0, top];
+    const [bw, bh] = [w * TOWER_BOARD.wide, h * TOWER_BOARD.tall];
+    const zTop = top * TOWER_BOARD.from + bh;
+    const svg = `<rect class="u-endtower-board" width="${n(bw)}" height="${n(bh)}"/><path class="u-endtower-rows" d="${Array.from({ length: 9 }, (_, k) => `M0 ${n(((k + 1) * bh) / 10)}H${n(bw)}`).join("")}"/>`;
+    if (fx !== 0) {
+        const x = fx > 0 ? x1 + TOWER_BOARD.out : x0 - TOWER_BOARD.out;
+        const mid = (y0 + y1) / 2;
+        planes.push({ ...shy(wall(`endtower-${index}-board`, "wall", x, mid - bw / 2, x, mid + bw / 2, zTop - bh, zTop, svg), centre), fadeTo: 0.25 });
+    }
+    else {
+        const y = fy > 0 ? y1 + TOWER_BOARD.out : y0 - TOWER_BOARD.out;
+        const mid = (x0 + x1) / 2;
+        planes.push({ ...shy(wall(`endtower-${index}-board`, "wall", mid - bw / 2, y, mid + bw / 2, y, zTop - bh, zTop, svg), centre), fadeTo: 0.25 });
+    }
+    return planes;
+}
 /** How many rings of pieces an air-supported roof is drawn in, from the rim in to the crown (ours: the roof is smooth, the drawing is faceted). */
 export const DOME_RINGS = 4;
 /**
@@ -315,7 +476,7 @@ const PANEL_THICK = 7;
  * building they park on, as slabs at the rim's height.
  */
 function panelsRoof(panels, c, lift, steps, open) {
-    const planes = [];
+    const planes = [...panelRails(panels, c, lift)];
     if (!open) {
         const rim = Array.from({ length: steps }, (_, k) => firstHit(panels.cover, c, (2 * Math.PI * k) / steps) ?? c);
         const inner = rim.map((p) => [c[0] + (p[0] - c[0]) * PANEL_CROWN, c[1] + (p[1] - c[1]) * PANEL_CROWN]);
@@ -344,6 +505,55 @@ function panelsRoof(panels, c, lift, steps, open) {
     });
     return planes;
 }
+/** How wide a rail girder is, how thick, how wide a column under it is, and how many columns stand under each rail, in feet (ours: the article says the roof runs on rails on the north and the south side, not what holds them up). */
+export const RAIL = { wide: 12, thick: 16, column: 15, columns: 4, inset: 24 };
+/** A prism over a four-cornered outline, from `z0` to `z1`: its sides and its top, in the roof's pod tone (a dark steel). */
+function prism(id, ring, z0, z1, c) {
+    const planes = [];
+    ring.forEach((a, i) => {
+        const b = ring[(i + 1) % ring.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (long < 0.5)
+            return;
+        planes.push({ ...shy(wall(`${id}-${i}`, "roof", a[0], a[1], b[0], b[1], z0, z1, `<rect class="u-rail" width="${n(long)}" height="${n(z1 - z0)}"/>`), c), fadeTo: 0.3 });
+    });
+    const top = raked(`${id}-top`, "roof", [...ring], { x0: ring[0][0], y0: ring[0][1], z0: z1, gx: 0, gy: 0 }, [1, 0], (corners) => `<polygon class="u-rail" points="${pointList(corners)}"/>`);
+    if (top !== undefined)
+        planes.push(top);
+    return planes;
+}
+/**
+ * The rails a retractable ballpark roof runs on, along its north and south sides (the article: 128 wheels on rails there), as two girders at the roof's lowest height, each on a row of columns from the ground, and running
+ * on over the strip where the sections rest. The rails run the way the sections park, from the cover's middle to where they rest; a girder lies a little inside each side of the cover.
+ */
+export function panelRails(panels, c, lift) {
+    const mean = (ring) => [ring.reduce((s, p) => s + p[0], 0) / ring.length, ring.reduce((s, p) => s + p[1], 0) / ring.length];
+    const park = mean(panels.parked);
+    const length = Math.hypot(park[0] - c[0], park[1] - c[1]);
+    if (length < 1)
+        return [];
+    const e = [(park[0] - c[0]) / length, (park[1] - c[1]) / length];
+    const m = [-e[1], e[0]];
+    const along = (p) => (p[0] - c[0]) * e[0] + (p[1] - c[1]) * e[1];
+    const across = (p) => (p[0] - c[0]) * m[0] + (p[1] - c[1]) * m[1];
+    const [a0, a1] = [Math.min(...panels.cover.map(along)), Math.max(...panels.parked.map(along), ...panels.cover.map(along))];
+    const [m0, m1] = [Math.min(...panels.cover.map(across)) + RAIL.inset, Math.max(...panels.cover.map(across)) - RAIL.inset];
+    const at = (u, v) => [c[0] + e[0] * u + m[0] * v, c[1] + e[1] * u + m[1] * v];
+    const planes = [];
+    const z = lift + panels.bottom;
+    [m0, m1].forEach((v, side) => {
+        const w = RAIL.wide / 2;
+        planes.push(...prism(`rail-${side}`, [at(a0, v - w), at(a1, v - w), at(a1, v + w), at(a0, v + w)], z - RAIL.thick, z, c));
+        for (let k = 0; k < RAIL.columns; k += 1) {
+            const u = a0 + ((k + 0.5) * (a1 - a0)) / RAIL.columns;
+            const h = RAIL.column / 2;
+            // A column is two strips crossed, as a post is (`pole`): seen from every side with two planes and not five.
+            const [x, y] = at(u, v);
+            planes.push(...pole(`rail-${side}-leg-${k}`, "roof", x, y, lift, z - RAIL.thick, h * 2, "u-rail"));
+        }
+    });
+    return planes;
+}
 /** The pod in the middle of a cable roof's opening, as a share of the opening's size, and how thick it is, in feet (ours: the article says the fabric gathers into a pod above the video board, not how large it is). */
 export const POD = { share: 0.24, thick: 9 };
 /**

package/dist/venues/amerant-bank-arena.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "../venues.ts";
+export declare const VENUE: RealVenueData;

package/dist/venues/amerant-bank-arena.data.js

@@ -0,0 +1,9 @@
+export const VENUE = {
+    "id": "amerant-bank-arena",
+    "wikidata": "Q795526",
+    "division": "atlantic",
+    "en": { "title": "Amerant Bank Arena", "revision": 1379821144 },
+    "seats": { "hockey": 19250, "source": "wikipedia", "wikidata": 20737, "read": "the infobox's figure for ice hockey, 19,250 (at least 20,000 with standing room); Wikidata's one capacity (20,737) has no sport and is the basketball one" },
+    "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of 70 suites and 2,623 club seats, which are not seating bowls" },
+    "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+};

package/dist/venues/amerant-bank-arena.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { VenueOsm } from "../venues.ts";
+export declare const OSM: VenueOsm;

package/dist/venues/amerant-bank-arena.osm.data.js

@@ -0,0 +1,47 @@
+export const OSM = {
+    "source": "way/43903801",
+    "read": "2026-10-20",
+    "base": "2026-10-20T23:14:51Z",
+    "licence": "ODbL-1.0",
+    "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+    "axis": { "heading": 90, "basis": "none", "strength": 1.16, "elongation": 1.02, "centre": [-80.325443, 26.158421] },
+    "ring": [
+        [-80.324676, 26.158684],
+        [-80.324614, 26.158588],
+        [-80.324552, 26.158446],
+        [-80.324708, 26.158215],
+        [-80.324608, 26.158149],
+        [-80.324762, 26.15801],
+        [-80.324661, 26.157905],
+        [-80.325085, 26.157719],
+        [-80.325365, 26.157557],
+        [-80.3254, 26.157691],
+        [-80.325621, 26.157659],
+        [-80.325627, 26.157763],
+        [-80.325924, 26.157768],
+        [-80.326026, 26.157894],
+        [-80.326082, 26.157998],
+        [-80.326126, 26.157984],
+        [-80.326144, 26.158016],
+        [-80.32619, 26.157992],
+        [-80.326228, 26.15808],
+        [-80.326258, 26.158233],
+        [-80.326261, 26.158415],
+        [-80.326242, 26.158516],
+        [-80.326189, 26.158716],
+        [-80.326139, 26.158828],
+        [-80.326054, 26.158935],
+        [-80.326022, 26.158916],
+        [-80.325842, 26.159111],
+        [-80.325688, 26.159133],
+        [-80.325547, 26.159133],
+        [-80.325544, 26.15918],
+        [-80.325358, 26.159169],
+        [-80.325129, 26.159108],
+        [-80.324965, 26.159041],
+        [-80.324812, 26.158949],
+        [-80.324618, 26.158787],
+        [-80.324672, 26.15875],
+        [-80.324645, 26.158707],
+    ],
+};

package/dist/venues/american-airlines-center.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "../venues.ts";
+export declare const VENUE: RealVenueData;

package/dist/venues/american-airlines-center.data.js

@@ -0,0 +1,9 @@
+export const VENUE = {
+    "id": "american-airlines-center",
+    "wikidata": "Q463345",
+    "division": "central",
+    "en": { "title": "American Airlines Center", "revision": 1379833787 },
+    "seats": { "hockey": 18532, "source": "wikipedia", "wikidata": 19200, "read": "the infobox's figure for ice hockey, 18,532 (19,323 with standing room); Wikidata's one capacity (19,200) is the basketball one" },
+    "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of retractable seating, which the bowl does not draw" },
+    "roof": { "kind": "barrel", "basis": "documented", "read": "the article says the roof looks like a Quonset hut, which is a barrel vault: drawn as a round arch over the rink's short axis, highest over its middle line and falling to the walls at the two long sides; the height of the crown (34 feet over the springing) is ours (the article gives none)" },
+};

package/dist/venues/american-airlines-center.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { VenueOsm } from "../venues.ts";
+export declare const OSM: VenueOsm;

package/dist/venues/american-airlines-center.osm.data.js

@@ -0,0 +1,57 @@
+export const OSM = {
+    "source": "way/25312698",
+    "read": "2026-10-20",
+    "base": "2026-10-20T21:35:07Z",
+    "licence": "ODbL-1.0",
+    "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+    "axis": { "heading": 144, "basis": "building", "strength": 2.19, "elongation": 1.31, "centre": [-96.81028, 32.79049] },
+    "ring": [
+        [-96.810234, 32.791328],
+        [-96.810164, 32.791245],
+        [-96.810182, 32.791236],
+        [-96.810056, 32.791086],
+        [-96.810012, 32.791113],
+        [-96.809956, 32.791046],
+        [-96.809969, 32.791039],
+        [-96.809568, 32.790561],
+        [-96.809555, 32.790569],
+        [-96.8095, 32.790504],
+        [-96.809545, 32.790477],
+        [-96.80934, 32.790256],
+        [-96.809439, 32.790198],
+        [-96.809429, 32.790171],
+        [-96.80958, 32.790081],
+        [-96.809551, 32.790046],
+        [-96.809959, 32.789817],
+        [-96.809952, 32.789809],
+        [-96.81003, 32.789763],
+        [-96.810056, 32.789794],
+        [-96.810209, 32.789704],
+        [-96.81024, 32.789718],
+        [-96.810339, 32.789661],
+        [-96.810408, 32.789744],
+        [-96.810392, 32.789752],
+        [-96.81051, 32.789892],
+        [-96.810556, 32.789865],
+        [-96.810611, 32.789932],
+        [-96.810599, 32.789939],
+        [-96.810997, 32.790421],
+        [-96.81101, 32.790413],
+        [-96.811063, 32.790477],
+        [-96.811021, 32.790502],
+        [-96.811154, 32.790659],
+        [-96.811168, 32.790649],
+        [-96.811237, 32.790731],
+        [-96.811139, 32.79079],
+        [-96.81113, 32.790776],
+        [-96.810963, 32.790875],
+        [-96.811009, 32.790929],
+        [-96.810986, 32.790943],
+        [-96.810931, 32.790975],
+        [-96.810924, 32.790967],
+        [-96.81053, 32.791213],
+        [-96.810484, 32.791159],
+        [-96.810319, 32.791257],
+        [-96.810331, 32.791269],
+    ],
+};

package/dist/venues/ball-arena.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "../venues.ts";
+export declare const VENUE: RealVenueData;

package/dist/venues/ball-arena.data.js

@@ -0,0 +1,9 @@
+export const VENUE = {
+    "id": "ball-arena",
+    "wikidata": "Q795470",
+    "division": "central",
+    "en": { "title": "Ball Arena", "revision": 1379560431 },
+    "seats": { "hockey": 17809, "source": "wikipedia", "wikidata": 19155, "read": "the infobox's figure for hockey (given with lacrosse), 17,809; Wikidata's capacity without a sport is 19,155 and its other (17,417) is for futsal" },
+    "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn" },
+    "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+};

package/dist/venues/ball-arena.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { VenueOsm } from "../venues.ts";
+export declare const OSM: VenueOsm;

package/dist/venues/ball-arena.osm.data.js

@@ -0,0 +1,63 @@
+export const OSM = {
+    "source": "way/25312645",
+    "read": "2026-10-20",
+    "base": "2026-10-20T21:33:18Z",
+    "licence": "ODbL-1.0",
+    "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+    "height": 22,
+    "axis": { "heading": 90, "basis": "none", "strength": 1.26, "elongation": 1.02, "centre": [-105.007573, 39.748633] },
+    "ring": [
+        [-105.008169, 39.749084],
+        [-105.008338, 39.748973],
+        [-105.008439, 39.748857],
+        [-105.008498, 39.748726],
+        [-105.008512, 39.748603],
+        [-105.008498, 39.748498],
+        [-105.008449, 39.748382],
+        [-105.00837, 39.748281],
+        [-105.008268, 39.7482],
+        [-105.008098, 39.748114],
+        [-105.008077, 39.748156],
+        [-105.007939, 39.748121],
+        [-105.00785, 39.748115],
+        [-105.007829, 39.748063],
+        [-105.007872, 39.74804],
+        [-105.007756, 39.747764],
+        [-105.007484, 39.74798],
+        [-105.007254, 39.748038],
+        [-105.007224, 39.747996],
+        [-105.00704, 39.74808],
+        [-105.006878, 39.748188],
+        [-105.00693, 39.748223],
+        [-105.00681, 39.748372],
+        [-105.006749, 39.748523],
+        [-105.006624, 39.74863],
+        [-105.006638, 39.748641],
+        [-105.006521, 39.748736],
+        [-105.006734, 39.748736],
+        [-105.006738, 39.748757],
+        [-105.006766, 39.748757],
+        [-105.006796, 39.748878],
+        [-105.00686, 39.748986],
+        [-105.00696, 39.749077],
+        [-105.006919, 39.749103],
+        [-105.007099, 39.749198],
+        [-105.007072, 39.74924],
+        [-105.006874, 39.749291],
+        [-105.006962, 39.749349],
+        [-105.00719, 39.749449],
+        [-105.007191, 39.749467],
+        [-105.00745, 39.749525],
+        [-105.007633, 39.749535],
+        [-105.007613, 39.749485],
+        [-105.007884, 39.749454],
+        [-105.007869, 39.749385],
+        [-105.007985, 39.749351],
+        [-105.007956, 39.749294],
+        [-105.008018, 39.749277],
+        [-105.007993, 39.749232],
+        [-105.008094, 39.749221],
+        [-105.008075, 39.749183],
+        [-105.008185, 39.749115],
+    ],
+};

package/dist/venues/bell-centre.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "../venues.ts";
+export declare const VENUE: RealVenueData;

package/dist/venues/bell-centre.data.js

@@ -0,0 +1,9 @@
+export const VENUE = {
+    "id": "bell-centre",
+    "wikidata": "Q522282",
+    "division": "atlantic",
+    "en": { "title": "Bell Centre", "revision": 1380110375 },
+    "seats": { "hockey": 20962, "source": "wikipedia", "wikidata": 21273, "read": "the article's seating capacity for hockey, 20,962 (the infobox's present figure, from 2025); Wikidata's one capacity (21,273) is the first figure of 1996" },
+    "tiers": { "count": 3, "basis": "documented", "read": "the article says the Bell Centre is arranged in a three-tier layout: the lower 100 section, the 200 section between two levels of boxes, and the upper 300 section" },
+    "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+};

package/dist/venues/bell-centre.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { VenueOsm } from "../venues.ts";
+export declare const OSM: VenueOsm;

package/dist/venues/bell-centre.osm.data.js

@@ -0,0 +1,24 @@
+export const OSM = {
+    "source": "way/19911284",
+    "read": "2026-10-20",
+    "base": "2026-10-20T23:14:51Z",
+    "licence": "ODbL-1.0",
+    "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+    "axis": { "heading": 132, "basis": "building", "strength": 2.28, "elongation": 1.53, "centre": [-73.569281, 45.496067] },
+    "ring": [
+        [-73.570363, 45.496182],
+        [-73.569576, 45.496827],
+        [-73.569294, 45.496653],
+        [-73.569259, 45.496681],
+        [-73.568425, 45.496166],
+        [-73.568449, 45.496144],
+        [-73.568418, 45.496124],
+        [-73.568329, 45.496108],
+        [-73.5683, 45.496056],
+        [-73.568168, 45.495975],
+        [-73.56905, 45.495279],
+        [-73.569731, 45.49569],
+        [-73.570154, 45.495977],
+        [-73.570107, 45.496015],
+    ],
+};

package/dist/venues/benchmark-international-arena.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealVenueData } from "../venues.ts";
+export declare const VENUE: RealVenueData;

package/dist/venues/benchmark-international-arena.data.js

@@ -0,0 +1,9 @@
+export const VENUE = {
+    "id": "benchmark-international-arena",
+    "wikidata": "Q940199",
+    "division": "atlantic",
+    "en": { "title": "Benchmark International Arena", "revision": 1376541285 },
+    "seats": { "hockey": 19092, "source": "wikipedia", "wikidata": 19204, "read": "the infobox's figure for ice hockey, 19,092; Wikidata's one capacity (19,204) has no sport" },
+    "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn" },
+    "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise; OpenStreetMap maps the building 43.47 metres high" },
+};

package/dist/venues/benchmark-international-arena.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { VenueOsm } from "../venues.ts";
+export declare const OSM: VenueOsm;