@openglobus/og 0.24.2 → 0.25.0

package/lib/js/terrain/RgbTerrain.js

@@ -1,428 +0,0 @@
-import { getTileExtent } from "../mercator";
-import { GlobusTerrain } from "./GlobusTerrain";
-import { isPowerOfTwo } from "../math";
-import { Layer } from "../layer/Layer";
-import { binarySearchFast } from "../utils/shared";
-/**
- * @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 || [options.minHeight != undefined ? options.minHeight : -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 = {};
-        this._minHeight = options.minHeight || -10000.0;
-        this._resolution = options.resolution || 0.1;
-    }
-    static checkNoDataValue(noDataValues, value) {
-        if (value > 50000) {
-            return true;
-        }
-        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;
-    }
-    _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);
-            this.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];
-            this.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) {
-            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++) {
-                    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 {
-            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
-        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 * 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 * this.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 * 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 * this.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;
-    }
-    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;
-        }
-        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;
-        }
-        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, imageSize - 1, imageSize - 1, skipPositiveHeights);
-        }
-        outCurrenElevations[outCurrenElevations.length - 1] = 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]);
-        }
-    }
-    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 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 * 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;
-            }
-            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;
-            }
-            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;
-            }
-        }
-    }
-    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 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 * 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;
-                }
-            }
-            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 + 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;
-            }
-        }
-    }
-}
-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/terrain/index.d.ts

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

package/lib/js/terrain/index.js

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

package/lib/js/ui/Button.d.ts

@@ -1,33 +0,0 @@
-import { View } from './View';
-import type { IViewParams, ViewEventsList } from './View';
-import type { EventsHandler } from "../Events";
-interface HTMLElementExt extends HTMLElement {
-    __og_button__: Button;
-}
-export type ButtonEventsList = ["click", "mousedown", "mouseup", "touchstart", "touchend", "touchcancel"];
-export interface IButtonParams extends IViewParams {
-    icon?: string;
-    text?: string;
-    title?: string;
-    name?: string;
-}
-declare class Button extends View<null> {
-    events: EventsHandler<ButtonEventsList> & EventsHandler<ViewEventsList>;
-    el: HTMLElementExt | null;
-    name: string;
-    $icon: HTMLElement | null;
-    $text: HTMLElement | null;
-    constructor(options?: IButtonParams);
-    render(params: any): this;
-    protected _initEvents(): void;
-    protected _onMouseDown: (e: MouseEvent) => void;
-    protected _onMouseUp: (e: MouseEvent) => void;
-    protected _onTouchStart: (e: TouchEvent) => void;
-    protected _onTouchEnd: (e: TouchEvent) => void;
-    protected _onTouchCancel: (e: TouchEvent) => void;
-    protected _mouseClickHandler(e: MouseEvent): void;
-    protected _onMouseClick: (e: MouseEvent) => void;
-    remove(): void;
-    protected _clearEvents(): void;
-}
-export { Button };

package/lib/js/ui/Button.js

@@ -1,78 +0,0 @@
-import { stringTemplate } from '../utils/shared';
-import { View } from './View';
-const TEMPLATE = `<div class="og-button" title="{title}">
-       <div class="og-button-icon">{icon}</div>
-       <div class="og-button-text">{text}</div>
-    </div>`;
-const BUTTON_EVENTS = ["click", "mousedown", "mouseup", "touchstart", "touchend", "touchcancel"];
-class Button extends View {
-    constructor(options = {}) {
-        super({
-            template: stringTemplate(TEMPLATE, {
-                icon: options.icon || "",
-                text: options.text || "",
-                title: options.title || ""
-            }),
-            ...options
-        });
-        this._onMouseDown = (e) => {
-            e.preventDefault();
-            this.events.dispatch(this.events.mousedown, this, e);
-        };
-        this._onMouseUp = (e) => {
-            e.preventDefault();
-            this.events.dispatch(this.events.mouseup, this, e);
-        };
-        this._onTouchStart = (e) => {
-            e.preventDefault();
-            this.events.dispatch(this.events.touchstart, this, e);
-        };
-        this._onTouchEnd = (e) => {
-            e.preventDefault();
-            this.events.dispatch(this.events.touchend, this, e);
-        };
-        this._onTouchCancel = (e) => {
-            e.preventDefault();
-            this.events.dispatch(this.events.touchcancel, this, e);
-        };
-        this._onMouseClick = (e) => {
-            this._mouseClickHandler(e);
-        };
-        //@ts-ignore
-        this.events = this.events.registerNames(BUTTON_EVENTS);
-        this.el = null;
-        this.name = options.name || "";
-        this.$icon = null;
-        this.$text = null;
-    }
-    render(params) {
-        super.render(params);
-        this.$icon = this.select(".og-button-icon");
-        this.$text = this.select(".og-button-text");
-        this.el.__og_button__ = this;
-        this._initEvents();
-        return this;
-    }
-    _initEvents() {
-        if (this.el) {
-            this.el.addEventListener("click", this._onMouseClick);
-            this.el.addEventListener("mousedown", this._onMouseDown);
-            this.el.addEventListener("mouseup", this._onMouseUp);
-            this.el.addEventListener("touchstart", this._onTouchStart);
-            this.el.addEventListener("touchend", this._onTouchEnd);
-            this.el.addEventListener("touchcancel", this._onTouchCancel);
-        }
-    }
-    _mouseClickHandler(e) {
-        e.preventDefault();
-        this.events.dispatch(this.events.click, this, e);
-    }
-    remove() {
-        this._clearEvents();
-        super.remove();
-    }
-    _clearEvents() {
-        this.el && this.el.removeEventListener("click", this._onMouseClick);
-    }
-}
-export { Button };

package/lib/js/ui/ButtonGroup.d.ts

@@ -1,16 +0,0 @@
-import { ToggleButton } from "./ToggleButton";
-import type { EventsHandler } from '../Events';
-interface IButtonGroupParams {
-    buttons?: ToggleButton[];
-}
-type ButtonGroupEventsList = ["change"];
-declare class ButtonGroup {
-    events: EventsHandler<ButtonGroupEventsList>;
-    protected _buttons: ToggleButton[];
-    constructor(options?: IButtonGroupParams);
-    protected _bindButton(button: ToggleButton): void;
-    add(button: ToggleButton): void;
-    protected _onChange: (isActive: boolean, btn: ToggleButton) => void;
-    remove(button: ToggleButton): void;
-}
-export { ButtonGroup };

package/lib/js/ui/ButtonGroup.js

@@ -1,41 +0,0 @@
-import { createEvents } from '../Events';
-const BUTTONGROUP_EVENTS = ["change"];
-class ButtonGroup {
-    constructor(options = {}) {
-        this._onChange = (isActive, btn) => {
-            if (isActive) {
-                btn.preventClick = true;
-                for (let i = 0; i < this._buttons.length; i++) {
-                    let bi = this._buttons[i];
-                    if (!bi.isEqual(btn)) {
-                        bi.setActive(false);
-                        bi.preventClick = false;
-                    }
-                }
-                this.events.dispatch(this.events.change, btn);
-            }
-        };
-        this.events = createEvents(BUTTONGROUP_EVENTS);
-        this._buttons = options.buttons || [];
-        for (let i = 0; i < this._buttons.length; i++) {
-            this._bindButton(this._buttons[i]);
-        }
-    }
-    _bindButton(button) {
-        button.events.on("change", this._onChange);
-    }
-    add(button) {
-        this._buttons.push(button);
-        this._bindButton(button);
-    }
-    remove(button) {
-        for (let i = 0; i < this._buttons.length; i++) {
-            if (this._buttons[i].isEqual(button)) {
-                this._buttons.splice(i);
-                button.events.off("change", this._onChange);
-                return;
-            }
-        }
-    }
-}
-export { ButtonGroup };

package/lib/js/ui/Checkbox.d.ts

@@ -1,32 +0,0 @@
-import type { EventsHandler } from "../Events";
-import { View } from './View';
-import type { IViewParams, ViewEventsList } from './View';
-interface ICheckboxParams extends IViewParams {
-    label?: string;
-    checked?: boolean;
-    disabled?: boolean;
-}
-type CheckboxEventsList = ["change"];
-declare class Checkbox extends View<null> {
-    events: EventsHandler<CheckboxEventsList> & EventsHandler<ViewEventsList>;
-    protected $label: HTMLElement | null;
-    protected $input: HTMLInputElement | null;
-    protected _checked: boolean;
-    protected _disabled: boolean;
-    constructor(options?: ICheckboxParams);
-    set disabled(disabled: boolean);
-    protected _updateDisabled(): void;
-    get disabled(): boolean;
-    render(params: any): this;
-    protected _onResize: () => void;
-    set checked(isChecked: boolean);
-    get checked(): boolean;
-    protected _initEvents(): void;
-    protected _clearEvents(): void;
-    protected _onMouseWheel: (e: WheelEvent) => void;
-    protected _onMouseWheelFF: (e: WheelEvent) => void;
-    protected _onClick: (e: Event) => void;
-    remove(): void;
-    set visibility(visibility: boolean);
-}
-export { Checkbox };