mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
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:
1 parent
aff5ce7f17
commit
e18353f769
12 files changed
+1068
-31
No files matched your search
@@ -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',
|
||||
);
|
||||
});
|
||||
Reference in new issue
Block a user