@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/Math/haversine.js

@@ -0,0 +1,22 @@
+/**
+ * Calculate great-circle distance (arc length) between two lat/lon points
+ * @param lat1 Latitude of point 1 (Radian)
+ * @param lon1 Longitude of point 1 (Radian)
+ * @param lat2 Latitude of point 2 (Radian)
+ * @param lon2 Longitude of point 2 (Radian)
+ * @returns Distance in unit sphere radius
+*/
+export function haversine(lat1, lon1, lat2, lon2) {
+    // Convert to radians in-place (minimal allocations)
+    const φ1 = lat1;
+    const φ2 = lat2;
+    const Δφ = lat2 - lat1;
+    const Δλ = lon2 - lon1;
+    // Haversine: a = sin²(Δφ/2) + cos(φ1)cos(φ2)sin²(Δλ/2)
+    const a = Math.sin(Δφ * 0.5) ** 2 +
+        Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ * 0.5) ** 2;
+    // c = 2 * atan2(√a, √(1−a))
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return c; // arc length
+}
+;

package/Math/methods.js

@@ -18,10 +18,23 @@ export const radianToMercator = (xy) => {
 };
 export function radianToMercatorXY(xy) {
     return [
-        xy[0] * Math.pow(2, 8),
-        Math.log(Math.tan(Math.PI / 4 + xy[1] / 2)) * Math.pow(2, 8)
+        xy[0],
+        Math.log(Math.tan(Math.PI / 4 + xy[1] / 2)),
     ];
 }
+export function globeBBoxToXYBBOX(t) {
+    // this code scales Y to linear integration
+    return {
+        ll: radianToMercatorXY([t.ll.x * RADIAN, t.ll.y * RADIAN]), // west longitude, north latitude
+        ur: radianToMercatorXY([t.ur.x * RADIAN, t.ur.y * RADIAN]) // east longitude, south latitude
+    };
+}
+export function tileXY2Radian(x, y, zoom) {
+    const n = Math.pow(2, zoom);
+    const long = x / n * 2 * Math.PI - Math.PI;
+    const lat = Math.atan(Math.sinh(Math.PI - (y / n * 2 * Math.PI)));
+    return [long, lat];
+}
 export const radianToCartesian3d = (xy) => {
     const x = Math.cos(xy[1]) * Math.cos(xy[0]);
     const y = Math.cos(xy[1]) * Math.sin(xy[0]);

package/Math/tessellation/methods.js

@@ -1,4 +1,4 @@
-import { TILE_COUNTS } from "./zoom-catch";
+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
@@ -9,6 +9,9 @@ import { TILE_COUNTS } from "./zoom-catch";
  *
  *
  */
+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];
 }

package/Math/tessellation/nearest-value-padding.js

@@ -0,0 +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 {
+    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.js

@@ -0,0 +1,99 @@
+/**
+ * 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;
+}