@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{Math/tessellation/methods.ts → webglobeplugins/Math/tessellation/methods.js}

@@ -1,79 +1,49 @@
-import { TILE_COUNTS } from "./constants";
-
-import { Plane, Vec3 } from "../types";
-import { LongLatRadian, Radian } from "../../types";
-
-type tileXY = [number, number];
-
-/**
- * If the slope is not close the zero not very important but
- * If a line goes along a parallel its latitude can tilt a lot
- * For these cases: 
- * Meridian junctions should be first. 
- * So we have information about possible edge latitude
- * Or the counting box should be calculated accourding to great circle
- * 
- * 
- */
-
-
-
-export function calculateMergedMeshDimLength(tileCount: number, sourceLength: number): number {
-
-    return sourceLength * tileCount - (tileCount - 1);
-}
-
-export function latToTileY(lat: Radian, zoom: number): number {
-    return (1 - Math.log(
-        Math.tan(lat) + 1 / Math.cos(lat)) / Math.PI) / 2 * TILE_COUNTS[zoom];
-}
-
-
-export function lonToTileX(lon: Radian, zoom: number): Radian {
-    return (lon + Math.PI) / (2 * Math.PI) * TILE_COUNTS[zoom];
-}
-
-
-export function longLatToTileDecimal(lon: number, lat: number, zoom: number): tileXY {
-    return [lonToTileX(lon, zoom), latToTileY(lat, zoom)];
-}
-
-
-export function tileYtoLat(y: number, zoom: number): Radian {
-    const n = Math.PI - 2 * Math.PI * y / TILE_COUNTS[zoom];
-    return (Math.PI / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))));
-}
-
-
-export function tileXtoLon(x: number, zoom: number): Radian {
-    return x / TILE_COUNTS[zoom] * (2 * Math.PI) - Math.PI;
-}
-
-export function tessellationLatDimention(zoom: number, lowLat: number, highLat: number): number[] {
-    const lowY = latToTileY(lowLat, zoom);
-    const highY = latToTileY(highLat, zoom);
-
-
-    const latitudes: number[] = [];
-    if (lowY % 1 !== 0) latitudes.push(lowLat);
-
-    for (let y = Math.ceil(lowY); y <= Math.floor(highY); y++) {
-        latitudes.push(tileYtoLat(y, zoom));
-    }
-    if (highY % 1 !== 0) latitudes.push(highLat);
-
-    return latitudes;
-}
-
-
-export function isOnTileEdge(longLat: LongLatRadian, zoom: number): boolean {
-
-    const tileX = lonToTileX(longLat[0], zoom);
-    const tileY = latToTileY(longLat[1], zoom);
-
-    const epsilon = 1 / TILE_COUNTS[zoom] / 200;
-    return (Math.abs(tileX % 1) < epsilon || Math.abs(tileY % 1) < epsilon || Math.abs(tileX % 1 - 1) < epsilon || Math.abs(tileY % 1 - 1) < epsilon);
-}
-
-
-
+import { TILE_COUNTS } from "./constants";
+/**
+ * If the slope is not close the zero not very important but
+ * If a line goes along a parallel its latitude can tilt a lot
+ * For these cases:
+ * Meridian junctions should be first.
+ * So we have information about possible edge latitude
+ * Or the counting box should be calculated accourding to great circle
+ *
+ *
+ */
+export function calculateMergedMeshDimLength(tileCount, sourceLength) {
+    return sourceLength * tileCount - (tileCount - 1);
+}
+export function latToTileY(lat, zoom) {
+    return (1 - Math.log(Math.tan(lat) + 1 / Math.cos(lat)) / Math.PI) / 2 * TILE_COUNTS[zoom];
+}
+export function lonToTileX(lon, zoom) {
+    return (lon + Math.PI) / (2 * Math.PI) * TILE_COUNTS[zoom];
+}
+export function longLatToTileDecimal(lon, lat, zoom) {
+    return [lonToTileX(lon, zoom), latToTileY(lat, zoom)];
+}
+export function tileYtoLat(y, zoom) {
+    const n = Math.PI - 2 * Math.PI * y / TILE_COUNTS[zoom];
+    return (Math.PI / Math.PI * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))));
+}
+export function tileXtoLon(x, zoom) {
+    return x / TILE_COUNTS[zoom] * (2 * Math.PI) - Math.PI;
+}
+export function tessellationLatDimention(zoom, lowLat, highLat) {
+    const lowY = latToTileY(lowLat, zoom);
+    const highY = latToTileY(highLat, zoom);
+    const latitudes = [];
+    if (lowY % 1 !== 0)
+        latitudes.push(lowLat);
+    for (let y = Math.ceil(lowY); y <= Math.floor(highY); y++) {
+        latitudes.push(tileYtoLat(y, zoom));
+    }
+    if (highY % 1 !== 0)
+        latitudes.push(highLat);
+    return latitudes;
+}
+export function isOnTileEdge(longLat, zoom) {
+    const tileX = lonToTileX(longLat[0], zoom);
+    const tileY = latToTileY(longLat[1], zoom);
+    const epsilon = 1 / TILE_COUNTS[zoom] / 200;
+    return (Math.abs(tileX % 1) < epsilon || Math.abs(tileY % 1) < epsilon || Math.abs(tileX % 1 - 1) < epsilon || Math.abs(tileY % 1 - 1) < epsilon);
+}

package/{Math/tessellation/nearest-value-padding.ts → webglobeplugins/Math/tessellation/nearest-value-padding.js}

@@ -1,147 +1,112 @@
-import { calculateMergedMeshDimLength } from "./methods";
-
-//TODO: file name to be changed to nearest-value-padding.ts
-const around = [
-    [1, 0],
-    [0, 1],
-    [-1, 0],
-    [0, -1],
-
-]
-
-export class NearestValuePadding {
-
-    private mergedTileCount: number;
-    private tileDimenstionLength: number;
-    private mergedMeshDimLength: number;
-    // Changed to string to prevent collisions with absolute coordinates
-    private tileGrid: Set<string> = new Set();
-
-    constructor(tileDimenstionLength: number, mergedTileCount: number) {
-        this.tileDimenstionLength = tileDimenstionLength;
-        this.mergedTileCount = mergedTileCount;
-        this.mergedMeshDimLength = calculateMergedMeshDimLength(mergedTileCount, tileDimenstionLength);
-
-    }
-
-
-    private _keyMaker(x: number, y: number): string {
-        return `${x}_${y}`;
-    }
-
-
-    public insert(x: number, y: number): void {
-        const { tileGrid } = this;
-
-        tileGrid.add(
-            this._keyMaker(x, y),
-        );
-    }
-
-
-    public fillTileFromBorders(
-        mesh: Float32Array,
-        relX: number, // Changed to relative coordinates
-        relY: number
-    ): void {
-        const { tileDimenstionLength, mergedMeshDimLength } = this;
-
-        // Tiles share edges, so stride is dimension - 1
-        const stride = tileDimenstionLength - 1;
-        const startX = relX * stride;
-        const startY = relY * stride;
-        const endX = startX + tileDimenstionLength;
-        const endY = startY + tileDimenstionLength;
-
-        const queue: number[] = [];
-        const getIndex = (gx: number, gy: number) => gy * mergedMeshDimLength + gx;
-
-        // 1. Collect valid border pixels as seeds
-        // Top and Bottom borders
-        for (let lx = 0; lx < tileDimenstionLength; lx++) {
-            const gx = startX + lx;
-
-            // Top
-            const topIdx = getIndex(gx, startY);
-            if (topIdx < mesh.length && !isNaN(mesh[topIdx])) queue.push(topIdx);
-
-            // Bottom
-            const bottomIdx = getIndex(gx, startY + tileDimenstionLength - 1);
-            if (bottomIdx < mesh.length && !isNaN(mesh[bottomIdx])) queue.push(bottomIdx);
-        }
-
-        // Left and Right borders (excluding corners)
-        for (let ly = 1; ly < tileDimenstionLength - 1; ly++) {
-            const gy = startY + ly;
-
-            // Left
-            const leftIdx = getIndex(startX, gy);
-            if (leftIdx < mesh.length && !isNaN(mesh[leftIdx])) queue.push(leftIdx);
-
-            // Right
-            const rightIdx = getIndex(startX + tileDimenstionLength - 1, gy);
-            if (rightIdx < mesh.length && !isNaN(mesh[rightIdx])) queue.push(rightIdx);
-        }
-
-        // 2. BFS Flood Fill
-        let head = 0;
-        while (head < queue.length) {
-            const idx = queue[head++];
-            const val = mesh[idx];
-
-            const cx = idx % mergedMeshDimLength;
-            const cy = Math.floor(idx / mergedMeshDimLength);
-
-            const neighbors = [
-                { nx: cx + 1, ny: cy },
-                { nx: cx - 1, ny: cy },
-                { nx: cx, ny: cy + 1 },
-                { nx: cx, ny: cy - 1 },
-            ];
-
-            for (const { nx, ny } of neighbors) {
-                // Check if neighbor is within the current tile bounds
-                if (nx >= startX && nx < endX && ny >= startY && ny < endY) {
-                    const nIdx = getIndex(nx, ny);
-                    if (nIdx < mesh.length && isNaN(mesh[nIdx])) {
-                        mesh[nIdx] = val;
-                        queue.push(nIdx);
-                    }
-                }
-            }
-        }
-    }
-
-
-    public clamp(mesh: Float32Array, minX: number, minY: number, maxX: number, maxY: number): void {
-        // traverse all tiles, if tileSet doesnt have the tile, calculate border verteces indexes. 
-        // for top index check the index on left-top, top, tight-top to fill closest value
-        const { tileGrid, mergedTileCount } = this;
-
-        // Use passed absolute bounds directly
-        for (let x = minX; x <= maxX; x++) {
-            for (let y = minY; y <= maxY; y++) {
-                const key = this._keyMaker(x, y);
-                if (tileGrid.has(key)) {
-                    continue;
-                }
-
-                // Calculate relative coordinates for mesh access
-                const relX = x - minX;
-                const relY = y - minY;
-
-                // Ensure we stay within the allocated merged mesh
-                if (relX >= 0 && relX < mergedTileCount && relY >= 0 && relY < mergedTileCount) {
-                    this.fillTileFromBorders(mesh, relX, relY);
-                }
-            }
-        }
-    }
-
-
-    public clear() {
-        this.tileGrid.clear();
-    }
-}
-
-
+import { calculateMergedMeshDimLength } from "./methods";
+//TODO: file name to be changed to nearest-value-padding.ts
+const around = [
+    [1, 0],
+    [0, 1],
+    [-1, 0],
+    [0, -1],
+];
+export class NearestValuePadding {
+    mergedTileCount;
+    tileDimenstionLength;
+    mergedMeshDimLength;
+    // Changed to string to prevent collisions with absolute coordinates
+    tileGrid = new Set();
+    constructor(tileDimenstionLength, mergedTileCount) {
+        this.tileDimenstionLength = tileDimenstionLength;
+        this.mergedTileCount = mergedTileCount;
+        this.mergedMeshDimLength = calculateMergedMeshDimLength(mergedTileCount, tileDimenstionLength);
+    }
+    _keyMaker(x, y) {
+        return `${x}_${y}`;
+    }
+    insert(x, y) {
+        const { tileGrid } = this;
+        tileGrid.add(this._keyMaker(x, y));
+    }
+    fillTileFromBorders(mesh, relX, // Changed to relative coordinates
+    relY) {
+        const { tileDimenstionLength, mergedMeshDimLength } = this;
+        // Tiles share edges, so stride is dimension - 1
+        const stride = tileDimenstionLength - 1;
+        const startX = relX * stride;
+        const startY = relY * stride;
+        const endX = startX + tileDimenstionLength;
+        const endY = startY + tileDimenstionLength;
+        const queue = [];
+        const getIndex = (gx, gy) => gy * mergedMeshDimLength + gx;
+        // 1. Collect valid border pixels as seeds
+        // Top and Bottom borders
+        for (let lx = 0; lx < tileDimenstionLength; lx++) {
+            const gx = startX + lx;
+            // Top
+            const topIdx = getIndex(gx, startY);
+            if (topIdx < mesh.length && !isNaN(mesh[topIdx]))
+                queue.push(topIdx);
+            // Bottom
+            const bottomIdx = getIndex(gx, startY + tileDimenstionLength - 1);
+            if (bottomIdx < mesh.length && !isNaN(mesh[bottomIdx]))
+                queue.push(bottomIdx);
+        }
+        // Left and Right borders (excluding corners)
+        for (let ly = 1; ly < tileDimenstionLength - 1; ly++) {
+            const gy = startY + ly;
+            // Left
+            const leftIdx = getIndex(startX, gy);
+            if (leftIdx < mesh.length && !isNaN(mesh[leftIdx]))
+                queue.push(leftIdx);
+            // Right
+            const rightIdx = getIndex(startX + tileDimenstionLength - 1, gy);
+            if (rightIdx < mesh.length && !isNaN(mesh[rightIdx]))
+                queue.push(rightIdx);
+        }
+        // 2. BFS Flood Fill
+        let head = 0;
+        while (head < queue.length) {
+            const idx = queue[head++];
+            const val = mesh[idx];
+            const cx = idx % mergedMeshDimLength;
+            const cy = Math.floor(idx / mergedMeshDimLength);
+            const neighbors = [
+                { nx: cx + 1, ny: cy },
+                { nx: cx - 1, ny: cy },
+                { nx: cx, ny: cy + 1 },
+                { nx: cx, ny: cy - 1 },
+            ];
+            for (const { nx, ny } of neighbors) {
+                // Check if neighbor is within the current tile bounds
+                if (nx >= startX && nx < endX && ny >= startY && ny < endY) {
+                    const nIdx = getIndex(nx, ny);
+                    if (nIdx < mesh.length && isNaN(mesh[nIdx])) {
+                        mesh[nIdx] = val;
+                        queue.push(nIdx);
+                    }
+                }
+            }
+        }
+    }
+    clamp(mesh, minX, minY, maxX, maxY) {
+        // traverse all tiles, if tileSet doesnt have the tile, calculate border verteces indexes. 
+        // for top index check the index on left-top, top, tight-top to fill closest value
+        const { tileGrid, mergedTileCount } = this;
+        // Use passed absolute bounds directly
+        for (let x = minX; x <= maxX; x++) {
+            for (let y = minY; y <= maxY; y++) {
+                const key = this._keyMaker(x, y);
+                if (tileGrid.has(key)) {
+                    continue;
+                }
+                // Calculate relative coordinates for mesh access
+                const relX = x - minX;
+                const relY = y - minY;
+                // Ensure we stay within the allocated merged mesh
+                if (relX >= 0 && relX < mergedTileCount && relY >= 0 && relY < mergedTileCount) {
+                    this.fillTileFromBorders(mesh, relX, relY);
+                }
+            }
+        }
+    }
+    clear() {
+        this.tileGrid.clear();
+    }
+}

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

@@ -1,127 +1,99 @@
-import { Vec3 } from "../types";
-
-/**
- * Calculates the 3D surface area of a spherical triangle defined by three unit vectors
- * on the surface of a sphere of radius R, using Girard's Theorem.
- *
- * @param p1 The first unit vector [x, y, z].
- * @param p2 The second unit vector [x, y, z].
- * @param p3 The third unit vector [x, y, z].
- * @param R The radius of the sphere (e.g., 6378.137 for Earth's radius).
- * @returns The surface area of the spherical triangle.
- */
-export function sphericalTriangleArea(p1: Vec3, p2: Vec3, p3: Vec3, R: number): number {
-    // --- 1. Utility Functions ---
-
-    /** Calculates the dot product of two vectors. */
-    const dot = (v1: Vec3, v2: Vec3): number => v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-
-    /** Calculates the cross product of two vectors. */
-    const cross = (v1: Vec3, v2: Vec3): Vec3 => [
-        v1[1] * v2[2] - v1[2] * v2[1],
-        v1[2] * v2[0] - v1[0] * v2[2],
-        v1[0] * v2[1] - v1[1] * v2[0],
-    ];
-
-    /** Calculates the squared magnitude (length squared) of a vector. */
-    const magSq = (v: Vec3): number => v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
-
-    // --- 2. Calculate Plane Normals ---
-
-    // The interior angles are the angles between the planes that contain the edges.
-    // The normal N_AB is perpendicular to the plane containing the segment P1-P2 and the origin.
-
-    const n_p1p2 = cross(p1, p2);
-    const n_p2p3 = cross(p2, p3);
-    const n_p3p1 = cross(p3, p1);
-
-    // Magnitudes (squared) of the normals. Since P1, P2, P3 are unit vectors,
-    // the magnitude of the cross product (sin(angle)) is not 1, so we must normalize later.
-    const n12_sq = magSq(n_p1p2);
-    const n23_sq = magSq(n_p2p3);
-    const n31_sq = magSq(n_p3p1);
-
-    // Handle degenerate cases (e.g., points are collinear or on a great circle)
-    if (n12_sq < 1e-9 || n23_sq < 1e-9 || n31_sq < 1e-9) {
-        return 0;
-    }
-
-    // --- 3. Calculate Interior Angles (Alpha, Beta, Gamma) ---
-    // The angle between two planes is the angle between their normal vectors (N_a, N_b).
-    // Angle = arccos( (N_a . N_b) / (||N_a|| * ||N_b||) )
-
-    // Angle at P1 (Alpha): angle between normal N_p3p1 and N_p1p2
-    const cos_alpha = dot(n_p3p1, n_p1p2) / Math.sqrt(n31_sq * n12_sq);
-    const alpha = Math.acos(Math.min(1.0, Math.max(-1.0, cos_alpha))); // Clamp for floating point errors
-
-    // Angle at P2 (Beta): angle between normal N_p1p2 and N_p2p3
-    const cos_beta = dot(n_p1p2, n_p2p3) / Math.sqrt(n12_sq * n23_sq);
-    const beta = Math.acos(Math.min(1.0, Math.max(-1.0, cos_beta)));
-
-    // Angle at P3 (Gamma): angle between normal N_p2p3 and N_p3p1
-    const cos_gamma = dot(n_p2p3, n_p3p1) / Math.sqrt(n23_sq * n31_sq);
-    const gamma = Math.acos(Math.min(1.0, Math.max(-1.0, cos_gamma)));
-
-    // --- 4. Apply Girard's Theorem ---
-
-    // Spherical Excess (E): The amount by which the sum of the interior angles exceeds PI.
-    const spherical_excess = alpha + beta + gamma - Math.PI;
-
-    // The surface area A is given by R^2 * E.
-    // Use Math.abs() to ensure a positive area, regardless of vertex winding order.
-    const area = R * R * Math.abs(spherical_excess);
-
-    return area;
-}
-
-
-// Define Earth's radius (R_3D) for context, though it's not strictly necessary if R is passed in.
-const R_EARTH = 6378.137; // km
-
-/**
- * Calculates the Culling Area Threshold (A_CULL) for a given zoom level.
- * Triangles with area LESS than this threshold are considered too small to display.
- *
- * @param zoomLevel The current integer zoom level (Z).
- * @param R The radius of the sphere (e.g., 6378.137 for Earth).
- * @param C1_Factor A tuning constant determining the base visibility level (Default: 1.0).
- * Lower values mean smaller triangles are culled at early zoom levels.
- * @returns The area threshold in R units squared (e.g., km^2).
- */
-export function generateCullAreaThreshold(zoomLevel: number, R: number, C1_Factor: number = 1.0): number {
-    // A_BASE_CULL should represent a "small" area on the sphere (e.g., 1 square degree equivalent).
-    // We scale it by R^2 to get the area in the correct units (e.g., km^2).
-    // The R^2 * 4 * Math.PI factor is the total surface area of the sphere.
-    // The denominator provides a large base number so the initial area is small.
-
-    // A simplified base area using 1/1,000,000th of the total spherical area for Z=0
-    const A_BASE_CULL = (4 * Math.PI * R * R) / 1000000;
-
-    // A_CULL scales exponentially with -2 * Z (since area is proportional to the square of linear size)
-    const threshold = C1_Factor * A_BASE_CULL * Math.pow(2, -2 * zoomLevel);
-
-    return threshold;
-}
-
-/**
- * Calculates the Tessellation Area Threshold (A_TESS) for a given zoom level.
- * Triangles with area GREATER than this threshold require subdivision (tessellation).
- *
- * @param zoomLevel The current integer zoom level (Z).
- * @param R The radius of the sphere (e.g., 6378.137 for Earth).
- * @param C2_Factor A tuning constant determining the relative size for tessellation.
- * Higher values mean tessellation happens less aggressively (Default: 100.0).
- * @returns The area threshold in R units squared (e.g., km^2).
- */
-export function generateTessellationAreaThreshold(zoomLevel: number, R: number, C2_Factor: number = 100.0): number {
-    // This threshold should be significantly larger than the CULL threshold.
-    // We can directly derive it by applying a large constant factor (C2_Factor) 
-    // to the cull threshold, maintaining the same exponential scaling.
-
-    // Use the Cull function as a base:
-    const A_CULL_BASE = generateCullAreaThreshold(zoomLevel, R, 1.0);
-
-    const threshold = C2_Factor * A_CULL_BASE;
-
-    return threshold;
-}
+/**
+ * Calculates the 3D surface area of a spherical triangle defined by three unit vectors
+ * on the surface of a sphere of radius R, using Girard's Theorem.
+ *
+ * @param p1 The first unit vector [x, y, z].
+ * @param p2 The second unit vector [x, y, z].
+ * @param p3 The third unit vector [x, y, z].
+ * @param R The radius of the sphere (e.g., 6378.137 for Earth's radius).
+ * @returns The surface area of the spherical triangle.
+ */
+export function sphericalTriangleArea(p1, p2, p3, R) {
+    // --- 1. Utility Functions ---
+    /** Calculates the dot product of two vectors. */
+    const dot = (v1, v2) => v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+    /** Calculates the cross product of two vectors. */
+    const cross = (v1, v2) => [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0],
+    ];
+    /** Calculates the squared magnitude (length squared) of a vector. */
+    const magSq = (v) => v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+    // --- 2. Calculate Plane Normals ---
+    // The interior angles are the angles between the planes that contain the edges.
+    // The normal N_AB is perpendicular to the plane containing the segment P1-P2 and the origin.
+    const n_p1p2 = cross(p1, p2);
+    const n_p2p3 = cross(p2, p3);
+    const n_p3p1 = cross(p3, p1);
+    // Magnitudes (squared) of the normals. Since P1, P2, P3 are unit vectors,
+    // the magnitude of the cross product (sin(angle)) is not 1, so we must normalize later.
+    const n12_sq = magSq(n_p1p2);
+    const n23_sq = magSq(n_p2p3);
+    const n31_sq = magSq(n_p3p1);
+    // Handle degenerate cases (e.g., points are collinear or on a great circle)
+    if (n12_sq < 1e-9 || n23_sq < 1e-9 || n31_sq < 1e-9) {
+        return 0;
+    }
+    // --- 3. Calculate Interior Angles (Alpha, Beta, Gamma) ---
+    // The angle between two planes is the angle between their normal vectors (N_a, N_b).
+    // Angle = arccos( (N_a . N_b) / (||N_a|| * ||N_b||) )
+    // Angle at P1 (Alpha): angle between normal N_p3p1 and N_p1p2
+    const cos_alpha = dot(n_p3p1, n_p1p2) / Math.sqrt(n31_sq * n12_sq);
+    const alpha = Math.acos(Math.min(1.0, Math.max(-1.0, cos_alpha))); // Clamp for floating point errors
+    // Angle at P2 (Beta): angle between normal N_p1p2 and N_p2p3
+    const cos_beta = dot(n_p1p2, n_p2p3) / Math.sqrt(n12_sq * n23_sq);
+    const beta = Math.acos(Math.min(1.0, Math.max(-1.0, cos_beta)));
+    // Angle at P3 (Gamma): angle between normal N_p2p3 and N_p3p1
+    const cos_gamma = dot(n_p2p3, n_p3p1) / Math.sqrt(n23_sq * n31_sq);
+    const gamma = Math.acos(Math.min(1.0, Math.max(-1.0, cos_gamma)));
+    // --- 4. Apply Girard's Theorem ---
+    // Spherical Excess (E): The amount by which the sum of the interior angles exceeds PI.
+    const spherical_excess = alpha + beta + gamma - Math.PI;
+    // The surface area A is given by R^2 * E.
+    // Use Math.abs() to ensure a positive area, regardless of vertex winding order.
+    const area = R * R * Math.abs(spherical_excess);
+    return area;
+}
+// Define Earth's radius (R_3D) for context, though it's not strictly necessary if R is passed in.
+const R_EARTH = 6378.137; // km
+/**
+ * Calculates the Culling Area Threshold (A_CULL) for a given zoom level.
+ * Triangles with area LESS than this threshold are considered too small to display.
+ *
+ * @param zoomLevel The current integer zoom level (Z).
+ * @param R The radius of the sphere (e.g., 6378.137 for Earth).
+ * @param C1_Factor A tuning constant determining the base visibility level (Default: 1.0).
+ * Lower values mean smaller triangles are culled at early zoom levels.
+ * @returns The area threshold in R units squared (e.g., km^2).
+ */
+export function generateCullAreaThreshold(zoomLevel, R, C1_Factor = 1.0) {
+    // A_BASE_CULL should represent a "small" area on the sphere (e.g., 1 square degree equivalent).
+    // We scale it by R^2 to get the area in the correct units (e.g., km^2).
+    // The R^2 * 4 * Math.PI factor is the total surface area of the sphere.
+    // The denominator provides a large base number so the initial area is small.
+    // A simplified base area using 1/1,000,000th of the total spherical area for Z=0
+    const A_BASE_CULL = (4 * Math.PI * R * R) / 1000000;
+    // A_CULL scales exponentially with -2 * Z (since area is proportional to the square of linear size)
+    const threshold = C1_Factor * A_BASE_CULL * Math.pow(2, -2 * zoomLevel);
+    return threshold;
+}
+/**
+ * Calculates the Tessellation Area Threshold (A_TESS) for a given zoom level.
+ * Triangles with area GREATER than this threshold require subdivision (tessellation).
+ *
+ * @param zoomLevel The current integer zoom level (Z).
+ * @param R The radius of the sphere (e.g., 6378.137 for Earth).
+ * @param C2_Factor A tuning constant determining the relative size for tessellation.
+ * Higher values mean tessellation happens less aggressively (Default: 100.0).
+ * @returns The area threshold in R units squared (e.g., km^2).
+ */
+export function generateTessellationAreaThreshold(zoomLevel, R, C2_Factor = 100.0) {
+    // This threshold should be significantly larger than the CULL threshold.
+    // We can directly derive it by applying a large constant factor (C2_Factor) 
+    // to the cull threshold, maintaining the same exponential scaling.
+    // Use the Cull function as a base:
+    const A_CULL_BASE = generateCullAreaThreshold(zoomLevel, R, 1.0);
+    const threshold = C2_Factor * A_CULL_BASE;
+    return threshold;
+}