@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/Math/tessellation/triangle-tessellation.ts

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

package/Math/tessellation/types.ts

@@ -0,0 +1 @@
+

package/Math/types.ts

@@ -0,0 +1,68 @@
+type Radians = number;
+type Degrees = number;
+type Meter = number;
+type Fraction = number; // between 0 and 1
+type WGS84 = [number, number]; // [longitude, latitude]
+type Vec2 = [number, number]; // [x, y] or [longitude, latitude] in Mercator projection
+type Vec3 = [number, number, number];
+type Vec4 = [number, number, number, number];
+
+type Line = {
+    origin: Vec3;
+    direction: Vec3;
+}
+
+type FiniteLine2D = [number, number, number, number];
+
+type Plane = {
+    normal: Vec3;
+    distance: number;
+};
+
+// TODO: CLEAN THIS USE LongLatRadian OR LongLatDegree FROM types.ts
+type LongLat = [number, number]; // [longitude, latitude]
+
+type Quaternion = [number, number, number, number];
+
+type Arc = {
+    p0: Vec3;
+    p1: Vec3;
+    normal: Vec3; // normal of the circle arc lie on
+    coverPlane: Plane; // plane that divides the circle that the arc lie on into visible and covered half
+    coverAngle: Radians;
+}
+
+type Sphere = {
+    center: Vec3;
+    radius: number;
+}
+
+type Circle = {
+    center: LongLat;
+    radius: Meter; // in meters
+}
+
+type CircleClosestAzimuthAngleProperties = {
+    normal: Vec3;
+    northPointProjectedToOriginPlaneNormalized: Vec3;
+}
+
+export {
+    Vec2,
+    Vec3,
+    Vec4,
+    Line,
+    Plane,
+    Quaternion,
+    Fraction,
+    WGS84,
+    Arc,
+    Sphere,
+    Radians,
+    Degrees,
+    Meter,
+    LongLat,
+    Circle,
+    CircleClosestAzimuthAngleProperties,
+    FiniteLine2D
+}

package/Math/utils.js

@@ -1,2 +1,3 @@
-import { Vector3D } from "./vector3d";
-import { Quaternion } from "./quaternion";
+import { Vector3D } from "./vector3d";
+import { Quaternion } from "./quaternion";
+