mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-22 03:02:20 +00:00
Coverage lines from KartaView's z13-14 JSON tiles (OSM ways with photos, chained end to start), the photo nearest a clicked line, cones along its sequence, and a viewer for flat photos and 360° panoramas (a small WebGL equirectangular renderer, no new dependency) with ‹ › along the sequence. Mapillary's camera-driven line coverage and sequence cones move to the provider-neutral core (lineCoverage.js, sequenceCones.js) with the tile fetch, zoom ladder, colours and pick prefixes injected; Mapillary keeps thin wrappers and its tests pass unchanged. KartaView quirks handled: api.kartaview.org (the documented api.openstreetcam.org serves empty tiles), photo URLs that name storage1 for photos stored elsewhere, and a photo API that answers 429 to more than about three requests at once (two in flight, retried with backoff). Co-Authored-By: Claude Opus 5.5 <[email protected]>
252 lines
8.2 KiB
JavaScript
252 lines
8.2 KiB
JavaScript
import { freshStreet } from './state.js';
|
|
|
|
/**
|
|
* Owns the panel's viewer element and the provider adapter mounted in it.
|
|
* Adapter poses update `state.street`, the marker and the follow camera.
|
|
*/
|
|
export function createViewerHost({ state, parts }) {
|
|
/** @type {{id: string, adapter: object, unsubscribe: () => void}|null} */
|
|
let active = null;
|
|
/** @type {{id: string, promise: Promise<object>}|null} */
|
|
let mounting = null;
|
|
let openSeq = 0;
|
|
/** Prewarmed, inactive adapters; each holds a live viewer (WebGL context) until `unmount`. */
|
|
const warmed = new Map();
|
|
|
|
function notify() {
|
|
state.notify?.();
|
|
}
|
|
|
|
function providerEntry(providerId) {
|
|
return state.providers.get(providerId) || null;
|
|
}
|
|
|
|
function applyPose(pose) {
|
|
if (!active || !state.street.open || pose.providerId !== active.id) return;
|
|
const previousSequence = state.street.sequenceId;
|
|
Object.assign(state.street, {
|
|
providerId: pose.providerId,
|
|
imageId: pose.imageId,
|
|
position: pose.position ? { ...pose.position } : null,
|
|
bearing: Number.isFinite(pose.bearing) ? pose.bearing : null,
|
|
tilt: Number.isFinite(pose.tilt) ? pose.tilt : 0,
|
|
altitude: Number.isFinite(pose.altitude) ? pose.altitude : null,
|
|
isPano: pose.isPano === true,
|
|
capturedAt: pose.capturedAt ?? null,
|
|
capturedAtPrecision:
|
|
pose.capturedAtPrecision === 'month' ? 'month' : 'day',
|
|
title: pose.title || null,
|
|
sequenceId: pose.sequenceId ?? null,
|
|
creator: pose.creator || null,
|
|
externalUrl: pose.externalUrl || null,
|
|
// FIT / FILL, unless this image has no frame to fit (a panorama).
|
|
renderModes:
|
|
typeof active.adapter.setRenderMode === 'function' &&
|
|
active.adapter.supportsRenderModes?.() !== false,
|
|
});
|
|
parts.marker.set(
|
|
state.street.position,
|
|
state.street.bearing,
|
|
providerEntry(pose.providerId)?.def.marker,
|
|
);
|
|
parts.follow.followCamera();
|
|
// Select the sequence only once the image is on screen, so its lookup
|
|
// never competes with the image download.
|
|
if (!state.street.loading && state.street.sequenceId !== previousSequence)
|
|
selectCurrentSequence();
|
|
notify();
|
|
}
|
|
|
|
function selectCurrentSequence() {
|
|
const { sequenceId, providerId } = state.street;
|
|
const entry = providerEntry(providerId);
|
|
if (!sequenceId || !entry?.instance.selectSequence || !state.enabled)
|
|
return;
|
|
const current = entry.instance.sequenceStats?.()?.selectedId;
|
|
if (current !== sequenceId) entry.instance.selectSequence(sequenceId);
|
|
}
|
|
|
|
/**
|
|
* Mount a provider's adapter. It becomes `active` only on success, so a
|
|
* failed mount is retried on the next open; concurrent opens share one.
|
|
*/
|
|
function mount(entry) {
|
|
if (active?.id === entry.def.id) return Promise.resolve(active.adapter);
|
|
if (mounting?.id === entry.def.id) return mounting.promise;
|
|
if (active) {
|
|
active.adapter.close();
|
|
active.unsubscribe();
|
|
active.adapter.unmount();
|
|
active = null;
|
|
}
|
|
// A prewarmed viewer would sit under this one, holding its WebGL context.
|
|
for (const [id, warm] of warmed) {
|
|
if (id === entry.def.id) continue;
|
|
warmed.delete(id);
|
|
warm.unmount();
|
|
}
|
|
const adapter = entry.instance.viewer;
|
|
const promise = (async () => {
|
|
await adapter.mount(state.street.host);
|
|
if (mounting?.promise !== promise) {
|
|
// Unmounted (layer off, provider switched) while loading. A newer
|
|
// mount of this provider shares the adapter and its viewer: tearing
|
|
// it down here would leave that mount active with no viewer.
|
|
const reused =
|
|
active?.id === entry.def.id || mounting?.id === entry.def.id;
|
|
if (!reused) adapter.unmount();
|
|
throw new Error('Street-level viewer was closed');
|
|
}
|
|
// Listen only once current: an outdated mount releasing the same
|
|
// `applyPose` would otherwise unhook the mount that replaced it.
|
|
const unsubscribe = adapter.onPose(applyPose);
|
|
active = { id: entry.def.id, adapter, unsubscribe };
|
|
warmed.delete(entry.def.id);
|
|
adapter.setRenderMode?.(state.street.renderMode);
|
|
return adapter;
|
|
})();
|
|
mounting = { id: entry.def.id, promise };
|
|
promise.then(
|
|
() => {
|
|
if (mounting?.promise === promise) mounting = null;
|
|
},
|
|
() => {
|
|
if (mounting?.promise === promise) mounting = null;
|
|
},
|
|
);
|
|
return promise;
|
|
}
|
|
|
|
/** Open an image: true once its first pose is in, false if it failed or was overtaken. */
|
|
async function open(providerId, imageId, { frame = true } = {}) {
|
|
const entry = providerEntry(providerId);
|
|
if (!entry || !imageId) return false;
|
|
if (!state.street.host) {
|
|
// A nearest-image lookup may have set it; nothing is loading now.
|
|
state.street.loading = false;
|
|
state.street.error = 'Open the Street Level panel to view imagery';
|
|
notify();
|
|
return false;
|
|
}
|
|
const seq = ++openSeq;
|
|
const current = () => seq === openSeq;
|
|
// Claimed now, honoured after loading only if nothing newer took the camera.
|
|
const ticket =
|
|
frame && !state.street.follow ? parts.follow.beginFraming() : null;
|
|
Object.assign(state.street, {
|
|
loading: true,
|
|
error: null,
|
|
open: true,
|
|
providerId,
|
|
providerName: entry.def.name,
|
|
providerLabel: entry.def.label,
|
|
});
|
|
notify();
|
|
try {
|
|
const adapter = await mount(entry);
|
|
if (!current()) return false;
|
|
// Per open: close() resets it, and a reopen skips mount().
|
|
state.street.renderModes = typeof adapter.setRenderMode === 'function';
|
|
await adapter.open(String(imageId));
|
|
if (!current()) return false;
|
|
if (ticket && !state.street.follow) parts.follow.lookAtPosition(ticket);
|
|
} catch (error) {
|
|
if (current())
|
|
state.street.error = error?.message || 'Image could not be opened';
|
|
} finally {
|
|
if (current()) state.street.loading = false;
|
|
notify();
|
|
}
|
|
if (!current() || state.street.error) return false;
|
|
selectCurrentSequence();
|
|
return true;
|
|
}
|
|
|
|
/** Close the image and stop any framing flight; the adapter stays warm. */
|
|
function close() {
|
|
openSeq++;
|
|
parts.follow.cancelFraming();
|
|
active?.adapter.close();
|
|
Object.assign(state.street, freshStreet());
|
|
parts.marker.clear();
|
|
notify();
|
|
}
|
|
|
|
function attach(element) {
|
|
state.street.host = element || null;
|
|
if (element && state.street.open) resize();
|
|
}
|
|
|
|
function resize() {
|
|
try {
|
|
active?.adapter.resize();
|
|
} catch {
|
|
/* no-op */
|
|
}
|
|
}
|
|
|
|
function setRenderMode(mode) {
|
|
state.street.renderMode = mode === 'fill' ? 'fill' : 'letterbox';
|
|
try {
|
|
active?.adapter.setRenderMode?.(state.street.renderMode);
|
|
} catch {
|
|
/* adapter not ready */
|
|
}
|
|
notify();
|
|
}
|
|
|
|
/** Stand active providers' viewers up ahead of the first image. */
|
|
async function prewarm(entries) {
|
|
const host = state.street.host;
|
|
if (!host || !state.enabled) return;
|
|
for (const entry of entries) {
|
|
const adapter = entry.instance.viewer;
|
|
if (!adapter.prewarm || !entry.on) continue;
|
|
// Another provider's viewer is showing in the host: do not build under it.
|
|
if (active && active.id !== entry.def.id) continue;
|
|
try {
|
|
await adapter.prewarm(host);
|
|
} catch {
|
|
/* the real open reports errors */
|
|
}
|
|
if (active?.id === entry.def.id || mounting?.id === entry.def.id)
|
|
continue;
|
|
// Switched off, or another viewer took the host meanwhile.
|
|
if (!state.enabled || !entry.on || active || mounting) adapter.unmount();
|
|
else warmed.set(entry.def.id, adapter);
|
|
}
|
|
}
|
|
|
|
/** Tear down every viewer, or only `providerId`'s (active or prewarmed). */
|
|
function unmount(providerId) {
|
|
if (
|
|
!providerId ||
|
|
active?.id === providerId ||
|
|
mounting?.id === providerId
|
|
) {
|
|
close();
|
|
mounting = null;
|
|
if (active) {
|
|
active.unsubscribe();
|
|
active.adapter.unmount();
|
|
active = null;
|
|
}
|
|
}
|
|
for (const [id, adapter] of warmed) {
|
|
if (providerId && id !== providerId) continue;
|
|
warmed.delete(id);
|
|
adapter.unmount();
|
|
}
|
|
}
|
|
|
|
return {
|
|
attach,
|
|
open,
|
|
close,
|
|
resize,
|
|
setRenderMode,
|
|
prewarm,
|
|
unmount,
|
|
};
|
|
}
|