@openglobus/og 0.19.4 → 0.20.0

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

@@ -1,6 +1,6 @@
 import { EventsHandler } from "../Events";
 import { TypedArray } from "../utils/shared";
-import { EmptyTerrain, IEmptyTerrainParams } from "./EmptyTerrain";
+import { EmptyTerrain, IEmptyTerrainParams, UrlRewriteFunc } from "./EmptyTerrain";
 import { Extent } from "../Extent";
 import { Loader } from "../utils/Loader";
 import { LonLat } from "../LonLat";
@@ -18,7 +18,6 @@ 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
@@ -66,8 +65,9 @@ declare class GlobusTerrain extends EmptyTerrain {
     get loader(): Loader<GlobusTerrain>;
     clearCache(): void;
     isBlur(segment: Segment): boolean;
+    setElevationCache(tileIndex: string, tileData: TileData): void;
+    getElevationCache(tileIndex: string): TileData | undefined;
     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.
@@ -97,7 +97,7 @@ declare class GlobusTerrain extends EmptyTerrain {
      */
     loadTerrain(segment: Segment, forceLoading?: boolean): void;
     protected _getSubdomain(): string;
-    _buildURL(x: number, y: number, z: number): string;
+    buildURL(x: number, y: number, z: number, tileGroup: number): string;
     /**
      * Creates default query url string.
      * @protected
@@ -123,7 +123,7 @@ declare class GlobusTerrain extends EmptyTerrain {
      * @public
      * @returns {Array.<number>} -
      */
-    protected _createHeights(data: any, tileIndex?: string, x?: number, y?: number, z?: number, extent?: Extent, isMaxZoom?: boolean): TypedArray | number[];
+    protected _createHeights(data: any, segment?: Segment | null, tileGroup?: number, x?: number, y?: number, z?: number, extent?: Extent, isMaxZoom?: boolean): TypedArray | number[];
     /**
      * @protected
      */

package/lib/js/terrain/GlobusTerrain.js

@@ -1,13 +1,13 @@
 import * as mercator from "../mercator";
 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 { TILEGROUP_COMMON } from "../segment/Segment";
 // import { QueueArray } from '../QueueArray';
 import { Ray } from "../math/Ray";
 import { Vec3 } from "../math/Vec3";
@@ -87,15 +87,22 @@ class GlobusTerrain extends EmptyTerrain {
     isBlur(segment) {
         return segment.tileZoom >= 6;
     }
+    setElevationCache(tileIndex, tileData) {
+        this._elevationCache[tileIndex] = tileData;
+    }
+    getElevationCache(tileIndex) {
+        return this._elevationCache[tileIndex];
+    }
     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 tileIndex = Layer.getTileIndex(x, y, z);
-        let cache = this._elevationCache[tileIndex];
+        const [x, y, z, tileGroup] = this._planet.quadTreeStrategy.getTileXY(lonLat, zoom || this.maxZoom);
+        let tileIndex = Layer.getTileIndex(x, y, z, tileGroup);
+        let cache = this.getElevationCache(tileIndex);
+        let merc = mercator.forward(lonLat);
         if (cache) {
             if (cache.heights) {
                 callback(this._getGroundHeightMerc(merc, cache));
@@ -106,21 +113,22 @@ class GlobusTerrain extends EmptyTerrain {
             return true;
         }
         else {
-            if (!this._fetchCache[tileIndex]) {
-                let url = this._buildURL(x, y, z);
-                this._fetchCache[tileIndex] = this._loader.fetch({
-                    src: url,
+            let def = this._fetchCache[tileIndex];
+            if (!def) {
+                def = this._loader.fetch({
+                    src: this.buildURL(x, y, z, tileGroup),
                     type: this._dataType
                 });
+                this._fetchCache[tileIndex] = def;
             }
-            this._fetchCache[tileIndex].then((response) => {
+            def.then((response) => {
                 let extent = mercator.getTileExtent(x, y, z);
                 if (response.status === "ready") {
                     let cache = {
-                        heights: this._createHeights(response.data, tileIndex, x, y, z, extent),
+                        heights: this._createHeights(response.data, null, tileGroup, x, y, z, extent),
                         extent: extent
                     };
-                    this._elevationCache[tileIndex] = cache;
+                    this.setElevationCache(tileIndex, cache);
                     callback(this._getGroundHeightMerc(merc, cache));
                 }
                 else if (response.status === "error") {
@@ -129,10 +137,10 @@ class GlobusTerrain extends EmptyTerrain {
                         this.getHeightAsync(lonLat, callback, this.maxNativeZoom, false);
                         return;
                     }
-                    this._elevationCache[tileIndex] = {
+                    this.setElevationCache(tileIndex, {
                         heights: null,
                         extent: extent
-                    };
+                    });
                     callback(0);
                 }
                 else {
@@ -144,14 +152,6 @@ class GlobusTerrain extends EmptyTerrain {
         }
         return false;
     }
-    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 tileIndex = Layer.getTileIndex(x, y, z);
-        return this._elevationCache[tileIndex];
-    }
     _getGroundHeightMerc(merc, tileData) {
         if (!(tileData.extent && tileData.heights)) {
             return 0;
@@ -207,7 +207,7 @@ class GlobusTerrain extends EmptyTerrain {
         this.name = name;
     }
     isReadyToLoad(segment) {
-        return segment._projection.equal(EPSG3857) && this._extent.overlaps(segment.getExtentLonLat());
+        return segment._tileGroup === TILEGROUP_COMMON && this._extent.overlaps(segment.getExtentLonLat());
     }
     /**
      * Starts to load segment elevation data.
@@ -220,7 +220,7 @@ class GlobusTerrain extends EmptyTerrain {
             segment.terrainReady = false;
             segment.terrainIsLoading = true;
             if (this.isReadyToLoad(segment)) {
-                let cache = this._elevationCache[segment.tileIndex];
+                let cache = this.getElevationCache(segment.tileIndex);
                 if (cache) {
                     this._applyElevationsData(segment, cache.heights);
                 }
@@ -233,11 +233,11 @@ class GlobusTerrain extends EmptyTerrain {
                         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] = {
+                            let heights = this._createHeights(response.data, segment, segment._tileGroup, segment.tileX, segment.tileY, segment.tileZoom, segment.getExtent(), segment.tileZoom === this.maxZoom);
+                            this.setElevationCache(segment.tileIndex, {
                                 heights: heights,
                                 extent: segment.getExtent()
-                            };
+                            });
                             this._applyElevationsData(segment, heights);
                         }
                         else if (response.status === "abort") {
@@ -264,7 +264,7 @@ class GlobusTerrain extends EmptyTerrain {
         this._requestCount++;
         return this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomain * this._s.length) / this._requestsPeerSubdomain)];
     }
-    _buildURL(x, y, z) {
+    buildURL(x, y, z, tileGroup) {
         return stringTemplate(this.url, {
             s: this._getSubdomain(),
             x: x.toString(),
@@ -279,7 +279,7 @@ class GlobusTerrain extends EmptyTerrain {
      * @returns {string} -
      */
     _createUrl(segment) {
-        return this._buildURL(segment.tileX, segment.tileY, segment.tileZoom);
+        return this.buildURL(segment.tileX, segment.tileY, segment.tileZoom, segment._tileGroup);
     }
     /**
      * Returns actual url query string.
@@ -288,7 +288,12 @@ class GlobusTerrain extends EmptyTerrain {
      * @returns {string} - Url string.
      */
     _getHTTPRequestString(segment) {
-        return this._urlRewriteCallback ? this._urlRewriteCallback(segment, this.url) : this._createUrl(segment);
+        if (this._urlRewriteCallback) {
+            return this._urlRewriteCallback(segment.tileX, segment.tileY, segment.tileZoom, segment._tileGroup) || this._createUrl(segment);
+        }
+        else {
+            return this._createUrl(segment);
+        }
     }
     /**
      * Sets url rewrite callback, used for custom url rewriting for every tile loading.
@@ -303,7 +308,7 @@ class GlobusTerrain extends EmptyTerrain {
      * @public
      * @returns {Array.<number>} -
      */
-    _createHeights(data, tileIndex, x, y, z, extent, isMaxZoom) {
+    _createHeights(data, segment, tileGroup, x, y, z, extent, isMaxZoom) {
         if (this._heightFactor !== 1) {
             let res = new Float32Array(data);
             for (let i = 0, len = res.length; i < len; i++) {

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

@@ -0,0 +1,22 @@
+import { Extent } from "../Extent";
+import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
+import { LonLat } from "../LonLat";
+import { Segment } from "../segment/Segment";
+import { TypedArray } from "../utils/shared";
+export interface IRgbTerrainParams extends IGlobusTerrainParams {
+    equalizeNormals?: boolean;
+    key?: string;
+    imageSize?: number;
+}
+declare class RgbTerrain extends GlobusTerrain {
+    protected _imageSize: number;
+    protected _ctx: CanvasRenderingContext2D;
+    protected _imageDataCache: Record<string, Uint8ClampedArray>;
+    constructor(name: string | null, options?: IRgbTerrainParams);
+    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    isBlur(segment: Segment): boolean;
+    protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
+    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;
+}
+export { RgbTerrain };

package/lib/js/terrain/RgbTerrain.js

@@ -0,0 +1,415 @@
+import { getTileExtent } from "../mercator";
+import { GlobusTerrain } from "./GlobusTerrain";
+import { isPowerOfTwo } from "../math";
+import { Layer } from "../layer/Layer";
+import { binarySearchFast } from "../utils/shared";
+const rgb2Height = (r, g, b) => {
+    // Filter for "yellowish" pixels
+    if (r === 255) {
+        return -10000;
+    }
+    return -10000 + 0.1 * (r * 256 * 256 + g * 256 + b);
+};
+class RgbTerrain extends GlobusTerrain {
+    constructor(name, options = {}) {
+        super(name || "RgbTerrain", {
+            equalizeVertices: options.equalizeVertices != undefined ? options.equalizeVertices : true,
+            maxZoom: options.maxZoom || 17,
+            noDataValues: options.noDataValues || [-65537, -10000],
+            plainGridSize: options.plainGridSize || 128,
+            url: options.url != undefined
+                ? options.url
+                : `//api.mapbox.com/v4/mapbox.terrain-rgb/{z}/{x}/{y}.pngraw?access_token=${options.key || "<key>"}`,
+            gridSizeByZoom: options.gridSizeByZoom || [
+                64, 32, 16, 8, 8, 8, 16, 16, 16, 32, 32, 32, 32, 32, 32, 64, 64, 64, 32, 32, 16, 8
+            ],
+            ...options
+        });
+        this.equalizeNormals = options.equalizeNormals || false;
+        this._dataType = "imageBitmap";
+        this._imageSize = options.imageSize || 256;
+        this._ctx = this._createTemporalCanvas(this._imageSize);
+        this._imageDataCache = {};
+    }
+    static checkNoDataValue(noDataValues, value) {
+        if (value > 50000) {
+            return true;
+        }
+        return binarySearchFast(noDataValues, value) !== -1;
+    }
+    isBlur(segment) {
+        return segment.tileZoom >= 16;
+    }
+    _createTemporalCanvas(size) {
+        let canvas = document.createElement("canvas");
+        canvas.width = size;
+        canvas.height = size;
+        return canvas.getContext("2d", {
+            willReadFrequently: true
+        });
+    }
+    _createHeights(data, segment, tileGroup, tileX, tileY, tileZoom, extent, preventChildren) {
+        this._ctx.clearRect(0, 0, this._imageSize, this._imageSize);
+        this._ctx.drawImage(data, 0, 0);
+        let rgbaData = this._ctx.getImageData(0, 0, this._imageSize, this._imageSize).data;
+        const SIZE = data.width;
+        let availableParentTileX = 0, availableParentTileY = 0, availableParentTileZoom = 0, availableParentData = null, skipPositiveHeights = false;
+        //
+        // Getting parent segment terrain data, for zero and nodata values for the current segment
+        //
+        if (segment) {
+            if (segment.tileZoom > this.maxNativeZoom) {
+                let pn = segment.node;
+                while (pn && !pn.segment.terrainExists) {
+                    pn = pn.parentNode;
+                }
+                if (pn) {
+                    availableParentTileX = pn.segment.tileX;
+                    availableParentTileY = pn.segment.tileY;
+                    availableParentTileZoom = pn.segment.tileZoom;
+                    availableParentData = pn.segment.elevationData;
+                    // in this case maxNativeZoom means sea level
+                    skipPositiveHeights = availableParentTileZoom <= 8;
+                }
+            }
+        }
+        //
+        //Non-power of two images
+        //
+        if (!isPowerOfTwo(this._imageSize) && SIZE === this._imageSize) {
+            let outCurrenElevations = new Float32Array(SIZE * SIZE);
+            extractElevationTilesRgbNonPowerOfTwo(rgbaData, outCurrenElevations, this._heightFactor);
+            return outCurrenElevations;
+        }
+        //
+        // When image size equals grid size
+        //
+        if (this._imageSize === this.plainGridSize) {
+            let elevationsSize = (this.plainGridSize + 1) * (this.plainGridSize + 1);
+            let outCurrenElevations = new Float32Array(elevationsSize);
+            let [availableParentOffsetX, availableParentOffsetY, availableZoomDiff] = segment ? getTileOffset(segment.tileX, segment.tileY, segment.tileZoom, availableParentTileX, availableParentTileY, availableParentTileZoom) : [0, 0, 0];
+            extractElevationSimple(rgbaData, this.noDataValues, availableParentData, availableParentOffsetX, availableParentOffsetY, availableZoomDiff, skipPositiveHeights, outCurrenElevations, this._heightFactor, this._imageSize);
+            return outCurrenElevations;
+        }
+        //
+        // Power of two images
+        //
+        let elevationsSize = (this.plainGridSize + 1) * (this.plainGridSize + 1);
+        let d = SIZE / this.plainGridSize;
+        let outCurrenElevations = new Float32Array(elevationsSize);
+        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);
+            }
+        }
+        if (!preventChildren) {
+            extractElevationTilesRgb(rgbaData, this._heightFactor, this.noDataValues, availableParentData, availableParentTileX, availableParentTileY, availableParentTileZoom, segment ? segment.tileX : 0, segment ? segment.tileY : 0, segment ? segment.tileZoom : 0, skipPositiveHeights, outCurrenElevations, outChildrenElevations);
+            // Save children data to cache
+            for (let i = 0; i < d; i++) {
+                for (let j = 0; j < d; j++) {
+                    let [x, y, z] = getChildTileIndex(tileX, tileY, tileZoom, j, i);
+                    let tileIndex = Layer.getTileIndex(x, y, z, tileGroup);
+                    this.setElevationCache(tileIndex, {
+                        heights: outChildrenElevations[i][j],
+                        //
+                        // @todo: must work for any grids
+                        //
+                        extent: getTileExtent(x, y, z)
+                    });
+                }
+            }
+        }
+        else {
+            extractElevationTilesRgbNoChildren(rgbaData, this._heightFactor, this.noDataValues, availableParentData, availableParentTileX, availableParentTileY, availableParentTileZoom, segment ? segment.tileX : 0, segment ? segment.tileY : 0, segment ? segment.tileZoom : 0, skipPositiveHeights, outCurrenElevations);
+        }
+        let tileIndex = Layer.getTileIndex(tileX, tileY, tileZoom, tileGroup);
+        // Save current data to cache
+        this.setElevationCache(tileIndex, {
+            heights: outCurrenElevations,
+            extent: extent
+        });
+        return outCurrenElevations;
+    }
+    getHeightAsync(lonLat, callback, zoom) {
+        zoom = zoom != undefined ? zoom : this.maxZoom;
+        if (zoom === 0) {
+            callback(0);
+            return true;
+        }
+        const qts = this._planet.quadTreeStrategy;
+        const [x, y, z, tileGroup] = qts.getTileXY(lonLat, zoom);
+        const [i, j] = qts.getLonLatTileOffset(lonLat, x, y, z, this._imageSize);
+        const index = (i * this._imageSize + j) * 4;
+        const tileIndex = Layer.getTileIndex(x, y, z, tileGroup);
+        if (this._imageDataCache[tileIndex]) {
+            let data = this._imageDataCache[tileIndex];
+            let height = this._heightFactor * rgb2Height(data[index], data[index + 1], data[index + 2]);
+            let isNoData = RgbTerrain.checkNoDataValue(this.noDataValues, height);
+            if (isNoData) {
+                return this.getHeightAsync(lonLat, callback, zoom - 1);
+            }
+            else {
+                callback(this._heightFactor * rgb2Height(data[index], data[index + 1], data[index + 2]));
+                return true;
+            }
+        }
+        let def = this._fetchCache[tileIndex];
+        if (!def) {
+            def = this._loader.fetch({
+                src: this._urlRewriteCallback && this._urlRewriteCallback(x, y, z, tileGroup) || this.buildURL(x, y, z, tileGroup),
+                type: this._dataType
+            });
+            this._fetchCache[tileIndex] = def;
+        }
+        def.then((response) => {
+            if (response.status === "ready") {
+                this._ctx.clearRect(0, 0, this._imageSize, this._imageSize);
+                this._ctx.drawImage(response.data, 0, 0);
+                let data = this._ctx.getImageData(0, 0, 256, 256).data;
+                this._imageDataCache[tileIndex] = data;
+                let height = this._heightFactor * rgb2Height(data[index], data[index + 1], data[index + 2]);
+                let isNoData = RgbTerrain.checkNoDataValue(this.noDataValues, height);
+                if (isNoData) {
+                    return this.getHeightAsync(lonLat, callback, zoom - 1);
+                }
+                else {
+                    callback(this._heightFactor * rgb2Height(data[index], data[index + 1], data[index + 2]));
+                }
+            }
+            else if (response.status === "error") {
+                return this.getHeightAsync(lonLat, callback, zoom - 1);
+            }
+            else {
+                //@ts-ignore
+                this._fetchCache[tileIndex] = null;
+                delete this._fetchCache[tileIndex];
+            }
+        });
+        return false;
+    }
+}
+function getTileOffset(currentTileX, currentTileY, currentTileZoom, parentTileX, parentTileY, parentTileZoom) {
+    let dz2 = 2 << (currentTileZoom - parentTileZoom - 1);
+    return [currentTileX - dz2 * parentTileX, currentTileY - dz2 * parentTileY, 1.0 / dz2];
+}
+function getChildTileIndex(currentParentTileX, currentParentTileY, currentParentTileZoom, childOffsetX, childOffsetY) {
+    return [currentParentTileX * 2 + childOffsetX, currentParentTileY * 2 + childOffsetY, currentParentTileZoom + 1];
+}
+function getParentHeight(oneByDz2, offsetX, offsetY, heights, i, j, skipPositiveHeights) {
+    let parentGridSize = Math.sqrt(heights.length);
+    let pi = Math.floor(offsetY * oneByDz2 * parentGridSize + i * oneByDz2), pj = Math.floor(offsetX * oneByDz2 * parentGridSize + j * oneByDz2);
+    let h = heights[pi * parentGridSize + pj];
+    return skipPositiveHeights ? (h > 0 ? 0 : h) : h;
+}
+function extractElevationSimple(rgbaData, noDataValues, availableParentData = null, availableParentOffsetX, availableParentOffsetY, availableZoomDiff, skipPositiveHeights, outCurrenElevations, heightFactor = 1, imageSize) {
+    for (let k = 0, len = imageSize * imageSize; k < len; k++) {
+        let j = k % imageSize, i = Math.floor(k / imageSize);
+        let fromInd4 = k * 4;
+        let height = heightFactor * rgb2Height(rgbaData[fromInd4], rgbaData[fromInd4 + 1], rgbaData[fromInd4 + 2]);
+        let isNoData = RgbTerrain.checkNoDataValue(noDataValues, height);
+        if ((isNoData || height === 0) && availableParentData) {
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, i, j, skipPositiveHeights);
+        }
+        outCurrenElevations[i * (imageSize + 1) + j] = height;
+    }
+    for (let i = 0, len = imageSize; i < len; i++) {
+        let j = imageSize - 1;
+        let fromInd4 = (i * imageSize + j) * 4;
+        let height = heightFactor * rgb2Height(rgbaData[fromInd4], rgbaData[fromInd4 + 1], rgbaData[fromInd4 + 2]);
+        let isNoData = RgbTerrain.checkNoDataValue(noDataValues, height);
+        if ((isNoData || height === 0) && availableParentData) {
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, i, j, skipPositiveHeights);
+        }
+        outCurrenElevations[i * (imageSize + 1) + imageSize] = height;
+    }
+    for (let j = 0, len = imageSize; j < len; j++) {
+        let i = imageSize - 1;
+        let fromInd4 = (i * imageSize + j) * 4;
+        let height = heightFactor * rgb2Height(rgbaData[fromInd4], rgbaData[fromInd4 + 1], rgbaData[fromInd4 + 2]);
+        let isNoData = RgbTerrain.checkNoDataValue(noDataValues, height);
+        if ((isNoData || height === 0) && availableParentData) {
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, i, j, skipPositiveHeights);
+        }
+        outCurrenElevations[imageSize * (imageSize + 1) + j] = height;
+    }
+    let height = heightFactor * rgb2Height(rgbaData[rgbaData.length - 4], rgbaData[rgbaData.length - 3], rgbaData[rgbaData.length - 2]);
+    let isNoData = RgbTerrain.checkNoDataValue(noDataValues, height);
+    if ((isNoData || height === 0) && availableParentData) {
+        height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, imageSize - 1, imageSize - 1, skipPositiveHeights);
+    }
+    outCurrenElevations[outCurrenElevations.length - 1] = height;
+}
+function extractElevationTilesRgbNonPowerOfTwo(rgbaData, outCurrenElevations, heightFactor = 1) {
+    for (let i = 0, len = outCurrenElevations.length; i < len; i++) {
+        let i4 = i * 4;
+        outCurrenElevations[i] = heightFactor * rgb2Height(rgbaData[i4], rgbaData[i4 + 1], rgbaData[i4 + 2]);
+    }
+}
+function extractElevationTilesRgb(rgbaData, heightFactor, noDataValues, availableParentData = null, availableParentTileX, availableParentTileY, availableParentTileZoom, currentTileX, currentTileY, currentTileZoom, skipPositiveHeights, outCurrenElevations, outChildrenElevations) {
+    let destSize = Math.sqrt(outCurrenElevations.length) - 1;
+    let destSizeOne = destSize + 1;
+    let sourceSize = Math.sqrt(rgbaData.length / 4);
+    let dt = sourceSize / destSize;
+    let rightHeight = 0, bottomHeight = 0, sourceSize4 = 0;
+    let [availableParentOffsetX, availableParentOffsetY, availableZoomDiff] = getTileOffset(currentTileX, currentTileY, currentTileZoom, availableParentTileX, availableParentTileY, availableParentTileZoom);
+    for (let k = 0, currIndex = 0, sourceDataLength = rgbaData.length / 4; k < sourceDataLength; k++) {
+        let k4 = k * 4;
+        let height = heightFactor * rgb2Height(rgbaData[k4], rgbaData[k4 + 1], rgbaData[k4 + 2]);
+        let isNoDataCurrent = RgbTerrain.checkNoDataValue(noDataValues, height), isNoDataRight = false, isNoDataBottom = false;
+        let i = Math.floor(k / sourceSize), j = k % sourceSize;
+        //
+        // Try to get current height from the parent data
+        if ((isNoDataCurrent || height === 0) && availableParentData) {
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(i / dt), Math.floor(j / dt), skipPositiveHeights);
+        }
+        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 = heightFactor * rgb2Height(rgbaData[k4 + 4], rgbaData[k4 + 5], rgbaData[k4 + 6]);
+            isNoDataRight = RgbTerrain.checkNoDataValue(noDataValues, rightHeight);
+            //
+            // Try to get right height from the parent data
+            if ((isNoDataRight || rightHeight === 0) && availableParentData) {
+                rightHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(i / dt), Math.floor((j + 1) / dt), skipPositiveHeights);
+            }
+            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
+            sourceSize4 = sourceSize * 4;
+            bottomHeight = heightFactor * rgb2Height(rgbaData[k4 + sourceSize4], rgbaData[k4 + sourceSize4 + 1], rgbaData[k4 + sourceSize4 + 2]);
+            isNoDataBottom = RgbTerrain.checkNoDataValue(noDataValues, bottomHeight);
+            //
+            // Try to get bottom height from the parent data
+            if ((isNoDataBottom || bottomHeight === 0) && availableParentData) {
+                bottomHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor((i + 1) / dt), Math.floor(j / dt), skipPositiveHeights);
+            }
+            let middleHeight = (height + bottomHeight) * 0.5;
+            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 = heightFactor * rgb2Height(rgbaData[k4 + sourceSize4 + 4], rgbaData[k4 + sourceSize4 + 5], rgbaData[k4 + sourceSize4 + 6]);
+            let isNoDataRightBottom = RgbTerrain.checkNoDataValue(noDataValues, rightBottomHeight);
+            //
+            // Try to get right bottom height from the parent data
+            if ((isNoDataRightBottom || rightBottomHeight === 0) && availableParentData) {
+                rightBottomHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor((i + 1) / dt), Math.floor((j + 1) / dt), skipPositiveHeights);
+            }
+            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;
+        }
+    }
+}
+function extractElevationTilesRgbNoChildren(rgbaData, heightFactor, noDataValues, availableParentData = null, availableParentTileX, availableParentTileY, availableParentTileZoom, currentTileX, currentTileY, currentTileZoom, skipPositiveHeights, outCurrenElevations) {
+    let destSize = Math.sqrt(outCurrenElevations.length) - 1;
+    let destSizeOne = destSize + 1;
+    let sourceSize = Math.sqrt(rgbaData.length / 4);
+    let dt = sourceSize / destSize;
+    let rightHeight = 0, bottomHeight = 0, sourceSize4 = 0;
+    let [availableParentOffsetX, availableParentOffsetY, availableZoomDiff] = getTileOffset(currentTileX, currentTileY, currentTileZoom, availableParentTileX, availableParentTileY, availableParentTileZoom);
+    for (let k = 0, currIndex = 0, sourceDataLength = rgbaData.length / 4; k < sourceDataLength; k++) {
+        let k4 = k * 4;
+        let height = heightFactor * rgb2Height(rgbaData[k4], rgbaData[k4 + 1], rgbaData[k4 + 2]);
+        let isNoDataCurrent = RgbTerrain.checkNoDataValue(noDataValues, height), isNoDataRight = false, isNoDataBottom = false;
+        let i = Math.floor(k / sourceSize), j = k % sourceSize;
+        if ((isNoDataCurrent || height === 0) && availableParentData) {
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(currIndex / destSizeOne), currIndex % destSizeOne, skipPositiveHeights);
+        }
+        let tileX = Math.floor(j / destSize), tileY = Math.floor(i / destSize);
+        if ((i + tileY) % dt === 0 && (j + tileX) % dt === 0) {
+            outCurrenElevations[currIndex++] = height;
+        }
+        if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
+            //current tile
+            rightHeight = heightFactor * rgb2Height(rgbaData[k4 + 4], rgbaData[k4 + 5], rgbaData[k4 + 6]);
+            isNoDataRight = RgbTerrain.checkNoDataValue(noDataValues, rightHeight);
+            if ((isNoDataRight || rightHeight === 0) && availableParentData) {
+                rightHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(currIndex / destSizeOne), currIndex % destSizeOne, skipPositiveHeights);
+            }
+            let middleHeight = height;
+            if (!(isNoDataCurrent || isNoDataRight)) {
+                middleHeight = (height + rightHeight) * 0.5;
+            }
+            if ((i + tileY) % dt === 0) {
+                outCurrenElevations[currIndex++] = middleHeight;
+            }
+        }
+        if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
+            //current tile
+            sourceSize4 = sourceSize * 4;
+            bottomHeight = heightFactor * rgb2Height(rgbaData[k4 + sourceSize4], rgbaData[k4 + sourceSize4 + 1], rgbaData[k4 + sourceSize4 + 2]);
+            isNoDataBottom = RgbTerrain.checkNoDataValue(noDataValues, bottomHeight);
+            if ((isNoDataBottom || bottomHeight === 0) && availableParentData) {
+                bottomHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(currIndex / destSizeOne), currIndex % destSizeOne, skipPositiveHeights);
+            }
+            let middleHeight = (height + bottomHeight) * 0.5;
+            if (!(isNoDataCurrent || isNoDataBottom)) {
+                middleHeight = (height + bottomHeight) * 0.5;
+            }
+            if ((j + tileX) % dt === 0) {
+                outCurrenElevations[currIndex++] = middleHeight;
+            }
+        }
+        if ((j + 1) % destSize === 0 && j !== sourceSize - 1 &&
+            (i + 1) % destSize === 0 && i !== sourceSize - 1) {
+            //current tile
+            let rightBottomHeight = heightFactor * rgb2Height(rgbaData[k4 + sourceSize4 + 4], rgbaData[k4 + sourceSize4 + 5], rgbaData[k4 + sourceSize4 + 6]);
+            let isNoDataRightBottom = RgbTerrain.checkNoDataValue(noDataValues, rightBottomHeight);
+            if ((isNoDataRightBottom || rightBottomHeight === 0) && availableParentData) {
+                rightBottomHeight = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, Math.floor(currIndex / destSizeOne), currIndex % destSizeOne, skipPositiveHeights);
+            }
+            let middleHeight = height;
+            if (!(isNoDataCurrent || isNoDataRight || isNoDataBottom || isNoDataRightBottom)) {
+                middleHeight = (height + rightHeight + bottomHeight + rightBottomHeight) * 0.25;
+            }
+            outCurrenElevations[currIndex++] = middleHeight;
+        }
+    }
+}
+export { RgbTerrain };

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

@@ -1,5 +1,6 @@
 import { BilTerrain } from './BilTerrain';
 import { EmptyTerrain } from './EmptyTerrain';
 import { GlobusTerrain } from './GlobusTerrain';
-import { MapboxTerrain } from './MapboxTerrain';
-export { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain };
+import { RgbTerrain } from './RgbTerrain';
+import { GlobusRgbTerrain } from './GlobusRgbTerrain';
+export { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain };