@johnmorrisdotca/kyogijo-stadiums 0.24.0 → 0.27.0

package/dist/venues.geo.js

@@ -0,0 +1,211 @@
+const EARTH = 6371008.8;
+const RAD = Math.PI / 180;
+/** Points in degrees as `[east, north]` metres from `origin`, on a plane tangent to the earth there (good to a few centimetres over a building's size). */
+export function metresFrom(origin, ring) {
+    const k = Math.cos(origin[1] * RAD);
+    return ring.map(([lon, lat]) => [(lon - origin[0]) * RAD * EARTH * k, (lat - origin[1]) * RAD * EARTH]);
+}
+/** The inverse of `metresFrom`: a point given as east and north metres from `origin`, in degrees. */
+export function lonLatFrom(origin, [east, north]) {
+    return [origin[0] + east / (RAD * EARTH * Math.cos(origin[1] * RAD)), origin[1] + north / (RAD * EARTH)];
+}
+/** The mean of a ring's longitudes and latitudes: a point to measure from. */
+export const middleOf = (ring) => [ring.reduce((s, p) => s + p[0], 0) / ring.length, ring.reduce((s, p) => s + p[1], 0) / ring.length];
+/** The area of a polygon, unsigned. */
+export function areaOf(points) {
+    let s = 0;
+    points.forEach(([x, y], i) => {
+        const [x2, y2] = points[(i + 1) % points.length];
+        s += x * y2 - x2 * y;
+    });
+    return Math.abs(s) / 2;
+}
+/** The centre of mass of a polygon's area. */
+export function centroidOf(points) {
+    let a = 0;
+    let cx = 0;
+    let cy = 0;
+    points.forEach(([x, y], i) => {
+        const [x2, y2] = points[(i + 1) % points.length];
+        const f = x * y2 - x2 * y;
+        a += f;
+        cx += (x + x2) * f;
+        cy += (y + y2) * f;
+    });
+    return a === 0 ? [points[0][0], points[0][1]] : [cx / (3 * a), cy / (3 * a)];
+}
+/** The convex hull of some points (Andrew's monotone chain), counter-clockwise. */
+export function hullOf(points) {
+    const sorted = [...points].sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+    if (sorted.length < 3)
+        return sorted;
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const half = (list) => {
+        const out = [];
+        for (const p of list) {
+            while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], p) <= 0)
+                out.pop();
+            out.push(p);
+        }
+        out.pop();
+        return out;
+    };
+    return [...half(sorted), ...half([...sorted].reverse())];
+}
+/** The heading, in degrees clockwise from north, of a direction given as east and north components, taken modulo 180 (an axis has no head): 0 to under 180. */
+export const axisHeading = (east, north) => (((Math.atan2(east, north) / RAD) % 180) + 180) % 180;
+/** The smallest rectangle (by area) that encloses some points: its long side's heading, its length and its width, in the units of the points. */
+export function smallestBox(points) {
+    const hull = hullOf(points);
+    let best;
+    hull.forEach((p, i) => {
+        const q = hull[(i + 1) % hull.length];
+        const d = Math.hypot(q[0] - p[0], q[1] - p[1]);
+        if (d < 1e-9)
+            return;
+        const ux = (q[0] - p[0]) / d;
+        const uy = (q[1] - p[1]) / d;
+        let lo = Infinity;
+        let hi = -Infinity;
+        let left = Infinity;
+        let right = -Infinity;
+        for (const [x, y] of hull) {
+            const along = x * ux + y * uy;
+            const across = -x * uy + y * ux;
+            lo = Math.min(lo, along);
+            hi = Math.max(hi, along);
+            left = Math.min(left, across);
+            right = Math.max(right, across);
+        }
+        const [a, b] = [hi - lo, right - left];
+        if (best === undefined || a * b < best.area - 1e-9)
+            best = a >= b ? { area: a * b, heading: axisHeading(ux, uy), length: a, width: b } : { area: a * b, heading: axisHeading(-uy, ux), length: b, width: a };
+    });
+    if (best === undefined)
+        throw new Error("a rectangle needs points that are not all the same");
+    return { heading: best.heading, length: best.length, width: best.width };
+}
+/**
+ * A point given as east and north metres, in the drawing's frame, for a rink whose long side runs along `heading` (degrees clockwise from north, 0 to under 180): x along the rink's long side, y across it and down the page,
+ * so that the picture is the map turned and not mirrored. Metres stay metres.
+ */
+export function turnedTo(heading, [east, north]) {
+    const a = heading * RAD;
+    return [east * Math.sin(a) + north * Math.cos(a), east * Math.cos(a) - north * Math.sin(a)];
+}
+/** The way north points in the drawing, in degrees clockwise from the top of the page, for a rink along `heading`. 90 less the heading: a rink that runs east-west has north at the top. */
+export const northOn = (heading) => 90 - heading;
+/** A ring with points that lie within `tolerance` of the line between their neighbours taken out (Douglas and Peucker), the ends kept: a ring is a list of points not repeating its first. */
+export function simplified(ring, tolerance) {
+    const keep = new Array(ring.length).fill(false);
+    // The two farthest-apart points anchor the ring; each half is then simplified as a line.
+    let [a, b, far] = [0, 0, -1];
+    ring.forEach((p, i) => ring.forEach((q, j) => {
+        const d = Math.hypot(p[0] - q[0], p[1] - q[1]);
+        if (j > i && d > far)
+            [a, b, far] = [i, j, d];
+    }));
+    keep[a] = true;
+    keep[b] = true;
+    const run = (from, to, step) => {
+        const [p, q] = [ring[from], ring[to]];
+        const len = Math.hypot(q[0] - p[0], q[1] - p[1]);
+        let at = -1;
+        let most = tolerance;
+        for (let i = step(from); i !== to; i = step(i)) {
+            const r = ring[i];
+            const d = len < 1e-9 ? Math.hypot(r[0] - p[0], r[1] - p[1]) : Math.abs((q[0] - p[0]) * (p[1] - r[1]) - (p[0] - r[0]) * (q[1] - p[1])) / len;
+            if (d > most)
+                [at, most] = [i, d];
+        }
+        if (at >= 0) {
+            keep[at] = true;
+            run(from, at, step);
+            run(at, to, step);
+        }
+    };
+    const next = (i) => (i + 1) % ring.length;
+    run(a, b, next);
+    run(b, a, next);
+    return ring.filter((_, i) => keep[i]);
+}
+/** Whether a point is in a polygon (even-odd). */
+export function inside(points, [x, y]) {
+    let hit = false;
+    for (let i = 0, j = points.length - 1; i < points.length; j = i, i += 1) {
+        const [xi, yi] = points[i];
+        const [xj, yj] = points[j];
+        if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi)
+            hit = !hit;
+    }
+    return hit;
+}
+/** The smallest box round some points. */
+export function boxOf(points) {
+    return { x0: Math.min(...points.map((p) => p[0])), y0: Math.min(...points.map((p) => p[1])), x1: Math.max(...points.map((p) => p[0])), y1: Math.max(...points.map((p) => p[1])) };
+}
+/** The distance from a point to the nearest edge of a polygon. */
+export function edgeDistance(points, [x, y]) {
+    let best = Infinity;
+    points.forEach(([ax, ay], i) => {
+        const [bx, by] = points[(i + 1) % points.length];
+        const [dx, dy] = [bx - ax, by - ay];
+        const len = dx * dx + dy * dy;
+        const t = len === 0 ? 0 : Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / len));
+        best = Math.min(best, Math.hypot(x - (ax + t * dx), y - (ay + t * dy)));
+    });
+    return best;
+}
+/** How coarse the raster `coreOf` lays on the outline is, in the units of the points, and how many degrees apart the directions it tries are. */
+const CELL = 2;
+const STEP = 3;
+/** The largest rectangle with its sides along x and y inside a polygon: width, height and the middle, found on a raster of `CELL` (the largest rectangle in each row's histogram). */
+function largestRectangle(poly) {
+    const b = boxOf(poly);
+    const nx = Math.max(1, Math.ceil((b.x1 - b.x0) / CELL));
+    const ny = Math.max(1, Math.ceil((b.y1 - b.y0) / CELL));
+    const column = new Array(nx).fill(0);
+    let best = { area: 0, w: 0, h: 0, at: [0, 0] };
+    for (let j = 0; j < ny; j += 1) {
+        for (let i = 0; i < nx; i += 1)
+            column[i] = inside(poly, [b.x0 + (i + 0.5) * CELL, b.y0 + (j + 0.5) * CELL]) ? column[i] + 1 : 0;
+        const stack = [];
+        for (let i = 0; i <= nx; i += 1) {
+            const h = i === nx ? 0 : column[i];
+            let start = i;
+            while (stack.length > 0 && stack[stack.length - 1][1] >= h) {
+                const [from, height] = stack.pop();
+                const area = height * (i - from);
+                if (area > best.area)
+                    best = { area, w: (i - from) * CELL, h: height * CELL, at: [b.x0 + (from + (i - from) / 2) * CELL, b.y0 + (j + 1 - height / 2) * CELL] };
+                start = from;
+            }
+            stack.push([start, h]);
+        }
+    }
+    return { w: best.w, h: best.h, at: best.at };
+}
+/**
+ * The main hall of a building: the largest rectangle inside its outline over every direction (`STEP` degrees apart), which does not see a wing, a plaza or a ramp that a rectangle cannot fill. Its long side is the
+ * building's axis, its middle the middle of the hall, and `strength` how much of a direction the building has (a round one has none). Ties between a direction and the one at a right angle go to the longer rectangle.
+ */
+export function coreOf(points) {
+    const areas = [];
+    let best;
+    for (let angle = 0; angle < 180; angle += STEP) {
+        const a = angle * RAD;
+        // The outline turned so that the direction `angle` (counter-clockwise from east) lies along x.
+        const turned = points.map(([x, y]) => [x * Math.cos(a) + y * Math.sin(a), -x * Math.sin(a) + y * Math.cos(a)]);
+        const { w, h, at } = largestRectangle(turned);
+        areas.push(w * h);
+        if (best === undefined || w * h > best.area * 1.005 || (w * h >= best.area * 0.995 && w / h > best.w / best.h))
+            best = { area: w * h, angle, w, h, at };
+    }
+    if (best === undefined || best.area === 0)
+        throw new Error("a building needs room for a rectangle");
+    const a = best.angle * RAD;
+    const centre = [best.at[0] * Math.cos(a) - best.at[1] * Math.sin(a), best.at[0] * Math.sin(a) + best.at[1] * Math.cos(a)];
+    // The long side runs along `angle` when it is the width, and at a right angle to it when it is the height; a heading is clockwise from north.
+    const along = best.w >= best.h ? best.angle : best.angle + 90;
+    return { heading: (((90 - along) % 180) + 180) % 180, length: Math.max(best.w, best.h), width: Math.min(best.w, best.h), centre, strength: Math.max(...areas) / Math.min(...areas) };
+}

package/dist/venues.js

@@ -0,0 +1,213 @@
+// The real venues: for an arena of the NHL, the outline of its building and the way its rink lies in it (from OpenStreetMap, ODbL 1.0), and a bowl of the seats, the number of seating levels and the kind of roof
+// the sources give (Wikidata, CC0, and the English Wikipedia article each fact cites), fitted inside the outline. Level one is the building: its outline and orientation, as OpenStreetMap maps them. Level two is a plausible
+// bowl: a number of seats in the number of tiers the sources say, between the rink's boards and the building's wall, under the roof's kind. It stops there: no team's or ticket seller's seat map is read or copied, no
+// section or row is named, and no mark of a team or a league is drawn. The drawing is `drawKyogijo({ sport: "nhl", arena, crowd: { real: true } })` and, in 3D, the same options in `buildTurn` or `mountTurn`.
+import { arenaById, arenaRinkIn } from "./arenas.js";
+import { NORTH_ROOM, aislesOf, areaOfOutline, outlinePoints } from "./crowd.js";
+import { NHL, FEET_PER_METRE } from "./geometry.js";
+import { boxOf, edgeDistance, inside, metresFrom, middleOf, northOn, turnedTo } from "./venues.geo.js";
+import { VENUE_DATA } from "./venues.data.js";
+import { VENUE_ATTRIBUTION, VENUE_OSM } from "./venues.osm.data.js";
+export { VENUE_ATTRIBUTION };
+/** The venues by key: every arena of the Pacific division of the NHL, with its facts and its outline. */
+export const VENUES = Object.freeze(Object.fromEntries(VENUE_DATA.map((data) => [data.id, Object.freeze({ ...data, osm: VENUE_OSM[data.id] })])));
+/** The keys of `VENUES`, in the order of the data. */
+export const VENUE_IDS = Object.freeze(VENUE_DATA.map((data) => data.id));
+/** The venue of an arena (by its key in `ARENAS`), or `undefined`. */
+export const venueById = (id) => (id !== undefined && Object.prototype.hasOwnProperty.call(VENUES, id) ? VENUES[id] : undefined);
+/** The venue whose arena is the Wikidata item `Q774138`, or `undefined`. */
+export const venueByWikidata = (wikidata) => Object.values(VENUES).find((venue) => venue.wikidata === wikidata);
+/** The venues of a division of the NHL, in the order of the data. */
+export const venuesIn = (division) => Object.values(VENUES).filter((venue) => venue.division === division);
+/** The arena a venue is of. */
+export const arenaOfVenue = (venue) => {
+    const arena = arenaById(venue.id);
+    if (arena === undefined)
+        throw new Error(`${venue.id} is not an arena`);
+    return arena;
+};
+const round = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
+const lonLat = (ring) => ring.map(([lon, lat]) => [lon, lat]);
+/** How the rink lies in a venue's building (see `VenueOsm.axis`). */
+export const venueOrientation = (venue) => ({ heading: venue.osm.axis.heading, basis: venue.osm.axis.basis, north: round(northOn(venue.osm.axis.heading)) });
+// ---- The bowl. ----
+/** The rink's box as the drawing has it: the arena's own where its sources publish a size, else the NHL's. */
+export function venueRink(venue) {
+    const sized = arenaRinkIn(arenaById(venue.id));
+    return { x: 0, y: 0, w: sized?.length ?? NHL.length, h: sized?.width ?? NHL.width };
+}
+/** How far the first row is from the boards at the sides and at the ends, and the bench side's extra, and the corner's radius: the NHL profile of `crowd.ts`, so that a real venue's first row is the usual one. */
+const FIRST_ROW = { side: 8, end: 8, bench: 6, corner: 40 };
+/** The floor a seat takes in plan, in square feet (ours): a bowl of today's arenas is steeper than the usual drawing's, whose seat is 2 by 2.3 feet (4.6), so that a seat takes less of the floor's area. Tried in turn: a building
+ * with room for the seats at the first has the first; one with less has a steeper bowl, to the last, which is the least a seat takes. */
+export const SEAT_AREAS = [3.8, 3.4, 3];
+/** How far the bowl's outer edge keeps from the building's wall, in feet (ours: the wall and the walk round the bowl). */
+export const WALL = 10;
+/** How far the hall's wall stands beyond the bowl's outer edge, in feet, where the building's outline allows: the concourse and the wall, ours. */
+export const HALL = 30;
+/** The walk between two tiers, in feet (ours: a suite level or a club between two bowls). */
+export const GAP = 10;
+/** The share of the seats in the lowest tier where no source says: a lower bowl is a little more than half. */
+const LOWER_SHARE = 0.56;
+/** A bowl's outer corners, as a share of its half-depth (ours). */
+const CORNER = 0.75;
+/** The height of the first row above the ice, in feet, the rise of a tier's rows by the number of tiers (what the lowest, a middle and the upper bowl rise, at most), the rise of the walk between two tiers (a suite level), and the steepest a bowl is raked, in degrees (ours: no source gives them). */
+export const FIRST_HEIGHT = 4;
+export const RISES = { 1: [40], 2: [26, 40], 3: [24, 20, 36] };
+export const WALK_RISE = 16;
+export const MAX_RAKE = 36;
+const TIER_IDS = { 1: ["lower"], 2: ["lower", "upper"], 3: ["lower", "middle", "upper"] };
+/** How many of a tier's seats are taken, relative to the stands' (the upper tiers are emptier), as `crowd.ts` has them. */
+const FILL = { lower: 1, middle: 0.94, upper: 0.88 };
+/** The height a roof's edge stands over the top row, at the least, in feet. */
+export const CLEARANCE = 22;
+const lerp = (a, b, t) => a + (b - a) * t;
+const between = (a, b, t) => ({ kind: "rrect", x0: lerp(a.x0, b.x0, t), y0: lerp(a.y0, b.y0, t), x1: lerp(a.x1, b.x1, t), y1: lerp(a.y1, b.y1, t), r: lerp(a.r, b.r, t) });
+/** The parameter in `[lo, hi]` at which an increasing function reaches `target` (bisection), or `hi` where it does not. */
+function solveFor(f, lo, hi, target) {
+    if (f(hi) <= target)
+        return hi;
+    let [a, b] = [lo, hi];
+    for (let i = 0; i < 48; i += 1) {
+        const m = (a + b) / 2;
+        if (f(m) < target)
+            a = m;
+        else
+            b = m;
+    }
+    return (a + b) / 2;
+}
+/**
+ * The plan of a venue's bowl: the building's outline turned so that the rink lies along x, a first row round the rink as an NHL arena has it, the largest bowl-shaped outline that fits the building round the middle of its main
+ * hall, and between the two the tiers, the outer edge of each placed so that its band holds the share of the venue's seats the sources give it (at `SEAT_AREAS` square feet a seat), with a walk between the tiers. The
+ * bowl is as long and wide as the building lets it be and as round at the corners as a bowl is; the rest is the building's.
+ * @example
+ * ```ts
+ * import { planVenue, venueById } from "@johnmorrisdotca/kyogijo-stadiums/venues";
+ * const plan = planVenue(venueById("honda-center")!);
+ * console.log(plan.orientation.basis, plan.seats.map((t) => t.tier).join(" "), plan.total);
+ * // building lower upper 17174
+ * ```
+ */
+export function planVenue(venue, rink = venueRink(venue)) {
+    const key = `${rink.x}|${rink.y}|${rink.w}|${rink.h}`;
+    const mine = PLANS.get(venue) ?? new Map();
+    PLANS.set(venue, mine);
+    const known = mine.get(key);
+    if (known !== undefined)
+        return known;
+    const made = plan(venue, rink);
+    mine.set(key, made);
+    return made;
+}
+/** Plans already made, by venue and rink: a plan is a pure function of a venue and a rink, and a drawing asks for it more than once. */
+const PLANS = new WeakMap();
+function plan(venue, rink) {
+    const orientation = venueOrientation(venue);
+    const origin = middleOf(lonLat(venue.osm.ring));
+    const turned = (ring) => metresFrom(origin, lonLat(ring)).map((p) => turnedTo(orientation.heading, p));
+    const outline = turned(venue.osm.ring);
+    // The rink stands in the middle of the ice where OpenStreetMap maps it, else in the middle of the building's main hall.
+    const [middle] = turned([venue.osm.axis.centre]);
+    const at = [rink.x + rink.w / 2, rink.y + rink.h / 2];
+    const footprint = outline.map(([x, y]) => [round((x - middle[0]) * FEET_PER_METRE + at[0], 2), round((y - middle[1]) * FEET_PER_METRE + at[1], 2)]);
+    const fb = boxOf(footprint);
+    // The first row round the rink, and the largest bowl-shaped outline that fits inside the building round the middle of the hall: as much longer than wide as the hall is, and as round at the corners as a bowl is.
+    const first = { kind: "rrect", x0: rink.x - FIRST_ROW.end, y0: rink.y - FIRST_ROW.side, x1: rink.x + rink.w + FIRST_ROW.end, y1: rink.y + rink.h + FIRST_ROW.side + FIRST_ROW.bench, r: FIRST_ROW.corner };
+    // The aspect that holds the most: a bowl is between 1.15 and 1.6 times as long as it is wide, as much as the hall allows.
+    const shapedAs = (long, s) => ({ kind: "rrect", x0: at[0] - long * s, y0: at[1] - s, x1: at[0] + long * s, y1: at[1] + s, r: CORNER * s });
+    const largest = (long) => {
+        let [lo, hi] = [60, Math.max(fb.x1 - fb.x0, fb.y1 - fb.y0)];
+        for (let i = 0; i < 24; i += 1) {
+            const m = (lo + hi) / 2;
+            if (outlinePoints(shapedAs(long, m)).every((p) => inside(footprint, p) && edgeDistance(footprint, p) >= WALL))
+                lo = m;
+            else
+                hi = m;
+        }
+        return lo;
+    };
+    const tries = [1.15, 1.25, 1.35, 1.45, 1.6].map((long) => ({ long, s: largest(long) }));
+    const best = tries.reduce((a, b) => (a.long * a.s * a.s >= b.long * b.s * b.s ? a : b));
+    const lo = best.s;
+    const shaped = (s) => shapedAs(best.long, s);
+    const wall = shaped(lo);
+    // A building too small for the first row and a tier's depth is given the room: the bowl then lies beyond its walls (`fit` says so).
+    const outer = { ...wall, x0: Math.min(wall.x0, first.x0 - 40), y0: Math.min(wall.y0, first.y0 - 40), x1: Math.max(wall.x1, first.x1 + 40), y1: Math.max(wall.y1, first.y1 + 40) };
+    const depth = (first.x0 - outer.x0) + (first.y0 - outer.y0) + (outer.x1 - first.x1) + (outer.y1 - first.y1);
+    const gap = GAP / Math.max(20, depth / 4);
+    // The tiers, from the rink out: each takes its share of the seats, then the walk. A building with less room than the seats need at the first of `SEAT_AREAS` a seat gets a bowl that is steeper (a seat takes less of the floor), down
+    // to the least a seat can take; where even that is too little the bowl holds fewer seats than the venue and `fit` says `tight`.
+    const count = venue.tiers.count;
+    const lower = venue.tiers.lowerShare ?? (count === 1 ? 1 : count === 2 ? LOWER_SHARE : 0.4);
+    const shares = count === 1 ? [1] : count === 2 ? [lower, 1 - lower] : [lower, (1 - lower) * 0.36, (1 - lower) * 0.64];
+    const outlineAt = (t) => between(first, outer, t);
+    const build = (area) => {
+        const seatsOf = (region, hole) => Math.round((areaOfOutline(region) - areaOfOutline(hole)) / area);
+        const rings = [];
+        let t0 = 0;
+        let tight = false;
+        let up = FIRST_HEIGHT;
+        shares.forEach((share, k) => {
+            const wanted = venue.seats.hockey * share;
+            const t1 = solveFor((t) => seatsOf(outlineAt(t), outlineAt(t0)), t0, 1, wanted);
+            if (seatsOf(outlineAt(t1), outlineAt(t0)) < wanted - 1)
+                tight = true;
+            const region = outlineAt(t1);
+            const hole = outlineAt(t0);
+            const tier = TIER_IDS[count][k];
+            // The band's depth along the two long sides on average, where the bowl is the shallowest and the rake the steepest: the rise is what a rake of at most `MAX_RAKE` degrees gives over it, up to the usual rise of a tier of its place.
+            const run = (region.y1 - hole.y1 + (hole.y0 - region.y0)) / 2;
+            const rise = Math.min(RISES[count][k], Math.max(6, run * Math.tan((MAX_RAKE * Math.PI) / 180)));
+            const [h0, h1] = [k === 0 ? FIRST_HEIGHT : up + WALK_RISE, (k === 0 ? FIRST_HEIGHT : up + WALK_RISE) + rise];
+            up = h1;
+            rings.push({
+                id: tier,
+                tier,
+                region,
+                hole,
+                // Its depth at the bench side, from the first row, as the tunnel and the camera are placed.
+                from: round(hole.y1 - first.y1, 2),
+                to: round(region.y1 - first.y1, 2),
+                height: [round(h0), round(h1)],
+                rake: round((Math.atan2(h1 - h0, Math.max(1, run)) * 180) / Math.PI),
+                fill: FILL[tier],
+                seats: seatsOf(region, hole),
+                aisles: aislesOf(region, hole),
+            });
+            t0 = Math.min(1, t1 + gap);
+        });
+        return { rings, tight };
+    };
+    let seatArea = SEAT_AREAS[0];
+    let made = build(seatArea);
+    for (const area of SEAT_AREAS.slice(1)) {
+        if (!made.tight)
+            break;
+        seatArea = area;
+        made = build(area);
+    }
+    const { rings, tight } = made;
+    // The rounding of each tier's seats leaves the total a seat or two off the venue's: the last tier takes the difference, so that a bowl that fits holds exactly the seats the sources give.
+    const missing = venue.seats.hockey - rings.reduce((sum, ring) => sum + ring.seats, 0);
+    if (!tight && Math.abs(missing) <= 3)
+        rings[rings.length - 1].seats += missing;
+    const total = rings.reduce((sum, ring) => sum + ring.seats, 0);
+    const top = rings[rings.length - 1].height[1];
+    const edge = Math.max(round((venue.osm.height ?? 0) * FEET_PER_METRE), top + CLEARANCE);
+    const north = orientation.basis === "none" ? undefined : orientation.north;
+    const room = north === undefined ? 0 : NORTH_ROOM;
+    const bowl = {
+        rings,
+        off: { left: FIRST_ROW.end, right: FIRST_ROW.end, top: FIRST_ROW.side, bottom: FIRST_ROW.side + FIRST_ROW.bench },
+        reach: { left: Math.max(0, rink.x - fb.x0), right: Math.max(0, fb.x1 - rink.x - rink.w), top: Math.max(0, rink.y - fb.y0) + room, bottom: Math.max(0, fb.y1 - rink.y - rink.h) },
+        shell: { footprint, hall: { ...outer, x0: outer.x0 - HALL, y0: outer.y0 - HALL, x1: outer.x1 + HALL, y1: outer.y1 + HALL, r: outer.r + HALL }, ...(north === undefined ? {} : { north }), roof: venue.roof.kind, edge },
+    };
+    return { venue, orientation, box: rink, footprint, bowl, seats: rings.map((ring) => ({ tier: ring.tier, seats: ring.seats })), total, seatArea, fit: tight ? "tight" : "fits" };
+}
+/** The stands of a venue for `layoutOf` and the 3D view, round a rink: `planVenue`'s bowl. */
+export const venueBowl = (venue, rink) => planVenue(venue, rink).bowl;
+/** Whether the bowl lies inside the building: every corner of every tier's outer edge is inside the footprint. */
+export function bowlInside(plan) {
+    return outlinePoints(plan.bowl.rings[plan.bowl.rings.length - 1].region).every((p) => inside(plan.footprint, p));
+}

package/dist/venues.osm.data.d.ts

@@ -0,0 +1,4 @@
+import type { VenueOsm } from "./venues.ts";
+/** The credit the ODbL asks for, wherever a drawing made from this data is shown. */
+export declare const VENUE_ATTRIBUTION = "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright";
+export declare const VENUE_OSM: Record<string, VenueOsm>;