astro-viewer 3.8.0 → 3.10.0

package/dist/astroviewer.cjs

@@ -4130,6 +4130,21 @@ 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);
     }
@@ -4811,7 +4826,7 @@ class AstroViewer {
     }
     //FOOTPRINT
     createFootprintSet(footprintSetName, footprintSetDescription, providerUrl, metadataManager) {
-        return new FootprintSetGL_js_1.FootprintSetGL(footprintSetName, footprintSetDescription, providerUrl, metadataManager, this.webgl, this.astroSphere.healpixGrid.visibleTilesManager);
+        return new FootprintSetGL_js_1.FootprintSetGL(footprintSetName, footprintSetDescription, providerUrl, metadataManager, this.webgl);
     }
     showFootprintSet(footprintSet) {
         this.astroSphere.showFootprintSet(footprintSet);
@@ -4836,7 +4851,7 @@ class AstroViewer {
         this.astroSphere.deleteCatalogue(pointSet);
     }
     createTerraFootprintSet(footprintSetName, footprintSetDescription, providerUrl, metadataManager) {
-        return new TerraFootprintSetGL_js_1.TerraFootprintSetGL(footprintSetName, footprintSetDescription, providerUrl, metadataManager, this.webgl, this.astroSphere.healpixGrid.visibleTilesManager);
+        return new TerraFootprintSetGL_js_1.TerraFootprintSetGL(footprintSetName, footprintSetDescription, providerUrl, metadataManager, this.webgl);
     }
     showTerraFootprintSet(footprintSet) {
         this.astroSphere.showFootprintSet(footprintSet);
@@ -4848,7 +4863,7 @@ class AstroViewer {
         this.astroSphere.deleteFootprintSet(footprintSet);
     }
     createTerraPolylineSet(polylineSetName, polylineSetDescription, providerUrl, metadataManager) {
-        return new TerraPolylineSetGL_js_1.TerraPolylineSetGL(polylineSetName, polylineSetDescription, providerUrl, metadataManager, this.webgl, this.astroSphere.healpixGrid.visibleTilesManager);
+        return new TerraPolylineSetGL_js_1.TerraPolylineSetGL(polylineSetName, polylineSetDescription, providerUrl, metadataManager, this.webgl);
     }
     showTerraPolylineSet(polylineSet) {
         this.astroSphere.showPolylineSet(polylineSet);
@@ -5001,6 +5016,15 @@ class AstroViewer {
     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 ?? [];
     }
@@ -5738,7 +5762,7 @@ class Global {
     // private _gl: GL | null;
     _healpix;
     // --- config/state flags ---
-    _selectionnside;
+    // private _selectionnside: number;
     // private _healpix4footprints: boolean;
     _useCORSProxy;
     _corsProxyUrl;
@@ -5746,6 +5770,7 @@ class Global {
     _debug;
     _insideSphere;
     _version;
+    _selectionOrder;
     constructor() {
         this._useCORSProxy = Config_js_1.bootSetup.useCORSProxy;
         this._corsProxyUrl = Config_js_1.bootSetup.corsProxyUrl;
@@ -5754,18 +5779,34 @@ class Global {
         this._insideSphere = Config_js_1.bootSetup.insideView;
         this._version = Config_js_1.bootSetup.version;
         this._healpix = {};
-        this._selectionnside = 32;
+        // this._selectionnside = 32;
+        this._selectionOrder = 5;
+    }
+    get selectionOrder() {
+        return this._selectionOrder;
     }
     init() {
-        console.log('Global.init()');
+        console.log("Global.init()");
     }
     // --- getters/setters ---
-    get version() { return this._version; }
-    set corsProxyUrl(url) { this._corsProxyUrl = url; }
-    get corsProxyUrl() { return this._corsProxyUrl; }
-    get useCORSProxy() { return this._useCORSProxy; }
-    set useCORSProxy(enabled) { this._useCORSProxy = enabled; }
-    get debug() { return this._debug; }
+    get version() {
+        return this._version;
+    }
+    set corsProxyUrl(url) {
+        this._corsProxyUrl = url;
+    }
+    get corsProxyUrl() {
+        return this._corsProxyUrl;
+    }
+    get useCORSProxy() {
+        return this._useCORSProxy;
+    }
+    set useCORSProxy(enabled) {
+        this._useCORSProxy = enabled;
+    }
+    get debug() {
+        return this._debug;
+    }
     getHealpix(order) {
         if (this._healpix[order] === undefined) {
             // order is HEALPix "order" ⇒ nside = 2^order
@@ -5773,10 +5814,15 @@ class Global {
         }
         return this._healpix[order];
     }
-    get MAX_DECIMALS() { return this._maxDecimals; }
-    set insideSphere(v) { this._insideSphere = v; }
-    get insideSphere() { return this._insideSphere; }
-    get nsideForSelection() { return this._selectionnside; }
+    get MAX_DECIMALS() {
+        return this._maxDecimals;
+    }
+    set insideSphere(v) {
+        this._insideSphere = v;
+    }
+    get insideSphere() {
+        return this._insideSphere;
+    }
 }
 const global = new Global();
 exports["default"] = global;
@@ -5867,7 +5913,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');
 
 
 /***/ },
@@ -7857,7 +7902,8 @@ class Source {
     }
     computeHealpixPixel() {
         // Get Healpix instance from global
-        const healpix = Global_js_1.default.getHealpix(Global_js_1.default.nsideForSelection);
+        // const healpix: Healpix = global.getHealpix(global.nsideForSelection);
+        const healpix = Global_js_1.default.getHealpix(Global_js_1.default.selectionOrder);
         const vec3 = new healpix_1.Vec3(this._point.x, this._point.y, this._point.z);
         const ptg = new healpix_1.Pointing(vec3, false);
         this._h_pix = healpix.ang2pix(ptg, false);
@@ -8145,7 +8191,7 @@ class CatalogueGL {
     _oldMouseCoords;
     _metadataManager;
     _isVisible = true;
-    _shapeColor = '#8F00FF';
+    _shapeColor = "#8F00FF";
     _healpixDensityMap;
     _providerUrl;
     _catalogueShaderProgram;
@@ -8154,7 +8200,7 @@ class CatalogueGL {
         this._webgl = webgl;
         this._ready = false;
         this._visibleTilesManager = visibleTilesManager;
-        this.TYPE = 'SOURCE_CATALOGUE';
+        this.TYPE = "SOURCE_CATALOGUE";
         this._name = catalogueName;
         this._description = catalogueDescription;
         this._providerUrl = providerUrl;
@@ -8172,7 +8218,7 @@ class CatalogueGL {
         this._oldMouseCoords = null;
         this._healpixDensityMap = new Map();
         // this.catalogueProps = new CatalogueProps(metadataManager, defaultColor);
-        // call catalogueShaderProgram to init shaders if they are not yet initialised 
+        // call catalogueShaderProgram to init shaders if they are not yet initialised
         this._catalogueShaderProgram = new CatalogueShaderProgram_js_1.CatalogueShaderProgram(this._webgl);
         this._catalogueShaderProgram.shaderProgram;
         // catalogueShaderProgram.shaderProgram
@@ -8217,7 +8263,7 @@ class CatalogueGL {
         }
         return {
             min: Number(min),
-            max: Number(max)
+            max: Number(max),
         };
     }
     get metadataManager() {
@@ -8266,7 +8312,7 @@ class CatalogueGL {
             const raw = Number(source.getDetailByindex(idx));
             const min = Number(minmax.min);
             const max = Number(minmax.max);
-            const norm = (raw - min) / Math.max(1e-12, (max - min));
+            const norm = (raw - min) / Math.max(1e-12, max - min);
             const size = norm * (20 - 8) + 8;
             source.shapeSize = size;
         }
@@ -8303,7 +8349,7 @@ class CatalogueGL {
             const raw = Number(source.getDetailByindex(idx));
             const min = Number(minmax.min);
             const max = Number(minmax.max);
-            const norm = (raw - min) / Math.max(1e-12, (max - min));
+            const norm = (raw - min) / Math.max(1e-12, max - min);
             // map [0,1] -> [1,-1]
             source.brightnessFactor = -(norm * 2 - 1);
         }
@@ -8333,7 +8379,7 @@ class CatalogueGL {
         for (let j = 0; j < in_data.length; j++) {
             const point = new Point_js_1.Point({
                 raDeg: in_data[j][raDataIndex],
-                decDeg: in_data[j][decDataIndex]
+                decDeg: in_data[j][decDataIndex],
             }, CoordsType_js_1.CoordsType.ASTRO);
             const source = new Source_js_1.Source(point, in_data[j]);
             // Ensure optional fields exist
@@ -8404,7 +8450,8 @@ class CatalogueGL {
             if (i >= 0) {
                 this.hoveredIndexes.splice(i, 1);
                 this.vertexCataloguePosition[base + 3] = 0.0; // not hovered
-                this.vertexCataloguePosition[base + 4] = this._sources[sIdx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
+                this.vertexCataloguePosition[base + 4] =
+                    this._sources[sIdx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             }
         }
     }
@@ -8428,7 +8475,8 @@ class CatalogueGL {
             if (i >= 0) {
                 this.selectedIndexes.splice(i, 1);
                 this.vertexCataloguePosition[base + 3] = 0.0; // not selected
-                this.vertexCataloguePosition[base + 4] = this._sources[sIdx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
+                this.vertexCataloguePosition[base + 4] =
+                    this._sources[sIdx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             }
         }
     }
@@ -8459,9 +8507,11 @@ class CatalogueGL {
             // hovered flag
             this.vertexCataloguePosition[positionIndex + 3] = 0.0;
             // size
-            this.vertexCataloguePosition[positionIndex + 4] = currSource.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
+            this.vertexCataloguePosition[positionIndex + 4] =
+                currSource.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             // brightness
-            this.vertexCataloguePosition[positionIndex + 5] = currSource.brightnessFactor ?? 0.0;
+            this.vertexCataloguePosition[positionIndex + 5] =
+                currSource.brightnessFactor ?? 0.0;
             positionIndex += CatalogueGL.ELEM_SIZE;
         }
         this._webgl.bufferData(this._webgl.ARRAY_BUFFER, this.vertexCataloguePosition, this._webgl.STATIC_DRAW);
@@ -8495,50 +8545,8 @@ class CatalogueGL {
                 return 0.0001;
         }
     }
-    checkClicking(in_mouseHelper) {
-        if (in_mouseHelper.x == null || in_mouseHelper.y == null || in_mouseHelper.z == null) {
-            console.log('CatalogueGL.checkClicking: missing mouse coords');
-            return [];
-        }
-        const clickedIndexes = [];
-        const mousePix = in_mouseHelper.computeNpix();
-        if (mousePix != null && this._healpixDensityMap.has(mousePix)) {
-            const candidates = this._healpixDensityMap.get(mousePix);
-            const selR = this.getSelectionRadius();
-            for (let i = 0; i < candidates.length; i++) {
-                const sourceIdx = candidates[i];
-                const source = this._sources[sourceIdx];
-                if (!source)
-                    continue;
-                const dx = source.point.x - in_mouseHelper.x;
-                const dy = source.point.y - in_mouseHelper.y;
-                const dz = source.point.z - in_mouseHelper.z;
-                const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-                if (dist <= selR) {
-                    clickedIndexes.push(sourceIdx);
-                }
-            }
-        }
-        return clickedIndexes;
-    }
-    // private setSelectedIndexes(nextSelected: number[]) {
-    //     const deduped = Array.from(new Set(nextSelected))
-    //         .filter((idx) => idx >= 0 && idx < this._sources.length);
-    //     if (this.vertexCataloguePosition.length) {
-    //         for (const prevIdx of this.selectedIndexes) {
-    //             if (deduped.includes(prevIdx)) continue;
-    //             const base = prevIdx * CatalogueGL.ELEM_SIZE;
-    //             if (base + 4 >= this.vertexCataloguePosition.length) continue;
-    //             if (!this.hoveredIndexes.includes(prevIdx) && !this.extHoveredIndexes.includes(prevIdx)) {
-    //                 this.vertexCataloguePosition[base + 3] = 0.0;
-    //             }
-    //             this.vertexCataloguePosition[base + 4] = this._sources[prevIdx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
-    //         }
-    //     }
-    //     this.selectedIndexes = deduped;
-    // }
     setSelectedIndexes(selectedIndex) {
-        selectedIndex.forEach(idx => {
+        selectedIndex.forEach((idx) => {
             if (idx < 0 || idx >= this._sources.length)
                 return;
             const base = idx * CatalogueGL.ELEM_SIZE;
@@ -8547,12 +8555,14 @@ class CatalogueGL {
             if (this.selectedIndexes.includes(idx)) {
                 this.selectedIndexes.splice(this.selectedIndexes.indexOf(idx), 1);
                 this.vertexCataloguePosition[base + 3] = 0.0; // not selected
-                this.vertexCataloguePosition[base + 4] = this._sources[idx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
+                this.vertexCataloguePosition[base + 4] =
+                    this._sources[idx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             }
             else {
                 this.selectedIndexes.push(idx);
                 this.vertexCataloguePosition[base + 3] = 2.0; // selected
-                this.vertexCataloguePosition[base + 4] = this._sources[idx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
+                this.vertexCataloguePosition[base + 4] =
+                    this._sources[idx]?.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             }
         });
     }
@@ -8569,7 +8579,7 @@ class CatalogueGL {
             };
         }
         const sources = [];
-        pickedIndexes.forEach(idx => {
+        pickedIndexes.forEach((idx) => {
             const source = this._sources[idx];
             if (source)
                 sources.push(source);
@@ -8599,7 +8609,7 @@ class CatalogueGL {
         }
         const selectionState = [];
         const selectedSources = [];
-        clickedIndexes.forEach(idx => {
+        clickedIndexes.forEach((idx) => {
             const source = this._sources[idx];
             if (!source)
                 return;
@@ -8617,31 +8627,43 @@ class CatalogueGL {
         const idx = this.hoveredIndexes[0];
         return this._sources[idx] ?? null;
     }
-    checkHovering(in_mouseHelper) {
-        if (in_mouseHelper.x == null || in_mouseHelper.y == null || in_mouseHelper.z == null) {
-            console.log('CatalogueGL.checkHovering: missing mouse coords');
-            return [];
+    findNearestSourceIndex(in_mouseHelper) {
+        if (in_mouseHelper.x == null ||
+            in_mouseHelper.y == null ||
+            in_mouseHelper.z == null) {
+            return null;
         }
-        const hoveredIndexes = [];
         const mousePix = in_mouseHelper.computeNpix();
-        if (mousePix != null && this._healpixDensityMap.has(mousePix)) {
-            const candidates = this._healpixDensityMap.get(mousePix);
-            const selR = this.getSelectionRadius();
-            for (let i = 0; i < candidates.length; i++) {
-                const sourceIdx = candidates[i];
-                const source = this._sources[sourceIdx];
-                if (!source)
-                    continue;
-                const dx = source.point.x - in_mouseHelper.x;
-                const dy = source.point.y - in_mouseHelper.y;
-                const dz = source.point.z - in_mouseHelper.z;
-                const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-                if (dist <= selR) {
-                    hoveredIndexes.push(sourceIdx);
-                }
+        if (mousePix == null)
+            return null;
+        const candidates = this._healpixDensityMap.get(mousePix);
+        if (!candidates?.length)
+            return null;
+        const selR = this.getSelectionRadius();
+        let nearestIndex = null;
+        let nearestDistance = Number.POSITIVE_INFINITY;
+        for (const sourceIdx of candidates) {
+            const source = this._sources[sourceIdx];
+            if (!source)
+                continue;
+            const dx = source.point.x - in_mouseHelper.x;
+            const dy = source.point.y - in_mouseHelper.y;
+            const dz = source.point.z - in_mouseHelper.z;
+            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (dist <= selR && dist < nearestDistance) {
+                nearestDistance = dist;
+                nearestIndex = sourceIdx;
             }
         }
-        return hoveredIndexes;
+        return nearestIndex;
+    }
+    checkClicking(in_mouseHelper) {
+        const nearestIndex = this.findNearestSourceIndex(in_mouseHelper);
+        return nearestIndex == null ? [] : [nearestIndex];
+    }
+    checkHovering(in_mouseHelper) {
+        const nearestIndex = this.findNearestSourceIndex(in_mouseHelper);
+        return nearestIndex == null ? [] : [nearestIndex];
     }
     /**
      * @param in_mMatrix Model matrix the current catalogue is associated to (e.g. HiPS matrix)
@@ -8688,7 +8710,8 @@ class CatalogueGL {
             const base = this.hoveredIndexes[k] * CatalogueGL.ELEM_SIZE;
             // if (this.vertexCataloguePosition[base + 3] == 2.0) continue; // selected, skip hover
             this.vertexCataloguePosition[base + 3] = 0.0; // not hovered
-            this.vertexCataloguePosition[base + 4] = this._sources[this.hoveredIndexes[k]].shapeSize; // size
+            this.vertexCataloguePosition[base + 4] =
+                this._sources[this.hoveredIndexes[k]].shapeSize; // size
         }
         // Hover logic on mouse move
         if (in_mouseHelper != null && in_mouseHelper.xyz !== this._oldMouseCoords) {
@@ -10313,11 +10336,9 @@ class FootprintSetGL {
     _metadataManager;
     _providerUrl;
     _footprintShaderProgram;
-    _visibleTilesManager;
-    constructor(fsetName, fsetDescription, providerUrl, metadataManager, webgl, visibleTilesManager) {
+    constructor(fsetName, fsetDescription, providerUrl, metadataManager, webgl) {
         this._webgl = webgl;
         this._ready = false;
-        this._visibleTilesManager = visibleTilesManager;
         this.TYPE = "FOOTPRINT_SET";
         this._name = fsetName;
         this._description = fsetDescription;
@@ -11633,8 +11654,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);
@@ -12062,6 +12089,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;
@@ -12106,30 +12134,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;
@@ -12243,7 +12248,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);
@@ -12380,6 +12385,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) {
@@ -12437,30 +12443,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;
@@ -12560,7 +12543,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);
@@ -12637,6 +12620,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) {
@@ -12666,22 +12652,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) {
@@ -12885,6 +12906,21 @@ 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;
@@ -12901,6 +12937,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() {
@@ -13136,6 +13179,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;
     }
@@ -13646,6 +13820,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) {
@@ -13784,30 +13959,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;
@@ -13911,7 +14063,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);
@@ -14489,7 +14641,9 @@ class MeshHiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
         const orders = Array.from(byOrder.keys()).sort((a, b) => a - b);
         for (const order of orders) {
             for (const coord of byOrder.get(order) ?? []) {
-                this._tiles.get(this.tileKey(coord))?.draw(pMatrix, vMatrix, mMatrix, this._descriptor.color, this._descriptor.wireframe);
+                this._tiles
+                    .get(this.tileKey(coord))
+                    ?.draw(pMatrix, vMatrix, mMatrix, this._descriptor.color, this._descriptor.wireframe);
             }
         }
         if (wasCullFace)
@@ -14502,7 +14656,7 @@ class MeshHiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
     getDebugStats() {
         const tiles = Array.from(this._tiles.values());
         return {
-            activeBaseLayer: 'meships',
+            activeBaseLayer: "meships",
             meshHiPSName: this._descriptor.name,
             meshHiPSUrl: this._descriptor.baseUrl,
             currentOrder: this._currentOrder,
@@ -14521,33 +14675,47 @@ class MeshHiPS extends AbstractSkyEntity_js_1.AbstractSkyEntity {
             ? byOrder.pixels
             : [];
         if (pixels.length > 0) {
-            return pixels.map((ipix) => ({ order: this._currentOrder, ipix }));
+            return pixels.map((ipix) => ({
+                order: this._currentOrder,
+                ipix,
+            }));
         }
         const tileCount = 12 * 4 ** this._currentOrder;
-        return Array.from({ length: tileCount }, (_, ipix) => ({ order: this._currentOrder, ipix }));
+        return Array.from({ length: tileCount }, (_, ipix) => ({
+            order: this._currentOrder,
+            ipix,
+        }));
     }
     resolveCoverageTiles(visibleTiles) {
         const tiles = new Map();
         const add = (coord) => {
-            if (coord.order < this._descriptor.minOrder || coord.order > this._descriptor.maxOrder)
+            if (coord.order < this._descriptor.minOrder ||
+                coord.order > this._descriptor.maxOrder) {
                 return;
+            }
             tiles.set(this.tileKey(coord), coord);
         };
         for (const coord of visibleTiles) {
             add(coord);
             for (let order = coord.order - 1; order >= this._descriptor.minOrder; order--) {
                 const shift = 2 * (coord.order - order);
-                add({ order, ipix: coord.ipix >> shift });
+                add({
+                    order,
+                    ipix: coord.ipix >> shift,
+                });
             }
         }
         const manager = this._healpixGrid.visibleTilesManager;
         const ancestorsMap = manager?.ancestorsMap;
         if (ancestorsMap) {
             for (const [order, ipixes] of ancestorsMap) {
-                if (order < this._descriptor.minOrder || order > this._descriptor.maxOrder)
+                if (order < this._descriptor.minOrder ||
+                    order > this._descriptor.maxOrder) {
                     continue;
-                for (const ipix of ipixes)
+                }
+                for (const ipix of ipixes) {
                     add({ order, ipix });
+                }
             }
         }
         return Array.from(tiles.values());
@@ -16164,6 +16332,9 @@ function normalizeLongitudeDeg(longitudeDeg) {
  *
  * See LICENSE.md, LICENSE-AGPL.md, and LICENSE-COMMERCIAL.md for details.
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.TerraFootprintSetGL = void 0;
 const FootprintSetGL_js_1 = __webpack_require__(592);
@@ -16172,6 +16343,8 @@ const Footprint_js_1 = __webpack_require__(2475);
 const MetadataColumn_js_1 = __webpack_require__(1072);
 const MetadataManager_js_1 = __webpack_require__(5403);
 const MetadataColumn_js_2 = __webpack_require__(1072);
+const Point_js_1 = __webpack_require__(6553);
+const GeomUtils_js_1 = __importDefault(__webpack_require__(2930));
 class TerraFootprintSetGL extends FootprintSetGL_js_1.FootprintSetGL {
     _kind = 'TerraFootprintSetGL';
     _coordsType = CoordsType_js_1.CoordsType.GEOGRAPHIC;
@@ -16190,6 +16363,23 @@ class TerraFootprintSetGL extends FootprintSetGL_js_1.FootprintSetGL {
         this._ready = true;
         this._bufferInitialised = false;
     }
+    checkSelection(mouseHelper) {
+        if (mouseHelper.x == null || mouseHelper.y == null || mouseHelper.z == null)
+            return;
+        const hoverState = this;
+        hoverState._hoveredFootprints = [];
+        this.totHoveredPoints = 0;
+        const mousePoint = new Point_js_1.Point({ x: mouseHelper.x, y: mouseHelper.y, z: mouseHelper.z }, CoordsType_js_1.CoordsType.CARTESIAN);
+        for (const footprint of this.footprintPolygons) {
+            if (!footprint.selectionObj)
+                continue;
+            if (GeomUtils_js_1.default.checkPointInsidePolygon5(footprint.selectionObj, mousePoint)) {
+                hoverState._hoveredFootprints.push(footprint);
+                this.totHoveredPoints += footprint.totPoints;
+            }
+        }
+        this.initHoveringBuffer();
+    }
     createGeoJSONMetadataColumns(features) {
         const names = new Set();
         features.forEach(feature => Object.keys(feature.properties).forEach(name => names.add(name)));
@@ -16234,8 +16424,44 @@ exports.TerraFootprintSetGL = TerraFootprintSetGL;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.TerraPointSetGL = void 0;
 const CatalogueGL_js_1 = __webpack_require__(1232);
+const MetadataManager_js_1 = __webpack_require__(5403);
+const Point_js_1 = __webpack_require__(6553);
+const CoordsType_js_1 = __webpack_require__(8145);
 class TerraPointSetGL extends CatalogueGL_js_1.CatalogueGL {
     _kind = 'TerraPointSetGL';
+    addSources(inData, columnsMeta) {
+        this._ready = false;
+        this._sources = [];
+        const metadataManager = new MetadataManager_js_1.MetadataManager(columnsMeta);
+        this._metadataManager = metadataManager;
+        const lonDataIndex = metadataManager.selectedRaColumn?.index ?? -1;
+        const latDataIndex = metadataManager.selectedDecColumn?.index ?? -1;
+        if (lonDataIndex < 0 || latDataIndex < 0) {
+            throw new Error(`(lon, lat) idx not defined (${lonDataIndex}, ${latDataIndex}) `);
+        }
+        for (const row of inData) {
+            const point = new Point_js_1.Point({
+                lonDeg: Number(row[lonDataIndex]),
+                latDeg: Number(row[latDataIndex]),
+            }, CoordsType_js_1.CoordsType.GEOGRAPHIC);
+            this.addSource({
+                point,
+                details: row,
+                healpixPixel: 0,
+                shapeSize: CatalogueGL_js_1.CatalogueGL.STANDARD_SHAPE_SIZE,
+                brightnessFactor: 3,
+                getDetailByindex(index) {
+                    return index < 0 || index >= row.length ? undefined : row[index];
+                },
+            });
+        }
+        this._ready = true;
+        this._bufferInitialised = false;
+    }
+    draw(inMatrix, inMouseHelper, viewMatrix, projectionMatrix) {
+        this._oldMouseCoords = inMouseHelper?.xyz ?? null;
+        super.draw(inMatrix, inMouseHelper, viewMatrix, projectionMatrix);
+    }
 }
 exports.TerraPointSetGL = TerraPointSetGL;
 
@@ -16268,7 +16494,6 @@ class TerraPolylineSetGL {
     _providerUrl;
     _metadataManager;
     _webgl;
-    _visibleTilesManager;
     static ELEM_SIZE = 3;
     static BYTES_X_ELEM = new Float32Array().BYTES_PER_ELEMENT;
     _kind = 'TerraPolylineSetGL';
@@ -16279,13 +16504,12 @@ class TerraPolylineSetGL {
     paths = [];
     renderSegments = [];
     _polylineShaderProgram;
-    constructor(_name, _description, _providerUrl, _metadataManager, _webgl, _visibleTilesManager) {
+    constructor(_name, _description, _providerUrl, _metadataManager, _webgl) {
         this._name = _name;
         this._description = _description;
         this._providerUrl = _providerUrl;
         this._metadataManager = _metadataManager;
         this._webgl = _webgl;
-        this._visibleTilesManager = _visibleTilesManager;
         this._polylineShaderProgram = new FootprintShaderProgram_js_1.FootprintShaderProgram(this._webgl);
     }
     addPath(points, metadata) {
@@ -16756,6 +16980,8 @@ class HiPSShaderProgram {
             textureMode: "uTextureMode",
             dataMin: "uDataMin",
             dataMax: "uDataMax",
+            scaleFunction: "uScaleFunction",
+            scaleParam: "uScaleParam",
         };
         this.gl_attributes = {
             vertex_pos: "aVertexPosition",
@@ -16770,6 +16996,8 @@ 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,
@@ -16903,7 +17131,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}`);
         }
@@ -16924,12 +17152,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
@@ -16945,6 +17181,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);
             }
@@ -17281,7 +17519,7 @@ class ShaderManager {
     }
     static footprintVS() {
         return `#version 300 es
-    precision highp float;
+    precision mediump float;
 
     layout(location = 0) in vec4 aCatPosition;
 
@@ -17323,7 +17561,7 @@ class ShaderManager {
     }
     static hipsNativeFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
 
     in vec2 vTextureCoord;
 
@@ -17389,7 +17627,7 @@ class ShaderManager {
     }
     static hipsGrayscaleFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
 
     in vec2 vTextureCoord;
 
@@ -17463,7 +17701,7 @@ class ShaderManager {
     }
     static hipsColorMapFS() {
         return `#version 300 es
-    precision mediump float;
+    precision highp float;
 
     uniform float uLayerOpacity;
 
@@ -17568,6 +17806,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);
@@ -17591,10 +17859,12 @@ class ShaderManager {
         1.0
       );
 
+      float scaled = applyFitsScale${index}(normalized);
+
       return vec4(
-        normalized,
-        normalized,
-        normalized,
+        scaled,
+        scaled,
+        scaled,
         1.0
       );
     }
@@ -18565,7 +18835,8 @@ class MouseHelper {
     computeNpix() {
         if (!this._xyz)
             return null;
-        const hp = Global_js_1.default.getHealpix(Global_js_1.default.nsideForSelection);
+        // const hp: Healpix = global.getHealpix(global.nsideForSelection);
+        const hp = Global_js_1.default.getHealpix(Global_js_1.default.selectionOrder);
         const v = new healpix_1.Vec3(this._xyz[0], this._xyz[1], this._xyz[2]);
         const ptg = new healpix_1.Pointing(v, false);
         return hp.ang2pix(ptg, false);