@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/Math/tessellation/shred-input.js

@@ -1,18 +0,0 @@
-import earcut from "earcut";
-import { createTriangleTessellationMeta } from "./triangle-tessellation-meta";
-function shredInput(vertices, holes, zoomLevel) {
-    const result = [];
-    const triangles = earcut(vertices, holes, 2);
-    for (let i = 0; i < triangles.length; i += 3) {
-        const idx1 = triangles[i] * 2;
-        const idx2 = triangles[i + 1] * 2;
-        const idx3 = triangles[i + 2] * 2;
-        const p1 = [vertices[idx1], vertices[idx1 + 1]];
-        const p2 = [vertices[idx2], vertices[idx2 + 1]];
-        const p3 = [vertices[idx3], vertices[idx3 + 1]];
-        const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
-        result.push(triangleMeta);
-    }
-    // cut triangles into smaller pieces based on zoom level...
-    return result;
-}

package/Math/tessellation/tile-merger.js

@@ -1,298 +0,0 @@
-function displayTileMetaData(tilesMetaData) {
-    // show maxZoom minZoom
-    console.log(`Max Level: ${tilesMetaData.maxLevel}
-    Min Level: ${tilesMetaData.minLevel}`);
-}
-function keyMethod(row, column, level) {
-    return `${level}_${row}_${column}`;
-}
-function calculateParentTile(row, column, level) {
-    return {
-        row: Math.floor(row / 2),
-        column: Math.floor(column / 2),
-        level: level - 1
-    };
-}
-function createMapAndMetaData(tiles) {
-    const tileMap = new Map();
-    let maxLevel = -Infinity;
-    let minLevel = Infinity;
-    const tileLimitsByZoom = new Map();
-    for (const tile of tiles) {
-        const key = keyMethod(tile.row, tile.column, tile.level);
-        tileMap.set(key, tile);
-        if (tile.level > maxLevel) {
-            maxLevel = tile.level;
-        }
-        if (tile.level < minLevel) {
-            minLevel = tile.level;
-        }
-        if (!tileLimitsByZoom.has(tile.level)) {
-            tileLimitsByZoom.set(tile.level, {
-                minRow: tile.row,
-                maxRow: tile.row,
-                minCol: tile.column,
-                maxCol: tile.column
-            });
-        }
-        else {
-            const limits = tileLimitsByZoom.get(tile.level);
-            if (tile.row < limits.minRow)
-                limits.minRow = tile.row;
-            if (tile.row > limits.maxRow)
-                limits.maxRow = tile.row;
-            if (tile.column < limits.minCol)
-                limits.minCol = tile.column;
-            if (tile.column > limits.maxCol)
-                limits.maxCol = tile.column;
-        }
-    }
-    return {
-        tileMap,
-        maxLevel,
-        minLevel,
-        tileLimitsByZoom
-    };
-}
-function populateTileIntoHigherZoomLevel(tileMesh, tileDimensionLength, targetDimensionLength) {
-    const newMesh = new Array(targetDimensionLength).fill(0).map(() => new Float32Array(targetDimensionLength));
-    // use linear interpolation to populate
-    for (let row = 0; row < targetDimensionLength; row++) {
-        for (let col = 0; col < targetDimensionLength; col++) {
-            const srcRow = row * (tileDimensionLength - 1) / (targetDimensionLength - 1);
-            const srcCol = col * (tileDimensionLength - 1) / (targetDimensionLength - 1);
-            const srcRowLow = Math.floor(srcRow);
-            const srcRowHigh = Math.min(Math.ceil(srcRow), tileDimensionLength - 1);
-            const srcColLow = Math.floor(srcCol);
-            const srcColHigh = Math.min(Math.ceil(srcCol), tileDimensionLength - 1);
-            const topLeft = tileMesh[srcRowLow][srcColLow];
-            const topRight = tileMesh[srcRowLow][srcColHigh];
-            const bottomLeft = tileMesh[srcRowHigh][srcColLow];
-            const bottomRight = tileMesh[srcRowHigh][srcColHigh];
-            const top = topLeft + (topRight - topLeft) * (srcCol - srcColLow);
-            const bottom = bottomLeft + (bottomRight - bottomLeft) * (srcCol - srcColLow);
-            newMesh[row][col] = top + (bottom - top) * (srcRow - srcRowLow);
-        }
-    }
-    return newMesh;
-}
-// This function is correct, assuming its inputs are prepared properly.
-// This function is correct, assuming its inputs are prepared properly.
-function moveMeshToMergedMesh(targetMesh, targetDimensionLength, sourceMesh, sourceDimensionLength, startX, startY) {
-    for (let row = 0; row < sourceDimensionLength; row++) {
-        for (let col = 0; col < sourceDimensionLength; col++) {
-            const targetIndex = (startY + row) * targetDimensionLength + (startX + col);
-            // Check if source value exists
-            if (sourceMesh[row] === undefined || sourceMesh[row][col] === undefined) {
-                console.warn(`Source data missing at [${row}][${col}]`);
-                continue;
-            }
-            const value = sourceMesh[row][col];
-            if (isNaN(value)) {
-                console.warn(`NaN value found in source mesh at row: ${row}, col: ${col}`);
-            }
-            ;
-            if (targetIndex >= targetMesh.length) {
-                console.warn(`⚠️ Target index out of bounds: ${targetIndex} >= ${targetMesh.length}`);
-                continue;
-            }
-            targetMesh[targetIndex] = value;
-        }
-    }
-}
-function limitCheck(limit, limitRange = 12) {
-    const rowRange = limit.maxRow - limit.minRow + 1;
-    const colRange = limit.maxCol - limit.minCol + 1;
-    if (rowRange > limitRange || colRange > limitRange) {
-        console.warn(`Tile limit range exceeded: Row Range = ${rowRange}, Col Range = ${colRange}, Limit Range = ${limitRange}`);
-        throw new Error("Tile limit range exceeded");
-    }
-}
-function mergeTiles(tilesMetaData, mergeCount = 8, tileDimensionLength = 5, processLimit = 6) {
-    const mergedMeshDimLength = tileDimensionLength * mergeCount - (mergeCount - 1);
-    const processedTiles = new Set();
-    const result = [];
-    for (let zoom = tilesMetaData.maxLevel; zoom >= tilesMetaData.minLevel; zoom--) {
-        let processedTileCountFromCurrentLevel = 0;
-        let processedTileCountFromParentLevel = 0;
-        if (tilesMetaData.maxLevel - zoom >= processLimit) {
-            break;
-        }
-        const limits = tilesMetaData.tileLimitsByZoom.get(zoom);
-        const mergedMesh = new Float32Array(mergedMeshDimLength * mergedMeshDimLength).fill(0);
-        const bboxLimit = {
-            ur: { x: -Infinity, y: -Infinity },
-            ll: { x: Infinity, y: Infinity }
-        };
-        if (!limits)
-            continue;
-        limitCheck(limits, 12);
-        for (let row = limits.minRow; row <= limits.maxRow; row++) {
-            for (let col = limits.minCol; col <= limits.maxCol; col++) {
-                const key = keyMethod(row, col, zoom);
-                if (processedTiles.has(key)) {
-                    continue;
-                }
-                const tile = tilesMetaData.tileMap.get(key);
-                if (tile) {
-                    // move tile mesh to merged mesh
-                    moveMeshToMergedMesh(mergedMesh, mergedMeshDimLength, tile.mesh, tileDimensionLength, (row - limits.minRow) * (tileDimensionLength - 1), (col - limits.minCol) * (tileDimensionLength - 1));
-                    // moveMeshToMergedMesh2(
-                    //     mergedMesh, mergedMeshDimLength,
-                    //     (row + col) % 2 === 0 ? 0.1 : 0,
-                    //     tileDimensionLength,
-                    //     (row - limits.minRow) * (tileDimensionLength - 1), (col - limits.minCol) * (tileDimensionLength - 1)
-                    // );
-                    processedTiles.add(key);
-                    processedTileCountFromCurrentLevel++;
-                    // update bbox
-                    if (tile.bbox.ll.x < bboxLimit.ll.x)
-                        bboxLimit.ll.x = tile.bbox.ll.x;
-                    if (tile.bbox.ll.y < bboxLimit.ll.y)
-                        bboxLimit.ll.y = tile.bbox.ll.y;
-                    if (tile.bbox.ur.x > bboxLimit.ur.x)
-                        bboxLimit.ur.x = tile.bbox.ur.x;
-                    if (tile.bbox.ur.y > bboxLimit.ur.y)
-                        bboxLimit.ur.y = tile.bbox.ur.y;
-                    /**
-                } else {
-                    // try to find parent tile
-                    const parent = calculateParentTile(row, col, zoom);
-                    const parentKey = keyMethod(parent.row, parent.column, parent.level);
-                    const parentTile = tilesMetaData.tileMap.get(parentKey);
-
-                    if (parentTile) {
-                        // Parent's 4 children at current zoom level
-                        const parentTopLeftChildRow = parent.row * 2;
-                        const parentTopLeftChildCol = parent.column * 2;
-                        const topLeftChildKey = keyMethod(parentTopLeftChildRow, parentTopLeftChildCol, zoom);
-
-                        // Only process parent once
-                        if (!processedTiles.has(topLeftChildKey)) {
-                            // Check if parent's area is within or overlaps the current limits
-                            const parentBottomRightChildRow = parentTopLeftChildRow + 1;
-                            const parentBottomRightChildCol = parentTopLeftChildCol + 1;
-
-                            // Check if parent's children overlap with current zoom's limits
-                            if (parentTopLeftChildRow > limits.maxRow ||
-                                parentBottomRightChildRow < limits.minRow ||
-                                parentTopLeftChildCol > limits.maxCol ||
-                                parentBottomRightChildCol < limits.minCol) {
-                                // Parent doesn't overlap, skip
-                                processedTiles.add(key);
-                                continue;
-                            }
-
-                            // Upscale parent to cover all 4 children
-                            const parentTileUpscaledMesh = populateTileIntoHigherZoomLevel(
-                                parentTile.mesh,
-                                tileDimensionLength,
-                                tileDimensionLength * 2 - 1
-                            );
-
-                            // Calculate destination position (parent's top-left child position)
-                            // Clamp to limits to handle edge cases
-                            const actualStartRow = Math.max(parentTopLeftChildRow, limits.minRow);
-                            const actualStartCol = Math.max(parentTopLeftChildCol, limits.minCol);
-
-                            const destRow = (actualStartRow - limits.minRow) * (tileDimensionLength - 1);
-                            const destCol = (actualStartCol - limits.minCol) * (tileDimensionLength - 1);
-
-                            // Calculate source offset if parent starts before limits
-                            const srcRowOffset = (actualStartRow - parentTopLeftChildRow) * (tileDimensionLength - 1);
-                            const srcColOffset = (actualStartCol - parentTopLeftChildCol) * (tileDimensionLength - 1);
-
-                            // Calculate how much to copy
-                            const actualEndRow = Math.min(parentBottomRightChildRow, limits.maxRow);
-                            const actualEndCol = Math.min(parentBottomRightChildCol, limits.maxCol);
-
-                            const copyRows = (actualEndRow - actualStartRow + 1) * (tileDimensionLength - 1);
-                            const copyCols = (actualEndCol - actualStartCol + 1) * (tileDimensionLength - 1);
-
-                            // Copy only the visible portion
-                            moveMeshToMergedMeshPartial(
-                                mergedMesh,
-                                mergedMeshDimLength,
-                                parentTileUpscaledMesh,
-                                tileDimensionLength * 2 - 1,
-                                destRow,
-                                destCol,
-                                srcRowOffset,
-                                srcColOffset,
-                                copyRows,
-                                copyCols
-                            );
-
-                            // Mark all 4 child positions as processed (even if out of bounds)
-                            for (let dr = 0; dr < 2; dr++) {
-                                for (let dc = 0; dc < 2; dc++) {
-                                    const childRow = parentTopLeftChildRow + dr;
-                                    const childCol = parentTopLeftChildCol + dc;
-                                    const childKey = keyMethod(childRow, childCol, zoom);
-                                    processedTiles.add(childKey);
-                                }
-                            }
-
-                            processedTileCountFromParentLevel++;
-
-                            // Update bbox (use actual parent bbox, not child bbox)
-                            if (parentTile.bbox.ll.x < bboxLimit.ll.x) bboxLimit.ll.x = parentTile.bbox.ll.x;
-                            if (parentTile.bbox.ll.y < bboxLimit.ll.y) bboxLimit.ll.y = parentTile.bbox.ll.y;
-                            if (parentTile.bbox.ur.x > bboxLimit.ur.x) bboxLimit.ur.x = parentTile.bbox.ur.x;
-                            if (parentTile.bbox.ur.y > bboxLimit.ur.y) bboxLimit.ur.y = parentTile.bbox.ur.y;
-                        } else {
-                            // Already processed via parent
-                            processedTiles.add(key);
-                        }
-                    } else {
-                        // No parent available
-                        processedTiles.add(key);
-                    }
-               
-                    */
-                }
-            }
-        }
-        const rowRatio = (limits.maxRow - limits.minRow + 1) / mergeCount;
-        const colRatio = (limits.maxCol - limits.minCol + 1) / mergeCount;
-        // console.log(`Zoom ${zoom}: Processed ${processedTileCountFromCurrentLevel} from current level, ${processedTileCountFromParentLevel} from parent level. Coverage: ${(rowRatio * 100).toFixed(1)}% x ${(colRatio * 100).toFixed(1)}%`);
-        result.push({ mesh: mergedMesh, bbox: bboxLimit, zoom: zoom, coverRatio: { x: rowRatio, y: colRatio } });
-    }
-    return result;
-}
-export function mergeMeshes(tiles, mergeCount = 12, tileDimensionLength = 5, processLimit = 6) {
-    // filter out tiles with NaN values
-    // return returnTop6tiles(tiles);
-    const tilesMetaData = createMapAndMetaData(tiles);
-    const mergedTiles = mergeTiles(tilesMetaData, mergeCount, tileDimensionLength, processLimit);
-    return mergedTiles;
-}
-function returnTop6tiles(tiles) {
-    const tilesMetaData = createMapAndMetaData(tiles);
-    const hightestZoom = tilesMetaData.maxLevel;
-    const result = [];
-    let counter = 6;
-    function tileToMergedTileInfo(tile) {
-        const mesh = new Float32Array(tile.mesh[0].length * tile.mesh[0].length);
-        for (let row = 0; row < tile.mesh[0].length; row++) {
-            for (let col = 0; col < tile.mesh[0].length; col++) {
-                mesh[row * tile.mesh[0].length + col] = tile.mesh[0][row * tile.mesh[0].length + col];
-            }
-        }
-        return {
-            mesh: mesh,
-            zoom: tile.level,
-            bbox: tile.bbox,
-            coverRatio: { x: 1, y: 1 },
-        };
-    }
-    for (const tile of tiles) {
-        if (counter === 0)
-            break;
-        if (tile.level === hightestZoom) {
-            result.push(tileToMergedTileInfo(tile));
-            counter--;
-        }
-    }
-    return result;
-}

package/Math/tessellation/tiler.js

@@ -1,50 +0,0 @@
-"use strict";
-// /**
-//  * Find length in x and y for a tile in given zoom level (in wgs84)
-//  * Find tile cuts for given line represented by two points
-//  * Find inner position of point in tile
-//  * 
-//  */
-// import { LongLat } from "../../types";
-// export function tileLength(zoom: number): LongLat {
-//     const tileSize = 256; // in pixels
-//     const worldSize = tileSize * Math.pow(2, zoom);
-//     const latLength = 180 / worldSize;
-//     const lonLength = 360 / worldSize;
-//     return [lonLength, latLength];
-// }
-// // export function tileCuts(p1: LongLat, p2: LongLat, zoom: number): LongLat[] {
-// //     const cuts: LongLat[] = [];
-// //     const tileSize = 256;
-// //     const worldSize = tileSize * Math.pow(2, zoom);
-// //     const latLength = 180 / worldSize;
-// //     const lonLength = 360 / worldSize;
-// //     const x1 = (p1[0] + 180) / lonLength;
-// //     const y1 = (90 - p1[1]) / latLength;
-// //     const x2 = (p2[0] + 180) / lonLength;
-// //     const y2 = (90 - p2[1]) / latLength;
-// //     const dx = x2 - x1;
-// //     const dy = y2 - y1;
-// //     const steps = Math.max(Math.abs(dx), Math.abs(dy));
-// //     const xStep = dx / steps;
-// //     const yStep = dy / steps;
-// //     let x = x1;
-// //     let y = y1;
-// //     for (let i = 0; i <= steps; i++) {
-// //         const tileX = Math.floor(x);
-// //         const tileY = Math.floor(y);
-// //         const cutX = tileX * lonLength - 180;
-// //         const cutY = 90 - tileY * latLength;
-// //         const cut: LongLat = [cutX, cutY];
-// //         if (cuts.length === 0 || (cuts[cuts.length - 1][0] !== cut[0] || cuts[cuts.length - 1][1] !== cut[1])) {
-// //             cuts.push(cut);
-// //         }
-// //         x += xStep;
-// //         y += yStep;
-// //     } 
-// //     return cuts;
-// // }
-// // function fillTriangle(p1: LongLat, p2: LongLat, p3: LongLat, zoom: number): {positions:LongLat[], indices:number[]} {
-// //     // this function fills the triangle triangle iteratively
-// //     // 
-// // }