Files
gods-eye-view/src/geo/screenCluster.test.mjs
T
Sameh Khamis c57eb74506 fix(radio): a cluster kept from the last pass names the same station first
Points too close together on screen are grouped by
geo/screenCluster.js as the default renderer's entity clustering grouped
them. Its range queries ran on a uniform grid sorted by index, while the
reference queries a KDBush tree, so a cluster kept as the eye came lower
could list its stations in another order, and a click on it played a
different station. The index is now KDBush, built as the reference builds
it, and kdbush is a declared dependency (it already came with the globe).

The package boundaries list kdbush as external wherever screenCluster is
owned, and own src/viewSky.js beside src/viewWeather.js.
2026-11-14 00:29:26 -08:00

181 lines
6.0 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import test from 'node:test';
import KDBush from 'kdbush';
import { clusterScreenPoints } from './screenCluster.js';
/** A point at screen `x, y` whose world position is `x, y, 0` too. */
const at = (id, x, y, pixelSize = 13) => ({
id,
position: { x, y, z: 0 },
screen: { x, y },
pixelSize,
});
const run = (points, extra = {}) =>
clusterScreenPoints({
points,
pixelRange: 42,
minimumClusterSize: 3,
viewHeight: 1000,
eyeHeight: 1_000_000,
project: (p) => ({ x: p.x, y: p.y }),
isOccluded: () => false,
...extra,
});
test('points inside a seed’s grown box cluster at their mean, the seed first', () => {
const result = run([
at('a', 100, 100),
at('b', 140, 100),
at('c', 100, 140),
at('far', 600, 600),
]);
assert.equal(result.clusters.length, 1);
assert.deepEqual(result.clusters[0].ids, ['a', 'b', 'c']);
assert.deepEqual(result.clusters[0].position, {
x: 340 / 3,
y: 340 / 3,
z: 0,
});
assert.deepEqual(result.single, ['far']);
});
test('fewer than the minimum stay on their own, and a box reaches half the size plus the range', () => {
// 6.5 + 42 = 48.5 px each way from the seed.
const edge = run([
at('a', 100, 100),
at('b', 148.5, 100),
at('c', 100, 51.5),
]);
assert.deepEqual(edge.clusters[0].ids, ['a', 'b', 'c']);
const out = run([at('a', 100, 100), at('b', 148.6, 100), at('c', 100, 51.5)]);
assert.deepEqual(out.clusters, []);
assert.deepEqual(out.single, ['a', 'b', 'c']);
});
test('a point already clustered is not taken again by a later seed', () => {
const result = run([
at('a', 100, 100),
at('b', 120, 100),
at('c', 140, 100),
at('d', 160, 100),
at('e', 180, 100),
]);
assert.deepEqual(
result.clusters.map((c) => c.ids),
[['a', 'b', 'c']],
);
assert.deepEqual(result.single, ['d', 'e']);
});
test('zooming in keeps last pass’s clusters still in view before seeding anew', () => {
const points = [at('a', 100, 100), at('b', 140, 100), at('c', 100, 140)];
const first = run(points);
const [kept] = first.state.clusters;
assert.equal(kept.minimumWidth, 97);
// Closer, with the points spread past a fresh seed's box but inside the
// kept cluster's (its box is measured from the top, the points' from the
// bottom, as the default renderer measures them).
const spread = [at('a', 70, 930), at('b', 200, 800), at('c', 70, 800)];
const again = run(spread, {
eyeHeight: 900_000,
previous: first.state,
project: () => ({ x: 113, y: 113 }),
});
assert.equal(again.clusters.length, 1);
assert.deepEqual(again.clusters[0].position, first.clusters[0].position);
assert.deepEqual([...again.clusters[0].ids].sort(), ['a', 'b', 'c']);
// From higher up, the last pass is not consulted.
const higher = run(spread, {
eyeHeight: 1_100_000,
previous: first.state,
project: () => ({ x: 113, y: 113 }),
});
assert.deepEqual(higher.clusters, []);
// Nor a cluster now behind the horizon.
const hidden = run(spread, {
eyeHeight: 900_000,
previous: run(points).state,
project: () => ({ x: 113, y: 113 }),
isOccluded: () => true,
});
assert.deepEqual(hidden.clusters, []);
});
test('many points cluster as a scan of every point would', () => {
let seed = 7;
const random = () => (seed = (seed * 16807) % 2147483647) / 2147483647;
const points = Array.from({ length: 600 }, (_, i) =>
at(`p${i}`, random() * 1600, random() * 1000),
);
const result = run(points);
const all = [...result.single, ...result.clusters.flatMap((c) => c.ids)];
assert.equal(all.length, 600);
assert.equal(new Set(all).size, 600, 'each point once');
// Brute force, as the renderer does it.
const done = new Set();
const expected = [];
const inBox = (s, o) =>
Math.abs(o.screen.x - s.screen.x) <= 48.5 &&
Math.abs(o.screen.y - s.screen.y) <= 48.5;
for (const s of points) {
if (done.has(s.id)) continue;
done.add(s.id);
const ids = [s.id];
for (const o of points) if (!done.has(o.id) && inBox(s, o)) ids.push(o.id);
if (ids.length >= 3) {
expected.push(ids);
ids.forEach((id) => done.add(id));
}
}
// The same seeds take the same points; the order after the seed is the
// index's, checked below.
const seedThenSorted = (ids) => [ids[0], ...ids.slice(1).sort()];
assert.deepEqual(
result.clusters.map((c) => seedThenSorted(c.ids)),
expected.map(seedThenSorted),
);
});
test('a cluster lists its points in the reference renderer’s KDBush order, so a kept one names the same point first', () => {
// The reference indexes the points with KDBush (64 per node, 64-bit) and
// lists a cluster's points in the order a range query returns them.
let seed = 11;
const random = () => (seed = (seed * 16807) % 2147483647) / 2147483647;
const points = Array.from({ length: 400 }, (_, i) =>
at(`p${i}`, random() * 400, random() * 400),
);
const index = new KDBush(points.length, 64, Float64Array);
for (const p of points) index.add(p.screen.x, 1000 - p.screen.y);
index.finish();
const first = run(points);
const [kept] = first.state.clusters;
// Closer, at once: the first kept cluster takes every unclustered point in
// its box, in the index's order.
// (Its box is measured from the top, the index from the bottom.)
const coord = { x: 200, y: 800 };
const again = run(points, {
eyeHeight: 999_999,
previous: first.state,
project: () => coord,
});
const width = Math.max(kept.width * 1e-6, kept.minimumWidth);
const height = Math.max(kept.height * 1e-6, kept.minimumHeight);
const expected = index
.range(
coord.x - width * 0.5,
coord.y - height * 0.5,
coord.x + width,
coord.y + height,
)
.map((i) => points[i].id);
assert.ok(expected.length >= 3, 'the kept cluster holds');
assert.deepEqual(again.clusters[0].ids, expected);
const ascending = [...expected].sort(
(a, b) => Number(a.slice(1)) - Number(b.slice(1)),
);
assert.notDeepEqual(expected, ascending, 'the order is not the input order');
});