astro-viewer 3.9.0 → 3.11.0

package/dist/astroviewer.cjs

@@ -43,6 +43,7 @@ __webpack_require__.d(vec3_namespaceObject, {
   dot: () => (dot),
   fromValues: () => (vec3_fromValues),
   length: () => (vec3_length),
+  lerp: () => (lerp),
   normalize: () => (normalize),
   scale: () => (vec3_scale),
   scaleAndAdd: () => (scaleAndAdd),
@@ -3895,6 +3896,7 @@ class AstroSphere {
         const handleMouseDown = (event) => {
             canvas.setPointerCapture(event.pointerId);
             this.mouseDown = true;
+            this._camera.cancelFlyTo();
             const rect = canvas.getBoundingClientRect();
             this.lastMouseX = event.clientX - rect.left; // locale al canvas
             this.lastMouseY = event.clientY - rect.top; // locale al canvas
@@ -4021,6 +4023,7 @@ class AstroSphere {
         const handleMouseWheel = (event) => {
             const currentFov = this._healpixGrid.getMinFoV();
             const zoomStep = this.computeZoomStep(currentFov, event.deltaY);
+            this._camera.cancelFlyTo();
             // Apply wheel zoom immediately and discard any queued inertia so reversing
             // direction feels responsive instead of "buffered".
             this.zoomInertia = 0;
@@ -4286,6 +4289,9 @@ class AstroSphere {
     goTo(raDeg, decDeg) {
         this._camera.goTo(raDeg, decDeg);
     }
+    flyTo(raDeg, decDeg, durationMs = 1200) {
+        this._camera.flyTo(raDeg, decDeg, durationMs);
+    }
     getActiveCoordinateMode() {
         if (this._activeBaseLayer === "xyz") {
             return "lonlat";
@@ -4521,6 +4527,16 @@ class AstroSphere {
         let PHI = 0;
         this._webgl.viewport(0, 0, this._webgl.drawingBufferWidth, this._webgl.drawingBufferHeight);
         this._webgl.clear(this._webgl.COLOR_BUFFER_BIT | this._webgl.DEPTH_BUFFER_BIT);
+        const now = performance.now();
+        const cameraFlying = this._camera.updateFlyTo(now);
+        if (cameraFlying) {
+            this.inertiaX = 0;
+            this.inertiaY = 0;
+            this.lastCameraMotionAt = now;
+            this._cameraStatusChanged = true;
+            this.updateCentralPoint();
+            this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
+        }
         // Zoom inertia
         if (this.zoomInertia !== 0) {
             if (Math.abs(this.zoomInertia) > 0.0001) {
@@ -4826,7 +4842,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);
@@ -4851,7 +4867,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);
@@ -4863,7 +4879,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);
@@ -5051,6 +5067,9 @@ class AstroViewer {
         // console.log(`AstroViewer.goTo goto(${raDeg}, ${decDeg})`)
         this.astroSphere.goTo(raDeg, decDeg);
     }
+    flyTo(raDeg, decDeg, durationMs = 1200) {
+        this.astroSphere.flyTo(raDeg, decDeg, durationMs);
+    }
     getActiveCoordinateMode() {
         return this.astroSphere.getActiveCoordinateMode();
     }
@@ -5372,6 +5391,7 @@ class Camera {
     lockRotX = false;
     lockRotY = false;
     lockRotZ = false;
+    flyToAnimation = null;
     constructor(in_position, in_sphere) {
         this.init(in_position, in_sphere);
     }
@@ -5381,7 +5401,11 @@ class Camera {
         this.vMatrix = gl_matrix_1.mat4.create();
         this.T = gl_matrix_1.mat4.create();
         this.R = gl_matrix_1.mat4.create();
-        gl_matrix_1.mat4.translate(this.T, this.T, [this.cam_pos[0], this.cam_pos[1], this.cam_pos[2]]);
+        gl_matrix_1.mat4.translate(this.T, this.T, [
+            this.cam_pos[0],
+            this.cam_pos[1],
+            this.cam_pos[2],
+        ]);
         // reset helpers
         this.FoV = this.previousFoV = 180.0;
         this.move = gl_matrix_1.vec3.clone([0, 0, 0]);
@@ -5390,11 +5414,15 @@ class Camera {
         this.goTo(raDeg, decDeg);
     }
     goTo(raDeg, decDeg) {
+        this.cancelFlyTo();
         this.goToPhiTheta((0, Utils_js_1.astroDegToSpherical)(raDeg, decDeg));
     }
     goToPhiTheta(ptDeg) {
         const xyz = (0, Utils_js_1.sphericalToCartesian)(ptDeg.phi, ptDeg.theta, this.cam_pos[2]);
-        const targetDirection = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), gl_matrix_1.vec3.fromValues(xyz[0], xyz[1], xyz[2]));
+        this.applyCameraPosition(gl_matrix_1.vec3.fromValues(xyz[0], xyz[1], xyz[2]));
+    }
+    applyCameraPosition(cameraPosition) {
+        const targetDirection = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), cameraPosition);
         const celestialNorth = gl_matrix_1.vec3.fromValues(0.0, 0.0, 1.0);
         const northProjection = gl_matrix_1.vec3.scale(gl_matrix_1.vec3.create(), targetDirection, gl_matrix_1.vec3.dot(celestialNorth, targetDirection));
         const cameraUp = gl_matrix_1.vec3.subtract(gl_matrix_1.vec3.create(), celestialNorth, northProjection);
@@ -5405,9 +5433,13 @@ class Camera {
             gl_matrix_1.vec3.normalize(cameraUp, cameraUp);
         }
         let cameraMatrix = gl_matrix_1.mat4.create();
-        cameraMatrix = gl_matrix_1.mat4.translate(cameraMatrix, cameraMatrix, gl_matrix_1.vec3.fromValues(xyz[0], xyz[1], xyz[2]));
+        cameraMatrix = gl_matrix_1.mat4.translate(cameraMatrix, cameraMatrix, cameraPosition);
         const focusPoint = [0.0, 0.0, 0.0];
-        const cameraPos = [cameraMatrix[12], cameraMatrix[13], cameraMatrix[14]];
+        const cameraPos = [
+            cameraMatrix[12],
+            cameraMatrix[13],
+            cameraMatrix[14],
+        ];
         cameraMatrix = gl_matrix_1.mat4.targetTo(cameraMatrix, cameraPos, focusPoint, cameraUp);
         this.R = gl_matrix_1.mat4.clone(cameraMatrix);
         this.R[12] = 0;
@@ -5419,6 +5451,81 @@ class Camera {
         }
         this.vMatrix = viewMatrix;
     }
+    flyTo(raDeg, decDeg, durationMs = 1200) {
+        const targetSpherical = (0, Utils_js_1.astroDegToSpherical)(raDeg, decDeg);
+        const targetPositionValues = (0, Utils_js_1.sphericalToCartesian)(targetSpherical.phi, targetSpherical.theta, this.cam_pos[2]);
+        const targetPosition = gl_matrix_1.vec3.fromValues(targetPositionValues[0], targetPositionValues[1], targetPositionValues[2]);
+        const currentPosition = this.getCameraPosition();
+        const startDirection = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), gl_matrix_1.vec3.fromValues(currentPosition[0], currentPosition[1], currentPosition[2]));
+        const targetDirection = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), targetPosition);
+        this.flyToAnimation = {
+            startDirection,
+            targetDirection,
+            targetPosition,
+            startTime: performance.now(),
+            durationMs: Math.max(1, durationMs),
+        };
+    }
+    updateFlyTo(now) {
+        const animation = this.flyToAnimation;
+        if (!animation) {
+            return false;
+        }
+        const elapsed = now - animation.startTime;
+        const progress = Math.min(1, elapsed / animation.durationMs);
+        const easedProgress = progress < 0.5
+            ? 4 * progress * progress * progress
+            : 1 - Math.pow(-2 * progress + 2, 3) / 2;
+        const direction = this.slerpDirection(animation.startDirection, animation.targetDirection, easedProgress);
+        const radius = Math.abs(this.cam_pos[2]);
+        const cameraPosition = gl_matrix_1.vec3.scale(gl_matrix_1.vec3.create(), direction, radius);
+        this.applyCameraPosition(cameraPosition);
+        if (progress >= 1) {
+            this.applyCameraPosition(animation.targetPosition);
+            this.flyToAnimation = null;
+        }
+        return true;
+    }
+    slerpDirection(start, end, t) {
+        const dot = Math.max(-1, Math.min(1, gl_matrix_1.vec3.dot(start, end)));
+        /*
+         * For almost identical directions, normalized linear interpolation is
+         * numerically more stable than the general SLERP formula.
+         */
+        if (dot > 0.999999) {
+            const result = gl_matrix_1.vec3.lerp(gl_matrix_1.vec3.create(), start, end, t);
+            return gl_matrix_1.vec3.normalize(result, result);
+        }
+        /*
+         * The normal SLERP formula becomes singular for antipodal vectors because
+         * sin(pi) = 0. In that case choose a stable vector orthogonal to start and
+         * rotate through that great circle.
+         */
+        if (dot < -0.999999) {
+            const referenceAxis = Math.abs(start[0]) < 0.9
+                ? gl_matrix_1.vec3.fromValues(1, 0, 0)
+                : gl_matrix_1.vec3.fromValues(0, 1, 0);
+            const orthogonal = gl_matrix_1.vec3.cross(gl_matrix_1.vec3.create(), start, referenceAxis);
+            gl_matrix_1.vec3.normalize(orthogonal, orthogonal);
+            const angle = Math.PI * t;
+            const result = gl_matrix_1.vec3.create();
+            gl_matrix_1.vec3.scale(result, start, Math.cos(angle));
+            gl_matrix_1.vec3.scaleAndAdd(result, result, orthogonal, Math.sin(angle));
+            return gl_matrix_1.vec3.normalize(result, result);
+        }
+        const angle = Math.acos(dot);
+        const sinAngle = Math.sin(angle);
+        const startWeight = Math.sin((1 - t) * angle) / sinAngle;
+        const endWeight = Math.sin(t * angle) / sinAngle;
+        const result = gl_matrix_1.vec3.create();
+        result[0] = start[0] * startWeight + end[0] * endWeight;
+        result[1] = start[1] * startWeight + end[1] * endWeight;
+        result[2] = start[2] * startWeight + end[2] * endWeight;
+        return gl_matrix_1.vec3.normalize(result, result);
+    }
+    cancelFlyTo() {
+        this.flyToAnimation = null;
+    }
     toggleInsideSphere() {
         // if (inside !== global.insideSphere) {
         //   global.insideSphere = inside;
@@ -5676,9 +5783,15 @@ class Camera {
     clearRotationLock() {
         this.lockRotX = this.lockRotY = this.lockRotZ = false;
     }
-    isRotationLockedX() { return this.lockRotX; }
-    isRotationLockedY() { return this.lockRotY; }
-    isRotationLockedZ() { return this.lockRotZ; }
+    isRotationLockedX() {
+        return this.lockRotX;
+    }
+    isRotationLockedY() {
+        return this.lockRotY;
+    }
+    isRotationLockedZ() {
+        return this.lockRotZ;
+    }
 }
 exports["default"] = Camera;
 
@@ -5762,7 +5875,7 @@ class Global {
     // private _gl: GL | null;
     _healpix;
     // --- config/state flags ---
-    _selectionnside;
+    // private _selectionnside: number;
     // private _healpix4footprints: boolean;
     _useCORSProxy;
     _corsProxyUrl;
@@ -5770,6 +5883,7 @@ class Global {
     _debug;
     _insideSphere;
     _version;
+    _selectionOrder;
     constructor() {
         this._useCORSProxy = Config_js_1.bootSetup.useCORSProxy;
         this._corsProxyUrl = Config_js_1.bootSetup.corsProxyUrl;
@@ -5778,18 +5892,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
@@ -5797,10 +5927,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;
@@ -7858,6 +7993,7 @@ class Source {
     _h_pix;
     _shapesize;
     _brightnessFactor;
+    _mediaStyle;
     /**
      * @param in_point Point.js (Cartesian/RA-Dec wrapper)
      * @param in_details Optional array of key/value metadata
@@ -7880,7 +8016,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);
@@ -7909,6 +8046,12 @@ class Source {
     set brightnessFactor(factor) {
         this._brightnessFactor = factor;
     }
+    get mediaStyle() {
+        return this._mediaStyle;
+    }
+    set mediaStyle(style) {
+        this._mediaStyle = style;
+    }
 }
 exports.Source = Source;
 
@@ -8134,6 +8277,9 @@ exports.SphereFoV = SphereFoV;
  *
  * 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.CatalogueGL = void 0;
 const Source_js_1 = __webpack_require__(146);
@@ -8142,6 +8288,8 @@ const CoordsType_js_1 = __webpack_require__(8145);
 const Utils_js_1 = __webpack_require__(7930);
 const CatalogueShaderProgram_js_1 = __webpack_require__(3559);
 const MetadataManager_js_1 = __webpack_require__(5403);
+const gl_matrix_1 = __webpack_require__(3890);
+const Global_js_1 = __importDefault(__webpack_require__(4382));
 class CatalogueGL {
     _kind = "CatalogueGL";
     static ELEM_SIZE = 6;
@@ -8168,16 +8316,19 @@ class CatalogueGL {
     _oldMouseCoords;
     _metadataManager;
     _isVisible = true;
-    _shapeColor = '#8F00FF';
+    _shapeColor = "#8F00FF";
     _healpixDensityMap;
     _providerUrl;
     _catalogueShaderProgram;
     _visibleTilesManager;
+    _mediaOverlayHost = null;
+    _mediaElements = [];
+    _svgMediaDataUrls = new Map();
     constructor(catalogueName, catalogueDescription, providerUrl, metadataManager, webgl, visibleTilesManager) {
         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;
@@ -8195,7 +8346,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
@@ -8240,7 +8391,7 @@ class CatalogueGL {
         }
         return {
             min: Number(min),
-            max: Number(max)
+            max: Number(max),
         };
     }
     get metadataManager() {
@@ -8289,7 +8440,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;
         }
@@ -8326,7 +8477,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);
         }
@@ -8343,9 +8494,10 @@ class CatalogueGL {
      * @param in_data Rows of TAP results
      * @param columnsmeta TapMetadataList (unused here because `CatalogueProps` already holds indices)
      */
-    addSources(in_data, columnsmeta) {
+    addSources(in_data, columnsmeta, options = {}) {
         this._ready = false;
         this._sources = [];
+        this.clearMediaOverlay();
         this._metadataManager = new MetadataManager_js_1.MetadataManager(columnsmeta);
         // const raDataIndex = (this.catalogueProps.raColumn as any).index ?? (this.catalogueProps.raColumn as any)._index;
         // const decDataIndex = (this.catalogueProps.decColumn as any).index ?? (this.catalogueProps.decColumn as any)._index;
@@ -8356,9 +8508,13 @@ 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]);
+            const mediaStyle = this.extractMediaStyle(in_data[j], columnsmeta, options.mediaColumns);
+            if (mediaStyle) {
+                source.mediaStyle = mediaStyle;
+            }
             // Ensure optional fields exist
             source.shapeSize = source.shapeSize ?? CatalogueGL.STANDARD_SHAPE_SIZE;
             source.brightnessFactor = 3;
@@ -8378,11 +8534,222 @@ class CatalogueGL {
         this._ready = true;
         this._bufferInitialised = false;
     }
+    getColumnIndex(columnsmeta, columnName) {
+        if (!columnName)
+            return -1;
+        return columnsmeta.find((column) => column.name === columnName)?.index ?? -1;
+    }
+    readCell(row, columnsmeta, columnName) {
+        const idx = this.getColumnIndex(columnsmeta, columnName);
+        return idx >= 0 ? row[idx] : undefined;
+    }
+    extractMediaStyle(row, columnsmeta, mediaColumns) {
+        if (!mediaColumns?.src)
+            return undefined;
+        const rawSrc = this.readCell(row, columnsmeta, mediaColumns.src);
+        const src = String(rawSrc ?? "").trim();
+        if (!src)
+            return undefined;
+        const rawKind = String(this.readCell(row, columnsmeta, mediaColumns.type) ?? "sprite").trim().toLowerCase();
+        const kind = rawKind === "model"
+            ? "model"
+            : rawKind === "image"
+                ? "image"
+                : rawKind === "icon"
+                    ? "icon"
+                    : rawKind === "circle"
+                        ? "circle"
+                        : "sprite";
+        if (kind === "circle" || kind === "model")
+            return undefined;
+        const scale = Number(this.readCell(row, columnsmeta, mediaColumns.scale));
+        const rotationDeg = Number(this.readCell(row, columnsmeta, mediaColumns.rotation));
+        const opacity = Number(this.readCell(row, columnsmeta, mediaColumns.opacity));
+        return {
+            kind,
+            src,
+            scale: Number.isFinite(scale) && scale > 0 ? scale : undefined,
+            rotationDeg: Number.isFinite(rotationDeg) ? rotationDeg : undefined,
+            opacity: Number.isFinite(opacity) ? Math.max(0, Math.min(1, opacity)) : undefined,
+        };
+    }
     clearSources() {
         this._sources = [];
         this.hoveredIndexes = [];
         this._healpixDensityMap.clear();
         this.vertexCataloguePosition = new Float32Array(0);
+        this.clearMediaOverlay();
+    }
+    clearMediaOverlay() {
+        this._mediaElements.forEach((el) => el.remove());
+        this._mediaElements = [];
+        if (this._mediaOverlayHost) {
+            this._mediaOverlayHost.remove();
+            this._mediaOverlayHost = null;
+        }
+    }
+    ensureMediaOverlayHost() {
+        const canvas = this._webgl?.canvas;
+        const parent = canvas?.parentElement;
+        if (!canvas || !parent)
+            return null;
+        const parentStyle = window.getComputedStyle(parent);
+        if (parentStyle.position === "static") {
+            parent.style.position = "relative";
+        }
+        if (!this._mediaOverlayHost) {
+            const host = document.createElement("div");
+            host.dataset.astroCatalogueMedia = "true";
+            host.style.position = "absolute";
+            host.style.left = `${canvas.offsetLeft}px`;
+            host.style.top = `${canvas.offsetTop}px`;
+            host.style.width = `${canvas.clientWidth}px`;
+            host.style.height = `${canvas.clientHeight}px`;
+            host.style.pointerEvents = "none";
+            host.style.overflow = "hidden";
+            host.style.zIndex = "4";
+            canvas.style.position = canvas.style.position || "relative";
+            canvas.style.zIndex = canvas.style.zIndex || "0";
+            parent.appendChild(host);
+            this._mediaOverlayHost = host;
+        }
+        else {
+            this._mediaOverlayHost.style.left = `${canvas.offsetLeft}px`;
+            this._mediaOverlayHost.style.top = `${canvas.offsetTop}px`;
+            this._mediaOverlayHost.style.width = `${canvas.clientWidth}px`;
+            this._mediaOverlayHost.style.height = `${canvas.clientHeight}px`;
+        }
+        return this._mediaOverlayHost;
+    }
+    ensureMediaElement(index, style) {
+        let img = this._mediaElements[index];
+        if (!img) {
+            img = document.createElement("img");
+            img.loading = "lazy";
+            img.decoding = "async";
+            img.style.position = "absolute";
+            img.style.objectFit = "contain";
+            img.style.pointerEvents = "none";
+            img.style.transformOrigin = "center center";
+            img.style.filter = "drop-shadow(0 1px 2px rgba(0, 0, 0, 0.55))";
+            img.style.willChange = "transform, left, top";
+            this._mediaElements[index] = img;
+        }
+        const src = String(style.src ?? "").trim();
+        const resolvedSrc = src ? new URL(src, document.baseURI).href : "";
+        if (resolvedSrc && img.getAttribute("src") !== resolvedSrc) {
+            img.removeAttribute("data-astro-media-src-index");
+            img.removeAttribute("data-astro-media-loaded");
+            img.onerror = null;
+            img.onload = null;
+            img.setAttribute("src", resolvedSrc);
+            if (/\.svg(?:[?#].*)?$/i.test(resolvedSrc)) {
+                void this.loadSvgMediaAsDataUrl(img, resolvedSrc);
+            }
+        }
+        return img;
+    }
+    async loadSvgMediaAsDataUrl(img, resolvedSrc) {
+        try {
+            let dataUrl = this._svgMediaDataUrls.get(resolvedSrc);
+            if (!dataUrl) {
+                const response = await fetch(resolvedSrc);
+                if (!response.ok)
+                    return;
+                const svg = await response.text();
+                if (!/^\s*<svg[\s>]/i.test(svg))
+                    return;
+                dataUrl = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+                this._svgMediaDataUrls.set(resolvedSrc, dataUrl);
+            }
+            if (img.getAttribute("src") === resolvedSrc) {
+                img.setAttribute("src", dataUrl);
+            }
+        }
+        catch {
+            // Keep the direct image src; remote servers may already provide a valid MIME type.
+        }
+    }
+    isSourceOnVisibleHemisphere(source, in_mMatrix, vMatrix) {
+        if (Global_js_1.default.insideSphere)
+            return true;
+        const invView = gl_matrix_1.mat4.create();
+        if (!gl_matrix_1.mat4.invert(invView, vMatrix))
+            return true;
+        const cameraPos = gl_matrix_1.vec3.fromValues(invView[12], invView[13], invView[14]);
+        const worldPoint4 = gl_matrix_1.vec4.fromValues(source.point.x, source.point.y, source.point.z, 1);
+        gl_matrix_1.vec4.transformMat4(worldPoint4, worldPoint4, in_mMatrix);
+        const worldPoint = gl_matrix_1.vec3.fromValues(worldPoint4[0], worldPoint4[1], worldPoint4[2]);
+        const normal = gl_matrix_1.vec3.normalize(gl_matrix_1.vec3.create(), worldPoint);
+        const toCamera = gl_matrix_1.vec3.subtract(gl_matrix_1.vec3.create(), cameraPos, worldPoint);
+        return gl_matrix_1.vec3.dot(normal, toCamera) > 0;
+    }
+    updateMediaOverlay(in_mMatrix, vMatrix, pMatrix) {
+        const sourcesWithMedia = this._sources.filter((source) => !!source.mediaStyle?.src);
+        if (!sourcesWithMedia.length) {
+            this.clearMediaOverlay();
+            return;
+        }
+        const host = this.ensureMediaOverlayHost();
+        const canvas = this._webgl.canvas;
+        if (!host || !canvas.clientWidth || !canvas.clientHeight)
+            return;
+        const modelView = gl_matrix_1.mat4.create();
+        const mvp = gl_matrix_1.mat4.create();
+        gl_matrix_1.mat4.multiply(modelView, vMatrix, in_mMatrix);
+        gl_matrix_1.mat4.multiply(mvp, pMatrix, modelView);
+        const width = canvas.clientWidth;
+        const height = canvas.clientHeight;
+        for (let i = 0; i < this._sources.length; i++) {
+            const source = this._sources[i];
+            const style = source.mediaStyle;
+            const img = this._mediaElements[i];
+            if (!style?.src) {
+                if (img)
+                    img.style.display = "none";
+                continue;
+            }
+            if (!this.isSourceOnVisibleHemisphere(source, in_mMatrix, vMatrix)) {
+                if (img)
+                    img.style.display = "none";
+                continue;
+            }
+            const projected = gl_matrix_1.vec4.fromValues(source.point.x, source.point.y, source.point.z, 1);
+            gl_matrix_1.vec4.transformMat4(projected, projected, mvp);
+            if (!projected[3]) {
+                if (img)
+                    img.style.display = "none";
+                continue;
+            }
+            const ndcX = projected[0] / projected[3];
+            const ndcY = projected[1] / projected[3];
+            const ndcZ = projected[2] / projected[3];
+            if (ndcX < -1.15 ||
+                ndcX > 1.15 ||
+                ndcY < -1.15 ||
+                ndcY > 1.15 ||
+                ndcZ < -1.15 ||
+                ndcZ > 1.15) {
+                if (img)
+                    img.style.display = "none";
+                continue;
+            }
+            const mediaEl = this.ensureMediaElement(i, style);
+            if (!mediaEl.parentElement)
+                host.appendChild(mediaEl);
+            const px = (ndcX * 0.5 + 0.5) * width;
+            const py = (1 - (ndcY * 0.5 + 0.5)) * height;
+            const baseSize = source.shapeSize || CatalogueGL.STANDARD_SHAPE_SIZE;
+            const size = Math.max(8, baseSize * (style.scale ?? 2.4));
+            const rotation = style.rotationDeg ?? 0;
+            mediaEl.style.display = "block";
+            mediaEl.style.left = `${px - size / 2}px`;
+            mediaEl.style.top = `${py - size / 2}px`;
+            mediaEl.style.width = `${size}px`;
+            mediaEl.style.height = `${size}px`;
+            mediaEl.style.opacity = `${style.opacity ?? 1}`;
+            mediaEl.style.transform = `rotate(${rotation}deg)`;
+        }
     }
     sourceMatches(left, right) {
         if (left === right)
@@ -8427,7 +8794,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;
             }
         }
     }
@@ -8451,7 +8819,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;
             }
         }
     }
@@ -8482,9 +8851,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);
@@ -8518,50 +8889,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;
@@ -8570,12 +8899,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;
             }
         });
     }
@@ -8592,7 +8923,7 @@ class CatalogueGL {
             };
         }
         const sources = [];
-        pickedIndexes.forEach(idx => {
+        pickedIndexes.forEach((idx) => {
             const source = this._sources[idx];
             if (source)
                 sources.push(source);
@@ -8622,7 +8953,7 @@ class CatalogueGL {
         }
         const selectionState = [];
         const selectedSources = [];
-        clickedIndexes.forEach(idx => {
+        clickedIndexes.forEach((idx) => {
             const source = this._sources[idx];
             if (!source)
                 return;
@@ -8640,31 +8971,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)
@@ -8711,7 +9054,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) {
@@ -8745,6 +9089,7 @@ class CatalogueGL {
         // draw
         const numItems = this.vertexCataloguePosition.length / CatalogueGL.ELEM_SIZE;
         this._webgl.drawArrays(this._webgl.POINTS, 0, numItems);
+        this.updateMediaOverlay(in_mMatrix, vMatrix, pMatrix);
         this._oldMouseCoords = in_mouseHelper.xyz;
     }
 }
@@ -10336,11 +10681,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;
@@ -14643,7 +14986,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)
@@ -14656,7 +15001,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,
@@ -14675,33 +15020,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());
@@ -16318,6 +16677,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);
@@ -16326,6 +16688,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;
@@ -16344,6 +16708,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)));
@@ -16388,8 +16769,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;
 
@@ -16422,7 +16839,6 @@ class TerraPolylineSetGL {
     _providerUrl;
     _metadataManager;
     _webgl;
-    _visibleTilesManager;
     static ELEM_SIZE = 3;
     static BYTES_X_ELEM = new Float32Array().BYTES_PER_ELEMENT;
     _kind = 'TerraPolylineSetGL';
@@ -16433,13 +16849,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) {
@@ -18765,7 +19180,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);