@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/Math/tessellation/methods.ts

@@ -0,0 +1,79 @@
+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);
+}
+
+
+

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

@@ -0,0 +1,147 @@
+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();
+    }
+}
+
+

package/Math/tessellation/roadmap.md

@@ -0,0 +1,48 @@
+# Preprocess
+
+1) EarCut: Polygon -> triangles
+2) triangles to arcs
+3) cut arcs
+    * Find peak points in latitude dimention.
+    * Find latitude and longitude cut points on zoom 12 ( 12 becse elevation starts)
+    * Cut from that latiude in meridian dimension
+    **Question** Should I cut from peak point, before finding zoom cuts?
+    I feels like no need. We will see
+4) Put tringles in rbush
+
+**Question** What represents a triangle? 
+3 Arcs, with metadata of bbox,
+Since we cut from peak point parallel junktion with any arc should give maximum 1 point.
+
+
+# Maintainance
+
+Rbush tree needs maintanance. Maybe a delete counter. When it exceeds threshhold. rebuild tree with last income
+
+On edit mode the shapes change frequently. Lightweight version should work on theese cases.
+
+**Question** How lightweight version is different?
+Smaller instance of the structure only holds updated data. Probably rBush is put aside. All the shapes on this instance are processed each frame.
+
+# On Fly
+
+Get screenBBox,
+Get 6 high reslutiotion tiles
+
+find all triangles that touches it. 
+Create Meshes of theme on webworker
+load result elements (3d and longlat coordinates)  and indexes to gpu
+load DEM data as texture
+
+**Question** What will happen if a triangles resolution is not changed on the upcoming frame?
+need to cache each triangles last resolution,
+
+Catched items for each triangle:
+1) mesh coordinates
+2) mesh indexes or indexes should be easy to calculate
+    **Question** How to calculate? Store how many points each parallel has. 
+3) Zoom Level
+
+If triangle has deeper mesh then its need to be, it can just use it
+Maybe I find a smart way to prune to mesh without distrupt its structure for lower resulution mesh 
+

package/Math/tessellation/spherical-triangle-area.ts

@@ -0,0 +1,127 @@
+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;
+}