@pirireis/webglobeplugins 1.0.2 → 1.0.4

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

@@ -1,533 +1,464 @@
-/**
- * @author Toprak Ozturk
- */
-/**
- * @description Finds inner and edge cut points of givin triangle for given zoom level
- * 
- * @param {number} zoomLevel - The current zoom level
- * @param {LongLat} p1 - First point of triangle
- * @param {LongLat} p2 - Second point of triangle
- * @param {LongLat} p3 - Third point of triangle
- * 
- * 
- * @returns {positions: LongLat[], indices: number[]} - positions are the inner and edge cut points of triangle, indices are the index array for triangle faces
- */
-
-
-import { Arc, Plane, Vec3 } from "../types";
-import { Radian, LongLatRadian } from "../../types";
-import { create as createArc, calculateZLimitPoint } from "../arc";
-import { createUnitVectorFromLongLat, equals, vec3ToLongLatRadians, clone } from "../vec3";
-import { TILE_COUNTS } from "./constants";
-import { pointsOnArc } from "../juction/arc-plane";
-import { latToTileY, tileYtoLat } from "./methods";
-import Delaunator from "delaunator";
-import { radianToMercatorXY } from "../methods";
-
-const KEY_PRECISION = 9;
-
-export type BBoxZoom = {
-    bbox: { min: LongLatRadian, max: LongLatRadian },
-    zoom: number
-}
-
-
-export type ArcExtended = Arc & {
-    exceededLimit?: Vec3,
-    bbox: {
-        min: LongLatRadian, max: LongLatRadian
-    },
-    p0LongLat: LongLatRadian,
-    p1LongLat: LongLatRadian
-};
-
-export type TriangleTessellationMeta = {
-    arcs: [ArcExtended, ArcExtended, ArcExtended],
-    bbox: { min: LongLatRadian, max: LongLatRadian },
-    showThreshold: number,
-    shortCut: {
-        vec3s: Float32Array;
-        longLats: Float32Array;
-        indices: Uint32Array;
-    }
-}
-
-// 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] as Vec3, distance: 0 } as Plane;
-const _resultPoints =  /*@__PURE__*/[[0, 0, 0], [0, 0, 0]] as [Vec3, Vec3];
-
-
-
-function createBBox(
-    p1: LongLatRadian,
-    p2: LongLatRadian,
-    limitVec: Vec3 | undefined): { min: LongLatRadian, max: LongLatRadian } {
-    if (limitVec) {
-        const limitLongLat: LongLatRadian = vec3ToLongLatRadians(limitVec);
-
-        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])],
-    };
-}
-
-
-function radianCheck(point: LongLatRadian): boolean {
-    return point[0] >= -Math.PI && point[0] <= Math.PI && point[1] >= -Math.PI
-        && point[1] <= Math.PI / 2 && point[1] >= -Math.PI / 2;
-}
-
-export function createTriangleTessellationMeta(p1: LongLatRadian, p2: LongLatRadian, p3: LongLatRadian): TriangleTessellationMeta {
-
-    if (!radianCheck(p1) || !radianCheck(p2) || !radianCheck(p3)) {
-        throw new Error('Points must be in radian range: ' +
-            'p1:' + p1[0] + ',' + p1[1] +
-            ' p2:' + p2[0] + ',' + p2[1] +
-            ' p3:' + p3[0] + ',' + p3[1]);
-    }
-    const p1v3: Vec3 = createUnitVectorFromLongLat(p1);
-    const p2v3: Vec3 = createUnitVectorFromLongLat(p2);
-    const p3v3: Vec3 = createUnitVectorFromLongLat(p3);
-    const arc1 = createArc(p1v3, p2v3) as ArcExtended;
-    const arc2 = createArc(p2v3, p3v3) as ArcExtended;
-    const arc3 = createArc(p3v3, p1v3) as ArcExtended;
-
-    const limitVec = [0, 0, 0] as Vec3;
-
-    if (calculateZLimitPoint(arc1, limitVec)) {
-        arc1.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
-    }
-
-    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])
-        ] as LongLatRadian,
-        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])
-        ] as LongLatRadian,
-    };
-
-
-    const meta = {
-        arcs: [arc1, arc2, arc3],
-        bbox,
-        showThreshold: calculateShowThreshold(arc1, arc2, arc3)
-    } as TriangleTessellationMeta;
-
-    meta.shortCut = partialTessellation(
-        meta,
-        [{
-            bbox: meta.bbox,
-            zoom: 0
-        }],
-        TILE_DEM_STEPCOUNT
-    );
-
-    return meta;
-}
-
-
-function calculateShowThreshold(arc1: Arc, arc2: Arc, arc3: Arc): number {
-
-    const largestCoverAngle = Math.max(arc1.coverAngle, arc2.coverAngle, arc3.coverAngle);
-    return Math.PI / largestCoverAngle;
-}
-
-export function zoomLevelShowThreshold(zoomLevel: number, tileRatio: number): number {
-    const tileCount = TILE_COUNTS[zoomLevel];
-
-    return tileCount / tileRatio / 2;
-}
-
-
-type EdgePoint = { vec: Vec3, longLat: LongLatRadian, arcIndex: number }
-/**
- * 
- * @param triangleMeta 
- * @param zoom 
- * @param angle 
- * @param dimension false for longitude (meridian) true for latitude (parallel)
- */
-function getPoints(triangleMeta: TriangleTessellationMeta, angle: Radian, dimension: boolean): [EdgePoint, EdgePoint] | [EdgePoint, EdgePoint, EdgePoint, EdgePoint] | [] {
-    // 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: EdgePoint[] = [];
-    // 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({ vec: clone(_resultPoints[0]), longLat: vec3ToLongLatRadians(_resultPoints[0]), arcIndex: i }
-            );
-        }
-        else if (count === 2) {
-            // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
-            result.push({ vec: [..._resultPoints[0]], longLat: vec3ToLongLatRadians(_resultPoints[0]), arcIndex: i });
-            result.push({ vec: clone(_resultPoints[1]), longLat: vec3ToLongLatRadians(_resultPoints[1]), arcIndex: i }); // 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) {
-        // throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n`);
-        console.error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n`);
-        return [];
-    }
-
-    if (dimension) {
-        result.sort((a, b) => {
-            return a.longLat[0] - b.longLat[0]; // sort by x for latitude cuts
-        });
-    }
-
-    return result as [EdgePoint, EdgePoint] | [EdgePoint, EdgePoint, EdgePoint, EdgePoint];
-}
-
-
-function getEdgePoints(triangleMeta: TriangleTessellationMeta, edgePointIndexSets: [Set<number>, Set<number>, Set<number>]): Vec3[] {
-    const points = [
-        triangleMeta.arcs[0].p0,
-        triangleMeta.arcs[1].p0,
-        triangleMeta.arcs[2].p0,
-    ]
-    edgePointIndexSets[0].add(0);
-    edgePointIndexSets[0].add(1);
-    edgePointIndexSets[1].add(1);
-    edgePointIndexSets[1].add(2);
-    edgePointIndexSets[2].add(2);
-    edgePointIndexSets[2].add(0);
-    let exceededLimitPointIndex = 3;
-    for (let i = 0; i < 3; i++) {
-        if (triangleMeta.arcs[i].exceededLimit) {
-            points.push(triangleMeta.arcs[i].exceededLimit as Vec3);
-            edgePointIndexSets[i].add(exceededLimitPointIndex);
-            exceededLimitPointIndex++;
-        }
-    }
-    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
-
-
-
-function filterDuplicate(points: EdgePoint[]): EdgePoint[] {
-
-    if (points.length < 2) {
-        return points;
-    }
-    const result: EdgePoint[] = [points[0]];
-    for (let i = 1; i < points.length; i++) {
-        let isDuplicate = false;
-        for (let j = 0; j < result.length; j++) {
-            if (equals(points[i].vec, result[j].vec)) {
-                isDuplicate = true;
-                break;
-            }
-        }
-        if (!isDuplicate) {
-            result.push(points[i]);
-        }
-    }
-
-    return result;
-}
-
-
-
-
-function filterEdgePointTriangles(
-    indeces: Uint32Array,
-    edgePointIndices: [Set<number>, Set<number>, Set<number>]): Uint32Array {
-
-
-    const result = []
-    for (let i = 0; i < indeces.length; i += 3) {
-
-        const i0 = indeces[i];
-        const i1 = indeces[i + 1];
-        const i2 = indeces[i + 2];
-        if ((edgePointIndices[0].has(i0) && edgePointIndices[0].has(i1) && edgePointIndices[0].has(i2)) ||
-            (edgePointIndices[1].has(i0) && edgePointIndices[1].has(i1) && edgePointIndices[1].has(i2)) ||
-            (edgePointIndices[2].has(i0) && edgePointIndices[2].has(i1) && edgePointIndices[2].has(i2))) {
-            continue;
-        }
-        result.push(i0, i1, i2);
-    }
-    return new Uint32Array(result);
-
-}
-
-
-
-
-
-export function partialTessellation(
-    triangleMeta: TriangleTessellationMeta,
-    limits: BBoxZoom[],
-    innerCuts: number
-): { vec3s: Float32Array; longLats: Float32Array; indices: Uint32Array } {
-    // TODO: pointMap can be local variable and cleaned after function call to avoid reinitialization overhead
-    const pointMap = new Map<string, number>(); // Key: "lon|lat", Value: index
-    const allVec3s: number[] = [];
-    const allLongLats: number[] = [];
-    let pointCounter = 0;
-    const stepCount = innerCuts - 1; // 
-    const edgePointIndexSets: [Set<number>, Set<number>, Set<number>] = [new Set<number>(), new Set<number>(), new Set<number>()];
-    // addTriangleVerticesToEdgeSets(edgePointIndexSets);
-
-    /**
-     * 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.
-     */
-
-    /**
-     * 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: LongLatRadian, vec3?: Vec3, edgeIndex?: number): number => {
-        const key = `${Math.round(longLat[0] * 1e9)}|${Math.round(longLat[1] * 1e9)}`;
-
-        let index = pointMap.get(key);
-        if (index !== undefined) {
-            if (edgeIndex !== undefined) {
-                edgePointIndexSets[edgeIndex].add(index);
-            }
-            return index; // Point already exists
-        }
-
-        // Point is new, add it
-        const v3 = vec3 || createUnitVectorFromLongLat(longLat);
-        allVec3s.push(v3[0], v3[1], v3[2]);
-        allLongLats.push(longLat[0], longLat[1]);
-
-
-        index = pointCounter++;
-
-        pointMap.set(key, index);
-        if (edgeIndex !== undefined) {
-            edgePointIndexSets[edgeIndex].add(index);
-        }
-        return index;
-    };
-
-    // 1. Add triangle's "shell" (for Delaunay) and "edge" (vertices/limits) points
-    // These points constrain the triangulation.
-    const edgePoints = getEdgePoints(triangleMeta, edgePointIndexSets);
-    // Assuming shellPoints and edgePoints have the same length and correspond
-
-    for (let i = 0; i < edgePoints.length; i++) {
-        addPoint(vec3ToLongLatRadians(edgePoints[i]), edgePoints[i], undefined);
-
-    }
-    // 2. Iterate through each tile limit
-    for (let i = 0; i < limits.length; i++) {
-        const tileBBox = limits[i].bbox;
-        const zoom = limits[i].zoom;
-
-        // 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])
-            ] as LongLatRadian,
-            max: [
-                Math.min(triangleMeta.bbox.max[0], tileBBox.max[0]),
-                Math.min(triangleMeta.bbox.max[1], tileBBox.max[1])
-            ] as LongLatRadian,
-        };
-
-        // 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);
-            if (intersections.length === 0) {
-                currentY += latStep;
-                continue;
-            }
-
-            for (let i = 0; i < intersections.length; i += 2) {
-                const p0 = intersections[i]; // {vec, longLat, arcIndex}
-                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.longLat[0], p1.longLat[0]);
-                const triMaxLon = Math.max(p0.longLat[0], p1.longLat[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(p0.longLat, p0.vec, p0.arcIndex);
-                    addPoint(p1.longLat, p1.vec, p1.arcIndex);
-
-                    // 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], undefined, undefined);
-                        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);
-            if (intersections.length === 0) {
-                currentLon += lonStep;
-                continue;
-            }
-
-            for (const p of intersections) {
-                const pLongLat = p.longLat;
-                // 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.vec, p.arcIndex);
-                }
-            }
-            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;
-
-    indices = filterEdgePointTriangles(indices, edgePointIndexSets);
-
-
-
-    // Convert to Mercator
-    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];
-    }
-
-    return {
-        vec3s: new Float32Array(allVec3s),
-        longLats: new Float32Array(allLongLats),
-        indices: indices,
-    };
-}
+/**
+ * @author Toprak Ozturk
+ */
+/**
+ * @description Finds inner and edge cut points of givin triangle for given zoom level
+ *
+ * @param {number} zoomLevel - The current zoom level
+ * @param {LongLat} p1 - First point of triangle
+ * @param {LongLat} p2 - Second point of triangle
+ * @param {LongLat} p3 - Third point of triangle
+ *
+ *
+ * @returns {positions: LongLat[], indices: number[]} - positions are the inner and edge cut points of triangle, indices are the index array for triangle faces
+ */
+import { create as createArc, calculateZLimitPoint } from "../arc";
+import { createUnitVectorFromLongLat, equals, vec3ToLongLatRadians, clone } from "../vec3";
+import { TILE_COUNTS } from "./constants";
+import { pointsOnArc } from "../juction/arc-plane";
+import { latToTileY, tileYtoLat } from "./methods";
+import Delaunator from "delaunator";
+import { radianToMercatorXY } from "../methods";
+export const uint32Escape = 4294967295;
+// 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 createBBox(p1, p2, limitVec) {
+    if (limitVec) {
+        const limitLongLat = vec3ToLongLatRadians(limitVec);
+        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])],
+    };
+}
+function radianCheck(point) {
+    return point[0] >= -Math.PI && point[0] <= Math.PI && point[1] >= -Math.PI
+        && point[1] <= Math.PI / 2 && point[1] >= -Math.PI / 2;
+}
+const _3RealEdges = new Uint32Array([uint32Escape, 0, 1, 2, 0]);
+const _2RealEdges_dismiss2 = new Uint32Array([uint32Escape, 0, 1, 2]);
+const _2RealEdges_dismiss1 = new Uint32Array([uint32Escape, 2, 0, 1]);
+const _2RealEdges_dismiss0 = new Uint32Array([uint32Escape, 1, 2, 0]);
+const _1realEdge_0 = new Uint32Array([uint32Escape, 0, 1]);
+const _1realEdge_1 = new Uint32Array([uint32Escape, 1, 2]);
+const _1realEdge_2 = new Uint32Array([uint32Escape, 2, 0]);
+const _noRealEdges = null;
+export function createTriangleTessellationMeta(p1, p2, p3, isRealp0p1 = false, isRealp1p2 = false, isRealp2p3 = false) {
+    // TODO: this might be a problem
+    if (!radianCheck(p1) || !radianCheck(p2) || !radianCheck(p3)) {
+        throw new Error('Points must be in radian range: ' +
+            'p1:' + p1[0] + ',' + p1[1] +
+            ' p2:' + p2[0] + ',' + p2[1] +
+            ' p3:' + p3[0] + ',' + p3[1]);
+    }
+    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);
+    arc1.realEdge = isRealp0p1;
+    arc2.realEdge = isRealp1p2;
+    arc3.realEdge = isRealp2p3;
+    const realEdgeArcIndices = (() => {
+        switch (true) {
+            case isRealp0p1 && isRealp1p2 && isRealp2p3:
+                return _3RealEdges;
+            case isRealp0p1 && isRealp1p2 && !isRealp2p3:
+                return _2RealEdges_dismiss2;
+            case isRealp1p2 && isRealp2p3 && !isRealp0p1:
+                return _2RealEdges_dismiss1;
+            case isRealp2p3 && isRealp0p1 && !isRealp1p2:
+                return _2RealEdges_dismiss0;
+            case isRealp0p1 && !isRealp1p2 && !isRealp2p3:
+                return _1realEdge_0;
+            case isRealp1p2 && !isRealp2p3 && !isRealp0p1:
+                return _1realEdge_1;
+            case isRealp2p3 && !isRealp0p1 && !isRealp1p2:
+                return _1realEdge_2;
+            default:
+                return _noRealEdges;
+        }
+    })();
+    const limitVec = [0, 0, 0];
+    if (calculateZLimitPoint(arc1, limitVec)) {
+        arc1.exceededLimit = [limitVec[0], limitVec[1], limitVec[2]];
+    }
+    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,
+        showThreshold: calculateShowThreshold(arc1, arc2, arc3),
+    };
+    // @ts-ignore
+    meta.shortCut = partialTessellation(meta, [{
+            bbox: meta.bbox,
+            zoom: 0
+        }], TILE_DEM_STEPCOUNT);
+    meta.shortCut.realEdgeArcIndices = realEdgeArcIndices;
+    // arcShortCut
+    return meta;
+}
+function calculateShowThreshold(arc1, arc2, arc3) {
+    const largestCoverAngle = Math.max(arc1.coverAngle, arc2.coverAngle, arc3.coverAngle);
+    return Math.PI / largestCoverAngle;
+}
+export function zoomLevelShowThreshold(zoomLevel, tileRatio) {
+    const tileCount = TILE_COUNTS[zoomLevel];
+    return tileCount / tileRatio / 2;
+}
+/**
+ *
+ * @param triangleMeta
+ * @param zoom
+ * @param angle
+ * @param dimension false for longitude (meridian) true for latitude (parallel)
+ */
+function getPoints(triangleMeta, angle, dimension) {
+    // 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({ vec: clone(_resultPoints[0]), longLat: vec3ToLongLatRadians(_resultPoints[0]), arcIndex: i });
+        }
+        else if (count === 2) {
+            // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
+            result.push({ vec: [..._resultPoints[0]], longLat: vec3ToLongLatRadians(_resultPoints[0]), arcIndex: i });
+            result.push({ vec: clone(_resultPoints[1]), longLat: vec3ToLongLatRadians(_resultPoints[1]), arcIndex: i }); // 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) {
+        // throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n`);
+        console.error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n`);
+        return [];
+    }
+    if (dimension) {
+        result.sort((a, b) => {
+            return a.longLat[0] - b.longLat[0]; // sort by x for latitude cuts
+        });
+    }
+    return result;
+}
+function getEdgePoints(triangleMeta, edgePointIndexSets) {
+    const points = [
+        triangleMeta.arcs[0].p0,
+        triangleMeta.arcs[1].p0,
+        triangleMeta.arcs[2].p0,
+    ];
+    edgePointIndexSets[0].add(0);
+    edgePointIndexSets[0].add(1);
+    edgePointIndexSets[1].add(1);
+    edgePointIndexSets[1].add(2);
+    edgePointIndexSets[2].add(2);
+    edgePointIndexSets[2].add(0);
+    let exceededLimitPointIndex = 3;
+    for (let i = 0; i < 3; i++) {
+        if (triangleMeta.arcs[i].exceededLimit) {
+            points.push(triangleMeta.arcs[i].exceededLimit);
+            edgePointIndexSets[i].add(exceededLimitPointIndex);
+            exceededLimitPointIndex++;
+        }
+    }
+    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
+function filterDuplicate(points) {
+    if (points.length < 2) {
+        return points;
+    }
+    const result = [points[0]];
+    for (let i = 1; i < points.length; i++) {
+        let isDuplicate = false;
+        for (let j = 0; j < result.length; j++) {
+            if (equals(points[i].vec, result[j].vec)) {
+                isDuplicate = true;
+                break;
+            }
+        }
+        if (!isDuplicate) {
+            result.push(points[i]);
+        }
+    }
+    return result;
+}
+function filterEdgePointTriangles(indeces, edgePointIndices) {
+    const result = [];
+    for (let i = 0; i < indeces.length; i += 3) {
+        const i0 = indeces[i];
+        const i1 = indeces[i + 1];
+        const i2 = indeces[i + 2];
+        if ((edgePointIndices[0].has(i0) && edgePointIndices[0].has(i1) && edgePointIndices[0].has(i2)) ||
+            (edgePointIndices[1].has(i0) && edgePointIndices[1].has(i1) && edgePointIndices[1].has(i2)) ||
+            (edgePointIndices[2].has(i0) && edgePointIndices[2].has(i1) && edgePointIndices[2].has(i2))) {
+            continue;
+        }
+        result.push(i0, i1, i2);
+    }
+    return new Uint32Array(result);
+}
+// function createArcPointHarvestingMeta(): ArcPointHarvestingMeta {
+//     return {
+//         parallelCutIndices: [],
+//         meridianCutIndices: [],
+//     };  
+// }
+export function partialTessellation(triangleMeta, limits, innerCuts, calculateRealEdgeArc = false) {
+    // 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; // 
+    const edgePointIndexSets = [new Set(), new Set(), new Set()];
+    // addTriangleVerticesToEdgeSets(edgePointIndexSets);
+    /**
+     * 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.
+     */
+    /**
+     * 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, edgeIndex) => {
+        const key = `${Math.round(longLat[0] * 1e9)}|${Math.round(longLat[1] * 1e9)}`;
+        let index = pointMap.get(key);
+        if (index !== undefined) {
+            if (edgeIndex !== undefined) {
+                edgePointIndexSets[edgeIndex].add(index);
+            }
+            return index; // Point already exists
+        }
+        // Point is new, add it
+        const v3 = vec3 || createUnitVectorFromLongLat(longLat);
+        allVec3s.push(v3[0], v3[1], v3[2]);
+        allLongLats.push(longLat[0], longLat[1]);
+        index = pointCounter++;
+        pointMap.set(key, index);
+        if (edgeIndex !== undefined) {
+            edgePointIndexSets[edgeIndex].add(index);
+        }
+        return index;
+    };
+    // 1. Add triangle's "shell" (for Delaunay) and "edge" (vertices/limits) points
+    // These points constrain the triangulation.
+    const edgePoints = getEdgePoints(triangleMeta, edgePointIndexSets);
+    // Assuming shellPoints and edgePoints have the same length and correspond
+    for (let i = 0; i < edgePoints.length; i++) {
+        addPoint(vec3ToLongLatRadians(edgePoints[i]), edgePoints[i], undefined);
+    }
+    // 2. Iterate through each tile limit
+    for (let i = 0; i < limits.length; i++) {
+        const tileBBox = limits[i].bbox;
+        const zoom = limits[i].zoom;
+        // 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);
+            if (intersections.length === 0) {
+                currentY += latStep;
+                continue;
+            }
+            for (let i = 0; i < intersections.length; i += 2) {
+                const p0 = intersections[i]; // {vec, longLat, arcIndex}
+                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.longLat[0], p1.longLat[0]);
+                const triMaxLon = Math.max(p0.longLat[0], p1.longLat[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(p0.longLat, p0.vec, p0.arcIndex);
+                    addPoint(p1.longLat, p1.vec, p1.arcIndex);
+                    // 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], undefined, undefined);
+                        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);
+            if (intersections.length === 0) {
+                currentLon += lonStep;
+                continue;
+            }
+            for (const p of intersections) {
+                const pLongLat = p.longLat;
+                // 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.vec, p.arcIndex);
+                }
+            }
+            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(),
+            realEdgeArcIndices: null,
+        };
+    }
+    const delaunator = new Delaunator(allLongLats);
+    let indices = delaunator.triangles;
+    indices = filterEdgePointTriangles(indices, edgePointIndexSets);
+    // Convert to Mercator
+    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];
+    }
+    const realEdgeArcIndices = calculateRealEdgeArc ? orderIndcecesAlongArc(triangleMeta, edgePointIndexSets, allLongLats) : null;
+    return {
+        vec3s: new Float32Array(allVec3s),
+        longLats: new Float32Array(allLongLats),
+        indices: indices,
+        realEdgeArcIndices,
+    };
+}
+function orderIndcecesAlongArc(triangleMeta, edgePointIndexSets, allLongLats) {
+    let result = [];
+    let itemCounter = 0;
+    for (let i = 0; i < 3; i++) {
+        const arc = triangleMeta.arcs[i];
+        if (!arc.realEdge) {
+            continue;
+        }
+        // convert set to list
+        const indices = Array.from(edgePointIndexSets[i]);
+        if (indices.length == 0) {
+            continue;
+        }
+        const dimension = Math.abs(arc.normal[2]) < 0.0001 ? 0 : 1;
+        indices.sort((a, b) => {
+            return allLongLats[a * 2 + dimension] - allLongLats[b * 2 + dimension];
+        });
+        result.push(indices);
+        itemCounter += indices.length + 1;
+    }
+    if (result.length === 0) {
+        return null;
+    }
+    const finalResult = new Uint32Array(itemCounter);
+    let counter = 0;
+    for (let i = 0; i < result.length; i++) {
+        finalResult[counter++] = uint32Escape;
+        const indices = result[i];
+        for (let j = 0; j < indices.length; j++) {
+            finalResult[counter++] = indices[j];
+        }
+    }
+    return finalResult;
+}