mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
KartaView filters coverage on its server only in its PNG tiles (its JSON tiles come back empty with a filter), so a filtered tile's PNG is a mask over the cached JSON segments: a segment stays when at least half the points along it lie on drawn pixels. A filter change reloads the lines (lineCoverage.reload keeps the drawn ones until the new ones are in); masks are cached per filter and tile, and a filtered tile KartaView is still drawing (504 or a timeout) is asked again, four tries in all. The nearest lookup asks the photo API for the projection and date, and the cones follow the filter like Mapillary's. The gate fixture draws filtered PNG tiles and adds an older flat-only street; a new gate step checks 360 and LAST YEAR thin KartaView's lines and ALL brings them back. Co-Authored-By: Claude Opus 5.5 <[email protected]>
188 lines
6.2 KiB
JavaScript
188 lines
6.2 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import {
|
|
MAX_LINE_POINTS,
|
|
MAX_TILE_SEGMENTS,
|
|
chainSegments,
|
|
decodeCoverageTile,
|
|
maskedSegments,
|
|
tileSegments,
|
|
} from './decode.js';
|
|
|
|
const at = (lng, lat) => ({ lat: String(lat), lng: String(lng) });
|
|
const TILE = { x: 4412, y: 6061, z: 14 };
|
|
|
|
test('segments that meet end to start chain into one line', () => {
|
|
const { sequences, overview } = decodeCoverageTile(
|
|
{
|
|
lines: [
|
|
{ track: [at(1, 1), at(2, 1)], matched: '1' },
|
|
{ track: [at(5, 5), at(6, 6)], matched: '1' },
|
|
{ track: [at(2, 1), at(3, 1), at(4, 2)], matched: '1' },
|
|
],
|
|
},
|
|
TILE,
|
|
);
|
|
assert.deepEqual(overview, []);
|
|
assert.equal(sequences.length, 2);
|
|
assert.deepEqual(sequences[0].parts, [
|
|
[
|
|
[1, 1],
|
|
[2, 1],
|
|
[3, 1],
|
|
[4, 2],
|
|
],
|
|
]);
|
|
assert.equal(sequences[0].id, '14/4412/6061/0');
|
|
assert.equal(sequences[1].id, '14/4412/6061/1');
|
|
// Nothing to date or project: every line passes as flat and undated.
|
|
assert.equal(sequences[0].capturedAt, 0);
|
|
assert.equal(sequences[0].isPano, false);
|
|
});
|
|
|
|
test('a junction continues one way only, and every segment is drawn exactly once', () => {
|
|
const { sequences } = decodeCoverageTile(
|
|
{
|
|
lines: [
|
|
{ track: [at(0, 0), at(1, 0)] },
|
|
{ track: [at(1, 0), at(2, 0)] },
|
|
{ track: [at(1, 0), at(1, 1)] },
|
|
// A loop back to its own start must end, not spin.
|
|
{ track: [at(9, 9), at(9, 8)] },
|
|
{ track: [at(9, 8), at(9, 9)] },
|
|
],
|
|
},
|
|
TILE,
|
|
);
|
|
const points = sequences.reduce((sum, s) => sum + s.parts[0].length, 0);
|
|
assert.equal(sequences.length, 3);
|
|
// 5 segments of 2 points, 2 joins in chains: 10 - 2 = 8 points.
|
|
assert.equal(points, 8);
|
|
});
|
|
|
|
test('bad points, repeats and one-point tracks are skipped; an empty tile has no lines', () => {
|
|
const { sequences } = decodeCoverageTile(
|
|
{
|
|
lines: [
|
|
{ track: [at(1, 1), at(1, 1), { lat: 'x', lng: '2' }, at(2, 2)] },
|
|
{ track: [at(3, 3)] },
|
|
{ track: null },
|
|
null,
|
|
],
|
|
},
|
|
TILE,
|
|
);
|
|
assert.equal(sequences.length, 1);
|
|
assert.deepEqual(sequences[0].parts[0], [
|
|
[1, 1],
|
|
[2, 2],
|
|
]);
|
|
assert.deepEqual(decodeCoverageTile({ lines: [] }, TILE).sequences, []);
|
|
});
|
|
|
|
test('a tile that is not a line list fails, so it is asked for again rather than kept empty', () => {
|
|
for (const payload of [
|
|
null,
|
|
{},
|
|
{ lines: 'nope' },
|
|
{ status: { apiCode: 690 } },
|
|
])
|
|
assert.throws(
|
|
() => decodeCoverageTile(payload, TILE),
|
|
/unreadable coverage tile/,
|
|
);
|
|
});
|
|
|
|
test('a tile whose segments all share one point decodes in linear time', () => {
|
|
// [P, Q_i, P]: every chain step looks at the same start point's list.
|
|
// 60k: the old quadratic chaining took over a second; capped and linear
|
|
// decoding takes tens of milliseconds.
|
|
const lines = Array.from({ length: 60_000 }, (_, i) => ({
|
|
track: [at(0, 0), at(1 + i * 1e-6, 1), at(0, 0)],
|
|
}));
|
|
const started = performance.now();
|
|
const { sequences } = decodeCoverageTile({ lines }, TILE);
|
|
const ms = performance.now() - started;
|
|
assert.ok(
|
|
ms < 1_000,
|
|
`${Math.round(ms)} ms (quadratic chaining took ~200 ms per 20k and grows fourfold per doubling)`,
|
|
);
|
|
const points = sequences.reduce((sum, s) => sum + s.parts[0].length, 0);
|
|
assert.ok(sequences.every((s) => s.parts[0].length <= MAX_LINE_POINTS));
|
|
assert.equal(
|
|
points,
|
|
MAX_TILE_SEGMENTS * 2 + sequences.length,
|
|
'every segment drawn once',
|
|
);
|
|
});
|
|
|
|
test('a tile is capped in segments and in points per line', () => {
|
|
const lines = Array.from({ length: MAX_TILE_SEGMENTS + 500 }, (_, i) => ({
|
|
track: [at(i, 0), at(i + 1, 0)],
|
|
}));
|
|
const { sequences } = decodeCoverageTile({ lines }, TILE);
|
|
const points = sequences.reduce((sum, s) => sum + s.parts[0].length, 0);
|
|
// One long chain, cut into lines of at most MAX_LINE_POINTS.
|
|
assert.ok(sequences.every((s) => s.parts[0].length <= MAX_LINE_POINTS));
|
|
assert.ok(points <= MAX_TILE_SEGMENTS + sequences.length);
|
|
assert.ok(
|
|
sequences.length >= Math.floor(MAX_TILE_SEGMENTS / MAX_LINE_POINTS),
|
|
);
|
|
});
|
|
|
|
/** [lon, lat] at pixel (px, py) of a 512 px mask of `tile` (Web Mercator). */
|
|
function lonLatAt(px, py, { x, y, z } = TILE, size = 512) {
|
|
const n = 2 ** z;
|
|
const lon = ((x + px / size) / n) * 360 - 180;
|
|
const my = Math.PI * (1 - (2 * (y + py / size)) / n);
|
|
const lat = (Math.atan(Math.sinh(my)) * 180) / Math.PI;
|
|
return [lon, lat];
|
|
}
|
|
|
|
/** A 512 px mask drawn on the given rows. */
|
|
function rowsMask(rows) {
|
|
const alpha = new Uint8Array(512 * 512);
|
|
for (const [from, to] of rows) alpha.fill(255, from * 512, (to + 1) * 512);
|
|
return { width: 512, height: 512, alpha };
|
|
}
|
|
|
|
test('a mask keeps the segments it draws over, chained as before', () => {
|
|
const along = (row, from = 40, to = 470) => [
|
|
lonLatAt(from, row),
|
|
lonLatAt(to, row),
|
|
];
|
|
const segments = [
|
|
along(100), // drawn at row 100
|
|
along(101.6), // a pixel off: still drawn within one pixel
|
|
along(300), // not drawn
|
|
// Two thirds along the drawn row, then off it: kept (at least half).
|
|
[lonLatAt(40, 100), lonLatAt(400, 100), lonLatAt(400, 280)],
|
|
// A third along it, then off: dropped.
|
|
[lonLatAt(300, 100), lonLatAt(400, 100), lonLatAt(400, 300)],
|
|
// Off the tile entirely: not this tile's to keep.
|
|
[lonLatAt(-200, 100), lonLatAt(-20, 100)],
|
|
];
|
|
const kept = maskedSegments(segments, rowsMask([[99, 100]]), TILE);
|
|
assert.deepEqual(kept, [segments[0], segments[1], segments[3]]);
|
|
assert.deepEqual(maskedSegments(segments, rowsMask([]), TILE), []);
|
|
// A full mask keeps every segment that is on the tile.
|
|
assert.equal(maskedSegments(segments, rowsMask([[0, 511]]), TILE).length, 5);
|
|
});
|
|
|
|
test('decoding is segments then chaining: the same lines either way', () => {
|
|
const payload = {
|
|
lines: [
|
|
{ track: [at(1, 1), at(2, 1)] },
|
|
{ track: [at(2, 1), at(3, 1)] },
|
|
{ track: [at(5, 5), at(6, 6)] },
|
|
],
|
|
};
|
|
const segments = tileSegments(payload);
|
|
assert.equal(segments.length, 3);
|
|
assert.deepEqual(
|
|
chainSegments(segments, TILE),
|
|
decodeCoverageTile(payload, TILE),
|
|
);
|
|
assert.throws(() => tileSegments({}), /unreadable coverage tile/);
|
|
});
|