@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/Math/tessellation/triangle-tessellation-meta.js

@@ -1,523 +0,0 @@
-/**
- * @author Toprak Ozturk
- */
-import { create as createArc, calculateZLimitPoint } from "../arc";
-import { createUnitVectorFromLongLat, equals, length, vec3ToLongLatRadians } from "../vec3";
-import { TILE_COUNTS } from "./zoom-catch";
-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
-const _plane = /*@__PURE__*/ { normal: [0, 0, 0], distance: 0 };
-const _resultPoints = /*@__PURE__*/ [[0, 0, 0], [0, 0, 0]];
-function createShellPoints(triangleMeta) {
-    const arcs = triangleMeta.arcs;
-    const points = [
-        arcs[0].p0LongLat,
-        arcs[1].p0LongLat,
-        arcs[2].p0LongLat
-    ];
-    for (let i = 0; i < 3; i++) {
-        if (arcs[i].exceededLimit) {
-            if (arcs[i].exceededLimit !== undefined) {
-                const longLat = vec3ToLongLatRadians(arcs[i].exceededLimit);
-                points.push(longLat);
-            }
-        }
-    }
-    const center = [
-        points.reduce((sum, p) => sum + p[0], 0) / points.length,
-        points.reduce((sum, p) => sum + p[1], 0) / points.length
-    ];
-    const shellPoints = [];
-    for (let i = 0; i < points.length; i++) {
-        const p = points[i];
-        const x = (p[0] - center[0]) / 10;
-        const y = (p[1] - center[1]) / 10;
-        shellPoints.push([p[0] + x, p[1] + y]);
-    }
-    return shellPoints;
-}
-function createBBox(p1, p2, limitVec) {
-    if (limitVec) {
-        const limitLongLat = vec3ToLongLatRadians(limitVec);
-        console.log('Limit point found at:', limitLongLat, 'for p1:', p1, 'p2:', p2);
-        return {
-            min: [Math.min(p1[0], p2[0], limitLongLat[0]), Math.min(p1[1], p2[1], limitLongLat[1])],
-            max: [Math.max(p1[0], p2[0], limitLongLat[0]), Math.max(p1[1], p2[1], limitLongLat[1])],
-        };
-    }
-    return {
-        min: [Math.min(p1[0], p2[0]), Math.min(p1[1], p2[1])],
-        max: [Math.max(p1[0], p2[0]), Math.max(p1[1], p2[1])],
-    };
-}
-export function createTriangleTessellationMeta(p1, p2, p3) {
-    const p1v3 = createUnitVectorFromLongLat(p1);
-    const p2v3 = createUnitVectorFromLongLat(p2);
-    const p3v3 = createUnitVectorFromLongLat(p3);
-    const arc1 = createArc(p1v3, p2v3);
-    const arc2 = createArc(p2v3, p3v3);
-    const arc3 = createArc(p3v3, p1v3);
-    const limitVec = [0, 0, 0];
-    if (calculateZLimitPoint(arc1, limitVec)) {
-        arc1.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
-        const longlat_ = vec3ToLongLatRadians(arc1.exceededLimit);
-        console.log('Arc 1 exceeded limit at:', longlat_.map(v => (v * 180 / Math.PI).toFixed(2)), 'rad:', arc1.exceededLimit);
-    }
-    arc1.bbox = createBBox(p1, p2, arc1.exceededLimit);
-    arc1.p0LongLat = p1;
-    arc1.p1LongLat = p2;
-    if (calculateZLimitPoint(arc2, limitVec)) {
-        arc2.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
-    }
-    arc2.bbox = createBBox(p2, p3, arc2.exceededLimit);
-    arc2.p0LongLat = p2;
-    arc2.p1LongLat = p3;
-    if (calculateZLimitPoint(arc3, limitVec)) {
-        arc3.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
-    }
-    arc3.bbox = createBBox(p3, p1, arc3.exceededLimit);
-    arc3.p0LongLat = p3;
-    arc3.p1LongLat = p1;
-    const bbox = {
-        min: [
-            Math.min(arc1.bbox.min[0], arc2.bbox.min[0], arc3.bbox.min[0]),
-            Math.min(arc1.bbox.min[1], arc2.bbox.min[1], arc3.bbox.min[1])
-        ],
-        max: [
-            Math.max(arc1.bbox.max[0], arc2.bbox.max[0], arc3.bbox.max[0]),
-            Math.max(arc1.bbox.max[1], arc2.bbox.max[1], arc3.bbox.max[1])
-        ],
-    };
-    const meta = {
-        arcs: [arc1, arc2, arc3],
-        bbox
-    };
-    showMeta(meta);
-    meta.shellPoints = createShellPoints(meta);
-    return meta;
-}
-function showMeta(triangleMeta) {
-    for (let i = 0; i < 3; i++) {
-        const arc = triangleMeta.arcs[i];
-        console.log(`Arc ${i} from ${showLongLatRadian(arc.p0LongLat)} to ${showLongLatRadian(arc.p1LongLat)}, bbox: min(${showLongLatRadian(arc.bbox.min)}) max(${showLongLatRadian(arc.bbox.max)})`);
-        if (arc.exceededLimit) {
-            console.log(`Exceeded limit at ${showLongLatRadian(vec3ToLongLatRadians(arc.exceededLimit))}`);
-        }
-    }
-    console.log(`Triangle BBOX: min(${showLongLatRadian(triangleMeta.bbox.min)}) max(${showLongLatRadian(triangleMeta.bbox.max)})`);
-}
-/**
- *
- * @param triangleMeta
- * @param zoom
- * @param angle
- * @param dimension false for longitude (meridian) true for latitude (parallel)
- */
-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;
-    if (dimension) {
-        _plane.normal[0] = 0;
-        _plane.normal[1] = 0;
-        _plane.normal[2] = 1;
-        _plane.distance = Math.sin(radians);
-    }
-    else {
-        _plane.normal[0] = Math.sin(radians);
-        _plane.normal[1] = -Math.cos(radians);
-        _plane.normal[2] = 0;
-        _plane.distance = 0;
-    }
-    let result = [];
-    // Add debugging
-    let resultsFromDistinctArcs = 0;
-    for (let i = 0; i < 3; i++) {
-        const arc = triangleMeta.arcs[i];
-        const coordIndex = dimension ? 1 : 0;
-        const minCoord = arc.bbox.min[coordIndex];
-        const maxCoord = arc.bbox.max[coordIndex];
-        if (minCoord > angle || maxCoord < angle) {
-            continue; // arc is out of range
-        }
-        const count = pointsOnArc(arc, _plane, _resultPoints);
-        if (count === 1) {
-            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]], vec3ToLongLatRadians(_resultPoints[0])]);
-            result.push([[..._resultPoints[1]], vec3ToLongLatRadians(_resultPoints[1])]); // TODO: this is a fix for a bug, need to investigate later
-        }
-        resultsFromDistinctArcs += 1;
-    }
-    if (resultsFromDistinctArcs === 3) {
-        result = filterDuplicate(result);
-    }
-    if (result.length !== 2 && result.length !== 4) {
-        // TODO: THERE is a case where 4 points are found.
-        // this happens when two arcs has limit and share space in Z dimension
-        console.log("ERROR");
-        const text = 'Angle:' + angle + ' dimension:' + (dimension ? 'latitude' : 'longitude') + "\n" +
-            'Result points count:' + result.length + "\n" +
-            "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 = 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);
-    }
-    // TODO: i want to see it delete later
-    if (result.length === 4) {
-        console.warn("Warning: 4 cut points found on triangle for angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude', "points:", result);
-    }
-    result.sort((a, b) => {
-        if (dimension) {
-            return a[0][1] - b[0][1]; // sort by y for longitude cuts
-        }
-        else {
-            return a[1][0] - b[1][0]; // sort by x for latitude cuts
-        }
-    });
-    return result;
-}
-function getEdgePoints(triangleMeta) {
-    const points = [
-        triangleMeta.arcs[0].p0,
-        triangleMeta.arcs[1].p0,
-        triangleMeta.arcs[2].p0,
-    ];
-    for (let i = 0; i < 3; i++) {
-        if (triangleMeta.arcs[i].exceededLimit) {
-            points.push(triangleMeta.arcs[i].exceededLimit);
-        }
-    }
-    return points;
-}
-// TODO: EDGES NEED ! LEVEL MORE ZOOM LEVEL OF RESOLUTION as THEY CAN BE NEIGHBOURS OF HIGHER ZOOM LEVEL TILES....
-// simple strategy: get max zoom level of neighbour, add edge cuts based on that zoom level, do not fill inner points.
-// partialTessellation cure this problem automatically
-export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT) {
-    // TODO: lonLengthRadian and latInnerStep might be change. Dynamic zoom level will show if needed
-    const points = [];
-    const longLatPoints = [];
-    // CALCULATE INFORMATION NEEDED FOR CUTTING
-    const tileCount = TILE_COUNTS[zoom];
-    const lonLengthRadian = 2 * Math.PI / tileCount / innerCuts; // inner step
-    const startMeridianRadian = triangleMeta.bbox.min[0];
-    const endMeridianRadian = triangleMeta.bbox.max[0];
-    const startParallelRadian = triangleMeta.bbox.min[1];
-    const endParallelRadian = triangleMeta.bbox.max[1];
-    // GET EDGE POINTS
-    const edgePoints = getEdgePoints(triangleMeta);
-    const shellPoints = triangleMeta.shellPoints;
-    for (let i = 0; i < edgePoints.length; i++) {
-        const longLat = vec3ToLongLatRadians(edgePoints[i]);
-        longLatPoints.push(...shellPoints[i]);
-        longLatPoints.push(...longLat);
-        points.push(0, 0, 0);
-        points.push(...edgePoints[i]);
-    }
-    // GET ALL PARRALLEL CUTS AND FILL MIDDLE POINTS
-    // how to calculate parallel tiles in range of bbox
-    const startTileY = latToTileY(startParallelRadian, zoom);
-    const endTileY = latToTileY(endParallelRadian, zoom);
-    const latInnerStep = 1 / innerCuts;
-    let currentY = startTileY - Math.abs(startTileY % latInnerStep);
-    if (currentY === startTileY)
-        currentY -= latInnerStep; // since start point is already added
-    let latCutCount = 0;
-    while (currentY > endTileY) {
-        const lat = tileYtoLat(currentY, zoom);
-        const concurances = getPoints(triangleMeta, lat, true);
-        for (let i = 0; i < concurances.length; i += 2) {
-            const p0 = concurances[i];
-            const p1 = concurances[i + 1];
-            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;
-        latCutCount++;
-    }
-    let currentLong = startMeridianRadian - startMeridianRadian % lonLengthRadian;
-    if (currentLong === startMeridianRadian)
-        currentLong += lonLengthRadian; // since start point is already added
-    while (currentLong < endMeridianRadian) {
-        const [p0, p1] = getPoints(triangleMeta, currentLong, false);
-        if (!isOnTileEdge(p0[1], zoom)) {
-            points.push(...p0[0]);
-            longLatPoints.push(...p0[1]);
-        }
-        if (!isOnTileEdge(p1[1], zoom)) {
-            points.push(...p1[0]);
-            longLatPoints.push(...p1[1]);
-        }
-        currentLong += lonLengthRadian;
-    }
-    const delaunator = new Delaunator(longLatPoints);
-    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);
-    // 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) {
-    // return;
-    // const start = Math.min(p1[0], p2[0]);
-    // const end = Math.max(p1[0], p2[0]);
-    const start = p1[0];
-    const end = p2[0];
-    // console.log("start:", start * 180 / Math.PI, "end:", end * 180 / Math.PI, "lat:", lat * 180 / Math.PI);
-    let current = start - (start % step);
-    while (current < end) {
-        const item = [current, lat];
-        fillVec3Arr.push(...createUnitVectorFromLongLat(item));
-        longLatPoints.push(...item);
-        current += step;
-    }
-}
-function filterDuplicate(points) {
-    const result = [points[0]];
-    let dublicate = false;
-    for (let i = 1; i < points.length; i++) {
-        for (let j = 0; j < result.length; j++) {
-            if (equals(points[i][0], result[j][0])) {
-                dublicate = true;
-                break;
-            }
-        }
-        if (!dublicate) {
-            result.push(points[i]);
-        }
-    }
-    return result;
-}
-function showLongLatRadian(longLat) {
-    return `(${(longLat[0] * 180 / Math.PI).toFixed(2)}°, ${(longLat[1] * 180 / Math.PI).toFixed(2)}°)`;
-}
-// 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;
-    const result = [];
-    for (let i = 0; i < length; i++) {
-        let pass = false;
-        for (let filterIndex of filterOutIndexes) {
-            if (indexes[i * 3] === filterIndex || indexes[i * 3 + 1] === filterIndex || indexes[i * 3 + 2] === filterIndex) {
-                pass = true;
-                break;
-            }
-        }
-        if (pass)
-            continue;
-        result.push(indexes[i * 3], indexes[i * 3 + 1], indexes[i * 3 + 2]);
-    }
-    return new Uint32Array(result);
-}
-/**
- * @unlockedPerk cache
- * final outpout can be saved on a hashmap since this triangles are static
- */
-function shredTriangleTessellationMeta(triangleMeta, zoomLevel) {
-    /**
-     * What if tile is covered by the curve of the limit of a single arc.
-     */
-    const result = [];
-    // cut triangleMeta into smaller triangles based on zoom level...
-    return result;
-}
-/**
- * @lockedPerk cache
- *
- * cache can be applied at tile triangle intersection level;
- *
- * @unlockedPerk smoothZoomTransition
- *
- * @puzzle triangle should be covered without duplicate points. A tile can be covered by a bigger one.
- * @solution bbox cuts:
- *  Ax    1 x  x is higher zoom level tile, A is a tile that covers it. 1 2 3 should be asked with A zoom level.
- *  AA ->      Problem1: 1 2 3 x will have edge points duplicated
- *        2 3  p1 sol1: edges can be taged, or added separately by and algorithm that only adds edge poitns.
- *
- * still all triangles should have some sort of cached tessellation to fast render on rapit earth rotation
- */
-/**
- * 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,
-    };
-}