Compare commits

..
Author SHA1 Message Date
Mazeyar Moeini FeizabadiandClaude Fable 5.2 45657b66fa docs(changelog): add the #1704 fragment
Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 16:05:51 +01:00
Mazeyar Moeini FeizabadiandClaude Fable 5.2 f1869ff52c fix(camera): keep a wheel zoom at the screen centre from stopping the globe
Above 1,000 km Cesium's wheel zoom turns the globe from the point under the
screen centre towards the point under the pointer. With the pointer on the
centre pixel the two are the same point; the dot product of its unit normal
with itself often rounds to just under 1, so Cesium rotates about their cross
product, which is the zero vector. Camera.rotate throws "normalized result is
not a number" from Scene.initializeFrame and the render loop stops until the
page is reloaded.

Guard camera.rotate against an axis it cannot normalize, and restart the
render loop from the last drawn pose when any error stops it, up to three
times in ten seconds.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
2026-11-13 14:50:21 +01:00
14 changed files with 449 additions and 245 deletions

No files matched your search

@@ -0,0 +1,5 @@
- Fix rendering stopping for good after a wheel zoom with the pointer on the
centre of a whole-globe view. Cesium's zoom could ask the camera to rotate
about a zero axis; that rotation is now ignored, and a render loop stopped by
any error is restarted from the last drawn camera pose, up to three times in
ten seconds (mazy1998, #1704).
-3
View File
@@ -1,3 +0,0 @@
- Halve the time the satellite cloud image takes to prepare on the 3D Tiles
map by applying its transparency curve from a lookup table, in place
(mazy1998, #1713).
@@ -1,3 +0,0 @@
- Satellite clouds on the 3D Tiles map apply their transparency in the shader
instead of rewriting each 4096 x 2048 image on the page, and changing the
cloud strength no longer builds a new image (mazy1998, #1721).
+4 -6
View File
@@ -891,11 +891,9 @@ image proxy accepts `bbox=west,south,east,north` for every product: inside the
product bounds, 2:1 within 1 %, rounded to 0.25°, up to 4096×2048 (the
default), cached by product, time, size and bbox. Diagnostics report
`shell.detail` (`bbox`, `size`, `ready`, `enabled`).
Clouds only applies a soft brightness ramp, using
Clouds only applies a soft brightness ramp to decoded pixels once, using
Cesium's sRGB-to-linear conversion (`channel ** 2.2`) and smoothstep from 0.40
to 0.70. Globe hosts apply it to decoded pixels once; a shell applies the same
ramp in its fragment shader from a strength uniform, so its images are drawn
as decoded and a strength change neither fetches nor rewrites an image. The old 0.55 threshold is the ramp midpoint. RGB and source alpha are
to 0.70. The old 0.55 threshold is the ramp midpoint. RGB and source alpha are
preserved in Full image mode; both modes use the chosen layer opacity. This
is a display filter, not a cloud mask. The cloud-filter slider is a continuous
0–100% strength: 0% is Full, 100% is the existing Clouds only key, and
@@ -911,13 +909,13 @@ and processes it before staging. Globe hosts crop that canvas into 256 px tiles
to maximum level 3 on a geographic 2×1 root grid bounded to the manifest extent,
avoiding request-dependent contrast seams.
On globe hosts, regional infrared retains network tiles and processes each
decoded tile once; shells never read a frame's pixels back.
decoded tile once; shells process each whole frame once.
Exact-time tile and image responses are immutable for 24 hours; manifests and
errors remain uncached. Each globe renderer retains up to 6 processed global
mosaics in a least-recently-used cache keyed by observation time and infrared
mode (up to 48 MiB of canvas pixels). Each shell keeps decoded full-extent and
detail images in one least-recently-used cache bounded at 128 MiB, keyed by
time and window: the shown frame and the warmed next frame, each
time, mode and window: the shown frame and the warmed next frame, each
full-extent and detail; nothing older survives them. Disable clears the caches.
Cache hits skip
fetch/decode and report `mosaic.cached: true` with zero decode time.
+2
View File
@@ -207,6 +207,7 @@
"modules": [
"src/app/viewer.js",
"src/app/atmosphereCompat.js",
"src/app/renderRecovery.js",
"src/globeInView.js",
"src/sky/starrySky.js",
"src/sky/stars.js",
@@ -2610,6 +2611,7 @@
"src/sky/starrySky.js",
"src/sky/stars.js",
"src/app/atmosphereCompat.js",
"src/app/renderRecovery.js",
"src/bloom.js",
"src/camera.js",
"src/cameraGroundGuard.js",
+155
View File
@@ -0,0 +1,155 @@
/**
* Keeps one bad frame from stopping the globe for good.
*
* Cesium's render loop stops itself on the first error a frame throws and
* leaves an error panel over the canvas; nothing restarts it short of a
* reload. Two things here:
*
* 1. `guardDegenerateRotation` removes one such error at its cause. Zooming
* with the wheel above 1,000 km, Cesium turns the globe from the point under
* the screen centre towards the point under the pointer
* (`ScreenSpaceCameraController` `handleZoom`): it normalizes both points,
* takes their dot product, and rotates about their cross product when the
* dot product is below 1. With the pointer on the centre pixel the two
* points are the same, but a unit vector's dot product with itself often
* rounds to 0.9999999999999999, so the check passes and the cross product is
* the zero vector. `Camera.rotate` then normalizes it and throws
* "normalized result is not a number" from `Scene.initializeFrame`, which
* runs outside the scene's own error handling. Builds without Cesium's
* debug checks would write NaN into the camera instead.
*
* 2. `installRenderRecovery` restarts the loop after any error that stops it,
* from the last pose a frame was drawn with, a bounded number of times.
*/
import * as Cesium from 'cesium';
import { governorRequestRender } from '../renderGovernor.js';
/** Restarts allowed within RECOVERY_WINDOW_MS before the error is left to stand. */
export const RECOVERY_LIMIT = 3;
/** An error that keeps coming back this fast is not one a restart gets past. */
export const RECOVERY_WINDOW_MS = 10_000;
/**
* Make `camera.rotate` ignore an axis it cannot normalize (zero or not finite)
* and an angle that is not finite. There is nothing to rotate about, so the
* camera stays where it is and the caller carries on; Cesium's wheel zoom
* still moves the camera in after the skipped turn.
* @param {Cesium.Camera} camera
* @returns {() => void} Restore the camera's own rotate.
*/
export function guardDegenerateRotation(camera) {
const own = Object.hasOwn(camera, 'rotate');
const rotate = camera.rotate;
const guarded = function (axis, angle) {
if (axis) {
const magnitudeSquared = Cesium.Cartesian3.magnitudeSquared(axis);
if (
!(magnitudeSquared > 0) ||
!Number.isFinite(magnitudeSquared) ||
(angle !== undefined && !Number.isFinite(angle))
)
return;
}
return rotate.call(this, axis, angle);
};
camera.rotate = guarded;
return () => {
if (camera.rotate !== guarded) return;
if (own) camera.rotate = rotate;
else delete camera.rotate;
};
}
function finite(cartesian) {
return (
Number.isFinite(cartesian?.x) &&
Number.isFinite(cartesian?.y) &&
Number.isFinite(cartesian?.z)
);
}
/**
* Restart Cesium's render loop when an error stops it.
*
* Cesium reports a stopped loop only through `showErrorPanel`: errors thrown
* while a frame is prepared (camera input, in `Scene.initializeFrame`) never
* reach `scene.renderError`, so that event alone would miss them. The panel
* call is the one place both kinds of stop pass through, after the loop is
* already off.
*
* On a stop this puts the camera back on the last pose a frame was drawn
* with, discards the input that was being applied (Cesium skips its own reset
* when the frame throws, so the same gesture would otherwise run again), and
* turns the loop back on. After RECOVERY_LIMIT restarts inside
* RECOVERY_WINDOW_MS the error is shown as before and rendering stays stopped.
* @param {Cesium.Viewer} viewer
* @param {object} [options]
* @param {() => number} [options.now]
* @param {(reason: string) => void} [options.requestRender]
* @returns {() => void} Idempotent disposer.
*/
export function installRenderRecovery(
viewer,
{ now = () => performance.now(), requestRender = governorRequestRender } = {},
) {
const widget = viewer?.cesiumWidget;
const scene = viewer?.scene;
const camera = viewer?.camera;
if (!widget?.showErrorPanel || !scene?.postRender || !camera)
throw new TypeError('A complete Cesium viewer is required');
// The pose of the last frame that drew: three vector copies a frame.
const position = new Cesium.Cartesian3();
const direction = new Cesium.Cartesian3();
const up = new Cesium.Cartesian3();
let hasPose = false;
const removePostRender = scene.postRender.addEventListener(() => {
if (!finite(camera.position) || !finite(camera.direction)) return;
Cesium.Cartesian3.clone(camera.position, position);
Cesium.Cartesian3.clone(camera.direction, direction);
Cesium.Cartesian3.clone(camera.up, up);
hasPose = true;
});
const recoveredAt = [];
const own = Object.hasOwn(widget, 'showErrorPanel');
const showErrorPanel = widget.showErrorPanel;
const recovering = function (title, message, error) {
const at = now();
while (recoveredAt.length && at - recoveredAt[0] > RECOVERY_WINDOW_MS)
recoveredAt.shift();
// Only a stopped loop is restarted; other panels (a failed start-up, a
// caller's own message) are shown as they are.
if (
viewer.useDefaultRenderLoop !== false ||
recoveredAt.length >= RECOVERY_LIMIT
)
return showErrorPanel.call(this, title, message, error);
recoveredAt.push(at);
console.error(
`[viewer] render loop stopped by an error; restarting (${recoveredAt.length} of ${RECOVERY_LIMIT})`,
error,
);
if (hasPose) {
Cesium.Cartesian3.clone(position, camera.position);
Cesium.Cartesian3.clone(direction, camera.direction);
Cesium.Cartesian3.clone(up, camera.up);
Cesium.Cartesian3.cross(camera.direction, camera.up, camera.right);
}
// Cesium has no public way to drop the input a failed frame left queued.
scene.screenSpaceCameraController?._aggregator?.reset?.();
viewer.useDefaultRenderLoop = true;
requestRender('render-recovery');
};
widget.showErrorPanel = recovering;
let active = true;
return () => {
if (!active) return;
active = false;
removePostRender?.();
if (widget.showErrorPanel !== recovering) return;
if (own) widget.showErrorPanel = showErrorPanel;
else delete widget.showErrorPanel;
};
}
+220
View File
@@ -0,0 +1,220 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import {
guardDegenerateRotation,
installRenderRecovery,
RECOVERY_LIMIT,
RECOVERY_WINDOW_MS,
} from './renderRecovery.js';
/** Cesium's own Camera.rotate on a camera-shaped object, with no scene behind it. */
function cameraFixture() {
const camera = Object.create(Cesium.Camera.prototype);
camera.position = new Cesium.Cartesian3(28_378_137, 0, 0);
camera.direction = new Cesium.Cartesian3(-1, 0, 0);
camera.up = new Cesium.Cartesian3(0, 0, 1);
camera.right = new Cesium.Cartesian3(0, 1, 0);
camera._adjustOrthographicFrustum = () => {};
return camera;
}
const pose = (camera) =>
[camera.position, camera.direction, camera.up, camera.right].map((v) =>
Cesium.Cartesian3.clone(v),
);
test("the wheel zoom's own arithmetic hands Camera.rotate a zero axis", () => {
// What handleZoom computes with the pointer on the centre pixel: the same
// picked point twice. The dot product rounds below 1, the cross product is 0.
const picked = Cesium.Cartesian3.fromDegrees(-41.11, -13.37);
const pickedNormal = Cesium.Cartesian3.normalize(
picked,
new Cesium.Cartesian3(),
);
const centreNormal = Cesium.Cartesian3.normalize(
picked,
new Cesium.Cartesian3(),
);
const axis = Cesium.Cartesian3.cross(
pickedNormal,
centreNormal,
new Cesium.Cartesian3(),
);
assert.deepEqual([axis.x, axis.y, axis.z], [0, 0, 0]);
const unguarded = cameraFixture();
assert.throws(() => unguarded.rotate(axis, 0.01), /not a number/);
const camera = cameraFixture();
const before = pose(camera);
guardDegenerateRotation(camera);
assert.doesNotThrow(() => camera.rotate(axis, 0.01));
assert.deepEqual(pose(camera), before);
});
test('an axis or angle that is not finite leaves the camera where it is', () => {
const camera = cameraFixture();
const before = pose(camera);
guardDegenerateRotation(camera);
camera.rotate(new Cesium.Cartesian3(NaN, 0, 1), 0.01);
camera.rotate(new Cesium.Cartesian3(Infinity, 0, 1), 0.01);
camera.rotate(Cesium.Cartesian3.UNIT_Z, NaN);
camera.rotate(Cesium.Cartesian3.UNIT_Z, Infinity);
assert.deepEqual(pose(camera), before);
});
test('an ordinary rotation is exactly what Cesium does unguarded', () => {
const axis = new Cesium.Cartesian3(0.2, -0.5, 0.84);
const plain = cameraFixture();
plain.rotate(axis, 0.37);
plain.rotate(Cesium.Cartesian3.UNIT_Z);
const camera = cameraFixture();
const restore = guardDegenerateRotation(camera);
camera.rotate(axis, 0.37);
// No angle: Cesium's default amount still applies.
camera.defaultRotateAmount = plain.defaultRotateAmount;
camera.rotate(Cesium.Cartesian3.UNIT_Z);
assert.deepEqual(pose(camera), pose(plain));
restore();
assert.equal(Object.hasOwn(camera, 'rotate'), false);
assert.equal(camera.rotate, Cesium.Camera.prototype.rotate);
});
/** Vector equality as Cesium has it: a recomputed right vector may hold -0. */
function assertPose(camera, expected) {
pose(camera).forEach((vector, i) =>
assert.ok(Cesium.Cartesian3.equals(vector, expected[i]), `vector ${i}`),
);
}
function viewerFixture() {
const postRender = new Cesium.Event();
const panels = [];
const resets = [];
const camera = cameraFixture();
const viewer = {
camera,
useDefaultRenderLoop: true,
cesiumWidget: {
showErrorPanel(title, message, error) {
panels.push({ title, message, error });
},
},
scene: {
postRender,
screenSpaceCameraController: {
_aggregator: { reset: () => resets.push(true) },
},
},
};
// What Cesium's loop does when a frame throws.
const fail = (error = new Error('frame failed')) => {
viewer.useDefaultRenderLoop = false;
viewer.cesiumWidget.showErrorPanel('Rendering has stopped.', undefined, error);
};
return { viewer, camera, postRender, panels, resets, fail };
}
function quietly(run) {
const original = console.error;
const logged = [];
console.error = (...args) => logged.push(args);
try {
run();
} finally {
console.error = original;
}
return logged;
}
test('a stopped render loop restarts from the last drawn pose', () => {
const { viewer, camera, postRender, panels, resets, fail } = viewerFixture();
const requests = [];
installRenderRecovery(viewer, {
now: () => 0,
requestRender: (reason) => requests.push(reason),
});
postRender.raiseEvent();
const drawn = pose(camera);
// The failed frame left the camera unusable.
camera.position.x = NaN;
camera.direction.y = NaN;
const error = new Error('normalized result is not a number');
const logged = quietly(() => fail(error));
assert.equal(viewer.useDefaultRenderLoop, true);
assert.deepEqual(panels, []);
assertPose(camera, drawn);
assert.deepEqual(resets, [true]);
assert.deepEqual(requests, ['render-recovery']);
assert.equal(logged.length, 1);
assert.equal(logged[0][1], error);
});
test('a frame drawn with a broken camera is not kept as the pose to return to', () => {
const { viewer, camera, postRender, fail } = viewerFixture();
installRenderRecovery(viewer, { now: () => 0, requestRender: () => {} });
postRender.raiseEvent();
const drawn = pose(camera);
camera.position.x = NaN;
postRender.raiseEvent();
quietly(() => fail());
assertPose(camera, drawn);
});
test('an error that keeps returning is shown and rendering stays stopped', () => {
const { viewer, panels, fail } = viewerFixture();
let at = 0;
installRenderRecovery(viewer, { now: () => at, requestRender: () => {} });
quietly(() => {
for (let i = 0; i < RECOVERY_LIMIT; i++) {
at += 100;
fail();
assert.equal(viewer.useDefaultRenderLoop, true, `restart ${i + 1}`);
}
at += 100;
fail();
});
assert.equal(viewer.useDefaultRenderLoop, false);
assert.equal(panels.length, 1);
assert.equal(panels[0].title, 'Rendering has stopped.');
// Once the window has passed, a later, unrelated error is recovered again.
at += RECOVERY_WINDOW_MS + 1;
quietly(() => fail());
assert.equal(viewer.useDefaultRenderLoop, true);
assert.equal(panels.length, 1);
});
test('a panel shown while the loop is running is left alone', () => {
const { viewer, panels, resets } = viewerFixture();
installRenderRecovery(viewer, { now: () => 0, requestRender: () => {} });
viewer.cesiumWidget.showErrorPanel('Error constructing CesiumWidget.', 'x');
assert.equal(panels.length, 1);
assert.deepEqual(resets, []);
});
test('disposing restores the widget and stops recording poses', () => {
const { viewer, postRender, panels, fail } = viewerFixture();
const original = viewer.cesiumWidget.showErrorPanel;
const dispose = installRenderRecovery(viewer, {
now: () => 0,
requestRender: () => {},
});
assert.equal(postRender.numberOfListeners, 1);
dispose();
dispose();
assert.equal(postRender.numberOfListeners, 0);
assert.equal(viewer.cesiumWidget.showErrorPanel, original);
fail();
assert.equal(viewer.useDefaultRenderLoop, false);
assert.equal(panels.length, 1);
});
test('an incomplete viewer is refused', () => {
assert.throws(() => installRenderRecovery({}), TypeError);
});
+9
View File
@@ -1,5 +1,9 @@
import * as Cesium from 'cesium';
import { applyModelAtmosphereWorkaround } from './atmosphereCompat.js';
import {
guardDegenerateRotation,
installRenderRecovery,
} from './renderRecovery.js';
import { StarrySky } from '../sky/starrySky.js';
import {
FREE_LOOK_MAX_HEIGHT_METERS,
@@ -415,6 +419,11 @@ export function createApplicationViewer({ container, creditContainer }) {
if (globalThis.matchMedia?.('(pointer: coarse)').matches)
viewer.scene.screenSpaceCameraController.zoomFactor *= 3;
limitZoomOut(viewer);
// Cesium's wheel zoom can hand the camera a zero rotation axis and stop
// the render loop for good; and whatever else stops it, restart it rather
// than leave the globe dead until a reload. See app/renderRecovery.js.
guardDegenerateRotation(viewer.camera);
installRenderRecovery(viewer);
// Before any tile builds a draw command: Cesium's per-vertex model
// atmosphere fails to LINK on Apple's Metal backend and kills the
// render loop. See app/atmosphereCompat.js.
+13 -36
View File
@@ -1,31 +1,22 @@
export const INFRARED_ALPHA_T0 = 0.4;
export const INFRARED_ALPHA_T1 = 0.7;
/** How much of the cloud key applies, 0–1, for a display mode or a 0–100
* strength. The weather shell passes it to its fragment shader. */
export function infraredAmount(strength) {
return strength === 'full'
? 0
: strength === 'filtered' || !Number.isFinite(strength)
? 1
: Math.max(0, Math.min(100, strength)) / 100;
}
/** Scale each pixel's alpha in place; RGB is left as it is. The scale depends
* only on the brightest channel, so it is worked out once for each of the 256
* byte values instead of once per pixel: a 4096×2048 image has 8.4 million
* pixels and the power curve per pixel held the page for over 100 ms. The
* table holds the same numbers the per-pixel formula produced, so the output
* bytes are unchanged.
/** Return display pixels without changing RGB or the source RGBA bytes.
* `strength` is 0–100: zero is the full image and 100 is the cloud key.
*/
export function applyInfraredAlpha(pixels, strength = 'filtered') {
const amount = infraredAmount(strength);
export function infraredAlpha(rgba, strength = 'filtered') {
const pixels = new Uint8ClampedArray(rgba);
const amount =
strength === 'full'
? 0
: strength === 'filtered' || !Number.isFinite(strength)
? 1
: Math.max(0, Math.min(100, strength)) / 100;
if (amount === 0) return pixels;
const scale = new Float64Array(256);
for (let value = 0; value < 256; value++) {
for (let i = 0; i < pixels.length; i += 4) {
// Match Cesium's czm_srgbToLinear conversion in draped imagery.
const linearMax = (value / 255) ** 2.2;
const linearMax =
(Math.max(rgba[i], rgba[i + 1], rgba[i + 2]) / 255) ** 2.2;
const t = Math.max(
0,
Math.min(
@@ -35,21 +26,7 @@ export function applyInfraredAlpha(pixels, strength = 'filtered') {
),
);
const filtered = t * t * (3 - 2 * t);
scale[value] = 1 - amount + filtered * amount;
}
for (let i = 0; i < pixels.length; i += 4) {
const r = pixels[i];
const g = pixels[i + 1];
const b = pixels[i + 2];
const max = r > g ? (r > b ? r : b) : g > b ? g : b;
pixels[i + 3] = pixels[i + 3] * scale[max];
pixels[i + 3] = rgba[i + 3] * (1 - amount + filtered * amount);
}
return pixels;
}
/** Return display pixels without changing RGB or the source RGBA bytes.
* `strength` is 0–100: zero is the full image and 100 is the cloud key.
*/
export function infraredAlpha(rgba, strength = 'filtered') {
return applyInfraredAlpha(new Uint8ClampedArray(rgba), strength);
}
-41
View File
@@ -1,7 +1,6 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import {
applyInfraredAlpha,
infraredAlpha,
INFRARED_ALPHA_T0,
INFRARED_ALPHA_T1,
@@ -62,43 +61,3 @@ test('full infrared preserves every channel including partial and zero alpha', (
]);
assert.deepEqual(infraredAlpha(pixels, 'full'), pixels);
});
test('the lookup table gives the per-pixel curve byte for byte, in place', () => {
// The transfer as it was written per pixel, before the table.
const perPixel = (rgba, amount) => {
const out = new Uint8ClampedArray(rgba);
for (let i = 0; i < out.length; i += 4) {
const linearMax =
(Math.max(rgba[i], rgba[i + 1], rgba[i + 2]) / 255) ** 2.2;
const t = Math.max(
0,
Math.min(
1,
(linearMax - INFRARED_ALPHA_T0) /
(INFRARED_ALPHA_T1 - INFRARED_ALPHA_T0),
),
);
out[i + 3] = rgba[i + 3] * (1 - amount + t * t * (3 - 2 * t) * amount);
}
return out;
};
// Every brightest-channel value in each channel, against a spread of alphas.
const bytes = [];
for (let value = 0; value < 256; value++)
for (const alpha of [0, 1, 37, 128, 200, 254, 255]) {
bytes.push(value, 0, 0, alpha);
bytes.push(value >> 1, value, 0, alpha);
bytes.push(0, value >> 2, value, alpha);
}
const source = new Uint8ClampedArray(bytes);
for (const strength of [1, 33, 50, 99, 100, 'filtered', Number.NaN]) {
const amount = Number.isFinite(strength) ? strength / 100 : 1;
const pixels = source.slice();
assert.equal(applyInfraredAlpha(pixels, strength), pixels);
assert.deepEqual(pixels, perPixel(source, amount), `strength ${strength}`);
}
for (const strength of [0, 'full']) {
const pixels = source.slice();
assert.deepEqual(applyInfraredAlpha(pixels, strength), source);
}
});
+6 -18
View File
@@ -6,7 +6,7 @@ import {
drawWeatherPixels,
closeWeatherPixels,
} from './source.js';
import { applyInfraredAlpha } from './infraredAlpha.js';
import { infraredAlpha } from './infraredAlpha.js';
export const MAX_MOSAIC_BYTES = 4 * 1024 * 1024;
@@ -31,22 +31,13 @@ export function processInfraredImage(
function applyInfraredTransfer(context, canvas, mode) {
const pixels = context.getImageData(0, 0, canvas.width, canvas.height);
// In place: a copy of a 4096×2048 image is 33 MB, made and written back.
applyInfraredAlpha(pixels.data, mode);
pixels.data.set(infraredAlpha(pixels.data, mode));
context.putImageData(pixels, 0, 0);
}
/** Draw pixels a frame source supplied into a new canvas, with the display
* transfer for infrared products, and release them. They must be `size`. */
function drawSuppliedImage(
pixels,
product,
mode,
size,
signal,
createCanvas,
transfer,
) {
function drawSuppliedImage(pixels, product, mode, size, signal, createCanvas) {
try {
signal.throwIfAborted();
const { width, height } = weatherPixelSize(pixels);
@@ -57,7 +48,7 @@ function drawSuppliedImage(
texture.height = height;
const context = texture.getContext('2d');
drawWeatherPixels(context, pixels);
if (transfer && (product === 'clouds' || product === 'clouds-regional'))
if (product === 'clouds' || product === 'clouds-regional')
applyInfraredTransfer(context, texture, mode);
return texture;
} finally {
@@ -97,8 +88,7 @@ export function decodeInfraredImage(blob, signal) {
}
/** Fetch one capped whole-extent frame, or a `bbox` detail window of it, and draw
* it into a canvas. Infrared frames get the display transfer unless `transfer`
* is false, for a caller that applies it when drawing; a canvas also keeps
* it into a canvas. Infrared frames get the display transfer; a canvas also keeps
* Cesium's texture row order, which an ImageBitmap upload would not. The decoded
* image is always released. With a `frameSource` that has `getImage`, the host
* supplies the decoded pixels instead and nothing is fetched or decoded here. */
@@ -117,7 +107,6 @@ export async function acquireWeatherImage(
now = () => performance.now(),
onFetched = () => {},
frameSource = null,
transfer = true,
},
) {
if (frameSource?.getImage) {
@@ -138,7 +127,6 @@ export async function acquireWeatherImage(
size,
signal,
createCanvas,
transfer,
);
return { texture, decodeMs: now() - started };
}
@@ -159,7 +147,7 @@ export async function acquireWeatherImage(
if (image.width !== size.width || image.height !== size.height)
throw new Error('Invalid weather image dimensions');
let texture;
if (transfer && (product === 'clouds' || product === 'clouds-regional'))
if (product === 'clouds' || product === 'clouds-regional')
texture = processInfraredImage(image, mode, createCanvas);
else {
texture = createCanvas();
-69
View File
@@ -26,75 +26,6 @@ function canvas() {
return output;
}
test('the transfer is applied to the canvas pixels in place, with no copy written back', () => {
let read = null;
const output = {};
output.getContext = () => ({
drawImage() {},
getImageData: () => {
read = { data: new Uint8ClampedArray([194, 0, 0, 200]) };
// A second full-size buffer copied over the first is what this guards.
read.data.set = () => {
throw new Error('the canvas pixels were overwritten from a copy');
};
return read;
},
putImageData: (pixels) => {
output.pixels = pixels;
},
});
processInfraredImage({ width: 1, height: 1 }, 'filtered', () => output);
assert.equal(output.pixels, read);
assert.deepEqual([...read.data], [194, 0, 0, 98]);
});
test('with transfer off an infrared frame is drawn and never read back', async () => {
const drawn = [];
const createCanvas = () => {
const output = {};
output.getContext = () => ({
drawImage: (image) => drawn.push(image),
getImageData: () => {
throw new Error('the frame was read back on the page');
},
putImageData: () => {
throw new Error('the frame was rewritten on the page');
},
});
return output;
};
const size = { width: 4096, height: 2048 };
const image = { ...size, close() {} };
const options = {
signal: new AbortController().signal,
mode: 'filtered',
size,
maxBytes: 1024,
createCanvas,
transfer: false,
};
const fetched = await acquireWeatherImage(
'clouds-regional',
'2026-09-15T20:00:00.000Z',
{
...options,
fetchImpl: async () => ({
ok: true,
headers: new Headers(),
arrayBuffer: async () => new ArrayBuffer(1),
}),
decodeImage: async () => image,
},
);
assert.equal(fetched.texture.width, 4096);
const supplied = { ...size };
await acquireWeatherImage('clouds-regional', '2026-09-15T20:00:00.000Z', {
...options,
frameSource: { getImage: async () => supplied },
});
assert.deepEqual(drawn, [image, supplied]);
});
test('decoded pixels are processed once on a same-sized canvas', () => {
const image = { width: 1, height: 1 };
const output = processInfraredImage(image, 'filtered', canvas);
+17 -34
View File
@@ -1,9 +1,4 @@
import { acquireWeatherImage } from './infraredImage.js';
import {
INFRARED_ALPHA_T0,
INFRARED_ALPHA_T1,
infraredAmount,
} from './infraredAlpha.js';
import { imageryHostStatus } from './imageryHost.js';
import { WEATHER_DETAIL_SIZE, WEATHER_IMAGE_SIZES } from './source.js';
import { msg } from '../../i18n/index.js';
@@ -41,10 +36,6 @@ const LIFT_STEP = 500;
// draw nothing until the full-extent image has arrived, and sample the detail
// image only once it has arrived. The window is west, south, east, north in the
// full-extent image's texture coordinates.
// `infrared` is how much of the cloud key applies, 0–1 (infraredAlpha.js has
// the same curve for the globe's draped imagery). It is applied here, to the
// image as it was decoded, so a 4096×2048 frame is never read back and
// rewritten on the page, and a strength change is one uniform, not a new image.
const MATERIAL_SOURCE = `czm_material czm_getMaterial(czm_materialInput materialInput)
{
czm_material material = czm_getDefaultMaterial(materialInput);
@@ -55,8 +46,7 @@ const MATERIAL_SOURCE = `czm_material czm_getMaterial(czm_materialInput material
float useDetail = inside * step(1.5, float(detailDimensions.x));
vec4 c = mix(coarse, texture(detail, clamp(dst, 0.0, 1.0)), useDetail);
material.diffuse = czm_gammaCorrect(c.rgb);
float key = smoothstep(${INFRARED_ALPHA_T0.toFixed(4)}, ${INFRARED_ALPHA_T1.toFixed(4)}, pow(max(c.r, max(c.g, c.b)), 2.2));
material.alpha = c.a * mix(1.0, key, infrared) * alpha * step(1.5, float(imageDimensions.x));
material.alpha = c.a * alpha * step(1.5, float(imageDimensions.x));
return material;
}
`;
@@ -73,7 +63,6 @@ function registerMaterial(cesium) {
image: cesium.Material.DefaultImageId,
detail: cesium.Material.DefaultImageId,
alpha: 1,
infrared: 0,
window: { type: 'vec4', x: 0, y: 0, z: -1, w: -1 },
},
// Diffuse and alpha share these samples, so one source, not components.
@@ -256,12 +245,6 @@ export function createShellSurface({
material.uniforms.alpha = value;
scene.requestRender();
},
/** How much of the infrared cloud key applies, 0–1. */
setInfrared(value) {
if (destroyed || material.uniforms.infrared === value) return;
material.uniforms.infrared = value;
scene.requestRender();
},
/** Draw `next` inside `rect` (west, south, east, north in the full-extent
* image's texture coordinates, 0–1); null clears it. In the same window only
* the image changes, and Cesium keeps drawing the previous texture until
@@ -455,11 +438,10 @@ export function createWeatherShell({
const visible = () => !hidden && !suspended();
const boundsKey = ({ west, south, east, north }) =>
`${west},${south},${east},${north}`;
// One image per time and window: the infrared mode is a uniform, not pixels.
const cacheKey = (time, box = null) =>
box ? `${time}|${boundsKey(box)}` : time;
const cacheKey = (time, mode, box = null) =>
`${time}|${infrared ? mode : 'none'}${box ? `|${boundsKey(box)}` : ''}`;
const wantedDetail = () =>
current && view ? cacheKey(current.time, view) : null;
current && view ? cacheKey(current.time, current.infrared, view) : null;
function evict(keep = []) {
const kept = new Set([...keep, current?.key, detail?.key]);
@@ -472,11 +454,12 @@ export function createWeatherShell({
}
async function acquire(
time,
mode,
signal,
{ box = null, keep = [], onFetched } = {},
) {
signal.throwIfAborted();
const key = cacheKey(time, box);
const key = cacheKey(time, mode, box);
const entry = images.get(key);
if (entry) {
images.delete(key);
@@ -485,8 +468,7 @@ export function createWeatherShell({
}
const result = await acquireWeatherImage(product, time, {
signal,
// The surface's shader applies the infrared transfer.
transfer: false,
mode,
size: box ? detailSize : size,
bbox: box,
maxBytes: MAX_IMAGE_BYTES,
@@ -582,7 +564,9 @@ export function createWeatherShell({
const job = { key, box: view, controller: new AbortController() };
detailJob = job;
job.timeout = setTimeout(() => job.controller.abort(), timeoutMs);
void acquire(current.time, job.controller.signal, { box: view })
void acquire(current.time, current.infrared, job.controller.signal, {
box: view,
})
.then(({ texture }) => installDetail(job, texture))
.catch(() => failDetail(job));
}
@@ -677,7 +661,6 @@ export function createWeatherShell({
loadMs: now() - frame.startedAt,
};
surface.setAlpha(alpha);
surface.setInfrared(infrared ? infraredAmount(frame.infrared) : 0);
applyVisibility();
lastError = null;
evict();
@@ -732,7 +715,7 @@ export function createWeatherShell({
return changed;
},
cancelPrefetch,
async prefetch(snapshot, time) {
async prefetch(snapshot, time, { infrared: mode = 'filtered' } = {}) {
let job;
try {
if (
@@ -746,8 +729,8 @@ export function createWeatherShell({
// Warm the next frame's detail window too while the window stays put.
const box =
view && viewBounds === boundsKey(snapshot.bounds) ? view : null;
const coarse = cacheKey(time);
const key = box ? cacheKey(time, box) : coarse;
const coarse = cacheKey(time, mode);
const key = box ? cacheKey(time, mode, box) : coarse;
if (prefetchJob?.key === key || prefetchedKey === key) return false;
cancelPrefetch();
job = { key, controller: new AbortController() };
@@ -756,8 +739,8 @@ export function createWeatherShell({
job.timeout = setTimeout(() => job.controller.abort(), timeoutMs);
// Both images at once: one after the other would outlast playback's step.
await Promise.all([
acquire(time, signal, { keep: box ? [key] : [] }),
box ? acquire(time, signal, { box, keep: [coarse] }) : null,
acquire(time, mode, signal, { keep: box ? [key] : [] }),
box ? acquire(time, mode, signal, { box, keep: [coarse] }) : null,
]);
signal.throwIfAborted();
if (prefetchJob === job) prefetchedKey = key;
@@ -799,7 +782,7 @@ export function createWeatherShell({
infrared: mode,
bounds,
product: snapshot.product,
key: cacheKey(time),
key: cacheKey(time, mode),
mosaic: { fetched: false, decodeMs: null, cached: false },
controller: new AbortController(),
startedAt: now(),
@@ -814,7 +797,7 @@ export function createWeatherShell({
});
watch(frame, signal);
frame.timeout = setTimeout(() => fail(frame), timeoutMs);
void acquire(time, frame.controller.signal, {
void acquire(time, mode, frame.controller.signal, {
onFetched: () => {
frame.mosaic.fetched = true;
},
+18 -35
View File
@@ -11,7 +11,6 @@ import {
WEATHER_SHELL_HEIGHTS,
} from './shellRendering.js';
import { NO_IMAGERY_HOST } from './imageryHost.js';
import { INFRARED_ALPHA_T0, INFRARED_ALPHA_T1 } from './infraredAlpha.js';
import {
createShellCesium,
createShellScene,
@@ -148,13 +147,12 @@ test('surface builds a flat raised rectangle drawn in primitive order without de
image: Cesium.Material.DefaultImageId,
detail: Cesium.Material.DefaultImageId,
alpha: 1,
infrared: 0,
window: { type: 'vec4', x: 0, y: 0, z: -1, w: -1 },
});
const { source } = template.fabric;
assert.match(
source,
/material\.alpha = c\.a \* mix\(1\.0, key, infrared\) \* alpha \* step\(1\.5, float\(imageDimensions\.x\)\);/,
/material\.alpha = c\.a \* alpha \* step\(1\.5, float\(imageDimensions\.x\)\);/,
'nothing draws before the full-extent image',
);
assert.match(
@@ -375,7 +373,6 @@ test('real Cesium builds the two-texture material, the opaque-pass appearance an
/uniform sampler2D image_\d+;/,
/uniform sampler2D detail_\d+;/,
/uniform float alpha_\d+;/,
/uniform float infrared_\d+;/,
/uniform vec4 window_\d+;/,
/uniform ivec3 imageDimensions_\d+;/,
/uniform ivec3 detailDimensions_\d+;/,
@@ -387,16 +384,9 @@ test('real Cesium builds the two-texture material, the opaque-pass appearance an
assert.match(shader, /step\(1\.5, float\(detailDimensions_\d+\.x\)\)/);
assert.match(
shader,
/material\.alpha = c\.a \* mix\(1\.0, key, infrared_\d+\) \* alpha_\d+ \* step\(1\.5, float\(imageDimensions_\d+\.x\)\);/,
/material\.alpha = c\.a \* alpha_\d+ \* step\(1\.5, float\(imageDimensions_\d+\.x\)\);/,
'the uniform is renamed, the material field is not',
);
// The cloud key the globe's draped imagery gets from infraredAlpha.js:
// brightest channel, 2.2 power, the shared thresholds.
assert.ok(
shader.includes(
`float key = smoothstep(${INFRARED_ALPHA_T0.toFixed(4)}, ${INFRARED_ALPHA_T1.toFixed(4)}, pow(max(c.r, max(c.g, c.b)), 2.2));`,
),
);
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 });
@@ -753,12 +743,12 @@ test('prefetch warms a decoded frame without staging and cancels cleanly', async
h.shell.clear();
});
test('infrared frames reach the shader as decoded, with the cloud key as a uniform; radar and lightning get none', async () => {
for (const [product, amount] of [
['clouds-regional', 1],
['clouds', 1],
['radar', 0],
['lightning', 0],
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]);
@@ -766,10 +756,11 @@ test('infrared frames reach the shader as decoded, with the cloud key as a unifo
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, `${product}: pixels never rewritten`);
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.material().uniforms.infrared, amount, product);
assert.equal(
h.shell.getDiagnostics().height,
WEATHER_SHELL_HEIGHTS[product],
@@ -778,28 +769,20 @@ test('infrared frames reach the shader as decoded, with the cloud key as a unifo
}
});
test('an infrared mode change is a uniform on the same image: no fetch, no new canvas', async () => {
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 image = h.material().uniforms.image;
assert.equal(h.material().uniforms.infrared, 1);
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);
const renders = h.scene.renders;
assert.equal(await show(h, times[0], { infrared: 'full' }), true);
assert.equal(h.material().uniforms.image, image);
assert.equal(h.material().uniforms.infrared, 0);
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.ok(h.scene.renders > renders, 'the new strength is drawn');
assert.equal(await show(h, times[0], { infrared: 40 }), true);
assert.equal(h.material().uniforms.infrared, 0.4);
assert.equal(h.shell.getDiagnostics().infrared, 40);
assert.equal(await show(h, times[0], { infrared: 'filtered' }), true);
assert.equal(h.material().uniforms.image, image);
assert.equal(h.material().uniforms.infrared, 1);
assert.equal(h.fetches.length, 1);
assert.equal(h.decoded.length, 1);
assert.equal(h.shell.getDiagnostics().cache.mosaics, 1);
assert.equal(h.material().uniforms.image, filtered, 'cache hit');
assert.equal(h.fetches.length, 2);
h.shell.clear();
});