@johnmorrisdotca/kyogijo-stadiums 0.23.0 → 0.25.0

package/dist/venue.real.d.ts

@@ -0,0 +1,16 @@
+import { type Pt, type RealShell, type StandRing } from "./crowd.ts";
+import { type Upright } from "./turn.kit.ts";
+/** 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 declare const LID_RISE = 22;
+export declare const SADDLE_RISE = 30;
+/** 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 declare function saddleAt(real: Pick<RealShell, "footprint">, [x, y]: Pt): number;
+/** The height of the roof over a point of the building's edge, above the surface, in feet. */
+export declare const roofAt: (real: RealShell, p: Pt) => number;
+/**
+ * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
+ * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
+ */
+export declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number): Items;
+type Items = Upright[];
+export {};

package/dist/venue.real.js

@@ -0,0 +1,103 @@
+// The building of a real venue, raised: its walls, standing on the outline OpenStreetMap gives, and its roof over the top tier, a lid that rises towards the middle or a saddle that rises at the two ends and falls at the two
+// sides. Both 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 { pointList, raked } from "./venue.geom.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;
+/** 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]);
+    const ys = real.footprint.map((p) => p[1]);
+    const [cx, cy] = [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+    const [hx, hy] = [(Math.max(...xs) - Math.min(...xs)) / 2, (Math.max(...ys) - Math.min(...ys)) / 2];
+    const s = ((x - cx) / hx) ** 2 - ((y - cy) / hy) ** 2;
+    return (1 + Math.max(-1, Math.min(1, s))) / 2;
+}
+/** 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);
+/** The point where a ray from `from` first meets a polygon, or `undefined`. */
+function firstHit(poly, from, angle) {
+    const [dx, dy] = [Math.cos(angle), Math.sin(angle)];
+    let best;
+    poly.forEach(([ax, ay], i) => {
+        const [bx, by] = poly[(i + 1) % poly.length];
+        const [ex, ey] = [bx - ax, by - ay];
+        const den = dx * ey - dy * ex;
+        if (Math.abs(den) < 1e-12)
+            return;
+        const t = ((ax - from[0]) * ey - (ay - from[1]) * ex) / den;
+        const u = ((ax - from[0]) * dy - (ay - from[1]) * dx) / den;
+        if (t > 1e-6 && u >= 0 && u <= 1 && (best === undefined || t < best.t))
+            best = { t, p: [from[0] + dx * t, from[1] + dy * t] };
+    });
+    return best?.p;
+}
+/** The plane a quad of points with heights lies nearest to, as a slope: least squares through its corners. */
+function slopeThrough(points) {
+    const m = points.length;
+    const [mx, my, mz] = [points.reduce((s, p) => s + p[0], 0) / m, points.reduce((s, p) => s + p[1], 0) / m, points.reduce((s, p) => s + p[2], 0) / m];
+    let [sxx, sxy, syy, sxz, syz] = [0, 0, 0, 0, 0];
+    for (const [x, y, z] of points) {
+        sxx += (x - mx) ** 2;
+        sxy += (x - mx) * (y - my);
+        syy += (y - my) ** 2;
+        sxz += (x - mx) * (z - mz);
+        syz += (y - my) * (z - mz);
+    }
+    const det = sxx * syy - sxy * sxy;
+    const [gx, gy] = Math.abs(det) < 1e-9 ? [0, 0] : [(sxz * syy - syz * sxy) / det, (syz * sxx - sxz * sxy) / det];
+    return { x0: mx, y0: my, z0: mz, gx, gy };
+}
+/**
+ * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
+ * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
+ */
+export function realBuilding(real, top, centre, lift, steps) {
+    const items = [];
+    const c = [centre[0], centre[1]];
+    const rim = Array.from({ length: steps }, (_, k) => {
+        const angle = (2 * Math.PI * k) / steps;
+        const cap = rayAt(real.hall, c[0], c[1], angle);
+        const out = firstHit(real.footprint, c, angle);
+        return out !== undefined && Math.hypot(out[0] - c[0], out[1] - c[1]) < Math.hypot(cap[0] - c[0], cap[1] - c[1]) ? out : cap;
+    });
+    const planes = [];
+    rim.forEach((a, i) => {
+        const b = rim[(i + 1) % steps];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (long < 1)
+            return;
+        const high = lift + 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="u-shell" width="${n(long)}" height="${n(high)}"/>`), centre), fadeTo: 0.02 });
+    });
+    if (planes.length > 0)
+        items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
+    if (top?.hole == null)
+        return items;
+    const roof = [];
+    const hole = top.hole;
+    const inner = rim.map((_, k) => rayAt(hole, c[0], c[1], (2 * Math.PI * k) / steps));
+    const rise = real.roof === "saddle" ? 0 : LID_RISE;
+    const zOf = (p, inward) => lift + roofAt(real, p) + (inward ? rise : 0);
+    for (let k = 0; k < steps; k += 1) {
+        const [a, b] = [rim[k], rim[(k + 1) % steps]];
+        const [ai, bi] = [inner[k], inner[(k + 1) % steps]];
+        const quad = [ai, bi, b, a];
+        const heights = [zOf(ai, true), zOf(bi, true), zOf(b, false), zOf(a, false)];
+        const slope = slopeThrough(quad.map((p, i) => [p[0], p[1], heights[i]]));
+        const [ex, ey] = [b[0] - a[0], b[1] - a[1]];
+        const el = Math.hypot(ex, ey);
+        if (el < 1e-6)
+            continue;
+        const mid = [(a[0] + b[0] + ai[0] + bi[0]) / 4, (a[1] + b[1] + ai[1] + bi[1]) / 4];
+        const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]);
+        const piece = raked(`roof-${k}`, "roof", quad, slope, [ex / el, ey / el], (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>`);
+        if (piece !== undefined)
+            roof.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] });
+    }
+    if (roof.length > 0)
+        items.push({ id: "roof", kind: "roof", at: centre, height: Math.max(...roof.flatMap((p) => [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]])), planes: roof });
+    return items;
+}

package/dist/venues-entry.d.ts

@@ -0,0 +1,2 @@
+export { VENUE_ATTRIBUTION, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn } from "./venues.ts";
+export type { RealVenue, RealVenueData, VenueBasis, VenueDivision, VenueOrientation, VenueOsm, VenuePlan, VenueRoof } from "./venues.ts";

package/dist/venues-entry.js

@@ -0,0 +1,2 @@
+// The real venues of the NHL's arenas: the outline of each building and the way its rink lies (OpenStreetMap, ODbL 1.0) and a plausible bowl from the seats, tiers and roof the sources give (Wikidata, Wikipedia).
+export { VENUE_ATTRIBUTION, VENUE_IDS, VENUES, arenaOfVenue, bowlInside, planVenue, venueBowl, venueById, venueByWikidata, venueOrientation, venueRink, venuesIn } from "./venues.js";

package/dist/venues.d.ts

@@ -0,0 +1,153 @@
+import { type Arena, type ArenaSource } from "./arenas.ts";
+import { type Box, type Pt, type RealBowl } from "./crowd.ts";
+import { VENUE_ATTRIBUTION } from "./venues.osm.data.ts";
+export { VENUE_ATTRIBUTION };
+/** How a fact is known: `documented` is what a source cited with it says; `plausible` is ours, for a bowl no source describes. */
+export type VenueBasis = "documented" | "plausible";
+/** The kinds of roof the venues have: `fixed` is a lid over the bowl, `saddle` a roof that rises at the two ends and falls at the two sides (the Scotiabank Saddledome's). */
+export type VenueRoof = "fixed" | "saddle";
+/** The NHL's divisions that have venues so far. */
+export type VenueDivision = "pacific";
+/** The facts of a venue: the seats and the number of seating levels and the kind of roof, each with what a source says. No text of an article is kept. */
+export interface RealVenueData {
+    /** The key of the arena in `ARENAS`: `honda-center`. */
+    id: string;
+    /** The Wikidata item of the arena. */
+    wikidata: string;
+    division: VenueDivision;
+    /** The English Wikipedia article the facts that are not Wikidata's were read from, at a revision. */
+    en: ArenaSource;
+    seats: {
+        /** The seats for ice hockey: Wikidata's where its item gives a figure for ice hockey (`wikidata`), else the article's (`wikipedia`). */
+        hockey: number;
+        source: "wikidata" | "wikipedia";
+        /** Wikidata's own capacity (P1083), kept beside it: it is often for another event, or an older year. */
+        wikidata: number;
+        /** What was read, in a few words of ours. */
+        read: string;
+    };
+    tiers: {
+        /** The seating levels (bowls), with the suites and the clubs that lie between them counted as walks, not tiers. */
+        count: 1 | 2 | 3;
+        basis: VenueBasis;
+        /** The share of the seats that are in the lowest tier, where a source gives it. */
+        lowerShare?: number;
+        read: string;
+    };
+    roof: {
+        kind: VenueRoof;
+        basis: VenueBasis;
+        read: string;
+    };
+}
+/** What OpenStreetMap gave of a venue: ODbL 1.0 data, "(c) OpenStreetMap contributors". */
+export interface VenueOsm {
+    /** The element the outline is: `way/120623151`. */
+    source: string;
+    /** The day it was read and the time of the OpenStreetMap data the answer was made from. */
+    read: string;
+    base: string;
+    licence: "ODbL-1.0";
+    attribution: string;
+    /** The building's height in metres, where OpenStreetMap maps one. */
+    height?: number;
+    /** The building's outline as `[longitude, latitude]`, not repeating its first point. */
+    ring: [number, number][];
+    /** The ice, where OpenStreetMap maps it inside the building: the element and its outline. */
+    ice?: {
+        source: string;
+        ring: [number, number][];
+    };
+    /**
+     * How the rink lies, worked out when the data was made: the heading of its long side (degrees clockwise from north, 0 to under 180), how that is known (`mapped`: from the ice OpenStreetMap maps; `building`: from the long
+     * axis of the building's main hall, the largest rectangle that fits its outline, which a rink usually follows, an inference; `none`: the building has no direction, 90 is stood in), how much of a direction the building has
+     * (`strength`, 1 for a round one) and how much longer than wide its main hall is (`elongation`), and the middle of the ice or of the main hall as `[longitude, latitude]`.
+     */
+    axis: {
+        heading: number;
+        basis: "mapped" | "building" | "none";
+        strength: number;
+        elongation: number;
+        centre: [number, number];
+    };
+}
+/** A venue: its facts and what OpenStreetMap gave. */
+export interface RealVenue extends RealVenueData {
+    osm: VenueOsm;
+}
+/** How the rink lies in the building: its long side's heading (degrees clockwise from north, 0 to under 180), how that is known, and the way north points on the page (degrees clockwise from the top). */
+export interface VenueOrientation {
+    heading: number;
+    /** `mapped`: from the ice OpenStreetMap maps in the building. `building`: from the building's long axis, which a rink usually follows (an inference). `none`: the building is near round, nothing is known, the plan has north at the top. */
+    basis: "mapped" | "building" | "none";
+    north: number;
+}
+/** The venues by key: every arena of the Pacific division of the NHL, with its facts and its outline. */
+export declare const VENUES: Readonly<Record<string, RealVenue>>;
+/** The keys of `VENUES`, in the order of the data. */
+export declare const VENUE_IDS: readonly string[];
+/** The venue of an arena (by its key in `ARENAS`), or `undefined`. */
+export declare const venueById: (id: string | undefined) => RealVenue | undefined;
+/** The venue whose arena is the Wikidata item `Q774138`, or `undefined`. */
+export declare const venueByWikidata: (wikidata: string | undefined) => RealVenue | undefined;
+/** The venues of a division of the NHL, in the order of the data. */
+export declare const venuesIn: (division: VenueDivision) => RealVenue[];
+/** The arena a venue is of. */
+export declare const arenaOfVenue: (venue: RealVenue) => Arena;
+/** How the rink lies in a venue's building (see `VenueOsm.axis`). */
+export declare const venueOrientation: (venue: RealVenue) => VenueOrientation;
+/** The rink's box as the drawing has it: the arena's own where its sources publish a size, else the NHL's. */
+export declare function venueRink(venue: RealVenue): Box;
+/** 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 declare const SEAT_AREAS: readonly number[];
+/** 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 declare 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 declare const HALL = 30;
+/** The walk between two tiers, in feet (ours: a suite level or a club between two bowls). */
+export declare const GAP = 10;
+/** 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 declare const FIRST_HEIGHT = 4;
+export declare const RISES: Readonly<Record<1 | 2 | 3, readonly number[]>>;
+export declare const WALK_RISE = 16;
+export declare const MAX_RAKE = 36;
+/** The height a roof's edge stands over the top row, at the least, in feet. */
+export declare const CLEARANCE = 22;
+/** The plan of a venue: its building in the drawing's frame, the bowl fitted inside, and how it lies. */
+export interface VenuePlan {
+    venue: RealVenue;
+    orientation: VenueOrientation;
+    /** The rink, in the drawing's frame. */
+    box: Box;
+    /** The building's outline in feet, in the drawing's frame (the rink along x, in the middle of the building's box). */
+    footprint: Pt[];
+    /** The stands for `layoutOf`: tiers, first row, ground, and the building and roof. */
+    bowl: RealBowl;
+    /** The seats the bowl's tiers hold, by tier, and in all: equal to the venue's seats where the building has room (`fit` is `fits`) and fewer where it has not (`tight`). */
+    seats: {
+        tier: string;
+        seats: number;
+    }[];
+    total: number;
+    /** The floor a seat takes in the plan, in square feet (one of `SEAT_AREAS`). */
+    seatArea: number;
+    fit: "fits" | "tight";
+}
+/**
+ * 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 declare function planVenue(venue: RealVenue, rink?: Box): VenuePlan;
+/** The stands of a venue for `layoutOf` and the 3D view, round a rink: `planVenue`'s bowl. */
+export declare const venueBowl: (venue: RealVenue, rink?: Box) => RealBowl;
+/** Whether the bowl lies inside the building: every corner of every tier's outer edge is inside the footprint. */
+export declare function bowlInside(plan: VenuePlan): boolean;

package/dist/venues.data.d.ts

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

package/dist/venues.data.js

@@ -0,0 +1,74 @@
+export const VENUE_DATA = [
+    {
+        "id": "honda-center",
+        "wikidata": "Q774138",
+        "division": "pacific",
+        "en": { "title": "Honda Center", "revision": 1380000927 },
+        "seats": { "hockey": 17174, "source": "wikipedia", "wikidata": 17174, "read": "the article's seating line for the Ducks, 17,174, which the infobox gives for ice hockey too; Wikidata's one capacity (P1083) is the same" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls (a lower and an upper) are drawn, the usual for an arena of 17,000 seats; the article speaks of two full levels of ribbon displays, one on each bowl's fascia, which agrees" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "scotiabank-saddledome",
+        "wikidata": "Q1140083",
+        "division": "pacific",
+        "en": { "title": "Scotiabank Saddledome", "revision": 1377341466 },
+        "seats": { "hockey": 19289, "source": "wikipedia", "wikidata": 16605, "read": "the infobox's present figure for hockey (19,289, from 1995), which the article's amenities line gives too; Wikidata's 16,605 is the 1983 figure and the first the infobox lists" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article speaks of the lower bowl, a second level and upper loges above it: two seating levels with suites at the top of the lower bowl" },
+        "roof": { "kind": "saddle", "basis": "documented", "read": "the article says the roof is a reverse hyperbolic paraboloid, shaped like a horse saddle; which way the saddle lies over the ice is not given: it is drawn high at the two ends" },
+    },
+    {
+        "id": "rogers-place",
+        "wikidata": "Q5339036",
+        "division": "pacific",
+        "en": { "title": "Rogers Place", "revision": 1380110483 },
+        "seats": { "hockey": 18641, "source": "wikidata", "wikidata": 18641, "read": "Wikidata's capacity for ice hockey (P1083 with the sport P641 ice hockey); the article's own line gives 18,347 for a hockey arena, 1.6 percent fewer, and OpenStreetMap has 18,641" },
+        "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" },
+    },
+    {
+        "id": "crypto-com-arena",
+        "wikidata": "Q186080",
+        "division": "pacific",
+        "en": { "title": "Crypto.com Arena", "revision": 1380458624 },
+        "seats": { "hockey": 18145, "source": "wikipedia", "wikidata": 19060, "read": "the article's figure for ice hockey, 18,145, which the infobox gives too; Wikidata's one capacity (19,060) is not for hockey" },
+        "tiers": { "count": 2, "basis": "documented", "lowerShare": 0.667, "read": "the article says two thirds of the seating, with the club seats, is in the lower bowl, and that three levels of suites lie between the lower and upper bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "sap-center",
+        "wikidata": "Q261863",
+        "division": "pacific",
+        "en": { "title": "SAP Center", "revision": 1380804230 },
+        "seats": { "hockey": 17435, "source": "wikipedia", "wikidata": 19190, "read": "the article says the hockey capacity changed from 17,562 to 17,435 when the new premium seating was finished (2023); Wikidata's one capacity (19,190) is the concert one" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of club levels and a penthouse, which are not seating bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "climate-pledge-arena",
+        "wikidata": "Q977529",
+        "division": "pacific",
+        "en": { "title": "Climate Pledge Arena", "revision": 1380851727 },
+        "seats": { "hockey": 17151, "source": "wikipedia", "wikidata": 18000, "read": "the article's seating capacity for ice hockey, 17,151, which the infobox gives too; Wikidata's one capacity (18,000) is near the basketball one (18,300)" },
+        "tiers": { "count": 2, "basis": "documented", "read": "the article tells of the upper level and the lower level, most of the lower level being below street level since the 2021 rebuild: two seating levels" },
+        "roof": { "kind": "fixed", "basis": "documented", "read": "the article says the original 1962 roof's shape was kept and carried on a fixed roof of steel trusses (the first, cable-hung, roof being taken down), and that the roof is landmarked" },
+    },
+    {
+        "id": "rogers-arena",
+        "wikidata": "Q517318",
+        "division": "pacific",
+        "en": { "title": "Rogers Arena", "revision": 1379918849 },
+        "seats": { "hockey": 18871, "source": "wikipedia", "wikidata": 18422, "read": "the infobox's present figure for ice hockey (18,871, from 2018); Wikidata's 18,422 is the 1995 figure and the first the infobox lists" },
+        "tiers": { "count": 2, "basis": "plausible", "read": "no source says how many seating levels there are: two bowls are drawn; the article speaks of a lower bowl; OpenStreetMap maps four building levels, which are floors, not seating bowls" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise" },
+    },
+    {
+        "id": "t-mobile-arena",
+        "wikidata": "Q3338973",
+        "division": "pacific",
+        "en": { "title": "T-Mobile Arena", "revision": 1379155307 },
+        "seats": { "hockey": 17500, "source": "wikipedia", "wikidata": 20000, "read": "the infobox's figure for ice hockey, 17,500 (20,000 with standing room); Wikidata's one capacity (20,000) is the one with standing room" },
+        "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.geo.d.ts

@@ -0,0 +1,60 @@
+import type { Pt } from "./crowd.ts";
+/** A point as `[longitude, latitude]`, in degrees, the order OpenStreetMap's GeoJSON gives. */
+export type LonLat = readonly [number, number];
+/** 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 declare function metresFrom(origin: LonLat, ring: readonly LonLat[]): Pt[];
+/** The inverse of `metresFrom`: a point given as east and north metres from `origin`, in degrees. */
+export declare function lonLatFrom(origin: LonLat, [east, north]: Pt): LonLat;
+/** The mean of a ring's longitudes and latitudes: a point to measure from. */
+export declare const middleOf: (ring: readonly LonLat[]) => LonLat;
+/** The area of a polygon, unsigned. */
+export declare function areaOf(points: readonly Pt[]): number;
+/** The centre of mass of a polygon's area. */
+export declare function centroidOf(points: readonly Pt[]): Pt;
+/** The convex hull of some points (Andrew's monotone chain), counter-clockwise. */
+export declare function hullOf(points: readonly Pt[]): Pt[];
+/** 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 declare const axisHeading: (east: number, north: number) => number;
+/** 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 declare function smallestBox(points: readonly Pt[]): {
+    heading: number;
+    length: number;
+    width: number;
+};
+/**
+ * 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 declare function turnedTo(heading: number, [east, north]: Pt): Pt;
+/** 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 declare const northOn: (heading: number) => number;
+/** 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 declare function simplified(ring: readonly Pt[], tolerance: number): Pt[];
+/** Whether a point is in a polygon (even-odd). */
+export declare function inside(points: readonly Pt[], [x, y]: Pt): boolean;
+/** The smallest box round some points. */
+export declare function boxOf(points: readonly Pt[]): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** The distance from a point to the nearest edge of a polygon. */
+export declare function edgeDistance(points: readonly Pt[], [x, y]: Pt): number;
+/** What `coreOf` finds: the building's main hall, as the largest rectangle that lies inside its outline. */
+export interface Core {
+    /** The heading of the rectangle's long side, 0 to under 180, degrees clockwise from north. */
+    heading: number;
+    /** The rectangle's long and short sides, in the units of the points. */
+    length: number;
+    width: number;
+    /** The middle of the rectangle, as east and north from the points' origin. */
+    centre: Pt;
+    /** How much the best direction beats the worst: the largest rectangle's area over the smallest, over every direction. A round building has 1; a building with a direction has more. */
+    strength: number;
+}
+/**
+ * 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 declare function coreOf(points: readonly Pt[]): Core;

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) };
+}