@basemaps/lambda-tiler 6.28.0 → 6.30.0

package/src/routes/tile.json.ts

@@ -3,7 +3,6 @@ import { Env, extractTileMatrixSet } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Router } from '../router.js';
 import { TileSets } from '../tile.set.cache.js';
-import { getTileMatrixId } from '../wmts.capability.js';
 import { NotFound } from './response.js';
 
 export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
@@ -22,7 +21,7 @@ export async function tileJson(req: LambdaHttpRequest): Promise<LambdaHttpRespon
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
   const tileUrl =
-    [host, version, name, tileSet.fullName, getTileMatrixId(tileMatrix), '{z}', '{x}', '{y}'].join('/') +
+    [host, version, name, tileSet.fullName, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') +
     `.${tileSet.format}?api=${apiKey}`;
 
   const tileJson: TileJson = { tiles: [tileUrl], tilejson: '3.0.0' };

package/src/routes/tile.wmts.ts

@@ -1,19 +1,17 @@
 import { Config, TileSetType } from '@basemaps/config';
-import { ImageFormat, TileMatrixSet } from '@basemaps/geo';
-import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
+import { GoogleTms, ImageFormat, Nztm2000QuadTms } from '@basemaps/geo';
+import { Env, tileWmtsFromPath } from '@basemaps/shared';
 import { getImageFormat } from '@basemaps/tiler';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { createHash } from 'crypto';
 import { Router } from '../router.js';
-import { TileSets } from '../tile.set.cache.js';
-import { TileSetRaster } from '../tile.set.raster.js';
 import { WmtsCapabilities } from '../wmts.capability.js';
 import { NotFound, NotModified } from './response.js';
 import { TileEtag } from './tile.etag.js';
 
 export function getImageFormats(req: LambdaHttpRequest): ImageFormat[] | undefined {
-  const formats = req.query.getAll('format');
-  if (formats == null || formats.length === 0) return undefined;
+  const formats = [...req.query.getAll('format'), ...req.query.getAll('tileFormat')];
+  if (formats.length === 0) return;
 
   const output: Set<ImageFormat> = new Set();
   for (const fmt of formats) {
@@ -21,7 +19,7 @@ export function getImageFormats(req: LambdaHttpRequest): ImageFormat[] | undefin
     if (parsed == null) continue;
     output.add(parsed);
   }
-  if (output.size === 0) return undefined;
+  if (output.size === 0) return;
   return [...output.values()];
 }
 
@@ -38,18 +36,28 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
   const host = Env.get(Env.PublicUrlBase) ?? '';
 
   req.timer.start('tileset:load');
-  const tileSets = await wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
+  const tileSet = await Config.TileSet.get(Config.TileSet.id(wmtsData.name ?? 'aerial'));
   req.timer.end('tileset:load');
-  if (tileSets.length === 0) return NotFound;
+  if (tileSet == null || tileSet.type !== TileSetType.Raster) return NotFound;
 
-  const providerId = Config.Provider.id('linz');
-  const provider = await Config.Provider.get(providerId);
+  const provider = await Config.Provider.get(Config.Provider.id('linz'));
+
+  const tileMatrix = wmtsData.tileMatrix == null ? [GoogleTms, Nztm2000QuadTms] : [wmtsData.tileMatrix];
+  req.timer.start('imagery:load');
+  const imagery = await Config.getAllImagery(
+    tileSet.layers,
+    tileMatrix.map((tms) => tms.projection),
+  );
+  req.timer.end('imagery:load');
 
   const apiKey = Router.apiKey(req);
   const xml = new WmtsCapabilities({
     httpBase: host,
     provider: provider ?? undefined,
-    layers: tileSets,
+    tileSet,
+    tileMatrix,
+    isIndividualLayers: wmtsData.tileMatrix == null,
+    imagery,
     apiKey,
     formats: getImageFormats(req),
   }).toXml();
@@ -67,13 +75,3 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
   req.set('bytes', data.byteLength);
   return response;
 }
-
-async function wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
-  if (tileMatrix != null) {
-    const ts = await TileSets.get(name, tileMatrix);
-    if (ts == null || ts.type === TileSetType.Vector) return [];
-    return [ts];
-  }
-  if (name === '') name = TileSetName.aerial;
-  return (await TileSets.getAll(name, tileMatrix)).filter((f) => f.type === 'raster') as TileSetRaster[];
-}

package/src/tile.set.cache.ts

@@ -1,5 +1,5 @@
 import { TileSetNameParser, TileSetType } from '@basemaps/config';
-import { TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { TileMatrixSet } from '@basemaps/geo';
 import { Config } from '@basemaps/shared';
 import { TileSet } from './tile.set.js';
 import { TileSetRaster } from './tile.set.raster.js';
@@ -79,33 +79,6 @@ export class TileSetCache {
     this.tileSets.set(tileSetId, ts);
     return ts;
   }
-
-  async getAll(name: string, tileMatrix?: TileMatrixSet | null): Promise<TileSet[]> {
-    const nameComp = TileSetNameParser.parse(name);
-    const tileMatrices = tileMatrix == null ? Array.from(TileMatrixSets.Defaults.values()) : [tileMatrix];
-
-    const promises: Promise<TileSet | null>[] = [];
-    for (const tileMatrix of tileMatrices) promises.push(this.get(name, tileMatrix));
-    const tileMatrixSets = await Promise.all(promises);
-
-    const tileSets: TileSetRaster[] = [];
-    for (const parent of tileMatrixSets) {
-      if (parent == null) continue;
-      if (parent.type === TileSetType.Vector) continue;
-
-      tileSets.push(parent);
-      if (nameComp.layer != null) {
-        parent.components.name = nameComp.name;
-      } else if (parent.imagery != null && parent.imagery.size > 1) {
-        for (const imageId of parent.imagery.keys()) {
-          const childImg = parent.child(imageId);
-          if (childImg == null) continue;
-          tileSets.push(childImg);
-        }
-      }
-    }
-    return tileSets.sort((a, b) => a.title.localeCompare(b.title));
-  }
 }
 
 export const TileSets = new TileSetCache();

package/src/tile.set.raster.ts

@@ -84,7 +84,7 @@ export class TileSetRaster {
 
   async init(record: ConfigTileSetRaster): Promise<void> {
     this.tileSet = record;
-    this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
+    this.imagery = await Config.getAllImagery(this.tileSet.layers, [this.tileMatrix.projection]);
   }
 
   async initTiffs(tile: Tile, log: LogType): Promise<CogTiff[]> {
@@ -213,9 +213,11 @@ export class TileSetRaster {
     child.tileSet = { ...this.tileSet };
     child.tileSet.background = undefined;
     const title = this.tileSet?.title ?? this.tileSet?.name;
-    child.tileSet.title = `${title} ${titleizeImageryName(image.name)}`;
+    child.tileSet.title = image.title ?? `${title} ${titleizeImageryName(image.name)}`;
     child.extentOverride = Bounds.fromJson(image.bounds);
 
+    if (image.category) child.tileSet.category = image.category;
+
     const layer: ConfigLayer = { name: image.name, minZoom: 0, maxZoom: 100 };
     layer[this.tileMatrix.projection.code] = image.id;
 

package/src/tile.set.vector.ts

@@ -1,28 +1,10 @@
 import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
 import { GoogleTms, TileMatrixSet, VectorFormat } from '@basemaps/geo';
-import { fsa, TileDataXyz } from '@basemaps/shared';
-import { Cotar } from '@cotar/core';
+import { TileDataXyz } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { CotarCache } from './cotar.cache.js';
 import { NotFound } from './routes/response.js';
 import { TileSets } from './tile.set.cache.js';
-import { St } from './source.tracer.js';
-
-class CotarCache {
-  cache = new Map<string, Promise<Cotar | null>>();
-
-  get(uri: string): Promise<Cotar | null> {
-    let cotar = this.cache.get(uri);
-    if (cotar == null) {
-      const source = fsa.source(uri);
-      St.trace(source);
-      cotar = Cotar.fromTar(source);
-      this.cache.set(uri, cotar);
-    }
-    return cotar;
-  }
-}
-
-export const Layers = new CotarCache();
 
 export class TileSetVector {
   type: TileSetType.Vector = TileSetType.Vector;
@@ -59,7 +41,7 @@ export class TileSetVector {
     if (layer[3857] == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
 
     req.timer.start('cotar:load');
-    const cotar = await Layers.get(layer[3857]);
+    const cotar = await CotarCache.get(layer[3857]);
     if (cotar == null) return new LambdaHttpResponse(500, 'Failed to load VectorTiles');
     req.timer.end('cotar:load');
 

package/src/wmts.capability.ts

@@ -1,8 +1,9 @@
-import { Bounds, ImageFormat, Nztm2000QuadTms, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
+import { Config, ConfigImagery, ConfigLayer, ConfigTileSet, standardizeLayerName } from '@basemaps/config';
+import { Bounds, GoogleTms, ImageFormat, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
 import { Projection, V, VNodeElement } from '@basemaps/shared';
 import { ImageFormatOrder } from '@basemaps/tiler';
+import { BoundingBox } from '@cogeotiff/core';
 import { BBox, Wgs84 } from '@linzjs/geojson';
-import { TileSetRaster } from './tile.set.raster.js';
 
 const CapabilitiesAttrs = {
   xmlns: 'http://www.opengis.net/wmts/1.0',
@@ -15,65 +16,74 @@ const CapabilitiesAttrs = {
   version: '1.0.0',
 };
 
-function wgs84Extent(layer: TileSetRaster): BBox {
-  return Projection.get(layer.tileMatrix).boundsToWgs84BoundingBox(layer.extent);
-}
-
-/**
- * Default the tile matrix id to the projection of the TileMatrixSet
- */
-export function getTileMatrixId(tileMatrix: TileMatrixSet): string {
-  // TODO this should really change everything to identifier
-  if (tileMatrix.identifier === Nztm2000QuadTms.identifier) return Nztm2000QuadTms.identifier;
-  return tileMatrix.projection.toEpsgString();
+function wgs84Extent(tileMatrix: TileMatrixSet, bbox: BoundingBox): BBox {
+  return Projection.get(tileMatrix).boundsToWgs84BoundingBox(bbox);
 }
 
 export interface WmtsCapabilitiesParams {
+  /** Base URL for tile server */
   httpBase: string;
   provider?: WmtsProvider;
-  layers: TileSetRaster[];
+  /** Tileset to export into WMTS */
+  tileSet: ConfigTileSet;
+  /** List of tile matrixes to output */
+  tileMatrix: TileMatrixSet[];
+  /** Should WMTS Layers be created for each imagery set inside this tileSet */
+  isIndividualLayers: boolean;
+  /** All the imagery used by the tileSet and tileMatrixes */
+  imagery: Map<string, ConfigImagery>;
+  /** API key to append to all resource urls */
   apiKey?: string;
+  /** Limit the output to the following image formats other wise @see ImageFormatOrder */
   formats?: ImageFormat[];
 }
 
 export class WmtsCapabilities {
   httpBase: string;
   provider?: WmtsProvider;
-
-  layers: Map<string, TileSetRaster[]> = new Map();
-
+  tileSet: ConfigTileSet;
   apiKey?: string;
   tileMatrixSets = new Map<string, TileMatrixSet>();
+  imagery: Map<string, ConfigImagery>;
   formats: ImageFormat[];
+  isIndividualLayers = false;
 
   constructor(params: WmtsCapabilitiesParams) {
     this.httpBase = params.httpBase;
     this.provider = params.provider;
+    this.tileSet = params.tileSet;
+    this.isIndividualLayers = params.isIndividualLayers;
+    for (const tms of params.tileMatrix) this.tileMatrixSets.set(tms.identifier, tms);
+    this.apiKey = params.apiKey;
+    this.formats = params.formats ?? ImageFormatOrder;
+    this.imagery = params.imagery;
+  }
 
-    for (const layer of params.layers) {
-      // TODO is grouping by name the best option
-      let existing = this.layers.get(layer.fullName);
-      if (existing == null) {
-        existing = [];
-        this.layers.set(layer.fullName, existing);
+  async loadImagery(): Promise<void> {
+    const ids = new Set<string>();
+    for (const tms of this.tileMatrixSets.values()) {
+      for (const layer of this.tileSet.layers) {
+        const layerId = layer[tms.projection.code];
+        if (layerId != null) ids.add(layerId);
       }
-      // TODO should a error be thrown here if the projection is invalid
-      existing.push(layer);
-
-      this.tileMatrixSets.set(layer.tileMatrix.identifier, layer.tileMatrix);
     }
-    this.apiKey = params.apiKey;
-    this.formats = params.formats ?? ImageFormatOrder;
+    this.imagery = await Config.Imagery.getAll(ids);
   }
 
-  buildWgs84BoundingBox(layers: TileSetRaster[], tagName = 'ows:WGS84BoundingBox'): VNodeElement {
-    let bbox = wgs84Extent(layers[0]);
-    for (let i = 1; i < layers.length; ++i) {
-      bbox = Wgs84.union(bbox, wgs84Extent(layers[i]));
+  buildWgs84BoundingBox(tms: TileMatrixSet, layers: Bounds[]): VNodeElement {
+    let bbox: BBox;
+    if (layers.length > 0) {
+      bbox = wgs84Extent(tms, layers[0]);
+      for (let i = 1; i < layers.length; i++) {
+        bbox = Wgs84.union(bbox, wgs84Extent(tms, layers[i]));
+      }
+    } else {
+      // No layers provided assume extent is the size of the tile matrix set :shrug: ?
+      bbox = wgs84Extent(tms, tms.extent);
     }
 
     return V(
-      tagName,
+      'ows:WGS84BoundingBox',
       { crs: 'urn:ogc:def:crs:OGC:2:84' },
       bbox[2] > 180
         ? [V('ows:LowerCorner', `-180 -90`), V('ows:UpperCorner', `180 90`)]
@@ -81,8 +91,20 @@ export class WmtsCapabilities {
     );
   }
 
-  buildBoundingBox(tms: TileMatrixSet, extent: Bounds): VNodeElement {
-    const bbox = extent.toBbox();
+  /** Combine all the bounds of the imagery inside the layers into a extent for the imagery set */
+  buildBoundingBoxFromImagery(tms: TileMatrixSet, layers: ConfigLayer[]): VNodeElement | null {
+    let bounds;
+    for (const layer of layers) {
+      const imgId = layer[tms.projection.code];
+      if (imgId == null) continue;
+      const img = this.imagery.get(imgId);
+      if (img == null) continue;
+      if (bounds == null) bounds = Bounds.fromJson(img.bounds);
+      else bounds = bounds.union(Bounds.fromJson(img.bounds));
+    }
+    if (bounds == null) return null;
+
+    const bbox = bounds.toBbox();
     return V('ows:BoundingBox', { crs: tms.projection.toUrn() }, [
       V('ows:LowerCorner', `${bbox[tms.indexX]} ${bbox[tms.indexY]}`),
       V('ows:UpperCorner', `${bbox[tms.indexX + 2]} ${bbox[tms.indexY + 2]}`),
@@ -124,13 +146,13 @@ export class WmtsCapabilities {
     ];
   }
 
-  buildTileUrl(tileSet: TileSetRaster, suffix: string): string {
+  buildTileUrl(tileSetId: string, suffix: string): string {
     const apiSuffix = this.apiKey ? `?api=${this.apiKey}` : '';
     return [
       this.httpBase,
       'v1',
       'tiles',
-      tileSet.fullName,
+      tileSetId,
       '{TileMatrixSet}',
       '{TileMatrix}',
       '{TileCol}',
@@ -138,37 +160,91 @@ export class WmtsCapabilities {
     ].join('/');
   }
 
-  buildResourceUrl(tileSet: TileSetRaster, suffix: string): VNodeElement {
+  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
     return V('ResourceURL', {
       format: 'image/' + suffix,
       resourceType: 'tile',
-      template: this.buildTileUrl(tileSet, suffix),
+      template: this.buildTileUrl(tileSetId, suffix),
     });
   }
 
-  buildLayer(layers: TileSetRaster[]): VNodeElement {
-    const matrixSets = new Set<string>();
+  buildLayerFromImagery(layer: ConfigLayer): VNodeElement | null {
+    const matrixSets = new Set<TileMatrixSet>();
     const matrixSetNodes: VNodeElement[] = [];
-    for (const layer of layers) {
-      if (matrixSets.has(layer.tileMatrix.identifier)) continue;
-      matrixSets.add(layer.tileMatrix.identifier);
-      matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', getTileMatrixId(layer.tileMatrix))]));
+    for (const tms of this.tileMatrixSets.values()) {
+      const imdIg = layer[tms.projection.code];
+      if (imdIg == null) continue;
+      const img = this.imagery.get(imdIg);
+      if (img == null) continue;
+      matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', tms.identifier)]));
+      matrixSets.add(tms);
+    }
+
+    const layerNameId = standardizeLayerName(layer.name);
+    const matrixSetList = [...matrixSets.values()];
+    const firstMatrix = matrixSetList[0];
+    if (firstMatrix == null) return null;
+    const firstImg = this.imagery.get(layer[firstMatrix.projection.code] ?? '');
+    if (firstImg == null) return null;
+
+    return V('Layer', [
+      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Abstract', ''),
+      V('ows:Identifier', layerNameId),
+      this.buildKeywords(firstImg),
+      ...matrixSetList.map((tms) => {
+        return this.buildBoundingBoxFromImagery(tms, [layer]);
+      }),
+      this.buildWgs84BoundingBox(firstMatrix, [Bounds.fromJson(firstImg.bounds)]),
+      this.buildStyle(),
+      ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
+      ...matrixSetNodes,
+      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
+    ]);
+  }
+
+  buildLayer(layer: ConfigTileSet): VNodeElement {
+    const matrixSets = new Set<TileMatrixSet>();
+    const matrixSetNodes: VNodeElement[] = [];
+    for (const tms of this.tileMatrixSets.values()) {
+      if (layer.layers.find((f) => f[tms.projection.code] != null)) {
+        matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', tms.identifier)]));
+        matrixSets.add(tms);
+      }
+    }
+    const layerNameId = standardizeLayerName(layer.name);
+    const matrixSetList = [...matrixSets.values()];
+    const firstMatrix = matrixSetList[0];
+    if (firstMatrix == null) throw new Error('No matrix sets found for layer ' + layer.name);
+
+    // Prefer using the web mercator tms for bounds
+    const webMercatorOrFirst = matrixSetList.find((f) => f.identifier === GoogleTms.identifier) ?? firstMatrix;
+    const bounds: Bounds[] = [];
+    for (const l of layer.layers) {
+      const img = this.imagery.get(l[webMercatorOrFirst.projection.code] ?? '');
+      if (img == null) continue;
+      bounds.push(Bounds.fromJson(img.bounds));
     }
 
-    const [firstLayer] = layers;
     return V('Layer', [
-      V('ows:Title', firstLayer.title),
-      V('ows:Abstract', firstLayer.description),
-      V('ows:Identifier', firstLayer.fullName),
-      ...layers.map((layer) => this.buildBoundingBox(layer.tileMatrix, layer.extent)),
-      this.buildWgs84BoundingBox(layers),
+      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Abstract', layer.description ?? ''),
+      V('ows:Identifier', layerNameId),
+      this.buildKeywords(layer),
+      ...[...matrixSets.values()].map((tms) => this.buildBoundingBoxFromImagery(tms, layer.layers)),
+      this.buildWgs84BoundingBox(webMercatorOrFirst, bounds),
       this.buildStyle(),
       ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
       ...matrixSetNodes,
-      ...this.formats.map((fmt) => this.buildResourceUrl(firstLayer, fmt)),
+      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
     ]);
   }
 
+  buildKeywords(tileSet: { category?: string }): VNodeElement {
+    if (tileSet.category == null) return V('ows:Keywords');
+    return V('ows:Keywords', [V('ows:Keyword', tileSet.category)]);
+  }
+
   buildStyle(): VNodeElement {
     return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
   }
@@ -177,7 +253,7 @@ export class WmtsCapabilities {
     return V('TileMatrixSet', [
       V('ows:Title', tms.def.title),
       tms.def.abstract ? V('ows:Abstract', tms.def.abstract) : null,
-      V('ows:Identifier', getTileMatrixId(tms)),
+      V('ows:Identifier', tms.identifier),
       V('ows:SupportedCRS', tms.projection.toUrn()),
       tms.def.wellKnownScaleSet ? V('WellKnownScaleSet', tms.def.wellKnownScaleSet) : null,
       ...tms.def.tileMatrix.map((c) => {
@@ -194,16 +270,25 @@ export class WmtsCapabilities {
     ]);
   }
   toVNode(): VNodeElement {
-    const layers: VNodeElement[] = [];
-    for (const tileSets of this.layers.values()) {
-      layers.push(this.buildLayer(tileSets));
+    const layers: (VNodeElement | null)[] = [];
+    layers.push(this.buildLayer(this.tileSet));
+
+    if (this.isIndividualLayers) {
+      const layerByName = new Map<string, ConfigLayer>();
+      // Dedupe the layers by unique name
+      for (const img of this.tileSet.layers) layerByName.set(standardizeLayerName(img.name), img);
+      const orderedLayers = Array.from(layerByName.values()).sort((a, b) =>
+        (a.title ?? a.name).localeCompare(b.title ?? b.name),
+      );
+      for (const img of orderedLayers) layers.push(this.buildLayerFromImagery(img));
     }
+
     for (const tms of this.tileMatrixSets.values()) layers.push(this.buildTileMatrixSet(tms));
 
     return V('Capabilities', CapabilitiesAttrs, [...this.buildProvider(), V('Contents', layers)]);
   }
 
   toXml(): string {
-    return '<?xml version="1.0"?>\n' + this.toVNode().toString();
+    return '<?xml version="1.0" encoding="utf-8"?>\n' + this.toVNode().toString();
   }
 }