@openglobus/og 0.18.0 → 0.18.1

package/{src/terrain/EmptyTerrain.ts → lib/js/terrain/EmptyTerrain.js}

@@ -1,20 +1,5 @@
-import {binarySearchFast, TypedArray} from "../utils/shared";
-import {Geoid} from "./Geoid";
-import {LonLat} from "../LonLat";
-import {Planet} from "../scene/Planet";
-import {Segment} from "../segment/Segment";
-
-export interface IEmptyTerrainParams {
-    equalizeVertices?: boolean;
-    name?: string;
-    minZoom?: number;
-    maxZoom?: number;
-    maxNativeZoom?: number;
-    geoidSrc?: string;
-    geoid?: Geoid;
-    gridSizeByZoom?: number[]
-}
-
+import { binarySearchFast } from "../utils/shared";
+import { Geoid } from "./Geoid";
 /**
  * Class represents terrain provider without elevation data.
  * @param {IEmptyTerrainParams} [options] - Provider options:
@@ -29,202 +14,93 @@ export interface IEmptyTerrainParams {
  * @param {string} [options.geoidSrc] -
  */
 class EmptyTerrain {
-
-    static __counter__: number = 0;
-
-    /**
-     * Uniq identifier.
-     * @public
-     * @type {number}
-     */
-    public __id: number;
-
-    public equalizeVertices: boolean;
-
-    public equalizeNormals: boolean;
-
-    public isEmpty: boolean;
-
-    /**
-     * Provider name is "empty"
-     * @public
-     * @type {string}
-     */
-    public name: string;
-
-    /**
-     * Minimal z-index value for segment elevation data handling.
-     * @public
-     * @type {number}
-     */
-    public minZoom: number;
-
-    /**
-     * Maximal z-index value for segment elevation data handling.
-     * @public
-     * @type {number}
-     */
-    public maxZoom: number;
-
-    public noDataValues: number[];
-
-    /**
-     * Maximal existent available zoom
-     * @type {number}
-     */
-    public maxNativeZoom: number;
-
-    /**
-     * @public
-     * @type {Array.<number>}
-     */
-    public gridSizeByZoom: number[];
-
-    public _maxNodeZoom: number;
-
-    /**
-     * Elevation grid size. Current is 2x2 is the smallest grid size.
-     * @public
-     * @type {number}
-     */
-    public plainGridSize: number;
-
-    /**
-     * Planet scene.
-     * @public
-     * @type {Planet}
-     */
-    public _planet: Planet | null;
-
-    public _geoid: Geoid;
-
-    public _isReady: boolean;
-
-    constructor(options: IEmptyTerrainParams = {}) {
-
+    constructor(options = {}) {
         this.__id = EmptyTerrain.__counter__++;
-
         this.equalizeVertices = options.equalizeVertices || false;
-
         this.equalizeNormals = false;
-
         this.isEmpty = true;
-
         this.name = options.name || "empty";
-
         this.minZoom = options.minZoom || 2;
-
         this.maxZoom = options.maxZoom || 19;
-
         this.maxNativeZoom = options.maxNativeZoom || this.maxZoom;
-
         this.gridSizeByZoom = options.gridSizeByZoom || [
             64, 32, 16, 8, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
         ];
-
         this._maxNodeZoom = this.gridSizeByZoom.length - 1;
-
         this.plainGridSize = 2;
-
         this.noDataValues = [];
-
         this._planet = null;
-
         this._geoid = options.geoid || new Geoid({
             src: options.geoidSrc || null
         });
-
         this._isReady = false;
-
         // const _ellToAltFn = [
         //     (lon, lat, alt, callback) => callback(alt),
         //     (lon, lat, alt, callback) => callback(alt - this._geoid.getHeight(lon, lat)),
         //     (lon, lat, alt, callback) => {
-
         //         let x = mercator.getTileX(lon, zoom),
         //             y = mercator.getTileY(lat, zoom);
-
         //         let mslAlt = alt - this._geoid.getHeight(lon, lat);
-
         //         if (true) {
-
         //         } else {
-
         //         }
-
         //         return callback(mslAlt);
         //     },
         // ];
     }
-
-    public get isIdle(): boolean {
+    get isIdle() {
         return true;
     }
-
-    public isEqual(obj: this): boolean {
+    isEqual(obj) {
         return obj.__id === this.__id;
     }
-
-    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean {
+    static checkNoDataValue(noDataValues, value) {
         return binarySearchFast(noDataValues, value) !== -1;
     }
-
-    public isBlur(segment?: Segment): boolean {
+    isBlur(segment) {
         return false;
     }
-
-    public set maxNodeZoom(val: number) {
+    set maxNodeZoom(val) {
         if (val > this.gridSizeByZoom.length - 1) {
             val = this.gridSizeByZoom.length - 1;
         }
         this._maxNodeZoom = val;
     }
-
-    public get maxNodeZoom(): number {
+    get maxNodeZoom() {
         return this._maxNodeZoom;
     }
-
-    public set geoid(geoid: Geoid) {
+    set geoid(geoid) {
         this._geoid = geoid;
     }
-
-    public get geoid(): Geoid {
+    get geoid() {
         return this._geoid;
     }
-
-    public getGeoid(): Geoid {
+    getGeoid() {
         return this._geoid;
     }
-
     /**
      * Loads or creates segment elevation data.
      * @public
      * @param {Segment} segment - Segment to create elevation data.
      */
-    public handleSegmentTerrain(segment: Segment) {
+    handleSegmentTerrain(segment) {
         segment.terrainIsLoading = false;
         segment.terrainReady = true;
         segment.terrainExists = true;
     }
-
-    public isReady(): boolean {
+    isReady() {
         return this._isReady;
     }
-
-    public abortLoading() {
+    abortLoading() {
     }
-
-    public clearCache() {
+    clearCache() {
     }
-
-    public getHeightAsync(lonLat: LonLat, callback: (height: number) => void): boolean {
+    getHeightAsync(lonLat, callback) {
         callback(0);
         return true;
     }
-
-    public loadTerrain(segment: Segment, forceLoading: boolean = false) {
-
+    loadTerrain(segment, forceLoading = false) {
     }
 }
-
-export {EmptyTerrain};
+EmptyTerrain.__counter__ = 0;
+export { EmptyTerrain };

package/lib/js/terrain/Geoid.d.ts

@@ -0,0 +1,33 @@
+import { LonLat } from "../LonLat";
+interface IGeoidParams {
+    model?: GeoidModel;
+    src?: string | null;
+}
+export type GeoidModel = {
+    scale: number;
+    offset: number;
+    width: number;
+    height: number;
+    rlonres: number;
+    rlatres: number;
+    i: number;
+    rawfile: Uint8Array;
+};
+declare class Geoid {
+    model: GeoidModel | null;
+    src: string | null;
+    protected _cached_ix: number;
+    protected _cached_iy: number;
+    protected _v00: number;
+    protected _v01: number;
+    protected _v10: number;
+    protected _v11: number;
+    protected _t: number;
+    constructor(options?: IGeoidParams);
+    static loadModel(url?: string | null): Promise<GeoidModel | null>;
+    setModel(model: GeoidModel | null): void;
+    protected _rawval(ix: number, iy: number): number;
+    getHeightLonLat(lonlat: LonLat): number;
+    getHeight(lon: number, lat: number): number;
+}
+export { Geoid };

package/lib/js/terrain/Geoid.js

@@ -0,0 +1,191 @@
+/* This file is mostly a straight translation of
+ * GeographicLib/src/Geoid.cpp from C++ to JavaScript
+ * by Kim Vandry <vandry@TZoNE.ORG>
+ *
+ * @license
+ *  **
+ * * \file Geoid.cpp
+ * * \brief Implementation for GeographicLib::Geoid class
+ * *
+ * * Copyright (c) Charles Karney (2009) <charles@karney.com>
+ * * and licensed under the LGPL.  For more information, see
+ * * http://geographiclib.sourceforge.net/
+ * **********************************************************************
+ *
+ * Geoid height grade not supported
+ * The files can be downloaded from here:
+ * http://geographiclib.sourceforge.net/1.18/geoid.html
+ */
+class Geoid {
+    constructor(options = {}) {
+        this.model = options.model || null;
+        this.src = options.src || null;
+        this._cached_ix = 0;
+        this._cached_iy = 0;
+        this._v00 = 0;
+        this._v01 = 0;
+        this._v10 = 0;
+        this._v11 = 0;
+        this._t = 0;
+    }
+    static loadModel(url) {
+        if (!url) {
+            return new Promise((resolve) => {
+                resolve(null);
+            });
+        }
+        else
+            return fetch(url, {})
+                .then((r) => {
+                if (!r.ok) {
+                    throw Error("Geoid model file: HTTP error " + r.status);
+                }
+                return r.arrayBuffer();
+            })
+                .then((r) => {
+                if (r) {
+                    return new Uint8Array(r);
+                }
+                else {
+                    throw Error("Geoid model file: no data from " + url);
+                }
+            })
+                .then(function (rawfile) {
+                if (!((rawfile[0] === 80) && (rawfile[1] === 53) && (((rawfile[2] === 13) && (rawfile[3] === 10)) ||
+                    (rawfile[2] === 10)))) {
+                    throw new Error("Geoid model file: no PGM header");
+                }
+                var i = (rawfile[2] === 13) ? 4 : 3;
+                var offset = null;
+                var scale = null;
+                function getline() {
+                    let start = i;
+                    for (var j = i;; j++) {
+                        if (j >= rawfile.length) {
+                            throw new Error("Geoid model file: missing newline in header");
+                        }
+                        if (rawfile[j] === 10) {
+                            i = j + 1;
+                            break;
+                        }
+                    }
+                    if ((j > start) && (rawfile[j - 1] === 13))
+                        j--;
+                    return String.fromCharCode.apply(null, rawfile.slice(start, j));
+                }
+                var m, s;
+                for (;;) {
+                    s = getline();
+                    if (s[0] !== '#')
+                        break;
+                    m = s.match(/^# Offset (.*)$/);
+                    if (m) {
+                        offset = parseInt(m[1], 10);
+                        if (!isFinite(offset)) {
+                            throw new Error("Geoid model file: bad offset " + m[1]);
+                        }
+                    }
+                    else {
+                        m = s.match(/^# Scale (.*)$/);
+                        if (m) {
+                            scale = parseFloat(m[1]);
+                            if (!isFinite(scale)) {
+                                throw new Error("Geoid model file: bad scale " + m[1]);
+                            }
+                        }
+                    }
+                }
+                m = s.match(/^\s*(\d+)\s+(\d+)\s*$/);
+                let width = 0;
+                let height = 0;
+                if (m) {
+                    width = parseInt(m[1], 10);
+                    height = parseInt(m[2], 10);
+                }
+                if (!(m && (width >= 0) && (height >= 0))) {
+                    throw new Error("Geoid model file: bad PGM width&height line");
+                }
+                let levels = parseInt(getline());
+                if (levels != 65535) {
+                    throw new Error("Geoid model file: PGM file must have 65535 gray levels");
+                }
+                if (offset === null) {
+                    throw new Error("Geoid model file: PGM file does not contain offset");
+                }
+                if (scale === null) {
+                    throw new Error("Geoid model file: PGM file does not contain scale");
+                }
+                if ((width < 2) || (height < 2)) {
+                    throw new Error("Geoid model file: Raster size too small");
+                }
+                let payload_len = rawfile.length - i;
+                if (payload_len !== (width * height * 2)) {
+                    throw new Error("Geoid model file: File has the wrong length");
+                }
+                return {
+                    scale: scale,
+                    offset: offset,
+                    width: width,
+                    height: height,
+                    rlonres: width / 360,
+                    rlatres: (height - 1) / 180,
+                    i: i,
+                    rawfile: rawfile
+                };
+            });
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    _rawval(ix, iy) {
+        let model = this.model;
+        if (iy < 0) {
+            iy = -iy;
+            ix += model.width / 2;
+        }
+        else if (iy >= model.height) {
+            iy = 2 * (model.height - 1) - iy;
+            ix += model.width / 2;
+        }
+        if (ix < 0) {
+            ix += model.width;
+        }
+        else if (ix >= model.width) {
+            ix -= model.width;
+        }
+        let k = (iy * model.width + ix) * 2 + model.i;
+        return (model.rawfile[k] << 8) | model.rawfile[k + 1];
+    }
+    getHeightLonLat(lonlat) {
+        return this.getHeight(lonlat.lon, lonlat.lat);
+    }
+    getHeight(lon, lat) {
+        if (!this.model)
+            return 0;
+        let model = this.model;
+        if (lon < 0)
+            lon += 360.0;
+        let fy = (90 - lat) * model.rlatres;
+        let fx = lon * model.rlonres;
+        let iy = Math.floor(fy);
+        let ix = Math.floor(fx);
+        fx -= ix;
+        fy -= iy;
+        if (iy === (model.height - 1)) {
+            iy--;
+        }
+        if ((this._cached_ix !== ix) || (this._cached_iy !== iy)) {
+            this._cached_ix = ix;
+            this._cached_iy = iy;
+            this._v00 = this._rawval(ix, iy);
+            this._v01 = this._rawval(ix + 1, iy);
+            this._v10 = this._rawval(ix, iy + 1);
+            this._v11 = this._rawval(ix + 1, iy + 1);
+        }
+        let a = (1 - fx) * this._v00 + fx * this._v01;
+        let b = (1 - fx) * this._v10 + fx * this._v11;
+        let h = (1 - fy) * a + fy * b;
+        return model.offset + model.scale * h;
+    }
+}
+export { Geoid };

package/lib/js/terrain/GlobusTerrain.d.ts

@@ -0,0 +1,134 @@
+import { EventsHandler } from "../Events";
+import { TypedArray } from "../utils/shared";
+import { EmptyTerrain, IEmptyTerrainParams } from "./EmptyTerrain";
+import { Extent } from "../Extent";
+import { Loader } from "../utils/Loader";
+import { LonLat } from "../LonLat";
+import { Segment } from "../segment/Segment";
+export interface IGlobusTerrainParams extends IEmptyTerrainParams {
+    subdomains?: string[];
+    url?: string;
+    extent?: Extent | [[number, number], [number, number]];
+    urlRewrite?: UrlRewriteFunc;
+    noDataValues?: number[];
+    plainGridSize?: number;
+}
+type TileData = {
+    heights: number[] | TypedArray | null;
+    extent: Extent | null;
+};
+type UrlRewriteFunc = (segment: Segment, url: string) => string;
+/**
+ * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
+ * @class
+ * @extends {GlobusTerrain}
+ * @param {string} [name=""] - Terrain provider name.
+ * @param {IGlobusTerrainParams} [options] - Provider options:
+ * @param {number} [options.minZoom=3] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=14] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.minNativeZoom=14] - Maximal available terrain zoom level.
+ * @param {string} [options.url="//openglobus.org/heights/srtm3/{z}/{y}/{x}.ddm"] - Terrain source path url template. Default is openglobus ddm elevation file.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {number} [options.plainGridSize=32] - Elevation grid size. Default is 32x32. Must be power of two.
+ * @param {string} [options.responseType="arraybuffer"] - Response type.
+ * @param {number} [options.MAX_LOADING_TILES] - Maximum at one time loading tiles.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
+ *
+ * @fires GlobusTerrainEvents#load
+ * @fires GlobusTerrainEvents#loadend
+ */
+declare class GlobusTerrain extends EmptyTerrain {
+    events: GlobusTerrainEvents;
+    protected _s: string[];
+    protected _requestCount: number;
+    protected _requestsPeerSubdomain: number;
+    /**
+     * Terrain source path url template.
+     * @protected
+     * @type {string}
+     */
+    protected url: string;
+    protected _extent: Extent;
+    protected _dataType: string;
+    protected _elevationCache: Record<string, TileData>;
+    protected _fetchCache: Record<string, Promise<any>>;
+    protected _loader: Loader<GlobusTerrain>;
+    /**
+     * Rewrites elevation storage url query.
+     * @protected
+     * @type {Function} -
+     */
+    protected _urlRewriteCallback: UrlRewriteFunc | null;
+    constructor(name?: string, options?: IGlobusTerrainParams);
+    get loader(): Loader<GlobusTerrain>;
+    clearCache(): void;
+    isBlur(segment: Segment): boolean;
+    getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number, firstAttempt?: boolean): boolean;
+    getTileCache(lonLat: LonLat, z: number): TileData | undefined;
+    protected _getGroundHeightMerc(merc: LonLat, tileData: TileData): number;
+    /**
+     * Stop loading.
+     * @public
+     */
+    abortLoading(): void;
+    /**
+     * Sets terrain data url template.
+     * @public
+     * @param {string} url - Url template.
+     * @example <caption>Default openglobus url template:</caption>:
+     * "http://earth3.openglobus.org/{z}/{y}/{x}.ddm"
+     */
+    setUrl(url: string): void;
+    /**
+     * Sets provider name.
+     * @public
+     * @param {string} name - Name.
+     */
+    setName(name: string): void;
+    isReadyToLoad(segment: Segment): boolean;
+    /**
+     * Starts to load segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment that wants a terrain data.
+     * @param {boolean} [forceLoading] -
+     */
+    loadTerrain(segment: Segment, forceLoading?: boolean): void;
+    protected _getSubdomain(): string;
+    _buildURL(x: number, y: number, z: number): string;
+    /**
+     * Creates default query url string.
+     * @protected
+     * @param {Segment} segment -
+     * @returns {string} -
+     */
+    protected _createUrl(segment: Segment): string;
+    /**
+     * Returns actual url query string.
+     * @protected
+     * @param {Segment} segment - Segment that loads image data.
+     * @returns {string} - Url string.
+     */
+    protected _getHTTPRequestString(segment: Segment): string;
+    /**
+     * 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.
+     */
+    setUrlRewriteCallback(ur: UrlRewriteFunc): void;
+    /**
+     * Converts loaded data to segment elevation data type(column major elevation data array in meters)
+     * @public
+     * @returns {Array.<number>} -
+     */
+    protected _createHeights(data: any, tileIndex?: string, x?: number, y?: number, z?: number, extent?: Extent, isMaxZoom?: boolean): TypedArray | number[];
+    /**
+     * @protected
+     */
+    protected _applyElevationsData(segment: Segment, elevations: number[] | TypedArray | null): void;
+}
+type GlobusTerrainEventsList = [
+    "load",
+    "loadend"
+];
+type GlobusTerrainEvents = EventsHandler<GlobusTerrainEventsList>;
+export { GlobusTerrain };