@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,34 +1,16 @@
 import * as mercator from "../mercator";
-import {createEvents, EventsHandler} from "../Events";
-import {createExtent, stringTemplate, TypedArray} from "../utils/shared";
-import {EPSG3857} from "../proj/EPSG3857";
-import {EmptyTerrain, IEmptyTerrainParams} from "./EmptyTerrain";
-import {Extent} from "../Extent";
-import {Layer} from "../layer/Layer";
-import {IResponse, Loader} from "../utils/Loader";
-import {LonLat} from "../LonLat";
-import {NOTRENDERING} from "../quadTree/quadTree";
-import {Segment} from "../segment/Segment";
+import { createEvents } from "../Events";
+import { createExtent, stringTemplate } from "../utils/shared";
+import { EPSG3857 } from "../proj/EPSG3857";
+import { EmptyTerrain } from "./EmptyTerrain";
+import { Extent } from "../Extent";
+import { Layer } from "../layer/Layer";
+import { Loader } from "../utils/Loader";
+import { LonLat } from "../LonLat";
+import { NOTRENDERING } from "../quadTree/quadTree";
 // import { QueueArray } from '../QueueArray';
-import {Ray} from "../math/Ray";
-import {Vec3} from "../math/Vec3";
-
-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;
-
+import { Ray } from "../math/Ray";
+import { Vec3 } from "../math/Vec3";
 /**
  * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
  * @class
@@ -49,92 +31,37 @@ type UrlRewriteFunc = (segment: Segment, url: string) => string;
  * @fires GlobusTerrainEvents#loadend
  */
 class GlobusTerrain extends EmptyTerrain {
-
-    public 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 | null, options: IGlobusTerrainParams = {}) {
-
+    constructor(name = "", options = {}) {
         super({
             geoidSrc: "//openglobus.org/geoid/egm84-30.pgm",
             maxNativeZoom: options.maxNativeZoom || 14,
             ...options
         });
-
         this._s = options.subdomains || ["a", "b", "c"];
-
         this.events = createEvents(GLOBUSTERRAIN_EVENTS, this);
-
         this._requestCount = 0;
-
         this._requestsPeerSubdomain = 4;
-
         this.isEmpty = false;
-
         this.equalizeNormals = true;
-
         this.name = name || "openglobus";
-
         this.url = options.url || "//{s}.srtm3.openglobus.org/{z}/{y}/{x}.ddm";
-
         this.gridSizeByZoom = options.gridSizeByZoom || [
             64, 32, 32, 16, 16, 8, 8, 8, 8, 16, 16, 16, 16, 32, 32, 16, 8, 4, 2, 2, 2, 2, 2, 2
         ];
-
         this.noDataValues = options.noDataValues || [];
-
         this.plainGridSize = options.plainGridSize || 32;
-
         this._extent = createExtent(options.extent, new Extent(new LonLat(-180.0, -90.0), new LonLat(180.0, 90.0)));
-
         this._dataType = "arrayBuffer";
-
         this._maxNodeZoom = this.gridSizeByZoom.length - 1;
-
         this._elevationCache = {};
-
         this._fetchCache = {};
-
-        this._loader = new Loader<GlobusTerrain>();
-
+        this._loader = new Loader();
         this._urlRewriteCallback = options.urlRewrite || null;
     }
-
-    public get loader(): Loader<GlobusTerrain> {
+    get loader() {
         return this._loader;
     }
-
-    public override clearCache() {
+    clearCache() {
         for (let c in this._elevationCache) {
             this._elevationCache[c].heights = null;
             this._elevationCache[c].extent = null;
@@ -143,7 +70,6 @@ class GlobusTerrain extends EmptyTerrain {
         //@ts-ignore
         this._elevationCache = null;
         this._elevationCache = {};
-
         for (let c in this._fetchCache) {
             //@ts-ignore
             this._fetchCache[c] = null;
@@ -153,38 +79,28 @@ class GlobusTerrain extends EmptyTerrain {
         this._fetchCache = null;
         this._fetchCache = {};
     }
-
-    public override isBlur(segment: Segment): boolean {
+    isBlur(segment) {
         return segment.tileZoom >= 6;
     }
-
-    public override getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number, firstAttempt?: boolean): boolean {
+    getHeightAsync(lonLat, callback, zoom, firstAttempt) {
         if (!lonLat || lonLat.lat > mercator.MAX_LAT || lonLat.lat < mercator.MIN_LAT) {
             callback(0);
             return true;
         }
-
         firstAttempt = firstAttempt != undefined ? firstAttempt : true;
-
-        let z = zoom || this.maxZoom,
-            z2 = Math.pow(2, z),
-            size = mercator.POLE2 / z2,
-            merc = mercator.forward(lonLat),
-            x = Math.floor((mercator.POLE + merc.lon) / size),
-            y = Math.floor((mercator.POLE - merc.lat) / size);
-
+        let z = zoom || this.maxZoom, z2 = Math.pow(2, z), size = mercator.POLE2 / z2, merc = mercator.forward(lonLat), x = Math.floor((mercator.POLE + merc.lon) / size), y = Math.floor((mercator.POLE - merc.lat) / size);
         let tileIndex = Layer.getTileIndex(x, y, z);
-
         let cache = this._elevationCache[tileIndex];
-
         if (cache) {
-            if (!cache.heights) {
-                callback(0);
-            } else {
+            if (cache.heights) {
                 callback(this._getGroundHeightMerc(merc, cache));
             }
+            else {
+                callback(0);
+            }
             return true;
-        } else {
+        }
+        else {
             if (!this._fetchCache[tileIndex]) {
                 let url = this._buildURL(x, y, z);
                 this._fetchCache[tileIndex] = this._loader.fetch({
@@ -192,70 +108,51 @@ class GlobusTerrain extends EmptyTerrain {
                     type: this._dataType
                 });
             }
-
-            this._fetchCache[tileIndex].then((response: IResponse) => {
-
+            this._fetchCache[tileIndex].then((response) => {
                 let extent = mercator.getTileExtent(x, y, z);
-
                 if (response.status === "ready") {
-                    let cache: TileData = {
+                    let cache = {
                         heights: this._createHeights(response.data, tileIndex, x, y, z, extent),
                         extent: extent
                     };
                     this._elevationCache[tileIndex] = cache;
                     callback(this._getGroundHeightMerc(merc, cache));
-
-                } else if (response.status === "error") {
+                }
+                else if (response.status === "error") {
                     if (firstAttempt && z > this.maxNativeZoom) {
                         firstAttempt = false;
                         this.getHeightAsync(lonLat, callback, this.maxNativeZoom, false);
                         return;
                     }
-
                     this._elevationCache[tileIndex] = {
                         heights: null,
                         extent: extent
                     };
-
                     callback(0);
-
-                } else {
+                }
+                else {
                     // @ts-ignore
                     this._fetchCache[tileIndex] = null;
                     delete this._fetchCache[tileIndex];
                 }
             });
         }
-
         return false;
     }
-
-    public getTileCache(lonLat: LonLat, z: number): TileData | undefined {
+    getTileCache(lonLat, z) {
         if (!lonLat || lonLat.lat > mercator.MAX_LAT || lonLat.lat < mercator.MIN_LAT) {
             return;
         }
-
-        let z2 = Math.pow(2, z),
-            size = mercator.POLE2 / z2,
-            merc = mercator.forward(lonLat),
-            x = Math.floor((mercator.POLE + merc.lon) / size),
-            y = Math.floor((mercator.POLE - merc.lat) / size);
-
+        let z2 = Math.pow(2, z), size = mercator.POLE2 / z2, merc = mercator.forward(lonLat), x = Math.floor((mercator.POLE + merc.lon) / size), y = Math.floor((mercator.POLE - merc.lat) / size);
         let tileIndex = Layer.getTileIndex(x, y, z);
-
         return this._elevationCache[tileIndex];
     }
-
-    protected _getGroundHeightMerc(merc: LonLat, tileData: TileData): number {
+    _getGroundHeightMerc(merc, tileData) {
         if (!(tileData.extent && tileData.heights)) {
             return 0;
         }
-
-        let w = tileData.extent.getWidth(),
-            gs = Math.sqrt(tileData.heights.length);
-
+        let w = tileData.extent.getWidth(), gs = Math.sqrt(tileData.heights.length);
         let size = w / (gs - 1);
-
         /*
         v2-----------v3
         |            |
@@ -263,51 +160,29 @@ class GlobusTerrain extends EmptyTerrain {
         |            |
         v0-----------v1
         */
-
-        let i = gs - Math.ceil((merc.lat - tileData.extent.southWest.lat) / size) - 1,
-            j = Math.floor((merc.lon - tileData.extent.southWest.lon) / size);
-
-        let v0Ind = (i + 1) * gs + j,
-            v1Ind = v0Ind + 1,
-            v2Ind = i * gs + j,
-            v3Ind = v2Ind + 1;
-
-        let h0 = tileData.heights[v0Ind],
-            h1 = tileData.heights[v1Ind],
-            h2 = tileData.heights[v2Ind],
-            h3 = tileData.heights[v3Ind];
-
-        let v0 = new Vec3(tileData.extent.southWest.lon + size * j, h0, tileData.extent.northEast.lat - size * i - size),
-            v1 = new Vec3(v0.x + size, h1, v0.z),
-            v2 = new Vec3(v0.x, h2, v0.z + size),
-            v3 = new Vec3(v0.x + size, h3, v0.z + size);
-
-        let xyz = new Vec3(merc.lon, 100000.0, merc.lat),
-            ray = new Ray(xyz, new Vec3(0, -1, 0));
-
+        let i = gs - Math.ceil((merc.lat - tileData.extent.southWest.lat) / size) - 1, j = Math.floor((merc.lon - tileData.extent.southWest.lon) / size);
+        let v0Ind = (i + 1) * gs + j, v1Ind = v0Ind + 1, v2Ind = i * gs + j, v3Ind = v2Ind + 1;
+        let h0 = tileData.heights[v0Ind], h1 = tileData.heights[v1Ind], h2 = tileData.heights[v2Ind], h3 = tileData.heights[v3Ind];
+        let v0 = new Vec3(tileData.extent.southWest.lon + size * j, h0, tileData.extent.northEast.lat - size * i - size), v1 = new Vec3(v0.x + size, h1, v0.z), v2 = new Vec3(v0.x, h2, v0.z + size), v3 = new Vec3(v0.x + size, h3, v0.z + size);
+        let xyz = new Vec3(merc.lon, 100000.0, merc.lat), ray = new Ray(xyz, new Vec3(0, -1, 0));
         let res = new Vec3();
         let d = ray.hitTriangle(v0, v1, v2, res);
-
         if (d === Ray.INSIDE) {
             return res.y;
         }
-
         d = ray.hitTriangle(v1, v3, v2, res);
         if (d === Ray.INSIDE) {
             return res.y;
         }
-
         return 0;
     }
-
     /**
      * Stop loading.
      * @public
      */
-    public override abortLoading() {
+    abortLoading() {
         this._loader.abortAll();
     }
-
     /**
      * Sets terrain data url template.
      * @public
@@ -315,92 +190,76 @@ class GlobusTerrain extends EmptyTerrain {
      * @example <caption>Default openglobus url template:</caption>:
      * "http://earth3.openglobus.org/{z}/{y}/{x}.ddm"
      */
-    public setUrl(url: string) {
+    setUrl(url) {
         this.url = url;
     }
-
     /**
      * Sets provider name.
      * @public
      * @param {string} name - Name.
      */
-    public setName(name: string) {
+    setName(name) {
         this.name = name;
     }
-
-    public isReadyToLoad(segment: Segment): boolean {
+    isReadyToLoad(segment) {
         return segment._projection.equal(EPSG3857) && this._extent.overlaps(segment.getExtentLonLat());
     }
-
     /**
      * Starts to load segment elevation data.
      * @public
      * @param {Segment} segment - Segment that wants a terrain data.
      * @param {boolean} [forceLoading] -
      */
-    public override loadTerrain(segment: Segment, forceLoading: boolean = false) {
-
-        if (this._planet!.terrainLock.isFree()) {
-
+    loadTerrain(segment, forceLoading = false) {
+        if (this._planet.terrainLock.isFree()) {
             segment.terrainReady = false;
             segment.terrainIsLoading = true;
-
             if (this.isReadyToLoad(segment)) {
-
                 let cache = this._elevationCache[segment.tileIndex];
-
                 if (cache) {
                     this._applyElevationsData(segment, cache.heights);
-                } else {
+                }
+                else {
                     this._loader.load({
-                            sender: this,
-                            src: this._getHTTPRequestString(segment),
-                            segment: segment,
-                            type: this._dataType,
-                            filter: () => (segment.plainReady && segment.node.getState() !== NOTRENDERING) || forceLoading
-                        }, (response: IResponse) => {
-
-                            if (response.status === "ready") {
-
-                                let heights = this._createHeights(
-                                    response.data,
-                                    segment.tileIndex,
-                                    segment.tileX, segment.tileY, segment.tileZoom,
-                                    segment.getExtent(),
-                                    segment.tileZoom === this.maxZoom
-                                );
-
-                                this._elevationCache[segment.tileIndex] = {
-                                    heights: heights,
-                                    extent: segment.getExtent()
-                                };
-
-                                this._applyElevationsData(segment, heights);
-
-                            } else if (response.status === "abort") {
-                                segment.terrainIsLoading = false;
-                            } else if (response.status === "error") {
-                                this._applyElevationsData(segment, null);
-                            } else {
-                                segment.terrainIsLoading = false;
-                            }
+                        sender: this,
+                        src: this._getHTTPRequestString(segment),
+                        segment: segment,
+                        type: this._dataType,
+                        filter: () => (segment.plainReady && segment.node.getState() !== NOTRENDERING) || forceLoading
+                    }, (response) => {
+                        if (response.status === "ready") {
+                            let heights = this._createHeights(response.data, segment.tileIndex, segment.tileX, segment.tileY, segment.tileZoom, segment.getExtent(), segment.tileZoom === this.maxZoom);
+                            this._elevationCache[segment.tileIndex] = {
+                                heights: heights,
+                                extent: segment.getExtent()
+                            };
+                            this._applyElevationsData(segment, heights);
+                        }
+                        else if (response.status === "abort") {
+                            segment.terrainIsLoading = false;
+                        }
+                        else if (response.status === "error") {
+                            this._applyElevationsData(segment, null);
+                        }
+                        else {
+                            segment.terrainIsLoading = false;
                         }
-                    );
+                    });
                 }
-            } else {
+            }
+            else {
                 segment.elevationsNotExists();
             }
-        } else {
+        }
+        else {
             segment.terrainIsLoading = false;
         }
     }
-
-    protected _getSubdomain(): string {
+    _getSubdomain() {
         this._requestCount++;
         return this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomain * this._s.length) / this._requestsPeerSubdomain)];
     }
-
-    public _buildURL(x: number, y: number, z: number): string {
+    _buildURL(x, y, z) {
         return stringTemplate(this.url, {
             s: this._getSubdomain(),
             x: x.toString(),
@@ -408,51 +267,46 @@ class GlobusTerrain extends EmptyTerrain {
             z: z.toString()
         });
     }
-
     /**
      * Creates default query url string.
      * @protected
      * @param {Segment} segment -
      * @returns {string} -
      */
-    protected _createUrl(segment: Segment): string {
+    _createUrl(segment) {
         return this._buildURL(segment.tileX, segment.tileY, segment.tileZoom);
     }
-
     /**
      * Returns actual url query string.
      * @protected
      * @param {Segment} segment - Segment that loads image data.
      * @returns {string} - Url string.
      */
-    protected _getHTTPRequestString(segment: Segment): string {
+    _getHTTPRequestString(segment) {
         return this._urlRewriteCallback ? this._urlRewriteCallback(segment, this.url) : this._createUrl(segment);
     }
-
     /**
      * 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.
      */
-    public setUrlRewriteCallback(ur: UrlRewriteFunc) {
+    setUrlRewriteCallback(ur) {
         this._urlRewriteCallback = ur;
     }
-
     /**
      * 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[] {
+    _createHeights(data, tileIndex, x, y, z, extent, isMaxZoom) {
         return new Float32Array(data);
     }
-
     /**
      * @protected
      */
-    protected _applyElevationsData(segment: Segment, elevations: number[] | TypedArray | null) {
+    _applyElevationsData(segment, elevations) {
         if (segment) {
-            let e = this.events.load!;
+            let e = this.events.load;
             if (e.handlers.length) {
                 this.events.dispatch(e, {
                     elevations: elevations,
@@ -463,27 +317,16 @@ class GlobusTerrain extends EmptyTerrain {
         }
     }
 }
-
-type GlobusTerrainEventsList = [
-    "load",
-    "loadend"
-];
-
-type GlobusTerrainEvents = EventsHandler<GlobusTerrainEventsList>;
-
-const GLOBUSTERRAIN_EVENTS: GlobusTerrainEventsList = [
+const GLOBUSTERRAIN_EVENTS = [
     /**
      * Triggered when current elevation tile has loaded but before rendering.
      * @event og.terrain.GlobusTerrain#load
      */
     "load",
-
     /**
      * Triggered when all elevation tiles have loaded or loading has stopped.
      * @event og.terrain.GlobusTerrain#loadend
      */
     "loadend"
 ];
-
-
-export {GlobusTerrain};
+export { GlobusTerrain };

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

@@ -0,0 +1,21 @@
+import { Extent } from "../Extent";
+import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
+import { LonLat } from "../LonLat";
+import { Segment } from "../segment/Segment";
+import { TypedArray } from "../utils/shared";
+interface IMapboxTerrainParams extends IGlobusTerrainParams {
+    equalizeNormals?: boolean;
+    key?: string;
+    imageSize?: number;
+}
+declare class MapboxTerrain extends GlobusTerrain {
+    protected _imageSize: number;
+    protected _ctx: CanvasRenderingContext2D;
+    protected _imageDataCache: Record<string, Uint8ClampedArray>;
+    constructor(name: string | null, options?: IMapboxTerrainParams);
+    isBlur(segment: Segment): boolean;
+    protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
+    protected _createHeights(data: HTMLImageElement | ImageBitmap, tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
+    getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
+}
+export { MapboxTerrain };