mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
267 lines
8.9 KiB
JavaScript
267 lines
8.9 KiB
JavaScript
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,
|
|
};
|
|
}
|