@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/Math/tessellation/tile-merger.ts

@@ -0,0 +1,578 @@
+import { DrawnTileInfo, GlobeBBox, Globe } from "../../types";
+import { xyzToBBOX } from "../xyz-tile";
+import { calculateMergedMeshDimLength } from "./methods";
+import { NearestValuePadding } from "./nearest-value-padding";
+// Channel of float32array mesh is 1;
+
+
+type TileLimit = {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    antimeridian?: boolean;
+    centerX?: number;
+    centerY?: number;
+}
+
+type TileMetaData = {
+    tileMap: Map<string, DrawnTileInfo>;
+    maxLevel: number;
+    minLevel: number;
+    tileLimitsByZoom: Map<number, TileLimit>;
+
+
+}
+
+
+
+
+
+export type MergedTilesInfo = {
+    mesh: Float32Array, bbox: GlobeBBox, zoom: number, coverRatio: { x: number, y: number }
+};
+
+
+
+
+function keyMethod(x: number, y: number, level: number): string {
+    return `${level}_${x}_${y}`;
+}
+
+function calculateParentTile(x: number, y: number, level: number): { x: number, y: number, level: number } {
+    return {
+        x: Math.floor(x / 2),
+        y: Math.floor(y / 2),
+        level: level - 1
+    };
+}
+
+// helper for analyses
+type ZoomLevelData = {
+    xValues: number[]; // All X coordinates at this level
+    yValues: number[]; // All Y Coordinates at this level
+}
+
+function createMapAndMetaData(tiles: DrawnTileInfo[], globe: Globe): TileMetaData {
+    const tileMap = new Map<string, DrawnTileInfo>();
+    let maxLevel = -Infinity;
+    let minLevel = Infinity;
+
+    // Intermediate storage to analyze distributions per zoom level
+    const zoomData = new Map<number, ZoomLevelData>();
+
+    // 1. First Pass: Populate Map and Collect Coordinates
+    for (const tile of tiles) {
+        const key = keyMethod(tile.x, tile.y, tile.level);
+        tileMap.set(key, tile);
+
+        // Update Level Range
+        if (tile.level > maxLevel) maxLevel = tile.level;
+        if (tile.level < minLevel) minLevel = tile.level;
+
+        // Collect Data
+        if (!zoomData.has(tile.level)) {
+            zoomData.set(tile.level, { xValues: [], yValues: [] });
+        }
+        const data = zoomData.get(tile.level)!;
+        data.xValues.push(tile.x);
+        data.yValues.push(tile.y);
+    }
+
+    const tileLimitsByZoom = new Map<number, TileLimit>();
+
+    // 2. Second Pass: Analyze Data per Zoom Level
+    zoomData.forEach((data, level) => {
+        // --- Calculate Gravity Centers (Mode) ---
+
+
+        // --- Calculate Min/Max and Antimeridian ---
+        // Sort X values to detect gaps
+        const sortedX = [...new Set(data.xValues)].sort((a, b) => a - b);
+        const minY = Math.min(...data.yValues);
+        const maxY = Math.max(...data.yValues);
+
+        let minX = sortedX[0];
+        let maxX = sortedX[sortedX.length - 1];
+        let isAntimeridian = false;
+
+
+        // We only check for wrapping if we have tiles near both edges (0 and Max)
+        // A simple heuristic: find the largest gap between sorted indices.
+        let maxGap = 0;
+        let gapIndex = -1;
+
+        for (let i = 0; i < sortedX.length - 1; i++) {
+            const gap = sortedX[i + 1] - sortedX[i];
+            if (gap > maxGap) {
+                maxGap = gap;
+                gapIndex = i;
+            }
+        }
+
+        // Also check the wrap-around gap (distance from last tile to world end + first tile)
+        // Though strictly for clustering split, we usually look for the internal gap.
+
+        // If the largest internal gap is significantly large (e.g., > worldWidth / 2),
+        // we treat the smaller numbers as the "East of view" (Right side) 
+        // and large numbers as "West of view" (Left side) relative to the dateline.
+        // let centerX = getGravityCenter(data.xValues);
+        // const centerY = getGravityCenter(data.yValues);
+        const { x: centerX, y: centerY } = getCenterFromCamera(globe, level);
+        if (maxGap > 5 && maxX === Math.pow(2, level) - 1 && minX === 0) {
+            isAntimeridian = true;
+
+            // Cluster 1 (Low X): sortedX[0] ... sortedX[gapIndex]  -> "West Cluster" (The Americas/Left side of map 0..x)
+            // Cluster 2 (High X): sortedX[gapIndex+1] ... end      -> "East Cluster" (Asia/Right side of map x..max)
+
+            // Per requirements:
+            // "max value now represents max of west cluster" -> Max of the Low X numbers
+            maxX = sortedX[gapIndex];
+
+            // "min values represents min of east cluster" -> Min of the High X numbers
+            minX = sortedX[gapIndex + 1];
+
+        }
+
+        tileLimitsByZoom.set(level, {
+            minX,
+            maxX,
+            minY,
+            maxY,
+            antimeridian: isAntimeridian,
+            centerX,
+            centerY
+        });
+    });
+
+    return {
+        tileMap,
+        maxLevel,
+        minLevel,
+        tileLimitsByZoom
+    };
+}
+
+// Helper to find the most frequent value (Gravity Center)
+function getMode(arr: number[]): number {
+    if (arr.length === 0) return 0;
+    const map = new Map<number, number>();
+    let maxCount = 0;
+    let mode = arr[0];
+
+    for (const num of arr) {
+        const count = (map.get(num) || 0) + 1;
+        map.set(num, count);
+        if (count > maxCount) {
+            maxCount = count;
+            mode = num;
+        }
+    }
+    return mode;
+}
+
+
+function getGravityCenter(arr: number[]): number {
+    if (arr.length === 0) return 0;
+    const sum = arr.reduce((acc, val) => acc + val, 0);
+    return Math.round(sum / arr.length);
+}
+
+function getCenterFromCamera(globe: any, zoom: number): { x: number, y: number } {
+    const camLongLat = globe.FCamera.FCamLongLat;
+    const n = Math.pow(2, zoom);
+    const x = Math.floor((camLongLat.x / (2 * Math.PI) + 0.5) * n);
+    const y = Math.floor((camLongLat.y / Math.PI + 0.5) * n);
+    return { x, y };
+
+}
+
+
+function populateTileIntoHigherZoomLevel(
+    tileMesh: Float32Array[], tileDimensionLength: number,
+    targetDimensionLength: number,
+): Float32Array[] {
+    const newMesh = Array.from({ length: targetDimensionLength }, () => new Float32Array(targetDimensionLength));
+    // use linear interpolation to populate
+    for (let row = 0; row < targetDimensionLength; row++) {
+        for (let col = 0; col < targetDimensionLength; col++) {
+            const sourceRow = row / (targetDimensionLength - 1) * (tileDimensionLength - 1);
+            const sourceCol = col / (targetDimensionLength - 1) * (tileDimensionLength - 1);
+            const rowLow = Math.floor(sourceRow);
+            const rowHigh = Math.min(Math.ceil(sourceRow), tileDimensionLength - 1);
+            const colLow = Math.floor(sourceCol);
+            const colHigh = Math.min(Math.ceil(sourceCol), tileDimensionLength - 1);
+            const topLeft = tileMesh[rowLow][colLow];
+            const topRight = tileMesh[rowLow][colHigh];
+            const bottomLeft = tileMesh[rowHigh][colLow];
+            const bottomRight = tileMesh[rowHigh][colHigh];
+            const top = topLeft + (topRight - topLeft) * (sourceCol - colLow);
+            const bottom = bottomLeft + (bottomRight - bottomLeft) * (sourceCol - colLow);
+            newMesh[row][col] = top + (bottom - top) * (sourceRow - rowLow);
+        }
+    }
+    return newMesh;
+}
+
+
+
+
+function fillFromChildren(
+    targetMesh: Float32Array, targetDimensionLength: number,
+    childrenMeshes: (Float32Array[] | undefined)[], sourceDimensionLength: number,
+    startX: number, startY: number): void {
+
+    const halfDim = (sourceDimensionLength - 1) / 2;
+
+    // Child 0: Top Left
+    if (childrenMeshes[0]) {
+        const child = childrenMeshes[0];
+        for (let r = 0; r <= halfDim; r++) {
+            // Read from top of child (source convention is bottom-up, so top is index Length-1)
+            // We skip every second row: (L-1), (L-3), ...
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                // Skip every second column
+                const val = rowData[c * 2];
+                const targetIdx = (startY + r) * targetDimensionLength + (startX + c);
+                targetMesh[targetIdx] = val;
+            }
+        }
+    }
+
+    // Child 1: Top Right
+    // In mergeTiles loop (dx outer, dy inner), index 2 corresponds to dx=1, dy=0 (Top Right)
+    if (childrenMeshes[2]) {
+        const child = childrenMeshes[2];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + r) * targetDimensionLength + (startX + halfDim + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+
+    // Child 2: Bottom Left
+    // In mergeTiles loop, index 1 corresponds to dx=0, dy=1 (Bottom Left)
+    if (childrenMeshes[1]) {
+        const child = childrenMeshes[1];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + halfDim + r) * targetDimensionLength + (startX + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+
+    // Child 3: Bottom Right
+    if (childrenMeshes[3]) {
+        const child = childrenMeshes[3];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + halfDim + r) * targetDimensionLength + (startX + halfDim + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+}
+
+
+
+// This function is correct, assuming its inputs are prepared properly.
+// This function is correct, assuming its inputs are prepared properly.
+function moveMeshToMergedMesh(
+    targetMesh: Float32Array, targetDimensionLength: number,
+    sourceMesh: Float32Array[], sourceDimensionLength: number,
+    startX: number, startY: number): void {
+    // sourceMesh[0][0] is south west corner
+    // targetMesh[0][0] is top left corner
+    let targetIndex: number = startY * targetDimensionLength + startX;
+    for (let y = 0; y < sourceDimensionLength; y++) {
+        // Read from bottom to top (source mesh convention)
+        const vertical = sourceMesh[sourceDimensionLength - y - 1];
+        for (let x = 0; x < sourceDimensionLength; x++) {
+            const value = vertical[x];
+            // const currentValue = targetMesh[targetIndex];
+            // TODO: investigate why overlapping values are not the same. cancel parent filling
+            // if (!isNaN(value) && value !== 0 && currentValue !== 0) {
+            //     if (currentValue !== value) {
+            //         console.warn(`Overlapping values are not the same: currentValue=${currentValue}, newValue=${value}`);
+            //     }
+            // }
+            if (isNaN(targetMesh[targetIndex])) {
+                targetMesh[targetIndex] = value;
+            }
+            targetIndex++;
+        }
+        targetIndex += targetDimensionLength - sourceDimensionLength;
+    }
+}
+
+
+
+
+
+function limitCheck(limit: TileLimit, limitRange = 12): void {
+    // TODO: far tiles from camera should be pruned to fit in the limit range
+    const rowRange = limit.maxX - limit.minX + 1;
+    const colRange = limit.maxY - limit.minY + 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: TileMetaData, mergeCount = 8, tileDimensionLength = 5, processLimit = 6): MergedTilesInfo[] {
+    const mergedMeshDimLength = calculateMergedMeshDimLength(mergeCount, tileDimensionLength);
+    const nearestValuePadding = new NearestValuePadding(tileDimensionLength, mergeCount);
+
+    // Helper to check if a number is between range (inclusive)
+
+    const result: MergedTilesInfo[] = [];
+
+    for (let zoom = tilesMetaData.maxLevel; zoom >= tilesMetaData.minLevel; zoom--) {
+
+        if (tilesMetaData.maxLevel - zoom >= processLimit) {
+            break;
+        }
+
+        const limits = tilesMetaData.tileLimitsByZoom.get(zoom);
+        if (!limits) continue;
+
+        const mergedMesh = new Float32Array(mergedMeshDimLength * mergedMeshDimLength).fill(NaN);
+
+        // Initialize BBox. 
+        // We track East (high X) and West (low X) clusters separately for Antimeridian cases.
+        const bboxLimit: GlobeBBox = {
+            ur: { x: -Infinity, y: -Infinity },
+            ll: { x: Infinity, y: Infinity }
+        };
+
+        // Specific BBox trackers for antimeridian split
+        let eastClusterMinX = Infinity; // For the left side of the view (e.g. 170)
+        let westClusterMaxX = -Infinity;  // For the right side of the view (e.g. -170)
+
+        // limitCheck(limits, 20); // Assumed helper<
+
+        const worldWidth = Math.pow(2, zoom);
+
+        // --- Task 1: Calculate Grid Origin (Centering) ---
+        // We determine where the top-left of our mergeCount x mergeCount grid starts in tile coordinates.
+
+        let originX = limits.minX;
+        let originY = limits.minY;
+
+        const rangeX = limits.antimeridian
+            ? (worldWidth - limits.minX) + limits.maxX + 1
+            : limits.maxX - limits.minX + 1;
+        const rangeY = limits.maxY - limits.minY + 1;
+
+        // If the data is wider than the mesh, center it using centerX
+        if (rangeX > mergeCount && limits.centerX !== undefined) {
+            originX = Math.floor(limits.centerX - (mergeCount / 2));
+        }
+
+        // If the data is taller than the mesh, center it using centerY
+        if (rangeY > mergeCount && limits.centerY !== undefined) {
+            originY = Math.floor(limits.centerY - (mergeCount / 2));
+        }
+
+        // --- Task 2: Iterate Grid Slots ---
+        // Instead of iterating tile coordinates, we iterate the target grid slots (0..mergeCount)
+        // and calculate which tile belongs there.
+
+        for (let i = 0; i < mergeCount; i++) {
+            for (let j = 0; j < mergeCount; j++) {
+
+                // Calculate actual Tile Coordinates
+                // Handle X Wrapping for Antimeridian
+                let tileX = (originX + i);
+                // JS modulo of negative numbers behaves oddly, ensure positive wrap
+                tileX = ((tileX % worldWidth) + worldWidth) % worldWidth;
+
+                const tileY = originY + j;
+
+                // --- Validity Check ---
+                // Check if this specific tileX/tileY is actually part of the visible map data
+                let isValidX = false;
+                if (limits.antimeridian) {
+                    isValidX = tileX >= limits.minX || tileX <= limits.maxX;
+                } else {
+                    isValidX = tileX >= limits.minX && tileX <= limits.maxX;
+                }
+
+                const isValidY = tileY >= limits.minY && tileY <= limits.maxY;
+
+                if (!isValidX || !isValidY) continue;
+
+                const key = keyMethod(tileX, tileY, zoom);
+                const tile = tilesMetaData.tileMap.get(key);
+
+                // Calculate mesh offset (target position in pixels/floats)
+                const meshOffsetX = i * (tileDimensionLength - 1);
+                const meshOffsetY = j * (tileDimensionLength - 1);
+
+                if (tile) {
+                    // 1. Direct Tile Found
+                    nearestValuePadding.insert(tile.x, tile.y); // Using original coordinates for padding logic
+                    moveMeshToMergedMesh(
+                        mergedMesh, mergedMeshDimLength,
+                        tile.mesh, tileDimensionLength,
+                        meshOffsetX, meshOffsetY
+                    );
+
+                    // Update BBox Limits
+                    // We simply expand the LL/UR. 
+                    // Post-processing will fix the inverted X for antimeridian.
+                    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;
+
+                    // Track clusters for antimeridian split
+                    // High X values (East Cluster) -> Left side of visual boundary
+                    // Low X values (West Cluster) -> Right side of visual boundary
+                    if (limits.antimeridian) {
+                        if (tileX >= limits.minX) {
+                            if (tile.bbox.ll.x < eastClusterMinX) eastClusterMinX = tile.bbox.ll.x;
+                        } else {
+                            if (tile.bbox.ur.x > westClusterMaxX) westClusterMaxX = tile.bbox.ur.x;
+                        }
+                    }
+
+                } else {
+                    // 2. Parent Tile Fallback
+                    const parentTileCoord = calculateParentTile(tileX, tileY, zoom);
+                    const parentKey = keyMethod(parentTileCoord.x, parentTileCoord.y, parentTileCoord.level);
+                    const parentTile = tilesMetaData.tileMap.get(parentKey);
+
+                    if (parentTile) {
+                        const populatedMesh = populateTileIntoHigherZoomLevel(
+                            parentTile.mesh, tileDimensionLength,
+                            tileDimensionLength * 2 - 1
+                        );
+
+                        // Adjust offset for parent logic
+                        // If current tile is odd (right/bottom), the parent mesh drawing needs to shift back
+                        // because 'populatedMesh' covers 2x2.
+                        const parentDrawOffsetX = meshOffsetX - (tileX % 2) * (tileDimensionLength - 1);
+                        const parentDrawOffsetY = meshOffsetY - (tileY % 2) * (tileDimensionLength - 1);
+
+                        moveMeshToMergedMesh(
+                            mergedMesh, mergedMeshDimLength,
+                            populatedMesh, tileDimensionLength * 2 - 1,
+                            parentDrawOffsetX,
+                            parentDrawOffsetY
+                        );
+
+                        // Padding logic for parents
+                        const xP = parentTile.x * 2;
+                        const yP = parentTile.y * 2;
+                        for (let dx = 0; dx < 2; dx++) {
+                            for (let dy = 0; dy < 2; dy++) {
+                                nearestValuePadding.insert(xP + dx, yP + dy);
+                            }
+                        }
+                    } else {
+                        // 3. Children Tile Fallback
+                        const childrenTiles: (Float32Array[] | undefined)[] = [];
+                        let anyChildren = 0;
+                        for (let dx = 0; dx < 2; dx++) {
+                            for (let dy = 0; dy < 2; dy++) {
+                                const childX = tileX * 2 + dx;
+                                const childY = tileY * 2 + dy;
+                                const childKey = keyMethod(childX, childY, zoom + 1);
+                                const childTile = tilesMetaData.tileMap.get(childKey);
+                                if (childTile) {
+                                    anyChildren++;
+                                    childrenTiles.push(childTile.mesh);
+                                } else {
+                                    childrenTiles.push(undefined);
+                                }
+                            }
+                        }
+
+                        if (anyChildren > 0) {
+                            nearestValuePadding.insert(tileX, tileY);
+                            fillFromChildren(
+                                mergedMesh, mergedMeshDimLength,
+                                childrenTiles, tileDimensionLength,
+                                meshOffsetX, meshOffsetY
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        // Post-Processing BBox for Antimeridian
+        if (limits.antimeridian) {
+            // Task: bbox.ll should contain lower-left of East Cluster, bbox.ur should contain upper-right of West Cluster
+            // This creates the condition ur.x < ll.x (e.g. 170 to -170)
+
+            // Only update if we actually found tiles in those clusters
+            if (eastClusterMinX !== Infinity) bboxLimit.ll.x = eastClusterMinX;
+            if (westClusterMaxX !== -Infinity) bboxLimit.ur.x = westClusterMaxX;
+            // console.log("Antimeridian BBox adjusted:", bboxLimit);
+        }
+
+        // We pad the merged mesh based on the VALID range we iterated.
+        // Since we iterate 0..mergeCount, the indices are implicitly 0..mergeCount
+        // However, the clamp function usually expects absolute coordinates. 
+        // Given the new "Grid" approach, the mesh is always locally 0 to mergeCount in valid data.
+        // We pass the grid-relative limits to clamp.
+        nearestValuePadding.clamp(mergedMesh, 0, 0, mergeCount, mergeCount);
+        nearestValuePadding.clear();
+
+        // Calculate Cover Ratio
+        // How much of the mesh grid (mergeCount) is covered by actual data range?
+        const currentWidth = limits.antimeridian ? rangeX : (limits.maxX - limits.minX + 1);
+        const currentHeight = limits.maxY - limits.minY + 1;
+
+        const usedWidth = Math.min(mergeCount, currentWidth);
+        const usedHeight = Math.min(mergeCount, currentHeight);
+
+        const xRatio = calculateMergedMeshDimLength(usedWidth, tileDimensionLength) / mergedMeshDimLength;
+        const yRatio = calculateMergedMeshDimLength(usedHeight, tileDimensionLength) / mergedMeshDimLength;
+
+        result.push({ mesh: mergedMesh, bbox: bboxLimit, zoom: zoom, coverRatio: { x: xRatio, y: yRatio } });
+    }
+
+    return result;
+}
+
+
+export function mergeMeshes(
+
+    tiles: DrawnTileInfo[],
+    mergeCount = 12,
+    tileDimensionLength = 5,
+    processLimit = 6,
+    globe: Globe
+): MergedTilesInfo[] {
+    // filter out tiles with NaN values
+    // return returnTop6tiles(tiles);
+
+    const tilesMetaData = createMapAndMetaData(tiles, globe);
+    const mergedTiles = mergeTiles(tilesMetaData, mergeCount, tileDimensionLength, processLimit);
+    return mergedTiles;
+}
+
+