@openglobus/og 0.20.4 → 0.22.0

package/lib/js/terrain/RgbTerrain.js

@@ -3,19 +3,23 @@ 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
+ * @extends {GlobusTerrain}
+ * @param {string} [name=""] - Terrain provider name.
+ * @param {IRgbTerrainParams} [options]:
+ * @param {boolean} [equalizeNormals=true] - Make normal equalization on the edges of the tiles.
+ * @param {string} [key=""] - API key.
+ * @param {number} [imageSize=256] - Image size.
+ * @param {number} [minHeight=-10000] - Minimal height for rgb to height converter.
+ * @param {number} [resolution=0.1] - Height converter resolution.
+ */
 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],
+            noDataValues: options.noDataValues || [options.minHeight != undefined ? options.minHeight : -10000],
             plainGridSize: options.plainGridSize || 128,
             url: options.url != undefined
                 ? options.url
@@ -30,6 +34,8 @@ class RgbTerrain extends GlobusTerrain {
         this._imageSize = options.imageSize || 256;
         this._ctx = this._createTemporalCanvas(this._imageSize);
         this._imageDataCache = {};
+        this._minHeight = options.minHeight || -10000.0;
+        this._resolution = options.resolution || 0.1;
     }
     static checkNoDataValue(noDataValues, value) {
         if (value > 50000) {
@@ -37,6 +43,13 @@ class RgbTerrain extends GlobusTerrain {
         }
         return binarySearchFast(noDataValues, value) !== -1;
     }
+    rgb2Height(r, g, b) {
+        // Filter for "yellowish" pixels
+        if (r === 255) {
+            return this._minHeight;
+        }
+        return this._minHeight + this._resolution * (r * 256 * 256 + g * 256 + b);
+    }
     isBlur(segment) {
         return segment.tileZoom >= 16;
     }
@@ -78,7 +91,7 @@ class RgbTerrain extends GlobusTerrain {
         //
         if (!isPowerOfTwo(this._imageSize) && SIZE === this._imageSize) {
             let outCurrenElevations = new Float32Array(SIZE * SIZE);
-            extractElevationTilesRgbNonPowerOfTwo(rgbaData, outCurrenElevations, this._heightFactor);
+            this.extractElevationTilesRgbNonPowerOfTwo(rgbaData, outCurrenElevations, this._heightFactor);
             return outCurrenElevations;
         }
         //
@@ -88,7 +101,7 @@ class RgbTerrain extends GlobusTerrain {
             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);
+            this.extractElevationSimple(rgbaData, this.noDataValues, availableParentData, availableParentOffsetX, availableParentOffsetY, availableZoomDiff, skipPositiveHeights, outCurrenElevations, this._heightFactor, this._imageSize);
             return outCurrenElevations;
         }
         //
@@ -105,7 +118,7 @@ class RgbTerrain extends GlobusTerrain {
             }
         }
         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);
+            this.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++) {
@@ -122,7 +135,7 @@ class RgbTerrain extends GlobusTerrain {
             }
         }
         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);
+            this.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
@@ -145,13 +158,13 @@ class RgbTerrain extends GlobusTerrain {
         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 height = this._heightFactor * this.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]));
+                callback(this._heightFactor * this.rgb2Height(data[index], data[index + 1], data[index + 2]));
                 return true;
             }
         }
@@ -169,13 +182,13 @@ class RgbTerrain extends GlobusTerrain {
                 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 height = this._heightFactor * this.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]));
+                    callback(this._heightFactor * this.rgb2Height(data[index], data[index + 1], data[index + 2]));
                 }
             }
             else if (response.status === "error") {
@@ -189,227 +202,227 @@ class RgbTerrain extends GlobusTerrain {
         });
         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);
+    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 * this.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;
         }
-        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);
+        for (let i = 0, len = imageSize; i < len; i++) {
+            let j = imageSize - 1;
+            let fromInd4 = (i * imageSize + j) * 4;
+            let height = heightFactor * this.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;
         }
-        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]);
+        for (let j = 0, len = imageSize; j < len; j++) {
+            let i = imageSize - 1;
+            let fromInd4 = (i * imageSize + j) * 4;
+            let height = heightFactor * this.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 * this.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, i, j, skipPositiveHeights);
+            height = getParentHeight(availableZoomDiff, availableParentOffsetX, availableParentOffsetY, availableParentData, imageSize - 1, imageSize - 1, 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]);
+        outCurrenElevations[outCurrenElevations.length - 1] = height;
     }
-}
-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;
+    extractElevationTilesRgbNonPowerOfTwo(rgbaData, outCurrenElevations, heightFactor = 1) {
+        for (let i = 0, len = outCurrenElevations.length; i < len; i++) {
+            let i4 = i * 4;
+            outCurrenElevations[i] = heightFactor * this.rgb2Height(rgbaData[i4], rgbaData[i4 + 1], rgbaData[i4 + 2]);
         }
-        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);
+    }
+    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 * this.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 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;
+            // 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);
             }
-            destIndex = (ii + tileY) * destSizeOne + jj + 1;
-            destArr[destIndex] = middleHeight;
-            if ((i + tileY) % dt === 0) {
-                outCurrenElevations[currIndex++] = middleHeight;
+            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;
             }
-            //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);
+            if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
+                //current tile
+                rightHeight = heightFactor * this.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;
             }
-            let middleHeight = (height + bottomHeight) * 0.5;
-            if (!(isNoDataCurrent || isNoDataBottom)) {
-                middleHeight = (height + bottomHeight) * 0.5;
+            if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
+                //current tile
+                sourceSize4 = sourceSize * 4;
+                bottomHeight = heightFactor * this.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;
             }
-            destIndex = (ii + 1) * destSizeOne + jj + tileX;
-            destArr[destIndex] = middleHeight;
-            if ((j + tileX) % dt === 0) {
+            if ((j + 1) % destSize === 0 && j !== sourceSize - 1 &&
+                (i + 1) % destSize === 0 && i !== sourceSize - 1) {
+                //current tile
+                let rightBottomHeight = heightFactor * this.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;
             }
-            //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);
+    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 * this.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 middleHeight = height;
-            if (!(isNoDataCurrent || isNoDataRight)) {
-                middleHeight = (height + rightHeight) * 0.5;
-            }
-            if ((i + tileY) % dt === 0) {
-                outCurrenElevations[currIndex++] = middleHeight;
+            let tileX = Math.floor(j / destSize), tileY = Math.floor(i / destSize);
+            if ((i + tileY) % dt === 0 && (j + tileX) % dt === 0) {
+                outCurrenElevations[currIndex++] = height;
             }
-        }
-        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);
+            if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
+                //current tile
+                rightHeight = heightFactor * this.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;
+                }
             }
-            let middleHeight = (height + bottomHeight) * 0.5;
-            if (!(isNoDataCurrent || isNoDataBottom)) {
-                middleHeight = (height + bottomHeight) * 0.5;
+            if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
+                //current tile
+                sourceSize4 = sourceSize * 4;
+                bottomHeight = heightFactor * this.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 + tileX) % dt === 0) {
+            if ((j + 1) % destSize === 0 && j !== sourceSize - 1 &&
+                (i + 1) % destSize === 0 && i !== sourceSize - 1) {
+                //current tile
+                let rightBottomHeight = heightFactor * this.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;
             }
         }
-        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;
-        }
     }
 }
+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;
+}
 export { RgbTerrain };

package/lib/js/utils/PlainSegmentWorker.js

@@ -1,5 +1,6 @@
 // import { QueueArray } from '../QueueArray.js';
 import { EPSG4326 } from "../proj/EPSG4326";
+import { equi } from "../proj/equi";
 import { BaseWorker } from "./BaseWorker";
 class PlainSegmentWorker extends BaseWorker {
     constructor(numWorkers = 2) {
@@ -53,9 +54,10 @@ class PlainSegmentWorker extends BaseWorker {
             if (this._workerQueue.length) {
                 let w = this._workerQueue.pop();
                 this._source.set(this._sourceId, segment);
+                let isLonLat = (segment._projection.id === EPSG4326.id || segment._projection.id === equi.id) ? 1.0 : 0.0;
                 let params = new Float64Array([
                     this._sourceId,
-                    segment._projection.id === EPSG4326.id ? 1.0 : 0.0,
+                    isLonLat,
                     segment.planet.terrain.gridSizeByZoom[segment.tileZoom],
                     segment.planet.terrain.plainGridSize,
                     segment._extent.southWest.lon,

package/lib/js/webgl/Handler.js

@@ -625,7 +625,7 @@ class Handler {
         this._initPrograms();
         this._setDefaults();
         this.intersectionObserver = new IntersectionObserver((entries) => {
-            this._toggleVisibilityChange(entries[0].isIntersecting);
+            this._toggleVisibilityChange(entries[entries.length - 1].isIntersecting);
         }, { threshold: 0 });
         this.intersectionObserver.observe(this.canvas);
         this.resizeObserver = new ResizeObserver(entries => {