Files
gods-eye-view/src/layers/weather/rasterTiles.test.mjs
T
Sameh Khamis e18353f769 feat(weather): a host can supply decoded frames to the weather layers
A weather feed may also be a frame source. With an optional
getFrameImage({ product, time, size, bbox, signal }) the layers take
whole-extent images, detail windows and the global mosaic from it; with an
optional getFrameTile({ product, time, z, x, y, size, signal }) regional
tiles and their prefetch come from it, null being a transparent tile. Pixels
may be an ImageBitmap, ImageData, canvas or VideoFrame of exactly the
requested size; the layer draws them once and closes them. Cancellation
reaches the source, and a feed without these methods reads the image and
tile routes as before.
2026-11-10 21:54:08 -08:00

318 lines
10 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
createRasterTileProvider,
createFrameTileProvider,
} from './rasterTiles.js';
import { createFieldRaster } from '../wind/fields.js';
// A small canvas double exposes the uploaded raster and exact drawImage crop.
// Verify crop coordinates and source-cell selection independently of canvas smoothing.
function createCanvas() {
const canvas = { width: 0, height: 0 };
const context = {
createImageData: (width, height) => ({
data: new Uint8ClampedArray(width * height * 4),
}),
putImageData(pixels) {
canvas.rgba = pixels.data;
},
drawImage(source, ...args) {
canvas.source = source;
canvas.crop = args;
},
getImageData(x, y) {
const [sx, sy, sw, sh, dx, dy, dw, dh] = canvas.crop;
const col = Math.floor(sx + ((x - dx + 0.5) * sw) / dw);
const row = Math.floor(sy + ((y - dy + 0.5) * sh) / dh);
const offset = (row * canvas.source.width + col) * 4;
return { data: canvas.source.rgba.slice(offset, offset + 4) };
},
};
canvas.getContext = () => context;
return canvas;
}
test('real Cesium geographic provider crops level 0/1 tiles from a decoded canvas with preserved pixels', async () => {
const raster = createFieldRaster(
{
nx: 8,
ny: 3,
lo1: -180,
la1: 90,
dx: 45,
dy: 90,
u: Float32Array.from([
0, 0, 10, 10, 20, 20, 30, 30, 0, 0, 10, 10, 20, 20, 30, 30, 30, 30, 20,
20, 10, 10, 0, 0,
]),
v: new Float32Array(24),
},
'speed',
720,
362,
);
const credit = new Cesium.Credit('NOAA GFS');
const texture = {
width: raster.width,
height: raster.height,
rgba: raster.rgba,
};
const provider = createRasterTileProvider({
cesium: Cesium,
texture,
credit,
createCanvas,
});
assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme);
assert.equal(provider.rectangle, Cesium.Rectangle.MAX_VALUE);
assert.equal(provider.minimumLevel, 0);
assert.equal(provider.maximumLevel, 2);
assert.equal(provider.tileWidth, 256);
assert.equal(provider.tileHeight, 256);
assert.equal(provider.ready, true);
assert.equal(provider.hasAlphaChannel, true);
assert.equal(provider.credit, credit);
assert.ok(provider.errorEvent instanceof Cesium.Event);
assert.equal(provider.tileDiscardPolicy, undefined);
assert.equal(provider.getTileCredits(0, 0, 0), undefined);
assert.equal(provider.pickFeatures(0, 0, 0, 0, 0), undefined);
for (const [x, y, level, crop, cell] of [
[0, 0, 0, [0, 0, 360, 362, 0, 0, 256, 256], [90, 91]],
[1, 0, 0, [360, 0, 360, 362, 0, 0, 256, 256], [450, 91]],
[0, 0, 1, [0, 0, 180, 181, 0, 0, 256, 256], [45, 45]],
[3, 1, 1, [540, 181, 180, 181, 0, 0, 256, 256], [585, 226]],
]) {
const pending = provider.requestImage(x, y, level);
assert.ok(pending instanceof Promise, 'ImageryLayer consumes a promise');
const tile = await pending;
assert.equal(tile.width, 256);
assert.equal(tile.height, 256);
assert.equal(tile.getContext('2d').imageSmoothingEnabled, true);
assert.deepEqual(tile.crop, crop);
const offset = (cell[1] * 720 + cell[0]) * 4;
assert.deepEqual(
tile.getContext('2d').getImageData(64, 64).data,
raster.rgba.slice(offset, offset + 4),
);
}
});
test('bounded decoded mosaic crops both roots and higher levels without resampling its extent', async () => {
const texture = { width: 2048, height: 1024 };
const rectangle = Cesium.Rectangle.fromDegrees(-180, -60, 180, 60);
const scheme = new Cesium.GeographicTilingScheme({
rectangle,
numberOfLevelZeroTilesX: 2,
numberOfLevelZeroTilesY: 1,
});
const credit = new Cesium.Credit('NOAA');
const provider = createRasterTileProvider({
cesium: Cesium,
texture,
rectangle,
tilingScheme: scheme,
maximumLevel: 3,
credit,
createCanvas,
});
assert.equal(provider.rectangle, rectangle);
assert.equal(provider.maximumLevel, 3);
assert.equal(provider.credit, credit);
assert.equal(provider.hasAlphaChannel, true);
for (const [x, y, level, crop] of [
[0, 0, 0, [0, 0, 1024, 1024, 0, 0, 256, 256]],
[1, 0, 0, [1024, 0, 1024, 1024, 0, 0, 256, 256]],
[7, 3, 2, [1792, 768, 256, 256, 0, 0, 256, 256]],
]) {
const pending = provider.requestImage(x, y, level);
assert.ok(pending instanceof Promise);
const tile = await pending;
assert.equal(tile.source, texture);
assert.deepEqual(tile.crop, crop);
}
});
test('512-pixel crops preserve source extent at root and clamped draping levels', async () => {
const texture = { width: 2048, height: 1024 };
const provider = createRasterTileProvider({
cesium: Cesium,
texture,
createCanvas,
tileSize: 512,
maximumLevel: 3,
});
assert.equal(provider.tileWidth, 512);
assert.equal(provider.tileHeight, 512);
for (const [x, y, level, crop] of [
[0, 0, 0, [0, 0, 1024, 1024, 0, 0, 512, 512]],
[3, 1, 1, [1536, 512, 512, 512, 0, 0, 512, 512]],
[7, 3, 2, [1792, 768, 256, 256, 0, 0, 512, 512]],
]) {
const tile = await provider.requestImage(x, y, level);
assert.equal(tile.width, 512);
assert.equal(tile.height, 512);
assert.equal(tile.source, texture);
assert.deepEqual(tile.crop, crop);
}
});
const time = '2026-09-15T20:00:00.000Z';
function tileCanvas() {
const canvas = { width: 0, height: 0, drawn: [] };
canvas.getContext = () => ({
drawImage: (source, ...args) => canvas.drawn.push([source, ...args]),
putImageData: (source, ...args) => canvas.drawn.push([source, ...args]),
});
return canvas;
}
const tilePixels = (size = 256) => ({
width: size,
height: size,
closes: 0,
close() {
this.closes++;
},
});
const deferredTile = () => {
let resolve, reject;
const promise = new Promise((yes, no) => {
resolve = yes;
reject = no;
});
return { promise, resolve, reject };
};
function frameProvider(getTile, options = {}) {
return createFrameTileProvider({
cesium: Cesium,
frameSource: { getTile },
product: 'radar',
time,
tilingScheme: new Cesium.GeographicTilingScheme(),
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
maximumLevel: 6,
credit: new Cesium.Credit('NOAA'),
createCanvas: tileCanvas,
...options,
});
}
test('a frame tile provider draws each supplied tile into its own canvas and releases it', async () => {
const requests = [];
const supplied = tilePixels();
const provider = frameProvider(async (request) => {
requests.push(request);
return supplied;
});
assert.equal(provider.tileWidth, 256);
assert.equal(provider.maximumLevel, 6);
assert.equal(provider.hasAlphaChannel, true);
const tile = await provider.requestImage(3, 1, 2);
assert.equal(tile.width, 256);
assert.equal(tile.height, 256);
assert.deepEqual(tile.drawn, [[supplied, 0, 0]]);
assert.equal(supplied.closes, 1);
assert.equal(requests.length, 1);
const { signal, ...rest } = requests[0];
assert.deepEqual(rest, {
product: 'radar',
time,
z: 2,
x: 3,
y: 1,
size: 256,
});
assert.ok(signal instanceof AbortSignal);
});
test('a null tile is one shared transparent canvas', async () => {
const provider = frameProvider(async () => null);
const first = await provider.requestImage(0, 0, 0);
const second = await provider.requestImage(1, 0, 0);
assert.equal(first, second);
assert.equal(first.width, 256);
assert.deepEqual(first.drawn, [], 'nothing is drawn on it');
});
test('beyond the concurrency limit a tile is deferred to Cesium', async () => {
const gates = [];
const provider = frameProvider(
() => {
const gate = deferredTile();
gates.push(gate);
return gate.promise;
},
{ maxConcurrent: 2 },
);
const first = provider.requestImage(0, 0, 1);
const second = provider.requestImage(1, 0, 1);
assert.equal(provider.requestImage(2, 0, 1), undefined);
gates[0].resolve(null);
await first;
const third = provider.requestImage(2, 0, 1);
assert.ok(third instanceof Promise, 'a finished tile frees its slot');
gates[1].resolve(null);
gates[2].resolve(null);
await Promise.all([second, third]);
});
test('a failed tile rejects, which Cesium reports through errorEvent', async () => {
const provider = frameProvider(async () => {
throw new Error('frame unavailable');
});
await assert.rejects(provider.requestImage(0, 0, 0), /frame unavailable/);
const wrong = tilePixels(512);
const sized = frameProvider(async () => wrong);
await assert.rejects(
sized.requestImage(0, 0, 0),
/Invalid weather tile dimensions/,
);
assert.equal(wrong.closes, 1, 'a refused tile is still released');
const layer = new Cesium.ImageryLayer(provider);
const reported = [];
provider.errorEvent.addEventListener((error) => {
reported.push(error);
error.retry = false;
});
const imagery = { x: 0, y: 0, level: 0, request: undefined };
layer._requestImagery(imagery);
await new Promise((resolve) => setTimeout(resolve, 0));
assert.equal(reported.length, 1);
assert.match(reported[0].error.message, /frame unavailable/);
assert.equal(imagery.state, Cesium.ImageryState.FAILED);
layer.destroy();
});
test('aborting the provider signal cancels tiles in flight and releases late pixels', async () => {
const controller = new AbortController();
const gate = deferredTile();
let seen;
const provider = frameProvider(
({ signal }) => {
seen = signal;
return gate.promise;
},
{ signal: controller.signal },
);
const request = new Cesium.Request();
const pending = provider.requestImage(0, 0, 0, request);
assert.equal(seen.aborted, false);
controller.abort();
assert.equal(seen.aborted, true, 'the abort reaches the frame source');
const late = tilePixels();
gate.resolve(late);
await assert.rejects(pending, { name: 'AbortError' });
assert.equal(late.closes, 1);
assert.equal(
request.state,
Cesium.RequestState.CANCELLED,
'Cesium unloads a cancelled tile instead of failing it',
);
await assert.rejects(
provider.requestImage(1, 0, 0),
{ name: 'AbortError' },
'a closed frame asks the source for nothing more',
);
});