astro-viewer 3.0.0 → 3.1.0

package/lib-esm/AstroSphere.d.ts

@@ -2,15 +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 { XYZLayer } from './model/earth/XYZLayer.js';
-import type { WMTSLayerConfig, XYZDebugStats, XYZLayerConfig } from './model/earth/types.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;
@@ -56,7 +57,7 @@ declare class AstroSphere {
     private pointerDownY;
     private pointerDownAt;
     private _activeHiPS;
-    private _activeXYZ;
+    private _activeXYZ2;
     private _activeBaseLayer;
     private startup;
     private fov;
@@ -68,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;
@@ -84,12 +88,18 @@ 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;
@@ -97,7 +107,11 @@ declare class AstroSphere {
     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;
@@ -114,7 +128,13 @@ declare class AstroSphere {
     private prevCentralRaDeg;
     private prevCentralDecDeg;
     get activeHiPS(): HiPS | null;
-    get activeXYZ(): XYZLayer | 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,9 +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 { XYZLayer } from './model/earth/XYZLayer.js';
 import { xyzTileRequestScheduler } from './model/earth/XYZTileRequestScheduler.js';
-import { WMTSAdapter } from './model/earth/wmts/WMTSAdapter.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)
  */
@@ -39,7 +53,7 @@ class AstroSphere {
     pointerDownY = null;
     pointerDownAt = 0;
     _activeHiPS = null;
-    _activeXYZ = null;
+    _activeXYZ2 = null;
     _activeBaseLayer = null;
     startup = true;
     fov;
@@ -51,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)
@@ -150,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)
@@ -266,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 {
@@ -419,12 +549,17 @@ class AstroSphere {
         this._activeBaseLayer = 'hips';
     }
     activateXYZ(config) {
-        this._activeXYZ = new XYZLayer(config, this._webgl);
+        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);
-        this._activeXYZ = new XYZLayer(adapter.toXYZLayerConfig(), this._webgl);
+        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
@@ -459,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() {
@@ -545,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;
@@ -557,12 +725,36 @@ class AstroSphere {
         return this._activeHiPS;
     }
     get activeXYZ() {
-        return this._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._activeXYZ?.getDebugStats() ?? null,
+            layer: this._activeXYZ2?.getDebugStats() ?? null,
             requests: xyzTileRequestScheduler.getDebugStats(),
         };
     }
@@ -571,7 +763,7 @@ class AstroSphere {
             return;
         if (!this._webgl)
             return;
-        if (!this._activeHiPS && !this._activeXYZ)
+        if (!this._activeHiPS && !this._activeXYZ2)
             return;
         if (!this._healpixGrid || Object.keys(this._healpixGrid).length === 0)
             return;
@@ -608,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;
@@ -672,7 +869,7 @@ class AstroSphere {
             this._activeHiPS?.draw(skyEntityDrawInput);
         }
         if (this._activeBaseLayer === 'xyz') {
-            this._activeXYZ?.draw(skyEntityDrawInput);
+            this._activeXYZ2?.draw(skyEntityDrawInput);
         }
         this._healpixGrid.draw(skyEntityDrawInput);
         this._equatorialGrid.draw(skyEntityDrawInput);
@@ -694,14 +891,14 @@ class AstroSphere {
             });
         }
         this.activeCatalogues.forEach(cat => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ?? this._activeXYZ?.getModelMatrix();
+            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 => {
-            const activeModelMatrix = this._activeHiPS?.getModelMatrix() ?? this._activeXYZ?.getModelMatrix();
+            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,8 +9,8 @@ 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 { XYZLayer } from './model/earth/XYZLayer.js';
-import type { WMTSLayerConfig, XYZDebugStats, XYZLayerConfig } from './model/earth/types.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 {
@@ -49,6 +49,9 @@ export declare class AstroViewer {
     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;
@@ -57,13 +60,14 @@ export declare class AstroViewer {
     changeColorMap(colorMapName: ColorMapName): void;
     changeCustomColorMap(colorMap: ColorMap): void;
     getActiveHiPS(): HiPS | null;
-    getActiveXYZ(): XYZLayer | 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;
@@ -71,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';
@@ -6,6 +18,7 @@ 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';
 // & {
@@ -116,6 +129,10 @@ export class AstroViewer {
     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);
     }
@@ -174,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();
     }
@@ -200,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();

package/lib-esm/Camera.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.
+ */
 /**
  * @author Fabrizio Giordano (Fab)
  */
@@ -44,10 +56,19 @@ class Camera {
     }
     goToPhiTheta(ptDeg) {
         const xyz = sphericalToCartesian(ptDeg.phi, ptDeg.theta, this.cam_pos[2]);
+        const targetDirection = vec3.normalize(vec3.create(), vec3.fromValues(xyz[0], xyz[1], xyz[2]));
+        const celestialNorth = vec3.fromValues(0.0, 0.0, 1.0);
+        const northProjection = vec3.scale(vec3.create(), targetDirection, vec3.dot(celestialNorth, targetDirection));
+        const cameraUp = vec3.subtract(vec3.create(), celestialNorth, northProjection);
+        if (vec3.length(cameraUp) < 1e-6) {
+            vec3.set(cameraUp, 0.0, 1.0, 0.0);
+        }
+        else {
+            vec3.normalize(cameraUp, cameraUp);
+        }
         let cameraMatrix = mat4.create();
         cameraMatrix = mat4.translate(cameraMatrix, cameraMatrix, vec3.fromValues(xyz[0], xyz[1], xyz[2]));
         const focusPoint = [0.0, 0.0, 0.0];
-        const cameraUp = vec3.clone([0.0, 1.0, 0.0]);
         const cameraPos = [cameraMatrix[12], cameraMatrix[13], cameraMatrix[14]];
         cameraMatrix = mat4.targetTo(cameraMatrix, cameraPos, focusPoint, cameraUp);
         this.R = mat4.clone(cameraMatrix);
@@ -200,10 +221,6 @@ class Camera {
         const totRot = Math.sqrt(phi * phi + theta * theta);
         if (totRot === 0)
             return;
-        // If both X and Y rotations are locked, nothing to do
-        if (this.lockRotX && this.lockRotY) {
-            return;
-        }
         const pos = this.getCameraPosition();
         const dist2Center = Math.sqrt(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]);
         const distanceFromSurface = Math.max(dist2Center - 1, 1e-6);
@@ -214,9 +231,8 @@ class Camera {
         const normalizedFoV = Math.min(1, this.FoV / 18);
         const fovFactor = 0.06 + 1.55 * Math.pow(normalizedFoV, 0.52);
         const usedRot = ((totRot * distanceFactor * fovFactor) / 1.9) * this.rotationSensitivity;
-        // Build an axis from phi/theta, but zero components that are locked
-        let axisX = this.lockRotX ? 0 : theta;
-        let axisY = this.lockRotY ? 0 : phi;
+        let axisX = theta;
+        let axisY = phi;
         const axisLen = Math.sqrt(axisX * axisX + axisY * axisY);
         // If after locking we have no axis left, do nothing
         if (axisLen === 0) {

package/lib-esm/Config.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.
+ */
 export const hipsNodes = [
     "https://skies.esac.esa.int/",
     "https://alasky.cds.unistra.fr/",

package/lib-esm/Global.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.
+ */
 'use strict';
 import { Healpix } from 'healpixjs';
 import { bootSetup } from './Config.js';