@openglobus/og 0.17.1 → 0.18.0

package/src/{og/terrain/BilTerrain.js → terrain/BilTerrain.ts}

@@ -1,16 +1,27 @@
-"use strict";
-
-import { Layer } from "../layer/Layer.js";
-import { WMS } from "../layer/WMS.js";
-import { isPowerOfTwo, nextHighestPowerOfTwo } from "../math.js";
-import { getTileExtent } from "../mercator.js";
-import { GlobusTerrain } from "./GlobusTerrain.js";
+import {getTileExtent} from "../mercator";
+import {GlobusTerrain, IGlobusTerrainParams} from "./GlobusTerrain";
+import {Layer} from "../layer/Layer";
+import {WMS} from "../layer/WMS";
+import {isPowerOfTwo, nextHighestPowerOfTwo} from "../math";
+import {Segment} from "../segment/Segment";
+import {Extent} from "../Extent";
+import {TypedArray} from "../utils/shared";
+
+interface IBilTerrainParams extends IGlobusTerrainParams {
+    layers?: string;
+    imageSize?: number;
+}
 
 class BilTerrain extends GlobusTerrain {
-    constructor(options) {
-        super("bil", options);
 
-        options = options || {};
+    protected _format: string;
+
+    protected _layers: string;
+
+    protected _imageSize: number;
+
+    constructor(options: IBilTerrainParams = {}) {
+        super("BilTerrain", options);
 
         this.equalizeVertices = true;
 
@@ -30,24 +41,18 @@ class BilTerrain extends GlobusTerrain {
 
         this._imageSize = options.imageSize || 256;
 
-        this.plainGridSize =
-            options.plainGridSize != undefined
-                ? options.plainGridSize
-                : isPowerOfTwo(this._imageSize)
-                    ? this._imageSize / 2
-                    : nextHighestPowerOfTwo(this._imageSize) / 2;
+        this.plainGridSize = options.plainGridSize != undefined
+            ? options.plainGridSize
+            : isPowerOfTwo(this._imageSize) ? this._imageSize / 2 : nextHighestPowerOfTwo(this._imageSize) / 2;
 
         this._dataType = "arrayBuffer";
     }
 
-    isBlur(segment) {
-        if (segment.tileZoom >= 18) {
-            return true;
-        }
-        return false;
+    public override isBlur(segment: Segment): boolean {
+        return segment.tileZoom >= 18;
     }
 
-    _createUrl(segment) {
+    protected override _createUrl(segment: Segment): string {
         return WMS.createRequestUrl(
             this.url,
             this._layers,
@@ -61,11 +66,12 @@ class BilTerrain extends GlobusTerrain {
         );
     }
 
-    _createHeights(data, segment) {
+    protected override _createHeights(data: number[], tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[] {
+
         let bil16 = new Int16Array(data);
 
         //
-        //Non power of two images
+        //Non-power of two images
         //
         if (!isPowerOfTwo(this._imageSize)) {
             let outCurrenElevations = new Float32Array(bil16.length);
@@ -91,18 +97,18 @@ class BilTerrain extends GlobusTerrain {
 
         extractElevationTiles(bil16, this.noDataValues, outCurrenElevations, outChildrenElevations);
 
-        this._elevationCache[segment.tileIndex] = {
+        this._elevationCache[tileIndex] = {
             heights: outCurrenElevations,
-            extent: segment.getExtent()
+            extent: extent
         };
 
         let dd = this._imageSize / this.plainGridSize;
 
         for (let i = 0; i < dd; i++) {
             for (let j = 0; j < dd; j++) {
-                let x = segment.tileX * 2 + j,
-                    y = segment.tileY * 2 + i,
-                    z = segment.tileZoom + 1;
+                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],
@@ -115,13 +121,13 @@ class BilTerrain extends GlobusTerrain {
     }
 }
 
-function extractElevationTilesNonPowerOfTwo(data, outCurrenElevations) {
+function extractElevationTilesNonPowerOfTwo(data: number[] | TypedArray, outCurrenElevations: number[] | TypedArray) {
     for (let i = 0, len = outCurrenElevations.length; i < len; i++) {
         outCurrenElevations[i] = data[i];
     }
 }
 
-function extractElevationTiles(data, noDataValues, outCurrenElevations, outChildrenElevations) {
+function extractElevationTiles(data: number[] | TypedArray, noDataValues: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]) {
     let destSize = Math.sqrt(outCurrenElevations.length) - 1;
     let destSizeOne = destSize + 1;
     let sourceSize = Math.sqrt(data.length);
@@ -240,4 +246,4 @@ function extractElevationTiles(data, noDataValues, outCurrenElevations, outChild
     }
 }
 
-export { BilTerrain };
+export {BilTerrain};

package/src/terrain/EmptyTerrain.ts

@@ -0,0 +1,230 @@
+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[]
+}
+
+/**
+ * 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 {
+
+    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 = {}) {
+
+        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 {
+        return true;
+    }
+
+    public isEqual(obj: this): boolean {
+        return obj.__id === this.__id;
+    }
+
+    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean {
+        return binarySearchFast(noDataValues, value) !== -1;
+    }
+
+    public isBlur(segment?: Segment): boolean {
+        return false;
+    }
+
+    public set maxNodeZoom(val: number) {
+        if (val > this.gridSizeByZoom.length - 1) {
+            val = this.gridSizeByZoom.length - 1;
+        }
+        this._maxNodeZoom = val;
+    }
+
+    public get maxNodeZoom(): number {
+        return this._maxNodeZoom;
+    }
+
+    public set geoid(geoid: Geoid) {
+        this._geoid = geoid;
+    }
+
+    public get geoid(): Geoid {
+        return this._geoid;
+    }
+
+    public getGeoid(): Geoid {
+        return this._geoid;
+    }
+
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    public handleSegmentTerrain(segment: Segment) {
+        segment.terrainIsLoading = false;
+        segment.terrainReady = true;
+        segment.terrainExists = true;
+    }
+
+    public isReady(): boolean {
+        return this._isReady;
+    }
+
+    public abortLoading() {
+    }
+
+    public clearCache() {
+    }
+
+    public getHeightAsync(lonLat: LonLat, callback: (height: number) => void): boolean {
+        callback(0);
+        return true;
+    }
+
+    public loadTerrain(segment: Segment, forceLoading: boolean = false) {
+
+    }
+}
+
+export {EmptyTerrain};

package/src/{og/terrain/Geoid.js → terrain/Geoid.ts}

@@ -34,40 +34,68 @@
 //        console.log(err);
 //    });
 
-'use strict';
+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
+};
 
 class Geoid {
-    constructor(options = {}) {
+
+    public model: GeoidModel | null;
+    public 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 = {}) {
 
         this.model = options.model || null;
         this.src = options.src || null;
 
-        this._cached_ix = null;
-        this._cached_iy = null;
-        this._v00 = null;
-        this._v01 = null;
-        this._v10 = null;
-        this._v11 = null;
-        this._t = 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) {
+    static loadModel(url?: string | null): Promise<GeoidModel | null> {
         if (!url) {
-            return new Promise((resolve) => {
+            return new Promise((resolve: any) => {
                 resolve(null);
             });
         } else
-
             return fetch(url, {})
 
-                .then((r) => {
+                .then((r: Response) => {
                     if (!r.ok) {
                         throw Error("Geoid model file: HTTP error " + r.status);
                     }
                     return r.arrayBuffer();
                 })
 
-                .then((r) => {
+                .then((r: ArrayBuffer) => {
                     if (r) {
                         return new Uint8Array(r);
                     } else {
@@ -75,7 +103,7 @@ class Geoid {
                     }
                 })
 
-                .then(function (rawfile) {
+                .then(function (rawfile: Uint8Array) {
 
                     if (!((rawfile[0] === 80) && (rawfile[1] === 53) && (
                         ((rawfile[2] === 13) && (rawfile[3] === 10)) ||
@@ -84,12 +112,12 @@ class Geoid {
                         throw new Error("Geoid model file: no PGM header");
                     }
 
-                    var i = (rawfile[2] === 13) ? 4 : 3;
-                    var offset = null;
-                    var scale = null;
+                    var i: number = (rawfile[2] === 13) ? 4 : 3;
+                    var offset: number | null = null;
+                    var scale: number | null = null;
 
-                    function getline() {
-                        var start = i;
+                    function getline(): string {
+                        let start = i;
                         for (var j = i; ; j++) {
                             if (j >= rawfile.length) {
                                 throw new Error("Geoid model file: missing newline in header");
@@ -100,7 +128,7 @@ class Geoid {
                             }
                         }
                         if ((j > start) && (rawfile[j - 1] === 13)) j--;
-                        return String.fromCharCode.apply(null, rawfile.slice(start, j));
+                        return String.fromCharCode.apply(null, rawfile.slice(start, j) as any);
                     }
 
                     var m, s;
@@ -126,8 +154,8 @@ class Geoid {
 
                     m = s.match(/^\s*(\d+)\s+(\d+)\s*$/);
 
-                    var width = null;
-                    var height = null;
+                    let width: number = 0;
+                    let height: number = 0;
 
                     if (m) {
                         width = parseInt(m[1], 10);
@@ -138,7 +166,7 @@ class Geoid {
                         throw new Error("Geoid model file: bad PGM width&height line");
                     }
 
-                    var levels = parseInt(getline());
+                    let levels = parseInt(getline());
 
                     if (levels != 65535) {
                         throw new Error("Geoid model file: PGM file must have 65535 gray levels");
@@ -153,7 +181,7 @@ class Geoid {
                         throw new Error("Geoid model file: Raster size too small");
                     }
 
-                    var payload_len = rawfile.length - i;
+                    let payload_len = rawfile.length - i;
 
                     if (payload_len !== (width * height * 2)) {
                         throw new Error("Geoid model file: File has the wrong length");
@@ -172,12 +200,12 @@ class Geoid {
                 });
     }
 
-    setModel(model) {
+    setModel(model: GeoidModel | null) {
         this.model = model;
     }
 
-    _rawval(ix, iy) {
-        let model = this.model;
+    protected _rawval(ix: number, iy: number): number {
+        let model = this.model!;
 
         if (iy < 0) {
             iy = -iy;
@@ -193,16 +221,16 @@ class Geoid {
             ix -= model.width;
         }
 
-        var k = (iy * model.width + ix) * 2 + model.i;
+        let k = (iy * model.width + ix) * 2 + model.i;
 
         return (model.rawfile[k] << 8) | model.rawfile[k + 1];
     }
 
-    getHeightLonLat(lonlat) {
+    public getHeightLonLat(lonlat: LonLat): number {
         return this.getHeight(lonlat.lon, lonlat.lat);
     }
 
-    getHeight(lon, lat) {
+    public getHeight(lon: number, lat: number): number {
 
         if (!this.model) return 0;
 
@@ -210,10 +238,10 @@ class Geoid {
 
         if (lon < 0) lon += 360.0;
 
-        var fy = (90 - lat) * model.rlatres;
-        var fx = lon * model.rlonres;
-        var iy = Math.floor(fy);
-        var ix = Math.floor(fx);
+        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;
@@ -233,15 +261,13 @@ class Geoid {
             this._v11 = this._rawval(ix + 1, iy + 1);
         }
 
-        let h = null;
-
-        var a = (1 - fx) * this._v00 + fx * this._v01;
-        var b = (1 - fx) * this._v10 + fx * this._v11;
+        let a = (1 - fx) * this._v00 + fx * this._v01;
+        let b = (1 - fx) * this._v10 + fx * this._v11;
 
-        h = (1 - fy) * a + fy * b;
+        let h = (1 - fy) * a + fy * b;
 
         return model.offset + model.scale * h;
     }
 }
 
-export { Geoid };
+export {Geoid};