Files
gods-eye-view/src/layers/weather/shellRendering.test.mjs
T

1505 lines
52 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
createShellSurface,
createWeatherShell,
detailWindow,
orderWeatherShells,
shellLift,
WEATHER_SHELL_CACHE_BYTES,
WEATHER_SHELL_HEIGHTS,
} from './shellRendering.js';
import { NO_IMAGERY_HOST } from './imageryHost.js';
import {
createShellCesium,
createShellScene,
renderShells,
} from './shellFixture.mjs';
const times = [
'2026-09-15T20:00:00.000Z',
'2026-09-15T20:05:00.000Z',
'2026-09-15T20:10:00.000Z',
];
const bounds = { west: -130, south: 20, east: -60, north: 55 };
const snapshot = (product = 'radar', extra = {}) => ({
product,
times,
latest: times[2],
bounds,
...extra,
});
const flush = async () => {
for (let i = 0; i < 30; i++) await Promise.resolve();
};
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => {
resolve = yes;
reject = no;
});
return { promise, resolve, reject };
};
function canvas() {
const output = { width: 0, height: 0 };
output.getContext = () => ({
drawImage(source) {
output.source = source;
},
getImageData: () => ({ data: new Uint8ClampedArray([194, 0, 0, 200]) }),
putImageData(pixels) {
output.pixels = pixels.data;
},
});
return output;
}
const response = () => ({
ok: true,
headers: new Headers(),
arrayBuffer: async () => new ArrayBuffer(1),
});
// The detail window uniform; NONE is the empty window.
const NONE = { x: 0, y: 0, z: -1, w: -1 };
const windowOf = (primitive) => {
const { x, y, z, w } = primitive.appearance.material.uniforms.window;
return { x, y, z, w };
};
function harness({ product = 'radar', camera, ...options } = {}) {
const cesium = options.cesium ?? createShellCesium();
const scene = createShellScene();
const fetches = [];
const decoded = [];
let host = { collection: null, kind: 'tileset' };
const shell = createWeatherShell({
viewer: { scene, camera },
cesium,
product,
getHost: () => host,
fetchImpl: async (url, init) => {
fetches.push({ url, signal: init.signal });
return response();
},
decodeImage: async () => {
const size =
product === 'clouds'
? { width: 2048, height: 1024 }
: { width: 4096, height: 2048 };
const image = {
...size,
closed: false,
close() {
this.closed = true;
},
};
decoded.push(image);
return image;
},
createCanvas: canvas,
...options,
});
return {
shell,
cesium,
scene,
fetches,
decoded,
setHost(value) {
host = value;
},
render: (count) => renderShells(cesium, scene, count),
primitives: () => scene.primitives.items,
material: () => scene.primitives.items.at(-1)?.appearance.material,
};
}
async function show(h, time, options) {
const pending = h.shell.setFrame(snapshot(h.shell.product), time, options);
await flush();
h.render();
return pending;
}
test('shell heights stack every product with lightning highest', () => {
assert.deepEqual(WEATHER_SHELL_HEIGHTS, {
wind: 5_000,
clouds: 5_500,
'clouds-regional': 5_800,
radar: 6_200,
lightning: 6_600,
});
assert.equal(WEATHER_SHELL_CACHE_BYTES, 128 * 1024 * 1024);
});
test('surface builds a flat raised rectangle drawn in primitive order without depth writes', () => {
const cesium = createShellCesium();
const scene = createShellScene();
const rectangle = Cesium.Rectangle.fromDegrees(-130, 20, -60, 55);
const surface = createShellSurface({
viewer: { scene },
cesium,
rectangle,
height: 6_200,
});
const template = cesium.templates.get('WeatherFrame');
assert.ok(!(template instanceof cesium.Material), 'plain template');
assert.deepEqual(template.fabric.uniforms, {
image: Cesium.Material.DefaultImageId,
detail: Cesium.Material.DefaultImageId,
alpha: 1,
window: { type: 'vec4', x: 0, y: 0, z: -1, w: -1 },
});
const { source } = template.fabric;
assert.match(
source,
/material\.alpha = c\.a \* alpha \* step\(1\.5, float\(imageDimensions\.x\)\);/,
'nothing draws before the full-extent image',
);
assert.match(
source,
/float useDetail = inside \* step\(1\.5, float\(detailDimensions\.x\)\);/,
'the detail image is sampled only once it has arrived',
);
assert.match(
source,
/all\(greaterThanEqual\(st, window\.xy\)\) && all\(lessThanEqual\(st, window\.zw\)\)/,
);
assert.match(
source,
/mix\(coarse, texture\(detail, clamp\(dst, 0\.0, 1\.0\)\), useDetail\)/,
);
assert.match(source, /material\.diffuse = czm_gammaCorrect\(c\.rgb\);/);
const [primitive] = scene.primitives.items;
const appearance = primitive.appearance;
assert.equal(appearance.material.options.translucent, false);
assert.deepEqual(
{ ...appearance.options, material: undefined },
{
aboveGround: true,
flat: true,
translucent: false,
material: undefined,
},
);
assert.deepEqual(appearance.getRenderState(), {
depthTest: { enabled: true },
depthMask: false,
blending: Cesium.BlendingState.ALPHA_BLEND,
});
const geometry = primitive.options.geometryInstances.geometry.options;
assert.equal(geometry.rectangle, rectangle);
assert.equal(geometry.height, 6_200);
assert.equal(geometry.granularity, Cesium.Math.toRadians(0.5));
assert.equal(
geometry.vertexFormat,
Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
);
assert.equal(primitive.options.asynchronous, true);
assert.equal(primitive.options.allowPicking, false);
const lower = createShellSurface({
viewer: { scene },
cesium,
rectangle,
height: 5_000,
});
assert.equal(cesium.templates.size, 1, 'the template registers once');
assert.deepEqual(
scene.primitives.items.map(
(item) => item.options.geometryInstances.geometry.options.height,
),
[5_000, 6_200],
);
lower.destroy();
surface.destroy();
});
test('a surface applies a new detail window only once its image has drawn; the same window swaps only the image', () => {
const cesium = createShellCesium();
const scene = createShellScene();
const surface = createShellSurface({
viewer: { scene },
cesium,
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
height: 6_200,
});
const [primitive] = scene.primitives.items;
const { uniforms } = primitive.appearance.material;
const render = (count) => renderShells(cesium, scene, count);
const image = () => ({ width: 4096, height: 2048 });
surface.setImage(image());
render();
assert.deepEqual(surface.getDiagnostics().detail, {
uploaded: false,
window: null,
});
const a = { west: 0.25, south: 0.5, east: 0.5, north: 0.75 };
const first = image();
surface.setDetail(first, a);
assert.equal(uniforms.detail, first);
assert.deepEqual(windowOf(primitive), NONE, 'the full-extent image covers');
assert.equal(scene.postRender.size, 1, 'renders until the detail has drawn');
render(2);
assert.deepEqual(windowOf(primitive), NONE);
render(1);
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
assert.ok(uniforms.window instanceof Cesium.Cartesian4);
assert.deepEqual(surface.getDiagnostics().detail, {
uploaded: true,
window: a,
});
assert.equal(scene.postRender.size, 0);
// A time change in the same window: Cesium keeps drawing the previous
// texture until the new one is uploaded, so the window stays.
const applied = uniforms.window;
const second = image();
surface.setDetail(second, { ...a });
assert.equal(uniforms.detail, second);
assert.equal(uniforms.window, applied, 'only the image is written');
assert.equal(surface.getDiagnostics().detail.uploaded, false);
render();
assert.equal(surface.getDiagnostics().detail.uploaded, true);
assert.equal(uniforms.window, applied);
const renders = scene.renders;
surface.setDetail(second, { ...a });
assert.equal(scene.renders, renders, 'an unchanged detail costs nothing');
assert.equal(scene.postRender.size, 0);
// A different window empties at once and applies once its image has drawn.
const b = { west: 0.5, south: 0.25, east: 0.75, north: 0.5 };
surface.setDetail(image(), b);
assert.deepEqual(windowOf(primitive), NONE);
render(2);
assert.deepEqual(windowOf(primitive), NONE);
render(1);
assert.deepEqual(windowOf(primitive), { x: 0.5, y: 0.25, z: 0.75, w: 0.5 });
surface.setDetail(null);
assert.equal(uniforms.detail, Cesium.Material.DefaultImageId);
assert.deepEqual(windowOf(primitive), NONE);
assert.deepEqual(surface.getDiagnostics().detail, {
uploaded: false,
window: null,
});
render();
assert.deepEqual(
{ ...uniforms.detailDimensions },
{ type: 'ivec3', x: 1, y: 1 },
);
// Counted renders alone are not enough: the bound texture must be this image.
surface.setDetail(image(), a);
for (let i = 0; i < 4; i++) scene.postRender.emit();
assert.deepEqual(windowOf(primitive), NONE, 'still the 1×1 default');
render(1);
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
surface.destroy();
surface.setDetail(image(), b);
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
assert.equal(scene.postRender.size, 0);
});
test('shells rise with the camera over coarse 3D tiles, in steps, up to 60 km', () => {
assert.equal(shellLift(undefined), 0);
assert.equal(shellLift(1_200), 0, 'city views keep the shell heights');
assert.equal(shellLift(3_000_000), 12_000);
assert.equal(shellLift(8_000_000), 32_000);
assert.equal(shellLift(18_500_000), 60_000);
const camera = { positionCartographic: { height: 1_200 } };
const scene = {
primitives: new Cesium.PrimitiveCollection(),
preRender: new Cesium.Event(),
postRender: new Cesium.Event(),
camera,
requestRender() {},
};
const surface = createShellSurface({
viewer: { scene },
cesium: Cesium,
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
height: 5_800,
});
const primitive = scene.primitives.get(0);
const identity = primitive.modelMatrix;
scene.preRender.raiseEvent();
assert.equal(primitive.modelMatrix, identity, 'no lift, no new matrix');
camera.positionCartographic.height = 8_000_000;
scene.preRender.raiseEvent();
const radius = Cesium.Ellipsoid.WGS84.maximumRadius;
assert.ok(
Math.abs(primitive.modelMatrix[0] * radius - (radius + 32_000)) < 1e-3,
);
const lifted = primitive.modelMatrix;
camera.positionCartographic.height = 8_010_000;
scene.preRender.raiseEvent();
assert.equal(primitive.modelMatrix, lifted, 'the same step keeps the matrix');
surface.destroy();
assert.equal(scene.preRender.numberOfListeners, 0);
});
test('real Cesium builds the two-texture material, the opaque-pass appearance and the rectangle primitive', () => {
const scene = {
primitives: new Cesium.PrimitiveCollection(),
postRender: new Cesium.Event(),
requestRender() {},
};
const surface = createShellSurface({
viewer: { scene },
cesium: Cesium,
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
height: 6_600,
});
const cached = Cesium.Material._materialCache.getMaterial('WeatherFrame');
assert.ok(cached && !(cached instanceof Cesium.Material));
const primitive = scene.primitives.get(0);
const material = primitive.appearance.material;
assert.ok(primitive instanceof Cesium.Primitive);
assert.equal(material.type, 'WeatherFrame');
assert.equal(material.isTranslucent(), false);
assert.equal(primitive.appearance.isTranslucent(), false, 'opaque pass');
assert.equal(primitive.appearance.getRenderState().depthMask, false);
assert.equal(
Cesium.Appearance.prototype.getRenderState.call(primitive.appearance)
.depthMask,
true,
'the default opaque render state would write depth',
);
assert.deepEqual(
[material.uniforms.imageDimensions.x, material.uniforms.detailDimensions.x],
[1, 1],
'Cesium tracks both bound texture sizes',
);
const shader = material.shaderSource;
for (const declaration of [
/uniform sampler2D image_\d+;/,
/uniform sampler2D detail_\d+;/,
/uniform float alpha_\d+;/,
/uniform vec4 window_\d+;/,
/uniform ivec3 imageDimensions_\d+;/,
/uniform ivec3 detailDimensions_\d+;/,
])
assert.match(shader, declaration);
assert.match(shader, /texture\(image_\d+, st\)/);
assert.match(shader, /texture\(detail_\d+, clamp\(dst, 0\.0, 1\.0\)\)/);
assert.match(shader, /lessThanEqual\(st, window_\d+\.zw\)/);
assert.match(shader, /step\(1\.5, float\(detailDimensions_\d+\.x\)\)/);
assert.match(
shader,
/material\.alpha = c\.a \* alpha_\d+ \* step\(1\.5, float\(imageDimensions_\d+\.x\)\);/,
'the uniform is renamed, the material field is not',
);
assert.match(shader, /float useDetail = inside \* step/, 'locals keep names');
const detail = { width: 4096, height: 2048 };
surface.setDetail(detail, { west: 0.1, south: 0.2, east: 0.3, north: 0.4 });
assert.equal(material.uniforms.detail, detail);
assert.deepEqual(
[material.uniforms.window.z, material.uniforms.window.w],
[-1, -1],
'no window before the image has drawn',
);
surface.setDetail(null);
assert.equal(material.uniforms.detail, Cesium.Material.DefaultImageId);
surface.setAlpha(0.4);
assert.equal(material.uniforms.alpha, 0.4);
surface.destroy();
assert.equal(scene.primitives.length, 0);
assert.equal(primitive.isDestroyed(), true);
assert.equal(material.isDestroyed(), true);
assert.equal(scene.postRender.numberOfListeners, 0);
});
test('shells draw first, in height order, regardless of add order', () => {
const scene = createShellScene();
const other = { name: 'other' };
scene.primitives.add(other);
const add = (name, height) => {
const primitive = { name };
scene.primitives.add(primitive);
orderWeatherShells(scene.primitives, primitive, height);
return primitive;
};
add('lightning', 6_600);
add('radar', 6_200);
add('wind', 5_000);
const later = { name: 'later' };
scene.primitives.add(later);
add('regional', 5_800);
assert.deepEqual(
scene.primitives.items.map(({ name }) => name),
['wind', 'regional', 'radar', 'lightning', 'other', 'later'],
);
const primitives = new Cesium.PrimitiveCollection({
destroyPrimitives: false,
});
const real = (name) => ({ name, update() {}, isDestroyed: () => false });
const tileset = primitives.add(real('tileset'));
const lightning = primitives.add(real('lightning'));
orderWeatherShells(primitives, lightning, 6_600);
const radar = primitives.add(real('radar'));
orderWeatherShells(primitives, radar, 6_200);
assert.deepEqual(
[0, 1, 2].map((i) => primitives.get(i).name),
['radar', 'lightning', 'tileset'],
'real Cesium collection order',
);
assert.equal(tileset.name, 'tileset');
});
test('first frame stages invisibly, requests renders until drawable and then commits', async () => {
const h = harness();
const pending = h.shell.setFrame(snapshot(), times[0]);
assert.equal(h.shell.getDiagnostics().loading, true);
await flush();
const material = h.material();
assert.equal(h.primitives().length, 1);
assert.equal(material.uniforms.alpha, 0, 'staging surface is invisible');
assert.equal(material.uniforms.image.width, 4096);
assert.equal(h.scene.postRender.size, 1, 'render loop while not drawable');
const before = h.scene.renders;
h.scene.postRender.emit();
assert.ok(h.scene.renders > before, 'each render asks for another');
assert.equal(h.shell.getDiagnostics().time, null);
h.render();
assert.equal(await pending, true);
assert.equal(material.uniforms.alpha, 0.7);
assert.equal(h.scene.postRender.size, 0, 'render loop ends');
const diagnostics = h.shell.getDiagnostics();
assert.equal(diagnostics.host, 'shell');
assert.equal(diagnostics.height, 6_200);
assert.deepEqual(diagnostics.imageSize, { width: 4096, height: 2048 });
assert.equal(diagnostics.time, times[0]);
assert.equal(diagnostics.product, 'radar');
assert.equal(diagnostics.loading, false);
assert.equal(diagnostics.imageryCount, 1);
assert.deepEqual(diagnostics.shell, {
height: 6_200,
ready: true,
uploaded: true,
show: true,
alpha: 0.7,
rendering: false,
detail: {
bbox: null,
size: { width: 4096, height: 2048 },
ready: false,
enabled: false,
},
});
assert.equal(h.fetches.length, 1, 'no camera, no detail window');
assert.equal(
new URL(h.fetches[0].url, 'https://example.test').search,
`?product=radar&time=${encodeURIComponent(times[0])}`,
);
h.shell.clear();
});
test('a new frame keeps the previous image until decoded, then swaps the uniform', async () => {
const decode = deferred();
let first = true;
const h = harness({
decodeImage: async () =>
first
? ((first = false), { width: 4096, height: 2048, close() {} })
: decode.promise,
});
assert.equal(await show(h, times[0]), true);
const material = h.material();
const previous = material.uniforms.image;
const pending = h.shell.setFrame(snapshot(), times[1]);
await flush();
assert.equal(material.uniforms.image, previous, 'previous image stays');
assert.equal(h.shell.getDiagnostics().time, times[0]);
assert.equal(h.shell.getDiagnostics().loading, true);
let closed = false;
decode.resolve({
width: 4096,
height: 2048,
close() {
closed = true;
},
});
assert.equal(await pending, true);
assert.equal(closed, true, 'decoded image is released');
assert.notEqual(material.uniforms.image, previous);
assert.equal(material.uniforms.image.source.width, 4096, 'canvas copy');
assert.equal(h.primitives().length, 1, 'same extent reuses the surface');
assert.equal(h.shell.getDiagnostics().time, times[1]);
assert.equal(h.scene.postRender.size, 1, 'renders until the upload');
h.render();
assert.equal(h.scene.postRender.size, 0);
h.shell.clear();
});
for (const outcome of ['fetch', 'decode', 'dimensions', 'timeout']) {
test(`${outcome} failure retains the previous frame and reports it`, async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
let fail = false;
const h = harness({
fetchImpl: async () => {
if (fail && outcome === 'fetch') throw new Error('offline');
return response();
},
decodeImage: async () => {
if (fail && outcome === 'decode') throw new Error('bad png');
if (fail && outcome === 'timeout') return new Promise(() => {});
return {
width: fail && outcome === 'dimensions' ? 2048 : 4096,
height: 2048,
close() {},
};
},
});
assert.equal(await show(h, times[0]), true);
const image = h.material().uniforms.image;
fail = true;
const pending = h.shell.setFrame(snapshot(), times[1]);
await flush();
if (outcome === 'timeout') t.mock.timers.tick(25_000);
assert.equal(await pending, false);
assert.equal(h.material().uniforms.image, image);
assert.equal(h.shell.getDiagnostics().time, times[0]);
assert.equal(
h.shell.getDiagnostics().error,
'Weather tiles unavailable · previous frame retained',
);
fail = false;
assert.equal(await show(h, times[2]), true);
assert.equal(h.shell.getDiagnostics().error, null);
h.shell.clear();
});
}
test('alpha writes the uniform and hidden hides without losing the frame', async () => {
const h = harness();
h.shell.setAlpha(0.4);
assert.equal(await show(h, times[0]), true);
const material = h.material();
assert.equal(material.uniforms.alpha, 0.4);
const renders = h.scene.renders;
h.shell.setAlpha(0.8);
assert.equal(material.uniforms.alpha, 0.8);
assert.ok(h.scene.renders > renders);
const primitive = h.primitives()[0];
const pending = h.shell.setFrame(snapshot(), times[1]);
h.shell.setHidden(true);
assert.equal(await pending, false, 'hiding cancels a stage');
assert.equal(primitive.show, false);
assert.equal(h.shell.getDiagnostics().time, null);
assert.equal(h.shell.getDiagnostics().hidden, true);
assert.equal(
await h.shell.prefetch(snapshot(), times[2]),
false,
'hidden frames do not prefetch',
);
h.shell.setHidden(false);
assert.equal(primitive.show, true);
assert.equal(h.shell.getDiagnostics().time, times[0]);
h.shell.clear();
});
test('clear destroys the primitive, material, listeners, timers and decoded images', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const h = harness();
assert.equal(await show(h, times[0]), true);
const [primitive] = h.primitives();
const material = primitive.appearance.material;
const pending = h.shell.setFrame(snapshot(), times[1]);
const signal = h.fetches.at(-1)?.signal;
h.shell.clear();
assert.equal(await pending, false);
assert.equal(h.primitives().length, 0);
assert.equal(primitive.destroyed, true);
assert.equal(material.destroyed, true, 'the material is destroyed too');
assert.equal(h.scene.postRender.size, 0);
assert.equal(signal?.aborted ?? true, true);
assert.deepEqual(h.shell.getDiagnostics().cache, {
mosaics: 0,
bytes: 0,
prefetching: false,
});
assert.equal(h.shell.getDiagnostics().time, null);
t.mock.timers.tick(30_000);
assert.equal(h.primitives().length, 0);
});
test('a new extent stages a second surface and retires the first only once drawable', async () => {
const h = harness();
assert.equal(await show(h, times[0]), true);
const [first] = h.primitives();
const pending = h.shell.setFrame(
snapshot('radar', { bounds: { ...bounds, south: 21 } }),
times[0],
);
await flush();
assert.equal(h.primitives().length, 2);
const second = h.primitives()[1];
assert.equal(second.appearance.material.uniforms.alpha, 0);
assert.equal(h.shell.getDiagnostics().imageryCount, 2);
h.render();
assert.equal(await pending, true);
assert.deepEqual(h.primitives(), [second]);
assert.equal(first.destroyed, true);
assert.equal(first.appearance.material.destroyed, true);
assert.equal(second.appearance.material.uniforms.alpha, 0.7);
h.shell.clear();
});
test('decoded frames are a byte-bounded LRU that never evicts the displayed frame', async () => {
const clouds = harness({
product: 'clouds',
cacheBytes: 48 * 1024 * 1024,
});
const extra = Array.from({ length: 5 }, (_, i) =>
new Date(Date.parse(times[2]) + (i + 1) * 60_000).toISOString(),
);
const all = [...times, ...extra];
const sample = snapshot('clouds', { times: all, latest: all.at(-1) });
for (const time of all.slice(0, 6)) {
const pending = clouds.shell.setFrame(sample, time);
await flush();
clouds.render();
assert.equal(await pending, true);
}
assert.deepEqual(clouds.shell.getDiagnostics().cache, {
mosaics: 6,
bytes: 6 * 8 * 1024 * 1024,
prefetching: false,
});
const pending = clouds.shell.setFrame(sample, all[6]);
await flush();
clouds.render();
assert.equal(await pending, true);
assert.equal(clouds.shell.getDiagnostics().cache.mosaics, 6);
const fetches = clouds.fetches.length;
const again = clouds.shell.setFrame(sample, all[0]);
await flush();
assert.equal(await again, true);
assert.equal(clouds.fetches.length, fetches + 1, 'oldest was evicted');
const cached = clouds.shell.setFrame(sample, all[5]);
assert.equal(await cached, true);
assert.equal(clouds.fetches.length, fetches + 1);
assert.deepEqual(clouds.shell.getDiagnostics().mosaic, {
fetched: false,
decodeMs: 0,
cached: true,
});
clouds.shell.clear();
const radar = harness({ cacheBytes: 48 * 1024 * 1024 });
assert.equal(await show(radar, times[0]), true);
assert.equal(await show(radar, times[1]), true);
assert.deepEqual(radar.shell.getDiagnostics().cache, {
mosaics: 1,
bytes: 32 * 1024 * 1024,
prefetching: false,
});
assert.equal(await radar.shell.prefetch(snapshot(), times[2]), true);
assert.equal(
radar.shell.getDiagnostics().cache.bytes,
64 * 1024 * 1024,
'the displayed frame and the newest decode stay',
);
assert.equal(await show(radar, times[2]), true);
assert.equal(radar.shell.getDiagnostics().cache.mosaics, 1);
assert.equal(radar.fetches.length, 3);
radar.shell.clear();
});
test('prefetch warms a decoded frame without staging and cancels cleanly', async () => {
const h = harness();
assert.equal(await show(h, times[0]), true);
const warm = h.shell.prefetch(snapshot(), times[1]);
assert.equal(h.shell.getDiagnostics().cache.prefetching, true);
assert.equal(await warm, true);
assert.equal(h.primitives().length, 1);
assert.equal(h.shell.getDiagnostics().time, times[0]);
assert.equal(
await h.shell.prefetch(snapshot(), times[1]),
false,
'completed work is not repeated',
);
assert.equal(await h.shell.setFrame(snapshot(), times[1]), true);
assert.equal(h.fetches.length, 2);
assert.equal(h.shell.getDiagnostics().mosaic.cached, true);
for (const cancel of ['cancelPrefetch', 'clear', 'setHidden']) {
const decode = deferred();
const other = harness({ decodeImage: () => decode.promise });
const pending = other.shell.prefetch(snapshot(), times[2]);
await flush();
other.shell[cancel](true);
assert.equal(other.fetches[0].signal.aborted, true);
let closed = false;
decode.resolve({
width: 4096,
height: 2048,
close() {
closed = true;
},
});
assert.equal(await pending, false);
assert.equal(closed, true);
assert.equal(other.shell.getDiagnostics().cache.mosaics, 0);
other.shell.clear();
}
h.shell.clear();
});
test('infrared frames get the display transfer; radar and lightning keep their pixels', async () => {
for (const [product, transfer] of [
['clouds-regional', true],
['clouds', true],
['radar', false],
['lightning', false],
]) {
const h = harness({ product });
const pending = h.shell.setFrame(snapshot(product), times[0]);
await flush();
const image = h.material().uniforms.image;
assert.equal(image.source, h.decoded[0], 'drawn into a canvas');
assert.equal(h.decoded[0].closed, true);
assert.equal(image.pixels !== undefined, transfer, product);
if (transfer)
assert.deepEqual([...image.pixels], [194, 0, 0, 98], 'clouds only');
h.render();
assert.equal(await pending, true);
assert.equal(
h.shell.getDiagnostics().height,
WEATHER_SHELL_HEIGHTS[product],
);
h.shell.clear();
}
});
test('an infrared mode change restages the same time with its own cached canvas', async () => {
const h = harness({ product: 'clouds' });
assert.equal(await show(h, times[0]), true);
const filtered = h.material().uniforms.image;
assert.equal(await show(h, times[0]), true, 'same frame is a no-op');
assert.equal(h.fetches.length, 1);
assert.equal(await show(h, times[0], { infrared: 'full' }), true);
const full = h.material().uniforms.image;
assert.notEqual(full, filtered);
assert.deepEqual([...full.pixels], [194, 0, 0, 200]);
assert.equal(h.shell.getDiagnostics().infrared, 'full');
assert.equal(await show(h, times[0], { infrared: 'filtered' }), true);
assert.equal(h.material().uniforms.image, filtered, 'cache hit');
assert.equal(h.fetches.length, 2);
h.shell.clear();
});
test('image size follows the product maximum and halves for small texture limits', async () => {
for (const [product, limit, size, query] of [
['radar', 0, [4096, 2048], null],
['clouds-regional', 16_384, [4096, 2048], null],
['radar', 2048, [2048, 1024], '2048x1024'],
['lightning', 0, [4096, 2048], null],
['lightning', 4096, [4096, 2048], null],
['clouds', 0, [2048, 1024], null],
['clouds', 1024, [1024, 512], '1024x512'],
]) {
const h = harness({
product,
cesium: createShellCesium({ maximumTextureSize: limit }),
decodeImage: async () => ({
width: size[0],
height: size[1],
close() {},
}),
});
assert.deepEqual(h.shell.getDiagnostics().imageSize, {
width: size[0],
height: size[1],
});
const pending = h.shell.setFrame(snapshot(product), times[0]);
await flush();
h.render();
assert.equal(await pending, true);
const url = new URL(h.fetches[0].url, 'https://example.test');
assert.equal(url.pathname, '/api/weather/image');
assert.equal(url.searchParams.get('product'), product);
assert.equal(url.searchParams.get('size'), query);
h.shell.clear();
}
});
test('a host without imagery hides the shell, keeps the frame and refuses work', async () => {
const h = harness();
assert.equal(await show(h, times[0]), true);
const [primitive] = h.primitives();
h.setHost({ collection: null, kind: 'none' });
assert.equal(h.shell.rehome(), true);
assert.equal(primitive.show, false);
assert.equal(h.shell.getDiagnostics().time, times[0]);
assert.equal(h.shell.getDiagnostics().error, NO_IMAGERY_HOST);
assert.equal(await h.shell.setFrame(snapshot(), times[1]), false);
assert.equal(await h.shell.prefetch(snapshot(), times[1]), false);
h.setHost({ collection: null, kind: 'tileset' });
h.shell.rehome();
assert.equal(primitive.show, true);
assert.equal(h.shell.getDiagnostics().error, null);
h.shell.clear();
});
test('an unowned restage is joined by the next request for the same frame', async () => {
const h = harness();
const restage = h.shell.setFrame(snapshot(), times[0]);
const controller = new AbortController();
const joined = h.shell.setFrame(snapshot(), times[0], {
signal: controller.signal,
});
await flush();
assert.equal(h.fetches.length, 1, 'one acquisition');
const other = h.shell.setFrame(snapshot(), times[0], {
signal: new AbortController().signal,
});
assert.equal(await restage, false, 'an owned stage is not joined');
assert.equal(await joined, false);
await flush();
h.render();
assert.equal(await other, true);
const cancelled = h.shell.setFrame(snapshot(), times[1]);
const abort = new AbortController();
const owner = h.shell.setFrame(snapshot(), times[1], {
signal: abort.signal,
});
abort.abort();
assert.equal(await cancelled, false);
assert.equal(await owner, false);
assert.equal(h.shell.getDiagnostics().time, times[0]);
h.shell.clear();
});
const footprint = (west, south, east, north) => ({ west, south, east, north });
const box = (west, south, east, north) => ({ west, south, east, north });
test('hidden frames do not count towards a pending detail window', () => {
const cesium = createShellCesium();
const scene = createShellScene();
const surface = createShellSurface({
viewer: { scene },
cesium,
rectangle: Cesium.Rectangle.fromDegrees(-130, 20, -60, 55),
height: 6_200,
});
const [primitive] = scene.primitives.items;
const render = (count) => renderShells(cesium, scene, count);
const image = () => ({ width: 4096, height: 2048 });
surface.setImage(image());
const a = { west: 0.25, south: 0.5, east: 0.5, north: 0.75 };
surface.setDetail(image(), a);
render();
assert.deepEqual(windowOf(primitive), { x: 0.25, y: 0.5, z: 0.5, w: 0.75 });
// A different window with a same-sized image: the dimensions alone cannot
// tell the textures apart, so only shown frames may count.
const b = { west: 0.5, south: 0.25, east: 0.75, north: 0.5 };
surface.setDetail(image(), b);
assert.deepEqual(windowOf(primitive), NONE);
for (let i = 0; i < 3; i++) {
surface.setShow(false);
scene.postRender.emit();
surface.setShow(true);
}
assert.deepEqual(windowOf(primitive), NONE, 'hidden frames counted nothing');
render(2);
assert.deepEqual(windowOf(primitive), NONE);
render(1);
assert.deepEqual(windowOf(primitive), { x: 0.5, y: 0.25, z: 0.75, w: 0.5 });
});
test('detail windows are sized from the footprint, snapped to 0.5° and clamped inside the product', () => {
// max(2 × the longitude span, 6°) wide, half as tall.
assert.deepEqual(
detailWindow(footprint(-100, 35, -98, 36), bounds),
box(-102, 34, -96, 37),
);
assert.deepEqual(
detailWindow(footprint(-100, 30, -95, 40), bounds),
box(-102.5, 32.5, -92.5, 37.5),
);
assert.deepEqual(
detailWindow(footprint(-100, 35, -95.8, 36), bounds),
box(-102.5, 33.5, -93.5, 38),
'whole-degree widths keep the half height on the grid',
);
assert.deepEqual(
detailWindow(footprint(-98.3, 34.6, -96.3, 35.6), bounds),
box(-100.5, 33.5, -94.5, 36.5),
);
assert.deepEqual(
detailWindow(footprint(-131, 20, -129, 21), bounds),
box(-130, 20, -124, 23),
);
assert.deepEqual(
detailWindow(footprint(-61, 54, -59, 56), bounds),
box(-66, 52, -60, 55),
);
const uneven = { west: -129.99, south: 20.01, east: -60.2, north: 54.9 };
assert.deepEqual(
detailWindow(footprint(-131, 20, -129, 21), uneven),
box(-129.5, 20.5, -123.5, 23.5),
'clamped to the grid inside uneven bounds',
);
// Enabled only while narrower than half the product extent (70° here).
assert.deepEqual(
detailWindow(footprint(-110, 30, -93, 40), bounds),
box(-118.5, 26.5, -84.5, 43.5),
);
assert.equal(detailWindow(footprint(-110, 30, -92.5, 40), bounds), null);
assert.equal(detailWindow(footprint(-180, -90, 180, 90), bounds), null);
assert.equal(
detailWindow(footprint(10, 45, 12, 46), bounds),
null,
'a view away from the product',
);
assert.equal(detailWindow(null, bounds), null);
assert.equal(
detailWindow(footprint(-100, 35, -98, 36), {
west: -130,
south: 30,
east: -60,
north: 32,
}),
null,
'a window taller than the product',
);
const world = { west: -180, south: -60, east: 180, north: 60 };
assert.deepEqual(
detailWindow(footprint(170, 0, -170, 10), world),
box(140, -5, 180, 15),
'a footprint across the antimeridian',
);
for (const [west, south, east, north] of [
[-100, 35, -98, 36],
[-129.7, 20.2, -121.1, 24.4],
[-75.3, 41.1, -61.2, 54.8],
[-97.77, 30.03, -96.41, 30.9],
]) {
const next = detailWindow(footprint(west, south, east, north), bounds);
assert.equal(next.east - next.west, 2 * (next.north - next.south));
assert.ok(Object.values(next).every((edge) => Number.isInteger(edge * 2)));
assert.ok(
next.west >= bounds.west &&
next.east <= bounds.east &&
next.south >= bounds.south &&
next.north <= bounds.north,
);
}
});
test('detail windows hold while the view stays in their inner half and the span within 50 %', () => {
const first = detailWindow(footprint(-100, 35, -98, 36), bounds);
assert.equal(
detailWindow(footprint(-98.6, 35.5, -96.6, 36.5), bounds, first),
first,
'panning inside the inner half costs nothing',
);
assert.deepEqual(
detailWindow(footprint(-98.4, 35, -96.4, 36), bounds, first),
box(-100.5, 34, -94.5, 37),
);
assert.deepEqual(
detailWindow(footprint(-100, 36, -98, 37), bounds, first),
box(-102, 35, -96, 38),
);
const wide = detailWindow(footprint(-100, 30, -95, 40), bounds);
assert.equal(detailWindow(footprint(-101, 30, -94, 40), bounds, wide), wide);
assert.equal(detailWindow(footprint(-99, 30, -96, 40), bounds, wide), wide);
const out = detailWindow(footprint(-101.5, 30, -93.5, 40), bounds, wide);
assert.deepEqual(out, box(-105.5, 31, -89.5, 39), 'zoomed out');
assert.deepEqual(
detailWindow(footprint(-99.25, 34.5, -95.75, 35.5), bounds, out),
box(-101, 33.5, -94, 37),
'zoomed in',
);
assert.equal(
detailWindow(footprint(-106, 30, -88, 40), bounds, out),
null,
'zooming past half the product disables the window',
);
const edge = detailWindow(footprint(-131, 20, -129, 21), bounds);
assert.equal(
detailWindow(footprint(-131.2, 20, -129.2, 21), bounds, edge),
edge,
'a clamped window that would not move is kept',
);
});
function camera(west, south, east, north) {
const listeners = new Set();
let rectangle = Cesium.Rectangle.fromDegrees(west, south, east, north);
return {
moveEnd: {
addEventListener(listener) {
listeners.add(listener);
return () => listeners.delete(listener);
},
get size() {
return listeners.size;
},
},
computeViewRectangle: () => rectangle,
look(...edges) {
rectangle = Cesium.Rectangle.fromDegrees(...edges);
for (const listener of [...listeners]) listener();
},
};
}
// A window in degrees, in the full-extent image's texture coordinates.
const windowFor = (w) => ({
x: (w.west - bounds.west) / (bounds.east - bounds.west),
y: (w.south - bounds.south) / (bounds.north - bounds.south),
z: (w.east - bounds.west) / (bounds.east - bounds.west),
w: (w.north - bounds.south) / (bounds.north - bounds.south),
});
const query = (url) => new URL(url, 'https://example.test').searchParams;
test('a detail window follows the view after the full-extent frame, on the same surface', async () => {
const view = camera(-100, 35, -98, 36);
const h = harness({ camera: view });
const pending = h.shell.setFrame(snapshot(), times[0]);
await flush();
assert.equal(h.fetches.length, 1, 'the full-extent image comes first');
h.render();
assert.equal(await pending, true);
assert.equal(view.moveEnd.size, 1);
await flush();
assert.equal(h.fetches.length, 2);
assert.equal(query(h.fetches[1].url).get('bbox'), '-102,34,-96,37');
assert.equal(query(h.fetches[1].url).get('time'), times[0]);
assert.equal(query(h.fetches[1].url).get('size'), null);
const [shell] = h.primitives();
assert.equal(h.primitives().length, 1, 'no second surface');
const { uniforms } = shell.appearance.material;
assert.equal(uniforms.detail.source, h.decoded[1]);
assert.deepEqual(windowOf(shell), NONE, 'the full-extent image covers');
assert.deepEqual(h.shell.getDiagnostics().shell.detail, {
bbox: [-102, 34, -96, 37],
size: { width: 4096, height: 2048 },
ready: false,
enabled: true,
});
h.render();
assert.deepEqual(windowOf(shell), windowFor(box(-102, 34, -96, 37)));
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
assert.equal(h.shell.getDiagnostics().imageryCount, 1);
assert.equal(h.scene.postRender.size, 0);
view.look(-99.5, 35.2, -97.5, 36.2);
await flush();
assert.equal(
h.fetches.length,
2,
'panning inside the window fetches nothing',
);
view.look(-90, 40, -88, 41);
assert.equal(
uniforms.detail,
Cesium.Material.DefaultImageId,
'a moved window clears at once',
);
assert.deepEqual(windowOf(shell), NONE);
assert.deepEqual(h.shell.getDiagnostics().shell.detail, {
bbox: [-92, 39, -86, 42],
size: { width: 4096, height: 2048 },
ready: false,
enabled: true,
});
await flush();
assert.equal(query(h.fetches[2].url).get('bbox'), '-92,39,-86,42');
assert.equal(uniforms.detail.source, h.decoded[2]);
assert.deepEqual(windowOf(shell), NONE, 'until the new image has drawn');
assert.equal(h.shell.getDiagnostics().shell.detail.ready, false);
h.render();
assert.deepEqual(windowOf(shell), windowFor(box(-92, 39, -86, 42)));
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
view.look(-120, 25, -100, 50);
assert.equal(
uniforms.detail,
Cesium.Material.DefaultImageId,
'a wide view needs no window',
);
assert.deepEqual(windowOf(shell), NONE);
assert.deepEqual(h.shell.getDiagnostics().shell.detail, {
bbox: null,
size: { width: 4096, height: 2048 },
ready: false,
enabled: false,
});
await flush();
assert.equal(h.fetches.length, 3);
assert.deepEqual(h.primitives(), [shell]);
assert.equal(h.shell.getDiagnostics().imageryCount, 1);
h.shell.clear();
assert.equal(view.moveEnd.size, 0);
});
test('a new extent restages the surface and the detail follows onto it', async () => {
const h = harness({ camera: camera(-100, 35, -98, 36) });
assert.equal(await show(h, times[0]), true);
await flush();
h.render();
const [first] = h.primitives();
const detail = first.appearance.material.uniforms.detail;
const wider = { ...bounds, west: -140 };
const pending = h.shell.setFrame(
snapshot('radar', { bounds: wider }),
times[0],
);
await flush();
const [, second] = h.primitives();
assert.equal(
second.appearance.material.uniforms.detail,
Cesium.Material.DefaultImageId,
);
assert.equal(h.shell.getDiagnostics().imageryCount, 2, 'staged, no detail');
h.render();
assert.equal(await pending, true);
assert.deepEqual(h.primitives(), [second]);
assert.equal(first.destroyed, true);
assert.equal(second.appearance.material.uniforms.detail, detail);
assert.deepEqual(windowOf(second), NONE, 'a new mesh uploads it first');
h.render();
const x = (edge) => (edge - wider.west) / (wider.east - wider.west);
assert.deepEqual(windowOf(second), {
x: x(-102),
y: windowFor(box(-102, 34, -96, 37)).y,
z: x(-96),
w: windowFor(box(-102, 34, -96, 37)).w,
});
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
h.shell.clear();
});
test('a new frame swaps the full-extent image first and keeps the detail until its own image decodes', async () => {
const view = camera(-100, 35, -98, 36);
const urls = [];
let gate = null;
let offline = false;
const h = harness({
camera: view,
fetchImpl: async (url) => {
urls.push(url);
if (offline && url.includes('bbox=')) throw new Error('offline');
return response();
},
decodeImage: async () => {
if (gate && urls.at(-1).includes('bbox=')) await gate.promise;
return { width: 4096, height: 2048, close() {} };
},
});
assert.equal(await show(h, times[0]), true);
await flush();
h.render();
const [shell] = h.primitives();
const { uniforms } = shell.appearance.material;
const previous = { image: uniforms.image, detail: uniforms.detail };
const applied = uniforms.window;
gate = deferred();
assert.equal(await h.shell.setFrame(snapshot(), times[1]), true);
await flush();
assert.notEqual(uniforms.image, previous.image);
assert.equal(h.shell.getDiagnostics().time, times[1]);
assert.equal(query(urls.at(-1)).get('time'), times[1]);
assert.equal(query(urls.at(-1)).get('bbox'), '-102,34,-96,37');
assert.equal(uniforms.detail, previous.detail, 'the previous detail stays');
assert.equal(uniforms.window, applied);
assert.equal(h.shell.getDiagnostics().shell.detail.ready, false);
gate.resolve();
await flush();
assert.notEqual(uniforms.detail, previous.detail);
assert.equal(
uniforms.window,
applied,
'the same window swaps only the image',
);
h.render();
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
gate = null;
offline = true;
assert.equal(await h.shell.setFrame(snapshot(), times[2]), true);
await flush();
assert.equal(
uniforms.detail,
Cesium.Material.DefaultImageId,
'a failed detail leaves no older one over the frame',
);
assert.deepEqual(windowOf(shell), NONE);
assert.equal(h.shell.getDiagnostics().time, times[2]);
assert.equal(h.shell.getDiagnostics().error, null);
h.shell.clear();
});
test('an older detail stays over at most one newer frame; a warmed detail follows every frame', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const all = Array.from({ length: 5 }, (_, i) =>
new Date(Date.parse(times[0]) + i * 300_000).toISOString(),
);
const playback = snapshot('radar', { times: all, latest: all.at(-1) });
const rect = windowFor(box(-102, 34, -96, 37));
const advance = async (h, time) => {
const pending = h.shell.setFrame(playback, time);
await flush();
h.render();
assert.equal(await pending, true);
await flush();
};
const requests = [];
let slow = false;
const h = harness({
camera: camera(-100, 35, -98, 36),
fetchImpl: async (url, init) => {
requests.push({ url, signal: init.signal });
return response();
},
decodeImage: async () =>
slow && requests.at(-1).url.includes('bbox=')
? new Promise(() => {})
: { width: 4096, height: 2048, close() {} },
});
await advance(h, all[0]);
h.render();
const [shell] = h.primitives();
const { uniforms } = shell.appearance.material;
const first = uniforms.detail;
assert.deepEqual(windowOf(shell), rect);
slow = true;
await advance(h, all[1]);
assert.equal(uniforms.detail, first, 'over one newer frame');
assert.deepEqual(windowOf(shell), rect);
assert.equal(h.shell.getDiagnostics().shell.detail.ready, false);
await advance(h, all[2]);
assert.equal(
uniforms.detail,
Cesium.Material.DefaultImageId,
'cleared at the second',
);
assert.deepEqual(windowOf(shell), NONE);
for (const time of all.slice(3)) {
await advance(h, time);
assert.equal(uniforms.detail, Cesium.Material.DefaultImageId);
assert.deepEqual(windowOf(shell), NONE);
}
const details = requests.filter(({ url }) => url.includes('bbox='));
assert.deepEqual(
details.map(({ url }) => query(url).get('time')),
all,
);
assert.ok(
details.slice(1, -1).every(({ signal }) => signal.aborted),
'each newer frame replaces the pending detail',
);
assert.equal(details.at(-1).signal.aborted, false);
h.shell.clear();
const warm = harness({ camera: camera(-100, 35, -98, 36) });
await advance(warm, all[0]);
warm.render();
const [surface] = warm.primitives();
const material = surface.appearance.material;
const applied = material.uniforms.window;
assert.deepEqual(windowOf(surface), rect);
for (const time of all.slice(1)) {
assert.equal(await warm.shell.prefetch(playback, time), true);
const fetches = warm.fetches.length;
const previous = material.uniforms.detail;
await advance(warm, time);
assert.equal(warm.fetches.length, fetches, 'both images from the cache');
assert.notEqual(material.uniforms.detail, previous, time);
assert.equal(material.uniforms.window, applied, 'the window never empties');
assert.equal(warm.shell.getDiagnostics().shell.detail.ready, true);
}
warm.shell.clear();
});
test('hiding, a host without imagery and clear hide or release the detail with its surface', async (t) => {
t.mock.timers.enable({ apis: ['setTimeout'] });
const view = camera(-100, 35, -98, 36);
const h = harness({ camera: view });
assert.equal(await show(h, times[0]), true);
await flush();
h.render();
const [shell] = h.primitives();
const rect = windowFor(box(-102, 34, -96, 37));
h.shell.setHidden(true);
assert.equal(shell.show, false);
assert.deepEqual(windowOf(shell), rect, 'the detail hides with its surface');
assert.equal(h.shell.getDiagnostics().shell.detail.ready, false);
h.shell.setHidden(false);
assert.equal(shell.show, true);
assert.deepEqual(windowOf(shell), rect);
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
h.shell.setAlpha(0.4);
assert.equal(shell.appearance.material.uniforms.alpha, 0.4);
h.setHost({ collection: null, kind: 'none' });
h.shell.rehome();
assert.equal(shell.show, false);
view.look(-90, 40, -88, 41);
await flush();
assert.equal(h.fetches.length, 2, 'no window work without a host');
assert.deepEqual(windowOf(shell), NONE, 'the moved window is dropped');
h.setHost({ collection: null, kind: 'tileset' });
h.shell.rehome();
await flush();
assert.equal(query(h.fetches[2].url).get('bbox'), '-92,39,-86,42');
h.render();
assert.deepEqual(windowOf(shell), windowFor(box(-92, 39, -86, 42)));
assert.deepEqual(h.primitives(), [shell]);
// Frames shown while hidden leave no older detail to reappear.
h.shell.setHidden(true);
for (const time of [times[1], times[2]])
assert.equal(await h.shell.setFrame(snapshot(), time), true);
h.shell.setHidden(false);
assert.equal(
shell.appearance.material.uniforms.detail,
Cesium.Material.DefaultImageId,
);
await flush();
assert.equal(query(h.fetches.at(-1).url).get('time'), times[2]);
h.render();
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
h.shell.clear();
assert.equal(shell.destroyed, true);
assert.equal(shell.appearance.material.destroyed, true);
assert.equal(view.moveEnd.size, 0);
assert.equal(h.scene.postRender.size, 0);
assert.deepEqual(h.shell.getDiagnostics().cache, {
mosaics: 0,
bytes: 0,
prefetching: false,
});
// A detail image still decoding is abandoned, never installed.
const gate = deferred();
const requests = [];
const late = harness({
camera: camera(-100, 35, -98, 36),
fetchImpl: async (url, init) => {
requests.push({ url, signal: init.signal });
return response();
},
decodeImage: async () => {
if (requests.at(-1).url.includes('bbox=')) await gate.promise;
return { width: 4096, height: 2048, close() {} };
},
});
assert.equal(await show(late, times[0]), true);
await flush();
assert.equal(requests.length, 2);
late.shell.clear();
assert.equal(requests[1].signal.aborted, true);
gate.resolve();
await flush();
assert.equal(late.primitives().length, 0);
assert.equal(late.shell.getDiagnostics().cache.mosaics, 0);
t.mock.timers.tick(30_000);
assert.equal(h.primitives().length, 0);
});
test('full-extent and detail images share one byte budget; prefetch warms both', async () => {
const view = camera(-100, 35, -98, 36);
const h = harness({ camera: view });
const MiB = 1024 * 1024;
assert.equal(await show(h, times[0]), true);
await flush();
h.render();
assert.deepEqual(h.shell.getDiagnostics().cache, {
mosaics: 2,
bytes: 64 * MiB,
prefetching: false,
});
assert.equal(await h.shell.prefetch(snapshot(), times[1]), true);
assert.deepEqual(
h.fetches
.slice(2)
.map(({ url }) => [query(url).get('time'), query(url).get('bbox')]),
[
[times[1], null],
[times[1], '-102,34,-96,37'],
],
);
assert.equal(
h.shell.getDiagnostics().cache.bytes,
128 * MiB,
'the shown pair and the warmed pair stay',
);
assert.equal(
await h.shell.prefetch(snapshot(), times[1]),
false,
'completed work is not repeated',
);
assert.equal(await show(h, times[1]), true);
await flush();
h.render();
assert.equal(h.fetches.length, 4, 'both images came from the cache');
assert.equal(h.shell.getDiagnostics().mosaic.cached, true);
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
assert.deepEqual(h.shell.getDiagnostics().cache, {
mosaics: 4,
bytes: 128 * MiB,
prefetching: false,
});
// After a prefetch the cache holds the shown pair and the warmed pair only.
assert.equal(await h.shell.prefetch(snapshot(), times[2]), true);
assert.equal(h.fetches.length, 6);
assert.deepEqual(h.shell.getDiagnostics().cache, {
mosaics: 4,
bytes: 128 * MiB,
prefetching: false,
});
for (const time of [times[2], times[1]]) {
assert.equal(await show(h, time), true);
await flush();
h.render();
assert.equal(h.fetches.length, 6, `${time} full-extent and detail cached`);
assert.equal(h.shell.getDiagnostics().shell.detail.ready, true);
}
assert.equal(await show(h, times[0]), true);
await flush();
assert.equal(h.fetches.length, 8, 'nothing older survived the prefetch');
assert.equal(h.shell.getDiagnostics().cache.bytes, 128 * MiB);
h.shell.clear();
const wide = harness({ camera: camera(-120, 25, -100, 50) });
assert.equal(await show(wide, times[0]), true);
assert.equal(await wide.shell.prefetch(snapshot(), times[1]), true);
assert.equal(wide.fetches.length, 2, 'no window, no detail prefetch');
assert.ok(wide.fetches.every(({ url }) => !url.includes('bbox=')));
wide.shell.clear();
});
test('global infrared keeps one full-extent image; detail images halve for small texture limits', async () => {
const view = camera(-100, 35, -98, 36);
const clouds = harness({ product: 'clouds', camera: view });
assert.equal(await show(clouds, times[0]), true);
await flush();
assert.equal(view.moveEnd.size, 0);
assert.equal(clouds.fetches.length, 1);
assert.equal(clouds.shell.getDiagnostics().shell.detail.enabled, false);
assert.equal(await clouds.shell.prefetch(snapshot('clouds'), times[1]), true);
assert.ok(clouds.fetches.every(({ url }) => !url.includes('bbox=')));
clouds.shell.clear();
const small = harness({
camera: camera(-100, 35, -98, 36),
cesium: createShellCesium({ maximumTextureSize: 2048 }),
decodeImage: async () => ({ width: 2048, height: 1024, close() {} }),
});
assert.equal(await show(small, times[0]), true);
await flush();
small.render();
assert.equal(query(small.fetches[1].url).get('size'), '2048x1024');
assert.equal(query(small.fetches[1].url).get('bbox'), '-102,34,-96,37');
assert.deepEqual(small.shell.getDiagnostics().shell.detail, {
bbox: [-102, 34, -96, 37],
size: { width: 2048, height: 1024 },
ready: true,
enabled: true,
});
small.shell.clear();
});