@map-colonies/mc-utils 3.1.0 → 3.3.0

package/dist/geo/tileRanger.js

@@ -1,233 +1,233 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TileRanger = void 0;
-const turf_1 = require("@turf/turf");
-const bboxUtils_1 = require("./bboxUtils");
-const tiles_1 = require("./tiles");
-const tilesGenerator_1 = require("./tilesGenerator");
-var TileIntersectionState;
-(function (TileIntersectionState) {
-    TileIntersectionState["FULL"] = "full";
-    TileIntersectionState["PARTIAL"] = "partial";
-    TileIntersectionState["NONE"] = "none";
-})(TileIntersectionState || (TileIntersectionState = {}));
-/**
- * class for generating and decoding tile hashes
- */
-class TileRanger {
-    /**
-     * converts tile to tile range of specified zoom level
-     * @param tile
-     * @param zoom target tile range zoom
-     * @returns
-     */
-    tileToRange(tile, zoom) {
-        let minX, minY, maxX, maxY;
-        minX = tile.x;
-        maxX = tile.x + 1;
-        minY = tile.y;
-        maxY = tile.y + 1;
-        if (tile.zoom < zoom) {
-            const dz = zoom - tile.zoom;
-            minX = minX << dz;
-            maxX = maxX << dz;
-            minY = minY << dz;
-            maxY = maxY << dz;
-        }
-        else if (tile.zoom > zoom) {
-            const dz = tile.zoom - zoom;
-            minX = minX >> dz;
-            minY = minY >> dz;
-            maxX = minX + 1;
-            maxY = minY + 1;
-        }
-        return {
-            minX,
-            minY,
-            maxX,
-            maxY,
-            zoom,
-        };
-    }
-    /**
-     * generate tile hashes
-     * @param footprint footprint to cover with generated tile hashes
-     * @param zoom max hash zoom
-     * @returns
-     */
-    async *encodeFootprint(footprint, zoom, verbose = false) {
-        ////////////////////////////////
-        /// Step 1: check if the footprint is identical to its bbox
-        ////////////////////////////////
-        if (verbose) {
-            console.log('encode footprint');
-        }
-        ////////////////////////////////
-        /// Step 2: convert footprint to BBOX
-        ////////////////////////////////
-        const bbox = (0, turf_1.bbox)(footprint);
-        if (this.isBbox(footprint)) {
-            // if it is convert its bbox directly to tile range and return it (bbox to tiles conversion is fast and direct mathematical conversion)
-            const tileRange = (0, bboxUtils_1.bboxToTileRange)(bbox, zoom);
-            if (verbose) {
-                console.log(`footprint is identical to its bbox - return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
-            }
-            yield await Promise.resolve(tileRange);
-        }
-        else {
-            const intersectionParams = {
-                footprint,
-                maxZoom: zoom,
-            };
-            if (verbose) {
-                console.log('footprint is different from its bbox - generateRanges');
-            }
-            yield* await Promise.resolve(this.generateRanges(bbox, zoom, intersectionParams, this.tileFootprintIntersection, verbose));
-        }
-    }
-    generateTiles(area, zoom) {
-        let gen;
-        if (Array.isArray(area)) {
-            const tileRangeGen = async function* tileRangeGenerator() {
-                yield await Promise.resolve((0, bboxUtils_1.bboxToTileRange)(area, zoom));
-            };
-            gen = tileRangeGen();
-        }
-        else {
-            gen = this.encodeFootprint(area, zoom);
-        }
-        return (0, tilesGenerator_1.tilesGenerator)(gen);
-    }
-    async *generateRanges(bbox, zoom, intersectionTarget, intersectionFunction, verbose = false) {
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        /// Step 3: Convert the bbox to tile range of the requested zoom
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        if (verbose) {
-            console.log('Convert the bbox to tile range of the requested zoom');
-        }
-        const boundingRange = (0, bboxUtils_1.bboxToTileRange)(bbox, zoom);
-        if (verbose) {
-            const bboxString = `BBOX[0]: ${bbox[0]}, BBOX[1]: ${bbox[1]}, BBOX[2]: ${bbox[2]}, BBOX[3]: ${bbox[3]}`;
-            console.log(`${bboxString}, Zoom: ${zoom}, bounding range: minX: ${boundingRange.minX}, maxX: ${boundingRange.maxX}, minY: ${boundingRange.minY}, maxY: ${boundingRange.maxY}`);
-        }
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        /// Step 4: Use range size to calculate zoom level where the target area is smaller then 1 tile
-        ///         (use zoom zero in-case there is no such zoom, for example in global bbox).
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        // find minimal zoom where the the area can be converted by area the size of single tile to skip levels that can't have full hashes
-        if (verbose) {
-            console.log("find minimal zoom where the the area can be converted by area the size of single tile to skip levels that can't have full hashes");
-        }
-        const dx = boundingRange.maxX - boundingRange.minX;
-        const dy = boundingRange.maxY - boundingRange.minY;
-        const minXZoom = Math.max(Math.floor(Math.log2(1 << (zoom + 1)) / dx) - 1, 0);
-        const minYZoom = Math.max(Math.floor(Math.log2(1 << zoom) / dy), 0);
-        const minZoom = Math.min(minXZoom, minYZoom);
-        if (verbose) {
-            console.log(`MinZoom: ${minZoom}`);
-        }
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        /// Step 5: convert the requested bbox to to tile range of the zoom level calculated in step 3 (this reduce the iteration required for the calculation)
-        /////////////////////////////////////////////////////////////////////////////////////////////////
-        //find base hashes
-        const minimalRange = (0, bboxUtils_1.bboxToTileRange)(bbox, minZoom);
-        for (let x = minimalRange.minX; x < minimalRange.maxX; x++) {
-            for (let y = minimalRange.minY; y < minimalRange.maxY; y++) {
-                /////////////////////////////////////////////////////////////////////////////////////////////////
-                /// Step 6: for every tile in the current range:
-                /// Step 7: check the tile intersection with the footprint
-                /////////////////////////////////////////////////////////////////////////////////////////////////
-                const tile = { x, y, zoom: minimalRange.zoom };
-                const intersection = intersectionFunction(tile, intersectionTarget);
-                if (verbose) {
-                    console.log(`Tile X: ${tile.x}, Y: ${tile.y} zoom ${tile.zoom}, intersection: ${intersection}`);
-                }
-                /// if it is completely covered or the tile is in the requested zoom:
-                if (intersection === TileIntersectionState.FULL) {
-                    /// convert it to tile range of the requested resolution
-                    /// add the range to the result set (yield is used for lazy calculation to improve memory usage)
-                    const tileRange = this.tileToRange(tile, zoom);
-                    if (verbose) {
-                        console.log(`return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
-                    }
-                    yield await Promise.resolve(tileRange);
-                }
-                else if (intersection === TileIntersectionState.PARTIAL) {
-                    /// if it partly covered:
-                    // calculate the sub tiles contained in the current tile (in the next zoom level)
-                    // for every sub tile recursively run step 6
-                    //optimize partial base hashes
-                    yield* await Promise.resolve(this.optimizeHash(tile, zoom, intersectionTarget, intersectionFunction, verbose));
-                }
-                /// else do nothing as this tiles aren't intersected with the original footprint
-            }
-        }
-    }
-    /**
-     * generate tile
-     * @param tile tile to get all intersecting tiles from
-     * @param targetZoom target tiles zoom level
-     * @param intersectionTarget original zoom level and footprint to intersect
-     * @param intersectionFunction the intersection function to be called
-     */
-    *optimizeHash(tile, targetZoom, intersectionTarget, intersectionFunction, verbose = false) {
-        /// generate from a tile the next zoom level tiles that compose the tile
-        if (verbose) {
-            console.log(`optimizeHash: Tile X: ${tile.x}, Y: ${tile.y} zoom ${tile.zoom}, intersectionTarget ${intersectionTarget.maxZoom}, - generate from a tile the next zoom level tiles that compose the tile`);
-        }
-        const tiles = this.generateSubTiles(tile);
-        for (const subTile of tiles) {
-            const intersection = intersectionFunction(subTile, intersectionTarget);
-            if (verbose) {
-                console.log(`Tile X: ${subTile.x}, Y: ${subTile.y} zoom ${subTile.zoom}, intersection: ${intersection}`);
-            }
-            if (intersection === TileIntersectionState.FULL) {
-                /// convert it to tile range of the requested resolution
-                /// add the range to the result set (yield is used for lazy calculation to improve memory usage)
-                const tileRange = this.tileToRange(subTile, targetZoom);
-                if (verbose) {
-                    console.log(`return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
-                }
-                yield tileRange;
-            }
-            else if (intersection === TileIntersectionState.PARTIAL) {
-                /// if it partly covered:
-                // calculate the sub tiles contained in the current tile (in the next zoom level) - recursive
-                yield* this.optimizeHash(subTile, targetZoom, intersectionTarget, intersectionFunction, verbose);
-            }
-        }
-    }
-    generateSubTiles(tile) {
-        const tile0 = { x: tile.x << 1, y: tile.y << 1, zoom: tile.zoom + 1 };
-        const tile1 = { x: tile0.x + 1, y: tile0.y, zoom: tile0.zoom };
-        const tile2 = { x: tile0.x, y: tile0.y + 1, zoom: tile0.zoom };
-        const tile3 = { x: tile0.x + 1, y: tile0.y + 1, zoom: tile0.zoom };
-        const tiles = [tile0, tile1, tile2, tile3];
-        return tiles;
-    }
-    tileFootprintIntersection = (tile, intersectionParams) => {
-        const tileBbox = (0, tiles_1.tileToBbox)(tile);
-        const tilePoly = (0, turf_1.bboxPolygon)(tileBbox);
-        const intersection = (0, turf_1.intersect)(intersectionParams.footprint, tilePoly);
-        if (intersection === null) {
-            return TileIntersectionState.NONE;
-        }
-        // stop condition
-        if (tile.zoom === intersectionParams.maxZoom) {
-            return TileIntersectionState.FULL;
-        }
-        const intArea = (0, turf_1.area)(intersection);
-        const hashArea = (0, turf_1.area)(tilePoly);
-        if (intArea == hashArea) {
-            return TileIntersectionState.FULL;
-        }
-        return TileIntersectionState.PARTIAL;
-    };
-    isBbox(footprint) {
-        const bbox = (0, turf_1.bbox)(footprint);
-        const bboxPoly = (0, turf_1.bboxPolygon)(bbox);
-        return (0, turf_1.booleanEqual)(footprint, bboxPoly);
-    }
-}
-exports.TileRanger = TileRanger;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TileRanger = void 0;
+const turf_1 = require("@turf/turf");
+const bboxUtils_1 = require("./bboxUtils");
+const tiles_1 = require("./tiles");
+const tilesGenerator_1 = require("./tilesGenerator");
+var TileIntersectionState;
+(function (TileIntersectionState) {
+    TileIntersectionState["FULL"] = "full";
+    TileIntersectionState["PARTIAL"] = "partial";
+    TileIntersectionState["NONE"] = "none";
+})(TileIntersectionState || (TileIntersectionState = {}));
+/**
+ * class for generating and decoding tile hashes
+ */
+class TileRanger {
+    /**
+     * converts tile to tile range of specified zoom level
+     * @param tile
+     * @param zoom target tile range zoom
+     * @returns
+     */
+    tileToRange(tile, zoom) {
+        let minX, minY, maxX, maxY;
+        minX = tile.x;
+        maxX = tile.x + 1;
+        minY = tile.y;
+        maxY = tile.y + 1;
+        if (tile.zoom < zoom) {
+            const dz = zoom - tile.zoom;
+            minX = minX << dz;
+            maxX = maxX << dz;
+            minY = minY << dz;
+            maxY = maxY << dz;
+        }
+        else if (tile.zoom > zoom) {
+            const dz = tile.zoom - zoom;
+            minX = minX >> dz;
+            minY = minY >> dz;
+            maxX = minX + 1;
+            maxY = minY + 1;
+        }
+        return {
+            minX,
+            minY,
+            maxX,
+            maxY,
+            zoom,
+        };
+    }
+    /**
+     * generate tile hashes
+     * @param footprint footprint to cover with generated tile hashes
+     * @param zoom max hash zoom
+     * @returns
+     */
+    async *encodeFootprint(footprint, zoom, verbose = false) {
+        ////////////////////////////////
+        /// Step 1: check if the footprint is identical to its bbox
+        ////////////////////////////////
+        if (verbose) {
+            console.log('encode footprint');
+        }
+        ////////////////////////////////
+        /// Step 2: convert footprint to BBOX
+        ////////////////////////////////
+        const bbox = (0, turf_1.bbox)(footprint);
+        if (this.isBbox(footprint)) {
+            // if it is convert its bbox directly to tile range and return it (bbox to tiles conversion is fast and direct mathematical conversion)
+            const tileRange = (0, bboxUtils_1.bboxToTileRange)(bbox, zoom);
+            if (verbose) {
+                console.log(`footprint is identical to its bbox - return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
+            }
+            yield await Promise.resolve(tileRange);
+        }
+        else {
+            const intersectionParams = {
+                footprint,
+                maxZoom: zoom,
+            };
+            if (verbose) {
+                console.log('footprint is different from its bbox - generateRanges');
+            }
+            yield* await Promise.resolve(this.generateRanges(bbox, zoom, intersectionParams, this.tileFootprintIntersection, verbose));
+        }
+    }
+    generateTiles(area, zoom) {
+        let gen;
+        if (Array.isArray(area)) {
+            const tileRangeGen = async function* tileRangeGenerator() {
+                yield await Promise.resolve((0, bboxUtils_1.bboxToTileRange)(area, zoom));
+            };
+            gen = tileRangeGen();
+        }
+        else {
+            gen = this.encodeFootprint(area, zoom);
+        }
+        return (0, tilesGenerator_1.tilesGenerator)(gen);
+    }
+    async *generateRanges(bbox, zoom, intersectionTarget, intersectionFunction, verbose = false) {
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        /// Step 3: Convert the bbox to tile range of the requested zoom
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        if (verbose) {
+            console.log('Convert the bbox to tile range of the requested zoom');
+        }
+        const boundingRange = (0, bboxUtils_1.bboxToTileRange)(bbox, zoom);
+        if (verbose) {
+            const bboxString = `BBOX[0]: ${bbox[0]}, BBOX[1]: ${bbox[1]}, BBOX[2]: ${bbox[2]}, BBOX[3]: ${bbox[3]}`;
+            console.log(`${bboxString}, Zoom: ${zoom}, bounding range: minX: ${boundingRange.minX}, maxX: ${boundingRange.maxX}, minY: ${boundingRange.minY}, maxY: ${boundingRange.maxY}`);
+        }
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        /// Step 4: Use range size to calculate zoom level where the target area is smaller then 1 tile
+        ///         (use zoom zero in-case there is no such zoom, for example in global bbox).
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        // find minimal zoom where the the area can be converted by area the size of single tile to skip levels that can't have full hashes
+        if (verbose) {
+            console.log("find minimal zoom where the the area can be converted by area the size of single tile to skip levels that can't have full hashes");
+        }
+        const dx = boundingRange.maxX - boundingRange.minX;
+        const dy = boundingRange.maxY - boundingRange.minY;
+        const minXZoom = Math.max(Math.floor(Math.log2(1 << (zoom + 1)) / dx) - 1, 0);
+        const minYZoom = Math.max(Math.floor(Math.log2(1 << zoom) / dy), 0);
+        const minZoom = Math.min(minXZoom, minYZoom);
+        if (verbose) {
+            console.log(`MinZoom: ${minZoom}`);
+        }
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        /// Step 5: convert the requested bbox to to tile range of the zoom level calculated in step 3 (this reduce the iteration required for the calculation)
+        /////////////////////////////////////////////////////////////////////////////////////////////////
+        //find base hashes
+        const minimalRange = (0, bboxUtils_1.bboxToTileRange)(bbox, minZoom);
+        for (let x = minimalRange.minX; x < minimalRange.maxX; x++) {
+            for (let y = minimalRange.minY; y < minimalRange.maxY; y++) {
+                /////////////////////////////////////////////////////////////////////////////////////////////////
+                /// Step 6: for every tile in the current range:
+                /// Step 7: check the tile intersection with the footprint
+                /////////////////////////////////////////////////////////////////////////////////////////////////
+                const tile = { x, y, zoom: minimalRange.zoom };
+                const intersection = intersectionFunction(tile, intersectionTarget);
+                if (verbose) {
+                    console.log(`Tile X: ${tile.x}, Y: ${tile.y} zoom ${tile.zoom}, intersection: ${intersection}`);
+                }
+                /// if it is completely covered or the tile is in the requested zoom:
+                if (intersection === TileIntersectionState.FULL) {
+                    /// convert it to tile range of the requested resolution
+                    /// add the range to the result set (yield is used for lazy calculation to improve memory usage)
+                    const tileRange = this.tileToRange(tile, zoom);
+                    if (verbose) {
+                        console.log(`return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
+                    }
+                    yield await Promise.resolve(tileRange);
+                }
+                else if (intersection === TileIntersectionState.PARTIAL) {
+                    /// if it partly covered:
+                    // calculate the sub tiles contained in the current tile (in the next zoom level)
+                    // for every sub tile recursively run step 6
+                    //optimize partial base hashes
+                    yield* await Promise.resolve(this.optimizeHash(tile, zoom, intersectionTarget, intersectionFunction, verbose));
+                }
+                /// else do nothing as this tiles aren't intersected with the original footprint
+            }
+        }
+    }
+    /**
+     * generate tile
+     * @param tile tile to get all intersecting tiles from
+     * @param targetZoom target tiles zoom level
+     * @param intersectionTarget original zoom level and footprint to intersect
+     * @param intersectionFunction the intersection function to be called
+     */
+    *optimizeHash(tile, targetZoom, intersectionTarget, intersectionFunction, verbose = false) {
+        /// generate from a tile the next zoom level tiles that compose the tile
+        if (verbose) {
+            console.log(`optimizeHash: Tile X: ${tile.x}, Y: ${tile.y} zoom ${tile.zoom}, intersectionTarget ${intersectionTarget.maxZoom}, - generate from a tile the next zoom level tiles that compose the tile`);
+        }
+        const tiles = this.generateSubTiles(tile);
+        for (const subTile of tiles) {
+            const intersection = intersectionFunction(subTile, intersectionTarget);
+            if (verbose) {
+                console.log(`Tile X: ${subTile.x}, Y: ${subTile.y} zoom ${subTile.zoom}, intersection: ${intersection}`);
+            }
+            if (intersection === TileIntersectionState.FULL) {
+                /// convert it to tile range of the requested resolution
+                /// add the range to the result set (yield is used for lazy calculation to improve memory usage)
+                const tileRange = this.tileToRange(subTile, targetZoom);
+                if (verbose) {
+                    console.log(`return BBOX tile range zoom: ${tileRange.zoom} : X ${tileRange.minX} - ${tileRange.maxX} : Y ${tileRange.minY} - ${tileRange.maxY}`);
+                }
+                yield tileRange;
+            }
+            else if (intersection === TileIntersectionState.PARTIAL) {
+                /// if it partly covered:
+                // calculate the sub tiles contained in the current tile (in the next zoom level) - recursive
+                yield* this.optimizeHash(subTile, targetZoom, intersectionTarget, intersectionFunction, verbose);
+            }
+        }
+    }
+    generateSubTiles(tile) {
+        const tile0 = { x: tile.x << 1, y: tile.y << 1, zoom: tile.zoom + 1 };
+        const tile1 = { x: tile0.x + 1, y: tile0.y, zoom: tile0.zoom };
+        const tile2 = { x: tile0.x, y: tile0.y + 1, zoom: tile0.zoom };
+        const tile3 = { x: tile0.x + 1, y: tile0.y + 1, zoom: tile0.zoom };
+        const tiles = [tile0, tile1, tile2, tile3];
+        return tiles;
+    }
+    tileFootprintIntersection = (tile, intersectionParams) => {
+        const tileBbox = (0, tiles_1.tileToBbox)(tile);
+        const tilePoly = (0, turf_1.bboxPolygon)(tileBbox);
+        const intersection = (0, turf_1.intersect)(intersectionParams.footprint, tilePoly);
+        if (intersection === null) {
+            return TileIntersectionState.NONE;
+        }
+        // stop condition
+        if (tile.zoom === intersectionParams.maxZoom) {
+            return TileIntersectionState.FULL;
+        }
+        const intArea = (0, turf_1.area)(intersection);
+        const hashArea = (0, turf_1.area)(tilePoly);
+        if (intArea == hashArea) {
+            return TileIntersectionState.FULL;
+        }
+        return TileIntersectionState.PARTIAL;
+    };
+    isBbox(footprint) {
+        const bbox = (0, turf_1.bbox)(footprint);
+        const bboxPoly = (0, turf_1.bboxPolygon)(bbox);
+        return (0, turf_1.booleanEqual)(footprint, bboxPoly);
+    }
+}
+exports.TileRanger = TileRanger;
 //# sourceMappingURL=tileRanger.js.map