astro-viewer 2.0.0 → 3.1.0

package/lib-esm/AstroSphere.d.ts

@@ -2,13 +2,16 @@ import Camera from './Camera.js';
 import { AstroCoords, HMS, SphericalCoords, DMS } from './utils/Utils.js';
 import { HiPS } from './model/hips/HiPS.js';
 import { HiPSDescriptor } from './model/hips/HiPSDescriptor.js';
-import { FoV } from './model/FoV.js';
+import { SphereFoV } from './model/SphereFoV.js';
 import { Point } from './model/Point.js';
 import { CatalogueGL } from './model/catalogues/CatalogueGL.js';
 import { FootprintSetGL, HoveredFootprintDetail } from './model/footprints/FootprintSetGL.js';
 import { EquatorialGrid } from './model/grid/EquatorialGrid.js';
 import { HealpixGrid } from './model/grid/HealpixGrid.js';
 import { ColorMap } from './model/ColorMaps.js';
+import type { WMTSLayerConfig, XYZDebugStats, XYZLayerConfig } from './model/earth/XYZConfig.js';
+import { XYZMapDescriptor } from './model/earth/XYZMapDescriptor.js';
+import { XYZMap } from './model/earth/XYZMap.js';
 export type PointCoordinates = {
     astroDeg: AstroCoords;
     raHMS: HMS;
@@ -54,6 +57,8 @@ declare class AstroSphere {
     private pointerDownY;
     private pointerDownAt;
     private _activeHiPS;
+    private _activeXYZ2;
+    private _activeBaseLayer;
     private startup;
     private fov;
     private activeCatalogues;
@@ -64,6 +69,9 @@ declare class AstroSphere {
     private lastHoveredSource;
     private lastHoveredCatalogue;
     private zoomSensitivity;
+    private lockedEastWestRaDeg;
+    private lockedNorthSouthDecDeg;
+    private keepCameraNorthUp;
     constructor(canvas: HTMLCanvasElement, webgl: WebGL2RenderingContext);
     private initCamera;
     setCamera(camera: Camera): void;
@@ -80,17 +88,30 @@ declare class AstroSphere {
     private computeZoomStep;
     setZoomSensitivity(value: number): void;
     getZoomSensitivity(): number;
+    private filterRotationDeltaByAstroLocks;
+    private projectModelDirectionToScreen;
+    private projectModelPointToScreen;
+    private enforceAstronomicalRotationLocks;
+    private enforceCameraNorthUp;
     private emitCameraChanged;
     private addEventListeners;
     getPhiThetaDeg(canvas: HTMLCanvasElement): SphericalCoords;
+    private collectViewportSphericalSamples;
     activateHiPS(hipsDescriptor: HiPSDescriptor): void;
+    activateXYZ(config: XYZLayerConfig): void;
+    activateXYZ2(config: XYZMapDescriptor): void;
+    activateWMTS(config: WMTSLayerConfig): void;
     showCatalogue(cat: CatalogueGL): Promise<CatalogueGL>;
     deleteCatalogue(catalogue: CatalogueGL): void;
     showFootprintSet(fset: FootprintSetGL): Promise<FootprintSetGL>;
     deleteFootprintSet(footprintSet: FootprintSetGL): void;
     getHoveredFootprints(): HoveredFootprintDetail[];
     goTo(raDeg: number, decDeg: number): void;
-    getFoV(): FoV;
+    getActiveCoordinateMode(): 'equatorial' | 'galactic' | 'lonlat';
+    resetAxesOrientation(): void;
+    setKeepCameraNorthUp(enabled: boolean): void;
+    isKeepCameraNorthUp(): boolean;
+    getFoV(): SphereFoV;
     getFoVPolygon(): Point[];
     changeFoV(deg: number): void;
     changeFoV2(deg: number): void;
@@ -107,6 +128,14 @@ declare class AstroSphere {
     private prevCentralRaDeg;
     private prevCentralDecDeg;
     get activeHiPS(): HiPS | null;
+    get activeXYZ(): XYZMap | null;
+    isLonLatGridVisible(): boolean;
+    toggleLonLatGrid(): boolean;
+    setEastWestRotationLocked(locked: boolean): void;
+    isEastWestRotationLocked(): boolean;
+    setNorthSouthRotationLocked(locked: boolean): void;
+    isNorthSouthRotationLocked(): boolean;
+    getXYZDebugStats(): XYZDebugStats;
     draw(canvas: HTMLCanvasElement): void;
     private emitHoveredSourceIfChanged;
 }

package/lib-esm/AstroSphere.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 import { bootSetup } from './Config.js';
 import Camera from './Camera.js';
 import RayPickingUtils from './utils/RayPickingUtils.js';
@@ -12,6 +24,11 @@ import { EquatorialGrid } from './model/grid/EquatorialGrid.js';
 import { HealpixGrid } from './model/grid/HealpixGrid.js';
 import { CoordsType } from './utils/CoordsType.js';
 import ColorMaps from './model/ColorMaps.js';
+import { xyzTileRequestScheduler } from './model/earth/XYZTileRequestScheduler.js';
+import { WMTSAdapter } from './model/earth/WMTSAdapter.js';
+import { XYZMapDescriptor } from './model/earth/XYZMapDescriptor.js';
+import { XYZMap } from './model/earth/XYZMap.js';
+import { mat4, vec3, vec4 } from 'gl-matrix';
 /**
  * AstroSphere — main WebGL scene controller (TS port)
  */
@@ -36,6 +53,8 @@ class AstroSphere {
     pointerDownY = null;
     pointerDownAt = 0;
     _activeHiPS = null;
+    _activeXYZ2 = null;
+    _activeBaseLayer = null;
     startup = true;
     fov;
     activeCatalogues = [];
@@ -46,6 +65,9 @@ class AstroSphere {
     lastHoveredSource = null;
     lastHoveredCatalogue = null;
     zoomSensitivity = 1.0;
+    lockedEastWestRaDeg = null;
+    lockedNorthSouthDecDeg = null;
+    keepCameraNorthUp = false;
     constructor(canvas, webgl) {
         console.log('[AstroSphere] new instance for canvas', canvas.id);
         // Keep global GL context (as in original JS)
@@ -145,6 +167,118 @@ class AstroSphere {
     getZoomSensitivity() {
         return this.zoomSensitivity;
     }
+    filterRotationDeltaByAstroLocks(deltaX, deltaY) {
+        const lockEastWest = this._camera.isRotationLockedY();
+        const lockNorthSouth = this._camera.isRotationLockedX();
+        if (!lockEastWest && !lockNorthSouth) {
+            return { deltaX, deltaY };
+        }
+        const center = RayPickingUtils.getIntersectionPointWithSingleModel(this.canvas.clientWidth / 2, this.canvas.clientHeight / 2, this._healpixGrid, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
+        if (!center || center.length < 3) {
+            return { deltaX, deltaY };
+        }
+        const centerVec = vec3.normalize(vec3.create(), vec3.fromValues(center[0], center[1], center[2]));
+        const northAxis = vec3.fromValues(0, 0, 1);
+        const eastVec = vec3.cross(vec3.create(), northAxis, centerVec);
+        if (vec3.length(eastVec) < 1e-6) {
+            vec3.set(eastVec, 1, 0, 0);
+        }
+        else {
+            vec3.normalize(eastVec, eastVec);
+        }
+        const northProjection = vec3.scale(vec3.create(), centerVec, vec3.dot(northAxis, centerVec));
+        const northVec = vec3.subtract(vec3.create(), northAxis, northProjection);
+        if (vec3.length(northVec) < 1e-6) {
+            vec3.cross(northVec, centerVec, eastVec);
+        }
+        vec3.normalize(northVec, northVec);
+        const eastScreen = this.projectModelDirectionToScreen(centerVec, eastVec);
+        const northScreen = this.projectModelDirectionToScreen(centerVec, northVec);
+        if (!eastScreen || !northScreen) {
+            return { deltaX, deltaY };
+        }
+        let nextDeltaX = deltaX;
+        let nextDeltaY = deltaY;
+        if (lockEastWest) {
+            const amount = nextDeltaX * eastScreen.x + nextDeltaY * eastScreen.y;
+            nextDeltaX -= amount * eastScreen.x;
+            nextDeltaY -= amount * eastScreen.y;
+        }
+        if (lockNorthSouth) {
+            const amount = nextDeltaX * northScreen.x + nextDeltaY * northScreen.y;
+            nextDeltaX -= amount * northScreen.x;
+            nextDeltaY -= amount * northScreen.y;
+        }
+        return {
+            deltaX: nextDeltaX,
+            deltaY: nextDeltaY,
+        };
+    }
+    projectModelDirectionToScreen(centerModel, directionModel) {
+        const offsetModel = vec3.scaleAndAdd(vec3.create(), centerModel, directionModel, 0.01);
+        const centerScreen = this.projectModelPointToScreen(centerModel);
+        const offsetScreen = this.projectModelPointToScreen(offsetModel);
+        if (!centerScreen || !offsetScreen) {
+            return null;
+        }
+        const x = offsetScreen.x - centerScreen.x;
+        const y = offsetScreen.y - centerScreen.y;
+        const len = Math.hypot(x, y);
+        if (len < 1e-6) {
+            return null;
+        }
+        return { x: x / len, y: y / len };
+    }
+    projectModelPointToScreen(pointModel) {
+        const vMatrix = this._camera.getCameraMatrix();
+        const mMatrix = this._healpixGrid.getModelMatrix();
+        const mvMatrix = mat4.create();
+        const mvpMatrix = mat4.create();
+        mat4.multiply(mvMatrix, vMatrix, mMatrix);
+        mat4.multiply(mvpMatrix, this._perspectiveMatrixManager.pMatrix, mvMatrix);
+        const clip = vec4.fromValues(pointModel[0], pointModel[1], pointModel[2], 1);
+        vec4.transformMat4(clip, clip, mvpMatrix);
+        if (Math.abs(clip[3]) < 1e-6) {
+            return null;
+        }
+        return {
+            x: clip[0] / clip[3],
+            y: -(clip[1] / clip[3]),
+        };
+    }
+    enforceAstronomicalRotationLocks() {
+        if (this.lockedEastWestRaDeg == null && this.lockedNorthSouthDecDeg == null) {
+            return false;
+        }
+        const center = this.updateCentralPoint();
+        if (!center) {
+            return false;
+        }
+        const nextRa = this.lockedEastWestRaDeg ?? center.astroDeg.ra;
+        const nextDec = this.lockedNorthSouthDecDeg ?? center.astroDeg.dec;
+        const needsCorrection = Math.abs(nextRa - center.astroDeg.ra) > 1e-6 ||
+            Math.abs(nextDec - center.astroDeg.dec) > 1e-6;
+        if (!needsCorrection) {
+            return false;
+        }
+        this._camera.goTo(nextRa, nextDec);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+        this.updateCentralPoint();
+        return true;
+    }
+    enforceCameraNorthUp() {
+        if (!this.keepCameraNorthUp) {
+            return false;
+        }
+        const center = this.updateCentralPoint();
+        if (!center) {
+            return false;
+        }
+        this._camera.goTo(center.astroDeg.ra, center.astroDeg.dec);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+        this.updateCentralPoint();
+        return true;
+    }
     emitCameraChanged(reason) {
         // avoid dispatch before scene is ready
         if (!this._activeHiPS)
@@ -261,8 +395,9 @@ class AstroSphere {
                 // Rotation deltas – either use client-space or local-space, but be consistent
                 const deltaX = ((newX - (this.lastMouseX ?? newX)) * Math.PI) / canvas.width;
                 const deltaY = ((newY - (this.lastMouseY ?? newY)) * Math.PI) / canvas.height;
-                this.inertiaX += 0.1 * deltaX;
-                this.inertiaY += 0.1 * deltaY;
+                const filteredDelta = this.filterRotationDeltaByAstroLocks(deltaX, deltaY);
+                this.inertiaX += 0.1 * filteredDelta.deltaX;
+                this.inertiaY += 0.1 * filteredDelta.deltaY;
                 this.updateCentralPoint();
             }
             else {
@@ -392,8 +527,40 @@ class AstroSphere {
         const pickerPoint = RayPickingUtils.getIntersectionPointWithSingleModel(maxX / 2, maxY / 2, this._healpixGrid, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         return cartesianToSpherical(pickerPoint);
     }
+    collectViewportSphericalSamples(sampleCount = 5) {
+        const rect = this.canvas.getBoundingClientRect();
+        const width = rect.width;
+        const height = rect.height;
+        const samples = [];
+        for (let ix = 0; ix < sampleCount; ix++) {
+            const x = sampleCount === 1 ? width / 2 : (ix / (sampleCount - 1)) * width;
+            for (let iy = 0; iy < sampleCount; iy++) {
+                const y = sampleCount === 1 ? height / 2 : (iy / (sampleCount - 1)) * height;
+                const hit = RayPickingUtils.getIntersectionPointWithSingleModel(x, y, this._healpixGrid, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
+                if (hit && hit.length > 0) {
+                    samples.push(cartesianToSpherical(hit));
+                }
+            }
+        }
+        return samples;
+    }
     activateHiPS(hipsDescriptor) {
         this._activeHiPS = new HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
+        this._activeBaseLayer = 'hips';
+    }
+    activateXYZ(config) {
+        this.activateXYZ2(new XYZMapDescriptor(config.name ?? 'XYZ Earth2 Layer', config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver));
+        this._activeBaseLayer = 'xyz';
+    }
+    activateXYZ2(config) {
+        this._activeXYZ2 = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, config, this._webgl);
+        this._activeBaseLayer = 'xyz';
+    }
+    activateWMTS(config) {
+        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._activeBaseLayer = 'xyz';
     }
     // Catalogue section
     async showCatalogue(cat) {
@@ -427,7 +594,39 @@ class AstroSphere {
     goTo(raDeg, decDeg) {
         this._camera.goTo(raDeg, decDeg);
     }
+    getActiveCoordinateMode() {
+        if (this._activeBaseLayer === 'xyz') {
+            return 'lonlat';
+        }
+        if (this._activeBaseLayer === 'hips' && this._activeHiPS?.isGalacticHips) {
+            return 'galactic';
+        }
+        return 'equatorial';
+    }
+    resetAxesOrientation() {
+        const center = this.updateCentralPoint();
+        if (!center)
+            return;
+        this.inertiaX = 0;
+        this.inertiaY = 0;
+        this._camera.goTo(center.astroDeg.ra, center.astroDeg.dec);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+        this.updateCentralPoint();
+        this._cameraStatusChanged = true;
+    }
+    setKeepCameraNorthUp(enabled) {
+        this.keepCameraNorthUp = enabled;
+        if (enabled) {
+            this.resetAxesOrientation();
+        }
+    }
+    isKeepCameraNorthUp() {
+        return this.keepCameraNorthUp;
+    }
     getFoV() {
+        if (this._activeBaseLayer === 'xyz' && this._activeXYZ2) {
+            return this._activeXYZ2.getFoV();
+        }
         return this.fov;
     }
     getFoVPolygon() {
@@ -513,10 +712,11 @@ class AstroSphere {
         // return null
     }
     changeColorMap(cm) {
-        if (!this._activeHiPS)
+        if (!this._activeHiPS && !this._activeXYZ2)
             return;
         this._selectedColorMap = cm;
         this._activeHiPS?.changeColorMap(cm);
+        this._activeXYZ2?.changeColorMap(cm);
     }
     prevFov = 0;
     prevCentralRaDeg = null;
@@ -524,12 +724,46 @@ class AstroSphere {
     get activeHiPS() {
         return this._activeHiPS;
     }
+    get activeXYZ() {
+        return this._activeXYZ2;
+    }
+    isLonLatGridVisible() {
+        return this._activeXYZ2?.isLonLatGridVisible() ?? false;
+    }
+    toggleLonLatGrid() {
+        return this._activeXYZ2?.toggleLonLatGrid() ?? false;
+    }
+    setEastWestRotationLocked(locked) {
+        this._camera.setRotationLock({ y: locked });
+        if (locked)
+            this.inertiaX = 0;
+        this.lockedEastWestRaDeg = locked ? this.updateCentralPoint()?.astroDeg.ra ?? null : null;
+    }
+    isEastWestRotationLocked() {
+        return this._camera.isRotationLockedY();
+    }
+    setNorthSouthRotationLocked(locked) {
+        this._camera.setRotationLock({ x: locked });
+        if (locked)
+            this.inertiaY = 0;
+        this.lockedNorthSouthDecDeg = locked ? this.updateCentralPoint()?.astroDeg.dec ?? null : null;
+    }
+    isNorthSouthRotationLocked() {
+        return this._camera.isRotationLockedX();
+    }
+    getXYZDebugStats() {
+        return {
+            activeBaseLayer: this._activeBaseLayer,
+            layer: this._activeXYZ2?.getDebugStats() ?? null,
+            requests: xyzTileRequestScheduler.getDebugStats(),
+        };
+    }
     draw(canvas) {
         if (this._refreshingStatus)
             return;
         if (!this._webgl)
             return;
-        if (!this._activeHiPS)
+        if (!this._activeHiPS && !this._activeXYZ2)
             return;
         if (!this._healpixGrid || Object.keys(this._healpixGrid).length === 0)
             return;
@@ -566,12 +800,17 @@ class AstroSphere {
         // Rotation inertia
         if (this.mouseDown || Math.abs(this.inertiaX) > 0.02 || Math.abs(this.inertiaY) > 0.02) {
             cameraRotated = true;
-            THETA = this.inertiaY;
-            PHI = this.inertiaX;
-            this.inertiaX *= 0.95;
-            this.inertiaY *= 0.95;
+            const filteredInertia = this.filterRotationDeltaByAstroLocks(this.inertiaX, this.inertiaY);
+            PHI = filteredInertia.deltaX;
+            THETA = filteredInertia.deltaY;
+            this.inertiaX = filteredInertia.deltaX * 0.95;
+            this.inertiaY = filteredInertia.deltaY * 0.95;
             this._camera.rotate(PHI, THETA);
             this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, bootSetup.camera_fov_deg, bootSetup.camera_near_plane, global.insideSphere);
+            const lockCorrected = this.enforceAstronomicalRotationLocks();
+            if (!lockCorrected) {
+                this.enforceCameraNorthUp();
+            }
         }
         else {
             this.inertiaY = 0;
@@ -613,15 +852,25 @@ 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);
-        const visibleOrder = Math.min(this._healpixGrid.visibleorder, this._activeHiPS.maxOrder);
-        this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
+        if (this._activeBaseLayer === 'hips' && this._activeHiPS) {
+            const visibleOrder = Math.min(this._healpixGrid.visibleorder, this._activeHiPS.maxOrder);
+            this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
+        }
         // DRAW HiPS
         const skyEntityDrawInput = {
             fovDeg: this._healpixGrid.getMinFoV(),
             camera: this._camera,
-            pMatrix: this._perspectiveMatrixManager.pMatrix
+            pMatrix: this._perspectiveMatrixManager.pMatrix,
+            centerSphericalDeg: this.updateCentralPoint().sphericalDeg,
+            fovPolygon: this._activeBaseLayer === 'xyz' ? this.getFoVPolygon() : undefined,
+            viewportSphericalSamples: this._activeBaseLayer === 'xyz' ? this.collectViewportSphericalSamples(7) : undefined,
         };
-        this._activeHiPS.draw(skyEntityDrawInput);
+        if (this._activeBaseLayer === 'hips') {
+            this._activeHiPS?.draw(skyEntityDrawInput);
+        }
+        if (this._activeBaseLayer === 'xyz') {
+            this._activeXYZ2?.draw(skyEntityDrawInput);
+        }
         this._healpixGrid.draw(skyEntityDrawInput);
         this._equatorialGrid.draw(skyEntityDrawInput);
         this._webgl.enable(this._webgl.DEPTH_TEST);
@@ -642,14 +891,16 @@ class AstroSphere {
             });
         }
         this.activeCatalogues.forEach(cat => {
-            if (this._activeHiPS) {
-                cat.draw(this._activeHiPS.getModelMatrix(), this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
+            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ?? this._activeXYZ2?.getModelMatrix();
+            if (activeModelMatrix) {
+                cat.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }
         });
         this.emitHoveredSourceIfChanged();
         this.activeFootprintSets.forEach(fst => {
-            if (this._activeHiPS) {
-                fst.draw(this._activeHiPS.getModelMatrix(), this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
+            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ?? this._activeXYZ2?.getModelMatrix();
+            if (activeModelMatrix) {
+                fst.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }
         });
     }

package/lib-esm/AstroViewer.d.ts

@@ -1,5 +1,5 @@
 import { HiPSDescriptor } from './model/hips/HiPSDescriptor.js';
-import { FoV } from './model/FoV.js';
+import { SphereFoV } from './model/SphereFoV.js';
 import { Point } from './model/Point.js';
 import { CatalogueGL } from './model/catalogues/CatalogueGL.js';
 import type { CameraChangedDetail, PointCoordinates } from './AstroSphere.js';
@@ -9,6 +9,10 @@ import Camera from './Camera.js';
 import { ReadonlyMat4 } from 'gl-matrix';
 import { ColorMap, ColorMapName } from './model/ColorMaps.js';
 import { HiPS } from './model/hips/HiPS.js';
+import type { WMTSLayerConfig, XYZDebugStats, XYZLayerConfig } from './model/earth/XYZConfig.js';
+import { XYZMap } from './model/earth/XYZMap.js';
+import { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
+import { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
 export declare class AstroViewer {
     private astroSphere;
     private canvas;
@@ -32,20 +36,38 @@ export declare class AstroViewer {
     showFootprintSet(footprintSet: FootprintSetGL): void;
     hideFootprintSet(footprintSet: FootprintSetGL, isVisible: boolean): void;
     deleteFootprintSet(footprintSet: FootprintSetGL): void;
+    createTerraPointSet(pointSetName: string, pointSetDescription: string, providerUrl: string, metadataManager: MetadataManager): TerraPointSetGL;
+    showTerraPointSet(pointSet: TerraPointSetGL): void;
+    hideTerraPointSet(pointSet: TerraPointSetGL, isVisible: boolean): void;
+    deleteTerraPointSet(pointSet: TerraPointSetGL): void;
+    createTerraFootprintSet(footprintSetName: string, footprintSetDescription: string, providerUrl: string, metadataManager: MetadataManager): TerraFootprintSetGL;
+    showTerraFootprintSet(footprintSet: TerraFootprintSetGL): void;
+    hideTerraFootprintSet(footprintSet: TerraFootprintSetGL, isVisible: boolean): void;
+    deleteTerraFootprintSet(footprintSet: TerraFootprintSetGL): void;
     changeFootprintSetColor(footprintSet: FootprintSetGL, hexColor: string): void;
     getHoveredFootprints(): HoveredFootprintDetail[];
     getDefaultHiPSURL(): string;
     activateHiPS(hipsDescriptor: HiPSDescriptor): void;
+    activateXYZ(config: XYZLayerConfig): void;
+    activateXYZ2(config: XYZLayerConfig & {
+        name?: string;
+    }): void;
+    activateWMTS(config: WMTSLayerConfig): void;
+    setXYZMaxConcurrentRequests(value: number): void;
+    getXYZMaxConcurrentRequests(): number;
+    getXYZDebugStats(): XYZDebugStats;
     loadHiPS(baseUrl: string): Promise<string>;
     changeColorMap(colorMapName: ColorMapName): void;
     changeCustomColorMap(colorMap: ColorMap): void;
     getActiveHiPS(): HiPS | null;
+    getActiveXYZ(): XYZMap | null;
     setCamera(camera: Camera): void;
     setCameraPosition(pos: [number, number, number]): void;
     setCameraMatrix(viewMatrix: Float32Array): void;
     restoreAstroViewerState(detail: CameraChangedDetail, applyColorMap: boolean): void;
     getCurrentAstroViewerStatus(): CameraChangedDetail | null;
     goTo(raDeg: number, decDeg: number): void;
+    getActiveCoordinateMode(): 'equatorial' | 'galactic' | 'lonlat';
     getCenterCoordinates(): PointCoordinates | undefined;
     getCoordinatesFromMouse(): PointCoordinates | undefined;
     setModelMatrix(modelMatrix: ReadonlyMat4): void;
@@ -53,7 +75,16 @@ export declare class AstroViewer {
     isHealpixGridVisible(): boolean;
     toggleEquatorialGrid(): void;
     isEquatorialGridVisible(): boolean;
-    getFoV(): FoV;
+    toggleLonLatGrid(): boolean;
+    isLonLatGridVisible(): boolean;
+    setEastWestRotationLocked(locked: boolean): void;
+    isEastWestRotationLocked(): boolean;
+    setNorthSouthRotationLocked(locked: boolean): void;
+    isNorthSouthRotationLocked(): boolean;
+    resetAxesOrientation(): void;
+    setKeepCameraNorthUp(enabled: boolean): void;
+    isKeepCameraNorthUp(): boolean;
+    getFoV(): SphereFoV;
     getFoVPolygon(): Point[];
     changeFoV(deg: number): void;
     changeFoV2(deg: number): void;

package/lib-esm/AstroViewer.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 // import global from './Global.js'
 import AstroSphere from './AstroSphere.js';
 import { HiPSDescriptor } from './model/hips/HiPSDescriptor.js';
@@ -5,6 +17,10 @@ import { CatalogueGL } from './model/catalogues/CatalogueGL.js';
 import { FootprintSetGL } from './model/footprints/FootprintSetGL.js';
 import { bootSetup } from './Config.js';
 import ColorMaps from './model/ColorMaps.js';
+import { xyzTileRequestScheduler } from './model/earth/XYZTileRequestScheduler.js';
+import { XYZMapDescriptor } from './model/earth/XYZMapDescriptor.js';
+import { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
+import { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
 // & {
 //   viewportWidth: number
 //   viewportHeight: number
@@ -71,6 +87,31 @@ export class AstroViewer {
     deleteFootprintSet(footprintSet) {
         this.astroSphere.deleteFootprintSet(footprintSet);
     }
+    // TERRA OVERLAYS
+    createTerraPointSet(pointSetName, pointSetDescription, providerUrl, metadataManager) {
+        return new TerraPointSetGL(pointSetName, pointSetDescription, providerUrl, metadataManager, this.webgl, this.astroSphere.healpixGrid.visibleTilesManager);
+    }
+    showTerraPointSet(pointSet) {
+        this.astroSphere.showCatalogue(pointSet);
+    }
+    hideTerraPointSet(pointSet, isVisible) {
+        pointSet.setIsVisible(isVisible);
+    }
+    deleteTerraPointSet(pointSet) {
+        this.astroSphere.deleteCatalogue(pointSet);
+    }
+    createTerraFootprintSet(footprintSetName, footprintSetDescription, providerUrl, metadataManager) {
+        return new TerraFootprintSetGL(footprintSetName, footprintSetDescription, providerUrl, metadataManager, this.webgl, this.astroSphere.healpixGrid.visibleTilesManager);
+    }
+    showTerraFootprintSet(footprintSet) {
+        this.astroSphere.showFootprintSet(footprintSet);
+    }
+    hideTerraFootprintSet(footprintSet, isVisible) {
+        footprintSet.setIsVisible(isVisible);
+    }
+    deleteTerraFootprintSet(footprintSet) {
+        this.astroSphere.deleteFootprintSet(footprintSet);
+    }
     changeFootprintSetColor(footprintSet, hexColor) {
         // footprintSet.footprintsetProps.changeColor(hexColor)
         footprintSet.changeColor(hexColor);
@@ -85,6 +126,25 @@ export class AstroViewer {
     activateHiPS(hipsDescriptor) {
         this.astroSphere.activateHiPS(hipsDescriptor);
     }
+    activateXYZ(config) {
+        this.astroSphere.activateXYZ(config);
+    }
+    activateXYZ2(config) {
+        const descriptor = new XYZMapDescriptor(config.name ?? 'XYZ Earth2 Layer', config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver);
+        this.astroSphere.activateXYZ2(descriptor);
+    }
+    activateWMTS(config) {
+        this.astroSphere.activateWMTS(config);
+    }
+    setXYZMaxConcurrentRequests(value) {
+        xyzTileRequestScheduler.setMaxConcurrent(value);
+    }
+    getXYZMaxConcurrentRequests() {
+        return xyzTileRequestScheduler.getMaxConcurrent();
+    }
+    getXYZDebugStats() {
+        return this.astroSphere.getXYZDebugStats();
+    }
     async loadHiPS(baseUrl) {
         const hipsUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
         const resp = await fetch(hipsUrl + 'properties');
@@ -108,6 +168,9 @@ export class AstroViewer {
     getActiveHiPS() {
         return this.astroSphere.activeHiPS;
     }
+    getActiveXYZ() {
+        return this.astroSphere.activeXYZ;
+    }
     // Camera: GOTOs and COORDS
     setCamera(camera) {
         this.astroSphere.setCamera(camera);
@@ -128,6 +191,9 @@ export class AstroViewer {
         // console.log(`AstroViewer.goTo goto(${raDeg}, ${decDeg})`)
         this.astroSphere.goTo(raDeg, decDeg);
     }
+    getActiveCoordinateMode() {
+        return this.astroSphere.getActiveCoordinateMode();
+    }
     getCenterCoordinates() {
         return this.astroSphere.getCentralPointCoordinates();
     }
@@ -154,6 +220,33 @@ export class AstroViewer {
         // return equatorialGridSingleton.isVisible()
         return this.astroSphere.equatorialGrid.isVisible();
     }
+    toggleLonLatGrid() {
+        return this.astroSphere.toggleLonLatGrid();
+    }
+    isLonLatGridVisible() {
+        return this.astroSphere.isLonLatGridVisible();
+    }
+    setEastWestRotationLocked(locked) {
+        this.astroSphere.setEastWestRotationLocked(locked);
+    }
+    isEastWestRotationLocked() {
+        return this.astroSphere.isEastWestRotationLocked();
+    }
+    setNorthSouthRotationLocked(locked) {
+        this.astroSphere.setNorthSouthRotationLocked(locked);
+    }
+    isNorthSouthRotationLocked() {
+        return this.astroSphere.isNorthSouthRotationLocked();
+    }
+    resetAxesOrientation() {
+        this.astroSphere.resetAxesOrientation();
+    }
+    setKeepCameraNorthUp(enabled) {
+        this.astroSphere.setKeepCameraNorthUp(enabled);
+    }
+    isKeepCameraNorthUp() {
+        return this.astroSphere.isKeepCameraNorthUp();
+    }
     // FOV
     getFoV() {
         return this.astroSphere.getFoV();