@pirireis/webglobeplugins 0.16.4 → 0.17.0

package/Math/juction/plane-plane.js

@@ -1,10 +1,8 @@
 import { EPSILON } from "../constants";
-import { copy, create, dot, cross, lengthSquared } from "../vec3";
-const _normal1 = create();
-const _normal2 = create();
-export function planePlaneJuction(out, plane1, plane2) {
-    copy(_normal1, plane1.normal);
-    copy(_normal2, plane2.normal);
+import { dot, cross, lengthSquared } from "../vec3";
+export function planePlaneJunction(out, plane1, plane2) {
+    const _normal1 = plane1.normal;
+    const _normal2 = plane2.normal;
     const distance1 = plane1.distance;
     const distance2 = plane2.distance;
     const { origin, direction } = out;

package/Math/methods.js

@@ -1,6 +1,6 @@
 import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants';
 import { dot as dot3, copy as copy3 } from './vec3';
-export const RADIANS = Math.PI / 180;
+export const RADIAN = Math.PI / 180;
 const _0vec3 = [0, 0, 0];
 const _0vec2 = [0, 0];
 export const cartesian3dToRadian = (output, cartesian) => {
@@ -47,8 +47,8 @@ export const sphericalLinearInterpolation_Cartesian3d = (output, a, b, ratio) =>
     output[2] = _0vec3[2] * height;
 };
 export const wgs84ToCartesian3d = (output, long, lat, height) => {
-    const longRad = long * RADIANS;
-    const latRad = lat * RADIANS;
+    const longRad = long * RADIAN;
+    const latRad = lat * RADIAN;
     const x = Math.cos(latRad) * Math.cos(longRad);
     const y = Math.cos(latRad) * Math.sin(longRad);
     const z = Math.sin(latRad);
@@ -59,8 +59,8 @@ export const wgs84ToCartesian3d = (output, long, lat, height) => {
 };
 export const wgs84ToMercator = (long, lat) => {
     return [
-        WORLD_RADIUS_MERCATOR * long * RADIANS,
-        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))
+        WORLD_RADIUS_MERCATOR * long * RADIAN,
+        WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIAN / 2))
     ];
 };
 export const pixelXYToRadians = (pixelXY) => {

package/Math/templete-shapes/grid-visually-equal.js

@@ -41,7 +41,6 @@ export function createfillGrid(globe, origin, startX, startY, rowSize, columnSiz
         grid[startY][i] = [long, lat];
     }
     // fill single horizontal from origin from startY to 0
-    console.log("grid", grid);
     for (let i = startY - 1; i >= 0; i--) {
         for (let j = 0; j < rowSize; j++) {
             const [long, lat] = moveByAngle(grid[i + 1][j], angleRadians - Math.PI / 2, cellSizeY);

package/Math/tessellation/earcut/adapters.js

@@ -0,0 +1,37 @@
+function geoJSONToEarcut(geojson) {
+    const vertices = [];
+    const holes = [];
+    const dimensions = 2; // Assuming 2D coordinates (longitude, latitude)
+    let holeIndex = 0;
+    if (geojson.type !== 'FeatureCollection') {
+        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
+    }
+    const features = geojson.features;
+    function processPolygon(coordinates) {
+        for (let i = 0; i < coordinates.length; i++) {
+            if (i > 0) {
+                holeIndex += coordinates[i - 1].length;
+                holes.push(holeIndex);
+            }
+            for (const coord of coordinates[i]) {
+                vertices.push(coord[0], coord[1]);
+            }
+        }
+    }
+    function processMultiPolygon(coordinates) {
+        for (const polygon of coordinates) {
+            processPolygon(polygon);
+        }
+    }
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        if (geometry.type === 'Polygon') {
+            processPolygon(geometry.coordinates);
+        }
+        else if (geometry.type === 'MultiPolygon') {
+            processMultiPolygon(geometry.coordinates);
+        }
+    }
+    return { vertices, holes, dimensions };
+}
+export { geoJSONToEarcut };

package/Math/tessellation/hybrid-triangle-tessellation-meta.js

@@ -0,0 +1,123 @@
+/**
+ * @author Toprak Ozturk
+ */
+import { equals, fromLongLatToUnitVector, fromUnitVectorToLongLat } from "../vec3";
+import { pointsOnArc } from "../juction/arc-plane";
+import { junctionVerticalOrHorizontalLines } from "../finite-line-2d";
+// 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
+var EdgeType;
+(function (EdgeType) {
+    EdgeType[EdgeType["ARC"] = 0] = "ARC";
+    EdgeType[EdgeType["LINEAR"] = 1] = "LINEAR";
+})(EdgeType || (EdgeType = {}));
+const _tempVec2 = /*@__PURE__*/ [0, 0];
+const _plane = /*@__PURE__*/ { normal: [0, 0, 0], distance: 0 };
+const _resultPoints = /*@__PURE__*/ [[0, 0, 0], [0, 0, 0]];
+/**
+ *
+ * @param triangleMeta
+ * @param zoom
+ * @param angle
+ * @param dimension false for longitude (meridian) true for latitude (parallel)
+ */
+function getPoints(triangleMeta, angle, dimension) {
+    // console.log("getPoints called with angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude');
+    // 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 resultsFromDistinctEdges = 0;
+    for (let i = 0; i < 3; i++) {
+        const edgeType = triangleMeta.edgeTypes[i];
+        const edge = triangleMeta.edges[i];
+        const coordIndex = dimension ? 1 : 0;
+        const minCoord = edge.bbox.min[coordIndex];
+        const maxCoord = edge.bbox.max[coordIndex];
+        if (minCoord > angle || maxCoord < angle) {
+            continue; // edge is out of range
+        }
+        let count = 0;
+        if (edgeType === EdgeType.ARC) {
+            count = pointsOnArc(edge, _plane, _resultPoints);
+            if (count === 1) {
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[0]);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+            }
+            else if (count === 2) {
+                // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[0]);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+                fromUnitVectorToLongLat(_tempVec2, _resultPoints[1]);
+                result.push([[..._resultPoints[1]], [..._tempVec2]]); // TODO: this is a fix for a bug, need to investigate later
+            }
+        }
+        else {
+            // linear line
+            count = junctionVerticalOrHorizontalLines(_tempVec2, edge.line, angle, dimension);
+            if (count === 1) {
+                fromLongLatToUnitVector(_resultPoints[0], _tempVec2);
+                result.push([[..._resultPoints[0]], [..._tempVec2]]);
+            }
+        }
+        resultsFromDistinctEdges += 1;
+    }
+    if (resultsFromDistinctEdges === 3) {
+        result = filterDuplicate(result);
+    }
+    if (result.length !== 2 && result.length !== 4) {
+        // TODO: THERE is a case where 4 points are found.
+        // this happens when two arcs has limit and share space in Z dimension
+        console.log("ERROR");
+        const text = 'Angle:' + angle + ' dimension:' + (dimension ? 'latitude' : 'longitude') + "\n" +
+            'Result points count:' + result.length + "\n" +
+            "bbox:" + triangleMeta.bbox.min[0] * 180 / Math.PI + ", " + triangleMeta.bbox.min[1] * 180 / Math.PI + ", " + triangleMeta.bbox.max[0] * 180 / Math.PI + ", " + triangleMeta.bbox.max[1] * 180 / Math.PI + "\n";
+        for (let res of result) {
+            const ll = res[1];
+            console.log("Point: " + ll[0] * 180 / Math.PI + ", " + ll[1] * 180 / Math.PI + "\n");
+        }
+        throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n` + text);
+    }
+    // TODO: i want to see it delete later
+    if (result.length === 4) {
+        console.warn("Warning: 4 cut points found on triangle for angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude', "points:", result);
+    }
+    result.sort((a, b) => {
+        if (dimension) {
+            return a[1][0] - b[1][0]; // sort by y for longitude cuts
+        }
+        else {
+            return a[1][1] - b[1][1]; // sort by x for latitude cuts
+        }
+    });
+    return result;
+}
+function filterDuplicate(points) {
+    const result = [points[0]];
+    let dublicate = false;
+    for (let i = 1; i < points.length; i++) {
+        for (let j = 0; j < result.length; j++) {
+            if (equals(points[i][0], result[j][0])) {
+                dublicate = true;
+                break;
+            }
+        }
+        if (!dublicate) {
+            result.push(points[i]);
+        }
+    }
+    return result;
+}

package/Math/tessellation/methods.js

@@ -0,0 +1,46 @@
+import { TILE_COUNTS } from "./zoom-catch";
+/**
+ * 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 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/shred-input.js

@@ -0,0 +1,18 @@
+import earcut from "earcut";
+import { createTriangleTessellationMeta } from "./triangle-tessellation-meta";
+function shredInput(vertices, holes, zoomLevel) {
+    const result = [];
+    const triangles = earcut(vertices, holes, 2);
+    for (let i = 0; i < triangles.length; i += 3) {
+        const idx1 = triangles[i] * 2;
+        const idx2 = triangles[i + 1] * 2;
+        const idx3 = triangles[i + 2] * 2;
+        const p1 = [vertices[idx1], vertices[idx1 + 1]];
+        const p2 = [vertices[idx2], vertices[idx2 + 1]];
+        const p3 = [vertices[idx3], vertices[idx3 + 1]];
+        const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+        result.push(triangleMeta);
+    }
+    // cut triangles into smaller pieces based on zoom level...
+    return result;
+}

package/Math/tessellation/tile-merger.js

@@ -0,0 +1,56 @@
+"use strict";
+function _sortXY(a, b) {
+    if (a.y === b.y) {
+        return a.x - b.x;
+    }
+    return a.y - b.y;
+}
+function groupByZoomLevel(tiles) {
+    const map = new Map();
+    for (const tile of tiles) {
+        if (!map.has(tile.z)) {
+            map.set(tile.z, []);
+        }
+        map.get(tile.z).push(tile);
+    }
+    map.forEach((tileList, z) => {
+        tileList.sort(_sortXY);
+    });
+    return map;
+}
+function _insertDEM(sourceDEM, sourceWidth, sourceHeight, targetDEM, targetWidth, targetHeight, offsetX, offsetY) {
+    for (let row = 0; row < sourceHeight; row++) {
+        for (let col = 0; col < sourceWidth; col++) {
+            const sourceIndex = row * sourceWidth + col;
+            const targetIndex = (row + offsetY) * targetWidth + (col + offsetX);
+            targetDEM[targetIndex] = sourceDEM[sourceIndex];
+        }
+    }
+}
+function mergeTiles(tiles, demWidth, demHeight) {
+    let minX = Number.MAX_VALUE;
+    let maxX = Number.MIN_VALUE;
+    let minY = Number.MAX_VALUE;
+    let maxY = Number.MIN_VALUE;
+    for (let tile of tiles) {
+        if (tile.x < minX) {
+            minX = tile.x;
+        }
+        if (tile.x > maxX) {
+            maxX = tile.x;
+        }
+        if (tile.y < minY) {
+            minY = tile.y;
+        }
+        if (tile.y > maxY) {
+            maxY = tile.y;
+        }
+    }
+    const xCount = maxX - minX + 1;
+    const yCount = maxY - minY + 1;
+    const mergedDEM = new Float32Array(xCount * demWidth * yCount * demHeight).fill(0);
+    for (let tile of tiles) {
+        _insertDEM(tile.DEM, demWidth, demHeight, mergedDEM, xCount * demWidth, yCount * demHeight, (tile.x - minX) * demWidth, (tile.y - minY) * demHeight);
+    }
+    return mergedDEM;
+}

package/Math/tessellation/tiler.js

@@ -0,0 +1,50 @@
+"use strict";
+// /**
+//  * Find length in x and y for a tile in given zoom level (in wgs84)
+//  * Find tile cuts for given line represented by two points
+//  * Find inner position of point in tile
+//  * 
+//  */
+// import { LongLat } from "../../types";
+// export function tileLength(zoom: number): LongLat {
+//     const tileSize = 256; // in pixels
+//     const worldSize = tileSize * Math.pow(2, zoom);
+//     const latLength = 180 / worldSize;
+//     const lonLength = 360 / worldSize;
+//     return [lonLength, latLength];
+// }
+// // export function tileCuts(p1: LongLat, p2: LongLat, zoom: number): LongLat[] {
+// //     const cuts: LongLat[] = [];
+// //     const tileSize = 256;
+// //     const worldSize = tileSize * Math.pow(2, zoom);
+// //     const latLength = 180 / worldSize;
+// //     const lonLength = 360 / worldSize;
+// //     const x1 = (p1[0] + 180) / lonLength;
+// //     const y1 = (90 - p1[1]) / latLength;
+// //     const x2 = (p2[0] + 180) / lonLength;
+// //     const y2 = (90 - p2[1]) / latLength;
+// //     const dx = x2 - x1;
+// //     const dy = y2 - y1;
+// //     const steps = Math.max(Math.abs(dx), Math.abs(dy));
+// //     const xStep = dx / steps;
+// //     const yStep = dy / steps;
+// //     let x = x1;
+// //     let y = y1;
+// //     for (let i = 0; i <= steps; i++) {
+// //         const tileX = Math.floor(x);
+// //         const tileY = Math.floor(y);
+// //         const cutX = tileX * lonLength - 180;
+// //         const cutY = 90 - tileY * latLength;
+// //         const cut: LongLat = [cutX, cutY];
+// //         if (cuts.length === 0 || (cuts[cuts.length - 1][0] !== cut[0] || cuts[cuts.length - 1][1] !== cut[1])) {
+// //             cuts.push(cut);
+// //         }
+// //         x += xStep;
+// //         y += yStep;
+// //     } 
+// //     return cuts;
+// // }
+// // function fillTriangle(p1: LongLat, p2: LongLat, p3: LongLat, zoom: number): {positions:LongLat[], indices:number[]} {
+// //     // this function fills the triangle triangle iteratively
+// //     // 
+// // }