astro-viewer 3.7.0 → 3.9.0

package/dist/astroviewer.cjs

@@ -3627,6 +3627,7 @@ class AstroSphere {
     pointerDownY = null;
     pointerDownAt = 0;
     _activeHiPS = null;
+    _activeHiPSLayers = [];
     _activeXYZ2 = null;
     _activeMeshHiPS = null;
     _activeBaseLayer = null;
@@ -4129,12 +4130,84 @@ class AstroSphere {
         }
         this._activeHiPS.changeFormat(format);
     }
+    setHiPSFITSScaleFunction(scaleFunction, scaleParam) {
+        if (!this._activeHiPS) {
+            throw new Error("No active HiPS.");
+        }
+        this._activeHiPS.setFITSScaleFunction(scaleFunction, scaleParam);
+    }
+    getActiveHiPSFITSStretch() {
+        return this._activeHiPS?.fitsStretch ?? null;
+    }
+    setHiPSFITSRangeMode(rangeMode) {
+        if (!this._activeHiPS) {
+            throw new Error("No active HiPS.");
+        }
+        this._activeHiPS.setFITSRangeMode(rangeMode);
+    }
+    createHiPS(hipsDescriptor) {
+        return new HiPS_js_1.HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
+    }
     activateHiPS(hipsDescriptor) {
-        if (this._activeHiPS) {
-            this._healpixGrid.visibleTilesManager.tileBuffer.removeHiPS(this._activeHiPS);
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        for (const hips of this._activeHiPSLayers) {
+            tileBuffer.removeHiPS(hips);
+        }
+        this._activeHiPSLayers = [];
+        const hips = this.createHiPS(hipsDescriptor);
+        this._activeHiPSLayers.push(hips);
+        this._activeHiPS = hips;
+        this._activeBaseLayer = "hips";
+        return hips;
+    }
+    setHiPSOpacity(hips, opacity) {
+        if (!this._activeHiPSLayers.includes(hips)) {
+            throw new Error("HiPS layer is not active in this AstroSphere.");
+        }
+        hips.setOpacity(opacity);
+    }
+    addHiPS(hipsDescriptor) {
+        const normalizeURL = (url) => String(url).replace(/\/+$/, "");
+        const descriptorURL = normalizeURL(hipsDescriptor.url);
+        const existing = this._activeHiPSLayers.find((hips) => normalizeURL(hips.baseURL) === descriptorURL);
+        if (existing) {
+            throw new Error(`HiPS already active: ${String(hipsDescriptor.url)}`);
         }
-        this._activeHiPS = new HiPS_js_1.HiPS(1, [0.0, 0.0, 0.0], 0, 0, hipsDescriptor, this._webgl, this._healpixGrid);
+        const hips = this.createHiPS(hipsDescriptor);
+        this._activeHiPSLayers.push(hips);
+        this._activeHiPS = hips;
         this._activeBaseLayer = "hips";
+        return hips;
+    }
+    removeHiPS(hips) {
+        const index = this._activeHiPSLayers.indexOf(hips);
+        if (index === -1) {
+            return;
+        }
+        this._healpixGrid.visibleTilesManager.tileBuffer.removeHiPS(hips);
+        this._activeHiPSLayers.splice(index, 1);
+        if (this._activeHiPSLayers.length === 0) {
+            this._activeHiPS = null;
+            if (this._activeBaseLayer === "hips") {
+                this._activeBaseLayer = null;
+            }
+            return;
+        }
+        if (this._activeHiPS === hips) {
+            this._activeHiPS =
+                this._activeHiPSLayers[this._activeHiPSLayers.length - 1];
+        }
+    }
+    removeAllHiPS() {
+        const tileBuffer = this._healpixGrid.visibleTilesManager.tileBuffer;
+        for (const hips of this._activeHiPSLayers) {
+            tileBuffer.removeHiPS(hips);
+        }
+        this._activeHiPSLayers = [];
+        this._activeHiPS = null;
+        if (this._activeBaseLayer === "hips") {
+            this._activeBaseLayer = null;
+        }
     }
     activateXYZ(config) {
         this.activateXYZ2(new XYZMapDescriptor_js_1.XYZMapDescriptor(config.name ?? "XYZ Earth2 Layer", config.urlTemplate, config.minZoom ?? 0, config.maxZoom ?? 8, config.segmentsPerSide ?? 48, config.maxCachedTiles ?? 384, 8, config.urlResolver));
@@ -4367,6 +4440,16 @@ class AstroSphere {
     get activeHiPS() {
         return this._activeHiPS;
     }
+    get activeHiPSLayers() {
+        return this._activeHiPSLayers;
+    }
+    setActiveHiPS(hips) {
+        if (!this._activeHiPSLayers.includes(hips)) {
+            throw new Error("HiPS layer is not active in this AstroSphere.");
+        }
+        this._activeHiPS = hips;
+        this._activeBaseLayer = "hips";
+    }
     get activeXYZ() {
         return this._activeXYZ2;
     }
@@ -4526,8 +4609,9 @@ class AstroSphere {
         this._webgl.enable(this._webgl.CULL_FACE);
         this._webgl.cullFace(Global_js_1.default.insideSphere ? this._webgl.FRONT : this._webgl.BACK);
         this._webgl.blendFunc(this._webgl.SRC_ALPHA, this._webgl.ONE_MINUS_SRC_ALPHA);
-        if (this._activeBaseLayer === "hips" && this._activeHiPS) {
-            const visibleOrder = Math.min(this._healpixGrid.visibleorder, this._activeHiPS.maxOrder);
+        if (this._activeBaseLayer === "hips" && this._activeHiPSLayers.length > 0) {
+            const maxHiPSOrder = Math.max(...this._activeHiPSLayers.map((hips) => hips.maxOrder));
+            const visibleOrder = Math.min(this._healpixGrid.visibleorder, maxHiPSOrder);
             this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         }
         if (this._activeBaseLayer === "meships" && this._activeMeshHiPS) {
@@ -4552,6 +4636,11 @@ class AstroSphere {
             cameraMoving: cameraMovingForGrid,
         };
         if (this._activeBaseLayer === "hips") {
+            for (const hips of this._activeHiPSLayers) {
+                if (hips !== this._activeHiPS) {
+                    hips.draw(skyEntityDrawInput);
+                }
+            }
             this._activeHiPS?.draw(skyEntityDrawInput);
         }
         if (this._activeBaseLayer === "xyz") {
@@ -4886,21 +4975,56 @@ class AstroViewer {
         this.astroSphere.activateMeshHiPS(desc);
         return desc.name;
     }
-    // changeColorMap(hips: HiPS, colorMapName: ColorMapName) {
+    setActiveHiPS(hips) {
+        this.astroSphere.setActiveHiPS(hips);
+    }
+    setHiPSOpacity(hips, opacity) {
+        this.astroSphere.setHiPSOpacity(hips, opacity);
+    }
     changeColorMap(colorMapName) {
         const colorMap = ColorMaps_js_1.default[colorMapName];
-        // hips.changeColorMap(colorMap)
         this.astroSphere.changeColorMap(colorMap);
     }
     changeCustomColorMap(colorMap) {
         this.astroSphere.changeColorMap(colorMap);
     }
+    addHiPS(hipsDescriptor) {
+        return this.astroSphere.addHiPS(hipsDescriptor);
+    }
+    async addHiPSFromUrl(baseUrl) {
+        const hipsUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+        const resp = await fetch(hipsUrl + "properties");
+        if (!resp.ok) {
+            throw new Error(`HTTP ${resp.status} fetching properties`);
+        }
+        const propsText = await resp.text();
+        const desc = new HiPSDescriptor_js_1.HiPSDescriptor(propsText, hipsUrl);
+        return this.astroSphere.addHiPS(desc);
+    }
+    removeHiPS(hips) {
+        this.astroSphere.removeHiPS(hips);
+    }
+    removeAllHiPS() {
+        this.astroSphere.removeAllHiPS();
+    }
+    getActiveHiPSLayers() {
+        return this.astroSphere.activeHiPSLayers;
+    }
     getActiveHiPS() {
         return this.astroSphere.activeHiPS;
     }
     changeHiPSFormat(format) {
         this.astroSphere.changeHiPSFormat(format);
     }
+    setHiPSFITSScaleFunction(scaleFunction, scaleParam) {
+        this.astroSphere.setHiPSFITSScaleFunction(scaleFunction, scaleParam);
+    }
+    getActiveHiPSFITSStretch() {
+        return this.astroSphere.getActiveHiPSFITSStretch();
+    }
+    setHiPSFITSRangeMode(rangeMode) {
+        this.astroSphere.setHiPSFITSRangeMode(rangeMode);
+    }
     getActiveHiPSFormats() {
         return this.astroSphere.activeHiPS?.availableFormats ?? [];
     }
@@ -5767,7 +5891,6 @@ var Source_js_1 = __webpack_require__(146);
 Object.defineProperty(exports, "Source", ({ enumerable: true, get: function () { return Source_js_1.Source; } }));
 var Footprint_js_1 = __webpack_require__(2475);
 Object.defineProperty(exports, "Footprint", ({ enumerable: true, get: function () { return Footprint_js_1.Footprint; } }));
-console.log('astroviewer UMD loaded');
 
 
 /***/ },
@@ -11533,8 +11656,14 @@ class HealpixGrid extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         // FIX: pass model & pMatrix to match FoVUtils TS signature
         const center = FoVUtils_js_1.FoVUtils.getCenterJ2000(gl.canvas, this, this._webgl, camera, pMatrix);
         const fovMin = (this.getMinFoV() * Math.PI) / 180 / 2;
+        const visibleHealpix = Global_js_1.default.getHealpix(this._visibleorder);
+        const maxPixel = visibleHealpix.getNPix();
         for (let p = 0; p < pixels.length; p++) {
-            const pixCenter = Global_js_1.default.getHealpix(this._visibleorder).pix2vec(pixels[p]);
+            const pixel = pixels[p];
+            if (!Number.isInteger(pixel) || pixel < 0 || pixel >= maxPixel) {
+                continue;
+            }
+            const pixCenter = visibleHealpix.pix2vec(pixel);
             // const pixCenter = (global.getHealpix(global.order).pix2vec(pixels[p]) as BoundVec);
             const point = new Point_js_1.Point({ x: pixCenter.x, y: pixCenter.y, z: pixCenter.z }, CoordsType_js_1.CoordsType.CARTESIAN);
             const distance = GeomUtils_js_1.default.orthodromicDistance(center, point);
@@ -11915,7 +12044,7 @@ class AllSky {
     _baseurl;
     _isGalacticHips;
     _order = 3;
-    opacity = 1.0;
+    // public opacity = 1.0;
     _hipsShaderIndex = 0;
     _texture = null;
     _image;
@@ -11962,6 +12091,7 @@ class AllSky {
     async loadFits() {
         try {
             this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this._hips.observeFITSDataRange(this._fitsTile);
             this.textureLoaded();
             this.initModelBuffer();
             this._textureLoaded = true;
@@ -12006,30 +12136,7 @@ class AllSky {
         }
     }
     getFitsDataRange() {
-        const hipsRange = this._hips.dataRange;
-        if (hipsRange.min !== undefined &&
-            hipsRange.max !== undefined &&
-            Number.isFinite(hipsRange.min) &&
-            Number.isFinite(hipsRange.max) &&
-            hipsRange.max > hipsRange.min) {
-            return {
-                min: hipsRange.min,
-                max: hipsRange.max,
-            };
-        }
-        const fits = this._fitsTile;
-        if (fits &&
-            fits.dataMin !== null &&
-            fits.dataMax !== null &&
-            Number.isFinite(fits.dataMin) &&
-            Number.isFinite(fits.dataMax) &&
-            fits.dataMax > fits.dataMin) {
-            return {
-                min: fits.dataMin,
-                max: fits.dataMax,
-            };
-        }
-        return null;
+        return this._hips.getFITSDisplayRange(this._fitsTile);
     }
     initModelBuffer() {
         const gl = this._webgl;
@@ -12143,7 +12250,7 @@ class AllSky {
                 console.error(`[AllSky] No display range available for FITS atlas ${this._texurl}`);
                 return false;
             }
-            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max, this._hips.fitsStretch.scaleFunctionIndex, this._hips.fitsStretch.scaleParam);
         }
         else {
             this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
@@ -12156,9 +12263,10 @@ class AllSky {
         gl.activeTexture(gl.TEXTURE0 + this._hipsShaderIndex);
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
         const factorLocation = this._hipsShaderProgram.locations.textureAlpha[this._hipsShaderIndex];
-        if (factorLocation) {
-            gl.uniform1f(factorLocation, this.opacity);
+        if (factorLocation !== null) {
+            gl.uniform1f(factorLocation, 1.0);
         }
+        this._hipsShaderProgram.setLayerOpacity(this._hips.opacity);
         gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexPositionBuffer);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.vertexIndexBuffer);
         gl.vertexAttribPointer(
@@ -12186,13 +12294,13 @@ class AllSky {
         const allSkyTiles2Skip = [];
         for (let i = 0; i < visibleTiles.length; i++) {
             const tileno = visibleTiles[i];
+            if (!this._hips.intersectsCoverage(childrenOrder, tileno)) {
+                allSkyTiles2Skip.push(tileno);
+                continue;
+            }
             const childTile = this._isGalacticHips
                 ? this._tileBuffer.getGalTile(tileno, childrenOrder, this._hips)
                 : this._tileBuffer.getTile(tileno, childrenOrder, this._hips);
-            // const childTile = this._isGalacticHips
-            //   ? newTileBuffer.getGalTile(tileno, childrenOrder, this._hips)
-            //   : newTileBuffer.getTile(tileno, childrenOrder, this._hips)
-            // childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx)
             childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
             if (childTile.getReadyState()) {
                 allSkyTiles2Skip.push(tileno);
@@ -12279,6 +12387,7 @@ class AncestorTile {
     async loadFits() {
         try {
             this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this._hips.observeFITSDataRange(this._fitsTile);
             this.textureLoaded();
             const fits = this._fitsTile;
             if (!fits) {
@@ -12336,30 +12445,7 @@ class AncestorTile {
         }
     }
     getFitsDataRange() {
-        const hipsRange = this._hips.dataRange;
-        if (hipsRange.min !== undefined &&
-            hipsRange.max !== undefined &&
-            Number.isFinite(hipsRange.min) &&
-            Number.isFinite(hipsRange.max) &&
-            hipsRange.max > hipsRange.min) {
-            return {
-                min: hipsRange.min,
-                max: hipsRange.max,
-            };
-        }
-        const fits = this._fitsTile;
-        if (fits &&
-            fits.dataMin !== null &&
-            fits.dataMax !== null &&
-            Number.isFinite(fits.dataMin) &&
-            Number.isFinite(fits.dataMax) &&
-            fits.dataMax > fits.dataMin) {
-            return {
-                min: fits.dataMin,
-                max: fits.dataMax,
-            };
-        }
-        return null;
+        return this._hips.getFITSDisplayRange(this._fitsTile);
     }
     initModelBuffer() {
         const gl = this._webgl;
@@ -12459,7 +12545,7 @@ class AncestorTile {
                 console.error(`[AncestorTile] No display range available for FITS tile ${this._texurl}`);
                 return false;
             }
-            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+            this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max, this._hips.fitsStretch.scaleFunctionIndex, this._hips.fitsStretch.scaleParam);
         }
         else {
             this._hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
@@ -12492,16 +12578,21 @@ class AncestorTile {
             return;
         for (let c = 0; c < 4; c++) {
             const childTileNo = (this._tileno << 2) + c;
+            if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                continue;
+            }
             const visibleChildren = visibleTilesMap.get(childrenOrder);
             if (visibleChildren.includes(childTileNo)) {
+                if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                    quadrantsToDraw.delete(c);
+                    continue;
+                }
                 const childTile = this._isGalacticHips
                     ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
                     : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
-                // childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx)
                 childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
                 if (childTile.getReadyState()) {
                     quadrantsToDraw.delete(c);
-                    // quadrantsToDraw.delete((childTile as any)._tileno - (this._tileno << 2))
                 }
             }
         }
@@ -12531,6 +12622,9 @@ var __webpack_unused_export__;
 __webpack_unused_export__ = ({ value: true });
 exports.loadFitsTile = loadFitsTile;
 const jsfitsio_1 = __webpack_require__(4971);
+const ROBUST_SAMPLE_COUNT = 8192;
+const ROBUST_LOW_PERCENTILE = 0.005;
+const ROBUST_HIGH_PERCENTILE = 0.995;
 async function loadFitsTile(url) {
     const fitsFile = await jsfitsio_1.FITSParser.loadFITSFile(url);
     if (!fitsFile?.primaryHDU) {
@@ -12560,22 +12654,57 @@ async function loadFitsTile(url) {
     const dataMin = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.DATAMIN);
     const dataMax = getNumericHeaderValue(image.header, jsfitsio_1.FITSHeaderManager.DATAMAX);
     const pixels = new Float32Array(data.length);
+    let physicalMin = null;
+    let physicalMax = null;
+    const robustSamples = [];
+    const sampleStep = Math.max(1, Math.floor(data.length / ROBUST_SAMPLE_COUNT));
     for (let i = 0; i < data.length; i++) {
         const rawValue = data[i];
         if (!Number.isFinite(rawValue) || (blank !== null && rawValue === blank)) {
             pixels[i] = Number.NaN;
             continue;
         }
-        pixels[i] = rawValue * bscale + bzero;
+        const physicalValue = rawValue * bscale + bzero;
+        pixels[i] = physicalValue;
+        if (Number.isFinite(physicalValue)) {
+            physicalMin =
+                physicalMin === null ? physicalValue : Math.min(physicalMin, physicalValue);
+            physicalMax =
+                physicalMax === null ? physicalValue : Math.max(physicalMax, physicalValue);
+            if (i % sampleStep === 0) {
+                robustSamples.push(physicalValue);
+            }
+        }
     }
+    const robustRange = computeRobustRange(robustSamples);
     return {
         width,
         height,
         pixels,
         dataMin,
         dataMax,
+        physicalMin,
+        physicalMax,
+        robustMin: robustRange?.min ?? null,
+        robustMax: robustRange?.max ?? null,
     };
 }
+function computeRobustRange(samples) {
+    if (samples.length === 0) {
+        return null;
+    }
+    samples.sort((a, b) => a - b);
+    const min = percentile(samples, ROBUST_LOW_PERCENTILE);
+    const max = percentile(samples, ROBUST_HIGH_PERCENTILE);
+    if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
+        return null;
+    }
+    return { min, max };
+}
+function percentile(sortedValues, p) {
+    const index = Math.min(sortedValues.length - 1, Math.max(0, Math.round((sortedValues.length - 1) * p)));
+    return sortedValues[index];
+}
 function getNumericHeaderValue(header, key) {
     const item = header.findById(key);
     if (!item) {
@@ -12778,10 +12907,29 @@ const FoVHelper_js_1 = __webpack_require__(229);
 const ColorMaps_js_1 = __importDefault(__webpack_require__(619));
 const AncestorTile_js_1 = __importDefault(__webpack_require__(2885));
 const AllSky_js_1 = __importDefault(__webpack_require__(2368));
+const HiPSCoverage_js_1 = __webpack_require__(9912);
+const FITS_SCALE_FUNCTION_INDEX = {
+    linear: 0,
+    sqrt: 1,
+    log: 2,
+    asinh: 3,
+    gamma: 4,
+};
+const DEFAULT_FITS_SCALE_PARAM = {
+    linear: 1,
+    sqrt: 1,
+    log: 100,
+    asinh: 10,
+    gamma: 0.5,
+};
+const MAX_ROBUST_TILE_RANGES = 512;
 class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     _ancestorTiles;
     _allSkyTile;
     _descriptor;
+    _coverage;
+    _coverageResolved = false;
+    _opacity = 1.0;
     _format;
     _baseurl;
     _maxorder;
@@ -12791,6 +12939,13 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     samplerIdx = 0;
     colorMapIdx = 0;
     colorMap = ColorMaps_js_1.default["native"];
+    _fitsStretch = {
+        scaleFunction: "linear",
+        scaleFunctionIndex: FITS_SCALE_FUNCTION_INDEX.linear,
+        scaleParam: DEFAULT_FITS_SCALE_PARAM.linear,
+        rangeMode: "robust",
+    };
+    _robustFITSRanges = [];
     _healpixGrid;
     // exposed read-only helpers
     get maxOrder() {
@@ -12820,6 +12975,17 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         this._baseurl = descriptor.url;
         this._maxorder = descriptor.maxOrder;
         this._minorder = descriptor.minOrder;
+        this._coverage = new HiPSCoverage_js_1.HiPSCoverage();
+        void this._coverage
+            .load(this._baseurl)
+            .then(() => {
+            this._coverageResolved = true;
+        })
+            .catch((error) => {
+            console.warn(`[HiPS] Coverage unavailable for ${this._baseurl}; continuing without MOC filtering.`, error);
+            this._coverage.clear();
+            this._coverageResolved = true;
+        });
         if (this.isGalacticHips) {
             this._healpixGrid.visibleTilesManager.tileBuffer.addGalHiPS(this);
         }
@@ -12842,6 +13008,31 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         this._allSky = true;
         this.initBaseTiles();
     }
+    setOpacity(opacity) {
+        if (!Number.isFinite(opacity)) {
+            throw new Error(`Invalid HiPS opacity: ${opacity}`);
+        }
+        this._opacity = Math.min(1, Math.max(0, opacity));
+    }
+    get opacity() {
+        return this._opacity;
+    }
+    intersectsCoverage(order, pixel) {
+        /*
+         * While Moc.fits is being resolved, do not start tile requests.
+         *
+         * Once loading has completed:
+         * - valid MOC -> filter using coverage
+         * - unavailable MOC -> HiPSCoverage is cleared and normal loading resumes
+         */
+        if (!this._coverageResolved) {
+            return false;
+        }
+        return this._coverage.intersectsTile(order, pixel);
+    }
+    get coverageLoaded() {
+        return this._coverage.loaded;
+    }
     initBaseTiles() {
         this._ancestorTiles = [];
         this._allSkyTile = null;
@@ -12990,6 +13181,137 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     get dataRange() {
         return this._descriptor.dataRange;
     }
+    get fitsStretch() {
+        return this._fitsStretch;
+    }
+    setFITSScaleFunction(scaleFunction, scaleParam) {
+        const scaleFunctionIndex = FITS_SCALE_FUNCTION_INDEX[scaleFunction];
+        if (scaleFunctionIndex === undefined) {
+            throw new Error(`Unsupported FITS scale function: ${scaleFunction}`);
+        }
+        const defaultParam = DEFAULT_FITS_SCALE_PARAM[scaleFunction];
+        const param = scaleParam ?? defaultParam;
+        if (!Number.isFinite(param) || param <= 0) {
+            throw new Error(`Invalid FITS scale parameter: ${param}`);
+        }
+        this._fitsStretch = {
+            ...this._fitsStretch,
+            scaleFunction,
+            scaleFunctionIndex,
+            scaleParam: param,
+        };
+    }
+    setFITSRangeMode(rangeMode) {
+        if (rangeMode !== "robust" && rangeMode !== "hips" && rangeMode !== "tile") {
+            throw new Error(`Unsupported FITS range mode: ${rangeMode}`);
+        }
+        this._fitsStretch = {
+            ...this._fitsStretch,
+            rangeMode,
+        };
+    }
+    observeFITSDataRange(fits) {
+        if (fits.robustMin === null ||
+            fits.robustMax === null ||
+            !Number.isFinite(fits.robustMin) ||
+            !Number.isFinite(fits.robustMax) ||
+            fits.robustMax <= fits.robustMin) {
+            return;
+        }
+        this._robustFITSRanges.push({
+            min: fits.robustMin,
+            max: fits.robustMax,
+        });
+        if (this._robustFITSRanges.length > MAX_ROBUST_TILE_RANGES) {
+            this._robustFITSRanges.shift();
+        }
+    }
+    getFITSDisplayRange(fits) {
+        const hipsRange = this.getHiPSDataRange();
+        if (this._fitsStretch.rangeMode === "hips" && hipsRange) {
+            return hipsRange;
+        }
+        if (this._fitsStretch.rangeMode === "robust") {
+            const robustRange = this.getRobustFITSRange() ?? this.getTileRobustRange(fits);
+            if (robustRange) {
+                return robustRange;
+            }
+        }
+        const tileRange = this.getTilePhysicalRange(fits) ?? this.getTileHeaderRange(fits);
+        if (tileRange) {
+            return tileRange;
+        }
+        return hipsRange;
+    }
+    getHiPSDataRange() {
+        const hipsRange = this.dataRange;
+        if (hipsRange.min !== undefined &&
+            hipsRange.max !== undefined &&
+            Number.isFinite(hipsRange.min) &&
+            Number.isFinite(hipsRange.max) &&
+            hipsRange.max > hipsRange.min) {
+            return {
+                min: hipsRange.min,
+                max: hipsRange.max,
+            };
+        }
+        return null;
+    }
+    getRobustFITSRange() {
+        if (this._robustFITSRanges.length === 0) {
+            return null;
+        }
+        const lows = this._robustFITSRanges.map((range) => range.min).sort((a, b) => a - b);
+        const highs = this._robustFITSRanges.map((range) => range.max).sort((a, b) => a - b);
+        const min = lows[Math.floor((lows.length - 1) * 0.1)];
+        const max = highs[Math.ceil((highs.length - 1) * 0.9)];
+        if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
+            return null;
+        }
+        return { min, max };
+    }
+    getTileRobustRange(fits) {
+        if (fits &&
+            fits.robustMin !== null &&
+            fits.robustMax !== null &&
+            Number.isFinite(fits.robustMin) &&
+            Number.isFinite(fits.robustMax) &&
+            fits.robustMax > fits.robustMin) {
+            return {
+                min: fits.robustMin,
+                max: fits.robustMax,
+            };
+        }
+        return null;
+    }
+    getTilePhysicalRange(fits) {
+        if (fits &&
+            fits.physicalMin !== null &&
+            fits.physicalMax !== null &&
+            Number.isFinite(fits.physicalMin) &&
+            Number.isFinite(fits.physicalMax) &&
+            fits.physicalMax > fits.physicalMin) {
+            return {
+                min: fits.physicalMin,
+                max: fits.physicalMax,
+            };
+        }
+        return null;
+    }
+    getTileHeaderRange(fits) {
+        if (fits &&
+            fits.dataMin !== null &&
+            fits.dataMax !== null &&
+            Number.isFinite(fits.dataMin) &&
+            Number.isFinite(fits.dataMax) &&
+            fits.dataMax > fits.dataMin) {
+            return {
+                min: fits.dataMin,
+                max: fits.dataMax,
+            };
+        }
+        return null;
+    }
     getCurrentHealpixOrder() {
         return this._visibleorder;
     }
@@ -13053,6 +13375,183 @@ class HiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
 exports.HiPS = HiPS;
 
 
+/***/ },
+
+/***/ 9912
+(__unused_webpack_module, exports, __webpack_require__) {
+
+var __webpack_unused_export__;
+
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-AstroViewer-Commercial
+ *
+ * AstroViewer is dual-licensed under the GNU Affero General Public License
+ * version 3 and a separate commercial license.
+ *
+ * See LICENSE.md, LICENSE-AGPL.md, and LICENSE-COMMERCIAL.md for details.
+ */
+__webpack_unused_export__ = ({ value: true });
+exports.HiPSCoverage = void 0;
+const jsfitsio_1 = __webpack_require__(4971);
+class HiPSCoverage {
+    intersec(intersec, arg1) {
+        throw new Error("Method not implemented.");
+    }
+    ises(ises, expents, of, arg3) {
+        throw new Error("Method not implemented.");
+    }
+    intersexpect(co, t, expe, arg3) {
+        throw new Error("Method not implemented.");
+    }
+    intersectsT19(intersectsT19, arg1) {
+        throw new Error("Method not implemented.");
+    }
+    _maxOrder = 0;
+    _intervals = [];
+    _loaded = false;
+    get loaded() {
+        return this._loaded;
+    }
+    get maxOrder() {
+        return this._maxOrder;
+    }
+    get intervalCount() {
+        return this._intervals.length;
+    }
+    clear() {
+        this._maxOrder = 0;
+        this._intervals = [];
+        this._loaded = false;
+    }
+    async load(baseUrl) {
+        const baseUrlString = baseUrl instanceof URL ? baseUrl.href : String(baseUrl);
+        const normalizedBaseUrl = baseUrlString.endsWith("/")
+            ? baseUrlString
+            : `${baseUrlString}/`;
+        await this.loadMoc(`${normalizedBaseUrl}Moc.fits`);
+    }
+    async loadMoc(mocUrl) {
+        this.clear();
+        const fits = await jsfitsio_1.FITSParser.loadFITSFile(mocUrl);
+        if (!fits) {
+            throw new Error("Unable to load HiPS Moc.fits");
+        }
+        const mocHDU = fits.hdus.find((hdu) => hdu instanceof jsfitsio_1.BinaryTableHDU);
+        if (!(mocHDU instanceof jsfitsio_1.BinaryTableHDU)) {
+            throw new Error("HiPS Moc.fits does not contain a BINTABLE HDU.");
+        }
+        const mocOrderItem = mocHDU.header.findById("MOCORDER");
+        if (!mocOrderItem) {
+            throw new Error("HiPS Moc.fits does not define MOCORDER.");
+        }
+        const maxOrder = Number(mocOrderItem.value);
+        if (!Number.isInteger(maxOrder) || maxOrder < 0) {
+            throw new Error(`Invalid MOCORDER value: ${mocOrderItem.value}`);
+        }
+        this._maxOrder = maxOrder;
+        const intervals = [];
+        for (let row = 0; row < mocHDU.rowCount; row++) {
+            const rawUniq = mocHDU.getCell(row, "UNIQ");
+            if (typeof rawUniq !== "number" ||
+                !Number.isInteger(rawUniq) ||
+                rawUniq < 4) {
+                throw new Error(`Invalid MOC UNIQ value at row ${row}: ${String(rawUniq)}`);
+            }
+            const { order, pixel } = HiPSCoverage.decodeUniq(rawUniq);
+            if (order > this._maxOrder) {
+                throw new Error(`MOC cell order ${order} exceeds MOCORDER ${this._maxOrder}.`);
+            }
+            const scale = 4 ** (this._maxOrder - order);
+            intervals.push({
+                first: pixel * scale,
+                last: (pixel + 1) * scale - 1,
+            });
+        }
+        this._intervals = HiPSCoverage.mergeIntervals(intervals);
+        this._loaded = true;
+    }
+    intersectsTile(order, pixel) {
+        if (!this._loaded) {
+            return true;
+        }
+        if (!Number.isInteger(order) ||
+            order < 0 ||
+            !Number.isInteger(pixel) ||
+            pixel < 0) {
+            return false;
+        }
+        let first;
+        let last;
+        if (order <= this._maxOrder) {
+            const scale = 4 ** (this._maxOrder - order);
+            first = pixel * scale;
+            last = (pixel + 1) * scale - 1;
+        }
+        else {
+            /*
+             * At orders finer than the MOC resolution, reduce the tile
+             * to its ancestor at MOCORDER.
+             */
+            const shift = 2 * (order - this._maxOrder);
+            const ancestor = Math.floor(pixel / 2 ** shift);
+            first = ancestor;
+            last = ancestor;
+        }
+        return this.intersectsInterval(first, last);
+    }
+    intersectsInterval(first, last) {
+        let low = 0;
+        let high = this._intervals.length - 1;
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const interval = this._intervals[middle];
+            if (interval.last < first) {
+                low = middle + 1;
+                continue;
+            }
+            if (interval.first > last) {
+                high = middle - 1;
+                continue;
+            }
+            return true;
+        }
+        return false;
+    }
+    static decodeUniq(uniq) {
+        let order = 0;
+        while (4 ** (order + 2) <= uniq) {
+            order++;
+        }
+        const base = 4 ** (order + 1);
+        return {
+            order,
+            pixel: uniq - base,
+        };
+    }
+    static mergeIntervals(intervals) {
+        if (intervals.length === 0) {
+            return [];
+        }
+        intervals.sort((a, b) => a.first - b.first);
+        const merged = [{ ...intervals[0] }];
+        for (let i = 1; i < intervals.length; i++) {
+            const current = intervals[i];
+            const previous = merged[merged.length - 1];
+            if (current.first <= previous.last + 1) {
+                previous.last = Math.max(previous.last, current.last);
+            }
+            else {
+                merged.push({ ...current });
+            }
+        }
+        return merged;
+    }
+}
+exports.HiPSCoverage = HiPSCoverage;
+
+
 /***/ },
 
 /***/ 5087
@@ -13254,7 +13753,7 @@ class Tile {
     vertexIndices = new Uint16Array();
     vertexIndexBuffer;
     _tileBuffer;
-    opacity = 1.0;
+    // public opacity = 1.0;
     _webgl;
     _visibleTileManager;
     // private _hipsShaderProgram
@@ -13323,6 +13822,7 @@ class Tile {
     async loadFits() {
         try {
             this._fitsTile = await (0, FitsTileLoader_js_1.loadFitsTile)(this._texurl);
+            this._hips.observeFITSDataRange(this._fitsTile);
             this._ready = true;
         }
         catch (error) {
@@ -13461,30 +13961,7 @@ class Tile {
         gl.bufferData(gl.ARRAY_BUFFER, this.vertexPosition[qidx], gl.STATIC_DRAW);
     }
     getFitsDataRange() {
-        const hipsRange = this._hips.dataRange;
-        if (hipsRange.min !== undefined &&
-            hipsRange.max !== undefined &&
-            Number.isFinite(hipsRange.min) &&
-            Number.isFinite(hipsRange.max) &&
-            hipsRange.max > hipsRange.min) {
-            return {
-                min: hipsRange.min,
-                max: hipsRange.max,
-            };
-        }
-        const fits = this._fitsTile;
-        if (fits &&
-            fits.dataMin !== null &&
-            fits.dataMax !== null &&
-            Number.isFinite(fits.dataMin) &&
-            Number.isFinite(fits.dataMax) &&
-            fits.dataMax > fits.dataMin) {
-            return {
-                min: fits.dataMin,
-                max: fits.dataMax,
-            };
-        }
-        return null;
+        return this._hips.getFITSDisplayRange(this._fitsTile);
     }
     get inView() {
         return this._inView;
@@ -13588,7 +14065,7 @@ class Tile {
                 console.error(`[Tile] No display range available for FITS tile ${this._texurl}`);
                 return;
             }
-            hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max);
+            hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, true, range.min, range.max, this._hips.fitsStretch.scaleFunctionIndex, this._hips.fitsStretch.scaleParam);
         }
         else {
             hipsShaderProgram.setTextureDataMode(this._hipsShaderIndex, false);
@@ -13600,8 +14077,9 @@ class Tile {
         gl.bindTexture(gl.TEXTURE_2D, this._texture);
         const factorLocation = locations.textureAlpha[this._hipsShaderIndex];
         if (factorLocation) {
-            gl.uniform1f(factorLocation, this.opacity);
+            gl.uniform1f(factorLocation, 1.0);
         }
+        hipsShaderProgram.setLayerOpacity(this._hips.opacity);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.vertexIndexBuffer);
         const elemno = this.vertexIndices.length;
         const indexType = this.vertexIndices instanceof Uint32Array
@@ -13625,6 +14103,9 @@ class Tile {
             const childTileNo = (this._tileno << 2) + c;
             const list = visibleTilesMap.get(childrenOrder);
             if (list.includes(childTileNo)) {
+                if (!this._hips.intersectsCoverage(childrenOrder, childTileNo)) {
+                    continue;
+                }
                 const childTile = this._isGalacticHips
                     ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
                     : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
@@ -13715,6 +14196,9 @@ class TileBuffer {
             if (order > hips.maxOrder) {
                 continue;
             }
+            if (!hips.intersectsCoverage(order, tileno)) {
+                continue;
+            }
             this.getTile(tileno, order, hips);
         }
     }
@@ -13724,6 +14208,9 @@ class TileBuffer {
             if (order > hips.maxOrder) {
                 continue;
             }
+            if (!hips.intersectsCoverage(order, tileno)) {
+                continue;
+            }
             this.getGalTile(tileno, order, hips);
         }
     }
@@ -16423,6 +16910,8 @@ class HiPSShaderProgram {
             textureMode: "uTextureMode",
             dataMin: "uDataMin",
             dataMax: "uDataMax",
+            scaleFunction: "uScaleFunction",
+            scaleParam: "uScaleParam",
         };
         this.gl_attributes = {
             vertex_pos: "aVertexPosition",
@@ -16437,6 +16926,9 @@ class HiPSShaderProgram {
             textureMode: new Array(8).fill(null),
             dataMin: new Array(8).fill(null),
             dataMax: new Array(8).fill(null),
+            scaleFunction: new Array(8).fill(null),
+            scaleParam: new Array(8).fill(null),
+            layerOpacity: null,
             clorMapIdx: null,
             vertexPositionAttribute: -1,
             textureCoordAttribute: -1,
@@ -16452,6 +16944,13 @@ class HiPSShaderProgram {
         gl.useProgram(this._shaderProgram);
         return this._shaderProgram;
     }
+    setLayerOpacity(opacity) {
+        const gl = this._webgl;
+        this.locations.layerOpacity = gl.getUniformLocation(this.shaderProgram, "uLayerOpacity");
+        if (this.locations.layerOpacity !== null) {
+            gl.uniform1f(this.locations.layerOpacity, opacity);
+        }
+    }
     setRuntimeColorMap(colorMap) {
         this._runtimeColorMap = colorMap;
     }
@@ -16562,7 +17061,7 @@ class HiPSShaderProgram {
         }
         gl.useProgram(this.shaderProgram);
     }
-    setTextureDataMode(samplerIndex, fits, min, max) {
+    setTextureDataMode(samplerIndex, fits, min, max, scaleFunction = 0, scaleParam = 1) {
         if (samplerIndex < 0 || samplerIndex >= 8) {
             throw new Error(`Invalid HiPS sampler index: ${samplerIndex}`);
         }
@@ -16583,12 +17082,20 @@ class HiPSShaderProgram {
         }
         const minLocation = this.locations.dataMin[samplerIndex];
         const maxLocation = this.locations.dataMax[samplerIndex];
+        const scaleFunctionLocation = this.locations.scaleFunction[samplerIndex];
+        const scaleParamLocation = this.locations.scaleParam[samplerIndex];
         if (minLocation) {
             gl.uniform1f(minLocation, min);
         }
         if (maxLocation) {
             gl.uniform1f(maxLocation, max);
         }
+        if (scaleFunctionLocation) {
+            gl.uniform1i(scaleFunctionLocation, scaleFunction);
+        }
+        if (scaleParamLocation) {
+            gl.uniform1f(scaleParamLocation, scaleParam);
+        }
     }
     enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx) {
         // const gl = global.gl
@@ -16604,6 +17111,8 @@ class HiPSShaderProgram {
             this.locations.textureMode[i] = gl.getUniformLocation(this.shaderProgram, `uTextureMode${i}`);
             this.locations.dataMin[i] = gl.getUniformLocation(this.shaderProgram, `uDataMin${i}`);
             this.locations.dataMax[i] = gl.getUniformLocation(this.shaderProgram, `uDataMax${i}`);
+            this.locations.scaleFunction[i] = gl.getUniformLocation(this.shaderProgram, `uScaleFunction${i}`);
+            this.locations.scaleParam[i] = gl.getUniformLocation(this.shaderProgram, `uScaleParam${i}`);
             if (this.locations.samplers[i]) {
                 gl.uniform1i(this.locations.samplers[i], i);
             }
@@ -16940,7 +17449,7 @@ class ShaderManager {
     }
     static footprintVS() {
         return `#version 300 es
-    precision highp float;
+    precision mediump float;
 
     layout(location = 0) in vec4 aCatPosition;
 
@@ -16982,10 +17491,11 @@ class ShaderManager {
     }
     static hipsNativeFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
 
     in vec2 vTextureCoord;
 
+    uniform float uLayerOpacity;
     uniform float uFactor0;
     uniform float uFactor1;
     uniform float uFactor2;
@@ -17042,15 +17552,16 @@ class ShaderManager {
           sampleHiPSTexture7(vTextureCoord).rgb * uFactor7;
       }
 
-      fragColor = vec4(finalColor, 1.0);
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
     static hipsGrayscaleFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
 
     in vec2 vTextureCoord;
 
+    uniform float uLayerOpacity;
     uniform float uFactor0;
     uniform float uFactor1;
     uniform float uFactor2;
@@ -17115,12 +17626,14 @@ class ShaderManager {
         finalColor += color7.rgb * uFactor7;
       }
 
-      fragColor = vec4(finalColor, 1.0);
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
     static hipsColorMapFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
+
+    uniform float uLayerOpacity;
 
     in vec2 vTextureCoord;
 
@@ -17214,7 +17727,7 @@ class ShaderManager {
           ) * uFactor7;
       }
 
-      fragColor = vec4(finalColor, 1.0);
+      fragColor = vec4(finalColor, uLayerOpacity);
     }`;
     }
     static hipsSamplerGLSL(index) {
@@ -17223,6 +17736,36 @@ class ShaderManager {
     uniform int uTextureMode${index};
     uniform float uDataMin${index};
     uniform float uDataMax${index};
+    uniform int uScaleFunction${index};
+    uniform float uScaleParam${index};
+
+    float asinhCompat${index}(float value) {
+      return log(value + sqrt(value * value + 1.0));
+    }
+
+    float applyFitsScale${index}(float normalized) {
+      float x = clamp(normalized, 0.0, 1.0);
+
+      if (uScaleFunction${index} == 1) {
+        return sqrt(x);
+      }
+
+      if (uScaleFunction${index} == 2) {
+        float strength = max(uScaleParam${index}, 1.0);
+        return log(1.0 + strength * x) / log(1.0 + strength);
+      }
+
+      if (uScaleFunction${index} == 3) {
+        float strength = max(uScaleParam${index}, 1.0);
+        return asinhCompat${index}(strength * x) / asinhCompat${index}(strength);
+      }
+
+      if (uScaleFunction${index} == 4) {
+        return pow(x, max(uScaleParam${index}, 0.0001));
+      }
+
+      return x;
+    }
 
     vec4 sampleHiPSTexture${index}(vec2 uv) {
       vec4 color = texture(uSampler${index}, uv);
@@ -17246,10 +17789,12 @@ class ShaderManager {
         1.0
       );
 
+      float scaled = applyFitsScale${index}(normalized);
+
       return vec4(
-        normalized,
-        normalized,
-        normalized,
+        scaled,
+        scaled,
+        scaled,
         1.0
       );
     }
@@ -19783,11 +20328,12 @@ function findCircleThroughTwoPoints(points, q1, q2) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  BinaryTableHDU: () => (/* reexport */ BinaryTableHDU),
   FITSHeaderManager: () => (/* reexport */ FITSHeaderManager),
   FITSParser: () => (/* reexport */ FITSParser)
 });
 
-// UNUSED EXPORTS: AsciiTableHDU, BinaryTableHDU, FITSFile, FITSHDU, FITSHeaderItem, FITSWriter, ImageHDU, ParseHeader, ParsePayload, PrimaryHDU
+// UNUSED EXPORTS: AsciiTableHDU, FITSFile, FITSHDU, FITSHeaderItem, FITSWriter, ImageHDU, ParseHeader, ParsePayload, PrimaryHDU
 
 ;// ./node_modules/jsfitsio/lib-esm/model/FITSHeaderItem.js
 /**