leaflet-city-mapper 0.1.0 → 0.1.1

package/src/geometry/restoreGeometry.js

@@ -1,29 +1,29 @@
-/**
- * Recreate geometry buffers on a device from retained CPU attributes.
- *
- * @param {Object} geometry Geometry and attribute data to restore.
- * @param {GPUDevice} device Device receiving the buffers.
- */
-export function restoreGeometry(geometry, device) {
-  if (geometry.attributes.index?.data instanceof Uint8Array) {
-    geometry.attributes.index.data = /* alloc */ new Uint16Array(geometry.attributes.index.data);
-  }
-  let name, attribute, oldBuffer;
-  for (name in geometry.attributes) {
-    attribute = geometry.attributes[name];
-    attribute.size ||= 1;
-    attribute.count = attribute.data.length / attribute.size;
-    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-    oldBuffer = attribute.buffer;
-    attribute.buffer = device.createBuffer(/* alloc */ {
-      size: Math.max(4, attribute.data.byteLength),
-      usage: name === 'index'
-        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    oldBuffer?.destroy();
-  }
-  geometry.device = device;
-  geometry.drawRange.count = geometry.attributes.index?.count || geometry.attributes.position.count;
-}
+/**
+ * Recreate geometry buffers on a device from retained CPU attributes.
+ *
+ * @param {Object} geometry Geometry and attribute data to restore.
+ * @param {GPUDevice} device Device receiving the buffers.
+ */
+export function restoreGeometry(geometry, device) {
+  if (geometry.attributes.index?.data instanceof Uint8Array) {
+    geometry.attributes.index.data = /* alloc */ new Uint16Array(geometry.attributes.index.data);
+  }
+  let name, attribute, oldBuffer;
+  for (name in geometry.attributes) {
+    attribute = geometry.attributes[name];
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    oldBuffer = attribute.buffer;
+    attribute.buffer = device.createBuffer(/* alloc */ {
+      size: Math.max(4, attribute.data.byteLength),
+      usage: name === 'index'
+        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    oldBuffer?.destroy();
+  }
+  geometry.device = device;
+  geometry.drawRange.count = geometry.attributes.index?.count || geometry.attributes.position.count;
+}

package/src/geometry/roofCoverage.js

@@ -1,33 +1,33 @@
-import { headerByLayer } from '../weakmaps/headerByLayer.js';
-import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
-import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
-import { roofFootprint } from './roofFootprint.js';
-import { subtractRoofTile } from './subtractRoofTile.js';
-
-/**
- * Test the mesh's ground footprint against loaded imagery, including coarse parent tiles.
- *
- * @param {Object} mesh Mesh whose footprint is tested.
- * @param {L.Layer} layer Rendering layer.
- * @param {Array<L.Layer>} rasters Raster layers to inspect.
- *
- * @returns {boolean} Whether the footprint is covered or needs no imagery.
- */
-export function roofCoverage(mesh, layer, rasters) {
-  let intersectsArchive = false, pending = false;
-  let rasterLayer, footprint, remaining, tile;
-  for (rasterLayer of rasters) {
-    if (!headerByLayer.get(rasterLayer)) { pending = true; continue; }
-    footprint = roofFootprint(mesh, layer, rasterLayer);
-    if (!footprint) continue;
-    intersectsArchive = true;
-    remaining = /* alloc */ [footprint];
-    for (tile of rasterTilesByLayer.get(rasterLayer).values()) {
-      // Failed imagery already reports an error; do not hide the building indefinitely.
-      if (!tile.done && !tile.error) continue;
-      remaining = subtractRoofTile(remaining, tile, tileZoomByLayer.get(rasterLayer));
-      if (!remaining.length) return true;
-    }
-  }
-  return !intersectsArchive && !pending;
-}
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { rasterTilesByLayer } from '../weakmaps/rasterTilesByLayer.js';
+import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
+import { roofFootprint } from './roofFootprint.js';
+import { subtractRoofTile } from './subtractRoofTile.js';
+
+/**
+ * Test the mesh's ground footprint against loaded imagery, including coarse parent tiles.
+ *
+ * @param {Object} mesh Mesh whose footprint is tested.
+ * @param {L.Layer} layer Rendering layer.
+ * @param {Array<L.Layer>} rasters Raster layers to inspect.
+ *
+ * @returns {boolean} Whether the footprint is covered or needs no imagery.
+ */
+export function roofCoverage(mesh, layer, rasters) {
+  let intersectsArchive = false, pending = false;
+  let rasterLayer, footprint, remaining, tile;
+  for (rasterLayer of rasters) {
+    if (!headerByLayer.get(rasterLayer)) { pending = true; continue; }
+    footprint = roofFootprint(mesh, layer, rasterLayer);
+    if (!footprint) continue;
+    intersectsArchive = true;
+    remaining = /* alloc */ [footprint];
+    for (tile of rasterTilesByLayer.get(rasterLayer).values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      remaining = subtractRoofTile(remaining, tile, tileZoomByLayer.get(rasterLayer));
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive && !pending;
+}

package/src/geometry/roofFootprint.js

@@ -1,40 +1,40 @@
-import { headerByLayer } from '../weakmaps/headerByLayer.js';
-import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
-import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
-import { radians } from '../globals/radians.js';
-import { earthCirc } from '../globals/earthCirc.js';
-
-/**
- * Project a mesh's bounding box into raster pixels and clip it to archive bounds.
- *
- * @param {Object} mesh Mesh with bounds and world matrix.
- * @param {L.Layer} layer Rendering layer.
- * @param {L.Layer} rasterLayer Raster layer providing zoom and archive bounds.
- *
- * @returns {Array<number>|null} Pixel rectangle, or null when outside the archive.
- */
-export function roofFootprint(mesh, layer, rasterLayer) {
-  const map = layer._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
-  const zoom = tileZoomByLayer.get(rasterLayer)
-  const origin = map.project(sceneOriginByLayer.get(layer), zoom);
-  const scale = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  let i, x, y, z, px, py, nw, se;
-  for (i = 0; i < 8; i++) {
-    x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
-    z = i & 4 ? bounds.max[2] : bounds.min[2];
-    px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
-    py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
-    minX = Math.min(minX, px); minY = Math.min(minY, py);
-    maxX = Math.max(maxX, px); maxY = Math.max(maxY, py);
-  }
-  if (headerByLayer.get(rasterLayer).maxLat !== undefined && headerByLayer.get(rasterLayer).minLon !== undefined &&
-    headerByLayer.get(rasterLayer).minLat !== undefined && headerByLayer.get(rasterLayer).maxLon !== undefined) {
-    nw = map.project(/* alloc */ [headerByLayer.get(rasterLayer).maxLat, headerByLayer.get(rasterLayer).minLon], zoom);
-    se = map.project(/* alloc */ [headerByLayer.get(rasterLayer).minLat, headerByLayer.get(rasterLayer).maxLon], zoom);
-    minX = Math.max(minX, nw.x); minY = Math.max(minY, nw.y);
-    maxX = Math.min(maxX, se.x); maxY = Math.min(maxY, se.y);
-    if (minX >= maxX || minY >= maxY) return null;
-  }
-  return /* alloc */ [minX, minY, maxX, maxY];
-}
+import { headerByLayer } from '../weakmaps/headerByLayer.js';
+import { sceneOriginByLayer } from '../weakmaps/sceneOriginByLayer.js';
+import { tileZoomByLayer } from '../weakmaps/tileZoomByLayer.js';
+import { radians } from '../globals/radians.js';
+import { earthCirc } from '../globals/earthCirc.js';
+
+/**
+ * Project a mesh's bounding box into raster pixels and clip it to archive bounds.
+ *
+ * @param {Object} mesh Mesh with bounds and world matrix.
+ * @param {L.Layer} layer Rendering layer.
+ * @param {L.Layer} rasterLayer Raster layer providing zoom and archive bounds.
+ *
+ * @returns {Array<number>|null} Pixel rectangle, or null when outside the archive.
+ */
+export function roofFootprint(mesh, layer, rasterLayer) {
+  const map = layer._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  const zoom = tileZoomByLayer.get(rasterLayer)
+  const origin = map.project(sceneOriginByLayer.get(layer), zoom);
+  const scale = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneOriginByLayer.get(layer).lat * radians));
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let i, x, y, z, px, py, nw, se;
+  for (i = 0; i < 8; i++) {
+    x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+    z = i & 4 ? bounds.max[2] : bounds.min[2];
+    px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+    py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+    minX = Math.min(minX, px); minY = Math.min(minY, py);
+    maxX = Math.max(maxX, px); maxY = Math.max(maxY, py);
+  }
+  if (headerByLayer.get(rasterLayer).maxLat !== undefined && headerByLayer.get(rasterLayer).minLon !== undefined &&
+    headerByLayer.get(rasterLayer).minLat !== undefined && headerByLayer.get(rasterLayer).maxLon !== undefined) {
+    nw = map.project(/* alloc */ [headerByLayer.get(rasterLayer).maxLat, headerByLayer.get(rasterLayer).minLon], zoom);
+    se = map.project(/* alloc */ [headerByLayer.get(rasterLayer).minLat, headerByLayer.get(rasterLayer).maxLon], zoom);
+    minX = Math.max(minX, nw.x); minY = Math.max(minY, nw.y);
+    maxX = Math.min(maxX, se.x); maxY = Math.min(maxY, se.y);
+    if (minX >= maxX || minY >= maxY) return null;
+  }
+  return /* alloc */ [minX, minY, maxX, maxY];
+}

package/src/geometry/samePoint.js

@@ -1,11 +1,11 @@
-/**
- * Compare two 2D coordinates with the geometry tolerance.
- *
- * @param {Array<number>} a First coordinate.
- * @param {Array<number>} b Second coordinate.
- *
- * @returns {boolean} Whether both components are within tolerance.
- */
-export function samePoint(a, b) {
-  return Math.abs(a[0] - b[0]) < 1e-10 && Math.abs(a[1] - b[1]) < 1e-10;
-}
+/**
+ * Compare two 2D coordinates with the geometry tolerance.
+ *
+ * @param {Array<number>} a First coordinate.
+ * @param {Array<number>} b Second coordinate.
+ *
+ * @returns {boolean} Whether both components are within tolerance.
+ */
+export function samePoint(a, b) {
+  return Math.abs(a[0] - b[0]) < 1e-10 && Math.abs(a[1] - b[1]) < 1e-10;
+}

package/src/geometry/segment.js

@@ -1,32 +1,32 @@
-import { L } from '../globals/L.js';
-import { triangle } from './appendNativeTriangle.js';
-import { disk } from './disk.js';
-
-/**
- * Append a stroke segment with optional square or round caps.
- *
- * @param {Object} context Line style and geometry buffers.
- * @param {L.Point} a Segment start.
- * @param {L.Point} b Segment end.
- * @param {boolean} startCap Whether to add a start cap.
- * @param {boolean} endCap Whether to add an end cap.
- */
-export function segment(context, a, b, startCap, endCap) {
-  const { options, width, stroke, point } = context;
-  const radius = width / 2;
-  const anchorA = a, anchorB = b;
-  const length = a.distanceTo(b);
-  if (!length) return;
-  const direction = b.subtract(a).divideBy(length);
-  const normal = /* alloc */ new L.Point(-direction.y * radius, direction.x * radius);
-  if (options.lineCap === 'square') {
-    if (startCap) a = a.subtract(direction.multiplyBy(radius));
-    if (endCap) b = b.add(direction.multiplyBy(radius));
-  }
-  triangle(point, stroke, a.add(normal), a.subtract(normal), b.add(normal), anchorA, anchorA, anchorB);
-  triangle(point, stroke, b.add(normal), a.subtract(normal), b.subtract(normal), anchorB, anchorA, anchorB);
-  if (options.lineCap === 'round') {
-    if (startCap) disk(point, a, radius, stroke);
-    if (endCap) disk(point, b, radius, stroke);
-  }
-}
+import { L } from '../globals/L.js';
+import { triangle } from './appendNativeTriangle.js';
+import { disk } from './disk.js';
+
+/**
+ * Append a stroke segment with optional square or round caps.
+ *
+ * @param {Object} context Line style and geometry buffers.
+ * @param {L.Point} a Segment start.
+ * @param {L.Point} b Segment end.
+ * @param {boolean} startCap Whether to add a start cap.
+ * @param {boolean} endCap Whether to add an end cap.
+ */
+export function segment(context, a, b, startCap, endCap) {
+  const { options, width, stroke, point } = context;
+  const radius = width / 2;
+  const anchorA = a, anchorB = b;
+  const length = a.distanceTo(b);
+  if (!length) return;
+  const direction = b.subtract(a).divideBy(length);
+  const normal = /* alloc */ new L.Point(-direction.y * radius, direction.x * radius);
+  if (options.lineCap === 'square') {
+    if (startCap) a = a.subtract(direction.multiplyBy(radius));
+    if (endCap) b = b.add(direction.multiplyBy(radius));
+  }
+  triangle(point, stroke, a.add(normal), a.subtract(normal), b.add(normal), anchorA, anchorA, anchorB);
+  triangle(point, stroke, b.add(normal), a.subtract(normal), b.subtract(normal), anchorB, anchorA, anchorB);
+  if (options.lineCap === 'round') {
+    if (startCap) disk(point, a, radius, stroke);
+    if (endCap) disk(point, b, radius, stroke);
+  }
+}

package/src/geometry/subtractRoofTile.js

@@ -1,28 +1,28 @@
-/**
- * Subtract a raster tile's footprint from uncovered roof rectangles.
- *
- * @param {Array<Array<number>>} remaining Uncovered pixel rectangles.
- * @param {Object} tile Raster tile with XYZ coordinates.
- * @param {number} zoom Zoom used by the rectangles.
- *
- * @returns {Array<Array<number>>} Remaining uncovered rectangles.
- */
-export function subtractRoofTile(remaining, tile, zoom) {
-  const size = 256 * 2 ** (zoom - tile.coords.z);
-  const left = tile.coords.x * size, top = tile.coords.y * size;
-  const pieces = /* alloc */ [];
-  let x0, y0, x1, y1, l, t, r, b;
-  for ([x0, y0, x1, y1] of remaining) {
-    l = Math.max(x0, left), t = Math.max(y0, top);
-    r = Math.min(x1, left + size), b = Math.min(y1, top + size);
-    if (l >= r || t >= b) {
-      pieces.push(/* alloc */ [x0, y0, x1, y1]);
-      continue;
-    }
-    if (y0 < t) pieces.push(/* alloc */ [x0, y0, x1, t]);
-    if (b < y1) pieces.push(/* alloc */ [x0, b, x1, y1]);
-    if (x0 < l) pieces.push(/* alloc */ [x0, t, l, b]);
-    if (r < x1) pieces.push(/* alloc */ [r, t, x1, b]);
-  }
-  return pieces;
-}
+/**
+ * Subtract a raster tile's footprint from uncovered roof rectangles.
+ *
+ * @param {Array<Array<number>>} remaining Uncovered pixel rectangles.
+ * @param {Object} tile Raster tile with XYZ coordinates.
+ * @param {number} zoom Zoom used by the rectangles.
+ *
+ * @returns {Array<Array<number>>} Remaining uncovered rectangles.
+ */
+export function subtractRoofTile(remaining, tile, zoom) {
+  const size = 256 * 2 ** (zoom - tile.coords.z);
+  const left = tile.coords.x * size, top = tile.coords.y * size;
+  const pieces = /* alloc */ [];
+  let x0, y0, x1, y1, l, t, r, b;
+  for ([x0, y0, x1, y1] of remaining) {
+    l = Math.max(x0, left), t = Math.max(y0, top);
+    r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+    if (l >= r || t >= b) {
+      pieces.push(/* alloc */ [x0, y0, x1, y1]);
+      continue;
+    }
+    if (y0 < t) pieces.push(/* alloc */ [x0, y0, x1, t]);
+    if (b < y1) pieces.push(/* alloc */ [x0, b, x1, y1]);
+    if (x0 < l) pieces.push(/* alloc */ [x0, t, l, b]);
+    if (r < x1) pieces.push(/* alloc */ [r, t, x1, b]);
+  }
+  return pieces;
+}

package/src/geometry/terrainBuffers.js

@@ -1,36 +1,36 @@
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-import { terrainGridsByLayer } from '../weakmaps/terrainGridsByLayer.js';
-import { demBuffer } from '../globals/demBuffer.js';
-import { terrainGrid } from './terrainGrid.js';
-
-/**
- * Get or create cached GPU buffers for a terrain grid subdivision count.
- *
- * @param {L.Layer} layer Terrain layer owning the cache.
- * @param {number} divisions Grid subdivisions per side.
- *
- * @returns {Object} GPU-backed grid attributes.
- */
-export function terrainBuffers(layer, divisions) {
-  const device = rendererByLayer.get(layer).device
-  let attributes = terrainGridsByLayer.get(layer).get(divisions);
-  if (!attributes) {
-    attributes = terrainGrid(divisions);
-    let name, attribute;
-    for ([name, attribute] of Object.entries(attributes)) {
-      attribute.size ||= 1;
-      attribute.count = attribute.data.length / attribute.size;
-      attribute.indexFormat = 'uint16';
-      attribute.buffer = device.createBuffer((
-        demBuffer.size = Math.max(4, attribute.data.byteLength),
-        demBuffer.usage = name === 'index'
-          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        demBuffer
-      ));
-      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    }
-    terrainGridsByLayer.get(layer).set(divisions, attributes);
-  }
-  return attributes;
-}
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { terrainGridsByLayer } from '../weakmaps/terrainGridsByLayer.js';
+import { demBuffer } from '../globals/demBuffer.js';
+import { terrainGrid } from './terrainGrid.js';
+
+/**
+ * Get or create cached GPU buffers for a terrain grid subdivision count.
+ *
+ * @param {L.Layer} layer Terrain layer owning the cache.
+ * @param {number} divisions Grid subdivisions per side.
+ *
+ * @returns {Object} GPU-backed grid attributes.
+ */
+export function terrainBuffers(layer, divisions) {
+  const device = rendererByLayer.get(layer).device
+  let attributes = terrainGridsByLayer.get(layer).get(divisions);
+  if (!attributes) {
+    attributes = terrainGrid(divisions);
+    let name, attribute;
+    for ([name, attribute] of Object.entries(attributes)) {
+      attribute.size ||= 1;
+      attribute.count = attribute.data.length / attribute.size;
+      attribute.indexFormat = 'uint16';
+      attribute.buffer = device.createBuffer((
+        demBuffer.size = Math.max(4, attribute.data.byteLength),
+        demBuffer.usage = name === 'index'
+          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        demBuffer
+      ));
+      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+    }
+    terrainGridsByLayer.get(layer).set(divisions, attributes);
+  }
+  return attributes;
+}

package/src/geometry/terrainTileGeometry.js

@@ -1,28 +1,28 @@
-import { demByLayer } from '../weakmaps/demByLayer.js';
-import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
-import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
-
-/**
- * Create terrain tile geometry with bounds covering DEM-displaced elevations.
- *
- * @param {L.Layer} layer Terrain layer.
- * @param {Object} attributes Shared terrain grid attributes.
- * @param {number} sizeX Tile width in scene units.
- * @param {number} sizeZ Tile depth in scene units.
- *
- * @returns {Object} Tile geometry and bounds.
- */
-export function terrainTileGeometry(layer, attributes, sizeX, sizeZ) {
-  const base = terrainOriginElevationByLayer.get(layer)
-  const bottom = Math.min(demByLayer.get(layer).low, base) - base, top = Math.max(demByLayer.get(layer).high, base) - base;
-  return /* alloc */ {
-    device: rendererByLayer.get(layer).device,
-    attributes,
-    drawRange: /* alloc */ { start: 0, count: attributes.index.count },
-    // Bounds must cover the DEM-displaced tile, although picking uses the flat grid.
-    bounds: /* alloc */ {
-      min: /* alloc */ [0, bottom, 0], max: /* alloc */ [1, top, 1], center: /* alloc */ [0.5, (bottom + top) / 2, 0.5],
-      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
-    },
-  };
-}
+import { demByLayer } from '../weakmaps/demByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+
+/**
+ * Create terrain tile geometry with bounds covering DEM-displaced elevations.
+ *
+ * @param {L.Layer} layer Terrain layer.
+ * @param {Object} attributes Shared terrain grid attributes.
+ * @param {number} sizeX Tile width in scene units.
+ * @param {number} sizeZ Tile depth in scene units.
+ *
+ * @returns {Object} Tile geometry and bounds.
+ */
+export function terrainTileGeometry(layer, attributes, sizeX, sizeZ) {
+  const base = terrainOriginElevationByLayer.get(layer)
+  const bottom = Math.min(demByLayer.get(layer).low, base) - base, top = Math.max(demByLayer.get(layer).high, base) - base;
+  return /* alloc */ {
+    device: rendererByLayer.get(layer).device,
+    attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.index.count },
+    // Bounds must cover the DEM-displaced tile, although picking uses the flat grid.
+    bounds: /* alloc */ {
+      min: /* alloc */ [0, bottom, 0], max: /* alloc */ [1, top, 1], center: /* alloc */ [0.5, (bottom + top) / 2, 0.5],
+      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
+    },
+  };
+}

package/src/geometry/validateTree.js

@@ -1,19 +1,19 @@
-/**
- * Validate tree radii, crown height and crown shape.
- *
- * @param {number} trunkRadius Trunk radius.
- * @param {number} crownRadius Crown radius.
- * @param {number} crownBottom Height where the crown begins.
- * @param {number} bottom Tree bottom height.
- * @param {number} top Tree top height.
- * @param {string} crownShape Crown shape.
- *
- * @throws {Error} If dimensions or crown shape are invalid.
- */
-export function validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape) {
-  if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) ||
-    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
-    crownShape !== 'round' && crownShape !== 'cone') {
-    throw /* alloc */ new Error('Invalid tree dimensions or crown shape');
-  }
-}
+/**
+ * Validate tree radii, crown height and crown shape.
+ *
+ * @param {number} trunkRadius Trunk radius.
+ * @param {number} crownRadius Crown radius.
+ * @param {number} crownBottom Height where the crown begins.
+ * @param {number} bottom Tree bottom height.
+ * @param {number} top Tree top height.
+ * @param {string} crownShape Crown shape.
+ *
+ * @throws {Error} If dimensions or crown shape are invalid.
+ */
+export function validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape) {
+  if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) ||
+    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
+    crownShape !== 'round' && crownShape !== 'cone') {
+    throw /* alloc */ new Error('Invalid tree dimensions or crown shape');
+  }
+}

package/src/globals/L.js

@@ -1,6 +1,6 @@
-/**
- * Leaflet namespace supplied by the host environment.
- *
- * @type {Object}
- */
-export const L = globalThis.L;
+/**
+ * Leaflet namespace supplied by the host environment.
+ *
+ * @type {Object}
+ */
+export const L = globalThis.L;

package/src/globals/cameraFov.js

@@ -1,8 +1,8 @@
-import { degrees } from './degrees.js';
-
-/**
- * Camera vertical field of view in degrees.
- *
- * @type {number}
- */
-export const cameraFov = 2 * Math.atan(1 / 3) * degrees;
+import { degrees } from './degrees.js';
+
+/**
+ * Camera vertical field of view in degrees.
+ *
+ * @type {number}
+ */
+export const cameraFov = 2 * Math.atan(1 / 3) * degrees;

package/src/globals/cogTags.js

@@ -1,6 +1,6 @@
-/**
- * TIFF tag identifiers read from COG image directories.
- *
- * @type {Array<number>}
- */
-export const cogTags = [256, 257, 258, 259, 262, 277, 284, 317, 322, 323, 324, 325, 339, 33550, 33922, 34735];
+/**
+ * TIFF tag identifiers read from COG image directories.
+ *
+ * @type {Array<number>}
+ */
+export const cogTags = [256, 257, 258, 259, 262, 277, 284, 317, 322, 323, 324, 325, 339, 33550, 33922, 34735];

package/src/globals/colorTexture.js

@@ -1,11 +1,11 @@
-/**
- * Reusable multisampled color texture descriptor for renderer resizing.
- *
- * @type {Object}
- */
-export const colorTexture = {
-  size: [null, null],
-  format: null,
-  sampleCount: 4,
-  usage: null
-};
+/**
+ * Reusable multisampled color texture descriptor for renderer resizing.
+ *
+ * @type {Object}
+ */
+export const colorTexture = {
+  size: [null, null],
+  format: null,
+  sampleCount: 4,
+  usage: null
+};

package/src/globals/cosObliquity.js

@@ -1,8 +1,8 @@
-import { radians } from './radians.js';
-
-/**
- * Cosine of Earth's axial obliquity used in celestial position calculations.
- *
- * @type {number}
- */
-export const cosObliquity = Math.cos(23.4397 * radians);
+import { radians } from './radians.js';
+
+/**
+ * Cosine of Earth's axial obliquity used in celestial position calculations.
+ *
+ * @type {number}
+ */
+export const cosObliquity = Math.cos(23.4397 * radians);

package/src/globals/degrees.js

@@ -1,6 +1,6 @@
-/**
- * Conversion factor from radians to degrees.
- *
- * @type {number}
- */
-export const degrees = 180 / Math.PI;
+/**
+ * Conversion factor from radians to degrees.
+ *
+ * @type {number}
+ */
+export const degrees = 180 / Math.PI;

package/src/globals/earthCirc.js

@@ -1,6 +1,6 @@
-/**
- * Equatorial circumference in meters using the Web Mercator Earth radius.
- *
- * @type {number}
- */
-export const earthCirc = 2 * Math.PI * 6378137;
+/**
+ * Equatorial circumference in meters using the Web Mercator Earth radius.
+ *
+ * @type {number}
+ */
+export const earthCirc = 2 * Math.PI * 6378137;