A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.
JavaScript 3d-globecesiumflight-trackinggeospatialgeospatial-intelligencegisosintphotogrammetrysatellite-trackingspatial-intelligencewebglworldview
import assert from 'node:assert/strict';
import test from 'node:test';
import {
RealtimeViewport,
pointerCropRect,
renderFreshPointerFrame,
} from './realtimeViewport.js';
test('crop: a square around the pointer, clamped inside the canvas, in buffer pixels', () => {
assert.deepEqual(
pointerCropRect({
x: 750,
y: 475,
cssWidth: 1500,
cssHeight: 950,
pixelWidth: 3000,
pixelHeight: 1900,
}),
{
sx: 988,
sy: 438,
sw: 1024,
sh: 1024,
output: 512,
pointX: 256,
pointY: 256,
},
);
const corner = pointerCropRect({
x: 20,
y: 20,
cssWidth: 1500,
cssHeight: 950,
pixelWidth: 1500,
pixelHeight: 950,
});
assert.equal(corner.sx, 0);
assert.equal(corner.sy, 0);
assert.equal(
corner.pointX,
20,
'the ring still marks the real spot near an edge',
);
assert.equal(
pointerCropRect({
x: 1,
y: 1,
cssWidth: 0,
cssHeight: 0,
pixelWidth: 0,
pixelHeight: 0,
}),
null,
);
assert.equal(
pointerCropRect({
x: Number.NaN,
y: 1,
cssWidth: 100,
cssHeight: 100,
pixelWidth: 100,
pixelHeight: 100,
}),
null,
'non-finite pointer geometry fails closed',
);
assert.equal(
pointerCropRect({
x: 101,
y: 1,
cssWidth: 100,
cssHeight: 100,
pixelWidth: 100,
pixelHeight: 100,
}),
null,
'out-of-canvas pointer geometry fails closed',
);
assert.equal(
pointerCropRect({
x: 120,
y: 100,
cssWidth: 320,
cssHeight: 240,
pixelWidth: 320,
pixelHeight: 240,
}).output,
512,
'the provider image stays 512 px even when the source crop is smaller',
);
});
test('crop: a slow render gets one bounded fresh-frame recovery request', async () => {
const originalDocument = globalThis.document;
let requests = 0;
let listener = null;
try {
globalThis.document = { hidden: false };
const scene = {
postRender: {
addEventListener(next) {
listener = next;
return () => {
if (listener === next) listener = null;
};
},
},
requestRender() {
requests += 1;
if (requests === 2) queueMicrotask(() => listener?.());
},
};
assert.equal(await renderFreshPointerFrame({ scene }), true);
assert.equal(requests, 2, 'only the pointer path retries once');
assert.equal(listener, null, 'the successful listener is removed');
} finally {
globalThis.document = originalDocument;
}
});
test('crop: a hidden document never starts the recovery request', async () => {
const originalDocument = globalThis.document;
let requests = 0;
try {
globalThis.document = { hidden: true };
const scene = {
postRender: { addEventListener: () => () => {} },
requestRender() {
requests += 1;
},
};
assert.equal(await renderFreshPointerFrame({ scene }), false);
assert.equal(requests, 0);
} finally {
globalThis.document = originalDocument;
}
});
function viewportFixture({ capturePointer, capture } = {}) {
const sent = [];
const captures = [];
const state = { clock: 10_000, pointer: null, camera: 'pose-A' };
const channel = { readyState: 'open' };
const viewport = new RealtimeViewport({
readChannel: () => channel,
readPointer: () => state.pointer,
readCameraKey: () => state.camera,
capture: capture || (async () => 'data:image/jpeg;base64,FULL'),
capturePointer:
capturePointer ||
(async (px) => {
captures.push(px);
return {
dataUrl: 'data:image/jpeg;base64,CROP',
rect: { x: 0.25, y: 0.2, w: 0.3, h: 0.5 },
};
}),
now: () => state.clock,
operations: {
sendRealtimeEvent: (event, label) => {
sent.push({ event, label });
return true;
},
},
});
return { viewport, sent, captures, state };
}
const ground = {
fresh: true,
target: 'ground',
at: 'keydown',
screenPx: { x: 400, y: 300 },
capturedAt: 9_000,
cameraKey: 'pose-A',
};
test('crop: sent once per snapshot, only at local/city scale, into the one retained slot', async () => {
const { viewport, sent, captures, state } = viewportFixture();
assert.equal(
await viewport.sendPointerCrop(ground, { viewScale: 'regional' }),
false,
'the scale guard lives in the shared send path',
);
assert.equal(
await viewport.sendPointerCrop(ground),
false,
'no scale, no crop',
);
assert.equal(
await viewport.sendPointerCrop(ground, { viewScale: 'city' }),
true,
);
assert.equal(
await viewport.sendPointerCrop(ground, { viewScale: 'city' }),
false,
'once per snapshot',
);
assert.deepEqual(captures, [{ x: 400, y: 300 }]);
assert.equal(sent[0].label, 'client.pointer_crop');
assert.match(sent[0].event.item.content[0].text, /ring marks the exact spot/);
assert.equal(
sent[0].event.item.content[1].image_url,
'data:image/jpeg;base64,CROP',
);
assert.deepEqual(viewport.retainedFrame, {
kind: 'crop',
rect: { x: 0.25, y: 0.2, w: 0.3, h: 0.5 },
cameraKey: 'pose-A',
});
assert.equal(
await viewport.sendPointerCrop(
{ ...ground, target: 'entity' },
{ viewScale: 'city' },
),
false,
'entities are named, not cropped',
);
state.clock = 60_000;
assert.equal(
await viewport.sendPointerCrop({ ...ground }, { viewScale: 'city' }),
false,
'too old',
);
// Pull: a ground pointer lookup sends the crop, deleting the old image.
state.clock = 10_000;
state.pointer = { ...ground, at: 'speech_start' };
const lookup = {
action: 'get_entity_context',
scope: 'pointer',
selected: null,
pointer: { latitude: 1, longitude: 2 },
scene: { basemap: { viewScale: 'city' } },
};
assert.equal(await viewport.sendVisualContextIfUseful(lookup), true);
assert.equal(
sent.at(-2).event.type,
'conversation.item.delete',
'one retained image at most',
);
assert.equal(sent.at(-1).label, 'client.pointer_crop');
assert.equal(
await viewport.sendVisualContextIfUseful({
...lookup,
selected: { id: 'x' },
}),
false,
);
assert.equal(
await viewport.sendVisualContextIfUseful({
...lookup,
scene: { basemap: { viewScale: 'regional' } },
}),
false,
);
viewport.reset();
assert.equal(viewport.lastPointerCrop, null);
assert.equal(viewport.retainedFrame, null);
});
test('crop: a camera move before or during capture drops it; pixels only name their own pose', async () => {
let release;
const { viewport, sent, state } = viewportFixture({
capturePointer: () =>
new Promise((resolve) => {
release = () =>
resolve({
dataUrl: 'data:image/jpeg;base64,CROP',
rect: { x: 0, y: 0, w: 1, h: 1 },
});
}),
});
state.camera = 'pose-B';
assert.equal(
await viewport.sendPointerCrop(ground, { viewScale: 'local' }),
false,
'moved before capture',
);
state.camera = null;
assert.equal(
await viewport.sendPointerCrop(
{ ...ground, cameraKey: null },
{ viewScale: 'local' },
),
false,
'a missing pose identity fails closed',
);
state.camera = 'pose-A';
const pending = viewport.sendPointerCrop(
{ ...ground },
{ viewScale: 'local' },
);
state.camera = 'pose-B';
release();
assert.equal(await pending, false, 'moved while capturing');
assert.equal(sent.length, 0);
});
test('crop: a snapshot that expires during capture is not published', async () => {
let release;
const { viewport, sent, state } = viewportFixture({
capturePointer: () =>
new Promise((resolve) => {
release = () =>
resolve({
dataUrl: 'data:image/jpeg;base64,CROP',
rect: { x: 0, y: 0, w: 1, h: 1 },
});
}),
});
const pending = viewport.sendPointerCrop(
{ ...ground },
{ viewScale: 'local' },
);
state.clock = 40_000;
release();
assert.equal(await pending, false);
assert.equal(sent.length, 0);
});
test('crop: an older capture that finishes last never replaces the newer image', async () => {
const releases = [];
const { viewport, sent } = viewportFixture({
capturePointer: () =>
new Promise((resolve) =>
releases.push((url) => resolve({ dataUrl: url, rect: null })),
),
});
const first = viewport.sendPointerCrop({ ...ground }, { viewScale: 'local' });
const second = viewport.sendPointerCrop(
{ ...ground },
{ viewScale: 'local' },
);
releases[1]('data:image/jpeg;base64,NEW');
assert.equal(await second, true);
releases[0]('data:image/jpeg;base64,OLD');
assert.equal(await first, false, 'superseded request');
assert.deepEqual(
sent.map((s) => s.event.item?.content?.[1]?.image_url).filter(Boolean),
['data:image/jpeg;base64,NEW'],
);
// A new user turn drops a capture still in flight from the previous one.
const third = viewport.sendPointerCrop({ ...ground }, { viewScale: 'local' });
viewport.beginTurn();
releases[2]('data:image/jpeg;base64,LATE');
assert.equal(await third, false);
});