astro-viewer 3.1.0 → 3.2.0

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

@@ -38,6 +38,7 @@ export class LatLonGrid extends AbstractSkyEntity {
     _showGrid = true;
     _lonArray = [];
     _latArray = [];
+    _bufferKey = '';
     defaultColor = '#41d4d4';
     gridText = new GridTextHelper('lonlat');
     constructor(radius, position, xrad, yrad, name, webgl) {
@@ -84,28 +85,67 @@ export class LatLonGrid extends AbstractSkyEntity {
         }
         gl.useProgram(this._shaderProgram);
     }
-    initBuffers(fovDeg) {
-        const steps = xyzFovHelper.getLonLatSteps(fovDeg);
+    initBuffers(fovDeg, centerSphericalDeg, coarse = false) {
+        const steps = xyzFovHelper.getLonLatSteps(fovDeg, coarse);
         this._lonStep = steps.lonStep;
         this._latStep = steps.latStep;
         this._segmentStep = Math.max(Math.min(this._lonStep, this._latStep), 0.25);
         this._lonArray = [];
         this._latArray = [];
-        for (let lon = -180; lon < 180; lon += this._lonStep) {
+        const center = centerSphericalDeg
+            ? {
+                lon: this.normalizeLon(centerSphericalDeg.phi > 180 ? centerSphericalDeg.phi - 360 : centerSphericalDeg.phi),
+                lat: 90 - centerSphericalDeg.theta,
+            }
+            : null;
+        const localGrid = !!center && !coarse && fovDeg < 2;
+        const lonValues = localGrid
+            ? this.buildLonRange(center.lon, Math.max(fovDeg * 4, this._lonStep * 3), this._lonStep)
+            : this.buildLonRange(0, 180, this._lonStep);
+        const latValues = localGrid
+            ? this.buildLatRange(center.lat, Math.max(fovDeg * 4, this._latStep * 3), this._latStep)
+            : this.buildLatRange(0, 90, this._latStep);
+        const latSegmentRange = localGrid && center
+            ? this.buildLatRange(center.lat, Math.max(fovDeg * 4, this._latStep * 3), this._segmentStep)
+            : this.buildLatRange(0, 90, this._segmentStep);
+        const lonSegmentRange = localGrid && center
+            ? this.buildLonRange(center.lon, Math.max(fovDeg * 4, this._lonStep * 3), this._segmentStep)
+            : this.buildLonRange(0, 180, this._segmentStep);
+        for (const lon of lonValues) {
             const vertices = [];
-            for (let lat = -90; lat <= 90; lat += this._segmentStep) {
+            for (const lat of latSegmentRange) {
                 vertices.push(...this.lonLatToCartesian(lon, Math.min(lat, 90)));
             }
             this._lonArray.push(new Float32Array(vertices));
         }
-        for (let lat = -90 + this._latStep; lat < 90; lat += this._latStep) {
+        for (const lat of latValues) {
             const vertices = [];
-            for (let lon = -180; lon <= 180; lon += this._segmentStep) {
+            if (lat <= -90 || lat >= 90)
+                continue;
+            for (const lon of lonSegmentRange) {
                 vertices.push(...this.lonLatToCartesian(Math.min(lon, 180), lat));
             }
             this._latArray.push(new Float32Array(vertices));
         }
     }
+    buildLonRange(centerLon, halfSpan, step) {
+        const values = [];
+        const start = Math.floor((centerLon - halfSpan) / step) * step;
+        const end = Math.ceil((centerLon + halfSpan) / step) * step;
+        for (let lon = start; lon <= end; lon += step) {
+            values.push(this.normalizeLon(lon));
+        }
+        return values;
+    }
+    buildLatRange(centerLat, halfSpan, step) {
+        const values = [];
+        const start = Math.max(-90, Math.floor((centerLat - halfSpan) / step) * step);
+        const end = Math.min(90, Math.ceil((centerLat + halfSpan) / step) * step);
+        for (let lat = start; lat <= end; lat += step) {
+            values.push(lat);
+        }
+        return values;
+    }
     lonLatToCartesian(lonDeg, latDeg) {
         const lonRad = degToRad(lonDeg);
         const latRad = degToRad(latDeg);
@@ -116,17 +156,28 @@ export class LatLonGrid extends AbstractSkyEntity {
             Math.sin(latRad),
         ];
     }
-    refresh(fovDeg) {
-        if (Math.abs(this._fovDeg - fovDeg) > 1e-6) {
+    refresh(fovDeg, input) {
+        const coarse = !!input.cameraMoving;
+        const steps = xyzFovHelper.getLonLatSteps(fovDeg, coarse);
+        const center = input.centerSphericalDeg;
+        const localGrid = !!center && !coarse && fovDeg < 2;
+        const centerLon = center ? this.normalizeLon(center.phi > 180 ? center.phi - 360 : center.phi) : 0;
+        const centerLat = center ? 90 - center.theta : 0;
+        const centerKey = localGrid
+            ? `${this.roundToStep(centerLon, Math.max(steps.lonStep, fovDeg))}:${this.roundToStep(centerLat, Math.max(steps.latStep, fovDeg))}`
+            : 'global';
+        const bufferKey = `${coarse ? 'coarse' : 'settled'}:${steps.lonStep}:${steps.latStep}:${centerKey}`;
+        if (this._bufferKey !== bufferKey) {
             this._fovDeg = fovDeg;
-            this.initBuffers(this._fovDeg);
+            this._bufferKey = bufferKey;
+            this.initBuffers(this._fovDeg, input.centerSphericalDeg, coarse);
         }
     }
     refreshFoV(input) {
         if (!input.camera || !input.pMatrix)
             return this._fovDeg;
         this._fovObj.getFoV(global.insideSphere, this, input.camera, input.pMatrix);
-        this.refresh(this._fovObj.minFoV);
+        this.refresh(this._fovObj.minFoV, input);
         return this._fovObj.minFoV;
     }
     getMinFoVDeg() {

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -65,6 +65,9 @@ export default class Tile {
     getReadyState() {
         return this._ready;
     }
+    isLoading() {
+        return !this._ready && !this._abort;
+    }
     get cacheTime0() {
         return this._cacheTime0;
     }

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

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

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

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

package/lib-esm/model/terra/TerraFootprintSetGL.d.ts

@@ -1,4 +1,10 @@
 import { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+import { CoordsType } from '../../utils/CoordsType.js';
+import { ParsedGeoJSONFeature } from '../../utils/GeoJSONParser.js';
 export declare class TerraFootprintSetGL extends FootprintSetGL {
     _kind: string;
+    protected _coordsType: CoordsType.GEOGRAPHIC;
+    addGeoJSONFeatures(features: ParsedGeoJSONFeature[]): void;
+    private createGeoJSONMetadataColumns;
+    private createGeoJSONDetails;
 }

package/lib-esm/model/terra/TerraFootprintSetGL.js

@@ -11,6 +11,48 @@
  * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
  */
 import { FootprintSetGL } from '../footprints/FootprintSetGL.js';
+import { CoordsType } from '../../utils/CoordsType.js';
+import { Footprint } from '../footprints/Footprint.js';
+import { MetadataColumn } from '../MetadataColumn.js';
+import { MetadataManager } from '../MetadataManager.js';
+import { ColumnType } from '../MetadataColumn.js';
 export class TerraFootprintSetGL extends FootprintSetGL {
     _kind = 'TerraFootprintSetGL';
+    _coordsType = CoordsType.GEOGRAPHIC;
+    addGeoJSONFeatures(features) {
+        this._ready = false;
+        this.clearFootprints();
+        this._metadataManager = new MetadataManager(this.createGeoJSONMetadataColumns(features));
+        for (const feature of features) {
+            const footprint = Footprint.fromPolygons(feature.polygons, this.createGeoJSONDetails(feature), CoordsType.GEOGRAPHIC);
+            if (footprint.valid) {
+                this.addFootprint(footprint);
+                this.totPoints += footprint.totPoints;
+                this.totConvexPoints += footprint.totConvexPoints;
+            }
+        }
+        this._ready = true;
+        this._bufferInitialised = false;
+    }
+    createGeoJSONMetadataColumns(features) {
+        const names = new Set();
+        features.forEach(feature => Object.keys(feature.properties).forEach(name => names.add(name)));
+        return Array.from(names).map((name, index) => {
+            const values = features.map(feature => feature.properties[name]).filter(value => value !== null && value !== undefined && value !== '');
+            const isNumber = values.length > 0 && values.every(value => typeof value === 'number' || !Number.isNaN(Number(value)));
+            const isName = /^name$|nome|denominazione|label|title/i.test(name);
+            return new MetadataColumn({
+                index,
+                name,
+                columnType: isName ? ColumnType.MAIN_NAME : (isNumber ? ColumnType.NUMBER : ColumnType.STRING),
+                unit: '',
+            });
+        });
+    }
+    createGeoJSONDetails(feature) {
+        return Object.entries(feature.properties).map(([key, value]) => ({
+            key,
+            value: typeof value === 'number' ? value : String(value ?? ''),
+        }));
+    }
 }

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

@@ -5,5 +5,6 @@
 export declare enum CoordsType {
     CARTESIAN = "cartesian",
     SPHERICAL = "spherical",
-    ASTRO = "astro"
+    ASTRO = "astro",
+    GEOGRAPHIC = "geographic"
 }

package/lib-esm/utils/CoordsType.js

@@ -19,5 +19,6 @@ export var CoordsType;
     CoordsType["CARTESIAN"] = "cartesian";
     CoordsType["SPHERICAL"] = "spherical";
     CoordsType["ASTRO"] = "astro";
+    CoordsType["GEOGRAPHIC"] = "geographic";
 })(CoordsType || (CoordsType = {}));
 // export default CoordsType;

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/PerspectiveMatrixManager.js

@@ -11,6 +11,7 @@
  * 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;
@@ -41,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/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;