@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{Math/tessellation/tile-merger.ts → webglobeplugins/Math/tessellation/tile-merger.js}

@@ -1,578 +1,429 @@
-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;
-}
-
-
+import { calculateMergedMeshDimLength } from "./methods";
+import { NearestValuePadding } from "./nearest-value-padding";
+function keyMethod(x, y, level) {
+    return `${level}_${x}_${y}`;
+}
+function calculateParentTile(x, y, level) {
+    return {
+        x: Math.floor(x / 2),
+        y: Math.floor(y / 2),
+        level: level - 1
+    };
+}
+function createMapAndMetaData(tiles, globe) {
+    const tileMap = new Map();
+    let maxLevel = -Infinity;
+    let minLevel = Infinity;
+    // Intermediate storage to analyze distributions per zoom level
+    const zoomData = new Map();
+    // 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();
+    // 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) {
+    if (arr.length === 0)
+        return 0;
+    const map = new Map();
+    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) {
+    if (arr.length === 0)
+        return 0;
+    const sum = arr.reduce((acc, val) => acc + val, 0);
+    return Math.round(sum / arr.length);
+}
+function getCenterFromCamera(globe, zoom) {
+    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, tileDimensionLength, targetDimensionLength) {
+    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, targetDimensionLength, childrenMeshes, sourceDimensionLength, startX, startY) {
+    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, targetDimensionLength, sourceMesh, sourceDimensionLength, startX, startY) {
+    // sourceMesh[0][0] is south west corner
+    // targetMesh[0][0] is top left corner
+    let targetIndex = 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, limitRange = 12) {
+    // 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, mergeCount = 8, tileDimensionLength = 5, processLimit = 6) {
+    const mergedMeshDimLength = calculateMergedMeshDimLength(mergeCount, tileDimensionLength);
+    const nearestValuePadding = new NearestValuePadding(tileDimensionLength, mergeCount);
+    // Helper to check if a number is between range (inclusive)
+    const result = [];
+    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 = {
+            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 = [];
+                        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, mergeCount = 12, tileDimensionLength = 5, processLimit = 6, globe) {
+    // filter out tiles with NaN values
+    // return returnTop6tiles(tiles);
+    const tilesMetaData = createMapAndMetaData(tiles, globe);
+    const mergedTiles = mergeTiles(tilesMetaData, mergeCount, tileDimensionLength, processLimit);
+    return mergedTiles;
+}