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.
This commit is contained in:
Sameh Khamis committed 2026-11-10 21:54:08 -08:00
1 parent aff5ce7f17
commit e18353f769
12 files changed
+1068 -31

No files matched your search

+162 -1
View File
@@ -1,7 +1,10 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createRasterTileProvider } from './rasterTiles.js';
import {
createRasterTileProvider,
createFrameTileProvider,
} from './rasterTiles.js';
import { createFieldRaster } from '../wind/fields.js';
// A small canvas double exposes the uploaded raster and exact drawImage crop.
@@ -154,3 +157,161 @@ test('512-pixel crops preserve source extent at root and clamped draping levels'
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',
);
});