astro-viewer 2.0.0 → 3.1.0

package/lib-esm/model/grid/HealpixGrid.js

@@ -1,10 +1,22 @@
+/*
+ * 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 { AbstractSkyEntity } from '../AbstractSkyEntity.js';
 import global from '../../Global.js';
 import { mat4, vec4 } from 'gl-matrix';
 import { fovHelper } from '../hips/FoVHelper.js';
 import { FoVUtils } from '../../utils/FoVUtils.js';
-import { FoV } from '../FoV.js';
+import { SphereFoV } from '../SphereFoV.js';
 import { CoordsType } from '../../utils/CoordsType.js';
 import { Point } from '../Point.js';
 import GridShaderManager from '../../shader/GridShaderManager.js';
@@ -22,7 +34,7 @@ export class HealpixGrid extends AbstractSkyEntity {
     fragmentShader;
     vertexShader;
     defaultColor = '#ec0acaff';
-    gridText = new GridTextHelper();
+    gridText = new GridTextHelper('healpix');
     // private _hipsShaderProgram: HiPSShaderProgram
     _attribLocations = {
         position: 0,
@@ -59,7 +71,7 @@ export class HealpixGrid extends AbstractSkyEntity {
         this._vertexCataloguePositionBuffer = super.webgl.createBuffer();
         this._indexBuffer = super.webgl.createBuffer();
         this._vertexCataloguePosition = new Float32Array(0);
-        this._fovObj = new FoV(super.webgl);
+        this._fovObj = new SphereFoV(super.webgl);
     }
     get fovObj() {
         return this._fovObj;
@@ -288,9 +300,10 @@ export class HealpixGrid extends AbstractSkyEntity {
                 // NDC divide
                 clipspace[0] /= clipspace[3];
                 clipspace[1] /= clipspace[3];
-                // clip → pixels
-                const pixelX = (clipspace[0] * 0.5 + 0.5) * gl.canvas.width;
-                const pixelY = (clipspace[1] * -0.5 + 0.5) * gl.canvas.height;
+                // clip -> CSS pixels
+                const canvasRect = gl.canvas.getBoundingClientRect();
+                const pixelX = canvasRect.left + (clipspace[0] * 0.5 + 0.5) * canvasRect.width;
+                const pixelY = canvasRect.top + (clipspace[1] * -0.5 + 0.5) * canvasRect.height;
                 this.gridText.addHPXDivSet(this._visibleorder + '/' + pixels[p], pixelX, pixelY);
                 // gridTextHelper.addHPXDivSet(this._visibleorder + '/' + pixels[p], pixelX, pixelY);
             }

package/lib-esm/model/grid/LonLatGrid.d.ts

@@ -0,0 +1,40 @@
+import { AbstractSkyEntity, SkyEntityDrawInput } from '../AbstractSkyEntity.js';
+import { SphereFoV } from '../SphereFoV.js';
+export declare class LatLonGrid extends AbstractSkyEntity {
+    static ELEM_SIZE: number;
+    static BYTES_X_ELEM: number;
+    private _shaderProgram;
+    private _vertexShader;
+    private _fragmentShader;
+    private _attribLocations;
+    private _lonVertexPositionBuffer;
+    private _latVertexPositionBuffer;
+    private _lonStep;
+    private _latStep;
+    private _segmentStep;
+    private _fovObj;
+    private _fovDeg;
+    private _showGrid;
+    private _lonArray;
+    private _latArray;
+    private defaultColor;
+    private gridText;
+    constructor(radius: number, position: [number, number, number], xrad: number, yrad: number, name: string, webgl: WebGL2RenderingContext);
+    init(): void;
+    private initShaders;
+    private initBuffers;
+    private lonLatToCartesian;
+    private refresh;
+    refreshFoV(input: SkyEntityDrawInput): number;
+    getMinFoVDeg(): number;
+    getFoV(): SphereFoV;
+    isVisible(): boolean;
+    toggleShowGrid(): boolean;
+    setShowGrid(showGrid: boolean): void;
+    private enableShader;
+    draw(input: SkyEntityDrawInput): void;
+    private drawLabels;
+    private projectPointToScreen;
+    private roundToStep;
+    private normalizeLon;
+}

package/lib-esm/model/grid/LonLatGrid.js

@@ -0,0 +1,258 @@
+/*
+ * 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.
+ */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { mat4, vec4 } from 'gl-matrix';
+import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
+import { xyzFovHelper } from '../earth/XYZFoVHelper.js';
+import GridShaderManager from '../../shader/GridShaderManager.js';
+import { colorHex2RGB, degToRad } from '../../utils/Utils.js';
+import { SphereFoV } from '../SphereFoV.js';
+import global from '../../Global.js';
+import GridTextHelper from './GridTextHelper.js';
+export class LatLonGrid extends AbstractSkyEntity {
+    static ELEM_SIZE = 3;
+    static BYTES_X_ELEM = new Float32Array().BYTES_PER_ELEMENT;
+    _shaderProgram;
+    _vertexShader;
+    _fragmentShader;
+    _attribLocations = {
+        position: 0,
+    };
+    _lonVertexPositionBuffer;
+    _latVertexPositionBuffer;
+    _lonStep = 10;
+    _latStep = 10;
+    _segmentStep = 1;
+    _fovObj;
+    _fovDeg = 180;
+    _showGrid = true;
+    _lonArray = [];
+    _latArray = [];
+    defaultColor = '#41d4d4';
+    gridText = new GridTextHelper('lonlat');
+    constructor(radius, position, xrad, yrad, name, webgl) {
+        super(radius, position, xrad, yrad, name, webgl);
+        this._fovObj = new SphereFoV(webgl);
+        this.init();
+    }
+    init() {
+        this.initGL(super.webgl);
+        const gl = super.webgl;
+        this._shaderProgram = gl.createProgram();
+        this.initShaders();
+        this._lonVertexPositionBuffer = gl.createBuffer();
+        this._latVertexPositionBuffer = gl.createBuffer();
+        this.initBuffers(this._fovDeg);
+    }
+    initShaders() {
+        const gl = super.webgl;
+        const fsSource = GridShaderManager.healpixGridFS();
+        this._fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+        gl.shaderSource(this._fragmentShader, fsSource);
+        gl.compileShader(this._fragmentShader);
+        if (!gl.getShaderParameter(this._fragmentShader, gl.COMPILE_STATUS)) {
+            const log = gl.getShaderInfoLog(this._fragmentShader) || 'Unknown fragment shader error';
+            console.error(log);
+            alert(log);
+            return;
+        }
+        const vsSource = GridShaderManager.healpixGridVS();
+        this._vertexShader = gl.createShader(gl.VERTEX_SHADER);
+        gl.shaderSource(this._vertexShader, vsSource);
+        gl.compileShader(this._vertexShader);
+        if (!gl.getShaderParameter(this._vertexShader, gl.COMPILE_STATUS)) {
+            const log = gl.getShaderInfoLog(this._vertexShader) || 'Unknown vertex shader error';
+            console.error(log);
+            alert(log);
+            return;
+        }
+        gl.attachShader(this._shaderProgram, this._vertexShader);
+        gl.attachShader(this._shaderProgram, this._fragmentShader);
+        gl.linkProgram(this._shaderProgram);
+        if (!gl.getProgramParameter(this._shaderProgram, gl.LINK_STATUS)) {
+            alert('Could not initialise shaders');
+        }
+        gl.useProgram(this._shaderProgram);
+    }
+    initBuffers(fovDeg) {
+        const steps = xyzFovHelper.getLonLatSteps(fovDeg);
+        this._lonStep = steps.lonStep;
+        this._latStep = steps.latStep;
+        this._segmentStep = Math.max(Math.min(this._lonStep, this._latStep), 0.25);
+        this._lonArray = [];
+        this._latArray = [];
+        for (let lon = -180; lon < 180; lon += this._lonStep) {
+            const vertices = [];
+            for (let lat = -90; lat <= 90; lat += this._segmentStep) {
+                vertices.push(...this.lonLatToCartesian(lon, Math.min(lat, 90)));
+            }
+            this._lonArray.push(new Float32Array(vertices));
+        }
+        for (let lat = -90 + this._latStep; lat < 90; lat += this._latStep) {
+            const vertices = [];
+            for (let lon = -180; lon <= 180; lon += this._segmentStep) {
+                vertices.push(...this.lonLatToCartesian(Math.min(lon, 180), lat));
+            }
+            this._latArray.push(new Float32Array(vertices));
+        }
+    }
+    lonLatToCartesian(lonDeg, latDeg) {
+        const lonRad = degToRad(lonDeg);
+        const latRad = degToRad(latDeg);
+        const cosLat = Math.cos(latRad);
+        return [
+            cosLat * Math.cos(lonRad),
+            cosLat * Math.sin(lonRad),
+            Math.sin(latRad),
+        ];
+    }
+    refresh(fovDeg) {
+        if (Math.abs(this._fovDeg - fovDeg) > 1e-6) {
+            this._fovDeg = fovDeg;
+            this.initBuffers(this._fovDeg);
+        }
+    }
+    refreshFoV(input) {
+        if (!input.camera || !input.pMatrix)
+            return this._fovDeg;
+        this._fovObj.getFoV(global.insideSphere, this, input.camera, input.pMatrix);
+        this.refresh(this._fovObj.minFoV);
+        return this._fovObj.minFoV;
+    }
+    getMinFoVDeg() {
+        return this._fovObj.minFoV;
+    }
+    getFoV() {
+        return this._fovObj;
+    }
+    isVisible() {
+        return this._showGrid;
+    }
+    toggleShowGrid() {
+        this._showGrid = !this._showGrid;
+        return this._showGrid;
+    }
+    setShowGrid(showGrid) {
+        this._showGrid = showGrid;
+    }
+    enableShader(mMatrix, pMatrix, vMatrix) {
+        const gl = super.webgl;
+        gl.useProgram(this._shaderProgram);
+        const mvMatrix = mat4.create();
+        mat4.multiply(mvMatrix, vMatrix, mMatrix);
+        const uMVMatrixLoc = gl.getUniformLocation(this._shaderProgram, 'uMVMatrix');
+        const uPMatrixLoc = gl.getUniformLocation(this._shaderProgram, 'uPMatrix');
+        const uColor = gl.getUniformLocation(this._shaderProgram, 'u_fragcolor');
+        this._attribLocations.position = gl.getAttribLocation(this._shaderProgram, 'aCatPosition');
+        if (uMVMatrixLoc)
+            gl.uniformMatrix4fv(uMVMatrixLoc, false, mvMatrix);
+        if (uPMatrixLoc)
+            gl.uniformMatrix4fv(uPMatrixLoc, false, pMatrix);
+        if (uColor) {
+            const rgb = colorHex2RGB(this.defaultColor);
+            gl.uniform4f(uColor, rgb[0], rgb[1], rgb[2], 1.0);
+        }
+    }
+    draw(input) {
+        if (!this._showGrid) {
+            this.gridText.resetDivSets();
+            return;
+        }
+        const gl = super.webgl;
+        const camera = input.camera;
+        if (!camera)
+            return;
+        const pMatrix = input.pMatrix;
+        if (!pMatrix)
+            return;
+        this.refreshFoV(input);
+        const vMatrix = camera.getCameraMatrix();
+        if (!vMatrix)
+            return;
+        const mMatrix = this.getModelMatrix();
+        this.enableShader(mMatrix, pMatrix, vMatrix);
+        for (const lonLine of this._lonArray) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._lonVertexPositionBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, lonLine, gl.STATIC_DRAW);
+            gl.vertexAttribPointer(this._attribLocations.position, LatLonGrid.ELEM_SIZE, gl.FLOAT, false, 0, 0);
+            gl.enableVertexAttribArray(this._attribLocations.position);
+            gl.drawArrays(gl.LINE_STRIP, 0, lonLine.length / LatLonGrid.ELEM_SIZE);
+        }
+        for (const latLine of this._latArray) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._latVertexPositionBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, latLine, gl.STATIC_DRAW);
+            gl.vertexAttribPointer(this._attribLocations.position, LatLonGrid.ELEM_SIZE, gl.FLOAT, false, 0, 0);
+            gl.enableVertexAttribArray(this._attribLocations.position);
+            gl.drawArrays(gl.LINE_LOOP, 0, latLine.length / LatLonGrid.ELEM_SIZE);
+        }
+        this.drawLabels(input, mMatrix, pMatrix, vMatrix);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    }
+    drawLabels(input, mMatrix, pMatrix, vMatrix) {
+        const center = input.centerSphericalDeg;
+        if (!center) {
+            this.gridText.resetDivSets();
+            return;
+        }
+        const centerLon = this.normalizeLon(center.phi > 180 ? center.phi - 360 : center.phi);
+        const centerLat = 90 - center.theta;
+        const lonLine = this.normalizeLon(this.roundToStep(centerLon, this._lonStep));
+        const latLine = Math.max(-90 + this._latStep, Math.min(90 - this._latStep, this.roundToStep(centerLat, this._latStep)));
+        const lonLabelPoint = this.lonLatToCartesian(lonLine, Math.max(-80, Math.min(80, centerLat)));
+        const latLabelPoint = this.lonLatToCartesian(centerLon, latLine);
+        const lonScreen = this.projectPointToScreen(lonLabelPoint, mMatrix, pMatrix, vMatrix);
+        if (lonScreen) {
+            this.gridText.addLonLatDivSet(`${lonLine.toFixed(0)}° lon`, lonScreen.x, lonScreen.y, 'lon');
+        }
+        const latScreen = this.projectPointToScreen(latLabelPoint, mMatrix, pMatrix, vMatrix);
+        if (latScreen) {
+            this.gridText.addLonLatDivSet(`${latLine.toFixed(0)}° lat`, latScreen.x, latScreen.y, 'lat');
+        }
+        this.gridText.resetDivSets();
+    }
+    projectPointToScreen(point, mMatrix, pMatrix, vMatrix) {
+        const mvMatrix = mat4.create();
+        const mvpMatrix = mat4.create();
+        mat4.multiply(mvMatrix, vMatrix, mMatrix);
+        mat4.multiply(mvpMatrix, pMatrix, mvMatrix);
+        const clipspace = vec4.fromValues(point[0], point[1], point[2], 1);
+        vec4.transformMat4(clipspace, clipspace, mvpMatrix);
+        if (Math.abs(clipspace[3]) < 1e-6) {
+            return null;
+        }
+        clipspace[0] /= clipspace[3];
+        clipspace[1] /= clipspace[3];
+        if (clipspace[0] < -1 || clipspace[0] > 1 || clipspace[1] < -1 || clipspace[1] > 1) {
+            return null;
+        }
+        const canvasRect = super.webgl.canvas.getBoundingClientRect();
+        return {
+            x: canvasRect.left + (clipspace[0] * 0.5 + 0.5) * canvasRect.width,
+            y: canvasRect.top + (clipspace[1] * -0.5 + 0.5) * canvasRect.height,
+        };
+    }
+    roundToStep(value, step) {
+        if (step <= 0)
+            return value;
+        return Math.round(value / step) * step;
+    }
+    normalizeLon(lonDeg) {
+        let lon = lonDeg;
+        while (lon < -180)
+            lon += 360;
+        while (lon > 180)
+            lon -= 360;
+        return lon;
+    }
+}

package/lib-esm/model/hips/AllSky.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 global from '../../Global.js';
 export default class AllSky {

package/lib-esm/model/hips/AncestorTile.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 global from '../../Global.js';
 import { fovHelper } from './FoVHelper.js';

package/lib-esm/model/hips/FoVHelper.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.
+ */
 // FoVHelper.ts
 'use strict';
 class FoVHelper {

package/lib-esm/model/hips/HiPS.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';
 /**
  * @author Fabrizio Giordano (Fab77)
@@ -5,8 +17,6 @@
 import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
 import { fovHelper } from './FoVHelper.js';
 import ColorMaps from '../ColorMaps.js';
-// import { hipsShaderProgram } from '../../shader/HiPSShaderProgram.js'
-// import { HiPSShaderProgram } from '../../shader/HiPSShaderProgram.js'
 import AncestorTile from './AncestorTile.js';
 import AllSky from './AllSky.js';
 export class HiPS extends AbstractSkyEntity {
@@ -33,10 +43,8 @@ export class HiPS extends AbstractSkyEntity {
     constructor(radius, position, xrad, yrad, descriptor, webgl, healpixGrid) {
         super(radius, position, xrad, yrad, descriptor.surveyName, webgl, descriptor.isGalactic);
         this._descriptor = descriptor;
-        // this.initGL((global as any).gl as WebGL2RenderingContext)
         this.initGL(webgl);
         this._healpixGrid = healpixGrid;
-        // newTileBuffer.addHiPS(this)
         this._healpixGrid.visibleTilesManager.tileBuffer.addHiPS(this);
         // DEBUG logs kept from JS (optional)
         // eslint-disable-next-line no-console
@@ -185,7 +193,6 @@ export class HiPS extends AbstractSkyEntity {
         if (!pMatrix)
             return;
         this.refresh();
-        // const pMatrix = computePerspectiveMatrixSingleton.pMatrix as Float32Array
         const mMatrix = this.getModelMatrix();
         super.hipsShaderProgram.setRuntimeColorMap(this.colorMap);
         if (this._allSky && this._allSkyTile) {
@@ -207,13 +214,9 @@ export class HiPS extends AbstractSkyEntity {
         const order = this.isGalacticHips
             ? this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder.order
             : this._healpixGrid.visibleTilesManager.visibleTilesByOrder.order;
-        // ? visibleTilesManager.galVisibleTilesByOrder.order
-        // : visibleTilesManager.visibleTilesByOrder.order
         const map = this.isGalacticHips
             ? this._healpixGrid.visibleTilesManager.galAncestorsMap
             : this._healpixGrid.visibleTilesManager.ancestorsMap;
-        // ? visibleTilesManager.galAncestorsMap
-        // : visibleTilesManager.ancestorsMap
         this._ancestorTiles.forEach((ancestor) => {
             ancestor.draw(order, map, pMatrix, vMatrix, mMatrix, this.colorMapIdx);
         });

package/lib-esm/model/hips/HiPSDescriptor.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.
+ */
 // HiPSDescriptor.ts
 'use strict';
 export class HiPSDescriptor {

package/lib-esm/model/hips/Tile.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.
+ */
 // Tile.ts
 import global from '../../Global.js';
 import { fovHelper } from './FoVHelper.js';

package/lib-esm/model/hips/TileBuffer.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.
+ */
 // TileBuffer.ts
 import Tile from './Tile.js'; // adjust if your file is named differently
 // export default class TileBuffer {

package/lib-esm/model/hips/VisibleTilesManager.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 { Pointing, Vec3 } from 'healpixjs';
 import RayPickingUtils from '../../utils/RayPickingUtils.js';

package/lib-esm/model/tap/TapMetadata.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';
 /**
  * @author Fabrizio Giordano (Fab77)

package/lib-esm/model/tap/TapMetadataList.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 class TapMetadataList {
     _posEqRAMetaColumns; // ucd.includes('pos.eq.ra')

package/lib-esm/model/tap/TapRepo.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 class TapRepo {
     _adqlFunctionList;
     _cataloguesList;

package/lib-esm/model/terra/TerraFootprintSetGL.d.ts

@@ -0,0 +1,4 @@
+import { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+export declare class TerraFootprintSetGL extends FootprintSetGL {
+    _kind: string;
+}

package/lib-esm/model/terra/TerraFootprintSetGL.js

@@ -0,0 +1,16 @@
+/*
+ * 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 { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+export class TerraFootprintSetGL extends FootprintSetGL {
+    _kind = 'TerraFootprintSetGL';
+}

package/lib-esm/model/terra/TerraPointSetGL.d.ts

@@ -0,0 +1,4 @@
+import { CatalogueGL } from '../catalogues/CatalogueGL.js';
+export declare class TerraPointSetGL extends CatalogueGL {
+    _kind: string;
+}

package/lib-esm/model/terra/TerraPointSetGL.js

@@ -0,0 +1,16 @@
+/*
+ * 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 { CatalogueGL } from '../catalogues/CatalogueGL.js';
+export class TerraPointSetGL extends CatalogueGL {
+    _kind = 'TerraPointSetGL';
+}

package/lib-esm/services/SesameService.js

@@ -1,6 +1,14 @@
-// SesameService.ts
-/**
- * @author Fabrizio Giordano (Fab)
+/*
+ * 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 SesameService {
     baseURL = 'https://cdsweb.u-strasbg.fr/cgi-bin/nph-sesame/-ox?';

package/lib-esm/services/helpers.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.
+ */
 // helpers.ts
 export const toHttps = (url) => url.startsWith('http:') ? url.replace('http:', 'https:') : url;
 export const urlJoin = (base, path) => new URL(path.replace(/^\/+/, ''), base).toString();