tileserver-gl-light 5.5.0-pre.6 → 5.5.0

package/src/serve_data.js

@@ -14,6 +14,7 @@ import {
   getTileUrls,
   isValidRemoteUrl,
   fetchTileData,
+  lonLatToTilePixel,
 } from './utils.js';
 import { getPMtilesInfo, openPMtiles } from './pmtiles_adapter.js';
 import { gunzipP, gzipP } from './promises.js';
@@ -45,6 +46,7 @@ export const serve_data = {
   init: function (options, repo, programOpts) {
     const { verbose } = programOpts;
     const app = express().disable('x-powered-by');
+    app.use(express.json());
 
     /**
      * Handles requests for tile data, responding with the tile image.
@@ -168,6 +170,164 @@ export const serve_data = {
       return res.status(200).send(data);
     });
 
+    /**
+     * Validates elevation data source and returns source info or sends error response.
+     * @param {string} id - ID of the data source.
+     * @param {object} res - Express response object.
+     * @returns {object|null} Source info object or null if validation failed.
+     */
+    const validateElevationSource = (id, res) => {
+      // eslint-disable-next-line security/detect-object-injection -- id is route parameter for data source lookup
+      const item = repo?.[id];
+      if (!item) {
+        res.sendStatus(404);
+        return null;
+      }
+      if (!item.source) {
+        res.status(404).send('Missing source');
+        return null;
+      }
+      if (!item.tileJSON) {
+        res.status(404).send('Missing tileJSON');
+        return null;
+      }
+      if (!item.sourceType) {
+        res.status(404).send('Missing sourceType');
+        return null;
+      }
+      const { source, tileJSON, sourceType } = item;
+      if (sourceType !== 'pmtiles' && sourceType !== 'mbtiles') {
+        res.status(400).send('Invalid sourceType. Must be pmtiles or mbtiles.');
+        return null;
+      }
+      const encoding = tileJSON?.encoding;
+      if (encoding == null) {
+        res.status(400).send('Missing tileJSON.encoding');
+        return null;
+      }
+      if (encoding !== 'terrarium' && encoding !== 'mapbox') {
+        res.status(400).send('Invalid encoding. Must be terrarium or mapbox.');
+        return null;
+      }
+      const format = tileJSON?.format;
+      if (format == null) {
+        res.status(400).send('Missing tileJSON.format');
+        return null;
+      }
+      if (format !== 'webp' && format !== 'png') {
+        res.status(400).send('Invalid format. Must be webp or png.');
+        return null;
+      }
+      if (tileJSON.minzoom == null || tileJSON.maxzoom == null) {
+        res.status(400).send('Missing tileJSON zoom bounds');
+        return null;
+      }
+      return {
+        source,
+        sourceType,
+        encoding,
+        format,
+        tileSize: tileJSON.tileSize || 512,
+        minzoom: tileJSON.minzoom,
+        maxzoom: tileJSON.maxzoom,
+      };
+    };
+
+    /**
+     * Validates that a point has valid lon, lat, and z properties.
+     * @param {object} point - Point to validate.
+     * @param {number} index - Index of the point in the array.
+     * @returns {string|null} Error message if invalid, null if valid.
+     */
+    const validatePoint = (point, index) => {
+      if (point == null || typeof point !== 'object') {
+        return `Invalid point at index ${index}: point must be an object`;
+      }
+      if (typeof point.lon !== 'number' || !isFinite(point.lon)) {
+        return `Invalid point at index ${index}: lon must be a finite number`;
+      }
+      if (typeof point.lat !== 'number' || !isFinite(point.lat)) {
+        return `Invalid point at index ${index}: lat must be a finite number`;
+      }
+      if (typeof point.z !== 'number' || !isFinite(point.z)) {
+        return `Invalid point at index ${index}: z must be a finite number`;
+      }
+      return null;
+    };
+
+    /**
+     * Gets batch elevations for an array of points.
+     * @param {object} sourceInfo - Validated source info from validateElevationSource.
+     * @param {Array<{lon: number, lat: number, z: number}>} points - Array of validated points.
+     * @returns {Promise<Array<number|null>>} Array of elevations in same order as input.
+     */
+    const getBatchElevations = async (sourceInfo, points) => {
+      const {
+        source,
+        sourceType,
+        encoding,
+        format,
+        tileSize,
+        minzoom,
+        maxzoom,
+      } = sourceInfo;
+
+      // Group points by tile (including zoom level in the key)
+      const tileGroups = new Map();
+      for (let i = 0; i < points.length; i++) {
+        // eslint-disable-next-line security/detect-object-injection -- i is loop counter
+        const point = points[i];
+        let zoom = point.z;
+        if (zoom < minzoom) {
+          zoom = minzoom;
+        }
+        if (zoom > maxzoom) {
+          zoom = maxzoom;
+        }
+        const { tileX, tileY, pixelX, pixelY } = lonLatToTilePixel(
+          point.lon,
+          point.lat,
+          zoom,
+          tileSize,
+        );
+        const tileKey = `${zoom},${tileX},${tileY}`;
+        if (!tileGroups.has(tileKey)) {
+          tileGroups.set(tileKey, { zoom, tileX, tileY, pixels: [] });
+        }
+        tileGroups.get(tileKey).pixels.push({ pixelX, pixelY, index: i });
+      }
+
+      // Initialize results array with nulls
+      const results = new Array(points.length).fill(null);
+
+      // Process each tile and extract elevations
+      for (const [, tileData] of tileGroups) {
+        const { zoom, tileX, tileY, pixels } = tileData;
+        const fetchTile = await fetchTileData(
+          source,
+          sourceType,
+          zoom,
+          tileX,
+          tileY,
+        );
+        if (fetchTile == null) {
+          continue;
+        }
+
+        const elevations = await serve_rendered.getBatchElevationsFromTile(
+          fetchTile.data,
+          { encoding, format, tile_size: tileSize },
+          pixels,
+        );
+        for (const { index, elevation } of elevations) {
+          // eslint-disable-next-line security/detect-object-injection -- index is from internal elevation processing
+          results[index] = elevation;
+        }
+      }
+
+      return results;
+    };
+
     /**
      * Handles requests for elevation data.
      * @param {object} req - Express request object.
@@ -190,48 +350,23 @@ export const serve_data = {
           );
         }
 
-        const item = repo?.[req.params.id];
-        if (!item) return res.sendStatus(404);
-        if (!item.source) return res.status(404).send('Missing source');
-        if (!item.tileJSON) return res.status(404).send('Missing tileJSON');
-        if (!item.sourceType) return res.status(404).send('Missing sourceType');
-        const { source, tileJSON, sourceType } = item;
-        if (sourceType !== 'pmtiles' && sourceType !== 'mbtiles') {
-          return res
-            .status(400)
-            .send('Invalid sourceType. Must be pmtiles or mbtiles.');
-        }
-        const encoding = tileJSON?.encoding;
-        if (encoding == null) {
-          return res.status(400).send('Missing tileJSON.encoding');
-        } else if (encoding !== 'terrarium' && encoding !== 'mapbox') {
-          return res
-            .status(400)
-            .send('Invalid encoding. Must be terrarium or mapbox.');
-        }
-        const format = tileJSON?.format;
-        if (format == null) {
-          return res.status(400).send('Missing tileJSON.format');
-        } else if (format !== 'webp' && format !== 'png') {
-          return res.status(400).send('Invalid format. Must be webp or png.');
-        }
+        const sourceInfo = validateElevationSource(req.params.id, res);
+        if (!sourceInfo) return;
+
         const z = parseInt(req.params.z, 10);
         const x = parseFloat(req.params.x);
         const y = parseFloat(req.params.y);
-        if (tileJSON.minzoom == null || tileJSON.maxzoom == null) {
-          return res.status(404).send(JSON.stringify(tileJSON));
-        }
-        const TILE_SIZE = tileJSON.tileSize || 512;
-        let bbox;
-        let xy;
-        var zoom = z;
+
+        let lon, lat;
+        let zoom = z;
 
         if (Number.isInteger(x) && Number.isInteger(y)) {
+          // Tile coordinates mode - strict bounds checking
           const intX = parseInt(req.params.x, 10);
           const intY = parseInt(req.params.y, 10);
           if (
-            zoom < tileJSON.minzoom ||
-            zoom > tileJSON.maxzoom ||
+            zoom < sourceInfo.minzoom ||
+            zoom > sourceInfo.maxzoom ||
             intX < 0 ||
             intY < 0 ||
             intX >= Math.pow(2, zoom) ||
@@ -239,49 +374,83 @@ export const serve_data = {
           ) {
             return res.status(404).send('Out of bounds');
           }
-          xy = [intX, intY];
-          bbox = new SphericalMercator().bbox(intX, intY, zoom);
+          const bbox = new SphericalMercator().bbox(intX, intY, zoom);
+          lon = (bbox[0] + bbox[2]) / 2;
+          lat = (bbox[1] + bbox[3]) / 2;
         } else {
-          //no zoom limit with coordinates
-          if (zoom < tileJSON.minzoom) {
-            zoom = tileJSON.minzoom;
-          }
-          if (zoom > tileJSON.maxzoom) {
-            zoom = tileJSON.maxzoom;
-          }
-          bbox = [x, y, x + 0.1, y + 0.1];
-          const { minX, minY } = new SphericalMercator().xyz(bbox, zoom);
-          xy = [minX, minY];
+          // Coordinate mode
+          lon = x;
+          lat = y;
         }
 
-        const fetchTile = await fetchTileData(
-          source,
-          sourceType,
-          zoom,
-          xy[0],
-          xy[1],
+        const results = await getBatchElevations(sourceInfo, [
+          { lon, lat, z: zoom },
+        ]);
+
+        if (results[0] == null) {
+          return res.status(204).send();
+        }
+
+        // Build response matching original format
+        const clampedZoom = Math.min(
+          Math.max(zoom, sourceInfo.minzoom),
+          sourceInfo.maxzoom,
         );
-        if (fetchTile == null) {
-          // sparse=true (default) -> 404 (allows overzoom)
-          // sparse=false -> 204 (empty tile, no overzoom)
-          return res.status(item.sparse ? 404 : 204).send();
+        const { tileX, tileY, pixelX, pixelY } = lonLatToTilePixel(
+          lon,
+          lat,
+          clampedZoom,
+          sourceInfo.tileSize,
+        );
+
+        res.status(200).json({
+          long: lon,
+          lat: lat,
+          elevation: results[0],
+          z: clampedZoom,
+          x: tileX,
+          y: tileY,
+          pixelX,
+          pixelY,
+        });
+      } catch (err) {
+        return res
+          .status(500)
+          .header('Content-Type', 'text/plain')
+          .send(err.message);
+      }
+    });
+
+    /**
+     * Handles batch elevation requests.
+     * Accepts a POST request with JSON body containing:
+     * - points: Array of {lon, lat, z} coordinates with zoom level
+     * Returns an array of elevations (or null for points with no data) in the same order as input.
+     * @param {object} req - Express request object.
+     * @param {object} res - Express response object.
+     * @param {string} req.params.id - ID of the data source.
+     * @returns {Promise<void>}
+     */
+    app.post('/:id/elevation', async (req, res, next) => {
+      try {
+        const sourceInfo = validateElevationSource(req.params.id, res);
+        if (!sourceInfo) return;
+
+        const { points } = req.body;
+        if (!Array.isArray(points) || points.length === 0) {
+          return res.status(400).send('Missing or empty points array');
         }
 
-        let data = fetchTile.data;
-        var param = {
-          long: bbox[0].toFixed(7),
-          lat: bbox[1].toFixed(7),
-          encoding,
-          format,
-          tile_size: TILE_SIZE,
-          z: zoom,
-          x: xy[0],
-          y: xy[1],
-        };
+        for (let i = 0; i < points.length; i++) {
+          // eslint-disable-next-line security/detect-object-injection -- i is loop counter
+          const error = validatePoint(points[i], i);
+          if (error) {
+            return res.status(400).send(error);
+          }
+        }
 
-        res
-          .status(200)
-          .send(await serve_rendered.getTerrainElevation(data, param));
+        const results = await getBatchElevations(sourceInfo, points);
+        res.status(200).json(results);
       } catch (err) {
         return res
           .status(500)

package/src/serve_light.js

@@ -6,8 +6,7 @@ export const serve_rendered = {
   add: (options, repo, params, id, programOpts, dataResolver) => {},
   remove: (repo, id) => {},
   clear: (repo) => {},
-  getTerrainElevation: (data, param) => {
-    param['elevation'] = 'not supported in light';
-    return param;
+  getBatchElevationsFromTile: (data, param, pixels) => {
+    return pixels.map(({ index }) => ({ index, elevation: null }));
   },
 };

package/src/serve_rendered.js

@@ -1832,83 +1832,66 @@ export const serve_rendered = {
       delete repo[id];
     });
   },
+
   /**
-   * Get the elevation of terrain tile data by rendering it to a canvas image
-   * @param {Buffer} data The terrain tile data buffer.
-   * @param {object} param Required parameters (coordinates e.g.)
-   * @returns {Promise<object>} Promise resolving to elevation data
+   * Gets multiple elevation values from a single decoded tile image.
+   * @param {Buffer} data - Raw tile image data
+   * @param {object} param - Parameters object containing encoding, format, and tile_size
+   * @param {Array<{pixelX: number, pixelY: number, index: number}>} pixels - Array of pixel coordinates to sample
+   * @returns {Promise<Array<{index: number, elevation: number}>>} Promise resolving to array of elevation results
    */
-  getTerrainElevation: async function (data, param) {
+  getBatchElevationsFromTile: async function (data, param, pixels) {
     return new Promise((resolve, reject) => {
-      const image = new Image(); // Create a new Image object
+      const image = new Image();
       image.onload = () => {
         try {
-          const canvas = createCanvas(param['tile_size'], param['tile_size']);
+          const canvas = createCanvas(param.tile_size, param.tile_size);
           const context = canvas.getContext('2d');
           context.drawImage(image, 0, 0);
 
-          // calculate pixel coordinate of tile,
-          // see https://developers.google.com/maps/documentation/javascript/examples/map-coordinates
-          let siny = Math.sin((param['lat'] * Math.PI) / 180);
-          // Truncating to 0.9999 effectively limits latitude to 89.189. This is
-          // about a third of a tile past the edge of the world tile.
-          siny = Math.min(Math.max(siny, -0.9999), 0.9999);
-          const xWorld = param['tile_size'] * (0.5 + param['long'] / 360);
-          const yWorld =
-            param['tile_size'] *
-            (0.5 - Math.log((1 + siny) / (1 - siny)) / (4 * Math.PI));
-
-          const scale = 1 << param['z'];
-
-          const xTile = Math.floor((xWorld * scale) / param['tile_size']);
-          const yTile = Math.floor((yWorld * scale) / param['tile_size']);
-
-          const xPixel =
-            Math.floor(xWorld * scale) - xTile * param['tile_size'];
-          const yPixel =
-            Math.floor(yWorld * scale) - yTile * param['tile_size'];
-          if (
-            xPixel < 0 ||
-            yPixel < 0 ||
-            xPixel >= param['tile_size'] ||
-            yPixel >= param['tile_size']
-          ) {
-            return reject('Out of bounds Pixel');
-          }
-          const imgdata = context.getImageData(xPixel, yPixel, 1, 1);
-          const red = imgdata.data[0];
-          const green = imgdata.data[1];
-          const blue = imgdata.data[2];
-          let elevation;
-          if (param['encoding'] === 'mapbox') {
-            elevation = -10000 + (red * 256 * 256 + green * 256 + blue) * 0.1;
-          } else if (param['encoding'] === 'terrarium') {
-            elevation = red * 256 + green + blue / 256 - 32768;
-          } else {
-            elevation = 'invalid encoding';
+          const results = [];
+          for (const pixel of pixels) {
+            const { pixelX, pixelY, index } = pixel;
+            if (
+              pixelX < 0 ||
+              pixelY < 0 ||
+              pixelX >= param.tile_size ||
+              pixelY >= param.tile_size
+            ) {
+              results.push({ index, elevation: null });
+              continue;
+            }
+            const imgdata = context.getImageData(pixelX, pixelY, 1, 1);
+            const red = imgdata.data[0];
+            const green = imgdata.data[1];
+            const blue = imgdata.data[2];
+            let elevation;
+            if (param.encoding === 'mapbox') {
+              elevation = -10000 + (red * 256 * 256 + green * 256 + blue) * 0.1;
+            } else if (param.encoding === 'terrarium') {
+              elevation = red * 256 + green + blue / 256 - 32768;
+            } else {
+              elevation = null;
+            }
+            results.push({ index, elevation });
           }
-          param['elevation'] = elevation;
-          param['red'] = red;
-          param['green'] = green;
-          param['blue'] = blue;
-          resolve(param);
+          resolve(results);
         } catch (error) {
-          reject(error); // Catch any errors during canvas operations
+          reject(error);
         }
       };
       image.onerror = (err) => reject(err);
 
-      // Load the image data - handle the sharp conversion outside the Promise
       (async () => {
         try {
-          if (param['format'] === 'webp') {
+          if (param.format === 'webp') {
             const img = await sharp(data).toFormat('png').toBuffer();
-            image.src = `data:image/png;base64,${img.toString('base64')}`; // Set data URL
+            image.src = `data:image/png;base64,${img.toString('base64')}`;
           } else {
             image.src = data;
           }
         } catch (err) {
-          reject(err); // Reject promise on sharp error
+          reject(err);
         }
       })();
     });

package/src/utils.js

@@ -471,6 +471,35 @@ export function isMBTilesProtocol(string) {
   }
 }
 
+/**
+ * Converts a longitude/latitude point to tile and pixel coordinates at a given zoom level.
+ * @param {number} lon - Longitude in degrees.
+ * @param {number} lat - Latitude in degrees.
+ * @param {number} zoom - Zoom level.
+ * @param {number} tileSize - Size of the tile in pixels (e.g., 256 or 512).
+ * @returns {{tileX: number, tileY: number, pixelX: number, pixelY: number}} - Tile and pixel coordinates.
+ */
+export function lonLatToTilePixel(lon, lat, zoom, tileSize) {
+  let siny = Math.sin((lat * Math.PI) / 180);
+  // Truncating to 0.9999 effectively limits latitude to 89.189. This is
+  // about a third of a tile past the edge of the world tile.
+  siny = Math.min(Math.max(siny, -0.9999), 0.9999);
+
+  const xWorld = tileSize * (0.5 + lon / 360);
+  const yWorld =
+    tileSize * (0.5 - Math.log((1 + siny) / (1 - siny)) / (4 * Math.PI));
+
+  const scale = 1 << zoom;
+
+  const tileX = Math.floor((xWorld * scale) / tileSize);
+  const tileY = Math.floor((yWorld * scale) / tileSize);
+
+  const pixelX = Math.floor(xWorld * scale) - tileX * tileSize;
+  const pixelY = Math.floor(yWorld * scale) - tileY * tileSize;
+
+  return { tileX, tileY, pixelX, pixelY };
+}
+
 /**
  * Fetches tile data from either PMTiles or MBTiles source.
  * @param {object} source - The source object, which may contain a mbtiles object, or pmtiles object.