astro-viewer 3.0.0 → 3.2.0

package/lib-esm/utils/FoVUtils.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 'use strict';
 /**
  * @author Fabrizio Giordano (Fab)

package/lib-esm/utils/GeoJSONParser.d.ts

@@ -0,0 +1,19 @@
+import { Point } from '../model/Point.js';
+export type GeoJSONProperties = Record<string, unknown>;
+export interface ParsedGeoJSONFeature {
+    id?: string | number;
+    geometryType: 'Polygon' | 'MultiPolygon';
+    properties: GeoJSONProperties;
+    polygons: Point[][];
+}
+declare class GeoJSONParser {
+    static isGeoJSON(value: unknown): boolean;
+    static parseGeoJSON(value: unknown): ParsedGeoJSONFeature[];
+    private static parseFeature;
+    private static parseGeometry;
+    private static parseMultiPolygonCoordinates;
+    private static parsePolygonCoordinates;
+    private static parseLinearRing;
+    private static parsePosition;
+}
+export default GeoJSONParser;

package/lib-esm/utils/GeoJSONParser.js

@@ -0,0 +1,112 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+import { CoordsType } from './CoordsType.js';
+import { Point } from '../model/Point.js';
+class GeoJSONParser {
+    static isGeoJSON(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const type = value.type;
+        return type === 'FeatureCollection'
+            || type === 'Feature'
+            || type === 'Polygon'
+            || type === 'MultiPolygon'
+            || type === 'GeometryCollection';
+    }
+    static parseGeoJSON(value) {
+        if (!value || typeof value !== 'object') {
+            throw new Error('GeoJSON root must be an object');
+        }
+        const obj = value;
+        if (obj.type === 'FeatureCollection') {
+            if (!Array.isArray(obj.features))
+                throw new Error('GeoJSON FeatureCollection has no features array');
+            return obj.features.flatMap((feature) => GeoJSONParser.parseFeature(feature));
+        }
+        if (obj.type === 'Feature')
+            return GeoJSONParser.parseFeature(obj);
+        if (obj.type === 'Polygon' || obj.type === 'MultiPolygon' || obj.type === 'GeometryCollection') {
+            return GeoJSONParser.parseGeometry(obj, {});
+        }
+        throw new Error(`Unsupported GeoJSON type: ${obj.type ?? 'unknown'}`);
+    }
+    static parseFeature(value) {
+        if (!value || typeof value !== 'object')
+            throw new Error('GeoJSON feature must be an object');
+        const feature = value;
+        if (feature.type !== 'Feature')
+            throw new Error('GeoJSON feature has invalid type');
+        if (!feature.geometry)
+            return [];
+        return GeoJSONParser.parseGeometry(feature.geometry, feature.properties ?? {}, feature.id);
+    }
+    static parseGeometry(geometry, properties, id) {
+        if (geometry.type === 'Polygon') {
+            return [{
+                    id,
+                    geometryType: 'Polygon',
+                    properties,
+                    polygons: GeoJSONParser.parsePolygonCoordinates(geometry.coordinates),
+                }];
+        }
+        if (geometry.type === 'MultiPolygon') {
+            return [{
+                    id,
+                    geometryType: 'MultiPolygon',
+                    properties,
+                    polygons: GeoJSONParser.parseMultiPolygonCoordinates(geometry.coordinates),
+                }];
+        }
+        if (geometry.type === 'GeometryCollection') {
+            if (!Array.isArray(geometry.geometries))
+                return [];
+            return geometry.geometries.flatMap((child) => GeoJSONParser.parseGeometry(child, properties, id));
+        }
+        return [];
+    }
+    static parseMultiPolygonCoordinates(coordinates) {
+        if (!Array.isArray(coordinates))
+            throw new Error('GeoJSON MultiPolygon coordinates must be an array');
+        return coordinates.flatMap((polygonCoordinates) => GeoJSONParser.parsePolygonCoordinates(polygonCoordinates));
+    }
+    static parsePolygonCoordinates(coordinates) {
+        if (!Array.isArray(coordinates))
+            throw new Error('GeoJSON Polygon coordinates must be an array');
+        return coordinates
+            .map((ring) => GeoJSONParser.parseLinearRing(ring))
+            .filter((ring) => ring.length >= 3);
+    }
+    static parseLinearRing(ring) {
+        if (!Array.isArray(ring))
+            throw new Error('GeoJSON linear ring must be an array');
+        const points = ring.map((position) => GeoJSONParser.parsePosition(position));
+        if (points.length > 1) {
+            const first = points[0];
+            const last = points[points.length - 1];
+            if (first.lonDeg === last.lonDeg && first.latDeg === last.latDeg)
+                points.pop();
+        }
+        return points;
+    }
+    static parsePosition(position) {
+        if (!Array.isArray(position) || position.length < 2) {
+            throw new Error('GeoJSON position must be [longitude, latitude]');
+        }
+        const [lonDeg, latDeg] = position;
+        if (!Number.isFinite(lonDeg) || !Number.isFinite(latDeg)) {
+            throw new Error('GeoJSON position contains non-finite longitude/latitude');
+        }
+        return new Point({ lonDeg, latDeg }, CoordsType.GEOGRAPHIC);
+    }
+}
+export default GeoJSONParser;

package/lib-esm/utils/GeomUtils.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 import { Point } from "../model/Point.js";
 import Point2D from "../model/Point2D.js";
 import { CoordsType } from "./CoordsType.js";

package/lib-esm/utils/MouseHelper.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 /**
  * @author Fabrizio Giordano (Fab)
  */

package/lib-esm/utils/PerspectiveMatrixManager.js

@@ -1,4 +1,17 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 import { mat4 } from "gl-matrix";
+import { bootSetup } from "../Config.js";
 export class PerspectiveMatrixManager {
     _pMatrix;
     _aspectRatio = 1;
@@ -29,7 +42,9 @@ export class PerspectiveMatrixManager {
             const cf = c2 * Math.sin(beta);
             farPlane = cf > 0 ? cf : r;
         }
-        mat4.perspective(p, (fovDeg * Math.PI) / 180, this._aspectRatio, nearPlane, farPlane);
+        const effectiveFovDeg = insideSphere ? bootSetup.inside_camera_fov_deg : fovDeg;
+        const effectiveNearPlane = insideSphere ? Math.max(nearPlane, 0.001) : nearPlane;
+        mat4.perspective(p, (effectiveFovDeg * Math.PI) / 180, this._aspectRatio, effectiveNearPlane, farPlane);
         this._pMatrix = p;
         return p;
     }

package/lib-esm/utils/RayPickingUtils.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 /**
  * @author Fabrizio Giordano (Fab)
  */

package/lib-esm/utils/STCSParser.d.ts

@@ -2,14 +2,18 @@
  * @author Fabrizio Giordano (Fab77)
  */
 import { Point } from "../model/Point.js";
+import { CoordsType } from "./CoordsType.js";
 export interface STCSParseResult {
     totpoints: number;
     polygons: Point[][];
 }
+export interface STCSParseOptions {
+    coordsType?: CoordsType.ASTRO | CoordsType.GEOGRAPHIC;
+}
 declare class STCSParser {
-    static parseSTCS(stcs: string): STCSParseResult;
+    static parseSTCS(stcs: string, options?: STCSParseOptions): STCSParseResult;
     static cleanStcs(stcs: string): string;
-    static parsePolygon(stcs: string): STCSParseResult;
-    static parseCircle(stcs: string): STCSParseResult;
+    static parsePolygon(stcs: string, options?: STCSParseOptions): STCSParseResult;
+    static parseCircle(stcs: string, options?: STCSParseOptions): STCSParseResult;
 }
 export default STCSParser;

package/lib-esm/utils/STCSParser.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 /**
  * @author Fabrizio Giordano (Fab77)
  */
@@ -5,15 +17,15 @@ import { Point } from "../model/Point.js";
 import { CoordsType } from "./CoordsType.js";
 import global from "../Global.js";
 class STCSParser {
-    static parseSTCS(stcs) {
+    static parseSTCS(stcs, options = {}) {
         const stcsParsed = STCSParser.cleanStcs(stcs);
         let totPoints = 0;
         const polygons = [];
         if (stcsParsed.includes("POLYGON")) {
-            return STCSParser.parsePolygon(stcsParsed);
+            return STCSParser.parsePolygon(stcsParsed, options);
         }
         else if (stcsParsed.includes("CIRCLE")) {
-            return STCSParser.parseCircle(stcsParsed);
+            return STCSParser.parseCircle(stcsParsed, options);
         }
         else {
             console.warn("STCS not recognised");
@@ -36,10 +48,11 @@ class STCSParser {
         s = s.replace(/ {2,}/g, ' ').trim();
         return s;
     }
-    static parsePolygon(stcs) {
+    static parsePolygon(stcs, options = {}) {
         let totPoints = 0;
         const polygons = [];
         const MAX_DECIMALS = global.MAX_DECIMALS ?? 12;
+        const coordsType = options.coordsType ?? CoordsType.ASTRO;
         const polys = stcs.split("POLYGON ");
         for (let i = 1; i < polys.length; i++) {
             const currPoly = [];
@@ -54,9 +67,11 @@ class STCSParser {
             }
             if (points.length > 2) {
                 for (let p = 0; p < points.length - 1; p += 2) {
-                    const raDeg = Number(parseFloat(points[p]).toFixed(MAX_DECIMALS));
-                    const decDeg = Number(parseFloat(points[p + 1]).toFixed(MAX_DECIMALS));
-                    const point = new Point({ raDeg, decDeg }, CoordsType.ASTRO);
+                    const xDeg = Number(parseFloat(points[p]).toFixed(MAX_DECIMALS));
+                    const yDeg = Number(parseFloat(points[p + 1]).toFixed(MAX_DECIMALS));
+                    const point = coordsType === CoordsType.GEOGRAPHIC
+                        ? new Point({ lonDeg: xDeg, latDeg: yDeg }, CoordsType.GEOGRAPHIC)
+                        : new Point({ raDeg: xDeg, decDeg: yDeg }, CoordsType.ASTRO);
                     currPoly.push(point);
                     totPoints += 1;
                 }
@@ -66,9 +81,10 @@ class STCSParser {
         return { totpoints: totPoints, polygons };
     }
     // Example format: "CIRCLE ICRS 8.739685 4.38147 0.027833"
-    static parseCircle(stcs) {
+    static parseCircle(stcs, options = {}) {
         let totPoints = 0;
         const polygons = [];
+        const coordsType = options.coordsType ?? CoordsType.ASTRO;
         const polys = stcs.split("CIRCLE ");
         for (let i = 1; i < polys.length; i++) {
             const currPoly = [];
@@ -83,7 +99,9 @@ class STCSParser {
             for (let p = npoints; p > 0; p--) {
                 const curra = radius * Math.cos(p * alpha) + ra;
                 const curdec = radius * Math.sin(p * alpha) + dec;
-                const point = new Point({ raDeg: curra, decDeg: curdec }, CoordsType.ASTRO);
+                const point = coordsType === CoordsType.GEOGRAPHIC
+                    ? new Point({ lonDeg: curra, latDeg: curdec }, CoordsType.GEOGRAPHIC)
+                    : new Point({ raDeg: curra, decDeg: curdec }, CoordsType.ASTRO);
                 currPoly.push(point);
                 totPoints += 1;
             }

package/lib-esm/utils/ShaderUtility.js

@@ -1,6 +1,18 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+export {};
 // import global from "../Global.js";
 // // import ShaderManager from "../shader/ShaderManager.js";
-export {};
 // // type GL = WebGLRenderingContext | WebGL2RenderingContext;
 // class ShaderUtility {
 //   private lastUsedProgram: WebGLProgram | null = null;

package/lib-esm/utils/Utils.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 /**
  * @author Fabrizio Giordano (Fab)
  */

package/lib-esm/utils/XYZRayPickingUtils.d.ts

@@ -0,0 +1,27 @@
+import { ReadonlyMat4, ReadonlyVec3, vec3 } from 'gl-matrix';
+import Camera from '../Camera.js';
+import { AbstractSkyEntity } from '../model/AbstractSkyEntity.js';
+import type { XYZTileCoord } from '../model/earth/XYZTypes.js';
+export type XYZLonLat = {
+    lonDeg: number;
+    latDeg: number;
+};
+declare class XYZRayPickingUtils {
+    static getRayFromMouse(mouseX: number, mouseY: number, pMatrix: ReadonlyMat4, webgl: WebGL2RenderingContext, vMatrix: ReadonlyMat4): vec3;
+    static raySphere(rayOrigWorld: ReadonlyVec3, rayDirectionWorld: ReadonlyVec3, sphere: Pick<AbstractSkyEntity, 'center' | 'radius'>): number;
+    static getIntersectionPointWithModel(mouseX: number, mouseY: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4): [number, number, number] | null;
+    static getLonLatFromMouse(mouseX: number, mouseY: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4): XYZLonLat | null;
+    static getTileFromMouse(mouseX: number, mouseY: number, z: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4): XYZTileCoord | null;
+    static getVisibleTilesFromViewport(z: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4, sampleCount?: number, padding?: number): XYZTileCoord[];
+    static modelPointToLonLat(point: Readonly<[number, number, number]>): XYZLonLat;
+    static lonLatToTile(lonDeg: number, latDeg: number, z: number): XYZTileCoord;
+    static getNeighborTiles(tile: XYZTileCoord, ring?: number): XYZTileCoord[];
+    static deduplicateTiles(tiles: XYZTileCoord[]): XYZTileCoord[];
+    private static fillSmallTileGaps;
+    private static latToTileY;
+    private static isMercatorLatitude;
+    private static wrapTileX;
+    private static clampTileY;
+    private static mat4MultiplyVec4;
+}
+export default XYZRayPickingUtils;

package/lib-esm/utils/XYZRayPickingUtils.js

@@ -0,0 +1,226 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+/**
+ * Ray picking helpers for XYZ/WebMercator maps.
+ *
+ * Unlike RayPickingUtils, this module has no HEALPix dependency. It intersects
+ * screen rays with an XYZ sphere, converts the hit to lon/lat, then maps that
+ * position to XYZ z/x/y tile coordinates.
+ */
+'use strict';
+import { mat4, vec3 } from 'gl-matrix';
+const MAX_MERCATOR_LAT = 85.0511287798066;
+class XYZRayPickingUtils {
+    static getRayFromMouse(mouseX, mouseY, pMatrix, webgl, vMatrix) {
+        const gl = webgl;
+        const canvas = gl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const x = (2.0 * mouseX) / rect.width - 1.0;
+        const y = 1.0 - (2.0 * mouseY) / rect.height;
+        const rayClip = [x, y, -1.0, 1.0];
+        const pInv = mat4.create();
+        mat4.invert(pInv, pMatrix);
+        const rayEye4 = [0, 0, 0, 0];
+        XYZRayPickingUtils.mat4MultiplyVec4(pInv, rayClip, rayEye4);
+        const rayEye = [rayEye4[0], rayEye4[1], -1.0, 0.0];
+        const vInv = mat4.create();
+        mat4.invert(vInv, vMatrix);
+        const rayWorld4 = [0, 0, 0, 0];
+        XYZRayPickingUtils.mat4MultiplyVec4(vInv, rayEye, rayWorld4);
+        const rayWorld = vec3.fromValues(rayWorld4[0], rayWorld4[1], rayWorld4[2]);
+        vec3.normalize(rayWorld, rayWorld);
+        return rayWorld;
+    }
+    static raySphere(rayOrigWorld, rayDirectionWorld, sphere) {
+        let intersectionDistance = -1;
+        const L = vec3.create();
+        vec3.subtract(L, rayOrigWorld, sphere.center);
+        const b = vec3.dot(rayDirectionWorld, L);
+        const c = vec3.dot(L, L) - sphere.radius * sphere.radius;
+        const disc = b * b - c;
+        if (disc > 0.0) {
+            const s = Math.sqrt(disc);
+            const ta = -b + s;
+            const tb = -b - s;
+            if (ta >= 0.0 || tb >= 0.0) {
+                intersectionDistance = tb < 0.0 ? ta : Math.min(ta, tb);
+            }
+        }
+        else if (disc === 0.0) {
+            const t = -b;
+            if (t >= 0.0) {
+                intersectionDistance = t;
+            }
+        }
+        return intersectionDistance;
+    }
+    static getIntersectionPointWithModel(mouseX, mouseY, xyzModel, webgl, camera, pMatrix) {
+        const vMatrix = camera.getCameraMatrix();
+        const rayWorld = XYZRayPickingUtils.getRayFromMouse(mouseX, mouseY, pMatrix, webgl, vMatrix);
+        const t = XYZRayPickingUtils.raySphere(camera.getCameraPosition(), rayWorld, xyzModel);
+        if (t < 0) {
+            return null;
+        }
+        const worldHit = vec3.create();
+        vec3.scale(worldHit, rayWorld, t);
+        vec3.add(worldHit, camera.getCameraPosition(), worldHit);
+        const worldHit4 = [worldHit[0], worldHit[1], worldHit[2], 1.0];
+        const modelHit4 = [0, 0, 0, 0];
+        XYZRayPickingUtils.mat4MultiplyVec4(xyzModel.getModelMatrixInverse(), worldHit4, modelHit4);
+        return [modelHit4[0], modelHit4[1], modelHit4[2]];
+    }
+    static getLonLatFromMouse(mouseX, mouseY, xyzModel, webgl, camera, pMatrix) {
+        const hit = XYZRayPickingUtils.getIntersectionPointWithModel(mouseX, mouseY, xyzModel, webgl, camera, pMatrix);
+        return hit ? XYZRayPickingUtils.modelPointToLonLat(hit) : null;
+    }
+    static getTileFromMouse(mouseX, mouseY, z, xyzModel, webgl, camera, pMatrix) {
+        const lonLat = XYZRayPickingUtils.getLonLatFromMouse(mouseX, mouseY, xyzModel, webgl, camera, pMatrix);
+        if (!lonLat || !XYZRayPickingUtils.isMercatorLatitude(lonLat.latDeg)) {
+            return null;
+        }
+        return XYZRayPickingUtils.lonLatToTile(lonLat.lonDeg, lonLat.latDeg, z);
+    }
+    static getVisibleTilesFromViewport(z, xyzModel, webgl, camera, pMatrix, sampleCount = 9, padding = 2) {
+        const gl = webgl;
+        const canvas = gl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const samples = Math.max(2, Math.floor(sampleCount));
+        const edgeSamples = Math.max(samples * 2 + 1, 21);
+        const safePadding = Math.max(0, Math.floor(padding));
+        const tiles = [];
+        const addSample = (x, y) => {
+            const tile = XYZRayPickingUtils.getTileFromMouse(x, y, z, xyzModel, webgl, camera, pMatrix);
+            if (!tile)
+                return;
+            tiles.push(tile);
+            tiles.push(...XYZRayPickingUtils.getNeighborTiles(tile, safePadding));
+        };
+        for (let iy = 0; iy < samples; iy++) {
+            const y = samples === 1 ? rect.height / 2 : (iy / (samples - 1)) * rect.height;
+            for (let ix = 0; ix < samples; ix++) {
+                const x = samples === 1 ? rect.width / 2 : (ix / (samples - 1)) * rect.width;
+                addSample(x, y);
+            }
+        }
+        for (let i = 0; i < edgeSamples; i++) {
+            const t = edgeSamples === 1 ? 0.5 : i / (edgeSamples - 1);
+            const x = t * rect.width;
+            const y = t * rect.height;
+            addSample(x, 0);
+            addSample(x, rect.height);
+            addSample(0, y);
+            addSample(rect.width, y);
+        }
+        return XYZRayPickingUtils.fillSmallTileGaps(XYZRayPickingUtils.deduplicateTiles(tiles));
+    }
+    static modelPointToLonLat(point) {
+        const [x, y, z] = point;
+        const len = Math.hypot(x, y, z);
+        if (!Number.isFinite(len) || len === 0) {
+            return { lonDeg: 0, latDeg: 0 };
+        }
+        const lonDeg = (Math.atan2(y, x) * 180) / Math.PI;
+        const latDeg = (Math.asin(Math.max(-1, Math.min(1, z / len))) * 180) / Math.PI;
+        return { lonDeg, latDeg };
+    }
+    static lonLatToTile(lonDeg, latDeg, z) {
+        const zoom = Math.max(0, Math.floor(z));
+        const dim = 2 ** zoom;
+        const x = Math.floor(((lonDeg + 180) / 360) * dim);
+        const y = Math.floor(XYZRayPickingUtils.latToTileY(latDeg, zoom));
+        return {
+            z: zoom,
+            x: XYZRayPickingUtils.wrapTileX(x, dim),
+            y: XYZRayPickingUtils.clampTileY(y, dim),
+        };
+    }
+    static getNeighborTiles(tile, ring = 1) {
+        const dim = 2 ** tile.z;
+        const tiles = [];
+        const safeRing = Math.max(0, Math.floor(ring));
+        for (let dx = -safeRing; dx <= safeRing; dx++) {
+            for (let dy = -safeRing; dy <= safeRing; dy++) {
+                tiles.push({
+                    z: tile.z,
+                    x: XYZRayPickingUtils.wrapTileX(tile.x + dx, dim),
+                    y: XYZRayPickingUtils.clampTileY(tile.y + dy, dim),
+                });
+            }
+        }
+        return XYZRayPickingUtils.deduplicateTiles(tiles);
+    }
+    static deduplicateTiles(tiles) {
+        const map = new Map();
+        for (const tile of tiles) {
+            map.set(`${tile.z}/${tile.x}/${tile.y}`, tile);
+        }
+        return Array.from(map.values());
+    }
+    static fillSmallTileGaps(tiles) {
+        if (tiles.length === 0) {
+            return tiles;
+        }
+        const zoom = tiles[0].z;
+        const dim = 2 ** zoom;
+        const map = new Map();
+        const key = (tile) => `${tile.z}/${tile.x}/${tile.y}`;
+        const add = (tile) => {
+            map.set(key(tile), tile);
+        };
+        const has = (x, y) => (y >= 0 && y < dim && map.has(`${zoom}/${XYZRayPickingUtils.wrapTileX(x, dim)}/${y}`));
+        for (const tile of tiles) {
+            add(tile);
+        }
+        for (const tile of tiles) {
+            const x = tile.x;
+            const y = tile.y;
+            if (has(x - 2, y) && !has(x - 1, y)) {
+                add({ z: zoom, x: XYZRayPickingUtils.wrapTileX(x - 1, dim), y });
+            }
+            if (has(x + 2, y) && !has(x + 1, y)) {
+                add({ z: zoom, x: XYZRayPickingUtils.wrapTileX(x + 1, dim), y });
+            }
+            if (has(x, y - 2) && !has(x, y - 1)) {
+                add({ z: zoom, x, y: y - 1 });
+            }
+            if (has(x, y + 2) && !has(x, y + 1)) {
+                add({ z: zoom, x, y: y + 1 });
+            }
+        }
+        return Array.from(map.values());
+    }
+    static latToTileY(latDeg, z) {
+        const lat = Math.max(-MAX_MERCATOR_LAT, Math.min(MAX_MERCATOR_LAT, latDeg));
+        const latRad = (lat * Math.PI) / 180;
+        const dim = 2 ** z;
+        return ((1 - Math.asinh(Math.tan(latRad)) / Math.PI) / 2) * dim;
+    }
+    static isMercatorLatitude(latDeg) {
+        return Math.abs(latDeg) <= MAX_MERCATOR_LAT;
+    }
+    static wrapTileX(x, dim) {
+        return ((x % dim) + dim) % dim;
+    }
+    static clampTileY(y, dim) {
+        return Math.max(0, Math.min(dim - 1, y));
+    }
+    static mat4MultiplyVec4(a, b, out) {
+        const d = b[0], e = b[1], g = b[2], w = b[3];
+        out[0] = a[0] * d + a[4] * e + a[8] * g + a[12] * w;
+        out[1] = a[1] * d + a[5] * e + a[9] * g + a[13] * w;
+        out[2] = a[2] * d + a[6] * e + a[10] * g + a[14] * w;
+        out[3] = a[3] * d + a[7] * e + a[11] * g + a[15] * w;
+        return out;
+    }
+}
+export default XYZRayPickingUtils;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "astro-viewer",
   "description": "Astrobrowser 3d engine.",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "keywords": [
     "HiPS",
     "HiPS cutout",
@@ -49,7 +49,7 @@
     "prod": "npm run clean && tsc -p tsconfig.build.json && webpack --mode=production && npm run web",
     "build": "npm run clean && tsc -p tsconfig.build.json && webpack --mode=production",
     "web": "cp dist/* public/javascripts/; cp -R src/html/javascripts/ public/javascripts/; cp -R src/html/css/ public/css/; cp src/html/*.html public/",
-    "start-server": "python3 -m http.server 8080 -d public",
+    "start-server": "npm run web; python3 -m http.server 8080 -d public",
     "all": "npm run clean; npm run prod; npm run start-server",
     "prepublishOnly": "npm run build"
   },