mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 09:42:21 +00:00
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.
181 lines
6.0 KiB
JavaScript
181 lines
6.0 KiB
JavaScript
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');
|
||
});
|