@basemaps/lambda-tiler 6.41.0 → 6.44.0

package/src/cli/render.tile.ts

@@ -1,17 +1,26 @@
 import { ConfigProviderMemory } from '@basemaps/config';
 import { initConfigFromUrls } from '@basemaps/config/build/json/tiff.config.js';
-import { GoogleTms, ImageFormat } from '@basemaps/geo';
+import { ImageFormat, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { LogConfig, setDefaultConfig } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import { LambdaHttpRequest, LambdaUrlRequest, UrlEvent } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
-import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
 import { pathToFileURL } from 'url';
+import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
 
-const target = pathToFileURL(`/home/blacha/tmp/basemaps/white-lines/nz-0.5m/`);
-const tile = { z: 10, x: 1013, y: 633 };
-const tileMatrix = GoogleTms;
-const imageFormat = ImageFormat.Webp;
+const target = pathToFileURL(`/home/blacha/tmp/imagery/southland-0.25-rural-2023/`);
+const tile = fromPath('/18/117833/146174.webp');
+
+const outputFormat = ImageFormat.Webp;
+let tileMatrix: TileMatrixSet | null = null;
+
+/** Convert a tile path /:z/:x/:y.png into a tile */
+function fromPath(s: string): Tile {
+  const parts = s.split('.')[0].split('/').map(Number);
+  if (s.startsWith('/')) parts.shift();
+  if (parts.length !== 3) throw new Error(`Invalid tile path ${s}`);
+  return { z: parts[0], x: parts[1], y: parts[2] };
+}
 
 async function main(): Promise<void> {
   const log = LogConfig.get();
@@ -21,21 +30,28 @@ async function main(): Promise<void> {
 
   if (tileSet.layers.length === 0) throw new Error('No imagery found in path: ' + target);
   log.info({ tileSet: tileSet.name, layers: tileSet.layers.length }, 'TileSet:Loaded');
+
   for (const im of imagery) {
     log.info({ url: im.uri, title: im.title, tileMatrix: im.tileMatrix, files: im.files.length }, 'Imagery:Loaded');
+    if (tileMatrix == null) {
+      tileMatrix = TileMatrixSets.find(im.tileMatrix);
+      log.info({ tileMatrix: im.tileMatrix }, 'Imagery:TileMatrix:Set');
+    }
   }
+
+  if (tileMatrix == null) throw new Error('No tileMatrix found');
   const request = new LambdaUrlRequest({ headers: {} } as UrlEvent, {} as Context, log) as LambdaHttpRequest;
 
-  tileSet.background = { r: 255, g: 255, b: 255, alpha: 1 };
+  tileSet.background = { r: 255, g: 0, b: 255, alpha: 0.25 };
   const res = await TileXyzRaster.tile(request, tileSet, {
     tile,
     tileMatrix,
     tileSet: tileSet.id,
-    tileType: imageFormat,
+    tileType: outputFormat,
   });
 
-  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.${imageFormat}`, Buffer.from(res.body, 'base64'));
-  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.${imageFormat}` }, 'Tile:Write');
+  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.${outputFormat}`, Buffer.from(res.body, 'base64'));
+  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.${outputFormat}` }, 'Tile:Write');
 }
 
 main();

package/src/index.ts

@@ -18,6 +18,8 @@ import { versionGet } from './routes/version.js';
 import { NotFound, OkResponse } from './util/response.js';
 import { CoSources } from './util/source.cache.js';
 import { St } from './util/source.tracer.js';
+import { tilePreviewGet } from './routes/preview.js';
+import { previewIndexGet } from './routes/preview.index.js';
 
 export const handler = lf.http(LogConfig.get());
 
@@ -93,6 +95,11 @@ handler.router.get('/v1/tiles/:tileSet/:tileMatrix/tile.json', tileJsonGet);
 // Tiles
 handler.router.get('/v1/tiles/:tileSet/:tileMatrix/:z/:x/:y.:tileType', tileXyzGet);
 
+// Preview
+handler.router.get('/v1/preview/:tileSet/:tileMatrix/:z/:lon/:lat', tilePreviewGet);
+handler.router.get('/v1/@:location', previewIndexGet);
+handler.router.get('/@:location', previewIndexGet);
+
 // Attribution
 handler.router.get('/v1/tiles/:tileSet/:tileMatrix/attribution.json', tileAttributionGet);
 handler.router.get('/v1/attribution/:tileSet/:tileMatrix/summary.json', tileAttributionGet);

package/src/routes/__tests__/preview.index.test.ts

@@ -0,0 +1,94 @@
+import { Env, LogConfig, V, fsa } from '@basemaps/shared';
+import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ALBEvent, Context } from 'aws-lambda';
+import o from 'ospec';
+
+import { loadAndServeIndexHtml } from '../preview.index.js';
+import { LocationUrl } from '@basemaps/geo';
+import { FsMemory } from '@chunkd/source-memory';
+
+o.spec('/@*', async () => {
+  o.specTimeout(1000);
+  const baseRequest: ALBEvent = {
+    requestContext: null as any,
+    httpMethod: 'get',
+    path: '/@-41.8900012,174.0492432,z5',
+    body: null,
+    isBase64Encoded: false,
+  };
+
+  const fsMem = new FsMemory();
+  let lastLocation: string | undefined;
+  o.beforeEach(() => {
+    fsa.register('memory://', fsMem);
+    lastLocation = process.env[Env.StaticAssetLocation];
+  });
+  o.afterEach(() => {
+    if (lastLocation == null) delete process.env[Env.StaticAssetLocation];
+    else process.env[Env.StaticAssetLocation] = lastLocation;
+  });
+
+  o('Should redirect on failure to load', async () => {
+    const ctx: LambdaHttpRequest = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
+
+    const res = await loadAndServeIndexHtml(ctx);
+    o(res.status).equals(302);
+    o(res.header('location')).equals('/?');
+  });
+
+  o('Should redirect with querystring on failure to load', async () => {
+    const evt: ALBEvent = { ...baseRequest, queryStringParameters: { config: 'config-latest.json' } };
+    const ctx: LambdaHttpRequest = new LambdaAlbRequest(evt, {} as Context, LogConfig.get());
+
+    const res = await loadAndServeIndexHtml(ctx);
+    o(res.status).equals(302);
+    o(res.header('location')).equals('/?config=config-latest.json');
+  });
+
+  o('Should redirect with querystring and location on failure to load', async () => {
+    const evt: ALBEvent = { ...baseRequest, queryStringParameters: { config: 'config-latest.json' } };
+    const loc = LocationUrl.fromSlug(evt.path);
+    const ctx: LambdaHttpRequest = new LambdaAlbRequest(evt, {} as Context, LogConfig.get());
+
+    const res = await loadAndServeIndexHtml(ctx, loc);
+    o(res.status).equals(302);
+    o(res.header('location')).equals('/?config=config-latest.json#@-41.8900012,174.0492432,z5');
+  });
+
+  o('should redirect on failure to load index.html', async () => {
+    const ctx: LambdaHttpRequest = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
+    process.env[Env.StaticAssetLocation] = 'memory://assets/';
+
+    const res = await loadAndServeIndexHtml(ctx);
+    o(res.status).equals(302);
+  });
+
+  o('should redirect with new tags!', async () => {
+    const ctx = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
+    process.env[Env.StaticAssetLocation] = 'memory://assets/';
+
+    const indexHtml = V('html', [
+      V('head', [
+        V('meta', { property: 'og:title', content: 'LINZ Basemaps' }),
+        V('meta', { property: 'og:image', content: '/basemaps-card.jepg' }),
+        V('meta', { name: 'viewport' }),
+      ]),
+    ]).toString();
+
+    await fsa.write('memory://assets/index.html', indexHtml);
+
+    // Pass back the body un altered
+    const res = await loadAndServeIndexHtml(ctx);
+    o(getBody(res)?.toString()).equals(indexHtml);
+
+    // Replace og:title with a <fake tag />
+    const resB = await loadAndServeIndexHtml(ctx, null, new Map([['og:title', '<fake tag />']]));
+    o(getBody(resB)?.toString().includes('<fake tag />')).equals(true);
+  });
+});
+
+function getBody(res: LambdaHttpResponse): Buffer | null {
+  if (res._body == null) return null;
+  if (res.isBase64Encoded) return Buffer.from(res._body as string, 'base64');
+  return Buffer.from(res._body as string);
+}

package/src/routes/attribution.ts

@@ -125,8 +125,7 @@ async function tileSetAttribution(
 
     items.push(item);
 
-    const minZoom = layer.disabled ? 32 : layer.minZoom;
-    const zoomMin = TileMatrixSet.convertZoomLevel(minZoom ? minZoom : 0, GoogleTms, tileMatrix, true);
+    const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);
     const zoomMax = TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true);
     cols.push({
       stac_version: Stac.Version,
@@ -141,7 +140,6 @@ async function tileSetAttribution(
         'linz:category': im.category,
         'linz:zoom': { min: zoomMin, max: zoomMax },
         'linz:priority': [1000 + tileSet.layers.indexOf(layer)],
-        'linz:disabled': layer.disabled ? true : false,
       },
     });
   }

package/src/routes/preview.index.ts

@@ -0,0 +1,119 @@
+import { GoogleTms, LocationUrl, LonLatZoom, TileMatrixSets } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
+import { Env, fsa } from '@basemaps/shared';
+import { isGzip } from '../util/cotar.serve.js';
+import { gunzip } from 'node:zlib';
+import { promisify } from 'node:util';
+import { Etag } from '../util/etag.js';
+
+const gunzipP = promisify(gunzip);
+
+export interface PreviewIndexGet {
+  Params: {
+    location: string;
+  };
+  Query: {
+    config?: string;
+    style?: string;
+    tileMatrix?: string;
+  };
+}
+
+/**
+ * Load the `index.html` from the static bucket and replace `<meta />` tags with the preview open graph tags
+ *
+ * @param loc location of the request if valid
+ * @param tags tags to replace if they exist
+ *
+ * @returns response containing the output HTML
+ */
+export async function loadAndServeIndexHtml(
+  req: LambdaHttpRequest,
+  loc?: LonLatZoom | null,
+  tags?: Map<string, string>,
+): Promise<LambdaHttpResponse> {
+  const locUrl = loc ? `#` + LocationUrl.toSlug(loc) : '';
+  // If the static location is given to us replace
+  const staticLocation = Env.get(Env.StaticAssetLocation);
+  // No static assets defined, just redirect back to the main page
+  if (staticLocation == null) {
+    return new LambdaHttpResponse(302, 'Invalid index.html', {
+      location: '/?' + req.query.toString() + locUrl,
+    });
+  }
+
+  try {
+    let indexHtml = await fsa.read(fsa.join(staticLocation, 'index.html'));
+    if (isGzip(indexHtml)) indexHtml = await gunzipP(indexHtml);
+
+    const res = new LambdaHttpResponse(200, 'ok');
+    // These index.html documents are refreshed frequently so only let them be cached for short durations
+    res.header(HttpHeader.CacheControl, 'public, max-age=30, stale-while-revalidate=60');
+
+    if (tags == null) {
+      res.header(HttpHeader.ETag, Etag.key(indexHtml));
+      res.buffer(indexHtml, `text/html; charset=utf-8`);
+      return res;
+    }
+
+    // Replace open graph tags
+    const output = String(indexHtml)
+      .split('\n')
+      .map((f) => {
+        for (const [key, value] of tags.entries()) {
+          if (f.includes(key)) return value;
+        }
+        return f;
+      });
+
+    const outHtml = output.join('\n');
+    res.header(HttpHeader.ETag, Etag.key(outHtml));
+    res.buffer(outHtml, `text/html; charset=utf-8`);
+    return res;
+  } catch (e) {
+    req.log.fatal({ e }, 'Index:Failed');
+    // If we fail to read transform the index, just redirect the user to the actual index.html
+    return new LambdaHttpResponse(302, 'Failed to render index.html', {
+      location: '/?' + req.query.toString() + locUrl,
+    });
+  }
+}
+
+export async function previewIndexGet(req: LambdaHttpRequest<PreviewIndexGet>): Promise<LambdaHttpResponse> {
+  const config = await ConfigLoader.load(req);
+  const loc = LocationUrl.fromSlug(req.params.location);
+  if (loc == null) return loadAndServeIndexHtml(req);
+
+  const query = LocationUrl.parseQuery(req.query);
+
+  req.timer.start('tileset:load');
+  const tileSet = await config.TileSet.get(config.TileSet.id(query.style));
+  req.timer.end('tileset:load');
+  if (tileSet == null) return loadAndServeIndexHtml(req, loc);
+  if (tileSet.type !== 'raster') return loadAndServeIndexHtml(req, loc);
+
+  let tileMatrix = TileMatrixSets.find(query.tileMatrix);
+  if (tileMatrix == null) tileMatrix = GoogleTms;
+
+  const short = LocationUrl.truncateLatLon(loc);
+  const shortLocation = [short.zoom, short.lon, short.lat].join('/');
+
+  // Include tile matrix name eg "[NZTM2000Quad]" in the title if its not WebMercatorQuad
+  const tileMatrixId = tileMatrix.identifier === GoogleTms.identifier ? '' : ` [${tileMatrix.identifier}]`;
+  // List of tags to replace in the index.html
+  const ogTags = new Map([
+    ['og:title', `<meta name="twitter:title" property="og:title" content="LINZ Basemaps">`],
+    // TODO attribution could be used to get exactly what imagery is being looked at.
+    [
+      'og:description',
+      `<meta name="twitter:description" property="og:description" content="${tileSet.title}${tileMatrixId}" />`,
+    ],
+    [
+      'og:image',
+      `<meta name="twitter:image" property="og:image" content="/v1/preview/${tileSet.name}/${tileMatrix.identifier}/${shortLocation}" />`,
+    ],
+  ]);
+
+  return loadAndServeIndexHtml(req, loc, ogTags);
+}

package/src/routes/preview.ts

@@ -0,0 +1,234 @@
+import { ConfigTileSetRaster } from '@basemaps/config';
+import { Bounds, ImageFormat, LatLon, Projection, TileMatrixSet } from '@basemaps/geo';
+import { CompositionTiff, Tiler } from '@basemaps/tiler';
+import { SharpOverlay, TileMakerSharp } from '@basemaps/tiler-sharp';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { ConfigLoader } from '../util/config.loader.js';
+import { Etag } from '../util/etag.js';
+import { NotModified } from '../util/response.js';
+import { Validate } from '../util/validate.js';
+import { DefaultResizeKernel, TileXyzRaster, isArchiveTiff } from './tile.xyz.raster.js';
+import sharp from 'sharp';
+
+export interface PreviewGet {
+  Params: {
+    tileSet: string;
+    tileMatrix: string;
+    lat: string;
+    lon: string;
+    z: string;
+  };
+}
+
+const PreviewSize = { width: 1200, height: 630 };
+const TilerSharp = new TileMakerSharp(PreviewSize.width, PreviewSize.height);
+
+const OutputFormat = ImageFormat.Webp;
+/** Slightly grey color for the checker background */
+const PreviewBackgroundFillColor = 0xef;
+/** Make th e checkered background 30x30px */
+const PreviewBackgroundSizePx = 30;
+
+/**
+ * Serve a preview of a imagery set
+ *
+ * /v1/preview/:tileSet/:tileMatrixSet/:z/:lon/:lat
+ *
+ * @example
+ * Raster Tile `/v1/preview/aerial/WebMercatorQuad/12/177.3998405/-39.0852555`
+ *
+ */
+export async function tilePreviewGet(req: LambdaHttpRequest<PreviewGet>): Promise<LambdaHttpResponse> {
+  const tileMatrix = Validate.getTileMatrixSet(req.params.tileMatrix);
+  if (tileMatrix == null) return new LambdaHttpResponse(404, 'Tile Matrix not found');
+
+  req.set('tileMatrix', tileMatrix.identifier);
+  req.set('projection', tileMatrix.projection.code);
+
+  // TODO we should detect the format based off the "Accept" header and maybe default back to webp
+  req.set('extension', OutputFormat);
+
+  const location = Validate.getLocation(req.params.lon, req.params.lat);
+  if (location == null) return new LambdaHttpResponse(404, 'Preview location not found');
+  req.set('location', location);
+
+  const z = Math.ceil(parseFloat(req.params.z));
+  if (isNaN(z) || z < 0 || z > tileMatrix.maxZoom) return new LambdaHttpResponse(404, 'Preview zoom invalid');
+
+  const config = await ConfigLoader.load(req);
+
+  req.timer.start('tileset:load');
+  const tileSet = await config.TileSet.get(config.TileSet.id(req.params.tileSet));
+  req.timer.end('tileset:load');
+  if (tileSet == null) return new LambdaHttpResponse(404, 'Tileset not found');
+  // Only raster previews are supported
+  if (tileSet.type !== 'raster') return new LambdaHttpResponse(404, 'Preview invalid tile set type');
+
+  return renderPreview(req, { tileSet, tileMatrix, location, outputFormat: OutputFormat, z });
+}
+
+interface PreviewRenderContext {
+  /** Imagery to use */
+  tileSet: ConfigTileSetRaster;
+  /** output tilematrix to use */
+  tileMatrix: TileMatrixSet;
+  /** Center point of the preview */
+  location: LatLon;
+  /** Iamge format to render the preview as */
+  outputFormat: ImageFormat;
+  /** Zom level to be use, must be a integer */
+  z: number;
+}
+/**
+ * Render the preview!
+ *
+ * All the parameter validation is done in {@link tilePreviewGet} this function expects everything to align
+ *
+ * @returns 304 not modified if the ETag matches or 200 ok with the content of the image
+ */
+export async function renderPreview(req: LambdaHttpRequest, ctx: PreviewRenderContext): Promise<LambdaHttpResponse> {
+  const tileMatrix = ctx.tileMatrix;
+  // Convert the input lat/lon into the projected coordinates to make it easier to do math with
+  const coords = Projection.get(tileMatrix).fromWgs84([ctx.location.lon, ctx.location.lat]);
+
+  // use the input as the center point, but round it to the closest pixel to make it easier to do math
+  const point = tileMatrix.sourceToPixels(coords[0], coords[1], ctx.z);
+  const pointCenter = { x: Math.round(point.x), y: Math.round(point.y) };
+
+  // position of the preview in relation to the output screen
+  const screenBounds = new Bounds(
+    pointCenter.x - PreviewSize.width / 2,
+    pointCenter.y - PreviewSize.height / 2,
+    PreviewSize.width,
+    PreviewSize.height,
+  );
+
+  // Convert the screen bounds back into the source to find the assets we need to render the preview
+  const topLeft = tileMatrix.pixelsToSource(screenBounds.x, screenBounds.y, ctx.z);
+  const bottomRight = tileMatrix.pixelsToSource(screenBounds.right, screenBounds.bottom, ctx.z);
+  const sourceBounds = Bounds.fromBbox([topLeft.x, topLeft.y, bottomRight.x, bottomRight.y]);
+
+  const assetLocations = await TileXyzRaster.getAssetsForBounds(
+    req,
+    ctx.tileSet,
+    tileMatrix,
+    sourceBounds,
+    ctx.z,
+    true,
+  );
+
+  const cacheKey = Etag.key(assetLocations);
+  if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+  const assets = await TileXyzRaster.loadAssets(req, assetLocations);
+  const tiler = new Tiler(tileMatrix);
+
+  // Figure out what tiffs and tiles need to be read and where they are placed on the output image
+  const compositions: CompositionTiff[] = [];
+  for (const asset of assets) {
+    // there shouldn't be any Cotar archives in previews but ignore them to be safe
+    if (!isArchiveTiff(asset)) continue;
+    const result = tiler.getTiles(asset, screenBounds, ctx.z);
+    if (result == null) continue;
+    compositions.push(...result);
+  }
+
+  // Load all the tiff tiles and resize/them into the correct locations
+  req.timer.start('compose:overlay');
+  const overlays = (await Promise.all(
+    compositions.map((comp) => TilerSharp.composeTileTiff(comp, DefaultResizeKernel)),
+  ).then((items) => items.filter((f) => f != null))) as SharpOverlay[];
+  req.timer.end('compose:overlay');
+
+  // Create the output image and render all the individual pieces into them
+  const img = getBaseImage(ctx.tileSet.background);
+  img.composite(overlays);
+
+  req.timer.start('compose:compress');
+  const buf = await TilerSharp.toImage(ctx.outputFormat, img);
+  req.timer.end('compose:compress');
+
+  req.set('layersUsed', overlays.length);
+  req.set('bytes', buf.byteLength);
+  const response = new LambdaHttpResponse(200, 'ok');
+  response.header(HttpHeader.ETag, cacheKey);
+  response.header(HttpHeader.CacheControl, 'public, max-age=604800, stale-while-revalidate=86400');
+  response.buffer(buf, 'image/' + ctx.outputFormat);
+
+  const shortLocation = [ctx.location.lon.toFixed(7), ctx.location.lat.toFixed(7)].join('_');
+  const suggestedFileName = `preview_${ctx.tileSet.name}_z${ctx.z}_${shortLocation}.${ctx.outputFormat}`;
+  response.header('Content-Disposition', `inline; filename=\"${suggestedFileName}\"`);
+
+  return response;
+}
+
+function getBaseImage(bg?: { r: number; g: number; b: number; alpha: number }): sharp.Sharp {
+  if (bg == null || bg.alpha === 0) {
+    const buf = createCheckerBoard({
+      width: PreviewSize.width,
+      height: PreviewSize.height,
+      colors: { fill: PreviewBackgroundFillColor, background: 0xff },
+      size: PreviewBackgroundSizePx,
+    });
+    return sharp(buf.buffer, { raw: buf.raw });
+  }
+  return TilerSharp.createImage(bg);
+}
+
+export interface CheckerBoard {
+  /** Output image width in pixels */
+  width: number;
+  /** Output image height in pixels */
+  height: number;
+  colors: {
+    /** Color of the checker board eg 0xef */
+    fill: number;
+    /** Color of the background eg 0xff */
+    background: number;
+  };
+  /** Size of the checkers */
+  size: number;
+}
+
+/** Create a chess/checkerboard background alternating between two colors */
+function createCheckerBoard(ctx: CheckerBoard): {
+  buffer: Buffer;
+  raw: { width: number; height: number; channels: 1 };
+} {
+  const { width, height, size } = ctx;
+  const fillColor = ctx.colors.fill;
+  // Create a one band image, which starts off as full white
+  const buf = Buffer.alloc(height * width, ctx.colors.background); // 1 band grey buffer;
+
+  // Number of squares to make in x/y directions
+  const tileY = height / size;
+  const tileX = width / size;
+
+  // Fill in a square at the x/y pixel offsets
+  function fillSquare(xOffset: number, yOffset: number): void {
+    for (let y = 0; y < size; y++) {
+      const yPx = (yOffset + y) * width;
+      for (let x = 0; x < size; x++) {
+        const px = yPx + xOffset + x;
+        // Actually set the color
+        buf[px] = fillColor;
+      }
+    }
+  }
+  for (let tX = 0; tX < tileX; tX++) {
+    for (let tY = 0; tY < tileY; tY++) {
+      const yOffset = tY * size;
+      const y2 = tY % 2;
+
+      // Draw every second tile alternating on rows
+      const x2 = tX % 2;
+      if (x2 === 0 && y2 === 1) continue;
+      if (x2 === 1 && y2 === 0) continue;
+
+      const xOffset = tX * size;
+      fillSquare(xOffset, yOffset);
+    }
+  }
+
+  return { buffer: buf, raw: { width, height, channels: 1 } };
+}

package/src/routes/tile.xyz.raster.ts

@@ -24,47 +24,62 @@ export function getTiffName(name: string): string {
 
 export type CloudArchive = CogTiff | Cotar;
 
+/** Check to see if a cloud archive is a Tiff or a Cotar */
+export function isArchiveTiff(x: CloudArchive): x is CogTiff {
+  if (x instanceof CogTiff) return true;
+  if (x.source.uri.endsWith('.tiff')) return true;
+  if (x.source.uri.endsWith('.tif')) return true;
+  return false;
+}
+
 export const TileComposer = new TileMakerSharp(256);
 
-const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' } as const;
-const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
+export const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' } as const;
+export const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
 
 export const TileXyzRaster = {
-  async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
+  async getAssetsForBounds(
+    req: LambdaHttpRequest,
+    tileSet: ConfigTileSetRaster,
+    tileMatrix: TileMatrixSet,
+    bounds: Bounds,
+    zoom: number,
+    ignoreOverview = false,
+  ): Promise<string[]> {
     const config = await ConfigLoader.load(req);
-    const imagery = await getAllImagery(config, tileSet.layers, [xyz.tileMatrix.projection]);
+    const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
     const filteredLayers = filterLayers(req, tileSet.layers);
 
     const output: string[] = [];
-    const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);
 
     // All zoom level config is stored as Google zoom levels
-    const filterZoom = TileMatrixSet.convertZoomLevel(xyz.tile.z, xyz.tileMatrix, TileMatrixSets.get(Epsg.Google));
+    const filterZoom = TileMatrixSet.convertZoomLevel(zoom, tileMatrix, TileMatrixSets.get(Epsg.Google));
     for (const layer of filteredLayers) {
-      if (layer.disabled) continue;
       if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
       if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
 
-      const imgId = layer[xyz.tileMatrix.projection.code];
-      if (imgId == null) {
-        req.log.warn({ layer: layer.name, projection: xyz.tileMatrix.projection.code }, 'Failed to lookup imagery');
-        continue;
-      }
+      const imgId = layer[tileMatrix.projection.code];
+      // Imagery does not exist for this projection
+      if (imgId == null) continue;
 
       const img = imagery.get(imgId);
       if (img == null) {
-        req.log.warn(
-          { layer: layer.name, projection: xyz.tileMatrix.projection.code, imgId },
-          'Failed to lookup imagery',
-        );
+        req.log.warn({ layer: layer.name, projection: tileMatrix.projection.code, imgId }, 'Failed to lookup imagery');
         continue;
       }
-      if (!tileBounds.intersects(Bounds.fromJson(img.bounds))) continue;
+      if (!bounds.intersects(Bounds.fromJson(img.bounds))) continue;
 
       for (const c of img.files) {
-        if (!tileBounds.intersects(Bounds.fromJson(c))) continue;
-
-        if (img.overviews && img.overviews.maxZoom >= filterZoom && img.overviews.minZoom <= filterZoom) {
+        if (!bounds.intersects(Bounds.fromJson(c))) continue;
+
+        // If there are overviews and they exist for this zoom range and we are not ignoring them
+        // lets use the overviews instead!
+        if (
+          img.overviews &&
+          img.overviews.maxZoom >= filterZoom &&
+          img.overviews.minZoom <= filterZoom &&
+          ignoreOverview !== true
+        ) {
           output.push(fsa.join(img.uri, img.overviews.path));
           break;
         }
@@ -76,15 +91,9 @@ export const TileXyzRaster = {
     return output;
   },
 
-  async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<LambdaHttpResponse> {
-    if (xyz.tileType === VectorFormat.MapboxVectorTiles) return NotFound();
-
-    const assetPaths = await this.getAssetsForTile(req, tileSet, xyz);
-    const cacheKey = Etag.key(assetPaths);
-    if (Etag.isNotModified(req, cacheKey)) return NotModified();
-
+  async loadAssets(req: LambdaHttpRequest, assets: string[]): Promise<CloudArchive[]> {
     const toLoad: Promise<CloudArchive | null>[] = [];
-    for (const assetPath of assetPaths) {
+    for (const assetPath of assets) {
       toLoad.push(
         LoadingQueue((): Promise<CloudArchive | null> => {
           if (assetPath.endsWith('.tar.co')) {
@@ -101,7 +110,22 @@ export const TileXyzRaster = {
       );
     }
 
-    const assets = (await Promise.all(toLoad)).filter((f) => f != null) as CloudArchive[];
+    return (await Promise.all(toLoad)).filter((f) => f != null) as CloudArchive[];
+  },
+
+  async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
+    const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);
+    return TileXyzRaster.getAssetsForBounds(req, tileSet, xyz.tileMatrix, tileBounds, xyz.tile.z);
+  },
+
+  async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<LambdaHttpResponse> {
+    if (xyz.tileType === VectorFormat.MapboxVectorTiles) return NotFound();
+
+    const assetPaths = await this.getAssetsForTile(req, tileSet, xyz);
+    const cacheKey = Etag.key(assetPaths);
+    if (Etag.isNotModified(req, cacheKey)) return NotModified();
+
+    const assets = await TileXyzRaster.loadAssets(req, assetPaths);
 
     const tiler = new Tiler(xyz.tileMatrix);
     const layers = await tiler.tile(assets, xyz.tile.x, xyz.tile.y, xyz.tile.z);