Skip to content

A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.

21.5 KB
Raw Blame
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import { createCycloneRendering } from './rendering.js';
import { CYCLONE_OVERLAY_SOURCE_ID } from './labels.js';

/** Records what the renderer publishes to the shared overlay host. */
function overlayRecorder() {
  const calls = [];
  return {
    calls,
    host: {
      setEntries: (source, entries, options) =>
        calls.push({ kind: 'entries', source, entries, options }),
      setVisible: (source, visible) =>
        calls.push({ kind: 'visible', source, visible }),
      clearSource: (source) => calls.push({ kind: 'clear', source }),
    },
    get publishes() {
      return calls.filter(({ kind }) => kind === 'entries').length;
    },
    published() {
      return calls.findLast(({ kind }) => kind === 'entries')?.entries || [];
    },
    entry(id) {
      return this.published().find((entry) => entry.id === id) || null;
    },
  };
}

function harness({ deferred = false } = {}) {
  const sources = [],
    completions = [],
    pointOccluders = [],
    sphereOccluders = [];
  const listeners = new Set();
  const visibility = {
    points: new Map(),
    spheres: new Map(),
    pointCalls: [],
    sphereCalls: [],
    writes: 0,
  };
  const color = (value) => ({
    value,
    withAlpha: (alpha) => ({ value, alpha }),
  });
  const cesium = {
    Color: {
      fromCssColorString: color,
      WHITE: color('white'),
      BLACK: color('black'),
    },
    Cartesian2: class {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
    },
    Cartesian3: {
      ZERO: { x: 0, y: 0, z: 0 },
      fromDegrees: (lon, lat, height) => ({ lon, lat, height }),
    },
    Ellipsoid: { WGS84: { minimumRadius: 6356752 } },
    EllipsoidalOccluder: class {
      constructor(ellipsoid, cameraPosition) {
        this.ellipsoid = ellipsoid;
        this.cameraPosition = cameraPosition;
        pointOccluders.push(this);
      }
      isPointVisible(position) {
        visibility.pointCalls.push(position);
        return visibility.points.get(position) ?? true;
      }
    },
    Occluder: class {
      constructor(sphere, cameraPosition) {
        this.sphere = sphere;
        this.cameraPosition = cameraPosition;
        sphereOccluders.push(this);
      }
      isBoundingSphereVisible(sphere) {
        visibility.sphereCalls.push(sphere);
        return visibility.spheres.get(sphere) ?? true;
      }
    },
    PolygonHierarchy: class {
      constructor(positions, holes = []) {
        this.positions = positions;
        this.holes = holes;
      }
    },
    BoundingSphere: class {
      constructor(center, radius) {
        this.center = center;
        this.radius = radius;
      }
      static fromPoints(points) {
        return { points, radius: 10 };
      }
    },
    LabelStyle: { FILL_AND_OUTLINE: 1 },
    HorizontalOrigin: { LEFT: 1 },
    ArcType: { GEODESIC: 1 },
    HeightReference: Cesium.HeightReference,
    ClassificationType: Cesium.ClassificationType,
    DistanceDisplayCondition: Cesium.DistanceDisplayCondition,
    CustomDataSource: class {
      constructor() {
        const values = [];
        this.entities = {
          values,
          add: (value) => {
            let show = true;
            Object.defineProperty(value, 'show', {
              get: () => show,
              set: (next) => {
                show = next;
                visibility.writes++;
              },
            });
            values.push(value);
            return value;
          },
          removeAll: () => {
            values.length = 0;
          },
        };
      }
    },
  };
  let renders = 0;
  const overlay = overlayRecorder();
  const viewer = {
    camera: { positionWC: { x: 6378487, y: 0, z: 0 } },
    scene: {
      requestRender: () => renders++,
      preRender: {
        addEventListener(listener) {
          listeners.add(listener);
          return () => listeners.delete(listener);
        },
      },
    },
    dataSources: {
      add(value) {
        if (deferred)
          return new Promise((resolve) =>
            completions.push(() => {
              sources.push(value);
              resolve(value);
            }),
          );
        sources.push(value);
        return Promise.resolve(value);
      },
      remove(value) {
        const i = sources.indexOf(value);
        if (i >= 0) sources.splice(i, 1);
      },
    },
  };
  return {
    rendering: createCycloneRendering({
      viewer,
      cesium,
      overlayHost: overlay.host,
    }),
    overlay,
    sources,
    completions,
    viewer,
    cesium,
    visibility,
    pointOccluders,
    sphereOccluders,
    listeners,
    frame() {
      for (const listener of listeners) listener();
    },
    get renders() {
      return renders;
    },
  };
}
const storm = () => ({
  id: 'ep152026',
  name: 'Fifteen-E',
  advisoryNumber: '10',
  geometryAdvisoryNumber: '10',
  geometryStatus: 'current',
  position: { longitude: 179, latitude: 15 },
  forecastPoints: [
    { position: { longitude: -179, latitude: 16 }, tauHours: 12 },
  ],
  track: {
    type: 'MultiLineString',
    coordinates: [
      [
        [179, 15],
        [-179, 16],
      ],
    ],
  },
  cone: {
    type: 'MultiPolygon',
    coordinates: [
      [
        [
          [178, 10],
          [-178, 10],
          [-178, 20],
          [178, 10],
        ],
        [
          [179, 12],
          [-179, 12],
          [-179, 14],
          [179, 12],
        ],
      ],
      [
        [
          [170, 1],
          [171, 1],
          [171, 2],
          [170, 1],
        ],
      ],
    ],
  },
});

test('horizon culling updates only changed entities and keeps selection independent', async () => {
  const h = harness();
  await h.rendering.setSnapshot({
    storms: [storm(), { ...storm(), id: 'near' }],
  });
  const entities = h.sources[0].entities.values;
  const far = entities.filter((e) => e.id.startsWith('cyclone:ep152026:'));
  const near = entities.filter((e) => e.id.startsWith('cyclone:near:'));
  const forecast = far.find((e) => e.id.endsWith('forecast:0'));
  const sphere = h.rendering.getFocusSphere('ep152026');
  for (const entity of far)
    if (entity.position) h.visibility.points.set(entity.position, false);
  h.visibility.spheres.set(sphere, false);
  h.rendering.setSelection('ep152026');
  const publishes = h.overlay.publishes;
  const before = h.renders;
  h.frame();
  assert.ok(far.every((e) => e.show === false));
  assert.ok(near.every((e) => e.show === true));
  assert.equal(
    h.overlay.entry('lead:ep152026:12').position,
    forecast.position,
    'the host culls labels at the same anchors the points use',
  );
  assert.equal(h.overlay.publishes, publishes, 'culling never republishes');
  assert.equal(h.renders, before + 1);
  assert.equal(h.visibility.writes, far.length);
  assert.equal(h.visibility.pointCalls.length, 4);
  assert.deepEqual(h.visibility.sphereCalls, [
    sphere,
    h.rendering.getFocusSphere('near'),
  ]);
  h.frame();
  assert.equal(h.renders, before + 1);
  assert.equal(h.visibility.writes, far.length);

  // A visible portion of the extent keeps all tracks/cones shown even when
  // the centre and an individual forecast point remain beyond the horizon.
  h.visibility.spheres.set(sphere, true);
  h.viewer.camera.positionWC = { x: 0, y: 6378487, z: 0 };
  h.frame();
  assert.ok(far.filter((e) => !e.position).every((e) => e.show));
  assert.ok(far.filter((e) => e.position).every((e) => !e.show));
  assert.equal(h.renders, before + 2);
  assert.equal(h.pointOccluders.length, 1);
  assert.equal(h.sphereOccluders.length, 1);
  assert.equal(h.pointOccluders[0].ellipsoid, h.cesium.Ellipsoid.WGS84);
  assert.equal(h.pointOccluders[0].cameraPosition, h.viewer.camera.positionWC);
  assert.equal(h.sphereOccluders[0].cameraPosition, h.viewer.camera.positionWC);

  h.rendering.setSelection('near');
  assert.equal(h.overlay.entry('lead:ep152026:12'), null);
  assert.equal(
    h.overlay.entry('lead:near:12').position,
    near.find((e) => e.id.endsWith('forecast:0')).position,
  );
  h.visibility.points.set(forecast.position, true);
  const beforeReveal = h.renders;
  const revealPublishes = h.overlay.publishes;
  h.frame();
  assert.equal(forecast.show, true);
  assert.equal(h.overlay.entry('lead:ep152026:12'), null);
  assert.equal(h.overlay.publishes, revealPublishes);
  assert.equal(far[0].show, false);
  assert.equal(h.renders, beforeReveal + 1);
  h.rendering.destroy();
});

test('horizon listener follows committed nonempty snapshots and clear/destroy', async () => {
  const h = harness();
  assert.equal(h.listeners.size, 0);
  await h.rendering.setSnapshot({ storms: [] });
  assert.equal(h.listeners.size, 0);
  await h.rendering.setSnapshot({ storms: [storm()] });
  assert.equal(h.listeners.size, 1);
  const old = [...h.sources[0].entities.values];
  await h.rendering.setSnapshot({ storms: [storm()] });
  assert.equal(h.listeners.size, 1);
  h.frame();
  assert.ok(
    h.visibility.pointCalls.every((p) => !old.some((e) => e.position === p)),
  );
  await h.rendering.setSnapshot({ storms: [] });
  assert.equal(h.listeners.size, 0);
  await h.rendering.setSnapshot({ storms: [storm()] });
  h.rendering.clear();
  assert.equal(h.listeners.size, 0);
  const before = h.renders;
  h.frame();
  assert.equal(h.renders, before);
  await h.rendering.setSnapshot({ storms: [storm()] });
  assert.equal(h.listeners.size, 1);
  h.rendering.destroy();
  h.rendering.destroy();
  assert.equal(h.listeners.size, 0);
  assert.equal(await h.rendering.setSnapshot({ storms: [storm()] }), false);
  assert.equal(h.listeners.size, 0);
});

test('late asynchronous additions never restore a cleared or destroyed horizon listener', async () => {
  for (const method of ['clear', 'destroy']) {
    const h = harness({ deferred: true });
    const pending = h.rendering.setSnapshot({ storms: [storm()] });
    assert.equal(h.listeners.size, 0);
    h.rendering[method]();
    h.completions.shift()();
    assert.equal(await pending, false);
    assert.equal(h.listeners.size, 0);
  }
});

test('real Cesium culls far storms and retains partially visible extents with either globe visibility', async () => {
  for (const globeShow of [true, false]) {
    const sources = [];
    const viewer = {
      camera: { positionWC: Cesium.Cartesian3.fromDegrees(0, 0, 350) },
      scene: {
        globe: { show: globeShow },
        preRender: new Cesium.Event(),
        requestRender() {},
      },
      dataSources: {
        async add(source) {
          sources.push(source);
        },
        remove() {},
      },
    };
    const overlay = overlayRecorder();
    const rendering = createCycloneRendering({
      viewer,
      cesium: Cesium,
      overlayHost: overlay.host,
    });
    const at = (id, longitude) => ({
      ...storm(),
      id,
      position: { longitude, latitude: 0 },
      forecastPoints: [{ position: { longitude, latitude: 0 }, tauHours: 24 }],
      track: {
        type: 'LineString',
        coordinates: [
          [longitude, 0],
          [longitude, 1],
        ],
      },
      cone: {
        type: 'Polygon',
        coordinates: [
          [
            [longitude, 0],
            [longitude + 1, 0],
            [longitude, 1],
            [longitude, 0],
          ],
        ],
      },
    });
    await rendering.setSnapshot({
      storms: [at('near', 0), at('far', 180), at('limb', 5)],
    });
    rendering.setSelection('near');
    viewer.scene.preRender.raiseEvent();
    const entities = sources[0].entities.values;
    for (const entity of entities.filter((e) => e.position)) {
      assert.equal(
        entity.point.heightReference.getValue(),
        Cesium.HeightReference.CLAMP_TO_GROUND,
      );
      assert.equal(entity.point.disableDepthTestDistance.getValue(), Infinity);
      assert.equal(entity.label, undefined, 'no Cesium label graphics');
      const published = overlay.entry(
        entity.id.includes(':forecast:')
          ? `lead:${entity.id.split(':')[1]}:24`
          : `storm:${entity.id.split(':')[1]}`,
      );
      if (entity.id.startsWith('cyclone:near:')) {
        assert.ok(
          Cesium.Cartesian3.equals(
            published.position,
            entity.position.getValue(),
          ),
        );
        assert.equal(published.horizonCull, true);
      }
      if (entity.id === 'cyclone:near:forecast:0')
        assert.equal(published.maxDistance, 4_000_000);
    }
    assert.ok(
      entities
        .filter((e) => e.id.startsWith('cyclone:near:'))
        .every((e) => e.show),
    );
    assert.ok(
      entities
        .filter((e) => e.id.startsWith('cyclone:far:'))
        .every((e) => !e.show),
    );
    const limb = entities.filter((e) => e.id.startsWith('cyclone:limb:'));
    assert.ok(limb.filter((e) => e.position).every((e) => !e.show));
    assert.ok(limb.filter((e) => !e.position).every((e) => e.show));
    rendering.destroy();
    assert.equal(viewer.scene.preRender.numberOfListeners, 0);
  }
});

test('picking accepts exact current owned entities, never prefixes or superseded identities', async () => {
  const h = harness();
  await h.rendering.setSnapshot({ storms: [storm()] });
  const oldEntities = [...h.sources[0].entities.values];
  assert.equal(oldEntities.length, 8);
  for (const entity of oldEntities) {
    assert.equal(h.rendering.pickStorm({ id: entity }), 'ep152026', entity.id);
    assert.equal(h.rendering.ownsPickId(entity.id), true);
    assert.equal(
      h.rendering.pickStorm({ id: { ...entity } }),
      null,
      'copied ID is not ownership',
    );
    assert.equal(
      h.rendering.pickStorm({ id: entity.id }),
      null,
      'string prefix is not ownership',
    );
  }
  assert.equal(h.rendering.pickStorm(undefined), null);
  assert.equal(h.rendering.ownsPickId('cyclone:ep152026:unknown'), false);
  await h.rendering.setSnapshot({ storms: [storm()] });
  for (const entity of oldEntities)
    assert.equal(h.rendering.pickStorm({ id: entity }), null);
  const current = h.sources[0].entities.values[0];
  assert.equal(h.rendering.pickStorm({ id: current }), 'ep152026');
  h.rendering.clear();
  assert.equal(h.rendering.pickStorm({ id: current }), null);
  assert.equal(h.rendering.ownsPickId(current.id), false);
  h.rendering.destroy();
});

test('registry IDs switch only when the next coherent data source commits', async () => {
  const h = harness({ deferred: true });
  const first = h.rendering.setSnapshot({ storms: [storm()] });
  assert.equal(h.rendering.ownsPickId('cyclone:ep152026:center'), false);
  h.completions.shift()();
  await first;
  assert.equal(h.rendering.ownsPickId('cyclone:ep152026:center'), true);
  const next = h.rendering.setSnapshot({
    storms: [{ ...storm(), id: 'ep162026' }],
  });
  assert.equal(h.rendering.ownsPickId('cyclone:ep152026:center'), true);
  assert.equal(h.rendering.ownsPickId('cyclone:ep162026:center'), false);
  h.completions.shift()();
  await next;
  assert.equal(h.rendering.ownsPickId('cyclone:ep152026:center'), false);
  assert.equal(h.rendering.ownsPickId('cyclone:ep162026:center'), true);
  h.rendering.destroy();
  assert.equal(h.rendering.ownsPickId('cyclone:ep162026:center'), false);
});
test('static entities preserve polygon parts, holes and geographic seam coordinates', async () => {
  const h = harness();
  await h.rendering.setSnapshot({ storms: [storm()] });
  const entities = h.sources[0].entities.values;
  const cones = entities.filter((e) => e.polygon);
  assert.equal(cones.length, 2);
  assert.equal(cones[0].polygon.hierarchy.holes.length, 1);
  assert.equal(cones[0].polygon.hierarchy.positions[1].lon, -178);
  for (const cone of cones) {
    assert.equal(
      cone.polygon.classificationType,
      h.cesium.ClassificationType.BOTH,
    );
    assert.equal(cone.polygon.height, undefined);
    assert.equal(cone.polygon.extrudedHeight, undefined);
    assert.equal(cone.polygon.outline, undefined);
  }
  const outlines = entities.filter((e) => e.id.includes(':outline:'));
  assert.equal(outlines.length, 3);
  assert.deepEqual(
    outlines.map((e) => e.polyline.positions.map((p) => [p.lon, p.lat])),
    storm().cone.coordinates.flat(),
  );
  for (const outline of outlines) {
    assert.deepEqual(outline.polyline.material, {
      value: '#7fe6ed',
      alpha: 0.55,
    });
  }
  for (const { polyline } of entities.filter((e) => e.polyline)) {
    assert.equal(polyline.clampToGround, true);
    assert.equal(polyline.classificationType, h.cesium.ClassificationType.BOTH);
    assert.ok(polyline.positions.every((p) => p.height === 0));
  }
  assert.equal(
    entities.find((e) => e.polyline).polyline.positions[1].lon,
    -179,
  );
  assert.deepEqual(h.rendering.getDiagnostics(), {
    storms: 1,
    tracks: 1,
    cones: 2,
    forecastPoints: 1,
    dataSources: 1,
    entities: 8,
    selectedId: null,
    timerActive: false,
  });
  h.rendering.setSelection('ep152026');
  assert.equal(
    h.overlay.entry('lead:ep152026:12').position,
    entities.find((e) => e.id.endsWith('forecast:0')).position,
  );
  assert.ok(entities.every((e) => e.label === undefined));
  assert.ok(h.rendering.getFocusSphere('ep152026').radius >= 500000);
  h.rendering.destroy();
  assert.equal(h.sources.length, 0);
  assert.equal(h.rendering.getDiagnostics().entities, 0);
});
test('pending or mismatched advisory geometry never renders even when supplied', async () => {
  for (const changed of [
    { geometryStatus: 'pending' },
    { geometryAdvisoryNumber: '9' },
  ]) {
    const h = harness();
    await h.rendering.setSnapshot({ storms: [{ ...storm(), ...changed }] });
    assert.equal(h.sources[0].entities.values.length, 1);
    assert.equal(h.rendering.getDiagnostics().tracks, 0);
    h.rendering.destroy();
  }
});
test('a data-source add settling after disable is removed, without a new owner', async () => {
  const h = harness({ deferred: true });
  const pending = h.rendering.setSnapshot({ storms: [storm()] });
  h.rendering.clear();
  h.completions.shift()();
  assert.equal(await pending, false);
  assert.equal(h.sources.length, 0);
  assert.equal(h.rendering.getDiagnostics().dataSources, 0);
});
test('superseded asynchronous additions cannot replace newer geometry', async () => {
  const h = harness({ deferred: true });
  const old = h.rendering.setSnapshot({ storms: [storm()] });
  const latest = h.rendering.setSnapshot({ storms: [] });
  h.completions[1]();
  assert.equal(await latest, true);
  h.completions[0]();
  assert.equal(await old, false);
  assert.equal(h.sources.length, 1);
  assert.equal(h.rendering.getDiagnostics().storms, 0);
  h.rendering.destroy();
});
test('aborting a pending add retains the prior complete source', async () => {
  const h = harness({ deferred: true });
  const initial = h.rendering.setSnapshot({ storms: [storm()] });
  h.completions.shift()();
  await initial;
  const controller = new AbortController();
  const update = h.rendering.setSnapshot(
    { storms: [] },
    { signal: controller.signal },
  );
  controller.abort();
  h.completions.shift()();
  assert.equal(await update, false);
  assert.equal(h.sources.length, 1);
  assert.equal(h.rendering.getDiagnostics().storms, 1);
  h.rendering.destroy();
});

test('labels publish committed anchors to the shared overlay and follow selection and clear', async () => {
  const h = harness({ deferred: true });
  const pending = h.rendering.setSnapshot({
    storms: [storm(), { ...storm(), id: 'near', name: 'Near' }],
  });
  assert.equal(h.overlay.calls.length, 0, 'nothing publishes before commit');
  h.completions.shift()();
  assert.equal(await pending, true);
  const entities = h.sources[0].entities.values;
  const center = (id) => entities.find((e) => e.id === `cyclone:${id}:center`);
  assert.deepEqual(
    h.overlay.calls
      .slice(0, 2)
      .map(({ kind, source, visible }) => [kind, source, visible]),
    [
      ['visible', CYCLONE_OVERLAY_SOURCE_ID, true],
      ['entries', CYCLONE_OVERLAY_SOURCE_ID, undefined],
    ],
  );
  assert.deepEqual(
    h.overlay.published().map((entry) => entry.id),
    ['storm:ep152026', 'storm:near'],
    'no selection, no lead-hour labels',
  );
  assert.equal(h.overlay.entry('storm:near').title, 'Near');
  assert.equal(h.overlay.entry('storm:near').position, center('near').position);

  h.rendering.setSelection('near');
  assert.equal(center('near').point.pixelSize, 12);
  assert.equal(center('ep152026').point.pixelSize, 9);
  assert.equal(h.overlay.entry('storm:near').variant, 'selected');
  assert.equal(h.overlay.entry('storm:ep152026').variant, 'card');
  assert.ok(h.overlay.entry('lead:near:12'));
  const publishes = h.overlay.publishes;
  h.rendering.setSelection('near');
  assert.equal(h.overlay.publishes, publishes, 'unchanged selection is quiet');

  // A refresh republishes the new anchors with the retained selection.
  const refresh = h.rendering.setSnapshot({
    storms: [{ ...storm(), id: 'near', name: 'Near' }],
  });
  h.completions.shift()();
  await refresh;
  assert.deepEqual(
    h.overlay.published().map((entry) => [entry.id, entry.variant]),
    [
      ['storm:near', 'selected'],
      ['lead:near:12', 'card'],
    ],
  );
  assert.equal(
    h.overlay.entry('storm:near').position,
    h.sources[0].entities.values[0].position,
  );

  // A superseded addition never publishes, and clear hides the source.
  const stale = h.rendering.setSnapshot({ storms: [storm()] });
  h.rendering.clear();
  const afterClear = h.overlay.calls.slice(-2);
  assert.deepEqual(afterClear, [
    { kind: 'clear', source: CYCLONE_OVERLAY_SOURCE_ID },
    { kind: 'visible', source: CYCLONE_OVERLAY_SOURCE_ID, visible: false },
  ]);
  h.completions.shift()();
  assert.equal(await stale, false);
  assert.equal(h.overlay.calls.at(-1), afterClear[1]);
  h.rendering.destroy();
  assert.equal(h.overlay.calls.at(-1), afterClear[1]);
});