mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
refactor(radio): separate directory and playback components
This commit is contained in:
1 parent
ba7fda74d7
commit
41b3cc1705
30 files changed
+4488
-2795
No files matched your search
@@ -0,0 +1,266 @@
|
||||
import {
|
||||
GLOBAL_RADIO_ALTITUDE_M,
|
||||
RADIO_SINGLETON_GLOBAL_LIMIT,
|
||||
RADIO_SINGLETON_MID_LIMIT,
|
||||
RADIO_SINGLETON_NEAR_LIMIT,
|
||||
RADIO_OVERLAY_COHORT_LIMIT,
|
||||
} from './policy.js';
|
||||
|
||||
export function createClustering({
|
||||
state: layerState,
|
||||
services,
|
||||
parts,
|
||||
source,
|
||||
}) {
|
||||
/** Return the bounded singleton-label allowance for the current camera scale. */
|
||||
|
||||
function radioSingletonLabelLimit(cameraHeightM) {
|
||||
const height = Math.max(0, Number(cameraHeightM) || 0);
|
||||
if (height >= GLOBAL_RADIO_ALTITUDE_M) return RADIO_SINGLETON_GLOBAL_LIMIT;
|
||||
if (height >= 250_000) return RADIO_SINGLETON_MID_LIMIT;
|
||||
return RADIO_SINGLETON_NEAR_LIMIT;
|
||||
}
|
||||
|
||||
/** Rank visible singleton stations by camera distance and stable station id. */
|
||||
|
||||
function selectRadioSingletonCandidates(
|
||||
candidates,
|
||||
limit = RADIO_SINGLETON_NEAR_LIMIT,
|
||||
) {
|
||||
const distance = (candidate) => {
|
||||
const value = Number(candidate?.distanceM);
|
||||
return Number.isFinite(value) ? value : Number.POSITIVE_INFINITY;
|
||||
};
|
||||
return [...(candidates || [])]
|
||||
.sort(
|
||||
(a, b) =>
|
||||
distance(a) - distance(b) ||
|
||||
String(a?.station?.id || a?.id || '').localeCompare(
|
||||
String(b?.station?.id || b?.id || ''),
|
||||
),
|
||||
)
|
||||
.slice(0, Math.max(0, Math.floor(Number(limit) || 0)));
|
||||
}
|
||||
|
||||
/** Rank and cap ambient Radio clusters before shared-host entry allocation. */
|
||||
|
||||
function selectRadioClusterCandidates(
|
||||
candidates,
|
||||
limit = RADIO_OVERLAY_COHORT_LIMIT,
|
||||
) {
|
||||
return [...(candidates || [])]
|
||||
.sort(
|
||||
(a, b) =>
|
||||
(Number(b?.stationCount) || 0) - (Number(a?.stationCount) || 0) ||
|
||||
String(a?.id || '').localeCompare(String(b?.id || '')),
|
||||
)
|
||||
.slice(0, Math.max(0, Math.floor(Number(limit) || 0)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Preserve one-to-one overlay identity for overlapping clusters.
|
||||
* Cesium clustering is screen-space, so a small camera move may alter exact
|
||||
* membership even when the same geographic cluster remains visible. Every
|
||||
* positive overlap participates in greatest-contributor discovery, while
|
||||
* inheritance remains mutual-best: a current cluster accepts only one of its
|
||||
* greatest contributors and a prior identity transfers only to one of its
|
||||
* strongest split children.
|
||||
*/
|
||||
|
||||
function reconcileRadioClusterCandidates(
|
||||
candidates,
|
||||
previous = [],
|
||||
createId = null,
|
||||
) {
|
||||
const current = (Array.isArray(candidates) ? candidates : []).map(
|
||||
(candidate, index) => {
|
||||
const stationIds = [
|
||||
...new Set((candidate?.stationIds || []).map((id) => String(id))),
|
||||
].sort();
|
||||
const membershipId = String(
|
||||
candidate?.id || `membership:${stationIds.join('|')}`,
|
||||
);
|
||||
return {
|
||||
...candidate,
|
||||
_reconcileIndex: index,
|
||||
_reconcileMembershipId: membershipId,
|
||||
_reconcileCanonicalKey: `${membershipId}\u0000${stationIds.join('\u0000')}`,
|
||||
stationIds,
|
||||
};
|
||||
},
|
||||
);
|
||||
const priorMembershipsByIdentity = new Map();
|
||||
for (const candidate of Array.isArray(previous) ? previous : []) {
|
||||
const identityId = String(candidate?.identityId || candidate?.id || '');
|
||||
if (!identityId) continue;
|
||||
if (!priorMembershipsByIdentity.has(identityId)) {
|
||||
priorMembershipsByIdentity.set(identityId, new Set());
|
||||
}
|
||||
const membership = priorMembershipsByIdentity.get(identityId);
|
||||
for (const stationId of candidate?.stationIds || [])
|
||||
membership.add(String(stationId));
|
||||
}
|
||||
const prior = [...priorMembershipsByIdentity]
|
||||
.map(([identityId, stationIds]) => ({
|
||||
identityId,
|
||||
stationIds: [...stationIds].sort(),
|
||||
}))
|
||||
.filter((candidate) => candidate.stationIds.length)
|
||||
.sort((a, b) => a.identityId.localeCompare(b.identityId));
|
||||
const priorByStation = new Map();
|
||||
for (let priorIndex = 0; priorIndex < prior.length; priorIndex += 1) {
|
||||
for (const stationId of prior[priorIndex].stationIds) {
|
||||
if (!priorByStation.has(stationId)) priorByStation.set(stationId, []);
|
||||
priorByStation.get(stationId).push(priorIndex);
|
||||
}
|
||||
}
|
||||
|
||||
const edges = [];
|
||||
const greatestOverlapByCurrent = new Map();
|
||||
const greatestOverlapByPrior = new Map();
|
||||
for (
|
||||
let currentIndex = 0;
|
||||
currentIndex < current.length;
|
||||
currentIndex += 1
|
||||
) {
|
||||
const overlapByPrior = new Map();
|
||||
for (const stationId of current[currentIndex].stationIds) {
|
||||
for (const priorIndex of priorByStation.get(stationId) || []) {
|
||||
overlapByPrior.set(
|
||||
priorIndex,
|
||||
(overlapByPrior.get(priorIndex) || 0) + 1,
|
||||
);
|
||||
}
|
||||
}
|
||||
for (const [priorIndex, overlap] of overlapByPrior) {
|
||||
const union =
|
||||
current[currentIndex].stationIds.length +
|
||||
prior[priorIndex].stationIds.length -
|
||||
overlap;
|
||||
const smaller = Math.min(
|
||||
current[currentIndex].stationIds.length,
|
||||
prior[priorIndex].stationIds.length,
|
||||
);
|
||||
const score = smaller > 0 ? overlap / smaller : 0;
|
||||
const similarity = union > 0 ? overlap / union : 0;
|
||||
edges.push({ currentIndex, priorIndex, overlap, score, similarity });
|
||||
greatestOverlapByCurrent.set(
|
||||
currentIndex,
|
||||
Math.max(greatestOverlapByCurrent.get(currentIndex) || 0, overlap),
|
||||
);
|
||||
greatestOverlapByPrior.set(
|
||||
priorIndex,
|
||||
Math.max(greatestOverlapByPrior.get(priorIndex) || 0, overlap),
|
||||
);
|
||||
}
|
||||
}
|
||||
const eligibleEdges = edges.filter(
|
||||
(edge) =>
|
||||
edge.overlap === greatestOverlapByCurrent.get(edge.currentIndex) &&
|
||||
edge.overlap === greatestOverlapByPrior.get(edge.priorIndex),
|
||||
);
|
||||
eligibleEdges.sort(
|
||||
(a, b) =>
|
||||
// Identity follows the contributor representing the largest share of the
|
||||
// new cluster. Overlap-coefficient-first incorrectly lets a fully retained
|
||||
// two-station minority beat a larger partial contributor during a merge.
|
||||
b.overlap - a.overlap ||
|
||||
b.score - a.score ||
|
||||
b.similarity - a.similarity ||
|
||||
current[a.currentIndex]._reconcileCanonicalKey.localeCompare(
|
||||
current[b.currentIndex]._reconcileCanonicalKey,
|
||||
) ||
|
||||
prior[a.priorIndex].identityId.localeCompare(
|
||||
prior[b.priorIndex].identityId,
|
||||
),
|
||||
);
|
||||
|
||||
const inheritedByCurrent = new Map();
|
||||
const usedPriorIdentities = new Set();
|
||||
for (const edge of eligibleEdges) {
|
||||
const identityId = prior[edge.priorIndex].identityId;
|
||||
if (
|
||||
inheritedByCurrent.has(edge.currentIndex) ||
|
||||
usedPriorIdentities.has(identityId)
|
||||
)
|
||||
continue;
|
||||
inheritedByCurrent.set(
|
||||
edge.currentIndex,
|
||||
prior[edge.priorIndex].identityId,
|
||||
);
|
||||
usedPriorIdentities.add(identityId);
|
||||
}
|
||||
|
||||
const generatedByCurrent = new Map();
|
||||
if (typeof createId === 'function') {
|
||||
const freshIndices = current
|
||||
.map((candidate, index) => ({ candidate, index }))
|
||||
.filter(({ index }) => !inheritedByCurrent.has(index))
|
||||
.sort((a, b) =>
|
||||
a.candidate._reconcileCanonicalKey.localeCompare(
|
||||
b.candidate._reconcileCanonicalKey,
|
||||
),
|
||||
);
|
||||
for (const { candidate, index } of freshIndices) {
|
||||
generatedByCurrent.set(index, String(createId(candidate, index) || ''));
|
||||
}
|
||||
}
|
||||
|
||||
return current.map((candidate, index) => {
|
||||
const membershipId = candidate._reconcileMembershipId;
|
||||
const inherited = inheritedByCurrent.get(index);
|
||||
const generated = generatedByCurrent.get(index) || '';
|
||||
const identityId = inherited || generated || membershipId;
|
||||
const {
|
||||
_reconcileIndex,
|
||||
_reconcileMembershipId,
|
||||
_reconcileCanonicalKey,
|
||||
...rest
|
||||
} = candidate;
|
||||
return { ...rest, membershipId, identityId, id: identityId };
|
||||
});
|
||||
}
|
||||
|
||||
function resetRadioClusterOverlayIdentities() {
|
||||
layerState._clusterOverlayIdentities = [];
|
||||
}
|
||||
|
||||
function emptyRadioOverlayDiagnostics() {
|
||||
return {
|
||||
entryCount: 0,
|
||||
selectedCount: 0,
|
||||
singletonTexts: [],
|
||||
singletonIds: [],
|
||||
clusterTexts: [],
|
||||
clusterIds: [],
|
||||
clusterMemberships: [],
|
||||
};
|
||||
}
|
||||
|
||||
/** Retain refresh identities only while every represented station still exists. */
|
||||
|
||||
function retainRadioClusterIdentitiesForStations(previous, stations) {
|
||||
const stationIds = new Set(
|
||||
(stations || [])
|
||||
.map((station) => String(station?.id || ''))
|
||||
.filter(Boolean),
|
||||
);
|
||||
return (previous || []).filter(
|
||||
(candidate) =>
|
||||
Array.isArray(candidate?.stationIds) &&
|
||||
candidate.stationIds.length > 0 &&
|
||||
candidate.stationIds.every((stationId) =>
|
||||
stationIds.has(String(stationId)),
|
||||
),
|
||||
);
|
||||
}
|
||||
return {
|
||||
radioSingletonLabelLimit,
|
||||
selectRadioSingletonCandidates,
|
||||
selectRadioClusterCandidates,
|
||||
reconcileRadioClusterCandidates,
|
||||
resetRadioClusterOverlayIdentities,
|
||||
emptyRadioOverlayDiagnostics,
|
||||
retainRadioClusterIdentitiesForStations,
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user