astro-viewer 2.0.0 → 3.1.0

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';

package/lib-esm/index.d.ts

@@ -1,9 +1,12 @@
 export { AstroViewer } from './AstroViewer.js';
 export { HiPSDescriptor } from './model/hips/HiPSDescriptor.js';
-export { FoV } from './model/FoV.js';
+export { SphereFoV as FoV } from './model/SphereFoV.js';
+export { SphereFoV } from './model/SphereFoV.js';
 export type { PointCoordinates, CameraChangedDetail } from './AstroSphere.js';
 export { HoveredFootprintDetail, FootprintSetGL } from './model/footprints/FootprintSetGL.js';
 export { CatalogueGL } from './model/catalogues/CatalogueGL.js';
+export { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
+export { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
 export { MetadataManager } from './model/MetadataManager.js';
 export { MetadataColumn, MetadataInit, ColumnType } from './model/MetadataColumn.js';
 export { Point, SphericalOpts, AstroOpts, PointInitOpts, CartesianOpts } from './model/Point.js';
@@ -12,5 +15,9 @@ export { CoordsType } from './utils/CoordsType.js';
 export { ColorMaps, COLOR_MAP_SAMPLE_COUNT, createColorMapFromSamples } from './model/ColorMaps.js';
 export type { ColorMap, ColorMapName } from './model/ColorMaps.js';
 export { HiPS } from './model/hips/HiPS.js';
+export { XYZMap } from './model/earth/XYZMap.js';
+export { WMTSAdapter } from './model/earth/WMTSAdapter.js';
+export type { XYZLayerConfig, WMTSLayerConfig, WMTSRequestEncoding } from './model/earth/XYZConfig.js';
+export type { XYZTileCoord, XYZTileMesh } from './model/earth/XYZTypes.js';
 export { Source } from './model/Source.js';
 export { Footprint } from './model/footprints/Footprint.js';

package/lib-esm/index.js

@@ -1,8 +1,23 @@
+/*
+ * 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 { AstroViewer } from './AstroViewer.js';
 export { HiPSDescriptor } from './model/hips/HiPSDescriptor.js';
-export { FoV } from './model/FoV.js';
+export { SphereFoV as FoV } from './model/SphereFoV.js';
+export { SphereFoV } from './model/SphereFoV.js';
 export { FootprintSetGL } from './model/footprints/FootprintSetGL.js';
 export { CatalogueGL } from './model/catalogues/CatalogueGL.js';
+export { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
+export { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
 export { MetadataManager } from './model/MetadataManager.js';
 export { MetadataColumn, ColumnType } from './model/MetadataColumn.js';
 export { Point } from './model/Point.js';
@@ -10,6 +25,8 @@ export { FoVUtils } from './utils/FoVUtils.js';
 export { CoordsType } from './utils/CoordsType.js';
 export { ColorMaps, COLOR_MAP_SAMPLE_COUNT, createColorMapFromSamples } from './model/ColorMaps.js';
 export { HiPS } from './model/hips/HiPS.js';
+export { XYZMap } from './model/earth/XYZMap.js';
+export { WMTSAdapter } from './model/earth/WMTSAdapter.js';
 export { Source } from './model/Source.js';
 export { Footprint } from './model/footprints/Footprint.js';
 console.log('astroviewer UMD loaded');

package/lib-esm/model/AbstractSkyEntity.d.ts

@@ -4,11 +4,21 @@
 import { vec3, mat4, ReadonlyVec3, ReadonlyMat4 } from "gl-matrix";
 import { HiPSShaderProgram } from '../shader/HiPSShaderProgram.js';
 import Camera from "../Camera.js";
+import { Point } from "./Point.js";
 type GL = WebGLRenderingContext | WebGL2RenderingContext;
 export interface SkyEntityDrawInput {
     fovDeg?: number;
     camera: Camera;
     pMatrix: ReadonlyMat4;
+    centerSphericalDeg?: {
+        phi: number;
+        theta: number;
+    };
+    fovPolygon?: Point[];
+    viewportSphericalSamples?: Array<{
+        phi: number;
+        theta: number;
+    }>;
 }
 export declare abstract class AbstractSkyEntity {
     refreshMe: boolean;

package/lib-esm/model/AbstractSkyEntity.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)
  */

package/lib-esm/model/AstroGL.js

@@ -1 +1,13 @@
+/*
+ * 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 {};

package/lib-esm/model/ColorMaps.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 COLOR_MAP_SAMPLE_COUNT = 256;
 function validateColorChannel(name, values) {
     if (!Array.isArray(values)) {

package/lib-esm/model/MetadataColumn.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';
 export var ColumnType;
 (function (ColumnType) {

package/lib-esm/model/MetadataManager.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 { ColumnType } from "./MetadataColumn.js";
 export class MetadataManager {
     static STANDARD_SIZE = "STANDARD_SIZE";

package/lib-esm/model/Point.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 (Fab77)
  */

package/lib-esm/model/Point2D.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.
+ */
 class Point2D {
     _x;
     _y;

package/lib-esm/model/Source.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 { Vec3, Pointing } from 'healpixjs';
 import global from '../Global.js';

package/lib-esm/model/SphereFoV.d.ts

@@ -0,0 +1,30 @@
+import { ReadonlyMat4 } from 'gl-matrix';
+import Camera from '../Camera.js';
+import { AbstractSkyEntity } from './AbstractSkyEntity.js';
+export declare class SphereFoV {
+    private static readonly MIN_FOV_DEG;
+    private fovXDeg;
+    private fovYDeg;
+    private ratio;
+    private _minFoV;
+    private _webgl;
+    private _lastModel;
+    private _lastCamera;
+    constructor(webgl: WebGL2RenderingContext);
+    getFoV(insideSphere: boolean, model: AbstractSkyEntity, camera: Camera, pMatrix: ReadonlyMat4): SphereFoV;
+    private computeRatio;
+    get minFoV(): number;
+    get xFoV(): number;
+    get yFoV(): number;
+    computeDistanceFromAngle(angleDeg: number): number;
+    changeMinFov(deg: number): void;
+    computeCameraPositionForMinFoV(targetMinFoVDeg: number): [number, number, number];
+    computeCameraPositionForFoV(targetFoVDeg: number): [number, number, number];
+    computeCameraPositionForAngularDiameter(targetAngularDiameterDeg: number): [number, number, number];
+    private computeAngle;
+    private computeAngularDistanceDeg;
+    private getIntersectionPointWithModel;
+    private getRayFromMouse;
+    private raySphere;
+    private mat4MultiplyVec4;
+}

package/lib-esm/model/SphereFoV.js

@@ -0,0 +1,195 @@
+/*
+ * 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 { mat4, vec3 } from 'gl-matrix';
+import { radToDeg } from '../utils/Utils.js';
+export class SphereFoV {
+    static MIN_FOV_DEG = 1e-6;
+    fovXDeg = 180;
+    fovYDeg = 180;
+    ratio = 0;
+    _minFoV = 180;
+    _webgl;
+    _lastModel = null;
+    _lastCamera = null;
+    constructor(webgl) {
+        this._webgl = webgl;
+    }
+    getFoV(insideSphere, model, camera, pMatrix) {
+        this._lastModel = model;
+        this._lastCamera = camera;
+        const canvas = this._webgl.canvas;
+        if (!canvas) {
+            this.fovXDeg = 180;
+            this.fovYDeg = 180;
+            this._minFoV = this.minFoV;
+            return this;
+        }
+        const rect = canvas.getBoundingClientRect();
+        const canvasWidth = rect.width;
+        const canvasHeight = rect.height;
+        this.fovXDeg = this.computeAngle(0, canvasHeight / 2, insideSphere, model, camera, pMatrix).angleDeg;
+        this.fovYDeg = this.computeAngle(canvasWidth / 2, 0, insideSphere, model, camera, pMatrix).angleDeg;
+        this._minFoV = this.minFoV;
+        this.ratio = this.computeRatio(camera);
+        return this;
+    }
+    computeRatio(camera) {
+        const pos = camera.getCameraPosition();
+        const distanceFromCenter = Math.sqrt(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]);
+        return distanceFromCenter / this.fovYDeg;
+    }
+    get minFoV() {
+        const minFov = this.fovYDeg <= this.fovXDeg ? this.fovYDeg : this.fovXDeg;
+        this._minFoV = Math.max(minFov, SphereFoV.MIN_FOV_DEG);
+        return this._minFoV;
+    }
+    get xFoV() {
+        return this.fovXDeg;
+    }
+    get yFoV() {
+        return this.fovYDeg;
+    }
+    computeDistanceFromAngle(angleDeg) {
+        return angleDeg * this.ratio;
+    }
+    changeMinFov(deg) {
+        if (this.fovYDeg <= this.fovXDeg) {
+            this.fovYDeg = deg;
+        }
+        else {
+            this.fovXDeg = deg;
+        }
+        this.minFoV;
+    }
+    computeCameraPositionForMinFoV(targetMinFoVDeg) {
+        return this.computeCameraPositionForFoV(targetMinFoVDeg);
+    }
+    computeCameraPositionForFoV(targetFoVDeg) {
+        return this.computeCameraPositionForAngularDiameter(targetFoVDeg);
+    }
+    computeCameraPositionForAngularDiameter(targetAngularDiameterDeg) {
+        if (!this._lastModel || !this._lastCamera) {
+            return [0, 0, 0];
+        }
+        const eps = 1e-6;
+        const clamped = Math.max(eps, Math.min(180 - eps, targetAngularDiameterDeg));
+        const halfRad = (clamped * Math.PI) / 360.0;
+        const sinHalf = Math.sin(halfRad);
+        if (sinHalf <= 0) {
+            return [0, 0, 0];
+        }
+        const model = this._lastModel;
+        const camera = this._lastCamera;
+        const targetDistance = Math.max(model.radius / sinHalf, model.radius + 1e-4);
+        const camPos = camera.getCameraPosition();
+        const direction = vec3.fromValues(camPos[0] - model.center[0], camPos[1] - model.center[1], camPos[2] - model.center[2]);
+        if (vec3.length(direction) < eps) {
+            vec3.set(direction, 0, 0, 1);
+        }
+        else {
+            vec3.normalize(direction, direction);
+        }
+        return [
+            model.center[0] + direction[0] * targetDistance,
+            model.center[1] + direction[1] * targetDistance,
+            model.center[2] + direction[2] * targetDistance,
+        ];
+    }
+    computeAngle(canvasX, canvasY, insideSphere, model, camera, pMatrix) {
+        const canvas = this._webgl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const centerHit = this.getIntersectionPointWithModel(rect.width / 2, rect.height / 2, model, camera, pMatrix);
+        const edgeHit = this.getIntersectionPointWithModel(canvasX, canvasY, model, camera, pMatrix);
+        if (!centerHit || !edgeHit) {
+            return { angleDeg: 180, distance: -1 };
+        }
+        const angleDeg = 2 * this.computeAngularDistanceDeg(centerHit.point, edgeHit.point);
+        return {
+            angleDeg: insideSphere ? 360 - angleDeg : angleDeg,
+            distance: edgeHit.distance,
+        };
+    }
+    computeAngularDistanceDeg(a, b) {
+        const aNorm = vec3.normalize(vec3.create(), a);
+        const bNorm = vec3.normalize(vec3.create(), b);
+        const dot = vec3.dot(aNorm, bNorm);
+        const clamped = Math.min(1, Math.max(-1, dot));
+        return radToDeg(Math.acos(clamped));
+    }
+    getIntersectionPointWithModel(mouseX, mouseY, model, camera, pMatrix) {
+        const rayWorld = this.getRayFromMouse(mouseX, mouseY, pMatrix, camera.getCameraMatrix());
+        const distance = this.raySphere(camera.getCameraPosition(), rayWorld, model);
+        if (distance < 0) {
+            return null;
+        }
+        const worldHit = vec3.create();
+        vec3.scale(worldHit, rayWorld, distance);
+        vec3.add(worldHit, camera.getCameraPosition(), worldHit);
+        const worldHit4 = [worldHit[0], worldHit[1], worldHit[2], 1.0];
+        const modelHit4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(model.getModelMatrixInverse(), worldHit4, modelHit4);
+        return {
+            point: vec3.fromValues(modelHit4[0], modelHit4[1], modelHit4[2]),
+            distance,
+        };
+    }
+    getRayFromMouse(mouseX, mouseY, pMatrix, vMatrix) {
+        const gl = this._webgl;
+        const canvas = gl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const x = (2.0 * mouseX) / rect.width - 1.0;
+        const y = 1.0 - (2.0 * mouseY) / rect.height;
+        const rayClip = [x, y, -1.0, 1.0];
+        const pInv = mat4.create();
+        mat4.invert(pInv, pMatrix);
+        const rayEye4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(pInv, rayClip, rayEye4);
+        const rayEye = [rayEye4[0], rayEye4[1], -1.0, 0.0];
+        const vInv = mat4.create();
+        mat4.invert(vInv, vMatrix);
+        const rayWorld4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(vInv, rayEye, rayWorld4);
+        const rayWorld = vec3.fromValues(rayWorld4[0], rayWorld4[1], rayWorld4[2]);
+        vec3.normalize(rayWorld, rayWorld);
+        return rayWorld;
+    }
+    raySphere(rayOrigWorld, rayDirectionWorld, sphere) {
+        let intersectionDistance = -1;
+        const L = vec3.create();
+        vec3.subtract(L, rayOrigWorld, sphere.center);
+        const b = vec3.dot(rayDirectionWorld, L);
+        const c = vec3.dot(L, L) - sphere.radius * sphere.radius;
+        const disc = b * b - c;
+        if (disc > 0.0) {
+            const s = Math.sqrt(disc);
+            const ta = -b + s;
+            const tb = -b - s;
+            if (ta >= 0.0 || tb >= 0.0) {
+                intersectionDistance = tb < 0.0 ? ta : Math.min(ta, tb);
+            }
+        }
+        else if (disc === 0.0) {
+            const t = -b;
+            if (t >= 0.0) {
+                intersectionDistance = t;
+            }
+        }
+        return intersectionDistance;
+    }
+    mat4MultiplyVec4(m, v, out) {
+        out[0] = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12] * v[3];
+        out[1] = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13] * v[3];
+        out[2] = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14] * v[3];
+        out[3] = m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3];
+    }
+}

package/lib-esm/model/catalogues/CatalogueGL.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 { Source } from '../Source.js';
 import { Point } from '../Point.js';
 import { CoordsType } from '../..//utils/CoordsType.js';

package/lib-esm/model/catalogues/CatalogueProps.js

@@ -1,6 +1,18 @@
+/*
+ * 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 {};
 // // CatalogueProps.ts
 // type UCD = string | undefined;
-export {};
 // import {Metadata} from "../tap/TapMetadata.js";
 // import {TapMetadataList} from "../tap/TapMetadataList.js";
 // function colName(col?: Metadata): string | undefined {

package/lib-esm/model/earth/WMTSAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { WMTSLayerConfig, XYZLayerConfig } from './XYZConfig.js';
+import type { XYZTileCoord } from './XYZTypes.js';
+export declare class WMTSAdapter {
+    private _config;
+    constructor(config: WMTSLayerConfig);
+    toXYZLayerConfig(): XYZLayerConfig;
+    private getInferredMaxZoom;
+    getTileUrl(tile: XYZTileCoord): string;
+    private buildRestUrl;
+    private buildKvpUrl;
+    private getCommonTokenValues;
+}