mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Draw the weather and wind imagery through the renderer's globe port
Radar, satellite clouds and lightning frames are imagery layers of the globe port instead of Cesium providers in the viewer's collection. A frame stages as a transparent layer on the globe's surface and counts its tiles through the layer's admit hook; the global infrared mosaic draws each tile of the geographic grid from the decoded canvas, the regional infrared transfer runs as the layer's tile transform on the upright tile, and throttled tiles are fetched again by the renderer. Readiness reads the port's imagery settling, the camera port gives the view and its move end, and the frame's credit, which a refreshed manifest can still change in place, is owed through the credits port while the layer is shown. Without a host the shown frame is hidden rather than detached. Wind's colour field is a port layer too, so the draw order is a zOrder per product (wind, infrared, radar, lightning), above the port's other imagery, and the raise-to-top helper goes. The Cesium port keeps a tile transform's bitmaps in straight alpha and closes the copies it spends, and a provider that fails to build is told as an error of its root tile. The weather rendering and raster tile modules no longer reach Cesium and leave the allow-list; the 3D Tiles shell still does.
This commit is contained in:
1 parent
9e1f9a1c3d
commit
76880f6eae
15 files changed
+735
-721
No files matched your search
@@ -140,14 +140,3 @@ export function insideExtent({ west, south, east, north }, lon, lat) {
|
||||
if (lat < south || lat > north) return false;
|
||||
return west < east ? lon >= west && lon <= east : lon >= west || lon <= east;
|
||||
}
|
||||
|
||||
/** Plain text for a Cesium credit, which otherwise reads its text as HTML. */
|
||||
export function escapeCreditText(value) {
|
||||
return value.replace(
|
||||
/[&<>"']/g,
|
||||
(ch) =>
|
||||
({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' })[
|
||||
ch
|
||||
],
|
||||
);
|
||||
}
|
||||
@@ -1,11 +1,11 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { GeographicTilingScheme } from 'cesium';
|
||||
import { createWeatherLayer } from './index.js';
|
||||
import { createWeatherRendering } from './rendering.js';
|
||||
import { weatherDisplay, insideExtent, escapeCreditText } from './display.js';
|
||||
import { createShellCesium, createShellScene } from './shellFixture.mjs';
|
||||
import { weatherDisplay, insideExtent } from './display.js';
|
||||
import { createShellScene } from './shellFixture.mjs';
|
||||
import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs';
|
||||
import { formatScaleLabel } from '../../ui/unitLabels.js';
|
||||
import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs';
|
||||
|
||||
@@ -581,10 +581,6 @@ test('display validation bounds text, legend shape, colours and extents', () =>
|
||||
assert.equal(insideExtent(wrap.extent, -100, 10), true);
|
||||
assert.equal(insideExtent(wrap.extent, 50, 10), false);
|
||||
assert.equal(insideExtent(wrap.extent, -100, 81), false);
|
||||
assert.equal(
|
||||
escapeCreditText(`<b>"A" & 'B'</b>`),
|
||||
'<b>"A" & 'B'</b>',
|
||||
);
|
||||
});
|
||||
|
||||
function mockCanvas() {
|
||||
@@ -598,35 +594,11 @@ function mockCanvas() {
|
||||
return canvas;
|
||||
}
|
||||
|
||||
/** A globe viewer whose imagery collection records providers. */
|
||||
/** A globe viewer whose globe port records the layers added. */
|
||||
function globeViewer() {
|
||||
const providers = [];
|
||||
const layers = [];
|
||||
const collection = {
|
||||
addImageryProvider(provider) {
|
||||
providers.push(provider);
|
||||
const layer = { imageryProvider: provider, alpha: 1, show: true };
|
||||
layers.push(layer);
|
||||
return layer;
|
||||
},
|
||||
contains: (layer) => layers.includes(layer),
|
||||
remove(layer) {
|
||||
layers.splice(layers.indexOf(layer), 1);
|
||||
return true;
|
||||
},
|
||||
get length() {
|
||||
return layers.length;
|
||||
},
|
||||
get: (index) => layers[index],
|
||||
indexOf: (layer) => layers.indexOf(layer),
|
||||
lower() {},
|
||||
raise() {},
|
||||
raiseToTop() {},
|
||||
isDestroyed: () => false,
|
||||
};
|
||||
const listeners = new Set();
|
||||
const viewer = {
|
||||
imageryLayers: collection,
|
||||
imageryLayers: {},
|
||||
camera: {
|
||||
moveEnd: { addEventListener: () => () => {} },
|
||||
flyTo() {},
|
||||
@@ -644,26 +616,20 @@ function globeViewer() {
|
||||
},
|
||||
};
|
||||
bindFakeCesiumCamera(viewer);
|
||||
class Provider {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
this.tilingScheme = new GeographicTilingScheme();
|
||||
this.errorEvent = new Cesium.Event();
|
||||
}
|
||||
requestImage() {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
const cesium = {
|
||||
...createShellCesium(),
|
||||
UrlTemplateImageryProvider: Provider,
|
||||
GeographicTilingScheme,
|
||||
Event: Cesium.Event,
|
||||
Credit: Cesium.Credit,
|
||||
Rectangle: Cesium.Rectangle,
|
||||
const globe = fakeGlobePort();
|
||||
const owed = [];
|
||||
const credits = {
|
||||
addStatic(credit) {
|
||||
const entry = { ...credit };
|
||||
owed.push(entry);
|
||||
return () => owed.splice(owed.indexOf(entry), 1);
|
||||
},
|
||||
};
|
||||
const options = {
|
||||
cesium,
|
||||
globeOf: () => globe,
|
||||
creditsOf: () => credits,
|
||||
cameraOf: () => null,
|
||||
toBitmap: (canvas) => canvas,
|
||||
fetchImpl: async () => ({
|
||||
ok: true,
|
||||
headers: new Headers(),
|
||||
@@ -677,7 +643,7 @@ function globeViewer() {
|
||||
for (let i = 0; i < 2; i++) for (const fn of [...listeners]) fn();
|
||||
await flush();
|
||||
};
|
||||
return { viewer, providers, options, settle };
|
||||
return { viewer, providers: globe.added, owed, options, settle };
|
||||
}
|
||||
|
||||
/** Show a frame of `manifest` and return the rendering and its globe. */
|
||||
@@ -693,7 +659,8 @@ async function shownFrame(manifest) {
|
||||
return { ...globe, rendering };
|
||||
}
|
||||
|
||||
const creditOf = (providers) => providers.at(-1).credit.html;
|
||||
/** The credit the shown frame owes. */
|
||||
const creditOf = (h) => h.owed.at(-1)?.text;
|
||||
|
||||
test('the imagery credit uses the source credit as plain text, else the built-in one', async () => {
|
||||
for (const product of ['radar', 'lightning', 'clouds-regional', 'clouds']) {
|
||||
@@ -703,7 +670,7 @@ test('the imagery credit uses the source credit as plain text, else the built-in
|
||||
product,
|
||||
...(display ? { display } : {}),
|
||||
});
|
||||
assert.equal(creditOf(h.providers), BUILT_IN[product].credit, product);
|
||||
assert.equal(creditOf(h), BUILT_IN[product].credit, product);
|
||||
h.rendering.clear();
|
||||
}
|
||||
const h = await shownFrame({
|
||||
@@ -712,8 +679,9 @@ test('the imagery credit uses the source credit as plain text, else the built-in
|
||||
display: { credit: 'Example <network> & partners' },
|
||||
});
|
||||
assert.equal(
|
||||
creditOf(h.providers),
|
||||
'Example <network> & partners',
|
||||
creditOf(h),
|
||||
'Example <network> & partners',
|
||||
'plain text: the credits port escapes it',
|
||||
);
|
||||
h.rendering.clear();
|
||||
}
|
||||
@@ -726,7 +694,7 @@ test('a refreshed manifest updates the credit of the frame already shown', async
|
||||
product,
|
||||
display: { credit: 'First credit' },
|
||||
});
|
||||
assert.equal(creditOf(h.providers), 'First credit');
|
||||
assert.equal(creditOf(h), 'First credit');
|
||||
const again = (display) =>
|
||||
h.rendering.setFrame(
|
||||
{ ...base, product, ...(display ? { display } : {}) },
|
||||
@@ -734,22 +702,22 @@ test('a refreshed manifest updates the credit of the frame already shown', async
|
||||
);
|
||||
assert.equal(await again({ credit: 'Second credit' }), true);
|
||||
assert.equal(h.providers.length, 1, 'the frame is not restaged');
|
||||
assert.equal(creditOf(h.providers), 'Second credit');
|
||||
assert.equal(creditOf(h), 'Second credit');
|
||||
assert.equal(await again(), true);
|
||||
assert.equal(creditOf(h.providers), BUILT_IN[product].credit);
|
||||
assert.equal(creditOf(h), BUILT_IN[product].credit);
|
||||
h.rendering.updateSnapshot({
|
||||
...base,
|
||||
product,
|
||||
display: { credit: 'Third credit' },
|
||||
});
|
||||
assert.equal(creditOf(h.providers), 'Third credit');
|
||||
assert.equal(creditOf(h), 'Third credit');
|
||||
// Another product's manifest leaves this frame alone.
|
||||
h.rendering.updateSnapshot({
|
||||
...base,
|
||||
product: 'radar',
|
||||
display: { credit: 'Other' },
|
||||
});
|
||||
assert.equal(creditOf(h.providers), 'Third credit');
|
||||
assert.equal(creditOf(h), 'Third credit');
|
||||
h.rendering.clear();
|
||||
}
|
||||
});
|
||||
@@ -790,7 +758,7 @@ test('a refreshed manifest leaves the shown snapshot for a host switch to restag
|
||||
display: { credit: 'Second credit' },
|
||||
};
|
||||
rendering.updateSnapshot(refreshed);
|
||||
assert.equal(creditOf(globe.providers), 'Second credit');
|
||||
assert.equal(creditOf(globe), 'Second credit');
|
||||
host = { collection: {}, kind: 'tileset' };
|
||||
assert.equal(rendering.rehome(), true);
|
||||
await flush();
|
||||
@@ -799,15 +767,12 @@ test('a refreshed manifest leaves the shown snapshot for a host switch to restag
|
||||
assert.equal(rendering.rehome(), true);
|
||||
await globe.settle();
|
||||
assert.equal(globe.providers.length, 2);
|
||||
const { west, south, east, north } = first.bounds;
|
||||
assert.ok(
|
||||
Cesium.Rectangle.equals(
|
||||
globe.providers.at(-1).options.rectangle,
|
||||
Cesium.Rectangle.fromDegrees(west, south, east, north),
|
||||
),
|
||||
assert.deepEqual(
|
||||
globe.providers.at(-1).spec.rectangle,
|
||||
first.bounds,
|
||||
'the restaged frame keeps the bounds it was staged from',
|
||||
);
|
||||
assert.equal(creditOf(globe.providers), 'Second credit');
|
||||
assert.equal(creditOf(globe), 'Second credit');
|
||||
rendering.clear();
|
||||
});
|
||||
|
||||
@@ -847,7 +812,7 @@ test('a refresh during a host-switch restage keeps the newest credit', async ()
|
||||
rendering.updateSnapshot({ ...first, display: { credit: 'Third credit' } });
|
||||
await globe.settle();
|
||||
assert.equal(globe.providers.length, 2);
|
||||
assert.equal(creditOf(globe.providers), 'Third credit');
|
||||
assert.equal(creditOf(globe), 'Third credit');
|
||||
rendering.clear();
|
||||
});
|
||||
|
||||
@@ -879,7 +844,7 @@ test('a refresh while a frame loads survives a later host switch', async () => {
|
||||
rendering.updateSnapshot({ ...first, display: { credit: 'Second credit' } });
|
||||
await globe.settle();
|
||||
assert.equal(await shown, true);
|
||||
assert.equal(creditOf(globe.providers), 'Second credit');
|
||||
assert.equal(creditOf(globe), 'Second credit');
|
||||
host = { collection: {}, kind: 'tileset' };
|
||||
assert.equal(rendering.rehome(), true);
|
||||
await flush();
|
||||
@@ -887,7 +852,7 @@ test('a refresh while a frame loads survives a later host switch', async () => {
|
||||
assert.equal(rendering.rehome(), true);
|
||||
await globe.settle();
|
||||
assert.equal(globe.providers.length, 2);
|
||||
assert.equal(creditOf(globe.providers), 'Second credit');
|
||||
assert.equal(creditOf(globe), 'Second credit');
|
||||
rendering.clear();
|
||||
});
|
||||
|
||||
@@ -906,7 +871,7 @@ test('a refresh before a frame is installed gives it the newest credit', async (
|
||||
});
|
||||
await globe.settle();
|
||||
assert.equal(await shown, true);
|
||||
assert.equal(creditOf(globe.providers), 'Second credit', product);
|
||||
assert.equal(creditOf(globe), 'Second credit', product);
|
||||
rendering.clear();
|
||||
}
|
||||
});
|
||||
@@ -933,13 +898,13 @@ test('a layer refresh with the same latest frame updates the imagery credit', as
|
||||
const first = layer.update();
|
||||
await globe.settle();
|
||||
await first;
|
||||
assert.equal(creditOf(globe.providers), 'First credit');
|
||||
assert.equal(creditOf(globe), 'First credit');
|
||||
manifest = { ...manifest, display: { credit: 'Second credit' } };
|
||||
await layer.update();
|
||||
assert.equal(globe.providers.length, 1, 'the frame is not restaged');
|
||||
assert.equal(creditOf(globe.providers), 'Second credit');
|
||||
assert.equal(creditOf(globe), 'Second credit');
|
||||
manifest = { ...base, product: 'lightning' };
|
||||
await layer.update();
|
||||
assert.equal(creditOf(globe.providers), BUILT_IN.lightning.credit);
|
||||
assert.equal(creditOf(globe), BUILT_IN.lightning.credit);
|
||||
layer.destroy();
|
||||
});
|
||||
@@ -1,17 +1,12 @@
|
||||
const priorities = new WeakMap();
|
||||
|
||||
/** Scalar context, infrared, radar, then lightning: independent of enable order. */
|
||||
export function orderWeatherImagery(collection, layer, priority) {
|
||||
priorities.set(layer, priority);
|
||||
if (typeof collection.raiseToTop !== 'function') return;
|
||||
const weather = [];
|
||||
for (let i = 0; i < collection.length; i++) {
|
||||
const item = collection.get(i);
|
||||
if (priorities.has(item)) weather.push(item);
|
||||
}
|
||||
const ordered = [...weather].sort(
|
||||
(a, b) => priorities.get(a) - priorities.get(b),
|
||||
);
|
||||
if (weather.every((item, i) => item === ordered[i])) return;
|
||||
for (const item of ordered) collection.raiseToTop(item);
|
||||
}
|
||||
/**
|
||||
* Draw order of the weather imagery through the globe port: scalar context
|
||||
* (wind), infrared, radar, then lightning, independent of enable order, and
|
||||
* above the port's other layers (zOrder 0).
|
||||
*/
|
||||
export const WEATHER_IMAGERY_Z = Object.freeze({
|
||||
wind: 1,
|
||||
clouds: 2,
|
||||
'clouds-regional': 2,
|
||||
radar: 3,
|
||||
lightning: 4,
|
||||
});
|
||||
@@ -1,72 +1,28 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { orderWeatherImagery } from './imageryOrder.js';
|
||||
import { WEATHER_IMAGERY_Z } from './imageryOrder.js';
|
||||
import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs';
|
||||
|
||||
test('weather compositing remains consistent when scalar, observation and history arrive out of order', () => {
|
||||
const base = { name: 'basemap' },
|
||||
radar = { name: 'radar' },
|
||||
cloud = { name: 'cloud' },
|
||||
wind = { name: 'wind' },
|
||||
lightning = { name: 'lightning' };
|
||||
const items = [base];
|
||||
const collection = {
|
||||
get length() {
|
||||
return items.length;
|
||||
},
|
||||
get: (i) => items[i],
|
||||
raiseToTop(layer) {
|
||||
items.push(...items.splice(items.indexOf(layer), 1));
|
||||
},
|
||||
};
|
||||
for (const [layer, priority] of [
|
||||
[radar, 2],
|
||||
[cloud, 1],
|
||||
[lightning, 3],
|
||||
[wind, 0],
|
||||
]) {
|
||||
items.push(layer);
|
||||
orderWeatherImagery(collection, layer, priority);
|
||||
}
|
||||
assert.deepEqual(items, [base, wind, cloud, radar, lightning]);
|
||||
const next = { name: 'new radar history frame' };
|
||||
items.push(next);
|
||||
orderWeatherImagery(collection, next, 2);
|
||||
assert.deepEqual(items, [base, wind, cloud, radar, next, lightning]);
|
||||
});
|
||||
|
||||
test('tileset imagery collection preserves scalar, infrared, radar and lightning order', async () => {
|
||||
const { ImageryLayerCollection, ImageryLayer } = await import('cesium');
|
||||
const tileset = { imageryLayers: new ImageryLayerCollection() };
|
||||
const layers = Array.from({ length: 4 }, () => new ImageryLayer());
|
||||
for (const priority of [3, 2, 0, 1]) {
|
||||
tileset.imageryLayers.add(layers[priority]);
|
||||
orderWeatherImagery(tileset.imageryLayers, layers[priority], priority);
|
||||
}
|
||||
assert.deepEqual(
|
||||
layers.map((_, i) => tileset.imageryLayers.get(i)),
|
||||
layers,
|
||||
);
|
||||
tileset.imageryLayers.destroy();
|
||||
});
|
||||
|
||||
test('already ordered imagery adds and repeated ordering cause no collection churn', () => {
|
||||
const items = [];
|
||||
let raises = 0;
|
||||
const collection = {
|
||||
get length() {
|
||||
return items.length;
|
||||
},
|
||||
get: (i) => items[i],
|
||||
raiseToTop(layer) {
|
||||
raises++;
|
||||
items.push(...items.splice(items.indexOf(layer), 1));
|
||||
},
|
||||
};
|
||||
for (const priority of [0, 1, 1, 2, 3]) {
|
||||
const layer = {};
|
||||
items.push(layer);
|
||||
orderWeatherImagery(collection, layer, priority);
|
||||
orderWeatherImagery(collection, layer, priority);
|
||||
}
|
||||
assert.equal(raises, 0);
|
||||
test('wind, infrared, radar, then lightning, above zOrder 0, whatever the enable order', () => {
|
||||
const globe = fakeGlobePort();
|
||||
const add = (name) =>
|
||||
globe.imagery.add({
|
||||
kind: 'xyz',
|
||||
url: `https://${name}.invalid/{z}/{x}/{y}`,
|
||||
zOrder: WEATHER_IMAGERY_Z[name],
|
||||
});
|
||||
const lightning = add('lightning');
|
||||
const overlay = globe.imagery.add({ kind: 'xyz', url: 'https://o.invalid' });
|
||||
const radar = add('radar');
|
||||
const wind = add('wind');
|
||||
const clouds = add('clouds');
|
||||
const regional = add('clouds-regional');
|
||||
assert.deepEqual(globe.layers, [
|
||||
overlay,
|
||||
wind,
|
||||
clouds,
|
||||
regional,
|
||||
radar,
|
||||
lightning,
|
||||
]);
|
||||
});
|
||||
@@ -1,5 +1,6 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import { createWeatherRendering } from './rendering.js';
|
||||
import { createWeatherShell } from './shellRendering.js';
|
||||
import { imageryHostStatus } from './imageryHost.js';
|
||||
import { weatherDisplay, insideExtent } from './display.js';
|
||||
import {
|
||||
@@ -284,7 +285,7 @@ export function createWeatherLayer({
|
||||
viewer = nextViewer;
|
||||
rendering = createRendering({
|
||||
viewer,
|
||||
cesium,
|
||||
createShell: (options) => createWeatherShell({ ...options, cesium }),
|
||||
getHost,
|
||||
onChange: notify,
|
||||
});
|
||||
|
||||
@@ -1,50 +1,29 @@
|
||||
/** Tile a bounded decoded canvas without network requests or scene state. */
|
||||
export function createRasterTileProvider({
|
||||
cesium,
|
||||
texture,
|
||||
credit,
|
||||
createCanvas,
|
||||
rectangle = cesium.Rectangle.MAX_VALUE,
|
||||
tilingScheme = new cesium.GeographicTilingScheme({ rectangle }),
|
||||
maximumLevel = 2,
|
||||
tileSize = 256,
|
||||
}) {
|
||||
return {
|
||||
tilingScheme,
|
||||
rectangle,
|
||||
tileWidth: tileSize,
|
||||
tileHeight: tileSize,
|
||||
minimumLevel: 0,
|
||||
maximumLevel,
|
||||
ready: true,
|
||||
tileDiscardPolicy: undefined,
|
||||
credit,
|
||||
errorEvent: new cesium.Event(),
|
||||
hasAlphaChannel: true,
|
||||
getTileCredits: () => undefined,
|
||||
pickFeatures: () => undefined,
|
||||
requestImage(x, y, level) {
|
||||
const tile = createCanvas();
|
||||
tile.width = tile.height = tileSize;
|
||||
const ctx = tile.getContext('2d');
|
||||
const width =
|
||||
texture.width / tilingScheme.getNumberOfXTilesAtLevel(level);
|
||||
const height =
|
||||
texture.height / tilingScheme.getNumberOfYTilesAtLevel(level);
|
||||
ctx.imageSmoothingEnabled = true;
|
||||
ctx.drawImage(
|
||||
texture,
|
||||
x * width,
|
||||
y * height,
|
||||
width,
|
||||
height,
|
||||
0,
|
||||
0,
|
||||
tileSize,
|
||||
tileSize,
|
||||
);
|
||||
// ImageryLayer consumes requestImage results as promises.
|
||||
return Promise.resolve(tile);
|
||||
},
|
||||
};
|
||||
/**
|
||||
* Draw one tile of the geographic scheme (two level-zero tiles) from a
|
||||
* decoded mosaic covering `bounds` (degrees), without network requests or
|
||||
* scene state. The part of a tile outside the mosaic stays transparent.
|
||||
* @param {CanvasImageSource & {width: number, height: number}} texture
|
||||
* @param {{west: number, south: number, east: number, north: number}} bounds
|
||||
* @param {{x: number, y: number, level: number}} tile
|
||||
* @param {HTMLCanvasElement} canvas Sized to the tile.
|
||||
*/
|
||||
export function drawMosaicTile(texture, bounds, { x, y, level }, canvas) {
|
||||
const size = 180 / 2 ** level;
|
||||
const west = -180 + x * size;
|
||||
const north = 90 - y * size;
|
||||
const perLon = texture.width / (bounds.east - bounds.west);
|
||||
const perLat = texture.height / (bounds.north - bounds.south);
|
||||
const ctx = canvas.getContext('2d');
|
||||
ctx.imageSmoothingEnabled = true;
|
||||
ctx.drawImage(
|
||||
texture,
|
||||
(west - bounds.west) * perLon,
|
||||
(bounds.north - north) * perLat,
|
||||
size * perLon,
|
||||
size * perLat,
|
||||
0,
|
||||
0,
|
||||
canvas.width,
|
||||
canvas.height,
|
||||
);
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { createRasterTileProvider } from './rasterTiles.js';
|
||||
import { drawMosaicTile } from './rasterTiles.js';
|
||||
import { createFieldRaster } from '../wind/fields.js';
|
||||
|
||||
// A small canvas double exposes the uploaded raster and exact drawImage crop.
|
||||
@@ -31,7 +30,17 @@ function createCanvas() {
|
||||
return canvas;
|
||||
}
|
||||
|
||||
test('real Cesium geographic provider crops level 0/1 tiles from a decoded canvas with preserved pixels', async () => {
|
||||
/** A tile canvas of `size`, drawn by `drawMosaicTile`. */
|
||||
function drawTile(texture, bounds, tile, size = 256) {
|
||||
const canvas = createCanvas();
|
||||
canvas.width = canvas.height = size;
|
||||
drawMosaicTile(texture, bounds, tile, canvas);
|
||||
return canvas;
|
||||
}
|
||||
|
||||
const WORLD = { west: -180, south: -90, east: 180, north: 90 };
|
||||
|
||||
test('a world mosaic crops level 0/1 geographic tiles with preserved pixels', () => {
|
||||
const raster = createFieldRaster(
|
||||
{
|
||||
nx: 8,
|
||||
@@ -50,42 +59,18 @@ test('real Cesium geographic provider crops level 0/1 tiles from a decoded canva
|
||||
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);
|
||||
const tile = drawTile(texture, WORLD, { x, y, level });
|
||||
assert.equal(tile.getContext('2d').imageSmoothingEnabled, true);
|
||||
assert.deepEqual(tile.crop, crop);
|
||||
const offset = (cell[1] * 720 + cell[0]) * 4;
|
||||
@@ -96,60 +81,29 @@ test('real Cesium geographic provider crops level 0/1 tiles from a decoded canva
|
||||
}
|
||||
});
|
||||
|
||||
test('bounded decoded mosaic crops both roots and higher levels without resampling its extent', async () => {
|
||||
test('a bounded mosaic maps each tile by degrees; outside it stays clear', () => {
|
||||
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);
|
||||
const bounds = { west: -180, south: -60, east: 180, north: 60 };
|
||||
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]],
|
||||
// 180° square tiles reach past the mosaic's 60° edges.
|
||||
[0, 0, 0, [0, -256, 1024, 1536, 0, 0, 256, 256]],
|
||||
[1, 0, 0, [1024, -256, 1024, 1536, 0, 0, 256, 256]],
|
||||
[7, 1, 2, [1792, 128, 256, 384, 0, 0, 256, 256]],
|
||||
]) {
|
||||
const pending = provider.requestImage(x, y, level);
|
||||
assert.ok(pending instanceof Promise);
|
||||
const tile = await pending;
|
||||
const tile = drawTile(texture, bounds, { x, y, level });
|
||||
assert.equal(tile.source, texture);
|
||||
assert.deepEqual(tile.crop, crop);
|
||||
}
|
||||
});
|
||||
|
||||
test('512-pixel crops preserve source extent at root and clamped draping levels', async () => {
|
||||
test('512-pixel tiles preserve the source extent at every level', () => {
|
||||
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);
|
||||
const tile = drawTile(texture, WORLD, { x, y, level }, 512);
|
||||
assert.equal(tile.source, texture);
|
||||
assert.deepEqual(tile.crop, crop);
|
||||
}
|
||||
|
||||
+169
-158
@@ -1,11 +1,10 @@
|
||||
import { weatherTileUrl } from './source.js';
|
||||
import { orderWeatherImagery } from './imageryOrder.js';
|
||||
import { WEATHER_IMAGERY_Z } from './imageryOrder.js';
|
||||
import { imageryHostStatus } from './imageryHost.js';
|
||||
import { createRasterTileProvider } from './rasterTiles.js';
|
||||
import { withTileRequestHook } from '../../render/cesium/tileRequests.js';
|
||||
import { createWeatherShell } from './shellRendering.js';
|
||||
import { weatherDisplay, escapeCreditText } from './display.js';
|
||||
import { drawMosaicTile } from './rasterTiles.js';
|
||||
import { weatherDisplay } from './display.js';
|
||||
import { msg } from '../../i18n/index.js';
|
||||
import { findCamera, findCredits, findGlobe } from '../../render/rendererOf.js';
|
||||
import { readResponseBytesCapped } from '../../sources/httpBody.js';
|
||||
import {
|
||||
acquireInfraredMosaic,
|
||||
@@ -19,11 +18,49 @@ const MAX_PREFETCH_TILES = 8;
|
||||
// How often a staged frame waiting out its quiet interval rechecks readiness.
|
||||
export const READY_WAKE_MS = 150;
|
||||
|
||||
/** Globe imagery: own at most a displayed and a staging frame. Use native Cesium
|
||||
* tile scheduling, projection and texture disposal; the application clock is never touched. */
|
||||
/**
|
||||
* A degrees rectangle's overlap with another, or null; either may cross the
|
||||
* antimeridian (`west > east`), as a view rectangle can.
|
||||
*/
|
||||
export function rectangleOverlap(a, b) {
|
||||
let aEast = a.east;
|
||||
let aWest = a.west;
|
||||
let bEast = b.east;
|
||||
let bWest = b.west;
|
||||
if (aEast < aWest && bEast > 0) aEast += 360;
|
||||
else if (bEast < bWest && aEast > 0) bEast += 360;
|
||||
if (aEast < aWest && bWest < 0) bWest += 360;
|
||||
else if (bEast < bWest && aWest < 0) aWest += 360;
|
||||
const wrap = (lon) =>
|
||||
lon >= -180 && lon <= 180 ? lon : ((((lon + 180) % 360) + 360) % 360) - 180;
|
||||
const west = wrap(Math.max(aWest, bWest));
|
||||
const east = wrap(Math.min(aEast, bEast));
|
||||
if ((a.west < a.east || b.west < b.east) && east <= west) return null;
|
||||
const south = Math.max(a.south, b.south);
|
||||
const north = Math.min(a.north, b.north);
|
||||
if (south >= north) return null;
|
||||
return { west, south, east, north };
|
||||
}
|
||||
|
||||
/** A tile of the geographic scheme (two level-zero tiles), in degrees. */
|
||||
export function geographicTile(x, y, level) {
|
||||
const size = 180 / 2 ** level;
|
||||
const west = -180 + x * size;
|
||||
const north = 90 - y * size;
|
||||
return { west, south: north - size, east: west + size, north };
|
||||
}
|
||||
|
||||
/** HTTP statuses a weather tile is fetched again for, rather than failing. */
|
||||
const RETRY_STATUSES = [429, 503];
|
||||
|
||||
/** Globe imagery through the renderer's globe port: own at most a displayed
|
||||
* and a staging frame; the application clock is never touched. */
|
||||
function createGlobeRendering({
|
||||
viewer,
|
||||
cesium,
|
||||
globeOf,
|
||||
cameraOf,
|
||||
creditsOf,
|
||||
toBitmap,
|
||||
getHost,
|
||||
onChange,
|
||||
timeoutMs,
|
||||
@@ -84,30 +121,18 @@ function createGlobeRendering({
|
||||
}
|
||||
|
||||
function prefetchTiles(snapshot, time) {
|
||||
const { west, south, east, north } = snapshot.bounds;
|
||||
const bounds = cesium.Rectangle.fromDegrees(west, south, east, north);
|
||||
const view = viewer.camera?.computeViewRectangle?.(
|
||||
viewer.scene.globe?.ellipsoid,
|
||||
);
|
||||
const coverage = view
|
||||
? cesium.Rectangle.intersection(bounds, view)
|
||||
: bounds;
|
||||
const bounds = snapshot.bounds;
|
||||
const view = cameraOf(viewer)?.viewRectangle?.();
|
||||
const coverage = view ? rectangleOverlap(bounds, view) : bounds;
|
||||
if (!coverage) return [];
|
||||
const scheme = new cesium.GeographicTilingScheme();
|
||||
const template = weatherTileUrl(snapshot.product, time, {
|
||||
size: profile(snapshot.product).tileSize,
|
||||
});
|
||||
const urls = [];
|
||||
for (let z = 0; z <= 1; z++) {
|
||||
for (let y = 0; y < scheme.getNumberOfYTilesAtLevel(z); y++) {
|
||||
for (let x = 0; x < scheme.getNumberOfXTilesAtLevel(z); x++) {
|
||||
if (
|
||||
!cesium.Rectangle.intersection(
|
||||
coverage,
|
||||
scheme.tileXYToRectangle(x, y, z),
|
||||
)
|
||||
)
|
||||
continue;
|
||||
for (let y = 0; y < 2 ** z; y++) {
|
||||
for (let x = 0; x < 2 ** (z + 1); x++) {
|
||||
if (!rectangleOverlap(coverage, geographicTile(x, y, z))) continue;
|
||||
urls.push(
|
||||
template.replace('{z}', z).replace('{x}', x).replace('{y}', y),
|
||||
);
|
||||
@@ -121,17 +146,31 @@ function createGlobeRendering({
|
||||
function creditText(snapshot) {
|
||||
const sourceCredit = weatherDisplay(snapshot).credit;
|
||||
return sourceCredit !== undefined
|
||||
? escapeCreditText(sourceCredit)
|
||||
? sourceCredit
|
||||
: snapshot.product === 'lightning'
|
||||
? 'NOAA/NWS lightning density · derived from Vaisala NLDN/GLD360'
|
||||
: snapshot.product === 'radar'
|
||||
? 'NOAA nowCOAST · NWS/OAR MRMS'
|
||||
: 'NOAA nowCOAST · NESDIS GOES / global satellite partners';
|
||||
}
|
||||
/**
|
||||
* The frame's credit is owed while its layer is drawn (shown, even
|
||||
* transparent while it stages), through the renderer's credits port.
|
||||
*/
|
||||
function syncCredit(frame) {
|
||||
const text =
|
||||
(!frame.closed && frame.layer?.show === true && frame.credit) || null;
|
||||
if (frame.creditShown === text) return;
|
||||
frame.offCredit?.();
|
||||
frame.offCredit = null;
|
||||
frame.creditShown = text;
|
||||
if (text) frame.offCredit = creditsOf(viewer)?.addStatic({ text }) ?? null;
|
||||
}
|
||||
function setCredit(frame) {
|
||||
const text = creditText(frame.creditSnapshot ?? frame.snapshot);
|
||||
if (frame.credit?.html === text) return false;
|
||||
frame.credit = new cesium.Credit(text, false);
|
||||
if (frame.credit === text) return false;
|
||||
frame.credit = text;
|
||||
if (frame.layer) syncCredit(frame);
|
||||
return true;
|
||||
}
|
||||
/**
|
||||
@@ -145,7 +184,7 @@ function createGlobeRendering({
|
||||
for (const frame of new Set([current, incoming, ...retiring])) {
|
||||
if (!frame || frame.product !== snapshot.product) continue;
|
||||
frame.creditSnapshot = snapshot;
|
||||
if (frame.credit && setCredit(frame)) changed = true;
|
||||
if (frame.credit !== undefined && setCredit(frame)) changed = true;
|
||||
}
|
||||
if (changed) viewer.scene.requestRender();
|
||||
}
|
||||
@@ -163,18 +202,9 @@ function createGlobeRendering({
|
||||
frame.offCamera?.();
|
||||
clearTimeout(frame.timeout);
|
||||
clearTimeout(frame.wake);
|
||||
for (const request of frame.requests) request.cancel?.();
|
||||
frame.requests.clear();
|
||||
frame.retries.clear();
|
||||
if (!frame.layer) return;
|
||||
const collection = frame.collection;
|
||||
if (
|
||||
collection &&
|
||||
!collection.isDestroyed?.() &&
|
||||
collection.contains(frame.layer)
|
||||
)
|
||||
collection.remove(frame.layer, true);
|
||||
else if (!frame.layer.isDestroyed?.()) frame.layer.destroy?.();
|
||||
syncCredit(frame);
|
||||
// Removing the layer cancels its tile requests in flight.
|
||||
frame.layer?.remove();
|
||||
}
|
||||
function cancelIncoming() {
|
||||
if (!incoming) return;
|
||||
@@ -183,13 +213,17 @@ function createGlobeRendering({
|
||||
remove(previous);
|
||||
previous.resolve(false);
|
||||
}
|
||||
/**
|
||||
* Follow the host: a globe host draws the frame, any other hides it (the
|
||||
* globe drapes nothing while hidden) and drops what was staging for it.
|
||||
*/
|
||||
function rehome() {
|
||||
const host = getHost();
|
||||
const { collection } = host;
|
||||
const { kind } = host;
|
||||
const hidden = frameHidden || imageryHostStatus(host) !== null;
|
||||
const changed =
|
||||
(current && current.collection !== collection) ||
|
||||
(incoming && incoming.collection !== collection);
|
||||
(current && current.kind !== kind) ||
|
||||
(incoming && incoming.kind !== kind);
|
||||
const visibilityChanged = current && current.layer.show === hidden;
|
||||
if (changed || imageryHostStatus(host) !== null) {
|
||||
cancelPrefetch();
|
||||
@@ -199,14 +233,8 @@ function createGlobeRendering({
|
||||
if (current) {
|
||||
if (!hidden && current.layer.alpha !== alpha) current.layer.alpha = alpha;
|
||||
if (visibilityChanged) current.layer.show = !hidden;
|
||||
}
|
||||
if (current && current.collection !== collection) {
|
||||
current.collection?.remove(current.layer, false);
|
||||
current.collection = collection;
|
||||
if (collection) {
|
||||
collection.add(current.layer);
|
||||
orderWeatherImagery(collection, current.layer, current.priority);
|
||||
}
|
||||
current.kind = kind;
|
||||
syncCredit(current);
|
||||
}
|
||||
if (changed || visibilityChanged) viewer.scene.requestRender();
|
||||
return Boolean(changed || visibilityChanged);
|
||||
@@ -265,8 +293,10 @@ function createGlobeRendering({
|
||||
rehome();
|
||||
cancelIncoming();
|
||||
const host = getHost();
|
||||
const { collection, kind } = host;
|
||||
const { kind } = host;
|
||||
if (imageryHostStatus(host)) return false;
|
||||
const globe = globeOf(viewer);
|
||||
if (!globe) return false;
|
||||
const nextProfile = profile(snapshot.product);
|
||||
if (
|
||||
current?.time === time &&
|
||||
@@ -279,7 +309,7 @@ function createGlobeRendering({
|
||||
}
|
||||
lastError = null;
|
||||
const { west, south, east, north } = snapshot.bounds;
|
||||
const rectangle = cesium.Rectangle.fromDegrees(west, south, east, north);
|
||||
const rectangle = { west, south, east, north };
|
||||
const global = snapshot.product === 'clouds';
|
||||
const frame = {
|
||||
snapshot,
|
||||
@@ -290,17 +320,8 @@ function createGlobeRendering({
|
||||
? { fetched: false, decodeMs: null, cached: false }
|
||||
: undefined,
|
||||
controller: new AbortController(),
|
||||
collection,
|
||||
kind,
|
||||
priority:
|
||||
snapshot.product === 'lightning'
|
||||
? 3
|
||||
: snapshot.product === 'radar'
|
||||
? 2
|
||||
: 1,
|
||||
product: snapshot.product,
|
||||
requests: new Set(),
|
||||
retries: new Map(),
|
||||
deferred: new Set(),
|
||||
pending: 0,
|
||||
loaded: 0,
|
||||
@@ -332,6 +353,7 @@ function createGlobeRendering({
|
||||
frame.loadMs = now() - frame.startedAt;
|
||||
frame.layer.alpha = alpha;
|
||||
frame.layer.show = !frameHidden;
|
||||
syncCredit(frame);
|
||||
viewer.scene.requestRender();
|
||||
if (previous) {
|
||||
retiring.add(previous);
|
||||
@@ -375,103 +397,83 @@ function createGlobeRendering({
|
||||
viewer.scene.requestRender();
|
||||
return;
|
||||
}
|
||||
const tilingScheme = new cesium.GeographicTilingScheme(
|
||||
global
|
||||
? {
|
||||
rectangle,
|
||||
numberOfLevelZeroTilesX: 2,
|
||||
numberOfLevelZeroTilesY: 1,
|
||||
}
|
||||
: undefined,
|
||||
);
|
||||
setCredit(frame);
|
||||
const credit = frame.credit;
|
||||
const source = global
|
||||
? createRasterTileProvider({
|
||||
cesium,
|
||||
texture,
|
||||
rectangle,
|
||||
tilingScheme,
|
||||
maximumLevel: GLOBAL_TILE_MAXIMUM_LEVEL,
|
||||
tileSize: nextProfile.tileSize,
|
||||
credit,
|
||||
createCanvas,
|
||||
})
|
||||
: new cesium.UrlTemplateImageryProvider({
|
||||
url: weatherTileUrl(snapshot.product, time, {
|
||||
size: nextProfile.tileSize,
|
||||
}),
|
||||
tilingScheme,
|
||||
rectangle,
|
||||
tileWidth: nextProfile.tileSize,
|
||||
tileHeight: nextProfile.tileSize,
|
||||
maximumLevel: nextProfile.maximumLevel,
|
||||
enablePickFeatures: false,
|
||||
credit,
|
||||
});
|
||||
const provider = withTileRequestHook(source, {
|
||||
// Cesium reads a provider's credit every frame; a refreshed manifest
|
||||
// can replace it without restaging the imagery.
|
||||
credit: () => frame.credit,
|
||||
requestImage: ({ x, y, level, request }, issue) => {
|
||||
if (frame.closed) return undefined;
|
||||
const result = issue();
|
||||
const tileKey = `${level}/${x}/${y}`;
|
||||
if (!result) {
|
||||
// Scheduler admission is part of readiness, not a successful tile.
|
||||
frame.deferred.add(tileKey);
|
||||
frame.lastActivity = now();
|
||||
return result;
|
||||
}
|
||||
frame.deferred.delete(tileKey);
|
||||
frame.pending++;
|
||||
const tileSize = nextProfile.tileSize;
|
||||
/** Readiness accounting: each own tile the renderer issues or defers. */
|
||||
const admit = (tile, issue) => {
|
||||
if (frame.closed) return undefined;
|
||||
const result = issue();
|
||||
const tileKey = `${tile.level}/${tile.x}/${tile.y}`;
|
||||
if (!result) {
|
||||
// Scheduler admission is part of readiness, not a successful tile.
|
||||
frame.deferred.add(tileKey);
|
||||
frame.lastActivity = now();
|
||||
if (request) frame.requests.add(request);
|
||||
return Promise.resolve(result)
|
||||
.then((image) => {
|
||||
// Cesium decodes tiles as ImageBitmaps already flipped, since WebGL
|
||||
// ignores UNPACK_FLIP_Y for them; a canvas upload flips again.
|
||||
if (!frame.closed && snapshot.product === 'clouds-regional')
|
||||
image = processInfraredImage(image, infrared, createCanvas, {
|
||||
flipY:
|
||||
typeof ImageBitmap !== 'undefined' &&
|
||||
image instanceof ImageBitmap,
|
||||
});
|
||||
frame.retries.delete(tileKey);
|
||||
frame.loaded++;
|
||||
return image;
|
||||
})
|
||||
.finally(() => {
|
||||
frame.pending--;
|
||||
frame.lastActivity = now();
|
||||
frame.requests.delete(request);
|
||||
if (!frame.closed) viewer.scene.requestRender();
|
||||
});
|
||||
},
|
||||
});
|
||||
frame.offError = provider.errorEvent.addEventListener((error) => {
|
||||
if (frame.closed) return;
|
||||
const status = error?.error?.statusCode;
|
||||
// Cesium retries synchronously after this event; no delay hook is exposed.
|
||||
const tileKey = `${error.level}/${error.x}/${error.y}`;
|
||||
const retries = frame.retries.get(tileKey) ?? 0;
|
||||
error.retry = false;
|
||||
if ((status === 429 || status === 503) && retries < 3) {
|
||||
frame.retries.set(tileKey, retries + 1);
|
||||
error.retry = true;
|
||||
return;
|
||||
return result;
|
||||
}
|
||||
frame.deferred.delete(tileKey);
|
||||
frame.pending++;
|
||||
frame.lastActivity = now();
|
||||
return Promise.resolve(result)
|
||||
.then((image) => {
|
||||
frame.loaded++;
|
||||
return image;
|
||||
})
|
||||
.finally(() => {
|
||||
frame.pending--;
|
||||
frame.lastActivity = now();
|
||||
if (!frame.closed) viewer.scene.requestRender();
|
||||
});
|
||||
};
|
||||
const spec = global
|
||||
? {
|
||||
kind: 'canvas',
|
||||
tiling: 'geographic',
|
||||
rectangle,
|
||||
maxLevel: GLOBAL_TILE_MAXIMUM_LEVEL,
|
||||
tileSize,
|
||||
drawTile: (tile, canvas) =>
|
||||
drawMosaicTile(texture, rectangle, tile, canvas),
|
||||
admit,
|
||||
zOrder: WEATHER_IMAGERY_Z[snapshot.product],
|
||||
}
|
||||
: {
|
||||
kind: 'xyz',
|
||||
url: weatherTileUrl(snapshot.product, time, { size: tileSize }),
|
||||
tiling: 'geographic',
|
||||
rectangle,
|
||||
tileSize,
|
||||
maxLevel: nextProfile.maximumLevel,
|
||||
retryStatuses: RETRY_STATUSES,
|
||||
admit,
|
||||
...(snapshot.product === 'clouds-regional'
|
||||
? {
|
||||
// The transfer runs on the upright tile the renderer
|
||||
// decoded.
|
||||
// Closed frames do not process late images.
|
||||
tileTransform: (_tile, image) =>
|
||||
frame.closed
|
||||
? image
|
||||
: toBitmap(
|
||||
processInfraredImage(image, infrared, createCanvas),
|
||||
),
|
||||
}
|
||||
: {}),
|
||||
zOrder: WEATHER_IMAGERY_Z[snapshot.product],
|
||||
};
|
||||
// A shown, transparent layer lets the renderer request staging tiles
|
||||
// while the last complete observation stays visible underneath it.
|
||||
frame.layer = globe.imagery.add(spec);
|
||||
frame.layer.drapeOn = 'surface';
|
||||
frame.layer.alpha = 0;
|
||||
syncCredit(frame);
|
||||
frame.offError = frame.layer.on('tileError', () => {
|
||||
if (frame.closed) return;
|
||||
frame.failed = true;
|
||||
lastError = msg('Some weather tiles unavailable');
|
||||
onChange();
|
||||
});
|
||||
// A shown, transparent layer lets Cesium request staging tiles while the last
|
||||
// complete observation stays visible underneath it.
|
||||
frame.layer = collection.addImageryProvider(provider);
|
||||
frame.layer.alpha = 0;
|
||||
orderWeatherImagery(collection, frame.layer, frame.priority);
|
||||
let settled = 0;
|
||||
frame.offCamera = viewer.camera?.moveEnd?.addEventListener(() => {
|
||||
frame.offCamera = cameraOf(viewer)?.on('moveEnd', () => {
|
||||
// Tiles abandoned by a previous viewport are no longer admission work.
|
||||
frame.deferred.clear();
|
||||
frame.lastActivity = now();
|
||||
@@ -488,7 +490,7 @@ function createGlobeRendering({
|
||||
frame.deferred.size === 0 &&
|
||||
now() - frame.lastActivity >= 200;
|
||||
if (
|
||||
((frame.kind === 'globe' && viewer.scene.globe.tilesLoaded) ||
|
||||
((frame.kind === 'globe' && globe.isSettled('imagery')) ||
|
||||
ownReady) &&
|
||||
frame.pending === 0
|
||||
) {
|
||||
@@ -586,7 +588,12 @@ function createGlobeRendering({
|
||||
* A host switch tears one renderer down and restages the last frame on the other. */
|
||||
export function createWeatherRendering({
|
||||
viewer,
|
||||
cesium,
|
||||
createShell,
|
||||
globeOf = findGlobe,
|
||||
cameraOf = findCamera,
|
||||
creditsOf = findCredits,
|
||||
toBitmap = (canvas) =>
|
||||
globalThis.createImageBitmap(canvas, { premultiplyAlpha: 'none' }),
|
||||
getHost = () => ({ collection: viewer.imageryLayers, kind: 'globe' }),
|
||||
onChange = () => {},
|
||||
timeoutMs = 25_000,
|
||||
@@ -594,11 +601,9 @@ export function createWeatherRendering({
|
||||
fetchImpl = (...args) => globalThis.fetch(...args),
|
||||
decodeImage,
|
||||
createCanvas = () => document.createElement('canvas'),
|
||||
createShell = createWeatherShell,
|
||||
}) {
|
||||
const shared = {
|
||||
viewer,
|
||||
cesium,
|
||||
getHost,
|
||||
onChange,
|
||||
timeoutMs,
|
||||
@@ -607,7 +612,13 @@ export function createWeatherRendering({
|
||||
decodeImage,
|
||||
createCanvas,
|
||||
};
|
||||
const globe = createGlobeRendering(shared);
|
||||
const globe = createGlobeRendering({
|
||||
...shared,
|
||||
globeOf,
|
||||
cameraOf,
|
||||
creditsOf,
|
||||
toBitmap,
|
||||
});
|
||||
let shell = null;
|
||||
let active = null;
|
||||
let alpha = 0.7;
|
||||
|
||||
+209
-214
@@ -6,7 +6,10 @@ import { createWeatherClock } from './clock.js';
|
||||
import * as Cesium from 'cesium';
|
||||
import { Color, ImageryLayerCollection, GeographicTilingScheme } from 'cesium';
|
||||
import { NO_IMAGERY_HOST } from './imageryHost.js';
|
||||
import { orderWeatherImagery } from './imageryOrder.js';
|
||||
import { createWeatherShell } from './shellRendering.js';
|
||||
import { WEATHER_IMAGERY_Z } from './imageryOrder.js';
|
||||
import { fakeGlobePort } from '../../testSupport/fakeGlobePort.mjs';
|
||||
import { createCesiumGlobe } from '../../render/cesium/globe.js';
|
||||
import {
|
||||
createShellCesium,
|
||||
createShellScene,
|
||||
@@ -95,74 +98,99 @@ const mockResponse = () => ({
|
||||
headers: new Headers(),
|
||||
arrayBuffer: async () => new ArrayBuffer(1),
|
||||
});
|
||||
/** A camera port over a fake viewer's Cesium-shaped camera. */
|
||||
const cameraOver = (viewer) =>
|
||||
viewer.camera && {
|
||||
on: (event, cb) =>
|
||||
event === 'moveEnd'
|
||||
? viewer.camera.moveEnd?.addEventListener(cb)
|
||||
: () => {},
|
||||
viewRectangle() {
|
||||
const rect = viewer.camera.computeViewRectangle?.();
|
||||
if (!rect) return null;
|
||||
const deg = Cesium.Math.toDegrees;
|
||||
return {
|
||||
west: deg(rect.west),
|
||||
south: deg(rect.south),
|
||||
east: deg(rect.east),
|
||||
north: deg(rect.north),
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
/** A credits port recording what is owed now. */
|
||||
function fakeCredits() {
|
||||
const owed = [];
|
||||
return {
|
||||
owed,
|
||||
addStatic(credit) {
|
||||
const entry = { ...credit };
|
||||
owed.push(entry);
|
||||
return () => {
|
||||
const i = owed.indexOf(entry);
|
||||
if (i >= 0) owed.splice(i, 1);
|
||||
};
|
||||
},
|
||||
list: () => owed.slice(),
|
||||
on: () => () => {},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Each layer added through the globe port, as a test drives it: `spec`,
|
||||
* the tile it answers with (`response`), `requestImage` through the
|
||||
* layer's hooks, and tile errors through `errorEvent.emit`.
|
||||
*/
|
||||
function layerDriver(layer, createCanvas) {
|
||||
const box = { response: null, requestArgs: undefined };
|
||||
return {
|
||||
layer,
|
||||
spec: layer.spec,
|
||||
box,
|
||||
get response() {
|
||||
return box.response;
|
||||
},
|
||||
set response(value) {
|
||||
box.response = value;
|
||||
},
|
||||
get requestArgs() {
|
||||
return box.requestArgs;
|
||||
},
|
||||
requestImage(x, y, level, request) {
|
||||
const tile = { x, y, level };
|
||||
return layer.request(tile, () => {
|
||||
box.requestArgs = [x, y, level, request];
|
||||
if (layer.spec.kind === 'canvas') {
|
||||
const canvas = createCanvas();
|
||||
canvas.width = canvas.height = layer.spec.tileSize;
|
||||
layer.spec.drawTile(tile, canvas);
|
||||
return Promise.resolve(canvas);
|
||||
}
|
||||
return box.response?.promise;
|
||||
});
|
||||
},
|
||||
errorEvent: {
|
||||
get size() {
|
||||
return layer.listenerCount('tileError');
|
||||
},
|
||||
emit(error) {
|
||||
const status = error?.error?.statusCode;
|
||||
layer.fail({
|
||||
tile: { x: error.x, y: error.y, level: error.level },
|
||||
...(Number.isFinite(status) ? { status } : {}),
|
||||
});
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function renderingHarness(options = {}) {
|
||||
const layers = [];
|
||||
const providers = [];
|
||||
const postRender = event();
|
||||
let renderRequests = 0;
|
||||
// `providers` lists what Cesium is handed, in order. The layer may hand it
|
||||
// a hook over this provider, so per-test state lives in one box both see.
|
||||
class Provider {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
this.tilingScheme = new GeographicTilingScheme();
|
||||
this.errorEvent = event();
|
||||
this.box = { response: null, requestArgs: undefined };
|
||||
}
|
||||
get response() {
|
||||
return this.box.response;
|
||||
}
|
||||
set response(value) {
|
||||
this.box.response = value;
|
||||
}
|
||||
get requestArgs() {
|
||||
return this.box.requestArgs;
|
||||
}
|
||||
requestImage(...args) {
|
||||
this.box.requestArgs = args;
|
||||
return this.response?.promise;
|
||||
}
|
||||
}
|
||||
const collection = {
|
||||
add(layer) {
|
||||
layers.push(layer);
|
||||
return layer;
|
||||
},
|
||||
addImageryProvider(provider) {
|
||||
if (!providers.includes(provider)) providers.push(provider);
|
||||
const layer = { imageryProvider: provider, alpha: 1, show: true };
|
||||
layers.push(layer);
|
||||
return layer;
|
||||
},
|
||||
contains(layer) {
|
||||
return layers.includes(layer);
|
||||
},
|
||||
remove(layer, destroy) {
|
||||
const index = layers.indexOf(layer);
|
||||
if (index < 0) return false;
|
||||
layers.splice(index, 1);
|
||||
layer.destroyed = destroy;
|
||||
return true;
|
||||
},
|
||||
get length() {
|
||||
return layers.length;
|
||||
},
|
||||
get(index) {
|
||||
return layers[index];
|
||||
},
|
||||
lower(layer) {
|
||||
const i = layers.indexOf(layer);
|
||||
if (i > 0) [layers[i - 1], layers[i]] = [layers[i], layers[i - 1]];
|
||||
},
|
||||
raiseToTop(layer) {
|
||||
const i = layers.indexOf(layer);
|
||||
if (i >= 0) layers.push(...layers.splice(i, 1));
|
||||
},
|
||||
isDestroyed: () => false,
|
||||
};
|
||||
const viewer = {
|
||||
clock: { untouched: true },
|
||||
imageryLayers: collection,
|
||||
imageryLayers: { isDestroyed: () => false },
|
||||
scene: {
|
||||
postRender,
|
||||
primitives: createShellScene().primitives,
|
||||
@@ -172,10 +200,20 @@ function renderingHarness(options = {}) {
|
||||
},
|
||||
},
|
||||
};
|
||||
const globe = fakeGlobePort({
|
||||
settled: () => viewer.scene.globe.tilesLoaded,
|
||||
});
|
||||
const createCanvas = options.createCanvas ?? mockCanvas;
|
||||
const add = globe.imagery.add;
|
||||
globe.imagery.add = (spec, index) => {
|
||||
const layer = add(spec, index);
|
||||
providers.push(layerDriver(layer, createCanvas));
|
||||
return layer;
|
||||
};
|
||||
const credits = fakeCredits();
|
||||
const cesium = {
|
||||
...createShellCesium(),
|
||||
Color,
|
||||
UrlTemplateImageryProvider: Provider,
|
||||
GeographicTilingScheme,
|
||||
Event: Cesium.Event,
|
||||
Credit: Cesium.Credit,
|
||||
@@ -183,10 +221,15 @@ function renderingHarness(options = {}) {
|
||||
};
|
||||
const rendering = createWeatherRendering({
|
||||
viewer,
|
||||
cesium,
|
||||
globeOf: () => globe,
|
||||
cameraOf: cameraOver,
|
||||
creditsOf: () => credits,
|
||||
toBitmap: (canvas) => canvas,
|
||||
createShell: (shellOptions) =>
|
||||
createWeatherShell({ ...shellOptions, cesium }),
|
||||
fetchImpl: async () => mockResponse(),
|
||||
decodeImage: async () => ({ width: 2048, height: 1024, close() {} }),
|
||||
createCanvas: mockCanvas,
|
||||
createCanvas,
|
||||
...options,
|
||||
});
|
||||
const settle = () => {
|
||||
@@ -197,8 +240,10 @@ function renderingHarness(options = {}) {
|
||||
rendering,
|
||||
viewer,
|
||||
cesium,
|
||||
globe,
|
||||
credits,
|
||||
providers,
|
||||
layers,
|
||||
layers: globe.layers,
|
||||
postRender,
|
||||
settle,
|
||||
shells: () => viewer.scene.primitives.items,
|
||||
@@ -412,10 +457,10 @@ test('weather stages invisibly, waits for pending tiles and render readiness, an
|
||||
0.7,
|
||||
'new layer is visible before retirement',
|
||||
);
|
||||
assert.equal(layer.destroyed, undefined);
|
||||
assert.equal(layer.removed, false);
|
||||
h.postRender.emit();
|
||||
assert.equal(h.layers.length, 1);
|
||||
assert.equal(layer.destroyed, true);
|
||||
assert.equal(layer.removed, true);
|
||||
assert.equal(h.providers[0].errorEvent.size, 0);
|
||||
assert.equal(h.rendering.getDiagnostics().time, times[1]);
|
||||
assert.deepEqual(h.viewer.clock, { untouched: true });
|
||||
@@ -429,15 +474,14 @@ test('superseded stages cancel requests and cannot resurrect after a late tile r
|
||||
const tile = deferred();
|
||||
const oldProvider = h.providers[0];
|
||||
oldProvider.response = tile;
|
||||
let cancellations = 0;
|
||||
const requested = oldProvider.requestImage(0, 0, 0, {
|
||||
cancel() {
|
||||
cancellations++;
|
||||
},
|
||||
});
|
||||
const requested = oldProvider.requestImage(0, 0, 0, {});
|
||||
const second = h.rendering.setFrame(snapshot, times[1]);
|
||||
assert.equal(await first, false);
|
||||
assert.equal(cancellations, 1);
|
||||
assert.equal(
|
||||
oldProvider.layer.removed,
|
||||
true,
|
||||
'removing the layer cancels its requests in flight',
|
||||
);
|
||||
assert.equal(h.layers.length, 1);
|
||||
assert.equal(oldProvider.errorEvent.size, 0);
|
||||
tile.resolve({});
|
||||
@@ -683,16 +727,15 @@ test('external abort cancels a staged renderer request and releases its observer
|
||||
});
|
||||
const tile = deferred();
|
||||
h.providers[0].response = tile;
|
||||
let cancellations = 0;
|
||||
const requested = h.providers[0].requestImage(0, 0, 0, {
|
||||
cancel() {
|
||||
cancellations++;
|
||||
},
|
||||
});
|
||||
const requested = h.providers[0].requestImage(0, 0, 0, {});
|
||||
const before = h.renders();
|
||||
controller.abort();
|
||||
assert.equal(await stage, false);
|
||||
assert.equal(cancellations, 1);
|
||||
assert.equal(
|
||||
h.providers[0].layer.removed,
|
||||
true,
|
||||
'removing the layer cancels its requests in flight',
|
||||
);
|
||||
assert.equal(h.layers.length, 0);
|
||||
assert.equal(h.postRender.size, 0);
|
||||
assert.equal(h.providers[0].errorEvent.size, 0);
|
||||
@@ -790,12 +833,12 @@ test('global infrared is acquired before staging and cropped from one processed
|
||||
});
|
||||
decode.resolve({ width: 2048, height: 1024 });
|
||||
await flush();
|
||||
const provider = h.layers[0].imageryProvider;
|
||||
assert.equal(provider.maximumLevel, 3);
|
||||
assert.equal(provider.tileWidth, 256);
|
||||
assert.equal(provider.tileHeight, 256);
|
||||
assert.equal(provider.tilingScheme.getNumberOfXTilesAtLevel(0), 2);
|
||||
assert.deepEqual(provider.tilingScheme.rectangle, provider.rectangle);
|
||||
const provider = h.providers[0];
|
||||
assert.equal(provider.spec.kind, 'canvas');
|
||||
assert.equal(provider.spec.maxLevel, 3);
|
||||
assert.equal(provider.spec.tileSize, 256);
|
||||
assert.equal(provider.spec.tiling, 'geographic');
|
||||
assert.deepEqual(provider.spec.rectangle, snapshot.bounds);
|
||||
const first = await provider.requestImage(0, 0, 0);
|
||||
const next = await provider.requestImage(1, 0, 0);
|
||||
assert.equal(first.source, next.source);
|
||||
@@ -909,7 +952,7 @@ test('history loading updates an existing info line and preserves summary status
|
||||
h.layer.destroy();
|
||||
});
|
||||
|
||||
test('no host cancels a globe stage, detaches the layer and restores it in weather order', async () => {
|
||||
test('no host cancels a globe stage and hides the frame; weather keeps its order', async () => {
|
||||
let host;
|
||||
const h = renderingHarness({ getHost: () => host });
|
||||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||||
@@ -917,25 +960,34 @@ test('no host cancels a globe stage, detaches the layer and restores it in weath
|
||||
h.settle();
|
||||
assert.equal(await stage, true);
|
||||
const radar = h.layers[0];
|
||||
const cloud = h.viewer.imageryLayers.add({ name: 'cloud' });
|
||||
const lightning = h.viewer.imageryLayers.add({ name: 'lightning' });
|
||||
orderWeatherImagery(h.viewer.imageryLayers, lightning, 3);
|
||||
orderWeatherImagery(h.viewer.imageryLayers, cloud, 1);
|
||||
const other = (zOrder) =>
|
||||
h.globe.imagery.add({ kind: 'xyz', url: 'https://o.invalid', zOrder });
|
||||
const cloud = other(WEATHER_IMAGERY_Z.clouds);
|
||||
const lightning = other(WEATHER_IMAGERY_Z.lightning);
|
||||
const overlay = other(undefined);
|
||||
assert.equal(radar.drapeOn, 'surface');
|
||||
assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]);
|
||||
assert.deepEqual(h.credits.owed, [{ text: 'NOAA nowCOAST · NWS/OAR MRMS' }]);
|
||||
const incoming = h.rendering.setFrame(snapshot, times[1]);
|
||||
host = { collection: null, kind: 'none' };
|
||||
assert.equal(h.rendering.rehome(), true);
|
||||
assert.equal(await incoming, false);
|
||||
assert.deepEqual(h.layers, [cloud, lightning]);
|
||||
assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]);
|
||||
assert.equal(radar.show, false, 'nothing draws without a host');
|
||||
assert.deepEqual(h.credits.owed, [], 'nor is its credit owed');
|
||||
assert.equal(await h.rendering.setFrame(snapshot, times[2]), false);
|
||||
assert.equal(h.rendering.getDiagnostics().error, NO_IMAGERY_HOST);
|
||||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||||
h.rendering.rehome();
|
||||
assert.deepEqual(h.layers, [cloud, radar, lightning]);
|
||||
assert.equal(radar.show, true);
|
||||
assert.equal(h.credits.owed.length, 1);
|
||||
assert.deepEqual(h.layers, [overlay, cloud, radar, lightning]);
|
||||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||||
h.rendering.clear();
|
||||
assert.deepEqual(h.layers, [cloud, lightning]);
|
||||
assert.equal(radar.destroyed, true);
|
||||
assert.deepEqual(h.layers, [overlay, cloud, lightning]);
|
||||
assert.equal(radar.removed, true);
|
||||
assert.deepEqual(h.credits.owed, []);
|
||||
});
|
||||
|
||||
const shellDecode = async () => ({ width: 4096, height: 2048, close() {} });
|
||||
@@ -1054,7 +1106,7 @@ test('host switches tear one renderer down and restage the retained frame on the
|
||||
host = { collection: tiles, kind: 'tileset' };
|
||||
assert.equal(h.rendering.rehome(), true);
|
||||
assert.equal(h.layers.length, 0);
|
||||
assert.equal(layer.destroyed, true);
|
||||
assert.equal(layer.removed, true);
|
||||
assert.equal(tiles.length, 0);
|
||||
assert.equal(
|
||||
h.rendering.getDiagnostics().time,
|
||||
@@ -1089,7 +1141,7 @@ test('host switches tear one renderer down and restage the retained frame on the
|
||||
assert.equal(diagnostics.time, times[1]);
|
||||
assert.equal(diagnostics.infrared, 'full');
|
||||
assert.equal(h.layers[0].alpha, 0.4);
|
||||
assert.equal(h.layers[0].imageryProvider.tileWidth, 256);
|
||||
assert.equal(h.layers[0].spec.tileSize, 256);
|
||||
h.rendering.clear();
|
||||
assert.equal(h.layers.length, 0);
|
||||
assert.equal(h.postRender.size, 0);
|
||||
@@ -1176,14 +1228,10 @@ test('a stage without a current frame is cancelled on host change and detached f
|
||||
h.settle();
|
||||
await ready;
|
||||
const layer = h.layers[0];
|
||||
let destroyed = false;
|
||||
layer.destroy = () => {
|
||||
destroyed = true;
|
||||
};
|
||||
host = { collection: null, kind: 'none' };
|
||||
h.rendering.rehome();
|
||||
h.rendering.clear();
|
||||
assert.equal(destroyed, true);
|
||||
assert.equal(layer.removed, true);
|
||||
});
|
||||
|
||||
for (const product of ['clouds', 'clouds-regional', 'radar', 'lightning']) {
|
||||
@@ -1194,56 +1242,33 @@ for (const product of ['clouds', 'clouds-regional', 'radar', 'lightning']) {
|
||||
});
|
||||
const stage = h.rendering.setFrame({ ...snapshot, product }, times[0]);
|
||||
await flush();
|
||||
const layer = collection.get(0);
|
||||
assert.equal(layer.colorToAlpha, undefined);
|
||||
const layer = h.layers[0];
|
||||
assert.equal(layer.spec.colorToAlpha, undefined);
|
||||
assert.equal(layer.alpha, 0);
|
||||
h.rendering.clear();
|
||||
assert.equal(await stage, false);
|
||||
});
|
||||
}
|
||||
|
||||
for (const statusCode of [429, 503]) {
|
||||
test(`${statusCode} retries up to three times without failing a healthy frame`, async () => {
|
||||
let now = 0;
|
||||
const h = renderingHarness({ now: () => now });
|
||||
h.viewer.scene.globe.tilesLoaded = false;
|
||||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||||
h.providers[0].response = deferred();
|
||||
const rejected = h.providers[0].requestImage(0, 0, 0, {});
|
||||
h.providers[0].response.reject(new Error('throttled'));
|
||||
await assert.rejects(rejected, /throttled/);
|
||||
for (let timesRetried = 0; timesRetried < 3; timesRetried++) {
|
||||
const error = {
|
||||
error: { statusCode },
|
||||
x: 0,
|
||||
y: 0,
|
||||
level: 0,
|
||||
timesRetried,
|
||||
retry: false,
|
||||
};
|
||||
h.providers[0].errorEvent.emit(error);
|
||||
assert.equal(error.retry, true);
|
||||
assert.equal(h.rendering.getDiagnostics().error, null);
|
||||
}
|
||||
h.settle();
|
||||
assert.equal(h.rendering.getDiagnostics().loading, true);
|
||||
h.providers[0].response = deferred();
|
||||
const retried = h.providers[0].requestImage(0, 0, 0, {});
|
||||
h.providers[0].response.resolve({});
|
||||
await retried;
|
||||
now = 250;
|
||||
h.settle();
|
||||
assert.equal(await stage, true);
|
||||
const exhausted = h.rendering.setFrame(snapshot, times[1]);
|
||||
const error = { error: { statusCode }, timesRetried: 3, retry: false };
|
||||
for (let i = 0; i < 4; i++) h.providers[1].errorEvent.emit(error);
|
||||
h.settle();
|
||||
assert.equal(error.retry, false);
|
||||
assert.equal(await exhausted, false);
|
||||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||||
h.rendering.clear();
|
||||
});
|
||||
}
|
||||
test('throttled tiles are fetched again by the renderer; a tile that still fails fails the frame', async () => {
|
||||
let now = 0;
|
||||
const h = renderingHarness({ now: () => now });
|
||||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||||
assert.deepEqual(h.providers[0].spec.retryStatuses, [429, 503]);
|
||||
h.providers[0].response = deferred();
|
||||
const loaded = h.providers[0].requestImage(0, 0, 0, {});
|
||||
h.providers[0].response.resolve({});
|
||||
await loaded;
|
||||
now = 250;
|
||||
h.settle();
|
||||
assert.equal(await stage, true);
|
||||
const exhausted = h.rendering.setFrame(snapshot, times[1]);
|
||||
h.providers[1].errorEvent.emit({ error: { statusCode: 429 }, x: 0, y: 0 });
|
||||
h.settle();
|
||||
assert.equal(await exhausted, false);
|
||||
assert.equal(h.rendering.getDiagnostics().time, times[0]);
|
||||
h.rendering.clear();
|
||||
});
|
||||
|
||||
test('404 fails a frame without retry', async () => {
|
||||
const h = renderingHarness();
|
||||
@@ -1315,12 +1340,20 @@ test('host restore through update stages latest after a no-host start', async ()
|
||||
h.layer.destroy();
|
||||
});
|
||||
|
||||
test('real Cesium global infrared provider supports the globe host', async () => {
|
||||
const collection = new Cesium.ImageryLayerCollection();
|
||||
const h = renderingHarness({
|
||||
cesium: Cesium,
|
||||
getHost: () => ({ collection, kind: 'globe' }),
|
||||
});
|
||||
test('the global infrared mosaic draws through the real Cesium globe port', async () => {
|
||||
const scene = {
|
||||
imageryLayers: new Cesium.ImageryLayerCollection(),
|
||||
globe: { show: true, tilesLoaded: true },
|
||||
primitives: { length: 0, get: () => undefined },
|
||||
};
|
||||
const { port } = createCesiumGlobe(
|
||||
{ scene },
|
||||
{
|
||||
capabilities: new Set(['imageHooks', 'imageryOnTiles']),
|
||||
requestRender: () => {},
|
||||
},
|
||||
);
|
||||
const h = renderingHarness({ globeOf: () => port });
|
||||
const stage = h.rendering.setFrame(
|
||||
{
|
||||
...snapshot,
|
||||
@@ -1330,7 +1363,7 @@ test('real Cesium global infrared provider supports the globe host', async () =>
|
||||
times[0],
|
||||
);
|
||||
await flush();
|
||||
const layer = collection.get(0);
|
||||
const layer = scene.imageryLayers.get(0);
|
||||
const provider = layer.imageryProvider;
|
||||
assert.ok(provider.tilingScheme instanceof Cesium.GeographicTilingScheme);
|
||||
assert.equal(provider.maximumLevel, 3);
|
||||
@@ -1345,44 +1378,12 @@ test('real Cesium global infrared provider supports the globe host', async () =>
|
||||
),
|
||||
);
|
||||
assert.equal(layer.colorToAlpha, undefined);
|
||||
assert.ok(provider.requestImage(0, 0, 0) instanceof Promise);
|
||||
assert.equal(layer.alpha, 0, 'staged transparent');
|
||||
h.rendering.clear();
|
||||
assert.equal(scene.imageryLayers.length, 0);
|
||||
assert.equal(await stage, false);
|
||||
});
|
||||
|
||||
for (const statusCode of [429, 503]) {
|
||||
test(`${statusCode} retries belong to tiles, regardless of the layer-wide counter`, async () => {
|
||||
const h = renderingHarness();
|
||||
const stage = h.rendering.setFrame(snapshot, times[0]);
|
||||
const provider = h.providers[0];
|
||||
const fail = (x, timesRetried = 0) => {
|
||||
const error = { x, y: 0, level: 2, timesRetried, error: { statusCode } };
|
||||
provider.errorEvent.emit(error);
|
||||
return error.retry;
|
||||
};
|
||||
// A shared counter may exceed three even though these are first failures.
|
||||
for (let x = 0; x < 4; x++) assert.equal(fail(x, x + 4), true);
|
||||
provider.response = { promise: Promise.resolve({}) };
|
||||
await provider.requestImage(0, 0, 2);
|
||||
for (let i = 0; i < 3; i++)
|
||||
assert.equal(fail(0), true, 'own success reset the count');
|
||||
for (let i = 0; i < 2; i++) {
|
||||
await provider.requestImage(2, 0, 2);
|
||||
assert.equal(fail(1), true);
|
||||
}
|
||||
await provider.requestImage(3, 0, 2);
|
||||
assert.equal(
|
||||
fail(1),
|
||||
false,
|
||||
'four failures exhaust this tile despite other successes',
|
||||
);
|
||||
h.settle();
|
||||
assert.equal(await stage, false);
|
||||
assert.equal(provider.errorEvent.size, 0);
|
||||
h.rendering.clear();
|
||||
});
|
||||
}
|
||||
|
||||
for (const [id, product] of [
|
||||
['weather-radar', 'radar'],
|
||||
['weather-satellite', 'clouds-regional'],
|
||||
@@ -1514,10 +1515,9 @@ for (const outcome of [
|
||||
if (outcome === 'supersede')
|
||||
assert.equal(await h.rendering.setFrame(snapshot, times[0]), true);
|
||||
if (outcome === 'rehome') {
|
||||
host = {
|
||||
collection: renderingHarness().viewer.imageryLayers,
|
||||
kind: 'globe',
|
||||
};
|
||||
host = { collection: null, kind: 'none' };
|
||||
h.rendering.rehome();
|
||||
host = { collection: h.viewer.imageryLayers, kind: 'globe' };
|
||||
h.rendering.rehome();
|
||||
}
|
||||
assert.equal(await pending, false);
|
||||
@@ -1535,7 +1535,7 @@ for (const outcome of [
|
||||
await flush();
|
||||
if (outcome !== 'fetch failure') assert.equal(closed, 1);
|
||||
}
|
||||
assert.equal(host.collection.length, 1);
|
||||
assert.equal(h.layers.length, 1);
|
||||
h.rendering.clear();
|
||||
assert.equal(h.postRender.size, 0);
|
||||
});
|
||||
@@ -1548,12 +1548,7 @@ test('regional transfer preserves deferrals, original Request, rejection and can
|
||||
times[0],
|
||||
);
|
||||
const provider = h.providers[0];
|
||||
let cancelled = 0;
|
||||
const request = {
|
||||
cancel() {
|
||||
cancelled++;
|
||||
},
|
||||
};
|
||||
const request = {};
|
||||
assert.equal(provider.requestImage(1, 2, 3, request), undefined);
|
||||
assert.deepEqual(provider.requestArgs, [1, 2, 3, request]);
|
||||
const image = { width: 256, height: 256 };
|
||||
@@ -1570,13 +1565,13 @@ test('regional transfer preserves deferrals, original Request, rejection and can
|
||||
provider.response = deferred();
|
||||
const late = provider.requestImage(0, 0, 0, request);
|
||||
h.rendering.clear();
|
||||
assert.equal(cancelled, 1);
|
||||
assert.equal(provider.layer.removed, true, 'its requests are cancelled');
|
||||
provider.response.resolve(image);
|
||||
assert.equal(await late, image, 'closed frames do not process late images');
|
||||
assert.equal(await stage, false);
|
||||
});
|
||||
|
||||
test('regional tiles decoded as flipped ImageBitmaps are drawn back upright', async () => {
|
||||
test('regional tiles are processed upright, as the renderer hands them over', async () => {
|
||||
const hadBitmap = Object.hasOwn(globalThis, 'ImageBitmap');
|
||||
const previous = globalThis.ImageBitmap;
|
||||
globalThis.ImageBitmap = class ImageBitmap {
|
||||
@@ -1590,11 +1585,10 @@ test('regional tiles decoded as flipped ImageBitmaps are drawn back upright', as
|
||||
times[0],
|
||||
);
|
||||
const provider = h.providers[0];
|
||||
// Cesium decodes with imageOrientation 'flipY'; the canvas upload flips again.
|
||||
// `tileTransform` is given the tile upright, whatever it was decoded as.
|
||||
provider.response = { promise: Promise.resolve(new ImageBitmap()) };
|
||||
const bitmapTile = await provider.requestImage(0, 0, 0, {});
|
||||
assert.deepEqual(bitmapTile.drawnWith, [1, 0, 0, -1, 0, 256]);
|
||||
// An HTMLImageElement fallback is not pre-flipped.
|
||||
assert.equal(bitmapTile.drawnWith, null);
|
||||
provider.response = {
|
||||
promise: Promise.resolve({ width: 256, height: 256 }),
|
||||
};
|
||||
@@ -1632,11 +1626,11 @@ for (const kind of ['globe']) {
|
||||
assert.equal(await full, true);
|
||||
assert.equal(h.layers.length, 2);
|
||||
assert.equal(h.layers[1].alpha, 0.7);
|
||||
assert.equal(previous.destroyed, undefined);
|
||||
assert.equal(previous.removed, false);
|
||||
assert.equal(h.rendering.getDiagnostics().infrared, 'full');
|
||||
h.postRender.emit();
|
||||
assert.equal(h.layers.length, 1);
|
||||
assert.equal(previous.destroyed, true);
|
||||
assert.equal(previous.removed, true);
|
||||
h.rendering.clear();
|
||||
assert.equal(h.postRender.size, 0);
|
||||
});
|
||||
@@ -1764,7 +1758,7 @@ test('a delayed installation failure retains the replacement and does not throw
|
||||
assert.equal(await stage, true);
|
||||
}
|
||||
const third = h.rendering.setFrame(snapshot, times[2]);
|
||||
h.viewer.imageryLayers.addImageryProvider = () => {
|
||||
h.globe.imagery.add = () => {
|
||||
throw new Error('upload unavailable');
|
||||
};
|
||||
assert.doesNotThrow(() => h.postRender.emit());
|
||||
@@ -2355,12 +2349,13 @@ for (const product of ['radar', 'clouds-regional', 'lightning']) {
|
||||
positionCartographic: { height: 60_000 },
|
||||
};
|
||||
const pending = h.rendering.setFrame({ ...snapshot, product }, times[0]);
|
||||
const options = collection.get(0).imageryProvider.options;
|
||||
assert.equal(options.tileWidth, 256);
|
||||
assert.equal(options.tileHeight, 256);
|
||||
assert.equal(options.maximumLevel, 6);
|
||||
const { spec } = h.layers[0];
|
||||
assert.equal(spec.kind, 'xyz');
|
||||
assert.equal(spec.tileSize, 256);
|
||||
assert.equal(spec.maxLevel, 6);
|
||||
assert.equal(spec.tiling, 'geographic');
|
||||
assert.equal(
|
||||
new URL(options.url, 'https://example.test').searchParams.get('size'),
|
||||
new URL(spec.url, 'https://example.test').searchParams.get('size'),
|
||||
'256',
|
||||
);
|
||||
assert.equal(h.rendering.getDiagnostics().host, 'globe');
|
||||
|
||||
@@ -3,7 +3,8 @@ import {
|
||||
WEATHER_SHELL_HEIGHTS,
|
||||
} from '../weather/shellRendering.js';
|
||||
import { createWindRelief } from './relief.js';
|
||||
import { orderWeatherImagery } from '../weather/imageryOrder.js';
|
||||
import { WEATHER_IMAGERY_Z } from '../weather/imageryOrder.js';
|
||||
import { findGlobe } from '../../render/rendererOf.js';
|
||||
import { NO_IMAGERY_HOST } from '../weather/imageryHost.js';
|
||||
import { msg } from '../../i18n/index.js';
|
||||
import { createWindGpuRendering } from './gpuRendering.js';
|
||||
@@ -69,6 +70,7 @@ export function createWindRendering({
|
||||
}),
|
||||
eventTarget = globalThis.window,
|
||||
createGpuRendering = createWindGpuRendering,
|
||||
globeOf = findGlobe,
|
||||
onStatusChange,
|
||||
} = {}) {
|
||||
let canvas = null;
|
||||
@@ -87,7 +89,6 @@ export function createWindRendering({
|
||||
let reducedMotion = false;
|
||||
let imagery = null;
|
||||
let shell = null;
|
||||
let imageryCollection = null;
|
||||
let imageryKind = null;
|
||||
let imageryError = null;
|
||||
let imageryErrorRemove = null;
|
||||
@@ -297,13 +298,10 @@ export function createWindRendering({
|
||||
function removeImagery() {
|
||||
imageryErrorRemove?.();
|
||||
imageryErrorRemove = null;
|
||||
if (imagery && imageryCollection && !imageryCollection.isDestroyed?.())
|
||||
imageryCollection.remove(imagery, true);
|
||||
else if (imagery && !imagery.isDestroyed?.()) imagery.destroy?.();
|
||||
imagery?.remove();
|
||||
imagery = null;
|
||||
shell?.destroy();
|
||||
shell = null;
|
||||
imageryCollection = null;
|
||||
imageryKind = null;
|
||||
}
|
||||
function updateImageryFade(camera, settled = false) {
|
||||
@@ -336,7 +334,7 @@ export function createWindRendering({
|
||||
return;
|
||||
}
|
||||
if (Math.abs(imagery.alpha - alpha) > 0.005) imagery.alpha = alpha;
|
||||
const show = alpha > 0;
|
||||
const show = alpha > 0 && getHost().kind !== 'none';
|
||||
if (imagery.show !== show) imagery.show = show;
|
||||
}
|
||||
function installImagery() {
|
||||
@@ -344,21 +342,18 @@ export function createWindRendering({
|
||||
imageryError = null;
|
||||
const viewer = viewerReady();
|
||||
if (!snapshot || overlay === 'none' || !viewer) return;
|
||||
const { collection, kind } = getHost();
|
||||
const { kind } = getHost();
|
||||
if (kind === 'none') {
|
||||
imageryError = NO_IMAGERY_HOST;
|
||||
return;
|
||||
}
|
||||
const globe = kind === 'tileset' ? null : globeOf(viewer);
|
||||
const raster = createFieldRaster(snapshot, overlay);
|
||||
if (!raster) {
|
||||
imageryError = fieldUnavailableText(overlay);
|
||||
return;
|
||||
}
|
||||
if (
|
||||
kind === 'tileset'
|
||||
? !cesium.Primitive
|
||||
: !collection || !cesium.SingleTileImageryProvider
|
||||
) {
|
||||
if (kind === 'tileset' ? !cesium.Primitive : !globe) {
|
||||
imageryError = msg('Globe imagery unavailable');
|
||||
return;
|
||||
}
|
||||
@@ -384,21 +379,19 @@ export function createWindRendering({
|
||||
viewer.scene?.requestRender?.();
|
||||
return;
|
||||
}
|
||||
const provider = new cesium.SingleTileImageryProvider({
|
||||
imagery = globe.imagery.add({
|
||||
kind: 'single-image',
|
||||
url: texture.toDataURL('image/png'),
|
||||
tileWidth: raster.width,
|
||||
tileHeight: raster.height,
|
||||
rectangle: cesium.Rectangle.MAX_VALUE,
|
||||
rectangle: { west: -180, south: -90, east: 180, north: 90 },
|
||||
zOrder: WEATHER_IMAGERY_Z.wind,
|
||||
});
|
||||
imagery = collection.addImageryProvider(provider);
|
||||
orderWeatherImagery(collection, imagery, 0);
|
||||
imageryCollection = collection;
|
||||
imagery.drapeOn = 'surface';
|
||||
imageryKind = kind;
|
||||
// Temperature colors carry quantitative meaning; double transparency
|
||||
// blends orange heat into blue ocean and obscures useful gradients.
|
||||
imagery.alpha = overlay === 'temperature' ? 1 : 0.85;
|
||||
if (gpuActive) updateImageryFade(viewer.scene.camera, true);
|
||||
imageryErrorRemove = provider.errorEvent?.addEventListener(() => {
|
||||
imageryErrorRemove = imagery.on('tileError', () => {
|
||||
imageryError = msg('Globe field image unavailable');
|
||||
});
|
||||
viewer.scene?.requestRender?.();
|
||||
@@ -410,7 +403,7 @@ export function createWindRendering({
|
||||
|
||||
function rehome() {
|
||||
if (!snapshot || overlay === 'none') return;
|
||||
const { collection, kind } = getHost();
|
||||
const { kind } = getHost();
|
||||
const wasHidden = imageryError === NO_IMAGERY_HOST;
|
||||
if ((imagery || shell) && kind !== 'none' && kind !== imageryKind) {
|
||||
installImagery();
|
||||
@@ -419,13 +412,11 @@ export function createWindRendering({
|
||||
}
|
||||
// A host without imagery hides the retained shell until a host returns.
|
||||
if (shell && kind === 'none') shell.setShow(false);
|
||||
if (imagery && collection !== imageryCollection) {
|
||||
imageryCollection?.remove(imagery, false);
|
||||
imageryCollection = collection;
|
||||
if (collection) {
|
||||
collection.add(imagery);
|
||||
orderWeatherImagery(collection, imagery, 0);
|
||||
}
|
||||
// Globe imagery stays on the globe, which draws nothing while hidden;
|
||||
// it is hidden too until a host returns.
|
||||
const show = kind !== 'none' && imagery?.alpha > 0;
|
||||
if (imagery && imagery.show !== show) {
|
||||
imagery.show = show;
|
||||
viewerReady()?.scene?.requestRender?.();
|
||||
}
|
||||
if ((gpuActive || kind === 'tileset') && kind !== 'none')
|
||||
|
||||
@@ -4,6 +4,7 @@ import * as Cesium from 'cesium';
|
||||
|
||||
import { createWindRendering } from './rendering.js';
|
||||
import { NO_IMAGERY_HOST } from '../weather/imageryHost.js';
|
||||
import { WEATHER_IMAGERY_Z } from '../weather/imageryOrder.js';
|
||||
import {
|
||||
createShellCesium,
|
||||
createShellScene,
|
||||
@@ -140,28 +141,37 @@ function harness({
|
||||
};
|
||||
const imagery = [];
|
||||
const removed = [];
|
||||
const imageryLayers = {
|
||||
addImageryProvider(provider) {
|
||||
let alpha = 1;
|
||||
const layer = {
|
||||
provider,
|
||||
show: true,
|
||||
alphaWrites: 0,
|
||||
get alpha() {
|
||||
return alpha;
|
||||
},
|
||||
set alpha(value) {
|
||||
alpha = value;
|
||||
this.alphaWrites++;
|
||||
},
|
||||
};
|
||||
imagery.push(layer);
|
||||
return layer;
|
||||
},
|
||||
remove(layer, destroy) {
|
||||
const i = imagery.indexOf(layer);
|
||||
if (i >= 0) imagery.splice(i, 1);
|
||||
removed.push({ layer, destroy });
|
||||
// The viewer's globe port: each layer added, and each removed.
|
||||
const imageryLayers = {};
|
||||
const globe = {
|
||||
imagery: {
|
||||
add(spec) {
|
||||
let alpha = 1;
|
||||
const errors = event();
|
||||
const layer = {
|
||||
spec,
|
||||
errors,
|
||||
show: true,
|
||||
drapeOn: 'all',
|
||||
alphaWrites: 0,
|
||||
get alpha() {
|
||||
return alpha;
|
||||
},
|
||||
set alpha(value) {
|
||||
alpha = value;
|
||||
this.alphaWrites++;
|
||||
},
|
||||
on: (name, cb) =>
|
||||
name === 'tileError' ? errors.addEventListener(cb) : () => {},
|
||||
remove() {
|
||||
const i = imagery.indexOf(layer);
|
||||
if (i >= 0) imagery.splice(i, 1);
|
||||
removed.push({ layer, destroy: true });
|
||||
},
|
||||
};
|
||||
imagery.push(layer);
|
||||
return layer;
|
||||
},
|
||||
},
|
||||
};
|
||||
const viewer = {
|
||||
@@ -214,6 +224,7 @@ function harness({
|
||||
cesium,
|
||||
container,
|
||||
getViewer: () => viewer,
|
||||
globeOf: (given) => (given === viewer ? globe : null),
|
||||
createGpuRendering,
|
||||
onStatusChange,
|
||||
getHost,
|
||||
@@ -397,7 +408,9 @@ test('scalar imagery builds once, survives pause, replaces cleanly, and releases
|
||||
h.rendering.start();
|
||||
assert.equal(h.imagery.length, 1);
|
||||
assert.equal(h.textures.length, 1);
|
||||
assert.equal(h.imagery[0].provider.options.tileWidth, 360);
|
||||
assert.equal(h.imagery[0].spec.kind, 'single-image');
|
||||
assert.equal(h.imagery[0].spec.zOrder, WEATHER_IMAGERY_Z.wind);
|
||||
assert.equal(h.imagery[0].drapeOn, 'surface');
|
||||
h.callbacks.shift()(16);
|
||||
h.callbacks.shift()(50);
|
||||
h.callbacks.shift()(85);
|
||||
@@ -1145,7 +1158,7 @@ for (const overlay of ['speed', 'temperature', 'pressure']) {
|
||||
kind = 'globe';
|
||||
h.rendering.rehome();
|
||||
assert.equal(primitive.destroyed, true);
|
||||
assert.equal(h.imagery[0].provider.options.tileWidth, 360);
|
||||
assert.equal(h.imagery[0].spec.kind, 'single-image');
|
||||
assert.equal(h.imagery[0].alpha, overlay === 'temperature' ? 1 : 0.85);
|
||||
h.rendering.destroy();
|
||||
assert.equal(camera.moveEnd.size, 0);
|
||||
@@ -1193,3 +1206,28 @@ for (const overlay of ['speed', 'temperature', 'pressure']) {
|
||||
h.rendering.destroy();
|
||||
});
|
||||
}
|
||||
|
||||
test('globe imagery hides without a host and shows again when one returns; a failed field image says so', () => {
|
||||
let host = { collection: {}, kind: 'globe' };
|
||||
const h = harness({ getHost: () => host });
|
||||
h.rendering.attach();
|
||||
h.rendering.setOptions({ overlay: 'speed' });
|
||||
h.rendering.setField(FIELD);
|
||||
const [layer] = h.imagery;
|
||||
assert.equal(layer.show, true);
|
||||
host = { collection: null, kind: 'none' };
|
||||
h.rendering.rehome();
|
||||
assert.equal(layer.show, false, 'hidden, not removed');
|
||||
assert.deepEqual(h.imagery, [layer]);
|
||||
host = { collection: {}, kind: 'globe' };
|
||||
h.rendering.rehome();
|
||||
assert.equal(layer.show, true);
|
||||
assert.deepEqual(h.imagery, [layer]);
|
||||
layer.errors.emit();
|
||||
assert.equal(
|
||||
h.rendering.getDiagnostics().imageryError,
|
||||
'Globe field image unavailable',
|
||||
);
|
||||
h.rendering.destroy();
|
||||
assert.equal(h.imagery.length, 0);
|
||||
});
|
||||
@@ -577,3 +577,16 @@ test('a scene with no globe drapes on its base tileset', () => {
|
||||
port.imagery.add({ kind: 'xyz', url: url('a') });
|
||||
assert.equal(tileset.imageryLayers.length, 1);
|
||||
});
|
||||
|
||||
test('a provider that fails to build is told as an error of its root tile', async () => {
|
||||
const { port } = setup();
|
||||
const layer = port.imagery.add({
|
||||
kind: 'single-image',
|
||||
url: 'data:image/png;base64,AAAA',
|
||||
});
|
||||
const errors = [];
|
||||
layer.on('tileError', (error) => errors.push(error));
|
||||
await new Promise((resolve) => setTimeout(resolve, 50));
|
||||
assert.deepEqual(errors, [{ tile: { x: 0, y: 0, level: 0 } }]);
|
||||
layer.remove();
|
||||
});
|
||||
@@ -194,12 +194,26 @@ const decodeTile = (blob) =>
|
||||
* flipped, as Cesium's own bitmaps are.
|
||||
*/
|
||||
async function transformTile(spec, tile, image) {
|
||||
// Straight alpha throughout, as Cesium uploads its own tiles: WebGL does
|
||||
// not premultiply an ImageBitmap, so one premultiplied here stays so.
|
||||
const straight = {
|
||||
premultiplyAlpha: 'none',
|
||||
colorSpaceConversion: 'default',
|
||||
};
|
||||
const upright = await createImageBitmap(
|
||||
image,
|
||||
isBitmap(image) ? FLIPPED : {},
|
||||
isBitmap(image) ? { ...FLIPPED, ...straight } : straight,
|
||||
);
|
||||
const result = await spec.tileTransform(tile, upright);
|
||||
return createImageBitmap(result, FLIPPED);
|
||||
// The input is the hook's until it settles; a bitmap it returns is the
|
||||
// renderer's, spent once copied.
|
||||
let result;
|
||||
try {
|
||||
result = await spec.tileTransform(tile, upright);
|
||||
return await createImageBitmap(result, { ...FLIPPED, ...straight });
|
||||
} finally {
|
||||
if (isBitmap(result) && result !== upright) result.close();
|
||||
upright.close();
|
||||
}
|
||||
}
|
||||
|
||||
/** A hook's synchronous throw as a failed tile, never a throw into the frame. */
|
||||
@@ -527,7 +541,16 @@ export function createCesiumImagery(
|
||||
record.provider = hooked;
|
||||
return hooked;
|
||||
});
|
||||
record.providerPromise.catch(() => {});
|
||||
// A provider that fails to build (its metadata, or a single image)
|
||||
// loads no tile: told as an error of the layer's root tile.
|
||||
record.providerPromise.catch((error) => {
|
||||
if (record.removed || listeners.tileError.size === 0) return;
|
||||
const status = error?.statusCode;
|
||||
listeners.tileError.fire({
|
||||
tile: { x: 0, y: 0, level: 0 },
|
||||
...(Number.isFinite(status) ? { status } : {}),
|
||||
});
|
||||
});
|
||||
} else {
|
||||
record.provider = hookProvider(made, spec, ctx);
|
||||
watchErrors(made);
|
||||
|
||||
@@ -184,8 +184,6 @@
|
||||
"src/layers/vessels/state.js",
|
||||
"src/layers/vessels/tracking.js",
|
||||
"src/layers/weather/index.js",
|
||||
"src/layers/weather/rasterTiles.js",
|
||||
"src/layers/weather/rendering.js",
|
||||
"src/layers/weather/shellRendering.js",
|
||||
"src/layers/wind/gpuRendering.js",
|
||||
"src/layers/wind/index.js",
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
/**
|
||||
* A globe port for tests of code that drapes imagery through the renderer's
|
||||
* globe port (`src/render/contract/globe.d.ts`): it records each layer and
|
||||
* its spec, orders layers by `zOrder` as the contract says, and lets a test
|
||||
* drive tile requests through a layer's hooks and raise its tile errors.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {{settled?: (kind: string) => boolean}} [options]
|
||||
* `settled`: what `isSettled` answers.
|
||||
*/
|
||||
export function fakeGlobePort({ settled = () => true } = {}) {
|
||||
/** Live layers, bottom to top. */
|
||||
const layers = [];
|
||||
/** Every layer ever added, in the order added. */
|
||||
const added = [];
|
||||
let split = 0;
|
||||
let globeVisible = true;
|
||||
|
||||
function add(spec, index) {
|
||||
const listeners = { tileError: new Set(), frameReady: new Set() };
|
||||
const layer = {
|
||||
spec,
|
||||
alpha: 1,
|
||||
show: true,
|
||||
split: 'none',
|
||||
drapeOn: 'all',
|
||||
lit: true,
|
||||
removed: false,
|
||||
on(event, cb) {
|
||||
listeners[event]?.add(cb);
|
||||
return () => listeners[event]?.delete(cb);
|
||||
},
|
||||
raise() {
|
||||
const i = layers.indexOf(layer);
|
||||
if (i < 0 || i === layers.length - 1) return;
|
||||
layers.splice(i, 1);
|
||||
layers.splice(i + 1, 0, layer);
|
||||
},
|
||||
lower() {
|
||||
const i = layers.indexOf(layer);
|
||||
if (i <= 0) return;
|
||||
layers.splice(i, 1);
|
||||
layers.splice(i - 1, 0, layer);
|
||||
},
|
||||
remove() {
|
||||
if (layer.removed) return;
|
||||
layer.removed = true;
|
||||
layers.splice(layers.indexOf(layer), 1);
|
||||
listeners.tileError.clear();
|
||||
listeners.frameReady.clear();
|
||||
},
|
||||
/**
|
||||
* Ask for a tile as the renderer would: `admit` decides, and an issued
|
||||
* request runs `fetch` (the renderer's own fetch) then `tileTransform`.
|
||||
* @param {{x: number, y: number, level: number}} tile
|
||||
* @param {() => Promise<unknown> | undefined} fetch
|
||||
*/
|
||||
request(tile, fetch) {
|
||||
const issue = () => {
|
||||
const started = fetch();
|
||||
if (!started || !spec.tileTransform) return started;
|
||||
return Promise.resolve(started).then((image) =>
|
||||
spec.tileTransform(tile, image),
|
||||
);
|
||||
};
|
||||
return spec.admit ? spec.admit(tile, issue) : issue();
|
||||
},
|
||||
/** Tell the layer's `tileError` listeners. */
|
||||
fail(error) {
|
||||
for (const cb of [...listeners.tileError]) cb(error);
|
||||
},
|
||||
listenerCount: (event) => listeners[event]?.size ?? 0,
|
||||
};
|
||||
let at = index;
|
||||
if (at === undefined) {
|
||||
const z = Number.isFinite(spec.zOrder) ? spec.zOrder : 0;
|
||||
at = layers.length;
|
||||
while (at > 0 && (layers[at - 1].spec.zOrder ?? 0) > z) at -= 1;
|
||||
}
|
||||
layers.splice(Math.max(0, Math.min(at, layers.length)), 0, layer);
|
||||
added.push(layer);
|
||||
return layer;
|
||||
}
|
||||
|
||||
return {
|
||||
layers,
|
||||
added,
|
||||
imagery: {
|
||||
add,
|
||||
list: () => layers.slice(),
|
||||
getSplit: () => split,
|
||||
setSplit: (x01) => {
|
||||
split = Math.min(1, Math.max(0, Number(x01)));
|
||||
},
|
||||
},
|
||||
isSettled: (kind) => settled(kind),
|
||||
setGlobeVisible(visible) {
|
||||
globeVisible = Boolean(visible);
|
||||
},
|
||||
get globeVisible() {
|
||||
return globeVisible;
|
||||
},
|
||||
on: () => () => {},
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user