mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 00:02:25 +00:00
The duplicate filter hid a held copy when another feed's copy outranked it and moved the selection away, so the held train stopped playing and the other copy's marker and card came back over the view. A copy a first-person view holds is now drawn whatever the scores until the view lets go; the better copy takes over at the next poll after the release. Holding a copy that another feed drew draws it at once. A category toggle no longer deselects a held train, and a held train keeps playing, its marker hidden, while its category is off. Released, it is deselected and stops as the toggle leaves any other train.
391 lines
13 KiB
JavaScript
391 lines
13 KiB
JavaScript
// One physical train in several loaded live feeds is drawn once: copies are
|
||
// matched by train number, or by line and category when near each other,
|
||
// and the copy with the better position source and line is drawn.
|
||
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import {
|
||
NUMBER_RADIUS_KM,
|
||
chooseCopies,
|
||
createDuplicateFilter,
|
||
labelNumbers,
|
||
matchCopies,
|
||
recordNumbers,
|
||
recordTrainNumber,
|
||
sameTrain,
|
||
scoreCopy,
|
||
trainNumber,
|
||
} from './dedupe.js';
|
||
import * as dedupe from './dedupe.js';
|
||
|
||
const ROSENHEIM = { lat: 47.85, lon: 12.119 };
|
||
const SALZBURG = { lat: 47.813, lon: 13.046 };
|
||
const LINZ = { lat: 48.29, lon: 14.291 };
|
||
|
||
/** A fake copy of a live train. */
|
||
function copy(key, feedId, extra = {}) {
|
||
return {
|
||
key,
|
||
feedId,
|
||
lat: ROSENHEIM.lat,
|
||
lon: ROSENHEIM.lon,
|
||
number: null,
|
||
line: null,
|
||
category: null,
|
||
position: 'gps',
|
||
onShape: false,
|
||
...extra,
|
||
};
|
||
}
|
||
|
||
test('train numbers compare across feeds', () => {
|
||
assert.equal(trainNumber('RJX 160'), '160');
|
||
assert.equal(trainNumber('160'), '160');
|
||
assert.equal(trainNumber('09725'), '9725');
|
||
assert.equal(trainNumber('TGV 10465'), '10465');
|
||
for (const none of [null, '', 'S', '0', 'RJX'])
|
||
assert.equal(trainNumber(none), null, String(none));
|
||
});
|
||
|
||
test('the same number is one train; another number is not', () => {
|
||
const a = copy('a', 'feed-a', { number: '160' });
|
||
assert.equal(sameTrain(a, copy('b', 'feed-b', { number: '160' })), true);
|
||
assert.equal(sameTrain(a, copy('b', 'feed-b', { number: '161' })), false);
|
||
// Never within one feed, never far apart.
|
||
assert.equal(sameTrain(a, copy('b', 'feed-a', { number: '160' })), false);
|
||
assert.equal(
|
||
sameTrain(a, copy('b', 'feed-b', { number: '160', ...LINZ })),
|
||
false,
|
||
);
|
||
// Two feeds report one train at different moments: 70 km on
|
||
// (Rosenheim–Salzburg) it is still the same numbered train.
|
||
assert.ok(NUMBER_RADIUS_KM > 70);
|
||
assert.equal(
|
||
sameTrain(a, copy('b', 'feed-b', { number: '160', ...SALZBURG })),
|
||
true,
|
||
);
|
||
assert.equal(
|
||
matchCopies([a, copy('b', 'feed-b', { number: '160', ...SALZBURG })])
|
||
.length,
|
||
1,
|
||
);
|
||
});
|
||
|
||
test('the filter matches nothing from timetables: no stops, dates or homes', () => {
|
||
// Copies are live trains only; nothing in the filter reads a schedule.
|
||
for (const gone of [
|
||
'scheduleRunStops',
|
||
'scheduleHomeCountry',
|
||
'copyCountry',
|
||
'shareTimedStops',
|
||
'serviceDateKey',
|
||
])
|
||
assert.equal(dedupe[gone], undefined, gone);
|
||
// Unnumbered copies off any line are never joined, however close.
|
||
assert.equal(sameTrain(copy('a', 'feed-a'), copy('b', 'feed-b')), false);
|
||
});
|
||
|
||
test('a bare-number headsign is the number when there is no name', () => {
|
||
assert.equal(
|
||
recordTrainNumber({ label: null, headsign: '839162' }),
|
||
'839162',
|
||
);
|
||
assert.equal(
|
||
recordTrainNumber({ label: 'RJX 160', headsign: '9999' }),
|
||
'160',
|
||
);
|
||
assert.equal(recordTrainNumber({ label: null, headsign: 'Paris-Est' }), null);
|
||
assert.equal(recordTrainNumber({ label: null, headsign: 'S 12' }), null);
|
||
});
|
||
|
||
test('a live vehicle labelled with its own car number takes the number from its trip', () => {
|
||
// A live feed's vehicle 8306 runs train 530.
|
||
const live = { id: '8306', label: '8306', tripId: 'AM:530' };
|
||
assert.equal(recordTrainNumber(live), '530');
|
||
// A label that is not the vehicle id is the train's name.
|
||
assert.equal(
|
||
recordTrainNumber({ id: 'v1', label: '531', tripId: 'AM:530' }),
|
||
'531',
|
||
);
|
||
// Long trip ids are not train numbers.
|
||
assert.equal(
|
||
recordTrainNumber({ id: '7', label: '7', tripId: '0519321010VRFV' }),
|
||
null,
|
||
);
|
||
// The GPS copy matches a station-report copy of train 530, and wins over
|
||
// it even on the operator's line.
|
||
const groups = matchCopies([
|
||
copy('gps', 'gps-feed', { number: recordTrainNumber(live) }),
|
||
copy('event', 'event-feed', {
|
||
number: '530',
|
||
position: 'event',
|
||
shape: 'operator',
|
||
}),
|
||
]);
|
||
assert.equal(groups.length, 1);
|
||
assert.equal(chooseCopies(groups).winners.get('event'), 'gps');
|
||
});
|
||
|
||
test('a group never holds two trains of one feed (coupled trains)', () => {
|
||
// Two coupled TGVs side by side in one feed; the other feed names one of
|
||
// them. Each pairs with its own number only.
|
||
const groups = matchCopies([
|
||
copy('fr-6194', 'feed-fr', { number: '6194' }),
|
||
copy('fr-6906', 'feed-fr', { number: '6906' }),
|
||
copy('ch-6194', 'feed-ch', { number: '6194' }),
|
||
copy('ch-6906', 'feed-ch', { number: '6906' }),
|
||
]);
|
||
assert.deepEqual(
|
||
groups.map((group) => group.map((c) => c.key).sort()).sort(),
|
||
[
|
||
['ch-6194', 'fr-6194'],
|
||
['ch-6906', 'fr-6906'],
|
||
],
|
||
);
|
||
// On one line, one feed's two copies still never share a group.
|
||
const s1 = { ...recordNumbers({ label: 'S1' }), category: 'local' };
|
||
const unnamed = matchCopies([
|
||
copy('a1', 'feed-a', s1),
|
||
copy('a2', 'feed-a', { ...s1, lat: ROSENHEIM.lat + 0.01 }),
|
||
copy('b1', 'feed-b', s1),
|
||
]);
|
||
assert.equal(unnamed.length, 1);
|
||
assert.equal(new Set(unnamed[0].map((c) => c.feedId)).size, 2);
|
||
});
|
||
|
||
test('a copy resembling two different trains never joins them', () => {
|
||
// An unnumbered S1 lies near two numbered trains on its line; the two
|
||
// carry different numbers, so the three are never one train.
|
||
const s1 = { line: { product: 'S', number: '1' }, category: 'local' };
|
||
const groups = matchCopies([
|
||
copy('n1', 'feed-a', { number: '1211', ...s1 }),
|
||
copy('n2', 'feed-s', { number: '22739', ...s1 }),
|
||
copy('s1', 'feed-c', s1),
|
||
]);
|
||
assert.ok(
|
||
groups.every((group) => group.length < 3),
|
||
'never all three',
|
||
);
|
||
});
|
||
|
||
test('the score: position source, then the line', () => {
|
||
const base = copy('a', 'x');
|
||
assert.deepEqual(scoreCopy(base), [2, 0]);
|
||
assert.deepEqual(scoreCopy({ ...base, position: 'event' }), [1, 0]);
|
||
assert.deepEqual(scoreCopy({ ...base, onShape: true }), [2, 1]);
|
||
// A source the layer does not know scores nothing.
|
||
assert.deepEqual(scoreCopy({ ...base, position: 'psychic' }), [0, 0]);
|
||
});
|
||
|
||
test('equal copies never trade places: the one drawn stays drawn', () => {
|
||
const twins = [
|
||
copy('a', 'f1', { number: '160', position: 'event' }),
|
||
copy('b', 'f2', { number: '160', position: 'event' }),
|
||
];
|
||
const first = chooseCopies([twins]);
|
||
const drawn = first.winners.get('a');
|
||
for (let i = 0; i < 3; i++) {
|
||
const again = chooseCopies([[...twins].reverse()], first.winners);
|
||
assert.equal(again.winners.get('a'), drawn);
|
||
}
|
||
// A GPS copy takes over from a station-report one at once.
|
||
const live = chooseCopies(
|
||
[[twins[0], { ...twins[1], position: 'gps' }]],
|
||
new Map([
|
||
['a', 'a'],
|
||
['b', 'a'],
|
||
]),
|
||
);
|
||
assert.equal(live.winners.get('a'), 'b');
|
||
});
|
||
|
||
/**
|
||
* A layer's state with one live train per feed, both train RJX 160, and
|
||
* spies for what the filter calls.
|
||
*/
|
||
function fakeLayer({ selected = null } = {}) {
|
||
const entry = (feedId, onShape) => ({
|
||
key: `${feedId}:v160`,
|
||
feedId,
|
||
record: {
|
||
id: 'v160',
|
||
tripId: 't1',
|
||
label: 'RJX 160',
|
||
...ROSENHEIM,
|
||
positionSource: 'gps',
|
||
},
|
||
path: onShape ? { shapeIndex: 0 } : null,
|
||
});
|
||
const trains = [entry('feed-a', false), entry('feed-b', true)];
|
||
const state = {
|
||
_trains: new Map(trains.map((t) => [t.key, t])),
|
||
_selectedKey: selected,
|
||
};
|
||
const calls = { paint: [], selected: [] };
|
||
const parts = {
|
||
rendering: {
|
||
paint: (e) => calls.paint.push([e.key, e.duplicate]),
|
||
schedulePlayback: () => {},
|
||
},
|
||
selection: {
|
||
selectTrain: (key) => {
|
||
calls.selected.push(key);
|
||
state._selectedKey = key;
|
||
},
|
||
},
|
||
};
|
||
return { state, parts, calls, trains };
|
||
}
|
||
|
||
test('the filter hides the weaker copy and the selection follows its train', () => {
|
||
const layer = fakeLayer({ selected: 'feed-a:v160' });
|
||
const filter = createDuplicateFilter({ ...layer, defer: (fn) => fn() });
|
||
assert.deepEqual(filter.refresh(), { groups: 1, hidden: 1 });
|
||
const [unbound, operator] = layer.trains;
|
||
assert.equal(unbound.duplicate, true, 'not on the operator’s line');
|
||
assert.equal(operator.duplicate, false);
|
||
assert.deepEqual(layer.calls.selected, [operator.key]);
|
||
// When the copy on the operator's line goes (its feed left the view), the
|
||
// other is drawn.
|
||
layer.state._trains.delete(operator.key);
|
||
filter.scheduleRefresh();
|
||
assert.equal(unbound.duplicate, false);
|
||
assert.deepEqual(filter.stats(), { groups: 0, hidden: 0 });
|
||
});
|
||
|
||
test('a copy a first-person view holds stays drawn, with the selection', () => {
|
||
const pair = [
|
||
copy('a', 'f1', { number: '160', position: 'event' }),
|
||
copy('b', 'f2', { number: '160', position: 'gps' }),
|
||
];
|
||
assert.equal(chooseCopies([pair]).winners.get('a'), 'b');
|
||
const held = chooseCopies([pair], new Map(), 'a');
|
||
assert.equal(held.winners.get('b'), 'a', 'drawn whatever the scores');
|
||
assert.deepEqual([...held.hidden], ['b']);
|
||
// Let go, the better copy takes over.
|
||
assert.equal(chooseCopies([pair], held.winners).winners.get('a'), 'b');
|
||
|
||
const layer = fakeLayer({ selected: 'feed-a:v160' });
|
||
layer.state._cockpitSubjectKey = 'feed-a:v160';
|
||
const filter = createDuplicateFilter({ ...layer, defer: (fn) => fn() });
|
||
filter.refresh();
|
||
const [unbound, operator] = layer.trains;
|
||
assert.equal(unbound.duplicate, false, 'the held copy');
|
||
assert.equal(operator.duplicate, true);
|
||
assert.deepEqual(layer.calls.selected, [], 'the selection stays on it');
|
||
layer.state._cockpitSubjectKey = null;
|
||
filter.refresh();
|
||
assert.equal(unbound.duplicate, true);
|
||
assert.deepEqual(layer.calls.selected, [operator.key]);
|
||
});
|
||
|
||
test('a short number after a local product names a line, not a train (S1, RB 1, U6)', () => {
|
||
for (const label of ['S1', 'RB 1', 'U6', 'S 12', 'RE5'])
|
||
assert.equal(recordTrainNumber({ label }), null, label);
|
||
assert.deepEqual(labelNumbers('RB 1').line, { product: 'RB', number: '1' });
|
||
// Three digits, or a long-distance product's own short number, are a
|
||
// train's.
|
||
assert.equal(recordTrainNumber({ label: 'EC 7' }), '7');
|
||
assert.equal(recordTrainNumber({ label: 'NJ 40' }), '40');
|
||
assert.equal(recordTrainNumber({ label: 'S 1264' }), '1264');
|
||
// A line name gives way to a trip id that is the train's number.
|
||
assert.equal(recordTrainNumber({ label: '5', tripId: 'AM:5' }), '5');
|
||
|
||
// An S1 and an RB 1 25 km apart are never joined as one train numbered 1.
|
||
const s1 = copy('s1', 'feed-a', {
|
||
...recordNumbers({ label: 'S1' }),
|
||
lat: 48.14,
|
||
lon: 11.56,
|
||
category: 'local',
|
||
});
|
||
const rb1 = copy('rb1', 'feed-b', {
|
||
...recordNumbers({ label: 'RB 1' }),
|
||
lat: 48.14 + 25 / 111.32,
|
||
lon: 11.56,
|
||
category: 'regional',
|
||
});
|
||
assert.equal(sameTrain(s1, rb1), false);
|
||
assert.deepEqual(matchCopies([s1, rb1]), []);
|
||
// Nearer, still two lines.
|
||
assert.equal(sameTrain(s1, { ...rb1, lat: 48.15, category: 'local' }), false);
|
||
});
|
||
|
||
test('copies on one line are one train in one category, the nearest first', () => {
|
||
const at = (key, feedId, km, extra = {}) =>
|
||
copy(key, feedId, {
|
||
...recordNumbers({ label: extra.label ?? 'S1' }),
|
||
lat: 48.14 + km / 111.32,
|
||
lon: 11.56,
|
||
category: 'local',
|
||
...extra,
|
||
});
|
||
const gps = at('gps', 'feed-a', 0);
|
||
// The other feed reports two S1 trains near it; the nearer is the same.
|
||
const near = at('near', 'feed-b', 1, { position: 'event' });
|
||
const next = at('next', 'feed-b', 6, { label: 'S 1', position: 'event' });
|
||
assert.equal(sameTrain(gps, near), true);
|
||
assert.deepEqual(
|
||
matchCopies([next, gps, near]).map((group) =>
|
||
group.map((c) => c.key).sort(),
|
||
),
|
||
[['gps', 'near']],
|
||
);
|
||
// Another category, or beyond the match radius: not one train.
|
||
assert.equal(sameTrain(gps, { ...near, category: 'regional' }), false);
|
||
assert.equal(sameTrain(gps, at('far', 'feed-b', 20)), false);
|
||
});
|
||
|
||
test('copies on one line 14 km apart east-west at 60°N are compared', () => {
|
||
// A 0.25° grid column is 13.9 km wide there: the copies sit two columns
|
||
// apart.
|
||
const line = { ...recordNumbers({ label: 'R1' }), category: 'regional' };
|
||
const west = copy('west', 'feed-a', { lat: 60, lon: 10.24, ...line });
|
||
const east = copy('east', 'feed-b', { lat: 60, lon: 10.5, ...line });
|
||
assert.equal(sameTrain(west, east), true);
|
||
assert.equal(matchCopies([west, east]).length, 1);
|
||
});
|
||
|
||
test('the filter reads lines and categories from the trains it compares', () => {
|
||
const entry = (feedId, label, category, lat) => ({
|
||
key: `${feedId}:${label}`,
|
||
feedId,
|
||
category,
|
||
record: {
|
||
id: `v-${feedId}`,
|
||
label,
|
||
lat,
|
||
lon: 11.56,
|
||
positionSource: 'gps',
|
||
},
|
||
});
|
||
const trains = [
|
||
entry('munich-live', 'S1', 'local', 48.14),
|
||
entry('other-live', 'S 1', 'local', 48.15),
|
||
entry('third-live', 'RB 1', 'regional', 48.16),
|
||
];
|
||
const state = {
|
||
_trains: new Map(trains.map((t) => [t.key, t])),
|
||
_pathPacks: new Map(),
|
||
_selectedKey: null,
|
||
};
|
||
const parts = {
|
||
rendering: { paint() {}, schedulePlayback() {} },
|
||
selection: { selectTrain() {} },
|
||
};
|
||
const filter = createDuplicateFilter({
|
||
state,
|
||
parts,
|
||
defer: (fn) => fn(),
|
||
});
|
||
assert.deepEqual(filter.refresh(), { groups: 1, hidden: 1 });
|
||
assert.equal(trains[2].duplicate, false, 'the RB 1 is its own train');
|
||
});
|
||
|
||
test('a Swiss IC line name is not a train number', () => {
|
||
assert.deepEqual(labelNumbers('IC 1'), {
|
||
number: null,
|
||
line: { product: 'IC', number: '1' },
|
||
});
|
||
assert.deepEqual(labelNumbers('IC 2010'), { number: '2010', line: null });
|
||
assert.deepEqual(labelNumbers('EC 7'), { number: '7', line: null });
|
||
});
|