@pirireis/webglobeplugins 0.16.7 → 0.17.1

package/Math/tessellation/tile-merger.js

@@ -0,0 +1,298 @@
+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/triangle-tessellation-meta.js

@@ -8,6 +8,7 @@ import { pointsOnArc } from "../juction/arc-plane";
 import { latToTileY, tileYtoLat } from "./methods";
 import { isOnTileEdge } from "./methods";
 import Delaunator from "delaunator";
+import { radianToMercatorXY } from "../methods";
 // TODO:get rid of embedded lists. always flat list
 const TILE_DEM_VERTEX_COUNT = 5; // 5x5 grid for DEM
 const TILE_DEM_STEPCOUNT = TILE_DEM_VERTEX_COUNT - 1; // 4 inner divisions in each dimension
@@ -118,7 +119,7 @@ function showMeta(triangleMeta) {
  * @param angle
  * @param dimension false for longitude (meridian) true for latitude (parallel)
  */
-function getPoints(triangleMeta, angle, dimension) {
+export function getPoints(triangleMeta, angle, dimension) {
     // console.log("getPoints called with angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude');
     // find which arcs are cut by plane
     const radians = angle;
@@ -147,12 +148,12 @@ function getPoints(triangleMeta, angle, dimension) {
         }
         const count = pointsOnArc(arc, _plane, _resultPoints);
         if (count === 1) {
-            result.push([..._resultPoints[0]]);
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
         }
         else if (count === 2) {
             // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
-            result.push([..._resultPoints[0]]);
-            result.push([..._resultPoints[1]]); // TODO: this is a fix for a bug, need to investigate later
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
+            result.push([[..._resultPoints[1]], vec3ToLongLatRadians(_resultPoints[1])]); // TODO: this is a fix for a bug, need to investigate later
         }
         resultsFromDistinctArcs += 1;
     }
@@ -168,7 +169,7 @@ function getPoints(triangleMeta, angle, dimension) {
             "bbox:" + triangleMeta.bbox.min[0] * 180 / Math.PI + ", " + triangleMeta.bbox.min[1] * 180 / Math.PI + ", " + triangleMeta.bbox.max[0] * 180 / Math.PI + ", " + triangleMeta.bbox.max[1] * 180 / Math.PI + "\n";
         showMeta(triangleMeta);
         for (let res of result) {
-            const ll = vec3ToLongLatRadians(res);
+            const ll = res[1];
             console.log("Point: " + ll[0] * 180 / Math.PI + ", " + ll[1] * 180 / Math.PI + "\n");
         }
         throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n` + text);
@@ -179,10 +180,10 @@ function getPoints(triangleMeta, angle, dimension) {
     }
     result.sort((a, b) => {
         if (dimension) {
-            return a[1] - b[1]; // sort by y for longitude cuts
+            return a[0][1] - b[0][1]; // sort by y for longitude cuts
         }
         else {
-            return a[0] - b[0]; // sort by x for latitude cuts
+            return a[1][0] - b[1][0]; // sort by x for latitude cuts
         }
     });
     return result;
@@ -239,15 +240,13 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
         for (let i = 0; i < concurances.length; i += 2) {
             const p0 = concurances[i];
             const p1 = concurances[i + 1];
-            points.push(...p0);
-            points.push(...p1);
-            const p0LongLat = vec3ToLongLatRadians(p0);
-            const p1LongLat = vec3ToLongLatRadians(p1);
-            longLatPoints.push(...p0LongLat);
-            longLatPoints.push(...p1LongLat);
-            fillBetweenInParallels(lat, p0LongLat, p1LongLat, lonLengthRadian, points, longLatPoints);
-            if (length(p0) < 0.99 || length(p1) < 0.99 || length(p0) > 1.01 || length(p1) > 1.01) {
-                console.warn("Warning: Cut point is not on unit sphere!", length(p0), length(p1));
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
+            fillBetweenInParallels(lat, p0[1], p1[1], lonLengthRadian, points, longLatPoints);
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
+            if (length(p0[0]) < 0.99 || length(p1[0]) < 0.99 || length(p0[0]) > 1.01 || length(p1[0]) > 1.01) {
+                console.warn("Warning: Cut point is not on unit sphere!", length(p0[0]), length(p1[0]));
             }
         }
         currentY -= latInnerStep;
@@ -258,15 +257,13 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
         currentLong += lonLengthRadian; // since start point is already added
     while (currentLong < endMeridianRadian) {
         const [p0, p1] = getPoints(triangleMeta, currentLong, false);
-        const p0LongLat = vec3ToLongLatRadians(p0);
-        const p1LongLat = vec3ToLongLatRadians(p1);
-        if (!isOnTileEdge(p0LongLat, zoom)) {
-            points.push(...p0);
-            longLatPoints.push(...p0LongLat);
+        if (!isOnTileEdge(p0[1], zoom)) {
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
         }
-        if (!isOnTileEdge(p1LongLat, zoom)) {
-            points.push(...p1);
-            longLatPoints.push(...p1LongLat);
+        if (!isOnTileEdge(p1[1], zoom)) {
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
         }
         currentLong += lonLengthRadian;
     }
@@ -274,7 +271,12 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
     let indices = delaunator.triangles;
     const edgeIndexes = shellPoints.map((e, index) => index * 2); // edge points are always first points in list
     indices = filteroutEdgeConnections(indices, edgeIndexes);
-    rotateIndices(indices);
+    // rotateIndices(indices);
+    // for (let i = 0; i < longLatPoints.length / 2; i++) {
+    //     const xy = radianToMercatorXY([longLatPoints[i * 2], longLatPoints[i * 2 + 1]]);
+    //     longLatPoints[i * 2] = xy[0];
+    //     longLatPoints[i * 2 + 1] = xy[1];
+    // }
     return { vec3s: new Float32Array(points), longLats: new Float32Array(longLatPoints), indices: indices };
 }
 function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
@@ -292,18 +294,18 @@ function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
         current += step;
     }
 }
-function filterDuplicate(vec3s) {
-    const result = [];
+function filterDuplicate(points) {
+    const result = [points[0]];
     let dublicate = false;
-    for (let i = 0; i < vec3s.length; i++) {
+    for (let i = 1; i < points.length; i++) {
         for (let j = 0; j < result.length; j++) {
-            if (equals(vec3s[i], result[j])) {
+            if (equals(points[i][0], result[j][0])) {
                 dublicate = true;
                 break;
             }
         }
         if (!dublicate) {
-            result.push(vec3s[i]);
+            result.push(points[i]);
         }
     }
     return result;
@@ -311,16 +313,6 @@ function filterDuplicate(vec3s) {
 function showLongLatRadian(longLat) {
     return `(${(longLat[0] * 180 / Math.PI).toFixed(2)}°, ${(longLat[1] * 180 / Math.PI).toFixed(2)}°)`;
 }
-function rotateIndices(indices) {
-    const len = indices.length / 3;
-    let hold;
-    for (let i = 0; i < len; i++) {
-        hold = indices[i * 3];
-        indices[i * 3] = indices[i * 3 + 1];
-        indices[i * 3 + 1] = hold;
-    }
-    return indices;
-}
 // This method for removing external edge connections. The connections are unnecessary and cause a veil descending to the center of sphere from the edges
 function filteroutEdgeConnections(indexes, filterOutIndexes) {
     const length = indexes.length / 3;
@@ -366,5 +358,166 @@ function shredTriangleTessellationMeta(triangleMeta, zoomLevel) {
  *
  * still all triangles should have some sort of cached tessellation to fast render on rapit earth rotation
  */
-// function partialTessellation(triangleMeta: TriangleTessellationMeta, limits: BBox[], zoomLevel: number, innerCuts: number): { vec3s: Float32Array, longLats: Float32Array, indices: Uint32Array } {
-// }
+/**
+ * Creates a mesh for a spherical triangle, tessellated only within the
+ * regions specified by the `limits` array.
+ *
+ * @param triangleMeta The metadata for the spherical triangle.
+ * @param limits An array of bounding boxes and their associated zoom levels to tessellate.
+ * @param innerCuts The number of subdivisions within each tile (e.g., TILE_DEM_STEPCOUNT).
+ * @returns A set of arrays (vec3s, longLats, indices) representing the partial mesh.
+ */
+export function partialTessellation(triangleMeta, limits, innerCuts) {
+    // TODO: pointMap can be local variable and cleaned after function call to avoid reinitialization overhead
+    const pointMap = new Map(); // Key: "lon|lat", Value: index
+    const allVec3s = [];
+    const allLongLats = [];
+    let pointCounter = 0;
+    const stepCount = innerCuts - 1; // 
+    /**
+     * Precision for coordinate keys in the map. 1e-12 radians is
+     * extremely small (sub-millimeter on Earth's surface) and avoids
+     * floating point inaccuracies causing duplicate points.
+     */
+    const KEY_PRECISION = 10;
+    /**
+     * Adds a point to the vertex arrays if it doesn't already exist.
+     * Returns the index of the point (new or existing).
+     */
+    const addPoint = (longLat, vec3) => {
+        const key = `${longLat[0].toPrecision(KEY_PRECISION)}|${longLat[1].toPrecision(KEY_PRECISION)}`;
+        let index = pointMap.get(key);
+        if (index !== undefined) {
+            return index; // Point already exists
+        }
+        // Point is new, add it
+        const v3 = vec3 || createUnitVectorFromLongLat(longLat);
+        allVec3s.push(...v3);
+        allLongLats.push(...longLat);
+        index = pointCounter++;
+        pointMap.set(key, index);
+        return index;
+    };
+    // 1. Add triangle's "shell" (for Delaunay) and "edge" (vertices/limits) points
+    // These points constrain the triangulation.
+    const shellPointIndices = [];
+    const edgePoints = getEdgePoints(triangleMeta);
+    // Assuming shellPoints and edgePoints have the same length and correspond
+    const shellPointCount = Math.min(triangleMeta.shellPoints.length, edgePoints.length);
+    for (let i = 0; i < shellPointCount; i++) {
+        // Add the "shell" point (for Delaunay stability)
+        shellPointIndices.push(addPoint(triangleMeta.shellPoints[i]));
+        // Add the actual "edge" point (triangle vertex or limit point)
+        addPoint(vec3ToLongLatRadians(edgePoints[i]), edgePoints[i]);
+    }
+    // 2. Iterate through each tile limit
+    for (const { bbox: tileBBox, zoom } of limits) {
+        // 2a. Calculate the intersection BBOX (the area we'll work on)
+        const workBBox = {
+            min: [
+                Math.max(triangleMeta.bbox.min[0], tileBBox.min[0]),
+                Math.max(triangleMeta.bbox.min[1], tileBBox.min[1])
+            ],
+            max: [
+                Math.min(triangleMeta.bbox.max[0], tileBBox.max[0]),
+                Math.min(triangleMeta.bbox.max[1], tileBBox.max[1])
+            ],
+        };
+        // If the intersection is invalid (no overlap), skip this tile
+        if (workBBox.min[0] >= workBBox.max[0] || workBBox.min[1] >= workBBox.max[1]) {
+            continue;
+        }
+        // 2b. Calculate grid steps for this tile's zoom
+        const tileCount = TILE_COUNTS[zoom];
+        const lonStep = (2 * Math.PI) / tileCount / stepCount;
+        const latStep = 1.0 / stepCount; // This is in tileY units
+        // 2c. Generate Latitude (Parallel) Points
+        const startTileY = latToTileY(workBBox.max[1], zoom); // max lat -> min tileY
+        const endTileY = latToTileY(workBBox.min[1], zoom); // min lat -> max tileY
+        // let currentY = Math.ceil(startTileY / latStep) * latStep;
+        let currentY = startTileY - Math.abs(startTileY % latStep);
+        // if (currentY < startTileY - 1e-9) currentY += latStep; // Ensure we start inside or on edge
+        if (currentY === startTileY)
+            currentY -= latStep; // since start point is already added
+        while (currentY <= endTileY + 1e-9) {
+            const lat = tileYtoLat(currentY, zoom);
+            // Skip if rounding put us slightly outside the work box
+            if (lat < workBBox.min[1] - 1e-9 || lat > workBBox.max[1] + 1e-9) {
+                currentY += latStep;
+                continue;
+            }
+            // Find where this latitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, lat, true);
+            for (let i = 0; i < intersections.length; i += 2) {
+                const p0 = intersections[i]; // [Vec3, LongLatRadian]
+                const p1 = intersections[i + 1];
+                // Find the segment of this latitude line that is *inside* both
+                // the triangle (p0-p1) AND the tile BBOX (workBBox)
+                const triMinLon = Math.min(p0[1][0], p1[1][0]);
+                const triMaxLon = Math.max(p0[1][0], p1[1][0]);
+                const segMinLon = Math.max(workBBox.min[0], triMinLon);
+                const segMaxLon = Math.min(workBBox.max[0], triMaxLon);
+                // If this clipped segment is valid, generate points
+                if (segMinLon < segMaxLon - 1e-9) {
+                    // Add the exact start and end points of the clipped segment
+                    addPoint([segMinLon, lat]);
+                    addPoint([segMaxLon, lat]);
+                    // Add fill points *between* them
+                    let currentLon = Math.ceil(segMinLon / lonStep) * lonStep;
+                    if (currentLon < segMinLon - 1e-9)
+                        currentLon += lonStep;
+                    while (currentLon < segMaxLon - 1e-9) {
+                        addPoint([currentLon, lat]);
+                        currentLon += lonStep;
+                    }
+                }
+            }
+            currentY += latStep;
+        }
+        // 2d. Generate Longitude (Meridian) Points
+        const startLon = workBBox.min[0];
+        const endLon = workBBox.max[0];
+        let currentLon = Math.ceil(startLon / lonStep) * lonStep;
+        if (currentLon < startLon - 1e-9)
+            currentLon += lonStep;
+        while (currentLon <= endLon + 1e-9) {
+            // Find where this longitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, currentLon, false);
+            for (const p of intersections) {
+                const pLongLat = p[1];
+                // Check if this point is inside the *workBBox*
+                if (pLongLat[1] >= workBBox.min[1] - 1e-9 &&
+                    pLongLat[1] <= workBBox.max[1] + 1e-9) {
+                    addPoint(pLongLat, p[0]);
+                }
+            }
+            currentLon += lonStep;
+        }
+    } // End loop over limits
+    // 3. Triangulate
+    // We must have at least 3 points to make a triangle
+    if (pointCounter < 3) {
+        return {
+            vec3s: new Float32Array(),
+            longLats: new Float32Array(),
+            indices: new Uint32Array(),
+        };
+    }
+    const delaunator = new Delaunator(allLongLats);
+    let indices = delaunator.triangles;
+    // 4. Filter out triangles connected to the "shell" points
+    indices = filteroutEdgeConnections(indices, shellPointIndices);
+    // console.log(...allLongLats.slice(0, 10));
+    for (let i = 0; i < allLongLats.length / 2; i++) {
+        const xy = radianToMercatorXY([allLongLats[i * 2], allLongLats[i * 2 + 1]]);
+        allLongLats[i * 2] = xy[0];
+        allLongLats[i * 2 + 1] = xy[1];
+    }
+    // show first 5
+    // console.log(...allLongLats.slice(0, 10));
+    return {
+        vec3s: new Float32Array(allVec3s),
+        longLats: new Float32Array(allLongLats),
+        indices: indices,
+    };
+}

package/Math/tessellation/triangle-tessellation.js

@@ -2,9 +2,13 @@
  * @author Toprak Ozturk
  *
  */
-import { createTriangleTessellationMeta, getAllPoints } from "./triangle-tessellation-meta";
+import { createTriangleTessellationMeta, getAllPoints, partialTessellation } from "./triangle-tessellation-meta";
 export function test1(zoomLevel, p1, p2, p3) {
     const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
     const { vec3s, longLats, indices } = getAllPoints(triangleMeta, zoomLevel);
     return { vec3s, longLats, indices };
 }
+export function partialTest(bboxZooms, p1, p2, p3) {
+    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+    return partialTessellation(triangleMeta, bboxZooms, 5);
+}