@a2f0/skyline 0.0.0-stage → 0.1.1

package/lib/models/one-prudential-tower.js

@@ -0,0 +1,246 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, inside } from "./building-kit.js";
+import { chainPier, chainsOf, gridBox, jointTrim, mitredBox, orient, paintedSlab, planOf, turnsAt } from "./facade-grid.js";
+// Heights above the street. The penthouse top and the antenna tip are published, and the
+// antenna's length is WGN's. The roof, the observatory band, the penthouse's louvers, the
+// floor pitch, and the window rows are measured on the photograph the drawing was traced
+// from, down from the published penthouse top. See docs/one-prudential-reference.md.
+export const onePrudentialLevels = Object.freeze({
+    // The ground storey, then thirty-nine office floors, then the observatory: forty-one.
+    lobbyTop: 12.03,
+    pitch: 3.93,
+    floors: 41,
+    sill: 0.85,
+    head: 2.45,
+    sillCourse: 164.9,
+    bandFoot: 165.3,
+    copingFoot: 169,
+    roof: 169.5,
+    signBottom: 171,
+    signTop: 179.5,
+    louverBottom: 180.3,
+    penthouseTop: 183.2,
+    // The 311 ft tubular mast's top, where WGN's 73 ft antenna leaves its 12 ft socket.
+    mastTop: 259.4,
+    tip: 278,
+    bay: 2.35,
+});
+const h = onePrudentialLevels;
+// A floor's level: the ground floor at the street, the office floors from the lobby's top,
+// and the forty-first at the observatory band's foot.
+export const floorLevel = (floor) => (floor === 1 ? 0 : h.lobbyTop + (floor - 2) * h.pitch);
+// The facade module. Interior piers stand one bay apart, centred on the wall; the bays at
+// each end take what is left, at least `endBay`, and the corner pier widens to fill it, so
+// every window is the same width.
+const endBay = 2.6, pierHalf = 0.55, pierDepth = 0.3, ribHalf = 0.5;
+export function wallStations(length) {
+    const interior = Math.max(0, Math.floor((length - 2 * endBay) / h.bay));
+    const end = (length - interior * h.bay) / 2;
+    return { piers: Array.from({ length: interior + 1 }, (_, i) => end + i * h.bay), corner: end - h.bay + pierHalf };
+}
+// A wing's ribs: as many bays as the wall holds, centred on it.
+export function wingRibs(length) {
+    const count = Math.floor(length / h.bay);
+    return Array.from({ length: count }, (_, i) => length / 2 + (i - (count - 1) / 2) * h.bay);
+}
+// The screen's fins: the drawing's forty-nine on the south face, one every 0.98 m from 2.2 m
+// in; the other faces hold as many as fit, centred.
+const finPitch = 0.98, finHalf = 0.15, finDepth = 0.2;
+export function screenFins(length, front) {
+    if (front)
+        return Array.from({ length: 49 }, (_, i) => 2.2 + i * finPitch);
+    const count = Math.floor((length - 1) / finPitch) + 1;
+    return Array.from({ length: count }, (_, i) => length / 2 + (i - (count - 1) / 2) * finPitch);
+}
+// The sign, along the penthouse's south face: a board carrying the Rock of Gibraltar and
+// the name, ten letters from 14 m to 42.8 m, their capital and ascenders taller than the rest.
+const sign = { board: [4.6, 43.3], logo: [7.1, 13], rows: [172, 173.8, 177, 178.7], letters: 10, name: [14, 42.8], tall: new Set([0, 3, 6, 7, 9]) };
+const mastFoot = 1.15, mastHead = 0.5, antennaHalf = 0.22;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = [0x262626, 0x2c2c2c, 0x323232, 0x222222].map(color);
+const litGlass = color(0x7c7c7c), dimGlass = color(0x4e4e4e);
+const observatory = [0x3a3a3a, 0x444444, 0x404040].map(color), litObservatory = color(0x8a8a8a);
+const aluminium = color(0x8e8e8e), darkSpandrel = color(0x242424), limestone = color(0xb0b0b0), roofing = color(0x4c4c4c);
+const penthouseWall = color(0x9c9c9c), louverBacking = color(0x383838), board = color(0x2e2e2e), lettering = color(0xc4c4c4), logo = color(0xb0b0b0);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 5, 0x9e3779b1) ^ Math.imul(bay + 23, 0x85ebca77) ^ Math.imul(wall + 13, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 3)
+        return litGlass;
+    if (value < 6)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+function wallRows(from, to) {
+    const rows = [{ lo: 0.4, hi: h.lobbyTop - 0.9, kind: "glass", floor: 1 }];
+    for (let floor = 2; floor < h.floors; floor += 1) {
+        const level = floorLevel(floor);
+        rows.push({ lo: rows.at(-1).hi, hi: level + h.sill, kind: "spandrel", floor }, { lo: level + h.sill, hi: level + h.head, kind: "glass", floor });
+    }
+    rows.push({ lo: rows.at(-1).hi, hi: h.bandFoot, kind: "spandrel", floor: h.floors - 1 });
+    rows.push({ lo: h.bandFoot, hi: h.copingFoot, kind: "band", floor: h.floors });
+    return rows.filter((row) => row.hi > from + 1e-6 && row.lo < to - 1e-6).map((row) => ({ ...row, lo: Math.max(row.lo, from), hi: Math.min(row.hi, to) }));
+}
+export function buildOnePrudentialTower(form) {
+    const kit = createBuilder(form.name, form.id);
+    const shell = kit.batch("One Prudential · shell", kit.material(0xffffff, { vertexColors: true }));
+    const glazing = kit.batch("One Prudential · windows and spandrels", kit.material(0xffffff, { vertexColors: true }));
+    const piers = kit.batch("One Prudential · limestone piers", kit.material(0xb4b4b4));
+    const bands = kit.batch("One Prudential · limestone courses", kit.material(0xc0c0c0));
+    const penthouse = kit.batch("One Prudential · penthouse and sign", kit.material(0xffffff, { vertexColors: true }));
+    const fins = kit.batch("One Prudential · screen louvers", kit.material(0x707070));
+    const mast = kit.batch("One Prudential · antenna mast", kit.material(0xb4b4b4));
+    const base = form.base;
+    const y = (real) => real - base;
+    const shown = (real) => real > base + 1e-6;
+    const tower = orient(form.tower), towerPlan = planOf(tower);
+    const wings = form.wings.filter(({ top }) => shown(top)).map(({ outline, top }) => ({ outline: orient(outline), plan: planOf(orient(outline)), top }));
+    // A wall is covered, up to a neighbour's roof, where a probe just outside it lands inside
+    // that neighbour: the tower covers its wings' inner walls, and the wings the tower's lower ones.
+    const parts = [{ outline: tower, top: h.roof }, ...wings.map(({ outline, top }) => ({ outline, top }))];
+    const coveredTo = (run, own) => Math.max(base, ...parts.filter(({ outline }) => outline !== own && inside(outline, run.at(run.length / 2, 0.3))).map(({ top }) => top));
+    const turns = turnsAt;
+    // The solids: walls, floors, and roofs, closed. Walls behind the facade are spandrel
+    // aluminium; a wall too short for a bay is plain limestone.
+    const solid = (outline, plan, top, paint) => {
+        plan.forEach((run) => {
+            const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+            kit.quad(shell, [[a[0], 0, a[1]], [b[0], 0, b[1]], [b[0], y(top), b[1]], [a[0], y(top), a[1]]], [[n[0], 0, n[1]]], paint(run));
+        });
+        paintedSlab(kit, shell, outline, 0, false, roofing);
+        paintedSlab(kit, shell, outline, y(top), true, roofing);
+    };
+    // Piers cross a chain's joints in pieces, and cells stop short of them: see chainPier and
+    // jointTrim in facade-grid.ts.
+    const trim = jointTrim;
+    const pierOn = (plan, chain, froms, a, b, depth, top) => chainPier(kit, piers, plan, chain, froms, a, b, depth, top, y);
+    // A run's cells start just above its piers, so their undersides never share a plane.
+    const cellsFrom = (from) => from + 0.1;
+    // The tower's walls. Each chain of nearly collinear runs is one wall with one set of
+    // piers; a run's windows start above whatever wing covers it.
+    const towerChains = chainsOf(towerPlan);
+    const plainRuns = new Set(towerChains.filter(({ length }) => length < 2 * endBay).flatMap(({ runs }) => runs));
+    solid(tower, towerPlan, h.roof, (run) => (plainRuns.has(towerPlan.indexOf(run)) ? limestone : aluminium));
+    towerChains.forEach((chain, wall) => {
+        if (chain.length < 2 * endBay)
+            return;
+        const { piers: stations, corner } = wallStations(chain.length);
+        const columns = [corner - 0.2, ...stations, chain.length - corner + 0.2];
+        const froms = chain.runs.map((index) => coveredTo(towerPlan[index], tower));
+        chain.runs.forEach((index, k) => {
+            const run = towerPlan[index], start = chain.starts[k], end = start + run.length;
+            const rows = wallRows(cellsFrom(froms[k]), h.copingFoot);
+            // Windows and spandrels: one box on the run, a column per bay and a row per window,
+            // spandrel, and the observatory band.
+            const first = Math.max(columns[0], start + trim(towerPlan, chain, froms, k, k - 1)), last = Math.min(columns.at(-1), end - trim(towerPlan, chain, froms, k, k + 1));
+            const local = [first, ...columns.filter((s) => s > first + 1e-6 && s < last - 1e-6), last];
+            const offset = columns.filter((s) => s <= first + 1e-6).length - 1;
+            if (last - first < 0.05 || !rows.length)
+                return;
+            gridBox(kit, glazing, run, local.map((s) => s - start), [rows[0].lo, ...rows.map((row) => row.hi)], 0.02, 0.07, (column, r) => {
+                const row = rows[r], bay = offset + column;
+                if (row.kind === "spandrel")
+                    return aluminium;
+                if (row.kind === "band")
+                    return paneColor(row.floor, bay, wall).equals(litGlass) ? litObservatory : observatory[bay % observatory.length];
+                return paneColor(row.floor, bay, wall);
+            }, aluminium, y);
+        });
+        // The piers, from the street to the sill course, standing proud of the glass: one on
+        // every bay line, and a wider one at each corner.
+        for (const s of stations)
+            pierOn(towerPlan, chain, froms, s - pierHalf, s + pierHalf, pierDepth, h.sillCourse);
+        pierOn(towerPlan, chain, froms, 0, corner, pierDepth, h.sillCourse);
+        pierOn(towerPlan, chain, froms, chain.length - corner, chain.length, pierDepth, h.sillCourse);
+    });
+    // The limestone sill course under the observatory and the coping over it, round every run.
+    towerPlan.forEach((run, index) => {
+        const [before, after] = turns(towerPlan, index);
+        if (shown(h.bandFoot))
+            mitredBox(kit, bands, run, 0, run.length, before, after, pierDepth, Math.max(h.sillCourse, base), h.bandFoot, y);
+        if (shown(h.roof))
+            mitredBox(kit, bands, run, 0, run.length, before, after, 0.35, Math.max(h.copingFoot, base), h.roof, y);
+    });
+    // The wings: dark spandrels between limestone ribs on the same module, a window per bay
+    // on each floor, and a coping. Walls the tower covers carry nothing.
+    wings.forEach(({ outline, plan, top }, number) => {
+        solid(outline, plan, top, () => darkSpandrel);
+        // Where a wall meets the tower, its cells and coping stop clear of the tower's piers.
+        const coping = top - 0.5, clear = pierDepth + 0.05;
+        const open = plan.map((run) => coveredTo(run, outline) < coping);
+        chainsOf(plan).forEach((chain, wall) => {
+            const ribs = wingRibs(chain.length);
+            const froms = chain.runs.map((index) => (open[index] ? coveredTo(plan[index], outline) : top));
+            chain.runs.forEach((index, k) => {
+                const run = plan[index], start = chain.starts[k];
+                // The cells stop under the coping, clear of the ribs' tops.
+                const rows = wallRows(cellsFrom(froms[k]), coping - 0.05).filter((row) => row.kind !== "band");
+                if (!open[index] || !rows.length)
+                    return;
+                // Cells stop short of a wall the tower covers, clear of the tower's piers in the corner.
+                const s0 = open[(index + plan.length - 1) % plan.length] ? trim(plan, chain, froms, k, k - 1) : clear;
+                const s1 = run.length - (open[(index + 1) % plan.length] ? trim(plan, chain, froms, k, k + 1) : clear);
+                const local = [s0, ...ribs.filter((s) => s > start + s0 + 1e-6 && s < start + s1 - 1e-6).map((s) => s - start), s1];
+                const offset = ribs.filter((s) => s <= start + 1e-6).length;
+                gridBox(kit, glazing, run, local, [rows[0].lo, ...rows.map((row) => row.hi)], 0.02, 0.07, (column, r) => (rows[r].kind === "glass" ? paneColor(rows[r].floor, offset + column, 40 + 10 * number + wall) : darkSpandrel), darkSpandrel, y);
+            });
+            for (const s of ribs)
+                pierOn(plan, chain, froms, s - ribHalf, s + ribHalf, pierDepth, coping);
+        });
+        // The coping, mitred between open walls. Against the tower it is mitred as if into a
+        // concave corner, its inner edge on the wall's own corners and its outer edge clear of
+        // the tower's piers.
+        plan.forEach((run, index) => {
+            if (!open[index])
+                return;
+            const [before, after] = turns(plan, index), quarter = Math.PI / 2;
+            mitredBox(kit, bands, run, 0, run.length, open[(index + plan.length - 1) % plan.length] ? before : quarter, open[(index + 1) % plan.length] ? after : quarter, 0.35, Math.max(coping, base), top, y);
+        });
+    });
+    // The penthouse: a pale wall carrying the sign, under a dark screen of limestone-grey fins.
+    const { corner, along, length, depth } = form.penthouse;
+    const inward = [along[1], -along[0]];
+    const offsetBy = ([x, z], s, d) => [x + along[0] * s + inward[0] * d, z + along[1] * s + inward[1] * d];
+    const penthouseOutline = orient([corner, offsetBy(corner, length, 0), offsetBy(corner, length, depth), offsetBy(corner, 0, depth)]);
+    const penthousePlan = planOf(penthouseOutline);
+    penthousePlan.forEach((run) => {
+        const a = run.at(0), b = run.at(run.length), n = run.normal(0), normal = [[n[0], 0, n[1]]];
+        const p = (q, v) => [q[0], y(v), q[1]];
+        kit.quad(penthouse, [p(a, h.roof), p(b, h.roof), p(b, h.louverBottom), p(a, h.louverBottom)], normal, penthouseWall);
+        kit.quad(penthouse, [p(a, h.louverBottom), p(b, h.louverBottom), p(b, h.penthouseTop), p(a, h.penthouseTop)], normal, louverBacking);
+        const front = n[1] > 0.9;
+        for (const s of screenFins(run.length, front))
+            kit.box(fins, run.at(s), n, finHalf, 0, finDepth, y(h.louverBottom + 0.15), y(h.penthouseTop - 0.15));
+        if (front) {
+            const pitch = (sign.name[1] - sign.name[0]) / sign.letters;
+            const letters = Array.from({ length: sign.letters }, (_, i) => [sign.name[0] + i * pitch + 0.25, sign.name[0] + (i + 1) * pitch - 0.25]).flat();
+            const columns = [sign.board[0], sign.logo[0], sign.logo[1], ...letters, sign.board[1]];
+            // Rows: the board's foot, the logo, the letters, the tall letters, the board's head.
+            gridBox(kit, penthouse, run, columns, [h.signBottom, ...sign.rows, h.signTop], 0.02, 0.25, (column, row) => {
+                if (column === 1)
+                    return row >= 1 && row <= 3 ? logo : board;
+                const letter = (column - 3) / 2;
+                if (column < 3 || !Number.isInteger(letter) || letter >= sign.letters)
+                    return board;
+                return row === 2 || (row === 3 && sign.tall.has(letter)) ? lettering : board;
+            }, board, y);
+        }
+    });
+    paintedSlab(kit, penthouse, penthouseOutline, y(h.roof), false, roofing);
+    paintedSlab(kit, penthouse, penthouseOutline, y(h.penthouseTop), true, roofing);
+    // The mast: an eight-sided steel tube tapering from the roof to its top, capped by a fan
+    // from its axis, and WGN's slim antenna on to the published tip.
+    const [mx, mz] = form.mast, sides = 8;
+    const ring = (radius, v) => Array.from({ length: sides }, (_, i) => { const a = (i + 0.5) * 2 * Math.PI / sides; return [mx + radius * Math.cos(a), y(v), mz - radius * Math.sin(a)]; });
+    const foot = ring(mastFoot, h.roof), head = ring(mastHead, h.mastTop);
+    // Each side leans in with the taper, so its normal tilts up by the apothem's fall per metre.
+    const lean = (mastFoot - mastHead) * Math.cos(Math.PI / sides) / (h.mastTop - h.roof);
+    for (let i = 0; i < sides; i += 1) {
+        const j = (i + 1) % sides, a = (i + 1) * 2 * Math.PI / sides, l = Math.hypot(1, lean), out = [Math.cos(a) / l, lean / l, -Math.sin(a) / l];
+        kit.quad(mast, [foot[i], foot[j], head[j], head[i]], [out]);
+        kit.triangle(mast, [[mx, y(h.mastTop), mz], head[i], head[j]], [[0, 1, 0], [0, 1, 0], [0, 1, 0]]);
+        kit.triangle(mast, [[mx, y(h.roof), mz], foot[j], foot[i]], [[0, -1, 0], [0, -1, 0], [0, -1, 0]]);
+    }
+    kit.box(mast, form.mast, [0, 1], antennaHalf, -antennaHalf, antennaHalf, y(h.mastTop), y(h.tip));
+    return kit.finish({ height: y(h.tip), outlines: [shell, bands], opacity: 0.18 });
+}

package/lib/models/peoples-gas-geographic.d.ts

@@ -0,0 +1,23 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const peoplesGasLevels: Readonly<{
+    court: number;
+    inner: number;
+    colonnade: number;
+    entablature: number;
+    frieze: number;
+    cornice: number;
+    roof: number;
+    top: 82.9;
+}>;
+export declare const peoplesGasPalette: Readonly<{
+    glass: number[];
+    lit: 7237230;
+    dim: 3947580;
+    stone: 8158332;
+    granite: 5921370;
+    band: 9342606;
+    shadow: 2368548;
+    court: 10263708;
+}>;
+export declare function createPeoplesGasGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;

package/lib/models/peoples-gas-geographic.js

@@ -0,0 +1,250 @@
+import * as THREE from "../vendor/three-r186.js";
+import { createBuilder, polygonOf } from "./building-kit.js";
+import { chainSkin, chainsOf, orient, paintedSlab, planOf, turnsAt } from "./facade-grid.js";
+// The Peoples Gas Building, 122 South Michigan Avenue (D. H. Burnham & Co., 1911): the
+// geographic layout's model, on the mapped outline 145498710 and its parts. The original
+// layout has no model of it; the drawing shows it between the Lake View Building and Adams
+// Street, with the Borg-Warner Building before its Adams front.
+//
+// Twenty storeys rise on the Michigan and Adams fronts between wide corner piers:
+// - two behind granite columns;
+// - fourteen of paired windows, eleven bays to Michigan and nine to Adams;
+// - three behind a colonnade under an entablature;
+// - an attic under a frieze of pendant arches, a projecting cornice and its cresting.
+// A light court opens over the ground storey and widens over the seventeenth floor. The top
+// is the City's 272 ft. The drawn cresting reads 86 m, so heights read on the drawing are
+// scaled to meet it; see docs/peoples-gas-reference.md. Units are meters; +x is east, +z is
+// south.
+const drawn = (height) => height * 82.9 / 86;
+export const peoplesGasLevels = Object.freeze({
+    court: drawn(7.2), // the light court's floor, over the ground storey
+    inner: drawn(66.3), // the court's inner wings' roof, at the seventeenth floor
+    colonnade: drawn(67.47), // the colonnade's foot
+    entablature: drawn(76.8), // the colonnade's entablature
+    frieze: drawn(82.1), // the frieze under the cornice
+    cornice: drawn(84.3), // the projecting cornice
+    roof: drawn(84.8), // the cornice's top and the roof
+    top: 82.9, // the cresting's top, the published height
+});
+const h = peoplesGasLevels;
+// The skins' colours: the window tones, and the terracotta, granite, bands, the frieze's
+// shadow and the court's white brick, which no window shares.
+export const peoplesGasPalette = Object.freeze({ glass: [0x2c2c2c, 0x303030, 0x343434, 0x383838], lit: 0x6e6e6e, dim: 0x3c3c3c, stone: 0x7c7c7c, granite: 0x5a5a5a, band: 0x8e8e8e, shadow: 0x242424, court: 0x9c9c9c });
+const palette = peoplesGasPalette;
+const color = (hex) => new THREE.Color(hex);
+const glassTones = palette.glass.map(color);
+const litGlass = color(palette.lit), dimGlass = color(palette.dim);
+const stone = color(palette.stone), granite = color(palette.granite), band = color(palette.band), shadow = color(palette.shadow), courtBrick = color(palette.court);
+const core = color(0x262626), party = color(0x646464), roofing = color(0x3c3c3c);
+function paneColor(row, bay, wall) {
+    const hash = (Math.imul(row + 61, 0x9e3779b1) ^ Math.imul(bay + 89, 0x85ebca77) ^ Math.imul(wall + 73, 0xc2b2ae3d)) >>> 0;
+    const value = hash % 101;
+    if (value < 4)
+        return litGlass;
+    if (value < 8)
+        return dimGlass;
+    return glassTones[value % glassTones.length];
+}
+const rows = [{ lo: 0.25, hi: drawn(0.6), kind: "granite", floor: 1 }];
+const push = (hi, kind, floor, more = {}) => rows.push({ lo: rows.at(-1).hi, hi: drawn(hi), kind, floor, ...more });
+push(6.2, "shop", 1);
+push(7.2, "granite", 2);
+push(11.6, "shop", 2);
+push(12.4, "granite", 2);
+push(13.3, "belt", 2);
+const sill = (n) => 63.36 - (16 - n) * 3.79;
+for (let n = 3; n <= 16; n += 1) {
+    push(sill(n), "wall", n);
+    push(sill(n) + 2.24, "glass", n, { pier: true });
+}
+push(66.3, "wall", 16);
+push(67.47, "wall", 17);
+push(69.7, "rail", 17, { pier: true });
+push(69.9, "rail", 17);
+push(70.9, "open", 18);
+push(73.2, "open", 18, { pier: true });
+push(74.56, "open", 19);
+push(76.8, "open", 19, { pier: true });
+push(78.3, "band", 19);
+push(78.9, "wall", 20);
+push(81, "attic", 20);
+push(81.3, "attic", 20, { reach: 0.45 });
+push(81.55, "pendant", 20, { reach: 0.45 });
+push(82.1, "pendant", 20, { reach: 0.9 });
+push(84.3, "frieze", 20);
+push(84.8, "parapet", 20);
+export function createPeoplesGasGeographicBuilding(record, projectPlan, offset) {
+    const kit = createBuilder(record.name, record.id);
+    const shell = kit.batch("Peoples Gas Building · shell", kit.material(0xffffff, { vertexColors: true }));
+    const wall = kit.batch("Peoples Gas Building · terracotta and windows", kit.material(0xffffff, { vertexColors: true }));
+    const cornice = kit.batch("Peoples Gas Building · cornice", kit.material(0x8e8e8e));
+    const corners = (coordinates) => orient(polygonOf(projectPlan(coordinates)));
+    const lot = corners(record.footprint.coordinates);
+    // The mapped parts: the twenty-level ring, the north wing within it, the inner wings
+    // rising to the seventeenth floor, the court, and the notch in the north wall that opens
+    // it to the Lake View Building's light court.
+    const part = (way) => corners(record.parts.find((p) => p.way === way).coordinates);
+    const mapped = [1179833660, 1179833658, 1179833661, 1179833659, 1179842408].map(part);
+    // The lot's south-east corner, on Michigan and Adams, with the Adams front running west to
+    // the alley and the Michigan front north to the Lake View Building.
+    const corner = lot.reduce((best, p) => (p[0] + p[1] > best[0] + best[1] ? p : best));
+    const northEast = lot.reduce((best, p) => (p[0] - p[1] > best[0] - best[1] ? p : best));
+    const southWest = lot.reduce((best, p) => (p[1] - p[0] > best[1] - best[0] ? p : best));
+    const unit = (p) => { const d = Math.hypot(p[0] - corner[0], p[1] - corner[1]); return [(p[0] - corner[0]) / d, (p[1] - corner[1]) / d]; };
+    const west = unit(southWest), north = unit(northEast);
+    const at = (a, b) => [corner[0] + west[0] * a + north[0] * b, corner[1] + west[1] * a + north[1] * b];
+    // The inverse of `at`: a point's distances along the Adams and Michigan fronts, which
+    // meet a little off square.
+    const skew = west[0] * north[1] - west[1] * north[0];
+    const inLot = (p) => {
+        const [x, z] = [p[0] - corner[0], p[1] - corner[1]];
+        return [(x * north[1] - z * north[0]) / skew, (west[0] * z - west[1] * x) / skew];
+    };
+    const [adams, michigan] = [inLot(southWest)[0], inLot(northEast)[1]];
+    // Corners and edges by value, since parts share the outline's nodes.
+    const key = (p) => `${p[0].toFixed(3)},${p[1].toFixed(3)}`;
+    // Where a part's edge joins two of the outline's corners a few nodes apart, it follows
+    // the outline between them, so that the roof meets the walls corner to corner: the ring
+    // skips two of the Michigan front's nodes.
+    const index = new Map(lot.map((p, i) => [key(p), i]));
+    const follow = (polygon) => polygon.flatMap((a, i) => {
+        const [from, to] = [index.get(key(a)), index.get(key(polygon[(i + 1) % polygon.length]))], n = lot.length;
+        if (from === undefined || to === undefined)
+            return [a];
+        const [ahead, back] = [(to - from + n) % n, (from - to + n) % n];
+        const step = ahead > 1 && ahead <= 3 ? 1 : back > 1 && back <= 3 ? -1 : 0, between = step === 1 ? ahead - 1 : step === -1 ? back - 1 : 0;
+        return [a, ...Array.from({ length: between }, (_, k) => lot[(from + step * (k + 1) + n) % n])];
+    });
+    // And a part takes every other part's corner within 2 cm of one of its edges: the ring's
+    // edge along the court passes 1.1 cm from the court's corner.
+    const conform = (polygon, others) => polygon.flatMap((a, i) => {
+        const b = polygon[(i + 1) % polygon.length], length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const on = others.flat().map((p) => ({ p, t: ((p[0] - a[0]) * (b[0] - a[0]) + (p[1] - a[1]) * (b[1] - a[1])) / length ** 2 }))
+            .filter(({ p, t }) => t > 1e-6 && t < 1 - 1e-6 && Math.abs((p[0] - a[0]) * (b[1] - a[1]) - (p[1] - a[1]) * (b[0] - a[0])) / length < 0.02);
+        return [a, ...[...new Map(on.map((x) => [key(x.p), x])).values()].sort((x, y) => x.t - y.t).map((x) => x.p)];
+    });
+    const followed = mapped.map(follow);
+    const [ring, northWing, innerWings, court, notch] = followed.map((polygon) => conform(polygon, followed.filter((other) => other !== polygon)));
+    const edges = (polygon) => new Set(polygon.flatMap((a, i) => { const b = polygon[(i + 1) % polygon.length]; return [`${key(a)}|${key(b)}`, `${key(b)}|${key(a)}`]; }));
+    const has = (set, run) => set.has(`${key(run.at(0))}|${key(run.at(run.length))}`);
+    // Two outlines sharing a run of edges, as one: the edges neither shares, end to end.
+    const merge = (p, q) => {
+        const [ep, eq] = [edges(p), edges(q)];
+        const kept = [...p.map((a, i) => [a, p[(i + 1) % p.length]]).filter(([a, b]) => !eq.has(`${key(a)}|${key(b)}`)),
+            ...q.map((a, i) => [a, q[(i + 1) % q.length]]).filter(([a, b]) => !ep.has(`${key(a)}|${key(b)}`))];
+        const next = new Map(kept.map(([a, b]) => [key(a), b]));
+        const out = [kept[0][0]];
+        for (let p1 = kept[0][1]; key(p1) !== key(out[0]); p1 = next.get(key(p1)))
+            out.push(p1);
+        return orient(out);
+    };
+    // The court's walls face into it, so their outlines run the other way.
+    const inward = (polygon) => [...polygon].reverse();
+    const [lower, upper, opening] = [inward(court), inward(merge(court, innerWings)), inward(notch)];
+    const [lotEdges, wingEdges, lowerEdges] = [edges(lot), edges(innerWings), edges(court)];
+    const face = (run, lo, hi, paint) => {
+        const a = run.at(0), b = run.at(run.length), n = run.normal(0);
+        kit.quad(shell, [[a[0], lo, a[1]], [b[0], lo, b[1]], [b[0], hi, b[1]], [a[0], hi, a[1]]], [[n[0], 0, n[1]]], paint);
+    };
+    // The outer walls to the roof, the north wall, above the Lake View Building, in common
+    // brick, and open over the court's floor at the notch. Walls split where the ones they
+    // meet end, at the court's floor and the inner wings' roof, so every edge is shared.
+    const notchEdges = edges(notch);
+    planOf(lot).forEach((run) => {
+        const paint = run.normal(0)[1] < -0.9 ? party : core;
+        face(run, 0, h.court, paint);
+        if (!has(notchEdges, run))
+            face(run, h.court, h.roof, paint);
+    });
+    // The court's walls: the inner wings' to their roof, the rest to the roof, and over the
+    // inner wings the widened court's; the notch's but its open side.
+    planOf(lower).forEach((run) => {
+        face(run, h.court, h.inner, courtBrick);
+        if (!has(wingEdges, run))
+            face(run, h.inner, h.roof, courtBrick);
+    });
+    planOf(upper).forEach((run) => { if (!has(lowerEdges, run))
+        face(run, h.inner, h.roof, courtBrick); });
+    planOf(opening).forEach((run) => { if (!has(lotEdges, run))
+        face(run, h.court, h.roof, courtBrick); });
+    paintedSlab(kit, shell, lot, 0, false, roofing);
+    for (const roof of [ring, northWing])
+        paintedSlab(kit, shell, roof, h.roof, true, roofing);
+    paintedSlab(kit, shell, innerWings, h.inner, true, roofing);
+    for (const floor of [court, notch])
+        paintedSlab(kit, shell, floor, h.court, true, roofing);
+    // The cornice projects 90 cm along both fronts, to 2 cm over the roof, stopping 3 cm
+    // short of the north and alley walls. It starts 8 cm inside the lines between the fronts'
+    // corners, which the mapped walls stand at most 2 cm inside and 12.4 cm outside, so it
+    // always meets them. Its cresting: blocks 50 cm wide and 1 m apart near its edge.
+    const [out, lip] = [0.9, 0.02];
+    kit.prism(cornice, planOf(orient([at(-out, michigan - 0.03), at(-out, -out), at(adams - 0.03, -out), at(adams - 0.03, 0.08), at(0.08, 0.08), at(0.08, michigan - 0.03)])), [h.cornice, h.roof + lip]);
+    const [east, south] = [[-north[1], north[0]], [west[1], -west[0]]];
+    for (let b = 0.5; b < michigan - 0.5; b += 1)
+        kit.box(cornice, at(-0.7, b), east, 0.25, -0.15, 0.15, h.roof + lip, h.top);
+    for (let a = 0.5; a < adams - 0.5; a += 1)
+        kit.box(cornice, at(a, -0.7), south, 0.25, -0.15, 0.15, h.roof + lip, h.top);
+    const skin = (plan, keep, from, to, seed, openings, plain) => {
+        const span = rows.filter((row) => row.lo >= from - 1e-9 && row.hi <= to + 1e-9), heights = [span[0].lo, ...span.map((row) => row.hi)];
+        const paints = { wall: plain, granite, band, shadow };
+        chainsOf(plan).forEach((chain, index) => {
+            if (!chain.runs.every((run) => keep(plan[run])))
+                return;
+            const first = chain.runs[0], last = chain.runs.at(-1);
+            const s0 = turnsAt(plan, first)[0] > 0 ? 0.09 : 0.02, s1 = chain.length - (turnsAt(plan, last)[1] > 0 ? 0.09 : 0.02);
+            const [columns, cell] = openings(chain.length);
+            chainSkin(kit, wall, plan, chain, 0, chain.runs.length - 1, s0, s1, columns, heights, 0.02, 0.07, (bay, r) => {
+                const row = span[r], shows = cell((columns[bay - 1] + columns[bay]) / 2, row);
+                return shows === "glass" ? paneColor(row.floor, bay, seed * 8 + index) : paints[shows];
+            }, plain);
+        });
+    };
+    const near = (list, x) => Math.min(...list.map((c) => Math.abs(x - c)));
+    const columnsOf = (length, cuts) => [0, ...[...new Set(cuts.map((c) => Math.round(c * 1e4) / 1e4))].sort((p, q) => p - q), length];
+    // A street front: corner piers 6 m to the first column's middle, each with a window 1.7 m
+    // wide 2.6 m from its corner; `count` bays between, each column 1.6 m wide. A bay holds a
+    // pair of windows 1.2 m wide either side of a 38 cm mullion, the colonnade's opening, and
+    // an attic window 1.7 m wide; a pendant hangs over each column.
+    const front = (count) => (length) => {
+        const pitch = (length - 12) / count, lines = Array.from({ length: count + 1 }, (_, k) => 6 + k * pitch);
+        const centres = lines.slice(1).map((line) => line - pitch / 2), piers = [2.6, length - 2.6];
+        const cuts = [...lines.flatMap((c) => [-0.9, -0.8, -0.45, 0.45, 0.8, 0.9].map((d) => c + d)), ...centres.flatMap((c) => [-1.39, -0.85, -0.19, 0.19, 0.85, 1.39].map((d) => c + d)), ...piers.flatMap((c) => [c - 0.85, c + 0.85])];
+        return [columnsOf(length, cuts), (mid, row) => {
+                const inside = mid > lines[0] && mid < lines.at(-1), line = near(lines, mid), centre = near(centres, mid);
+                const pierWindow = near(piers, mid) < 0.85;
+                switch (row.kind) {
+                    case "granite": return "granite";
+                    case "shop": return inside && line > 0.8 ? "glass" : "granite";
+                    case "belt":
+                    case "band": return "band";
+                    case "glass": return (inside && centre > 0.19 && centre < 1.39) || pierWindow ? "glass" : "wall";
+                    case "rail": return row.pier && pierWindow ? "glass" : inside && line > 0.8 ? "band" : "wall";
+                    case "open": return (row.pier && pierWindow) || (inside && line > 0.8) ? "glass" : "wall";
+                    case "attic": return row.reach !== undefined && line < row.reach ? "shadow" : (inside && centre < 0.85) || pierWindow ? "glass" : "wall";
+                    case "pendant": return line < row.reach ? "shadow" : "wall";
+                    case "frieze": return "shadow";
+                    default: return "wall";
+                }
+            }];
+    };
+    // The alley's and the court's windows, which the drawing does not show: 1.6 m wide, spread
+    // evenly about 3.2 m apart, one to each floor from the third.
+    const spread = (length) => {
+        const count = Math.max(1, Math.round(length / 3.2)), centres = Array.from({ length: count }, (_, k) => length * (k + 0.5) / count);
+        return [columnsOf(length, centres.flatMap((c) => [c - 0.8, c + 0.8])), (mid, row) => ((row.kind === "glass" || row.kind === "attic" || row.pier === true) && near(centres, mid) < 0.8 ? "glass" : "wall")];
+    };
+    const facing = (x, z) => (run) => run.normal(0)[0] * x + run.normal(0)[1] * z > 0.9;
+    // The fronts to the cornice, the alley to the roof; the north wall, shared with the Lake
+    // View Building, stays plain.
+    skin(planOf(lot), facing(1, 0), rows[0].lo, h.cornice, 0, front(11), stone);
+    skin(planOf(lot), facing(0, 1), rows[0].lo, h.cornice, 1, front(9), stone);
+    skin(planOf(lot), facing(-1, 0), rows[0].lo, h.roof, 2, spread, stone);
+    skin(planOf(lower), () => true, h.court, h.inner, 3, spread, courtBrick);
+    skin(planOf(upper), () => true, h.inner, h.roof, 4, spread, courtBrick);
+    skin(planOf(opening), (run) => !has(lotEdges, run), h.court, h.roof, 5, spread, courtBrick);
+    const model = kit.finish({ height: h.top, outlines: [shell, cornice], opacity: 0.16 });
+    model.building.position.set(offset[0], 0, offset[1]);
+    model.building.userData["geography"] = record;
+    model.building.userData["geographicDetail"] = { levels: h, source: "docs/peoples-gas-reference.md" };
+    return model;
+}

package/lib/models/railway-exchange-geographic.d.ts

@@ -0,0 +1,18 @@
+import type { BuildingModel, Plan } from "./building-kit.js";
+import type { GeoBuilding } from "./skyline-geography-data.js";
+export declare const railwayExchangeLevels: Readonly<{
+    belt: number;
+    frieze: number;
+    cornice: number;
+    eaves: 71.6;
+    top: 78.9;
+}>;
+export declare const railwayExchangePalette: Readonly<{
+    glass: number[];
+    lit: 7237230;
+    dim: 3947580;
+    terracotta: 8421504;
+    band: 9474192;
+    plain: 6447714;
+}>;
+export declare function createRailwayExchangeGeographicBuilding(record: GeoBuilding, projectPlan: (coordinates: [number, number][]) => Plan, offset: [number, number]): BuildingModel;