@johnmorrisdotca/kyogijo-stadiums 0.40.1 → 0.43.0

package/dist/venue.real.d.ts

@@ -1,5 +1,5 @@
 import { type Pt, type RealShell, type StandRing } from "./crowd.ts";
-import { type Upright } from "./turn.kit.ts";
+import { type Plane, 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;
@@ -9,6 +9,22 @@ export declare function saddleAt(real: Pick<RealShell, "footprint">, [x, y]: Pt)
 export declare const roofAt: (real: RealShell, p: Pt) => number;
 /** The point where a ray from `from` first meets a polygon, or `undefined`. */
 export declare function firstHit(poly: readonly Pt[], from: Pt, angle: number): Pt | undefined;
+/** How tall the glazed concourse band over a podium is, in feet (ours). */
+export declare const GLAZING = 14;
+/** The point of the hall's rim at an angle from the middle: where a ray meets the hall's outline or the building's, whichever it meets first. */
+export declare function rimPoint(real: Pick<RealShell, "hall" | "footprint">, c: Pt, angle: number): Pt;
+/** How far a mast leans out from the vertical, in degrees (ours: the sources give the count and the height of BC Place's masts, and the photographs of the building show them leaning out from the rim). */
+export declare const MAST_LEAN = 12;
+/** How thick a mast is drawn, in feet (ours). */
+export declare const MAST_WIDTH = 6;
+/**
+ * The masts of a cable roof: `count` of them round the rim, each rising from the rim at the roof's edge, `height` feet, leaning out from the middle. A mast is two thin strips crossed, one in the plane of the slant and the
+ * radius and one in the plane of the slant and the tangent, so that it is seen from every side (as a post is). The count and the height are the sources'; the lean and the thickness are ours.
+ */
+export declare function mastPlanes(real: Pick<RealShell, "hall" | "footprint">, c: Pt, z: number, masts: {
+    count: number;
+    height: number;
+}): Plane[];
 /**
  * The walls and the roof of a real venue (`parts` says which are made). 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).
@@ -17,6 +33,11 @@ export declare function realBuilding(real: RealShell, top: StandRing | undefined
     walls: boolean;
     roof: boolean;
 }): Items;
+/** How far a skylight cap stands over the inner edge of the roof's band, and how wide the skylight bar is, in feet (ours: the sources do not say how high the roof closes or how wide the glass is). */
+export declare const CAP_RISE = 7;
+export declare const SKYLIGHT_WIDTH = 14;
+/** The share of the opening's length the skylight bar runs over, from the middle each way. */
+export declare const SKYLIGHT_SHARE = 0.78;
 /** 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 declare const CANOPY_NOTE = "low over the field, high over the back of the stands";
 /** 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). */

package/dist/venue.real.js

@@ -53,6 +53,46 @@ function slopeThrough(points) {
     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 };
 }
+/** How tall the glazed concourse band over a podium is, in feet (ours). */
+export const GLAZING = 14;
+/** A wall's two bands: the podium at its foot (a shade darker), a ledge over it and a band of glazing over the ledge, on the wall's own plane (its y runs down from the top). */
+function podiumBands(long, high, podium) {
+    const top = Math.min(podium, high * 0.6);
+    const glaze = Math.min(GLAZING, Math.max(0, high - top - 4));
+    return `<rect class="u-podium" y="${n(high - top)}" width="${n(long)}" height="${n(top)}"/><rect class="u-ledge" y="${n(high - top - 1.2)}" width="${n(long)}" height="1.2"/>${glaze > 2 ? `<rect class="u-glazing" y="${n(high - top - 1.2 - glaze)}" width="${n(long)}" height="${n(glaze)}"/>` : ""}`;
+}
+/** The point of the hall's rim at an angle from the middle: where a ray meets the hall's outline or the building's, whichever it meets first. */
+export function rimPoint(real, c, angle) {
+    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;
+}
+/** How far a mast leans out from the vertical, in degrees (ours: the sources give the count and the height of BC Place's masts, and the photographs of the building show them leaning out from the rim). */
+export const MAST_LEAN = 12;
+/** How thick a mast is drawn, in feet (ours). */
+export const MAST_WIDTH = 6;
+/**
+ * The masts of a cable roof: `count` of them round the rim, each rising from the rim at the roof's edge, `height` feet, leaning out from the middle. A mast is two thin strips crossed, one in the plane of the slant and the
+ * radius and one in the plane of the slant and the tangent, so that it is seen from every side (as a post is). The count and the height are the sources'; the lean and the thickness are ours.
+ */
+export function mastPlanes(real, c, z, masts) {
+    const planes = [];
+    const lean = (MAST_LEAN * Math.PI) / 180;
+    for (let i = 0; i < masts.count; i += 1) {
+        const angle = (2 * Math.PI * (i + 0.5)) / masts.count;
+        const [bx, by] = rimPoint(real, c, angle);
+        const [rx, ry] = [Math.cos(angle), Math.sin(angle)];
+        const [tx, ty] = [-ry, rx];
+        const slant = [rx * masts.height * Math.sin(lean), ry * masts.height * Math.sin(lean), masts.height * Math.cos(lean)];
+        const long = Math.hypot(...slant);
+        const half = MAST_WIDTH / 2;
+        const svg = `<polygon class="u-mast" points="0 ${n(half)} ${n(long)} ${n(half * 0.45)} ${n(long)} ${n(half * 1.55)}"/>`;
+        // A strip along the slant, across the tangent; and one along the slant, across the radius.
+        planes.push({ id: `mast-${i}-a`, kind: "mast", o: [bx - tx * half, by - ty * half, z], u: slant, v: [tx * MAST_WIDTH, ty * MAST_WIDTH, 0], svg });
+        planes.push({ id: `mast-${i}-b`, kind: "mast", o: [bx - rx * half, by - ry * half, z], u: slant, v: [rx * MAST_WIDTH, ry * MAST_WIDTH, 0], svg });
+    }
+    return planes;
+}
 /**
  * The walls and the roof of a real venue (`parts` says which are made). 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).
@@ -60,12 +100,7 @@ function slopeThrough(points) {
 export function realBuilding(real, top, centre, lift, steps, open = false, parts = { walls: true, roof: true }) {
     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 rim = Array.from({ length: steps }, (_, k) => rimPoint(real, c, (2 * Math.PI * k) / steps));
     const planes = [];
     rim.forEach((a, i) => {
         const b = rim[(i + 1) % steps];
@@ -73,7 +108,7 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         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)}"/>`), centre), fadeTo: 0.02 });
+        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 });
     });
     if (parts.walls && planes.length > 0)
         items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
@@ -127,12 +162,46 @@ export function realBuilding(real, top, centre, lift, steps, open = false, parts
         if (piece !== undefined)
             roof.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] });
     }
+    if (crown === undefined && real.skylight === true)
+        roof.push(...skylightCap(inner, c, lift + real.edge + rise));
     if (crown !== undefined)
         roof.push(...cablePod(lift + real.edge + crown.rise, inner, c, steps, open));
+    if (crown !== undefined && real.masts !== undefined)
+        roof.push(...mastPlanes(real, c, lift + real.edge, real.masts));
     if (roof.length > 0)
         items.push({ id: "roof", kind: "roof", at: centre, height: heightOf(roof), planes: roof });
     return items;
 }
+/** How far a skylight cap stands over the inner edge of the roof's band, and how wide the skylight bar is, in feet (ours: the sources do not say how high the roof closes or how wide the glass is). */
+export const CAP_RISE = 7;
+export const SKYLIGHT_WIDTH = 14;
+/** The share of the opening's length the skylight bar runs over, from the middle each way. */
+export const SKYLIGHT_SHARE = 0.78;
+/**
+ * Close the roof's middle: the opening the band leaves is covered at `z` by a flat cap raised `CAP_RISE` over the band's inner edge, with a short skirt joining the two, and over the middle of the cap along the long axis lies a long
+ * skylight bar of glass (the roof of Rogers Arena has one; the surface's long side lies along x in the drawing's frame, so the bar runs along x). The shape and the sizes are ours.
+ */
+function skylightCap(hole, c, z) {
+    const planes = [];
+    const top = z + CAP_RISE;
+    const cap = raked("cap", "roof", hole, { x0: c[0], y0: c[1], z0: top, gx: 0, gy: 0 }, [1, 0], (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>`);
+    if (cap !== undefined)
+        planes.push(cap);
+    hole.forEach((a, k) => {
+        const b = hole[(k + 1) % hole.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (long < 0.5)
+            return;
+        planes.push({ ...shy(wall(`skirt-${k}`, "roof", a[0], a[1], b[0], b[1], z, top, `<rect class="u-roof" width="${n(long)}" height="${n(CAP_RISE)}"/>`), c), fadeTo: 0.3 });
+    });
+    const xs = hole.map((p) => p[0]);
+    const half = ((Math.max(...xs) - Math.min(...xs)) / 2) * SKYLIGHT_SHARE;
+    const bar = [[c[0] - half, c[1] - SKYLIGHT_WIDTH / 2], [c[0] + half, c[1] - SKYLIGHT_WIDTH / 2], [c[0] + half, c[1] + SKYLIGHT_WIDTH / 2], [c[0] - half, c[1] + SKYLIGHT_WIDTH / 2]];
+    const glass = raked("skylight", "roof", bar, { x0: c[0], y0: c[1], z0: top + 0.4, gx: 0, gy: 0 }, [1, 0], (corners) => `<polygon class="u-skylight" points="${pointList(corners)}"/>`);
+    if (glass !== undefined)
+        planes.push(glass);
+    return planes;
+}
 /** The top of a set of planes. */
 const heightOf = (planes) => Math.max(...planes.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]]));
 /** The two points where a ray from `from` first enters a polygon and last leaves it (the polygon is a band round the middle, so a ray crosses it once), or `undefined` where it misses. */

package/dist/venues.d.ts

@@ -41,10 +41,18 @@ export interface RealVenueData {
         lowerShare?: number;
         read: string;
     };
+    /** The building's lower band, a podium under the upper levels: its height in feet and how it is known (ours where the sources do not say). */
+    facade?: {
+        podium: number;
+        unit: "ft";
+        basis: VenueBasis;
+        read: string;
+    };
     roof: {
         kind: VenueRoof;
         basis: VenueBasis;
-        read: string;
+        read: string; /** A long skylight over the middle of the roof, closed in round it: drawn where the venue says so (ours). */
+        skylight?: boolean;
     };
 }
 /** What OpenStreetMap gave of a venue: ODbL 1.0 data, "(c) OpenStreetMap contributors". */

package/dist/venues.data.js

@@ -60,7 +60,8 @@ export const VENUE_DATA = [
         "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" },
+        "roof": { "kind": "fixed", "basis": "plausible", "read": "an indoor arena: a fixed roof, as nothing says otherwise; the long skylight over the middle of the roof, and the cap that closes the roof round it, are ours (the brief's)", "skylight": true },
+        "facade": { "podium": 38, "unit": "ft", "basis": "plausible", "read": "the brief: the stepped facade over the Pat Quinn Way front, a lower podium under the upper levels; its height is ours (the sources do not say)" },
     },
     {
         "id": "t-mobile-arena",

package/dist/venues.js

@@ -209,7 +209,7 @@ function plan(venue, rink) {
         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 },
+        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, ...(venue.facade === undefined ? {} : { podium: venue.facade.podium }), ...(venue.roof.skylight === true ? { skylight: true } : {}) },
     };
     return { venue, orientation, box: rink, footprint, bowl, seats: rings.map((ring) => ({ tier: ring.tier, seats: ring.seats })), total, seatArea, fit: tight ? "tight" : "fits" };
 }

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.40.1";
+export declare const VERSION = "0.43.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.40.1";
+export const VERSION = "0.43.0";

package/dist/walk.d.ts

@@ -0,0 +1,56 @@
+import type { LonLat } from "./venues.geo.ts";
+import type { Pt } from "./crowd.ts";
+/** What a district's mask is made from, as `walk.data.ts` holds it: lines (`[width in tenths of a metre, first point, steps...]`) and areas (rings, the first the outside, in whole quarter-metres). */
+export interface WalkData {
+    /** The raw file the data was made from, and the day it was read and the time of OpenStreetMap's data. */
+    source: string;
+    read: string;
+    base: string;
+    licence: "ODbL-1.0";
+    attribution: string;
+    /** The venues the district was made for: the keys of `VENUES` and `STADIUMS` with the configuration, as a district names them. */
+    venues: readonly string[];
+    /** The `[longitude, latitude]` the metres are measured from. */
+    origin: LonLat;
+    /** The box the data covers, `[west, south, east, north]` in metres from the origin. */
+    box: readonly [number, number, number, number];
+    walkLines: readonly (readonly number[])[];
+    walkAreas: readonly (readonly (readonly number[])[])[];
+    blockLines: readonly (readonly number[])[];
+    blockAreas: readonly (readonly (readonly number[])[])[];
+}
+/** The side of a cell of the mask, in metres: half a metre, finer than the narrowest path and a person's width. */
+export declare const WALK_CELL = 0.5;
+/** The grid of a mask: `cells[row * width + column]` is 1 where a person may stand. Cell `(0, 0)` has its corner at `(x0, y0)` metres east and north of `origin`. */
+export interface WalkMask {
+    id: string;
+    origin: LonLat;
+    cell: number;
+    x0: number;
+    y0: number;
+    width: number;
+    height: number;
+    cells: Uint8Array;
+    /** How many cells are walkable. */
+    walkable: number;
+}
+/** The districts there are masks for. */
+export declare const WALK_IDS: readonly string[];
+/** A path from its packed form: the first point, then the step to each next one, in metres. */
+export declare function unpack(packed: readonly number[], from?: number): Pt[];
+/** What a mask is given besides the data: rings in metres from the mask's origin that stop a crowd (the venues' own buildings), and rings whose surroundings are the venues' own ground. */
+export interface WalkExtras {
+    /** The outline of each venue's building: stops a crowd, and a band `apron` metres wide round it is ground a crowd may stand on. */
+    buildings: readonly (readonly Pt[])[];
+    /** The width of the venue's own ground round its building, in metres. */
+    apron: number;
+}
+/**
+ * The mask of a district, rasterised from `WALK_DATA` (and kept for the next call): the walkable areas and the paths at their width, the apron round each venue, then the carriageways, cycle tracks, railways, water and buildings cut out
+ * of them, and the venues' own buildings last. A person stands in a cell with value 1, and nowhere else.
+ */
+export declare function walkMask(id: string, extras: WalkExtras): WalkMask;
+/** Whether a point (metres east and north of the mask's origin) is in a walkable cell. */
+export declare function walkable(mask: WalkMask, x: number, y: number): boolean;
+/** The mask a set of venues stand on, if there is one: the first mask that names one of them (by id, whatever configuration). */
+export declare const walkIdFor: (venueIds: readonly string[]) => string | undefined;

package/dist/walk.data.d.ts

@@ -0,0 +1,4 @@
+import type { WalkData } from "./walk.ts";
+/** The metres one whole number of the mask's coordinates is. */
+export declare const WALK_UNIT = 0.25;
+export declare const WALK_DATA: Record<string, WalkData>;