astro-viewer 3.11.0 → 3.13.0

package/lib-esm/AstroSphere.js

@@ -54,12 +54,18 @@ class AstroSphere {
     _activeHiPS = null;
     _activeHiPSLayers = [];
     _activeXYZ2 = null;
+    _earthRasterOverlays = [];
+    _earthRasterOverlaySequence = 0;
     _activeMeshHiPS = null;
     _activeBaseLayer = null;
+    _activeDomain = "astronomy";
+    domainCameraStates = {};
     startup = true;
     fov;
-    activeCatalogues = [];
-    activeFootprintSets = [];
+    astronomyCatalogues = [];
+    earthPointSets = [];
+    astronomyFootprintSets = [];
+    earthFootprintSets = [];
     activePolylineSets = [];
     activeSensorCones = [];
     activeSatelliteObjects = [];
@@ -75,6 +81,7 @@ class AstroSphere {
     lockedNorthSouthDecDeg = null;
     keepCameraNorthUp = true;
     gridLabelContainers;
+    fovAnimationResolve = null;
     constructor(canvas, webgl, options = {}) {
         console.log("[AstroSphere] new instance for canvas", canvas.id);
         // Keep global GL context (as in original JS)
@@ -292,9 +299,7 @@ class AstroSphere {
         return true;
     }
     emitCameraChanged(reason) {
-        // avoid dispatch before scene is ready
-        if (!this._activeHiPS && !this._activeXYZ2 && !this._activeMeshHiPS)
-            return;
+        // Camera interaction remains meaningful even when no base layer is active.
         if (!this._healpixGrid?.fovObj)
             return;
         const detail = this.getCurrentStatus();
@@ -321,6 +326,7 @@ class AstroSphere {
             canvas.setPointerCapture(event.pointerId);
             this.mouseDown = true;
             this._camera.cancelFlyTo();
+            this.cancelFoVAnimation();
             const rect = canvas.getBoundingClientRect();
             this.lastMouseX = event.clientX - rect.left; // locale al canvas
             this.lastMouseY = event.clientY - rect.top; // locale al canvas
@@ -359,8 +365,11 @@ class AstroSphere {
                 if (mousePoint && mousePoint.length > 0) {
                     this.mouseHelper.update(mousePoint);
                     this.updateLastMousePoint();
-                    for (const cat of this.activeCatalogues) {
-                        const clickResult = cat.selectPrimarySourceFromClick(this.mouseHelper);
+                    for (const cat of this.getActivePointSets()) {
+                        const activeModelMatrix = this.getActiveDomainModelMatrix();
+                        if (!activeModelMatrix)
+                            continue;
+                        const clickResult = cat.selectPrimarySourceFromClick(this.mouseHelper, activeModelMatrix, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
                         if (!clickResult?.sources.length)
                             continue;
                         this._webgl.canvas.dispatchEvent(new CustomEvent("source-clicked", {
@@ -373,7 +382,7 @@ class AstroSphere {
                             composed: true,
                         }));
                     }
-                    for (const fset of this.activeFootprintSets) {
+                    for (const fset of this.getActiveFootprintSets()) {
                         const clickResult = fset.selectPrimaryFootprintFromClick(this.mouseHelper);
                         if (!clickResult?.footprints.length)
                             continue;
@@ -448,6 +457,7 @@ class AstroSphere {
             const currentFov = this._healpixGrid.getMinFoV();
             const zoomStep = this.computeZoomStep(currentFov, event.deltaY);
             this._camera.cancelFlyTo();
+            this.cancelFoVAnimation();
             // Apply wheel zoom immediately and discard any queued inertia so reversing
             // direction feels responsive instead of "buffered".
             this.zoomInertia = 0;
@@ -470,8 +480,11 @@ class AstroSphere {
             }
             this.mouseHelper.update(mousePoint);
             this.updateLastMousePoint();
-            for (const cat of this.activeCatalogues) {
-                const pickResult = cat.getSourcesFromPointer(this.mouseHelper);
+            for (const cat of this.getActivePointSets()) {
+                const activeModelMatrix = this.getActiveDomainModelMatrix();
+                if (!activeModelMatrix)
+                    continue;
+                const pickResult = cat.getSourcesFromPointer(this.mouseHelper, activeModelMatrix, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
                 if (!pickResult?.sources.length)
                     continue;
                 this._webgl.canvas.dispatchEvent(new CustomEvent("source-contextmenu", {
@@ -486,7 +499,7 @@ class AstroSphere {
                 }));
                 break;
             }
-            for (const fset of this.activeFootprintSets) {
+            for (const fset of this.getActiveFootprintSets()) {
                 const pickResult = fset.getFootprintsFromPointer(this.mouseHelper);
                 if (!pickResult?.footprints.length)
                     continue;
@@ -576,19 +589,22 @@ class AstroSphere {
         return new HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
     }
     activateHiPS(hipsDescriptor) {
+        if (this._activeHiPSLayers.length > 0) {
+            throw new Error("Cannot load a HiPS base layer while stacked layers are active.");
+        }
         const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
-        for (const hips of this._activeHiPSLayers) {
-            tileBuffer.removeHiPS(hips);
+        if (this._activeHiPS) {
+            tileBuffer.removeHiPS(this._activeHiPS);
         }
-        this._activeHiPSLayers = [];
         const hips = this.createHiPS(hipsDescriptor);
-        this._activeHiPSLayers.push(hips);
         this._activeHiPS = hips;
+        this._activeDomain = "astronomy";
         this._activeBaseLayer = "hips";
         return hips;
     }
     setHiPSOpacity(hips, opacity) {
-        if (!this._activeHiPSLayers.includes(hips)) {
+        const isBaseLayer = this._activeHiPSLayers.length === 0 && this._activeHiPS === hips;
+        if (!isBaseLayer && !this._activeHiPSLayers.includes(hips)) {
             throw new Error("HiPS layer is not active in this AstroSphere.");
         }
         hips.setOpacity(opacity);
@@ -596,6 +612,13 @@ class AstroSphere {
     addHiPS(hipsDescriptor) {
         const normalizeURL = (url) => String(url).replace(/\/+$/, "");
         const descriptorURL = normalizeURL(hipsDescriptor.url);
+        // Entering stack mode discards the standalone base HiPS. Base mode and
+        // stack mode are intentionally mutually exclusive.
+        if (this._activeHiPSLayers.length === 0 && this._activeHiPS) {
+            const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+            tileBuffer.removeHiPS(this._activeHiPS);
+            this._activeHiPS = null;
+        }
         const existing = this._activeHiPSLayers.find((hips) => normalizeURL(hips.baseURL) === descriptorURL);
         if (existing) {
             throw new Error(`HiPS already active: ${String(hipsDescriptor.url)}`);
@@ -603,6 +626,7 @@ class AstroSphere {
         const hips = this.createHiPS(hipsDescriptor);
         this._activeHiPSLayers.push(hips);
         this._activeHiPS = hips;
+        this._activeDomain = "astronomy";
         this._activeBaseLayer = "hips";
         return hips;
     }
@@ -627,8 +651,13 @@ class AstroSphere {
     }
     removeAllHiPS() {
         const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
-        for (const hips of this._activeHiPSLayers) {
-            tileBuffer.removeHiPS(hips);
+        if (this._activeHiPSLayers.length === 0 && this._activeHiPS) {
+            tileBuffer.removeHiPS(this._activeHiPS);
+        }
+        else {
+            for (const hips of this._activeHiPSLayers) {
+                tileBuffer.removeHiPS(hips);
+            }
         }
         this._activeHiPSLayers = [];
         this._activeHiPS = null;
@@ -641,39 +670,169 @@ class AstroSphere {
         this._activeBaseLayer = "xyz";
     }
     activateXYZ2(config) {
+        this._activeDomain = "earth";
         this._activeXYZ2 = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, config, this._webgl, this.gridLabelContainers);
         this._activeBaseLayer = "xyz";
     }
     activateMeshHiPS(descriptor) {
+        this._activeDomain = "mesh";
         this._activeMeshHiPS = new MeshHiPS(descriptor.meshRadius, [0.0, 0.0, 0.0], 0, 0, descriptor, this._webgl, this._healpixGrid);
         this._activeBaseLayer = "meships";
     }
+    setMeshHiPSColor(color) {
+        this._activeMeshHiPS?.setColor(color);
+    }
+    setMeshHiPSWireframe(wireframe) {
+        this._activeMeshHiPS?.setWireframe(wireframe);
+    }
     activateWMTS(config) {
+        this._activeDomain = "earth";
         const adapter = new WMTSAdapter(config);
         const xyzConfig = adapter.toXYZLayerConfig();
         this._activeXYZ2 = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, new XYZMapDescriptor(config.layer ? `WMTS ${config.layer}` : "WMTS Earth2 Layer", xyzConfig.urlTemplate, xyzConfig.minZoom ?? 0, xyzConfig.maxZoom ?? 8, xyzConfig.segmentsPerSide ?? 48, xyzConfig.maxCachedTiles ?? 384, 8, xyzConfig.urlResolver), this._webgl, this.gridLabelContainers);
         this._activeBaseLayer = "xyz";
     }
-    // Catalogue section
+    addXYZRasterOverlay(config) {
+        const map = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, config, this._webgl, this.gridLabelContainers);
+        return this.addEarthRasterOverlay(config.name, "xyz", map);
+    }
+    addWMTSRasterOverlay(config) {
+        const adapter = new WMTSAdapter(config);
+        const xyzConfig = adapter.toXYZLayerConfig();
+        const name = config.layer ? `WMTS ${config.layer}` : "WMTS Earth Raster Overlay";
+        const map = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, new XYZMapDescriptor(name, xyzConfig.urlTemplate, xyzConfig.minZoom ?? 0, xyzConfig.maxZoom ?? 8, xyzConfig.segmentsPerSide ?? 48, xyzConfig.maxCachedTiles ?? 384, 8, xyzConfig.urlResolver), this._webgl, this.gridLabelContainers);
+        return this.addEarthRasterOverlay(name, "wmts", map);
+    }
+    getEarthRasterOverlays() {
+        return this._earthRasterOverlays.map(({ map: _map, ...overlay }) => ({ ...overlay }));
+    }
+    setEarthRasterOverlayOpacity(id, opacity) {
+        const overlay = this._earthRasterOverlays.find((entry) => entry.id === id);
+        if (!overlay)
+            return;
+        overlay.opacity = Math.min(1, Math.max(0, opacity));
+        overlay.map.setOpacity(overlay.opacity);
+    }
+    setEarthRasterOverlayVisible(id, visible) {
+        const overlay = this._earthRasterOverlays.find((entry) => entry.id === id);
+        if (overlay)
+            overlay.visible = visible;
+    }
+    removeEarthRasterOverlay(id) {
+        this._earthRasterOverlays = this._earthRasterOverlays.filter((entry) => entry.id !== id);
+    }
+    removeAllEarthRasterOverlays() {
+        this._earthRasterOverlays = [];
+    }
+    addEarthRasterOverlay(name, sourceType, map) {
+        const overlay = {
+            id: `earth-raster-${++this._earthRasterOverlaySequence}`,
+            name,
+            sourceType,
+            visible: true,
+            opacity: 0.65,
+            map,
+        };
+        map.setOpacity(overlay.opacity);
+        this._earthRasterOverlays.push(overlay);
+        const { map: _map, ...info } = overlay;
+        return { ...info };
+    }
+    setActiveDomain(domain) {
+        if (domain !== this._activeDomain) {
+            this.clearGridLabelsForDomain(this._activeDomain);
+            this.domainCameraStates[this._activeDomain] = this._camera.getViewState();
+            const targetCameraState = this.domainCameraStates[domain];
+            if (targetCameraState) {
+                this._camera.restoreViewState(targetCameraState);
+            }
+            this.inertiaX = 0;
+            this.inertiaY = 0;
+            this.zoomInertia = 0;
+            this._cameraStatusChanged = true;
+        }
+        this._activeDomain = domain;
+        if (domain === "astronomy") {
+            this._activeBaseLayer = this._activeHiPS ? "hips" : null;
+        }
+        else if (domain === "earth") {
+            this._activeBaseLayer = this._activeXYZ2 ? "xyz" : null;
+        }
+        else {
+            this._activeBaseLayer = this._activeMeshHiPS ? "meships" : null;
+        }
+        // A hover from the previous vertical must not leak into the new one.
+        this.lastHoveredSource = null;
+        this.lastHoveredCatalogue = null;
+    }
+    clearGridLabelsForDomain(domain) {
+        if (domain === "astronomy") {
+            this._healpixGrid?.clearLabels();
+            this._equatorialGrid?.clearLabels();
+            return;
+        }
+        if (domain === "earth") {
+            this._activeXYZ2?.clearLonLatGridLabels?.();
+        }
+    }
+    get activeDomain() {
+        return this._activeDomain;
+    }
+    getActivePointSets() {
+        if (this._activeDomain === "astronomy")
+            return this.astronomyCatalogues;
+        if (this._activeDomain === "earth")
+            return this.earthPointSets;
+        return [];
+    }
+    getActiveFootprintSets() {
+        if (this._activeDomain === "astronomy")
+            return this.astronomyFootprintSets;
+        if (this._activeDomain === "earth")
+            return this.earthFootprintSets;
+        return [];
+    }
+    // Astronomy catalogue ownership
     async showCatalogue(cat) {
-        // console.log(cat)
-        if (cat)
-            this.activeCatalogues.push(cat);
+        if (cat && !this.astronomyCatalogues.includes(cat)) {
+            this.astronomyCatalogues.push(cat);
+        }
         return cat;
     }
     deleteCatalogue(catalogue) {
-        this.activeCatalogues = this.activeCatalogues.filter((c) => c !== catalogue);
+        this.astronomyCatalogues = this.astronomyCatalogues.filter((c) => c !== catalogue);
     }
-    // End Catalogue section
-    // Footprint section
+    // Earth point-set ownership. TerraPointSetGL still extends CatalogueGL in
+    // 3.12, but it no longer shares the Astronomy lifecycle collection.
+    async showTerraPointSet(pointSet) {
+        if (pointSet && !this.earthPointSets.includes(pointSet)) {
+            this.earthPointSets.push(pointSet);
+        }
+        return pointSet;
+    }
+    deleteTerraPointSet(pointSet) {
+        this.earthPointSets = this.earthPointSets.filter((set) => set !== pointSet);
+    }
+    // Astronomy footprint ownership
     async showFootprintSet(fset) {
-        // console.log(fset)
-        if (fset)
-            this.activeFootprintSets.push(fset);
+        if (fset && !this.astronomyFootprintSets.includes(fset)) {
+            this.astronomyFootprintSets.push(fset);
+        }
         return fset;
     }
     deleteFootprintSet(footprintSet) {
-        this.activeFootprintSets = this.activeFootprintSets.filter((fst) => fst !== footprintSet);
+        this.astronomyFootprintSets = this.astronomyFootprintSets.filter((fst) => fst !== footprintSet);
+    }
+    // Earth footprint ownership. TerraFootprintSetGL still reuses the common
+    // FootprintSetGL rendering implementation, but has an independent lifecycle.
+    async showTerraFootprintSet(footprintSet) {
+        if (footprintSet && !this.earthFootprintSets.includes(footprintSet)) {
+            this.earthFootprintSets.push(footprintSet);
+        }
+        return footprintSet;
+    }
+    deleteTerraFootprintSet(footprintSet) {
+        this.earthFootprintSets = this.earthFootprintSets.filter((fst) => fst !== footprintSet);
     }
     async showPolylineSet(polylineSet) {
         if (polylineSet)
@@ -703,8 +862,8 @@ class AstroSphere {
         satelliteObject.dispose();
     }
     getHoveredFootprints() {
-        let footprintsHovered = [];
-        this.activeFootprintSets.forEach((fset) => {
+        const footprintsHovered = [];
+        this.getActiveFootprintSets().forEach((fset) => {
             footprintsHovered.push(fset.hoveredFootprints);
         });
         return footprintsHovered;
@@ -756,25 +915,128 @@ class AstroSphere {
             throw new Error(`healpixGrid is ${this.healpixGrid}`);
         return FoVUtils.getFoVPolygon(this._camera, this.canvas, this._healpixGrid, this._healpixGrid, this._webgl, this._perspectiveMatrixManager.pMatrix);
     }
-    changeFoV(deg) {
-        const distance = this._healpixGrid.getFoV().computeDistanceFromAngle(deg);
-        this._camera.translate(distance);
+    validateFoV(deg) {
+        if (!Number.isFinite(deg) || deg <= 0 || deg >= 180) {
+            throw new RangeError(`FoV must be > 0 and < 180 degrees. Received ${deg}.`);
+        }
+        if (global.insideSphere) {
+            throw new Error("FoV navigation is currently supported only outside the sphere.");
+        }
+    }
+    /**
+     * Resolve the radial camera distance that produces the requested minimum FoV.
+     *
+     * The search temporarily samples radial distances, then restores the original
+     * camera distance before returning. Callers can therefore either apply the
+     * result immediately or animate toward it.
+     */
+    findRadialDistanceForFoV(deg) {
+        this.validateFoV(deg);
+        const originalDistance = this._camera.getRadialDistance();
+        const minDistance = 1.000001;
+        const maxDistance = 4.0;
+        const tolerance = Math.max(1e-5, deg * 0.001);
+        const maxIterations = 40;
+        let low = minDistance;
+        let high = maxDistance;
+        let bestDistance = originalDistance;
+        let bestError = Number.POSITIVE_INFINITY;
+        for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+            const candidateDistance = (low + high) / 2;
+            this._camera.setRadialDistance(candidateDistance);
+            this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+            const candidateFoV = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
+            const measuredFoV = candidateFoV.minFoV;
+            const error = Math.abs(measuredFoV - deg);
+            if (error < bestError) {
+                bestError = error;
+                bestDistance = candidateDistance;
+            }
+            if (error <= tolerance) {
+                break;
+            }
+            if (measuredFoV >= deg || measuredFoV >= 179.999) {
+                high = candidateDistance;
+            }
+            else {
+                low = candidateDistance;
+            }
+        }
+        this._camera.setRadialDistance(originalDistance);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+        this.fov = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
+        this._camera.refreshFoV(this.fov.minFoV);
+        return bestDistance;
+    }
+    finishFoVAnimation() {
+        const resolve = this.fovAnimationResolve;
+        this.fovAnimationResolve = null;
+        resolve?.();
+    }
+    cancelFoVAnimation() {
+        this._camera.cancelRadialAnimation();
+        this.finishFoVAnimation();
+    }
+    /** Set the minimum angular field of view immediately, in degrees. */
+    setFoV(deg) {
+        this.validateFoV(deg);
+        this.cancelFoVAnimation();
+        this._camera.cancelFlyTo();
+        this.zoomInertia = 0;
+        const targetDistance = this.findRadialDistanceForFoV(deg);
+        this._camera.setRadialDistance(targetDistance);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
         this.fov = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
         this._camera.refreshFoV(this.fov.minFoV);
+        this.lastCameraMotionAt = performance.now();
+        this._cameraStatusChanged = true;
+        this.emitCameraChanged("set-fov");
+    }
+    async flyToFoV(deg, durationMs = 1200) {
+        this.validateFoV(deg);
+        if (!Number.isFinite(durationMs) || durationMs < 0) {
+            throw new RangeError(`FoV animation duration must be >= 0 ms. Received ${durationMs}.`);
+        }
+        if (durationMs === 0) {
+            this.setFoV(deg);
+            return;
+        }
+        this.cancelFoVAnimation();
+        this.zoomInertia = 0;
+        const targetDistance = this.findRadialDistanceForFoV(deg);
+        this._camera.flyToRadialDistance(targetDistance, durationMs);
+        this.lastCameraMotionAt = performance.now();
+        this._cameraStatusChanged = true;
+        return new Promise((resolve) => {
+            this.fovAnimationResolve = resolve;
+        });
+    }
+    async zoomIn(steps = 1, durationMs = 500) {
+        this.validateZoomSteps(steps);
+        const targetFoV = this.getFoV().minFoV / Math.pow(2, steps);
+        return this.flyToFoV(targetFoV, durationMs);
+    }
+    async zoomOut(steps = 1, durationMs = 500) {
+        this.validateZoomSteps(steps);
+        const targetFoV = this.getFoV().minFoV * Math.pow(2, steps);
+        return this.flyToFoV(targetFoV, durationMs);
     }
+    validateZoomSteps(steps) {
+        if (!Number.isInteger(steps) || steps < 1) {
+            throw new RangeError(`Zoom steps must be a positive integer. Received ${steps}.`);
+        }
+    }
+    /** @deprecated Use setFoV(). */
+    changeFoV(deg) {
+        this.setFoV(deg);
+    }
+    /** @deprecated Use setFoV(). */
     changeFoV2(deg) {
-        const newCameraPos = this._healpixGrid
-            .getFoV()
-            .computeCameraPositionForFoV(deg);
-        this._camera.setCameraPosition(newCameraPos);
+        this.setFoV(deg);
     }
+    /** @deprecated Use setFoV(). */
     changeFoV3(deg) {
-        const newPos = this._healpixGrid
-            .getFoV()
-            .computeCameraPositionForAngularDiameter(deg);
-        this._camera.setCameraPosition(newPos);
-        // Recompute projection after moving the camera
-        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, false);
+        this.setFoV(deg);
     }
     getInsideSphere() {
         return global.insideSphere;
@@ -784,6 +1046,7 @@ class AstroSphere {
         this.inertiaX = 0;
         this.inertiaY = 0;
         this.zoomInertia = 0;
+        this.cancelFoVAnimation();
         global.insideSphere = !global.insideSphere;
         // console.log(global.insideSphere)
         this._camera.toggleInsideSphere();
@@ -936,8 +1199,6 @@ class AstroSphere {
             return;
         if (!this._webgl)
             return;
-        if (!this._activeHiPS && !this._activeXYZ2 && !this._activeMeshHiPS)
-            return;
         if (!this._healpixGrid || Object.keys(this._healpixGrid).length === 0)
             return;
         if (this._healpixGrid.fovObj === undefined)
@@ -961,6 +1222,14 @@ class AstroSphere {
             this.updateCentralPoint();
             this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
         }
+        const fovFlying = this._camera.updateRadialAnimation(now);
+        const fovAnimationFinished = fovFlying && !this._camera.isRadialAnimationActive();
+        if (fovFlying) {
+            this.zoomInertia = 0;
+            this.lastCameraMotionAt = now;
+            this._cameraStatusChanged = true;
+            this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+        }
         // Zoom inertia
         if (this.zoomInertia !== 0) {
             if (Math.abs(this.zoomInertia) > 0.0001) {
@@ -1009,6 +1278,9 @@ class AstroSphere {
             this._camera.refreshFoV(this.fov.minFoV);
             this.prevFov = this.fov.minFoV;
         }
+        if (fovAnimationFinished) {
+            this.finishFoVAnimation();
+        }
         // Se la camera è ruotata (anche solo per inerzia), aggiorna punto centrale + emetti cameraChanged
         if (cameraRotated) {
             // Ricalcola il punto centrale
@@ -1049,8 +1321,14 @@ class AstroSphere {
         this._webgl.enable(this._webgl.CULL_FACE);
         this._webgl.cullFace(global.insideSphere ? this._webgl.FRONT : this._webgl.BACK);
         this._webgl.blendFunc(this._webgl.SRC_ALPHA, this._webgl.ONE_MINUS_SRC_ALPHA);
-        if (this._activeBaseLayer === "hips" && this._activeHiPSLayers.length > 0) {
-            const maxHiPSOrder = Math.max(...this._activeHiPSLayers.map((hips) => hips.maxOrder));
+        if (this._activeBaseLayer === "hips" && this._activeHiPS) {
+            // During directional flyTo navigation, keep visibility current but render
+            // only HiPS tiles that are already available. Final-view refinement
+            // resumes automatically on the first frame after the flight.
+            this._healpixGrid.visibleTilesManager.tileBuffer.setTileAcquisitionEnabled(!cameraFlying);
+            const maxHiPSOrder = this._activeHiPSLayers.length > 0
+                ? Math.max(...this._activeHiPSLayers.map((hips) => hips.maxOrder))
+                : this._activeHiPS.maxOrder;
             const visibleOrder = Math.min(this._healpixGrid.visibleorder, maxHiPSOrder);
             this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         }
@@ -1065,6 +1343,7 @@ class AstroSphere {
             Math.abs(this.zoomInertia) > 0.0001 ||
             Math.abs(this.inertiaX) > 0.02 ||
             Math.abs(this.inertiaY) > 0.02 ||
+            this._camera.isRadialAnimationActive() ||
             nowForGrid - this.lastCameraMotionAt < 220;
         const skyEntityDrawInput = {
             fovDeg: stableFovDeg,
@@ -1085,12 +1364,19 @@ class AstroSphere {
         }
         if (this._activeBaseLayer === "xyz") {
             this._activeXYZ2?.draw(skyEntityDrawInput);
+            for (const overlay of this._earthRasterOverlays) {
+                if (overlay.visible) {
+                    overlay.map.draw(skyEntityDrawInput, true);
+                }
+            }
         }
         if (this._activeBaseLayer === "meships") {
             this._activeMeshHiPS?.draw(skyEntityDrawInput);
         }
-        this._healpixGrid.draw(skyEntityDrawInput);
-        this._equatorialGrid.draw(skyEntityDrawInput);
+        if (this._activeDomain === "astronomy") {
+            this._healpixGrid.draw(skyEntityDrawInput);
+            this._equatorialGrid.draw(skyEntityDrawInput);
+        }
         this._webgl.enable(this._webgl.DEPTH_TEST);
         this._webgl.disable(this._webgl.CULL_FACE);
         if (this.startup) {
@@ -1109,52 +1395,53 @@ class AstroSphere {
                 decDMS,
             });
         }
-        this.activeCatalogues.forEach((cat) => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix() ??
-                this._activeMeshHiPS?.getModelMatrix();
+        this.getActivePointSets().forEach((cat) => {
+            const activeModelMatrix = this.getActiveDomainModelMatrix();
             if (activeModelMatrix) {
                 cat.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }
         });
         this.emitHoveredSourceIfChanged();
-        this.activeFootprintSets.forEach((fst) => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix() ??
-                this._activeMeshHiPS?.getModelMatrix();
+        this.getActiveFootprintSets().forEach((fst) => {
+            const activeModelMatrix = this.getActiveDomainModelMatrix();
             if (activeModelMatrix) {
                 fst.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }
         });
-        this.activePolylineSets.forEach((polylineSet) => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix() ??
-                this._activeMeshHiPS?.getModelMatrix();
-            if (activeModelMatrix) {
-                polylineSet.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
-            }
-        });
-        this.activeSensorCones.forEach((sensorCone) => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix() ??
-                this._activeMeshHiPS?.getModelMatrix();
-            if (activeModelMatrix) {
-                sensorCone.draw(this._perspectiveMatrixManager.pMatrix, this._camera.getCameraMatrix(), activeModelMatrix);
-            }
-        });
-        this.activeSatelliteObjects.forEach((satelliteObject) => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix() ??
-                this._activeMeshHiPS?.getModelMatrix();
-            if (activeModelMatrix) {
-                satelliteObject.draw(this._perspectiveMatrixManager.pMatrix, this._camera.getCameraMatrix(), activeModelMatrix);
-            }
-        });
+        if (this._activeDomain === "earth") {
+            this.activePolylineSets.forEach((polylineSet) => {
+                const activeModelMatrix = this.getActiveDomainModelMatrix();
+                if (activeModelMatrix) {
+                    polylineSet.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
+                }
+            });
+            this.activeSensorCones.forEach((sensorCone) => {
+                const activeModelMatrix = this.getActiveDomainModelMatrix();
+                if (activeModelMatrix) {
+                    sensorCone.draw(this._perspectiveMatrixManager.pMatrix, this._camera.getCameraMatrix(), activeModelMatrix);
+                }
+            });
+            this.activeSatelliteObjects.forEach((satelliteObject) => {
+                const activeModelMatrix = this.getActiveDomainModelMatrix();
+                if (activeModelMatrix) {
+                    satelliteObject.draw(this._perspectiveMatrixManager.pMatrix, this._camera.getCameraMatrix(), activeModelMatrix);
+                }
+            });
+        }
+    }
+    getActiveDomainModelMatrix() {
+        if (this._activeDomain === "astronomy") {
+            return (this._activeHiPS?.getModelMatrix() ?? this._healpixGrid.getModelMatrix());
+        }
+        if (this._activeDomain === "earth") {
+            return (this._activeXYZ2?.getModelMatrix() ?? this._healpixGrid.getModelMatrix());
+        }
+        return (this._activeMeshHiPS?.getModelMatrix() ?? this._healpixGrid.getModelMatrix());
     }
     emitHoveredSourceIfChanged() {
         let nextHoveredSource = null;
         let nextHoveredCatalogue = null;
-        for (const cat of this.activeCatalogues) {
+        for (const cat of this.getActivePointSets()) {
             const hovered = cat.getPrimaryHoveredSource();
             if (!hovered)
                 continue;