@openglobus/og 1.0.0-rc33 → 1.0.0-rc35

package/lib/proj/epsgIo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Registers the CRS in {@link proj4}, taking its definition from epsg.io. Returns whether the
+ * projection became available, i.e. whether the data in that CRS is worth reading again.
+ */
+export declare function defineProjection(crsCode: number): Promise<boolean>;

package/lib/proj/proj4.d.ts

@@ -0,0 +1 @@
+export declare const proj4: any;

package/lib/quadTree/EntityCollectionNode.d.ts

@@ -33,6 +33,8 @@ declare class EntityCollectionNode {
     protected _setExtentBounds(): void;
     __setLonLat__(entity: Entity): LonLat;
     buildTree(entities: Entity[], rightNow?: boolean): void;
+    protected _addEntitiesToChildNodes(entities: Entity[], rightNow?: boolean): void;
+    protected _moveCollectionToChildNodes(): void;
     isInside(entity: Entity): boolean;
     createChildNodes(): void;
     collectRenderCollectionsPASS1(visibleNodes: NodesDict, outArr: EntityCollection[]): void;

package/lib/quadTree/QuadTreeStrategy.d.ts

@@ -128,6 +128,14 @@ export declare class QuadTreeStrategy {
     protected _collectRenderNodes(camera: PlanetCamera): void;
     clear(): void;
     get quadTreeList(): Node[];
+    /**
+     * Returns the most detailed node made under the point, not deeper than the zoom.
+     * @public
+     * @param {LonLat} lonLat - Point.
+     * @param {number} [zoom] - Maximal node zoom.
+     * @returns {Node | null} -
+     */
+    getNodeByLonLat(lonLat: LonLat, zoom?: number): Node | null;
     getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
     getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
     collectVisibleNode(node: Node): void;

package/lib/terrain/GlobusTerrain.d.ts

@@ -45,7 +45,7 @@ type TileData = {
  * @fires loadend
  */
 declare class GlobusTerrain extends EmptyTerrain {
-    events: GlobusTerrainEvents;
+    events: TerrainEvents;
     protected _s: string[];
     protected _requestCount: number;
     protected _requestsPeerSubdomain: number;
@@ -103,6 +103,13 @@ declare class GlobusTerrain extends EmptyTerrain {
      * @param {boolean} [forceLoading=false] - Forces loading even if default filter would skip it.
      */
     loadTerrain(segment: Segment, forceLoading?: boolean): void;
+    /**
+     * Converts loaded segment data to elevations and applies them.
+     * @protected
+     * @param {Segment} segment - Segment that requested terrain data.
+     * @param {any} data - Loaded data.
+     */
+    protected _onTerrainLoaded(segment: Segment, data: any): void;
     protected _getSubdomain(): string;
     buildURL(x: number, y: number, z: number, tileGroup: number): string;
     /**
@@ -122,11 +129,11 @@ declare class GlobusTerrain extends EmptyTerrain {
     /**
      * Sets url rewrite callback, used for custom url rewriting for every tile loading.
      * @public
-     * @param {UrlRewriteFunc} ur - The callback that returns tile custom created url.
+     * @param {UrlRewriteFunc} ur - The callback that returns tile custom-created url.
      */
     setUrlRewriteCallback(ur: UrlRewriteFunc): void;
     /**
-     * Converts loaded data to segment elevation data type(column major elevation data array in meters)
+     * Converts loaded data to segment elevation data type (column major elevation data array in meters)
      * @public
      * @returns {Array.<number> | TypedArray} Column-major elevation data array in meters.
      */
@@ -136,6 +143,7 @@ declare class GlobusTerrain extends EmptyTerrain {
      */
     protected _applyElevationsData(segment: Segment, elevations: number[] | TypedArray | null): void;
 }
-type GlobusTerrainEventsList = ["load", "loadend"];
-type GlobusTerrainEvents = EventsHandler<GlobusTerrainEventsList>;
+export type TerrainEventsList = ["load", "loadend"];
+export type TerrainEvents = EventsHandler<TerrainEventsList>;
+export declare const TERRAIN_EVENTS: TerrainEventsList;
 export { GlobusTerrain };

package/lib/terrain/ProceduralTerrain.d.ts

@@ -0,0 +1,71 @@
+import { EmptyTerrain } from "./EmptyTerrain";
+import type { IEmptyTerrainParams } from "./EmptyTerrain";
+import type { TerrainEvents } from "./GlobusTerrain";
+import { Extent } from "../Extent";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
+import type { Segment } from "../segment/Segment";
+import type { TypedArray } from "../utils/shared";
+export type ProceduralHeights = number[] | TypedArray | null;
+export type GetHeightsFunc = (segment: Segment) => ProceduralHeights | Promise<ProceduralHeights>;
+export interface IProceduralTerrainParams extends IEmptyTerrainParams {
+    getHeights: GetHeightsFunc;
+    plainGridSize?: number;
+    noDataValues?: number[];
+}
+type TileHeights = {
+    heights: ProceduralHeights;
+    extent: Extent;
+};
+/**
+ * Terrain with the heights made by a function, without a server.
+ * @class
+ * @extends {EmptyTerrain}
+ * @param {string} [name="ProceduralTerrain"] - Terrain provider name.
+ * @param {IProceduralTerrainParams} options - Provider options:
+ * @param {GetHeightsFunc} options.getHeights - Returns the segment heights, or a promise of them, rows from north
+ * to south, vertices evenly spaced in segment.getExtent(), or null when the segment has no terrain.
+ * (plainGridSize + 1)² heights are taken as they are. Larger (2^n + 1)² vertices, or 2^n x 2^n pixels, are reduced
+ * to them keeping peaks and pits. Segments of the height requests are not in the quad tree, their node is null.
+ * @param {number} [options.plainGridSize=32] - Elevation grid size.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Segment grid sizes by zoom, the same as RgbTerrain ones by default.
+ * @param {Array.<number>} [options.noDataValues] - Heights of no data.
+ *
+ * @fires load
+ * @fires loadend
+ */
+declare class ProceduralTerrain extends EmptyTerrain {
+    events: TerrainEvents;
+    /**
+     * Height requests counters as GlobusTerrain loader ones: promises in progress, the queue is empty,
+     * every request starts right away.
+     */
+    loader: {
+        loading: number;
+        queue: Segment[];
+    };
+    protected _getHeights: GetHeightsFunc;
+    protected _heightsCache: Record<string, TileHeights>;
+    protected _pendingHeights: Record<string, Promise<TileHeights>>;
+    protected _loadendFrame: number;
+    constructor(name: string | null, options: IProceduralTerrainParams);
+    clearCache(): void;
+    abortLoading(): void;
+    loadTerrain(segment: Segment): void;
+    protected _applyHeights(segment: Segment, tile: TileHeights): void;
+    protected _checkLoadend: () => void;
+    /**
+     * Returns the height under the point from the zoom tile heights, they are made for the request if there are none.
+     * Calls back right away and returns true when the heights are ready.
+     */
+    getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
+    protected _getPointTileHeights(lonLat: LonLat, zoom: number, outPoint: Vec3): TileHeights | Promise<TileHeights> | null;
+    /**
+     * Returns the segment heights, or the promise of them while they are made. Every tile heights are requested once,
+     * failed requests are made again next time.
+     */
+    protected _getSegmentHeights(segment: Segment): TileHeights | Promise<TileHeights>;
+    protected _setHeights(segment: Segment, extent: Extent, heights: ProceduralHeights): TileHeights;
+    protected _toGridHeights(segment: Segment, heights: ProceduralHeights): ProceduralHeights;
+}
+export { ProceduralTerrain };

package/lib/terrain/RgbTerrain.d.ts

@@ -4,6 +4,7 @@ import { GlobusTerrain } from "./GlobusTerrain";
 import { LonLat } from "../LonLat";
 import { Segment } from "../segment/Segment";
 import type { TypedArray } from "../utils/shared";
+import type { DecodeHeightsRowFunc, IRgbHeightsParams } from "./terrainUtils";
 export type RgbTerrainEncoding = "rgb" | "terrarium";
 export type RgbToHeightFunc = (r: number, g: number, b: number, minHeight: number, resolution: number) => number;
 export declare function rgbToHeightRgb(r: number, g: number, b: number, minHeight: number, resolution: number): number;
@@ -39,16 +40,37 @@ declare class RgbTerrain extends GlobusTerrain {
     protected _minHeight: number;
     protected _resolution: number;
     protected _rgbToHeight: RgbToHeightFunc;
+    protected _encoding: number;
     constructor(name: string | null, options?: IRgbTerrainParams);
     static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
     rgb2Height(r: number, g: number, b: number): number;
     isBlur(segment: Segment): boolean;
     protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
+    /**
+     * Returns true when "rgb" or "terrarium" heights are decoded without rgb2Height calls.
+     * @protected
+     * @returns {boolean} -
+     */
+    protected _isBuiltInDecoding(): boolean;
+    /**
+     * Returns true when the loaded image heights are created in the worker.
+     * @protected
+     * @param {HTMLImageElement | ImageBitmap} data - Loaded image.
+     * @returns {boolean} -
+     */
+    protected _isWorkerDecoding(data: HTMLImageElement | ImageBitmap): boolean;
+    protected _getHeightsParams(segment: Segment | null, tileZoom: number, preventChildren: boolean): IRgbHeightsParams;
+    protected _createDecodeRow(rgbaData: number[] | TypedArray, p: IRgbHeightsParams): DecodeHeightsRowFunc;
+    /**
+     * Saves the tile and its subdivision levels heights to cache.
+     * @protected
+     * @returns {Float32Array} - Tile heights.
+     */
+    protected _cacheHeightsLevels(heights: Float32Array, p: IRgbHeightsParams, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent): Float32Array;
+    protected _onTerrainLoaded(segment: Segment, data: HTMLImageElement | ImageBitmap): void;
     protected _createHeights(data: HTMLImageElement | ImageBitmap, segment: Segment | null, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
     getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
-    extractElevationSimple(rgbaData: number[] | TypedArray, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentOffsetX: number, availableParentOffsetY: number, availableZoomDiff: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, heightFactor: number | undefined, imageSize: number): void;
+    extractHeightsRgbRow(rgbaData: number[] | TypedArray, row: number, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: TypedArray | number[] | null, availableParentOffsetX: number, availableParentOffsetY: number, availableZoomDiff: number, skipPositiveHeights: boolean, size: number, parentScale: number, outHeights: Float32Array, noDataHeight: number): void;
     extractElevationTilesRgbNonPowerOfTwo(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, heightFactor?: number): void;
-    extractElevationTilesRgb(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]): void;
-    extractElevationTilesRgbNoChildren(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray): void;
 }
 export { RgbTerrain };

package/lib/terrain/index.d.ts

@@ -5,6 +5,8 @@ import { RgbTerrain, rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium
 import type { IRgbTerrainParams, RgbTerrainEncoding, RgbToHeightFunc } from "./RgbTerrain";
 import { GlobusRgbTerrain } from "./GlobusRgbTerrain";
 import { MapterhornTerrain } from "./MapterhornTerrain";
-export { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain, MapterhornTerrain };
+import { ProceduralTerrain } from "./ProceduralTerrain";
+import type { GetHeightsFunc, IProceduralTerrainParams } from "./ProceduralTerrain";
+export { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain, MapterhornTerrain, ProceduralTerrain };
 export { rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium, resolveRgbToHeightFunc };
-export type { IRgbTerrainParams, RgbTerrainEncoding, RgbToHeightFunc };
+export type { IRgbTerrainParams, RgbTerrainEncoding, RgbToHeightFunc, GetHeightsFunc, IProceduralTerrainParams };

package/lib/terrain/terrainUtils.d.ts

@@ -0,0 +1,145 @@
+import type { TypedArray } from "../utils/shared";
+import type { Extent } from "../Extent";
+export declare const RGB_ENCODING_CUSTOM = -1;
+export declare const RGB_ENCODING_RGB = 0;
+export declare const RGB_ENCODING_TERRARIUM = 1;
+/** Segment grid sizes by zoom of the elevation terrains. */
+export declare const TERRAIN_GRID_SIZE_BY_ZOOM: number[];
+/** Writes a row of pixel heights, NaN for no data pixels. */
+export type DecodeHeightsRowFunc = (row: number, outHeights: Float32Array) => void;
+export interface IRgbDecodeParams {
+    encoding: number;
+    minHeight: number;
+    resolution: number;
+    heightFactor: number;
+    noDataValues: number[] | TypedArray;
+    parentData: number[] | TypedArray | null;
+    parentOffsetX: number;
+    parentOffsetY: number;
+    parentZoomDiff: number;
+    skipPositiveHeights: boolean;
+}
+export interface IRgbHeightsParams {
+    decode: IRgbDecodeParams;
+    size: number;
+    gridSize: number;
+    levels: number;
+    noDataHeight: number;
+}
+/**
+ * Returns pixel grid cells for the image size, 2^n and (2^n + 1) sizes only.
+ * @param {number} size - Image size.
+ * @returns {number} -
+ */
+export declare function getGridCells(size: number): number;
+/**
+ * Returns vertex grid cells for the image size. 2^n images have vertices at the pixel centers and corners,
+ * (2^n + 1) images are the grid itself.
+ * @param {number} size - Image size.
+ * @returns {number} -
+ */
+export declare function getVertexGridCells(size: number): number;
+/**
+ * Returns subdivision levels of the image tile. Native zoom levels are not finer than the image pixels,
+ * finer data comes with their own tiles. Levels above the native zooms go down to the vertex grid.
+ * @param {number} size - Image size.
+ * @param {number} gridSize - Tile grid size.
+ * @param {number} tileZoom - Image tile zoom.
+ * @param {number} maxZoom - Maximal terrain zoom.
+ * @param {number} maxNativeZoom - Maximal zoom of the terrain tiles.
+ * @returns {number} -
+ */
+export declare function getSubdivisionLevels(size: number, gridSize: number, tileZoom: number, maxZoom: number, maxNativeZoom: number): number;
+export declare function getParentHeight(oneByDz2: number, offsetX: number, offsetY: number, heights: TypedArray | number[], i: number, j: number, skipPositiveHeights?: boolean): number;
+/**
+ * Decodes "rgb" or "terrarium" encoded pixel row heights.
+ * @param {number[] | TypedArray} rgbaData - Image RGBA data.
+ * @param {number} row - Pixel row.
+ * @param {number} size - Image size.
+ * @param {number} parentScale - Parent grid cells by image grid cells.
+ * @param {IRgbDecodeParams} p - Decode parameters.
+ * @param {Float32Array} outHeights - Row heights.
+ * @param {number} noDataHeight - Height for no data pixels.
+ */
+export declare function decodeRgbHeightsRow(rgbaData: number[] | TypedArray, row: number, size: number, parentScale: number, p: IRgbDecodeParams, outHeights: Float32Array, noDataHeight: number): void;
+/**
+ * Returns the height at the tile edge, extrapolated from the edge pixel p0 inwards through p1 and p2.
+ * The slope is limited (minmod), so peaks, pits and slope breaks at the edge are not overshot.
+ * @param {number} p0 - Edge pixel height.
+ * @param {number} p1 - Next pixel height.
+ * @param {number} p2 - Pixel height after the next.
+ * @returns {number} -
+ */
+export declare function getEdgeHeight(p0: number, p1: number, p2: number): number;
+/**
+ * Returns the ground height at the point of the tile heights grid, on the grid triangles as they are rendered.
+ * @param {number} x - Point x in the tile extent projection.
+ * @param {number} y - Point y in the tile extent projection.
+ * @param {Extent} extent - Tile extent.
+ * @param {number[] | TypedArray} heights - Tile heights grid, rows from north to south.
+ * @returns {number} -
+ */
+export declare function getGroundHeight(x: number, y: number, extent: Extent, heights: number[] | TypedArray): number;
+/**
+ * Converts size x size pixel heights to the vertex grid in the pixel corners, (size + 1) x (size + 1),
+ * or in the pixel centers and corners, (2 * size + 1) x (2 * size + 1). Pixel center vertices keep the pixel heights.
+ * @param {Float32Array} pixels - Pixel heights, NaN for no data.
+ * @param {number} size - Image size.
+ * @param {number} noDataHeight - Height for vertices without data around.
+ * @param {boolean} [pixelCenters=true] - Vertices at the pixel centers too.
+ * @returns {Float32Array} -
+ */
+export declare function createVertexGrid(pixels: Float32Array, size: number, noDataHeight: number, pixelCenters?: boolean): Float32Array;
+/** Peak and pit pixels, and their place in the vertex grid. */
+export interface IGridPeaks {
+    pixels: Float32Array;
+    size: number;
+    /** Peaks by pixel rows, columns of row r are cols[rowStart[r]] ... cols[rowStart[r + 1] - 1]. */
+    rowStart: Int32Array;
+    cols: Int32Array;
+    /** 1 for peaks, 0 for pits. */
+    isPeak: Uint8Array;
+    /** Pixel p is at (p + offset) * scale vertex. */
+    offset: number;
+    scale: number;
+}
+/**
+ * Finds the pixels that are not lower (peaks) or not higher (pits) than the pixels around,
+ * and differ from at least one of them.
+ * @param {Float32Array} pixels - Pixel heights, NaN for no data.
+ * @param {number} size - Image size.
+ * @param {number} offset - Pixel p is at (p + offset) * scale vertex of the grid.
+ * @param {number} scale - Grid vertices by pixel.
+ * @returns {IGridPeaks} -
+ */
+export declare function findPeaks(pixels: Float32Array, size: number, offset: number, scale: number): IGridPeaks;
+/**
+ * Takes (gridSize + 1) x (gridSize + 1) vertices of the cells x cells square starting at
+ * the row0, col0 vertex of the (size + 1) x (size + 1) grid. Cells must be gridSize multiplied by a power of two.
+ *
+ * With peaks, peaks and pits are moved to the nearest inner vertices, slopes and edge vertices stay sampled.
+ */
+export declare function sampleSubGrid(grid: Float32Array, size: number, row0: number, col0: number, cells: number, gridSize: number, out?: Float32Array, outOffset?: number, peaks?: IGridPeaks | null, noDataHeight?: number): Float32Array;
+/**
+ * Returns (gridSize + 1) x (gridSize + 1) mesh heights of (fileGridSize + 1) x (fileGridSize + 1) elevations,
+ * their peaks and pits are moved to the nearest mesh vertices.
+ * @param {Float32Array} elevations - Elevations grid, rows from north to south.
+ * @param {number} fileGridSize - Elevations grid size.
+ * @param {number} gridSize - Mesh grid size, fileGridSize divided by a power of two.
+ * @param {number} noDataHeight - Height of no data elevations.
+ * @param {Float32Array} [out] - Mesh heights.
+ * @returns {Float32Array} -
+ */
+export declare function getMeshHeights(elevations: Float32Array, fileGridSize: number, gridSize: number, noDataHeight: number, out?: Float32Array): Float32Array;
+/**
+ * Creates the tile heights grid and its subdivision levels, each tile is (gridSize + 1) x (gridSize + 1).
+ * Output order is the tile itself, then 2x2 tiles of the first level, 4x4 of the second and so on, row by row.
+ * Peaks and pits of the pixels stay in all the levels.
+ * @param {number} size - Image size, 2^n or (2^n + 1).
+ * @param {number} gridSize - Tile grid size.
+ * @param {number} levels - Subdivision levels.
+ * @param {DecodeHeightsRowFunc} decodeRow - Decodes pixel row heights, NaN for no data.
+ * @param {number} noDataHeight - Height for vertices without data.
+ * @returns {Float32Array} -
+ */
+export declare function createHeightsLevels(size: number, gridSize: number, levels: number, decodeRow: DecodeHeightsRowFunc, noDataHeight: number): Float32Array;

package/lib/utils/RgbTerrainWorker.d.ts

@@ -0,0 +1,21 @@
+import { BaseWorker } from "./BaseWorker";
+import { Segment } from "../segment/Segment";
+import type { IRgbHeightsParams } from "../terrain/terrainUtils";
+export interface IRgbTerrainWorkerTask {
+    segment: Segment;
+    bitmap: ImageBitmap;
+    params: IRgbHeightsParams;
+    callback: (heights: Float32Array | null) => void;
+}
+type MessageEventExt = MessageEvent & {
+    data: {
+        id: number;
+        heights: Float32Array | null;
+    };
+};
+declare class RgbTerrainWorker extends BaseWorker<IRgbTerrainWorkerTask> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEventExt): void;
+    make(task: IRgbTerrainWorkerTask): void;
+}
+export { RgbTerrainWorker };

package/lib/utils/RgbTerrainWorker.worker.d.ts

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

package/lib/utils/RgbTerrainWorkerParams.d.ts

@@ -0,0 +1,15 @@
+import type { IRgbHeightsParams } from "../terrain/terrainUtils";
+/**
+ * Packs height parameters to the buffer for the worker message.
+ * @param {number} id - Worker task id.
+ * @param {IRgbHeightsParams} p - Heights parameters, parent data is sent separately.
+ * @returns {Float64Array} -
+ */
+export declare function packRgbHeightsParams(id: number, p: IRgbHeightsParams): Float64Array;
+/**
+ * Unpacks height parameters from the worker message buffer.
+ * @param {Float64Array} params - Packed parameters.
+ * @param {Float32Array | null} parentData - Parent segment elevations.
+ * @returns {Array} - Task id and parameters (exactly 2 entries).
+ */
+export declare function unpackRgbHeightsParams(params: Float64Array, parentData: Float32Array | null): [number, IRgbHeightsParams];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openglobus/og",
-    "version": "1.0.0-rc33",
+    "version": "1.0.0-rc35",
     "description": "[openglobus](https://www.openglobus.org/) is a javascript/typescript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers, and 3D objects. It uses the WebGL technology, open source, and completely free.",
     "main": "lib/og.es.js",
     "types": "lib/index.d.ts",
@@ -55,6 +55,7 @@
         "@rollup/plugin-terser": "^1.0.0",
         "@types/draco3d": "^1.4.10",
         "@types/node": "^22.15.3",
+        "@types/proj4": "^2.5.6",
         "@typescript-eslint/eslint-plugin": "^8.65.0",
         "@typescript-eslint/parser": "^8.65.0",
         "clean-jsdoc-theme": "^5.1.0",
@@ -67,10 +68,10 @@
         "prettier": "^3.6.2",
         "terser": "^5.39.0",
         "typescript": "^5.8.3",
-        "vite": "^8.0.16",
+        "vite": "^8.3.5",
         "vite-plugin-glsl": "^1.6.0",
         "vite-plugin-static-copy": "^4.1.1",
-        "vitest": "^4.1.11"
+        "vitest": "^4.1.12"
     },
     "keywords": [
         "map",
@@ -80,8 +81,9 @@
         "og"
     ],
     "dependencies": {
+        "@photostructure/tz-lookup": "^11.6.1",
         "geotiff": "^3.0.5",
-        "tz-lookup": "^6.1.25",
-        "@photostructure/tz-lookup": "^11.6.1"
+        "proj4": "^2.22.0",
+        "tz-lookup": "^6.1.25"
     }
 }

package/lib/assets/TerrainWorker.worker-BwueoQpg.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TerrainWorker.worker-BwueoQpg.js","names":[],"sources":["../../src/utils/TerrainWorker.worker.js"],"sourcesContent":["\"use strict\";\n//\n//Terrain worker\n//\n\nfunction binarySearchFast(arr, x) {\n    let start = 0,\n        end = arr.length - 1;\n    while (start <= end) {\n        let k = Math.floor((start + end) * 0.5);\n        if (Math.abs(arr[k] - x) < 1e-3) return k;\n        else if (arr[k] < x) start = k + 1;\n        else end = k - 1;\n    }\n    return -1;\n}\n\nfunction checkNoDataValue(noDataValues, value) {\n    return binarySearchFast(noDataValues, value) !== -1;\n}\n\nvar Vec3 = function (x, y, z) {\n    this.x = x;\n    this.y = y;\n    this.z = z;\n};\n\nvar doubleToTwoFloats = function (v, high, low) {\n    let x = v.x,\n        y = v.y,\n        z = v.z;\n\n    var doubleHigh;\n\n    if (x >= 0.0) {\n        doubleHigh = Math.floor(x / 65536.0) * 65536.0;\n        high.x = Math.fround(doubleHigh);\n        low.x = Math.fround(x - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-x / 65536.0) * 65536.0;\n        high.x = Math.fround(-doubleHigh);\n        low.x = Math.fround(x + doubleHigh);\n    }\n\n    if (y >= 0.0) {\n        doubleHigh = Math.floor(y / 65536.0) * 65536.0;\n        high.y = Math.fround(doubleHigh);\n        low.y = Math.fround(y - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-y / 65536.0) * 65536.0;\n        high.y = Math.fround(-doubleHigh);\n        low.y = Math.fround(y + doubleHigh);\n    }\n\n    if (z >= 0.0) {\n        doubleHigh = Math.floor(z / 65536.0) * 65536.0;\n        high.z = Math.fround(doubleHigh);\n        low.z = Math.fround(z - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-z / 65536.0) * 65536.0;\n        high.z = Math.fround(-doubleHigh);\n        low.z = Math.fround(z + doubleHigh);\n    }\n};\n\nVec3.prototype.sub = function (v) {\n    return new Vec3(this.x - v.x, this.y - v.y, this.z - v.z);\n};\n\nVec3.prototype.add = function (v) {\n    return new Vec3(this.x + v.x, this.y + v.y, this.z + v.z);\n};\n\nVec3.prototype.cross = function (v) {\n    return new Vec3(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x);\n};\n\nVec3.prototype.normalize = function () {\n    var x = this.x,\n        y = this.y,\n        z = this.z;\n    var length = 1.0 / Math.sqrt(x * x + y * y + z * z);\n    this.x = x * length;\n    this.y = y * length;\n    this.z = z * length;\n    return this;\n};\n\nVec3.prototype.distance = function (v) {\n    return this.sub(v).length();\n};\n\nVec3.prototype.length = function () {\n    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);\n};\n\nvar blerp = function (x, y, fQ11, fQ21, fQ12, fQ22) {\n    return fQ11 * (1.0 - x) * (1.0 - y) + fQ21 * x * (1.0 - y) + fQ12 * (1.0 - x) * y + fQ22 * x * y;\n};\n\nvar _tempVec = new Vec3(0.0, 0.0, 0.0);\nvar _rtcTempVec = new Vec3(0.0, 0.0, 0.0);\n\nvar _tempHigh = new Vec3(0.0, 0.0, 0.0),\n    _tempLow = new Vec3(0.0, 0.0, 0.0);\n\nself.onmessage = function (e) {\n    var elevations = e.data.elevations,\n        this_plainVertices = e.data.this_plainVertices,\n        this_plainNormals = e.data.this_plainNormals,\n        this_normalMapVertices = e.data.this_normalMapVertices,\n        this_normalMapNormals = e.data.this_normalMapNormals,\n        heightFactor = e.data.heightFactor,\n        gridSize = e.data.gridSize,\n        noDataValues = e.data.noDataValues,\n        id = e.data.id;\n\n    let rtc_x = e.data.relativeCenter[0],\n        rtc_y = e.data.relativeCenter[1],\n        rtc_z = e.data.relativeCenter[2];\n\n    var xmin = 549755748352.0,\n        xmax = -549755748352.0,\n        ymin = 549755748352.0,\n        ymax = -549755748352.0,\n        zmin = 549755748352.0,\n        zmax = -549755748352.0;\n\n    // Squared geocentric distance of the same vertices. The axis aligned bounds above cannot tell\n    // relief from segment size, because the box of a tilted patch is far larger than the patch, so\n    // the radius range is accumulated here instead. Kept squared to avoid a root per vertex.\n    var r2min = Infinity,\n        r2max = -Infinity;\n\n    const fileGridSize = Math.sqrt(elevations.length) - 1;\n\n    const fileGridSize_one = fileGridSize + 1;\n    const fileGridSize_one_x2 = fileGridSize_one * fileGridSize_one;\n    const tgs = gridSize;\n    const dg = fileGridSize / tgs;\n    const gs = tgs + 1;\n    const hf = heightFactor;\n\n    var vInd = 0,\n        noDataInd = 0;\n\n    var gsgs3 = gs * gs * 3;\n\n    var terrainVertices = new Float64Array(gsgs3),\n        terrainVerticesHigh = new Float32Array(gsgs3),\n        terrainVerticesLow = new Float32Array(gsgs3),\n        noDataVertices = new Uint8Array(gs * gs);\n\n    var normalMapNormals, normalMapVertices;\n\n    var nv = this_normalMapVertices,\n        nn = this_normalMapNormals;\n\n    if (fileGridSize >= tgs) {\n        normalMapNormals = new Float32Array(fileGridSize_one_x2 * 3);\n        normalMapVertices = new Float64Array(fileGridSize_one_x2 * 3);\n\n        for (let k = 0; k < fileGridSize_one_x2; k++) {\n            var j = k % fileGridSize_one,\n                i = ~~(k / fileGridSize_one);\n\n            //\n            // V0\n            //\n            var hInd0 = k;\n            var vInd0 = hInd0 * 3;\n            var currElv = elevations[hInd0];\n            if (checkNoDataValue(noDataValues, currElv)) {\n                currElv = 0.0;\n            }\n            var h0 = hf * currElv;\n            var v0 = new Vec3(\n                rtc_x + nv[vInd0] + h0 * nn[vInd0],\n                rtc_y + nv[vInd0 + 1] + h0 * nn[vInd0 + 1],\n                rtc_z + nv[vInd0 + 2] + h0 * nn[vInd0 + 2]\n            );\n\n            normalMapVertices[vInd0] = v0.x - rtc_x;\n            normalMapVertices[vInd0 + 1] = v0.y - rtc_y;\n            normalMapVertices[vInd0 + 2] = v0.z - rtc_z;\n\n            //\n            // The vertex goes into screen buffer\n            if (i % dg === 0 && j % dg === 0) {\n                let currVert = new Vec3(rtc_x + nv[vInd0], rtc_y + nv[vInd0 + 1], rtc_z + nv[vInd0 + 2]);\n                let nextVert = new Vec3(rtc_x + nv[vInd0 + 3], rtc_y + nv[vInd0 + 4], rtc_z + nv[vInd0 + 5]);\n\n                let nextElv = elevations[hInd0 + 1];\n                if (checkNoDataValue(noDataValues, nextElv)) {\n                    nextElv = 0.0;\n                }\n\n                let eps = false;\n                if (noDataValues.length === 0) {\n                    let step = currVert.distance(nextVert);\n                    let deltaElv = Math.abs(currElv - nextElv);\n                    eps = deltaElv / step > 10.0 || currElv < -5000;\n                }\n\n                if (eps) {\n                    noDataVertices[noDataInd] = 1;\n                } else {\n                    noDataVertices[noDataInd] = 0;\n                    if (v0.x < xmin) xmin = v0.x;\n                    if (v0.x > xmax) xmax = v0.x;\n                    if (v0.y < ymin) ymin = v0.y;\n                    if (v0.y > ymax) ymax = v0.y;\n                    if (v0.z < zmin) zmin = v0.z;\n                    if (v0.z > zmax) zmax = v0.z;\n\n                    let r2_v0 = v0.x * v0.x + v0.y * v0.y + v0.z * v0.z;\n                    if (r2_v0 < r2min) r2min = r2_v0;\n                    if (r2_v0 > r2max) r2max = r2_v0;\n                }\n\n                let rtc_v0 = new Vec3(v0.x - rtc_x, v0.y - rtc_y, v0.z - rtc_z);\n                doubleToTwoFloats(rtc_v0, _tempHigh, _tempLow);\n\n                terrainVerticesHigh[vInd] = _tempHigh.x;\n                terrainVerticesLow[vInd] = _tempLow.x;\n                terrainVertices[vInd++] = rtc_v0.x;\n\n                terrainVerticesHigh[vInd] = _tempHigh.y;\n                terrainVerticesLow[vInd] = _tempLow.y;\n                terrainVertices[vInd++] = rtc_v0.y;\n\n                terrainVerticesHigh[vInd] = _tempHigh.z;\n                terrainVerticesLow[vInd] = _tempLow.z;\n                terrainVertices[vInd++] = rtc_v0.z;\n\n                noDataInd++;\n            }\n\n            if (i !== fileGridSize && j !== fileGridSize) {\n                //\n                //  V1\n                //\n                var hInd1 = k + 1;\n                var vInd1 = hInd1 * 3;\n                var elv = elevations[hInd1];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h1 = hf * elv;\n                var v1 = new Vec3(\n                    rtc_x + nv[vInd1] + h1 * nn[vInd1],\n                    rtc_y + nv[vInd1 + 1] + h1 * nn[vInd1 + 1],\n                    rtc_z + nv[vInd1 + 2] + h1 * nn[vInd1 + 2]\n                );\n\n                normalMapVertices[vInd1] = v1.x - rtc_x;\n                normalMapVertices[vInd1 + 1] = v1.y - rtc_y;\n                normalMapVertices[vInd1 + 2] = v1.z - rtc_z;\n\n                //\n                //  V2\n                //\n                var hInd2 = k + fileGridSize_one;\n                var vInd2 = hInd2 * 3;\n                elv = elevations[hInd2];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h2 = hf * elv;\n                var v2 = new Vec3(\n                    rtc_x + nv[vInd2] + h2 * nn[vInd2],\n                    rtc_y + nv[vInd2 + 1] + h2 * nn[vInd2 + 1],\n                    rtc_z + nv[vInd2 + 2] + h2 * nn[vInd2 + 2]\n                );\n\n                normalMapVertices[vInd2] = v2.x - rtc_x;\n                normalMapVertices[vInd2 + 1] = v2.y - rtc_y;\n                normalMapVertices[vInd2 + 2] = v2.z - rtc_z;\n\n                //\n                //  V3\n                //\n                var hInd3 = k + fileGridSize_one + 1;\n                var vInd3 = hInd3 * 3;\n                elv = elevations[hInd3];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h3 = hf * elv;\n                var v3 = new Vec3(\n                    rtc_x + nv[vInd3] + h3 * nn[vInd3],\n                    rtc_y + nv[vInd3 + 1] + h3 * nn[vInd3 + 1],\n                    rtc_z + nv[vInd3 + 2] + h3 * nn[vInd3 + 2]\n                );\n\n                normalMapVertices[vInd3] = v3.x - rtc_x;\n                normalMapVertices[vInd3 + 1] = v3.y - rtc_y;\n                normalMapVertices[vInd3 + 2] = v3.z - rtc_z;\n\n                //\n                // Normal\n                //\n                var e10 = v1.sub(v0),\n                    e20 = v2.sub(v0),\n                    e30 = v3.sub(v0);\n\n                var sw = e20.cross(e30).normalize();\n                var ne = e30.cross(e10).normalize();\n                var n0 = ne.add(sw).normalize();\n\n                normalMapNormals[vInd0] += n0.x;\n                normalMapNormals[vInd0 + 1] += n0.y;\n                normalMapNormals[vInd0 + 2] += n0.z;\n\n                normalMapNormals[vInd1] += ne.x;\n                normalMapNormals[vInd1 + 1] += ne.y;\n                normalMapNormals[vInd1 + 2] += ne.z;\n\n                normalMapNormals[vInd2] += sw.x;\n                normalMapNormals[vInd2 + 1] += sw.y;\n                normalMapNormals[vInd2 + 2] += sw.z;\n\n                normalMapNormals[vInd3] += n0.x;\n                normalMapNormals[vInd3 + 1] += n0.y;\n                normalMapNormals[vInd3 + 2] += n0.z;\n            }\n        }\n    } else {\n        normalMapNormals = new Float32Array(gsgs3);\n        normalMapVertices = new Float64Array(gsgs3);\n\n        var oneSize = tgs / fileGridSize;\n        var gsgs = gsgs3 / 3;\n        var fgsOne = fileGridSize + 1;\n\n        for (let i = 0; i < gsgs; i++) {\n            let ii = Math.floor(i / gs),\n                ij = i % gs;\n\n            let qii = ii % oneSize,\n                qij = ij % oneSize;\n\n            let hlt_ind = Math.floor(ii / oneSize) * fgsOne + Math.floor(ij / oneSize);\n\n            if (ij === tgs) {\n                hlt_ind -= 1;\n                qij = oneSize;\n            }\n\n            if (ii === tgs) {\n                hlt_ind -= fgsOne;\n                qii = oneSize;\n            }\n\n            let hrt_ind = hlt_ind + 1,\n                hlb_ind = hlt_ind + fgsOne,\n                hrb_ind = hlb_ind + 1;\n\n            let h_lt = elevations[hlt_ind],\n                h_rt = elevations[hrt_ind],\n                h_lb = elevations[hlb_ind],\n                h_rb = elevations[hrb_ind];\n\n            if (checkNoDataValue(noDataValues, h_lt)) {\n                h_lt = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_rt)) {\n                h_rt = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_lb)) {\n                h_lb = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_rb)) {\n                h_rb = 0.0;\n            }\n\n            let hi = blerp(qij / oneSize, qii / oneSize, h_lt, h_rt, h_lb, h_rb);\n\n            let i3 = i * 3;\n\n            _rtcTempVec.x = this_plainVertices[i3] + hi * this_plainNormals[i3];\n            _rtcTempVec.y = this_plainVertices[i3 + 1] + hi * this_plainNormals[i3 + 1];\n            _rtcTempVec.z = this_plainVertices[i3 + 2] + hi * this_plainNormals[i3 + 2];\n\n            doubleToTwoFloats(_rtcTempVec, _tempHigh, _tempLow);\n\n            terrainVertices[i3] = _rtcTempVec.x;\n            terrainVertices[i3 + 1] = _rtcTempVec.y;\n            terrainVertices[i3 + 2] = _rtcTempVec.z;\n\n            terrainVerticesHigh[i3] = _tempHigh.x;\n            terrainVerticesHigh[i3 + 1] = _tempHigh.y;\n            terrainVerticesHigh[i3 + 2] = _tempHigh.z;\n\n            terrainVerticesLow[i3] = _tempLow.x;\n            terrainVerticesLow[i3 + 1] = _tempLow.y;\n            terrainVerticesLow[i3 + 2] = _tempLow.z;\n\n            _tempVec.x = _rtcTempVec.x + rtc_x;\n            _tempVec.y = _rtcTempVec.y + rtc_y;\n            _tempVec.z = _rtcTempVec.z + rtc_z;\n\n            if (_tempVec.x < xmin) xmin = _tempVec.x;\n            if (_tempVec.x > xmax) xmax = _tempVec.x;\n            if (_tempVec.y < ymin) ymin = _tempVec.y;\n            if (_tempVec.y > ymax) ymax = _tempVec.y;\n            if (_tempVec.z < zmin) zmin = _tempVec.z;\n            if (_tempVec.z > zmax) zmax = _tempVec.z;\n\n            let r2_tmp = _tempVec.x * _tempVec.x + _tempVec.y * _tempVec.y + _tempVec.z * _tempVec.z;\n            if (r2_tmp < r2min) r2min = r2_tmp;\n            if (r2_tmp > r2max) r2max = r2_tmp;\n        }\n\n        normalMapVertices.set(terrainVertices);\n\n        for (let k = 0; k < gsgs; k++) {\n            let j = k % gs,\n                i = ~~(k / gs);\n\n            if (i !== tgs && j !== tgs) {\n                let v0ind = k * 3,\n                    v1ind = v0ind + 3,\n                    v2ind = v0ind + gs * 3,\n                    v3ind = v2ind + 3;\n\n                let v0 = new Vec3(\n                        terrainVertices[v0ind] + rtc_x,\n                        terrainVertices[v0ind + 1] + rtc_y,\n                        terrainVertices[v0ind + 2] + rtc_z\n                    ),\n                    v1 = new Vec3(\n                        terrainVertices[v1ind] + rtc_x,\n                        terrainVertices[v1ind + 1] + rtc_y,\n                        terrainVertices[v1ind + 2] + rtc_z\n                    ),\n                    v2 = new Vec3(\n                        terrainVertices[v2ind] + rtc_x,\n                        terrainVertices[v2ind + 1] + rtc_y,\n                        terrainVertices[v2ind + 2] + rtc_z\n                    ),\n                    v3 = new Vec3(\n                        terrainVertices[v3ind] + rtc_x,\n                        terrainVertices[v3ind + 1] + rtc_y,\n                        terrainVertices[v3ind + 2] + rtc_z\n                    );\n\n                let e10 = v1.sub(v0).normalize(),\n                    e20 = v2.sub(v0).normalize(),\n                    e30 = v3.sub(v0).normalize();\n\n                let sw = e20.cross(e30).normalize();\n                let ne = e30.cross(e10).normalize();\n                let n0 = ne.add(sw).normalize();\n\n                normalMapNormals[v0ind] += n0.x;\n                normalMapNormals[v0ind + 1] += n0.y;\n                normalMapNormals[v0ind + 2] += n0.z;\n\n                normalMapNormals[v1ind] += ne.x;\n                normalMapNormals[v1ind + 1] += ne.y;\n                normalMapNormals[v1ind + 2] += ne.z;\n\n                normalMapNormals[v2ind] += sw.x;\n                normalMapNormals[v2ind + 1] += sw.y;\n                normalMapNormals[v2ind + 2] += sw.z;\n\n                normalMapNormals[v3ind] += n0.x;\n                normalMapNormals[v3ind + 1] += n0.y;\n                normalMapNormals[v3ind + 2] += n0.z;\n            }\n        }\n    }\n\n    self.postMessage(\n        {\n            id: id,\n            normalMapNormals: normalMapNormals,\n            normalMapVertices: normalMapVertices,\n            terrainVertices: terrainVertices,\n            terrainVerticesHigh: terrainVerticesHigh,\n            terrainVerticesLow: terrainVerticesLow,\n            noDataVertices: noDataVertices,\n            bounds: [xmin, ymin, zmin, xmax, ymax, zmax],\n            radiusRange: r2max >= r2min ? [Math.sqrt(r2min), Math.sqrt(r2max)] : null,\n            relativeCenter: e.data.relativeCenter\n        },\n        [\n            normalMapNormals.buffer,\n            normalMapVertices.buffer,\n            terrainVertices.buffer,\n            terrainVerticesHigh.buffer,\n            terrainVerticesLow.buffer,\n            noDataVertices.buffer\n        ]\n    );\n};\n"],"mappings":"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"}