astro-viewer 3.0.0 → 3.2.0

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

@@ -0,0 +1,309 @@
+/*
+ * 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 = [];
+    _bufferKey = '';
+    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, centerSphericalDeg, coarse = false) {
+        const steps = xyzFovHelper.getLonLatSteps(fovDeg, coarse);
+        this._lonStep = steps.lonStep;
+        this._latStep = steps.latStep;
+        this._segmentStep = Math.max(Math.min(this._lonStep, this._latStep), 0.25);
+        this._lonArray = [];
+        this._latArray = [];
+        const center = centerSphericalDeg
+            ? {
+                lon: this.normalizeLon(centerSphericalDeg.phi > 180 ? centerSphericalDeg.phi - 360 : centerSphericalDeg.phi),
+                lat: 90 - centerSphericalDeg.theta,
+            }
+            : null;
+        const localGrid = !!center && !coarse && fovDeg < 2;
+        const lonValues = localGrid
+            ? this.buildLonRange(center.lon, Math.max(fovDeg * 4, this._lonStep * 3), this._lonStep)
+            : this.buildLonRange(0, 180, this._lonStep);
+        const latValues = localGrid
+            ? this.buildLatRange(center.lat, Math.max(fovDeg * 4, this._latStep * 3), this._latStep)
+            : this.buildLatRange(0, 90, this._latStep);
+        const latSegmentRange = localGrid && center
+            ? this.buildLatRange(center.lat, Math.max(fovDeg * 4, this._latStep * 3), this._segmentStep)
+            : this.buildLatRange(0, 90, this._segmentStep);
+        const lonSegmentRange = localGrid && center
+            ? this.buildLonRange(center.lon, Math.max(fovDeg * 4, this._lonStep * 3), this._segmentStep)
+            : this.buildLonRange(0, 180, this._segmentStep);
+        for (const lon of lonValues) {
+            const vertices = [];
+            for (const lat of latSegmentRange) {
+                vertices.push(...this.lonLatToCartesian(lon, Math.min(lat, 90)));
+            }
+            this._lonArray.push(new Float32Array(vertices));
+        }
+        for (const lat of latValues) {
+            const vertices = [];
+            if (lat <= -90 || lat >= 90)
+                continue;
+            for (const lon of lonSegmentRange) {
+                vertices.push(...this.lonLatToCartesian(Math.min(lon, 180), lat));
+            }
+            this._latArray.push(new Float32Array(vertices));
+        }
+    }
+    buildLonRange(centerLon, halfSpan, step) {
+        const values = [];
+        const start = Math.floor((centerLon - halfSpan) / step) * step;
+        const end = Math.ceil((centerLon + halfSpan) / step) * step;
+        for (let lon = start; lon <= end; lon += step) {
+            values.push(this.normalizeLon(lon));
+        }
+        return values;
+    }
+    buildLatRange(centerLat, halfSpan, step) {
+        const values = [];
+        const start = Math.max(-90, Math.floor((centerLat - halfSpan) / step) * step);
+        const end = Math.min(90, Math.ceil((centerLat + halfSpan) / step) * step);
+        for (let lat = start; lat <= end; lat += step) {
+            values.push(lat);
+        }
+        return values;
+    }
+    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, input) {
+        const coarse = !!input.cameraMoving;
+        const steps = xyzFovHelper.getLonLatSteps(fovDeg, coarse);
+        const center = input.centerSphericalDeg;
+        const localGrid = !!center && !coarse && fovDeg < 2;
+        const centerLon = center ? this.normalizeLon(center.phi > 180 ? center.phi - 360 : center.phi) : 0;
+        const centerLat = center ? 90 - center.theta : 0;
+        const centerKey = localGrid
+            ? `${this.roundToStep(centerLon, Math.max(steps.lonStep, fovDeg))}:${this.roundToStep(centerLat, Math.max(steps.latStep, fovDeg))}`
+            : 'global';
+        const bufferKey = `${coarse ? 'coarse' : 'settled'}:${steps.lonStep}:${steps.latStep}:${centerKey}`;
+        if (this._bufferKey !== bufferKey) {
+            this._fovDeg = fovDeg;
+            this._bufferKey = bufferKey;
+            this.initBuffers(this._fovDeg, input.centerSphericalDeg, coarse);
+        }
+    }
+    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, input);
+        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.d.ts

@@ -1,6 +1,9 @@
 declare class FoVHelper {
-    getHiPSNorder(fov: number): number;
-    getRADegSteps(fov: number): {
+    private static readonly LEVEL_HYSTERESIS;
+    private static readonly HIPS_ORDER_MIN_FOV;
+    getHiPSNorder(fov: number, currentOrder?: number): number;
+    private getRawHiPSNorder;
+    getRADegSteps(fov: number, coarse?: boolean): {
         raStep: number;
         decStep: number;
     };

package/lib-esm/model/hips/FoVHelper.js

@@ -1,7 +1,52 @@
+/*
+ * 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 {
-    getHiPSNorder(fov) {
+    static LEVEL_HYSTERESIS = 0.12;
+    static HIPS_ORDER_MIN_FOV = {
+        0: 179,
+        1: 90,
+        2: 30,
+        3: 20,
+        4: 6,
+        5: 3.2,
+        6: 1.6,
+        7: 0.85,
+        8: 0.42,
+        9: 0.21,
+        10: 0.12,
+        11: 0.06,
+        12: 0.015,
+        13: 0,
+    };
+    getHiPSNorder(fov, currentOrder) {
+        const rawOrder = this.getRawHiPSNorder(fov);
+        if (currentOrder === undefined || currentOrder === rawOrder)
+            return rawOrder;
+        if (rawOrder > currentOrder) {
+            const boundary = FoVHelper.HIPS_ORDER_MIN_FOV[currentOrder];
+            if (boundary > 0 && fov > boundary * (1 - FoVHelper.LEVEL_HYSTERESIS))
+                return currentOrder;
+        }
+        else {
+            const boundary = FoVHelper.HIPS_ORDER_MIN_FOV[rawOrder];
+            if (boundary > 0 && fov < boundary * (1 + FoVHelper.LEVEL_HYSTERESIS))
+                return currentOrder;
+        }
+        return rawOrder;
+    }
+    getRawHiPSNorder(fov) {
         if (fov >= 179)
             return 0;
         if (fov >= 90)
@@ -30,10 +75,14 @@ class FoVHelper {
             return 12;
         return 13;
     }
-    getRADegSteps(fov) {
+    getRADegSteps(fov, coarse = false) {
         let raStep;
         let decStep;
-        if (fov >= 179) {
+        if (coarse && fov < 0.21) {
+            raStep = 10;
+            decStep = 10;
+        }
+        else if (fov >= 179) {
             raStep = 10;
             decStep = 10;
         }

package/lib-esm/model/hips/HiPS.d.ts

@@ -4,6 +4,7 @@
 import { AbstractSkyEntity, SkyEntityDrawInput } from '../AbstractSkyEntity.js';
 import { ColorMap } from '../ColorMaps.js';
 import { HiPSDescriptor } from './HiPSDescriptor.js';
+import type { HiPSDebugStats } from './HiPSConfig.js';
 import { HealpixGrid } from '../grid/HealpixGrid.js';
 export declare class HiPS extends AbstractSkyEntity {
     private _ancestorTiles;
@@ -41,6 +42,7 @@ export declare class HiPS extends AbstractSkyEntity {
     changeColorMap(colorMap: ColorMap): void;
     private initShaders;
     getCurrentHealpixOrder(): number;
+    getDebugStats(): HiPSDebugStats;
     private refresh;
     draw(input: SkyEntityDrawInput): void;
 }

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
@@ -172,10 +180,31 @@ export class HiPS extends AbstractSkyEntity {
     getCurrentHealpixOrder() {
         return this._visibleorder;
     }
-    refresh() {
-        // const fov = healpixGridSingleton.getMinFoV()
-        const fov = this._healpixGrid.getMinFoV();
-        this._visibleorder = Math.min(fovHelper.getHiPSNorder(fov), this._maxorder);
+    getDebugStats() {
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        const visibleTiles = this.isGalacticHips
+            ? this._healpixGrid.visibleTilesManager.galVisibleTilesByOrder
+            : this._healpixGrid.visibleTilesManager.visibleTilesByOrder;
+        return {
+            activeBaseLayer: 'hips',
+            hipsName: this._descriptor.surveyName,
+            hipsUrl: this._baseurl,
+            isGalactic: this.isGalacticHips,
+            currentOrder: visibleTiles.order,
+            visibleTileCount: visibleTiles.pixels.length,
+            activeTileCount: tileBuffer.activeTileCount,
+            cachedTileCount: tileBuffer.cachedTileCount,
+            cacheSize: tileBuffer.size,
+            readyTileCount: tileBuffer.readyTileCount,
+            loadingTileCount: tileBuffer.loadingTileCount,
+        };
+    }
+    refresh(input) {
+        // const fov = this._healpixGrid.getMinFoV()
+        // this._visibleorder = Math.min(fovHelper.getHiPSNorder(fov), this._maxorder)
+        const rawFov = input.fovDeg ?? this._healpixGrid.getMinFoV();
+        const fov = Number.isFinite(rawFov) && rawFov > 0 ? rawFov : 1e-6;
+        this._visibleorder = Math.min(fovHelper.getHiPSNorder(fov, this._visibleorder), this._maxorder);
     }
     draw(input) {
         const vMatrix = input.camera.getCameraMatrix();
@@ -184,8 +213,7 @@ export class HiPS extends AbstractSkyEntity {
         const pMatrix = input.pMatrix;
         if (!pMatrix)
             return;
-        this.refresh();
-        // const pMatrix = computePerspectiveMatrixSingleton.pMatrix as Float32Array
+        this.refresh(input);
         const mMatrix = this.getModelMatrix();
         super.hipsShaderProgram.setRuntimeColorMap(this.colorMap);
         if (this._allSky && this._allSkyTile) {
@@ -207,13 +235,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/HiPSConfig.d.ts

@@ -0,0 +1,13 @@
+export type HiPSDebugStats = {
+    activeBaseLayer: 'hips' | 'xyz' | null;
+    hipsName: string | null;
+    hipsUrl: string | null;
+    isGalactic: boolean | null;
+    currentOrder: number | null;
+    visibleTileCount: number;
+    activeTileCount: number;
+    cachedTileCount: number;
+    cacheSize: number;
+    readyTileCount: number;
+    loadingTileCount: number;
+};

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.d.ts

@@ -32,6 +32,7 @@ export default class Tile {
     constructor(tileno: number, order: number, hips: HiPS, tileBuffer: TileBuffer, webgl: WebGL2RenderingContext, visibleTileManager: VisibleTilesManager);
     destroyIntervals(): void;
     getReadyState(): boolean;
+    isLoading(): boolean;
     get cacheTime0(): number | undefined;
     resetCacheTime0(): void;
     setCacheTime0(): void;

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';
@@ -53,6 +65,9 @@ export default class Tile {
     getReadyState() {
         return this._ready;
     }
+    isLoading() {
+        return !this._ready && !this._abort;
+    }
     get cacheTime0() {
         return this._cacheTime0;
     }

package/lib-esm/model/hips/TileBuffer.d.ts

@@ -35,4 +35,9 @@ export declare class TileBuffer {
     private key;
     /** Optional: call to stop internal timers if you dispose this buffer. */
     dispose(): void;
+    get size(): number;
+    get activeTileCount(): number;
+    get cachedTileCount(): number;
+    get readyTileCount(): number;
+    get loadingTileCount(): number;
 }

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 {
@@ -142,6 +154,55 @@ export class TileBuffer {
     dispose() {
         window.clearInterval(this._cleanerId);
     }
+    get size() {
+        return this._tiles.size + this._cachedTiles.size + this._galTiles.size + this._galCachedTiles.size;
+    }
+    get activeTileCount() {
+        return this._tiles.size + this._galTiles.size;
+    }
+    get cachedTileCount() {
+        return this._cachedTiles.size + this._galCachedTiles.size;
+    }
+    get readyTileCount() {
+        let count = 0;
+        for (const tile of this._tiles.values()) {
+            if (tile.getReadyState())
+                count++;
+        }
+        for (const tile of this._galTiles.values()) {
+            if (tile.getReadyState())
+                count++;
+        }
+        for (const tile of this._cachedTiles.values()) {
+            if (tile.getReadyState())
+                count++;
+        }
+        for (const tile of this._galCachedTiles.values()) {
+            if (tile.getReadyState())
+                count++;
+        }
+        return count;
+    }
+    get loadingTileCount() {
+        let count = 0;
+        for (const tile of this._tiles.values()) {
+            if (tile.isLoading())
+                count++;
+        }
+        for (const tile of this._galTiles.values()) {
+            if (tile.isLoading())
+                count++;
+        }
+        for (const tile of this._cachedTiles.values()) {
+            if (tile.isLoading())
+                count++;
+        }
+        for (const tile of this._galCachedTiles.values()) {
+            if (tile.isLoading())
+                count++;
+        }
+        return count;
+    }
 }
 // Singleton (kept for compatibility with your original export)
 // export const newTileBuffer = new TileBuffer()