leaflet-city-mapper 0.0.0-stage → 0.0.2

package/src/utils/roofCoverage.js

@@ -0,0 +1,47 @@
+/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
+export function roofCoverage(mesh, backend, rasters) {
+  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  let intersectsArchive = false;
+  for (const layer of rasters) {
+    const zoom = layer._tileZoom, origin = map.project(backend._sceneOrigin, zoom);
+    const scale = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));
+    const min = [Infinity, Infinity], max = [-Infinity, -Infinity];
+    for (let i = 0; i < 8; i++) {
+      const x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+      const z = i & 4 ? bounds.max[2] : bounds.min[2];
+      const px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+      const py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+      min[0] = Math.min(min[0], px); min[1] = Math.min(min[1], py);
+      max[0] = Math.max(max[0], px); max[1] = Math.max(max[1], py);
+    }
+    if (layer.header.maxLat !== undefined && layer.header.minLon !== undefined &&
+      layer.header.minLat !== undefined && layer.header.maxLon !== undefined) {
+      const nw = map.project([layer.header.maxLat, layer.header.minLon], zoom);
+      const se = map.project([layer.header.minLat, layer.header.maxLon], zoom);
+      min[0] = Math.max(min[0], nw.x); min[1] = Math.max(min[1], nw.y);
+      max[0] = Math.min(max[0], se.x); max[1] = Math.min(max[1], se.y);
+      if (min[0] >= max[0] || min[1] >= max[1]) continue;
+    }
+    intersectsArchive = true;
+    let remaining = [[min[0], min[1], max[0], max[1]]];
+    for (const tile of layer._rasterTiles.values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      const size = 256 * 2 ** (zoom - tile.coords.z);
+      const left = tile.coords.x * size, top = tile.coords.y * size;
+      remaining = remaining.flatMap(([x0, y0, x1, y1]) => {
+        const l = Math.max(x0, left), t = Math.max(y0, top);
+        const r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+        if (l >= r || t >= b) return [[x0, y0, x1, y1]];
+        const pieces = [];
+        if (y0 < t) pieces.push([x0, y0, x1, t]);
+        if (b < y1) pieces.push([x0, b, x1, y1]);
+        if (x0 < l) pieces.push([x0, t, l, b]);
+        if (r < x1) pieces.push([r, t, x1, b]);
+        return pieces;
+      });
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive;
+}

package/src/utils/routeGeometry.js

@@ -0,0 +1,22 @@
+/** Dashed lane outline, in layer-local metres. */
+
+export function routeGeometry(lanes) {
+  const position = [], normal = [], color = [];
+  for (const { points, lengths } of lanes) for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1], b = points[i];
+    const dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];
+    if (!length) continue;
+    const x = -dz / length * 2.5, z = dx / length * 2.5;
+    for (let distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {
+      const start = Math.max(0, (distance - lengths[i - 1]) / length);
+      const end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);
+      if (end <= start) continue;
+      const p = [a[0] + dx * start, a[1] + dz * start], q = [a[0] + dx * end, a[1] + dz * end], y = a[2] + 0.4;
+      for (const point of [[p[0] - x, p[1] - z], [p[0] + x, p[1] + z], [q[0] + x, q[1] + z],
+      [p[0] - x, p[1] - z], [q[0] + x, q[1] + z], [q[0] - x, q[1] - z]]) {
+        position.push(point[0], y, point[1]); normal.push(0, 1, 0); color.push(0.08, 0.7, 0.85);
+      }
+    }
+  }
+  return { position, normal, color };
+}

package/src/utils/scheduledTrips.js

@@ -0,0 +1,29 @@
+/**
+ * Trips of a frequency-based timetable (like GTFS frequencies.txt) underway at `date`, in the timetable's local time.
+ * @param {{timeZone: string, duration: number, services: Array<{from: string, to: string, every?: number, months?: number[], weekdays?: number[]}>}} timetable
+ * `duration` and `every` are minutes; `from`/`to` are 'HH:MM' first/last departures; months are 1-12, weekdays 0 (Sunday)-6.
+ * @returns {Array<{id: string, departure: string, progress: number}>} `progress` is 0-1 along the lane.
+ */
+
+export function scheduledTrips(date, { timeZone, duration, services }) {
+  const time = new Date(date);
+  if (!Number.isFinite(time.getTime())) throw new Error('Invalid date');
+  const clock = new Intl.DateTimeFormat('en-GB', {
+    timeZone, year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+  });
+  const parts = Object.fromEntries(clock.formatToParts(time).filter(p => p.type !== 'literal').map(p => [p.type, Number(p.value)]));
+  const minute = parts.hour * 60 + parts.minute + (parts.second + time.getUTCMilliseconds() / 1000) / 60;
+  const weekday = new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();
+  const minutes = clockTime => clockTime.split(':').reduce((hours, value) => hours * 60 + Number(value));
+  const departures = [];
+  for (const { from, to, every = Infinity, months, weekdays } of services) {
+    if (months?.includes(parts.month) === false || weekdays?.includes(weekday) === false) continue;
+    for (let departure = minutes(from); departure <= minutes(to); departure += every) departures.push(departure);
+  }
+  return departures.sort((a, b) => a - b).filter(departure => minute >= departure && minute < departure + duration).map(departure => ({
+    id: `${parts.year}-${parts.month}-${parts.day}-${departure}`,
+    departure: `${String(Math.floor(departure / 60)).padStart(2, '0')}:${String(departure % 60).padStart(2, '0')}`,
+    progress: (minute - departure) / duration,
+  }));
+}

package/src/utils/setGeoJSONData.js

@@ -0,0 +1,11 @@
+import { releaseArea } from './releaseArea.js';
+import { updateArea } from './updateArea.js';
+
+export function setGeoJSONData(layer, data) {
+  layer.options.data = data;
+  delete layer.options.url;
+  for (const area of layer._areas.values()) releaseArea(layer, area);
+  layer._areas.clear();
+  updateArea(layer);
+  return layer;
+}

package/src/utils/setHighlight.js

@@ -0,0 +1,13 @@
+import { update } from './update.js';
+
+/** Highlight a source vertex range in the shader; vertex colors stay untouched. */
+
+export function setHighlight(backend, feature) {
+  if (feature?.model) feature = null;
+  if (backend.highlightedFeature?.mesh === feature?.mesh &&
+    backend.highlightedFeature?.vertexStart === feature?.vertexStart) return;
+  if (backend.highlightedFeature) backend.highlightedFeature.mesh.highlight = null;
+  backend.highlightedFeature = feature;
+  if (feature) feature.mesh.highlight = [feature.vertexStart, feature.vertexEnd];
+  update(backend);
+}

package/src/utils/setPMTileOpacity.js

@@ -0,0 +1,7 @@
+import { setRasterOpacity } from './rasterTiles.js';
+
+export function setPMTileOpacity(backend, opacity) {
+  backend.options.opacity = opacity;
+  setRasterOpacity(backend, opacity);
+  return backend;
+}

package/src/utils/setPMTileZIndex.js

@@ -0,0 +1,7 @@
+import { setRasterZIndex } from './rasterTiles.js';
+
+export function setPMTileZIndex(backend, zIndex) {
+  backend.options.zIndex = zIndex;
+  setRasterZIndex(backend, zIndex);
+  return backend;
+}

package/src/utils/setParent.js

@@ -0,0 +1,7 @@
+/** Reparent/detach scene data without drawing or disposing GPU resources. */
+
+export function setParent(node, parent) {
+  if (node.parent) node.parent.children.splice(node.parent.children.indexOf(node), 1);
+  node.parent = parent;
+  if (parent) parent.children.push(node);
+}

package/src/utils/setTerrainHeight.js

@@ -0,0 +1,10 @@
+import { getElevation } from './getElevation.js';
+
+export function setTerrainHeight(layer) {
+  if (!layer.root || !layer.location) return;
+  layer._terrainBaseY ??= layer.root.position[1];
+  const terrain = layer._map?._terrain3D;
+  const elevation = terrain && getElevation(terrain, layer.location);
+  const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;
+  layer.root.position[1] = layer._terrainBaseY + (elevation ?? 0) + offset;
+}

package/src/utils/setVertexColor.js

@@ -0,0 +1,14 @@
+/**
+ * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
+ * @param {Object} mesh Layer-created mesh with a color attribute.
+ * @param {number} start Inclusive vertex index, not an offset into the RGB array.
+ * @param {number} end Exclusive vertex index.
+ * @param {Object} color sRGB {r,g,b}, typically from parseColor().
+ */
+
+export function setVertexColor(mesh, start, end, color) {
+  for (let i = start; i < end; i++) {
+    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);
+  }
+  mesh.geometry.attributes.color.needsUpdate = true;
+}

package/src/utils/showFeature.js

@@ -0,0 +1,27 @@
+/** Update tooltip content/position and arbitrate cursor ownership across shared layers. */
+
+export function showFeature(backend, feature, event) {
+  const tooltip = backend._tooltip;
+  if (!tooltip) return;
+  if (feature) {
+    tooltip.replaceChildren(backend.options.tooltip(feature));
+    tooltip.hidden = false;
+    const rect = backend.container.getBoundingClientRect();
+    const x = event.clientX - rect.left, y = event.clientY - rect.top;
+    tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;
+    tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;
+  } else {
+    tooltip.hidden = true;
+  }
+  const shared = backend._shared;
+  if (shared) {
+    const visible = [...shared._layers].some(layer => layer._tooltip && !layer._tooltip.hidden);
+    if (visible) {
+      if (shared._cursor === undefined) shared._cursor = backend.container.style.cursor;
+      backend.container.style.cursor = 'pointer';
+    } else if (shared._cursor !== undefined) {
+      backend.container.style.cursor = shared._cursor;
+      delete shared._cursor;
+    }
+  }
+}

package/src/utils/sizes.js

@@ -0,0 +1 @@
+export const sizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };

package/src/utils/skin.js

@@ -0,0 +1,2 @@
+// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.
+export const skin = [0.85, 0.64, 0.5], shirt = [0.75, 0.2, 0.15], trousers = [0.16, 0.2, 0.32], dark = [0.08, 0.07, 0.06];

package/src/utils/solarPosition.js

@@ -0,0 +1,17 @@
+import { horizontalPosition } from "./horizontalPosition.js";
+
+// Solar centre, without atmospheric refraction.
+
+export function solarPosition(date, lat, lng) {
+  const time = new Date(date).getTime();
+  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||
+    !Number.isFinite(lng) || Math.abs(lng) > 180) throw new Error('Invalid solar date or location');
+  const rad = Math.PI / 180, d = time / 86400000 - 10957.5;
+  const mean = (357.5291 + 0.98560028 * d) * rad;
+  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +
+    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * rad;
+  const obliquity = 23.4397 * rad;
+  const declination = Math.asin(Math.sin(longitude) * Math.sin(obliquity));
+  const ascension = Math.atan2(Math.sin(longitude) * Math.cos(obliquity), Math.cos(longitude));
+  return horizontalPosition(d, lat, lng, ascension, declination);
+}

package/src/utils/sortMeshes.js

@@ -0,0 +1,12 @@
+
+export function sortMeshes(meshes) {
+  return meshes.sort((a, b) => Number(Boolean(b.ground)) - Number(Boolean(a.ground)) ||
+    (a.ground && b.ground ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
+      a.tile.coords.z - b.tile.coords.z : 0) ||
+    Number(a.program.transparent) - Number(b.program.transparent) ||
+    (a.program.transparent
+      ? (a.renderOrder || 0) - (b.renderOrder || 0) ||
+      b._sortDepth - a._sortDepth || a.id - b.id
+      : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id)
+  );
+}

package/src/utils/speed.js

@@ -0,0 +1,3 @@
+// Pure helpers of the 'traffic' type: lane interpolation and vehicle scheduling.
+/** Default urban speed (m/s) used to turn a lane's hourly `flow` into vehicles on the road. */
+export const speed = 8;

package/src/utils/startZoom.js

@@ -0,0 +1,5 @@
+/** Preserve the outgoing tile level before Leaflet changes its logical zoom. */
+
+export function startZoom() {
+  this._zoomLevel = null;
+}

package/src/utils/taillight.js

@@ -0,0 +1 @@
+export const taillight = [1.7, 0.06, 0.05];

package/src/utils/terrainAtlas.js

@@ -0,0 +1,21 @@
+/** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */
+
+export function terrainAtlas(tiles, bounds) {
+  const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
+  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);
+  let low = Infinity, high = -Infinity;
+  for (const [key, values] of tiles) {
+    const [x, y] = key.split('/').map(Number);
+    const start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;
+    for (let row = 0; row < 256; row++) {
+      for (let column = 0; column < 256; column++) {
+        const value = values[row * 256 + column];
+        if (!Number.isFinite(value) || value <= -1000) continue;
+        elevations[start + row * columns * 256 + column] = value;
+        low = Math.min(low, value);
+        high = Math.max(high, value);
+      }
+    }
+  }
+  return { elevations, low, high };
+}

package/src/utils/terrainElevation.js

@@ -0,0 +1,20 @@
+/** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */
+
+export function terrainElevation(point, tiles) {
+  const x = point.x - 0.5, y = point.y - 0.5;
+  const x0 = Math.floor(x), y0 = Math.floor(y);
+  const fx = x - x0, fy = y - y0;
+  const sample = (px, py) => {
+    const tileX = Math.floor(px / 256), tileY = Math.floor(py / 256);
+    const tile = tiles.get(`${tileX}/${tileY}`);
+    if (!tile) return null;
+    const elevation = tile[(py - tileY * 256) * 256 + px - tileX * 256];
+    return Number.isFinite(elevation) && elevation > -1000 ? elevation : null;
+  };
+  const values = [sample(x0, y0), sample(x0 + 1, y0), sample(x0, y0 + 1), sample(x0 + 1, y0 + 1)];
+  const valid = values.map((value, i) => Number.isFinite(value) ? i : -1).filter(i => i >= 0);
+  if (!valid.length) return null;
+  if (valid.length < 4) return values[valid[0]];
+  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +
+    (values[2] * (1 - fx) + values[3] * fx) * fy;
+}

package/src/utils/terrainGrid.js

@@ -0,0 +1,23 @@
+/** Unit tile grid; the vertex shader supplies the elevation. */
+
+export function terrainGrid(divisions) {
+  const positions = [], normals = [], uvs = [], indices = [];
+  for (let row = 0; row <= divisions; row++) {
+    for (let column = 0; column <= divisions; column++) {
+      positions.push(column / divisions, 0, row / divisions);
+      normals.push(0, 1, 0);
+      uvs.push(column / divisions, row / divisions);
+      if (row < divisions && column < divisions) {
+        const a = row * (divisions + 1) + column;
+        const b = a + 1, c = a + divisions + 1, d = c + 1;
+        indices.push(a, c, b, b, c, d);
+      }
+    }
+  }
+  return {
+    position: { size: 3, data: new Float32Array(positions) },
+    normal: { size: 3, data: new Float32Array(normals) },
+    uv: { size: 2, data: new Float32Array(uvs) },
+    index: { data: new Uint16Array(indices) },
+  };
+}

package/src/utils/textureSampler.js

@@ -0,0 +1,10 @@
+/** Translate glTF sampler constants into WebGPU sampler options. */
+
+export function textureSampler(sampler) {
+  return {
+    addressModeU: sampler.wrapS === 33071 ? 'clamp-to-edge' : sampler.wrapS === 33648 ? 'mirror-repeat' : 'repeat',
+    addressModeV: sampler.wrapT === 33071 ? 'clamp-to-edge' : sampler.wrapT === 33648 ? 'mirror-repeat' : 'repeat',
+    magFilter: sampler.magFilter === 9728 ? 'nearest' : 'linear',
+    minFilter: sampler.minFilter === 9728 || sampler.minFilter === 9984 || sampler.minFilter === 9986 ? 'nearest' : 'linear',
+  };
+}

package/src/utils/tileId.js

@@ -0,0 +1,18 @@
+/** Cumulative Hilbert ID for an archive tile. */
+
+export function tileId(z, x, y) {
+  if (![z, x, y].every(Number.isInteger) || z < 0 || z > 26 ||
+    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');
+  let id = (4 ** z - 1) / 3;
+  const n = 2 ** z;
+  // Same cumulative Hilbert ordering used by build/pmtiles.js.
+  for (let s = n / 2; s >= 1; s /= 2) {
+    const rx = (x & s) ? 1 : 0, ry = (y & s) ? 1 : 0;
+    id += s * s * ((3 * rx) ^ ry);
+    if (!ry) {
+      if (rx) { x = n - 1 - x; y = n - 1 - y; }
+      [x, y] = [y, x];
+    }
+  }
+  return id;
+}

package/src/utils/toLanes.js

@@ -0,0 +1,7 @@
+// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),
+// `lengths` and `length` in layer-local metres.
+
+export const toLanes = ({ features = [] }) => features.flatMap(({ geometry, properties }) => {
+  const lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];
+  return lines.map(line => ({ latlngs: line.map(([lng, lat]) => [lat, lng]), properties: properties ?? {}, elevation: properties?.elevation }));
+});

package/src/utils/toSRGB.js

@@ -0,0 +1 @@
+export const toSRGB = value => value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;

package/src/utils/tooltip.js

@@ -0,0 +1,6 @@
+export const tooltip = ({ properties: p }) => {
+  const content = document.createElement('div');
+  content.style.whiteSpace = 'pre-line';
+  content.textContent = [p.name, p.departure && `Departure ${p.departure} ${p.timetable.timeZone}`, p.description].filter(Boolean).join('\n');
+  return content;
+};