@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/Math/tessellation/triangle-tessellation.js

@@ -1,14 +1,386 @@
 /**
  * @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";
+const KEY_PRECISION = 9;
+// 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;
+}
+export function createTriangleTessellationMeta(p1, p2, p3) {
+    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);
+    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)
+    };
+    meta.shortCut = partialTessellation(meta, [{
+            bbox: meta.bbox,
+            zoom: 0
+        }], TILE_DEM_STEPCOUNT);
+    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)
  */
-import { createTriangleTessellationMeta, getAllPoints, partialTessellation } from "./triangle-tessellation-meta";
-export function test1(zoomLevel, p1, p2, p3) {
-    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
-    const { vec3s, longLats, indices } = getAllPoints(triangleMeta, zoomLevel);
-    return { vec3s, longLats, indices };
-}
-export function partialTest(bboxZooms, p1, p2, p3) {
-    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
-    return partialTessellation(triangleMeta, bboxZooms, 5);
+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);
+}
+export function partialTessellation(triangleMeta, limits, innerCuts) {
+    // TODO: pointMap can be local variable and cleaned after function call to avoid reinitialization overhead
+    const pointMap = new Map(); // Key: "lon|lat", Value: index
+    const allVec3s = [];
+    const allLongLats = [];
+    let pointCounter = 0;
+    const stepCount = innerCuts - 1; // 
+    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(),
+        };
+    }
+    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,
+    };
 }

package/Math/vec3.js

@@ -148,4 +148,8 @@ function vec3ToLongLatRadians(v) {
         Math.asin(v[2])
     ];
 }
+export function vec3ToLongLatRadiansOut(out, v) {
+    out[0] = Math.atan2(v[1], v[0]);
+    out[1] = Math.asin(v[2]);
+}
 export { create, set, clone, copy, add, subtract, negate, dot, cross, multiplyScalar, divideScalar, lengthSquared, length, normalize, distanceSquared, distance, equals, fromUnitVectorToLongLat, fromLongLatToUnitVector, applyQuaternion, randomUnit, str, createUnitVectorFromLongLat, vec3ToLongLatDegrees, vec3ToLongLatRadians };

package/Math/xyz-tile.js

@@ -0,0 +1,18 @@
+import { RADIAN } from "./methods";
+export function xyzToBBOX(x, y, z) {
+    const n = Math.pow(2, z);
+    const lonMin = x / n * 360 - 180;
+    const lonMax = (x + 1) / n * 360 - 180;
+    const latMinRad = Math.atan(Math.sinh(Math.PI * (1 - 2 * (y + 1) / n)));
+    const latMaxRad = Math.atan(Math.sinh(Math.PI * (1 - 2 * y / n)));
+    return {
+        ll: {
+            x: lonMin,
+            y: latMinRad / RADIAN
+        },
+        ur: {
+            x: lonMax,
+            y: latMaxRad / RADIAN
+        }
+    };
+}

package/altitude-locator/plugin.js

@@ -4,8 +4,7 @@ import { ElementPointGlowProgramCache } from '../programs/point-on-globe/element
 import { ElementGlobeSufaceGlowCache } from '../programs/point-on-globe/element-globe-surface-glow.js';
 import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible';
 import { BufferOrchestrator, BufferManager } from "../util/account";
-// @ts-ignore
-import { PickerDisplayer } from '../util/picking/picker-displayer.js';
+import { PickerDisplayer } from '../util/picking/picker-displayer';
 import { wgs84ToCartesian3d, wgs84ToMercator } from '../Math/methods';
 import { constraintFloat, opacityCheck } from '../util/check/typecheck';
 import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';

package/investigation-tools/draw/tiles/adapters.js

@@ -21,7 +21,7 @@ export function tileToArcInputs(tiles, color) {
     //     msl?: boolean | null;
     // }
     for (const tile of tiles) {
-        const tileKey = `tile_${tile.row}_${tile.column}`;
+        const tileKey = `tile_${tile.x}_${tile.y}`;
         const bbox = tile.bbox;
         // left side
         result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ll.x, bbox.ur.y], color, `${tileKey}_left`));
@@ -50,7 +50,7 @@ export function mergedTileToArcInputs(mergedTile, color) {
 export function tilesToContextWriter4Inputs(tiles) {
     const result = [];
     for (const tile of tiles) {
-        const tileKey = `L_${tile.level}_R${tile.row}_C${tile.column}`;
+        const tileKey = `L_${tile.level}_R${tile.x}_C${tile.y}`;
         const centerLong = (tile.bbox.ll.x + tile.bbox.ur.x) / 2;
         const centerLat = (tile.bbox.ll.y + tile.bbox.ur.y) / 2;
         result.push({

package/investigation-tools/draw/tiles/tiles.js

@@ -59,7 +59,7 @@ export class TilesRendererPlugin {
         //     this.globe.api_GetDrawedTilesInfo(),
         //     this.globe
         // );
-        const drawnTiles = this.globe.api_GetDrawedTilesInfo();
+        const drawnTiles = this.globe.api_GetVisibleTilesInfo();
         let maxLevel = 0;
         let minLevel = Number.MAX_VALUE;
         const tileMap = new Map();
@@ -98,7 +98,7 @@ export class TilesRendererPlugin {
             this.arcPlugin.insertBulk(arcInputs);
         }
         // drawMergedBBoxes:
-        const mergedTiles = mergeMeshes(drawnTiles, 12, 5, 4);
+        const mergedTiles = mergeMeshes(drawnTiles, 12, 5, 4, this.globe);
         const color = [255, 255, 0, 255]; // Yellow
         const arcMergedInputs = mergedTiles.map(mergedTile => mergedTileToArcInputs(mergedTile, color)).flat();
         this.arcPlugin.insertBulk(arcMergedInputs);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.17.1",
+    "version": "1.0.3",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",

package/programs/helpers/fadeaway.js

@@ -25,7 +25,12 @@ void main() {
     outColor = vec4(color.rgb, color.a * opacity);
 }
 `;
-class FadeAwayProgram {
+export class FadeAwayProgram {
+    gl;
+    program;
+    vao;
+    uniforms;
+    _buffer;
     constructor(gl) {
         this.gl = gl;
         this.program = createProgram(gl, vertexShaderSource, fragmentShaderSource);

package/programs/point-on-globe/square-pixel-point.js

@@ -116,6 +116,7 @@ class PointOnGlobeProgram {
             gl.bindBuffer(gl.ARRAY_BUFFER, rgbaBuffer);
             gl.enableVertexAttribArray(2);
             gl.vertexAttribPointer(2, 4, gl.FLOAT, false, 0, 0);
+            // gl.vertexAttribPointer(2, 4, gl.UNSIGNED_INT, true, 0, 0);
         }
         gl.bindVertexArray(null);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);