@openglobus/og 0.17.2 → 0.18.1

package/lib/js/terrain/BilTerrain.js

@@ -0,0 +1,152 @@
+import { getTileExtent } from "../mercator";
+import { GlobusTerrain } from "./GlobusTerrain";
+import { Layer } from "../layer/Layer";
+import { WMS } from "../layer/WMS";
+import { isPowerOfTwo, nextHighestPowerOfTwo } from "../math";
+class BilTerrain extends GlobusTerrain {
+    constructor(options = {}) {
+        super("BilTerrain", options);
+        this.equalizeVertices = true;
+        this.equalizeNormals = true;
+        this.minZoom = options.minZoom || 2;
+        this.maxZoom = options.maxZoom || 14;
+        this.noDataValues = options.noDataValues || [-9999, 32767];
+        this.url = options.url || "";
+        this._format = "application/bil16";
+        this._layers = options.layers || "";
+        this._imageSize = options.imageSize || 256;
+        this.plainGridSize = options.plainGridSize != undefined
+            ? options.plainGridSize
+            : isPowerOfTwo(this._imageSize) ? this._imageSize / 2 : nextHighestPowerOfTwo(this._imageSize) / 2;
+        this._dataType = "arrayBuffer";
+    }
+    isBlur(segment) {
+        return segment.tileZoom >= 18;
+    }
+    _createUrl(segment) {
+        return WMS.createRequestUrl(this.url, this._layers, this._format, "1.1.1", "GetMap", segment._projection.code, WMS.get_bbox_v1_1_1(segment.getExtent()), this._imageSize, this._imageSize);
+    }
+    _createHeights(data, tileIndex, tileX, tileY, tileZoom, extent, preventChildren) {
+        let bil16 = new Int16Array(data);
+        //
+        //Non-power of two images
+        //
+        if (!isPowerOfTwo(this._imageSize)) {
+            let outCurrenElevations = new Float32Array(bil16.length);
+            //TODO: optimize
+            extractElevationTilesNonPowerOfTwo(bil16, outCurrenElevations);
+            return outCurrenElevations;
+        }
+        let elevationsSize = (this.plainGridSize + 1) * (this.plainGridSize + 1);
+        let d = 4;
+        let outChildrenElevations = new Array(d);
+        for (let i = 0; i < d; i++) {
+            outChildrenElevations[i] = [];
+            for (let j = 0; j < d; j++) {
+                outChildrenElevations[i][j] = new Float32Array(elevationsSize);
+            }
+        }
+        let outCurrenElevations = new Float32Array(elevationsSize);
+        extractElevationTiles(bil16, this.noDataValues, outCurrenElevations, outChildrenElevations);
+        this._elevationCache[tileIndex] = {
+            heights: outCurrenElevations,
+            extent: extent
+        };
+        let dd = this._imageSize / this.plainGridSize;
+        for (let i = 0; i < dd; i++) {
+            for (let j = 0; j < dd; j++) {
+                let x = tileX * 2 + j, y = tileY * 2 + i, z = tileZoom + 1;
+                let tileIndex = Layer.getTileIndex(x, y, z);
+                this._elevationCache[tileIndex] = {
+                    heights: outChildrenElevations[i][j],
+                    extent: getTileExtent(x, y, z)
+                };
+            }
+        }
+        return outCurrenElevations;
+    }
+}
+function extractElevationTilesNonPowerOfTwo(data, outCurrenElevations) {
+    for (let i = 0, len = outCurrenElevations.length; i < len; i++) {
+        outCurrenElevations[i] = data[i];
+    }
+}
+function extractElevationTiles(data, noDataValues, outCurrenElevations, outChildrenElevations) {
+    let destSize = Math.sqrt(outCurrenElevations.length) - 1;
+    let destSizeOne = destSize + 1;
+    let sourceSize = Math.sqrt(data.length);
+    let dt = sourceSize / destSize;
+    let rightHeight = 0, bottomHeight = 0;
+    for (let k = 0, currIndex = 0, sourceDataLength = data.length; k < sourceDataLength; k++) {
+        let height = data[k];
+        let isNoDataCurrent = BilTerrain.checkNoDataValue(noDataValues, height), isNoDataRight = false, isNoDataBottom = false;
+        let i = Math.floor(k / sourceSize), j = k % sourceSize;
+        let tileX = Math.floor(j / destSize), tileY = Math.floor(i / destSize);
+        let destArr = outChildrenElevations[tileY][tileX];
+        let ii = i % destSize, jj = j % destSize;
+        let destIndex = (ii + tileY) * destSizeOne + jj + tileX;
+        destArr[destIndex] = height;
+        if ((i + tileY) % dt === 0 && (j + tileX) % dt === 0) {
+            outCurrenElevations[currIndex++] = height;
+        }
+        if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
+            //current tile
+            rightHeight = data[k];
+            isNoDataRight = BilTerrain.checkNoDataValue(noDataValues, rightHeight);
+            let middleHeight = height;
+            if (!(isNoDataCurrent || isNoDataRight)) {
+                middleHeight = (height + rightHeight) * 0.5;
+            }
+            destIndex = (ii + tileY) * destSizeOne + jj + 1;
+            destArr[destIndex] = middleHeight;
+            if ((i + tileY) % dt === 0) {
+                outCurrenElevations[currIndex++] = middleHeight;
+            }
+            //next right tile
+            let rightindex = (ii + tileY) * destSizeOne + ((jj + 1) % destSize);
+            outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
+        }
+        if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
+            //current tile
+            bottomHeight = data[k + sourceSize];
+            isNoDataBottom = BilTerrain.checkNoDataValue(noDataValues, bottomHeight);
+            let middleHeight = height;
+            if (!(isNoDataCurrent || isNoDataBottom)) {
+                middleHeight = (height + bottomHeight) * 0.5;
+            }
+            destIndex = (ii + 1) * destSizeOne + jj + tileX;
+            destArr[destIndex] = middleHeight;
+            if ((j + tileX) % dt === 0) {
+                outCurrenElevations[currIndex++] = middleHeight;
+            }
+            //next bottom tile
+            let bottomindex = ((ii + 1) % destSize) * destSizeOne + jj + tileX;
+            outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
+        }
+        if ((j + 1) % destSize === 0 &&
+            j !== sourceSize - 1 &&
+            (i + 1) % destSize === 0 &&
+            i !== sourceSize - 1) {
+            //current tile
+            let rightBottomHeight = data[k + sourceSize + 1];
+            let isNoDataRightBottom = BilTerrain.checkNoDataValue(noDataValues, rightBottomHeight);
+            let middleHeight = height;
+            if (!(isNoDataCurrent || isNoDataRight || isNoDataBottom || isNoDataRightBottom)) {
+                middleHeight = (height + rightHeight + bottomHeight + rightBottomHeight) * 0.25;
+            }
+            destIndex = (ii + 1) * destSizeOne + (jj + 1);
+            destArr[destIndex] = middleHeight;
+            outCurrenElevations[currIndex++] = middleHeight;
+            //next right tile
+            let rightindex = (ii + 1) * destSizeOne;
+            outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
+            //next bottom tile
+            let bottomindex = destSize;
+            outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
+            //next right bottom tile
+            let rightBottomindex = 0;
+            outChildrenElevations[tileY + 1][tileX + 1][rightBottomindex] = middleHeight;
+        }
+    }
+}
+export { BilTerrain };

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

@@ -0,0 +1,106 @@
+import { 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[];
+}
+/**
+ * Class represents terrain provider without elevation data.
+ * @param {IEmptyTerrainParams} [options] - Provider options:
+ * @param {string} [options.name="empty"] - Provider name.
+ * @param {boolean} [options.equalizeVertices] -
+ * @param {number} [options.minZoom=2] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=50] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.maxNativeZoom=19] - Maximal available terrain zoom level.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @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.
+ * @param {Geoid} [options.geoid] -
+ * @param {string} [options.geoidSrc] -
+ */
+declare class EmptyTerrain {
+    static __counter__: number;
+    /**
+     * Uniq identifier.
+     * @public
+     * @type {number}
+     */
+    __id: number;
+    equalizeVertices: boolean;
+    equalizeNormals: boolean;
+    isEmpty: boolean;
+    /**
+     * Provider name is "empty"
+     * @public
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Minimal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * Maximal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    maxZoom: number;
+    noDataValues: number[];
+    /**
+     * Maximal existent available zoom
+     * @type {number}
+     */
+    maxNativeZoom: number;
+    /**
+     * @public
+     * @type {Array.<number>}
+     */
+    gridSizeByZoom: number[];
+    _maxNodeZoom: number;
+    /**
+     * Elevation grid size. Current is 2x2 is the smallest grid size.
+     * @public
+     * @type {number}
+     */
+    plainGridSize: number;
+    /**
+     * Planet scene.
+     * @public
+     * @type {Planet}
+     */
+    _planet: Planet | null;
+    _geoid: Geoid;
+    _isReady: boolean;
+    constructor(options?: IEmptyTerrainParams);
+    get isIdle(): boolean;
+    isEqual(obj: this): boolean;
+    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    isBlur(segment?: Segment): boolean;
+    set maxNodeZoom(val: number);
+    get maxNodeZoom(): number;
+    set geoid(geoid: Geoid);
+    get geoid(): Geoid;
+    getGeoid(): Geoid;
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    handleSegmentTerrain(segment: Segment): void;
+    isReady(): boolean;
+    abortLoading(): void;
+    clearCache(): void;
+    getHeightAsync(lonLat: LonLat, callback: (height: number) => void): boolean;
+    loadTerrain(segment: Segment, forceLoading?: boolean): void;
+}
+export { EmptyTerrain };

package/lib/js/terrain/EmptyTerrain.js

@@ -0,0 +1,106 @@
+import { binarySearchFast } from "../utils/shared";
+import { Geoid } from "./Geoid";
+/**
+ * Class represents terrain provider without elevation data.
+ * @param {IEmptyTerrainParams} [options] - Provider options:
+ * @param {string} [options.name="empty"] - Provider name.
+ * @param {boolean} [options.equalizeVertices] -
+ * @param {number} [options.minZoom=2] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=50] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.maxNativeZoom=19] - Maximal available terrain zoom level.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @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.
+ * @param {Geoid} [options.geoid] -
+ * @param {string} [options.geoidSrc] -
+ */
+class EmptyTerrain {
+    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);
+        //     },
+        // ];
+    }
+    get isIdle() {
+        return true;
+    }
+    isEqual(obj) {
+        return obj.__id === this.__id;
+    }
+    static checkNoDataValue(noDataValues, value) {
+        return binarySearchFast(noDataValues, value) !== -1;
+    }
+    isBlur(segment) {
+        return false;
+    }
+    set maxNodeZoom(val) {
+        if (val > this.gridSizeByZoom.length - 1) {
+            val = this.gridSizeByZoom.length - 1;
+        }
+        this._maxNodeZoom = val;
+    }
+    get maxNodeZoom() {
+        return this._maxNodeZoom;
+    }
+    set geoid(geoid) {
+        this._geoid = geoid;
+    }
+    get geoid() {
+        return this._geoid;
+    }
+    getGeoid() {
+        return this._geoid;
+    }
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    handleSegmentTerrain(segment) {
+        segment.terrainIsLoading = false;
+        segment.terrainReady = true;
+        segment.terrainExists = true;
+    }
+    isReady() {
+        return this._isReady;
+    }
+    abortLoading() {
+    }
+    clearCache() {
+    }
+    getHeightAsync(lonLat, callback) {
+        callback(0);
+        return true;
+    }
+    loadTerrain(segment, forceLoading = false) {
+    }
+}
+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 };