mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 02:02:21 +00:00
- The flight after a count click checks the frame on both axes and at the height of the highest mount, so a group on a slope or in a very wide window stays in view; when it cannot, it flies to the nearest cell with two or more cameras, never to a lone camera that joined the count. - A count takes a click over a background fill no layer owns (earthquake discs, fire perimeters), and still yields to a scene item another layer registered. - A count crossing the HUD edge refreshes the view only when the active icon or a lone camera depends on it, and never mid-motion, so panning no longer runs extra full view passes. - A count restored at the HUD edge keeps the lone cameras its outline covers, and leaves the others as icons.
239 lines
8.3 KiB
JavaScript
239 lines
8.3 KiB
JavaScript
import { fromDegrees } from '../geo/ellipsoid.js';
|
|
|
|
/** Exact below 1,000, then K with one decimal below 10K. Uses Latin digits in every locale. */
|
|
export function formatCameraCount(count) {
|
|
if (count < 1000) return String(count);
|
|
const thousands =
|
|
count < 10000 ? Math.round(count / 100) / 10 : Math.round(count / 1000);
|
|
return `${thousands}K`;
|
|
}
|
|
|
|
/** An empty cell and its on-screen picker candidate. */
|
|
export function createCameraCell(key) {
|
|
return {
|
|
key,
|
|
count: 0,
|
|
latSum: 0,
|
|
lonSum: 0,
|
|
heightSum: 0,
|
|
south: Infinity,
|
|
north: -Infinity,
|
|
west: Infinity,
|
|
east: -Infinity,
|
|
low: Infinity,
|
|
high: -Infinity,
|
|
winner: null,
|
|
rank: Infinity,
|
|
};
|
|
}
|
|
|
|
/** Accumulate one horizon-visible mount in its ground cell. */
|
|
export function addCellCamera(cell, camera) {
|
|
const { lat, lon, absoluteHeightM: height = 0 } = camera;
|
|
cell.count++;
|
|
// Integer sums make the mean independent of catalog order, to about a centimetre.
|
|
cell.latSum += Math.round(lat * 1e7);
|
|
cell.lonSum += Math.round(lon * 1e7);
|
|
cell.heightSum += Math.round(height * 100);
|
|
cell.south = Math.min(cell.south, lat);
|
|
cell.north = Math.max(cell.north, lat);
|
|
cell.west = Math.min(cell.west, lon);
|
|
cell.east = Math.max(cell.east, lon);
|
|
cell.low = Math.min(cell.low, height);
|
|
cell.high = Math.max(cell.high, height);
|
|
}
|
|
|
|
const wrapLongitude = (lon) => ((((lon + 180) % 360) + 360) % 360) - 180;
|
|
|
|
/** Mean longitude and latitude of a cell's mounts, in degrees. */
|
|
export function cellLonLat(cell) {
|
|
return {
|
|
lon: wrapLongitude(cell.lonSum / (1e7 * cell.count)),
|
|
lat: cell.latSum / (1e7 * cell.count),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Geographic mean of the mounts. Its height is the drawn ground under it
|
|
* when the cell carries one (`groundM`), since a camera nobody has looked at
|
|
* yet may still hold a catalog height far from the terrain; otherwise the
|
|
* mean mount height.
|
|
*/
|
|
export function cellCenter(cell) {
|
|
const { lon, lat } = cellLonLat(cell);
|
|
return fromDegrees(
|
|
lon,
|
|
lat,
|
|
Number.isFinite(cell.groundM)
|
|
? cell.groundM
|
|
: cell.heightSum / (100 * cell.count),
|
|
);
|
|
}
|
|
|
|
/** Half the east-west and north-south ground extent of a cell's mounts, in metres. */
|
|
export function cellHalfExtents(cell) {
|
|
// The parallel nearest the equator bounds the width of every row.
|
|
const parallel = (Math.max(0, cell.south, -cell.north) * Math.PI) / 180;
|
|
return {
|
|
halfWidthM: 0.5 * (cell.east - cell.west) * 111_320 * Math.cos(parallel),
|
|
halfHeightM: 0.5 * (cell.north - cell.south) * 111_320,
|
|
};
|
|
}
|
|
|
|
/** A padded sphere over the rectangle and every mount, centred at groundM
|
|
* when set, otherwise at the mid mount height. */
|
|
export function cellBounds(cell) {
|
|
const lat = (cell.north + cell.south) / 2;
|
|
const lon = wrapLongitude((cell.east + cell.west) / 2);
|
|
const height = Number.isFinite(cell.groundM)
|
|
? cell.groundM
|
|
: (cell.high + cell.low) / 2;
|
|
const { halfWidthM, halfHeightM } = cellHalfExtents(cell);
|
|
const halfWidth = Math.hypot(halfWidthM, halfHeightM);
|
|
const vertical = Math.max(cell.high - height, height - cell.low);
|
|
const radius = 1.2 * Math.hypot(halfWidth, vertical);
|
|
return { center: fromDegrees(lon, lat, height), radius: Math.max(1, radius) };
|
|
}
|
|
|
|
/** Add a whole ground cell to a marker, retaining the sums for a weighted mean. */
|
|
function addCell(target, cell) {
|
|
// Across the antimeridian a cell joins on the side of the group's mean.
|
|
const shift = target.count
|
|
? 360 *
|
|
Math.round(
|
|
(target.lonSum / target.count - cell.lonSum / cell.count) / 3.6e9,
|
|
)
|
|
: 0;
|
|
target.count += cell.count;
|
|
target.latSum += cell.latSum;
|
|
target.lonSum += cell.lonSum + shift * 1e7 * cell.count;
|
|
target.heightSum += cell.heightSum;
|
|
target.south = Math.min(target.south, cell.south);
|
|
target.north = Math.max(target.north, cell.north);
|
|
target.west = Math.min(target.west, cell.west + shift);
|
|
target.east = Math.max(target.east, cell.east + shift);
|
|
target.low = Math.min(target.low, cell.low);
|
|
target.high = Math.max(target.high, cell.high);
|
|
}
|
|
|
|
/** Visit the touching pills in this marker's bucket and its eight neighbors. */
|
|
function visitNeighbors(marker, grid, gap, visit) {
|
|
for (let col = -1; col <= 1; col++) {
|
|
for (let row = -1; row <= 1; row++) {
|
|
const bucket = grid.get(`${marker.col + col},${marker.row + row}`);
|
|
if (!bucket) continue;
|
|
for (const other of bucket) {
|
|
// Distance between the horizontal centre segments of the two pills.
|
|
const extra = marker.halfSegment + other.halfSegment;
|
|
const dx = Math.max(0, Math.abs(marker.x - other.x) - extra);
|
|
const dy = marker.y - other.y;
|
|
const reach = marker.radius + other.radius + gap;
|
|
if (dx * dx + dy * dy >= reach * reach) continue;
|
|
visit(other, dx * dx + dy * dy, reach);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge connected groups of overlapping horizontal pills. Each marker occupies
|
|
* one grid bucket. Even the widest pill can only touch its eight neighbors.
|
|
* A cell with one camera takes the footprint `sizeFor(1)` gives its icon and
|
|
* joins the nearest count it touches. Lone cameras never join each other
|
|
* or bridge two counts. A spread icon's `offsetPx` shifts its footprint sideways.
|
|
* A merged group lists its ground cells in `parts`.
|
|
* Ground cells stay intact for the camera picker and individual-icon pass.
|
|
*/
|
|
export function mergeCountCells(cells, project, sizeFor, gap) {
|
|
let columnWidth = 0;
|
|
let rowHeight = 0;
|
|
const markers = cells.map((cell) => {
|
|
const screen = project(cellCenter(cell));
|
|
const { width, height } = sizeFor(cell.count, cell);
|
|
columnWidth = Math.max(columnWidth, width + gap);
|
|
rowHeight = Math.max(rowHeight, height + gap);
|
|
// The view projector reuses its result object.
|
|
return {
|
|
cell,
|
|
x: screen ? screen.x + (cell.offsetPx ?? 0) : undefined,
|
|
y: screen?.y,
|
|
halfSegment: (width - height) / 2,
|
|
radius: height / 2,
|
|
};
|
|
});
|
|
const grid = new Map();
|
|
for (const marker of markers) {
|
|
if (!Number.isFinite(marker.x) || !Number.isFinite(marker.y)) continue;
|
|
marker.col = Math.floor(marker.x / columnWidth);
|
|
marker.row = Math.floor(marker.y / rowHeight);
|
|
const key = `${marker.col},${marker.row}`;
|
|
if (!grid.has(key)) grid.set(key, new Set());
|
|
marker.bucket = grid.get(key);
|
|
if (marker.cell.count > 1) marker.bucket.add(marker);
|
|
}
|
|
|
|
for (const marker of markers) {
|
|
if (marker.cell.count !== 1 || !marker.bucket) continue;
|
|
let best = Infinity;
|
|
visitNeighbors(marker, grid, gap, (other, distanceSquared, reach) => {
|
|
const clearance = Math.sqrt(distanceSquared) - reach;
|
|
if (clearance < best) {
|
|
best = clearance;
|
|
marker.nearest = other;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Only counts were candidates for nearest. Now they can claim lone cameras.
|
|
for (const marker of markers)
|
|
if (marker.cell.count === 1) marker.bucket?.add(marker);
|
|
|
|
const members = [];
|
|
for (const seed of markers) {
|
|
if (seed.cell.count === 1 || !seed.bucket?.delete(seed)) continue;
|
|
members.length = 0;
|
|
members.push(seed);
|
|
for (const marker of members) {
|
|
if (marker.cell.count === 1) continue;
|
|
visitNeighbors(marker, grid, gap, (other) => {
|
|
if (other.cell.count === 1 && other.nearest !== marker) return;
|
|
other.bucket.delete(other);
|
|
members.push(other);
|
|
});
|
|
}
|
|
if (members.length === 1) {
|
|
seed.result = seed.cell;
|
|
} else {
|
|
const group = createCameraCell(seed.cell.key);
|
|
group.lone = [];
|
|
group.parts = [];
|
|
for (const { cell } of members) {
|
|
addCell(group, cell);
|
|
group.parts.push(...(cell.parts ?? [cell]));
|
|
if (cell.count === 1) group.lone.push(cell);
|
|
else if (cell.lone) group.lone.push(...cell.lone);
|
|
}
|
|
seed.result = group;
|
|
}
|
|
}
|
|
|
|
const groups = [];
|
|
for (const marker of markers) {
|
|
if (marker.result) groups.push(marker.result);
|
|
else if (!marker.bucket || marker.bucket.has(marker))
|
|
groups.push(marker.cell);
|
|
}
|
|
return groups;
|
|
}
|
|
|
|
/** Rebuild a group's count under its original key, keeping only the lone cameras in `keep`. */
|
|
export function withoutLoneCameras(group, keep = []) {
|
|
const counts = (group.parts ?? []).filter((cell) => cell.count > 1);
|
|
if (!counts.length) return null;
|
|
const core = createCameraCell(group.key);
|
|
core.parts = [...counts, ...keep];
|
|
if (keep.length) core.lone = [...keep];
|
|
for (const cell of core.parts) addCell(core, cell);
|
|
return core;
|
|
}
|