@pirireis/webglobeplugins 0.8.15-alpha → 0.8.17

package/Math/arc.ts

@@ -0,0 +1,239 @@
+
+import { Vector3D } from "./vector3d";
+import { Plane } from "./plane";
+import { Quaternion } from "./quaternion";
+import { Radians } from "./types";
+import { Ray } from "./ray";
+
+const _quaternion = /*@__PURE__*/ new Quaternion(0, 0, 0, 0);
+const _ray = /*@__PURE__*/ new Ray(new Vector3D(0, 0, 0), new Vector3D(0, 0, 0));
+const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
+const _0plane = /*@__PURE__*/ new Plane(_0vector, 0);
+
+const _A_x_otherA = /*@__PURE__*/ new Vector3D(0, 0, 0);
+const _A_x_otherB = /*@__PURE__*/ new Vector3D(0, 0, 0);
+const _AxB = /*@__PURE__*/ new Vector3D(0, 0, 0);
+
+
+
+
+
+export class Arc {
+    pointA: Vector3D;
+    pointB: Vector3D;
+    _dot: number;
+    _AxB: Vector3D;
+    _theta: Radians;
+    _imageinaryPlane: Plane;
+    constructor(
+        pointA: Vector3D,
+        pointB: Vector3D,
+    ) {
+        this.pointA = pointA.normalize();
+        this.pointB = pointB.normalize();
+        this._AxB = pointA.clone().cross(pointB);
+        this._dot = this.pointA.dot(this.pointB);
+        this._theta = Math.acos(this._dot);
+        this._imageinaryPlane = new Plane(this._AxB.clone().normalize(), 0);
+    }
+
+
+    copy(arc: Arc): Arc {
+        this.pointA.copy(arc.pointA);
+        this.pointB.copy(arc.pointB);
+        this._AxB.copy(arc._AxB);
+        this._dot = arc._dot;
+        this._theta = arc._theta;
+        this._imageinaryPlane.copy(arc._imageinaryPlane);
+        return this;
+    }
+
+
+    clone(): Arc {
+        return new Arc(this.pointA.clone(), this.pointB.clone());
+    }
+
+
+    equals(arc: Arc): boolean {
+        return (this.pointA.equals(arc.pointA) && this.pointB.equals(arc.pointB)) || (this.pointA.equals(arc.pointB) && this.pointB.equals(arc.pointA));
+    }
+
+
+    slerp(t: number): Vector3D {
+
+        const pointA = this.pointA;
+        const pointB = this.pointB;
+
+        const step = t / this._theta;
+        const sinTheta = Math.sin(this._theta);
+        const sinStep = Math.sin(step * this._theta);
+        const sinOneMinusStep = Math.sin((1 - step) * this._theta);
+
+        const x = (sinOneMinusStep * pointA[0] + sinStep * pointB[0]) / sinTheta;
+        const y = (sinOneMinusStep * pointA[1] + sinStep * pointB[1]) / sinTheta;
+        const z = (sinOneMinusStep * pointA[2] + sinStep * pointB[2]) / sinTheta;
+
+        return new Vector3D(x, y, z);
+
+    }
+
+
+
+
+    // TODO: EDGE CASE: the points are on same location 
+    intersectionMedium(medium: Plane, target: Arc | null = null): Arc | null {
+        // Orianted in right hand rule
+        if (this.pointA.equals(this.pointB)) return null; // arc is too short
+
+        const result = this._imageinaryPlane.intersectionPlane(medium);
+        if (result instanceof Plane) {
+            return this.clone();
+        }
+
+        if (result === null) { console.log("null intersection"); return null; } // planes are parallel
+
+        const intersectionPoints = _ray.set(result.origin, result.direction).intersectionSphere(_0vector.set(0, 0, 0), 1);
+        if (intersectionPoints === null) {
+            return null; // no intersection
+        }
+
+
+        const [A, B] = (() => {
+            Vector3D.crossVectors(...intersectionPoints, _AxB);
+            if (_AxB.dot(this._AxB) >= 0) {
+                return [intersectionPoints[0], intersectionPoints[1]];
+            } else {
+                return [intersectionPoints[1], intersectionPoints[0]];
+            }
+        })();
+
+
+        Vector3D.crossVectors(this.pointA, A, _A_x_otherA);
+        Vector3D.crossVectors(this.pointA, B, _A_x_otherB);
+
+        // think as this.pointA is on Vector3D(0, 0, 1) on some space
+        const _yA = this.pointA.dot(A);
+        const _yB = this.pointA.dot(B);
+
+        const _xA = _A_x_otherA.dot(this._AxB);
+        const _xB = _A_x_otherB.dot(this._AxB);
+
+
+        if (_xA < 0 && _xB < 0) {
+            return null; // no intersection
+        }
+        if (_yA < this._dot && _yB < this._dot) {
+            return null; // no intersection
+        }
+
+
+        const results: [Vector3D, Vector3D] = [_xA < 0 ? this.pointA.clone() : A, _yB <= this._dot ? this.pointB.clone() : B];
+
+        if (target === null) {
+            target = new Arc(...results);
+        } else {
+            target.setFromUnitVectors(...results);
+        }
+
+        return target;
+    }
+
+
+
+
+    setFromUnitVectors(
+        pointA: Vector3D,
+        pointB: Vector3D,
+    ) {
+
+        // following values might be calculated lazily
+        this.pointA.copy(pointA).normalize();
+        this.pointB.copy(pointB).normalize();
+        this._AxB = pointA.clone().cross(pointB);
+        this._dot = this.pointA.dot(this.pointB);
+        this._theta = Math.acos(this._dot);
+        this._imageinaryPlane = new Plane(this._AxB.clone().normalize(), 0);
+    }
+
+
+
+    populatePoints3D(pointCount: number, startProportion: number = 0, endProportion: number = 1): Float32Array {
+
+        const points3D = new Float32Array(pointCount * 3);
+        const step = (endProportion - startProportion) / (pointCount - 1);
+        const _AxBnormalized = this._AxB.clone().normalize();
+
+        _0vector.copy(this.pointA);
+
+        if (startProportion > 0) {
+            _quaternion.setFromAxisAngle(_AxBnormalized, this._theta * startProportion);
+            _0vector.applyQuaternion(_quaternion);
+        }
+        _quaternion.setFromAxisAngle(_AxBnormalized, this._theta * step);
+        let index = 0;
+        for (let i = 0; i < pointCount; i++) {
+            points3D[index++] = _0vector.x;
+            points3D[index++] = _0vector.y;
+            points3D[index++] = _0vector.z;
+            _0vector.applyQuaternion(_quaternion);
+        }
+
+        return points3D;
+    }
+    // cutBoundingBoxes(dotStep: number = 0.025): { minX: number, minY: number, maxX: number, maxY: number }[] {
+    //     const pointA = this.pointA;
+    //     const to = this.pointB;
+    //     const a = [pointA.x, pointA.y, pointA.z];
+    //     const b = [to.x, to.y, to.z];
+
+    //     const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
+    //     const step = dotStep / theta;
+
+    //     if (step >= 1) {
+    //         return [{ minX: Math.min(pointA.x, to.x), minY: Math.min(pointA.y, to.y), maxX: Math.max(pointA.x, to.x), maxY: Math.max(pointA.y, to.y) }];
+    //     }
+
+    //     let points = [pointA] as Vector3D[];
+    //     let currentStep = 0;
+    //     while (currentStep < 1) {
+    //         currentStep += step;
+    //         points.push(this.slerp(currentStep, currentStep + step, 1)[0]);
+    //     }
+
+    //     return points.map(point => ({ minX: point.x, minY: point.y, maxX: point.x, maxY: point.y }));
+    // }
+
+    // boundingBox(): { minLon: Radians, minLat: Radians, maxLon: Radians, maxLat: Radians } {
+
+    //     // Do two poınts remaın on the same half when the circle is cut by Z axis?
+    //     const Z = Math.sign(this.pointA.z + this.pointB.z);
+    //     _0vector.set(0, 0, Z);
+    //     const zDot = this.greatCirclePlaneNormalVector.dot(_0vector);
+    //     const zDif = Math.abs(this.pointA.z - this.pointB.z);
+    //     const minPossibleZDistanceIfOnTheSameHalf = (1 - this.dot) * zDot;
+
+    //     const aLonLat = this.pointA.toLonLat();
+    //     const bLonLat = this.pointB.toLonLat();
+
+    //     if (zDif >= minPossibleZDistanceIfOnTheSameHalf) {
+    //         return {
+    //             minLon: Math.min(aLonLat.lon, bLonLat.lon),
+    //             minLat: Math.min(aLonLat.lat, bLonLat.lat),
+    //             maxLon: Math.max(aLonLat.lon, bLonLat.lon),
+    //             maxLat: Math.max(aLonLat.lat, bLonLat.lat)
+    //         }
+    //     }
+
+    //     // if not, we need to calculate Z peek of the arc
+    //     const z = Math.asin(zDot * Z);
+    //     return {
+    //         minLon: Math.min(aLonLat.lon, bLonLat.lon),
+    //         minLat: Math.min(aLonLat.lat, bLonLat.lat, z),
+    //         maxLon: Math.max(aLonLat.lon, bLonLat.lon),
+    //         maxLat: Math.max(aLonLat.lat, bLonLat.lat, z)
+
+    //     }
+    // }
+
+}
+

package/Math/bounds/line-bbox.js

@@ -0,0 +1,225 @@
+function isClose(a, b, rtol = 1e-5, atol = 1e-8) {
+    // JavaScript equivalent of NumPy's isclose
+    return Math.abs(a - b) <= (atol + rtol * Math.abs(b));
+}
+
+function mod(n, m) {
+    // Proper modulo operation that handles negative numbers
+    return ((n % m) + m) % m;
+}
+
+function calculateInitialBearing(phi1, lambda1, phi2, lambda2) {
+    // Calculates the initial bearing (forward azimuth) from point 1 to point 2
+    if (isClose(Math.cos(phi1), 0)) { // Starting from a pole
+        if (phi1 > 0) { // North pole
+            return Math.PI; // Bearing is South
+        } else { // South pole
+            return 0; // Bearing is North
+        }
+    }
+
+    const deltaLambda = lambda2 - lambda1;
+    const y = Math.sin(deltaLambda) * Math.cos(phi2);
+    const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
+    const theta = Math.atan2(y, x);
+    return theta;
+}
+
+function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
+    // Calculates the bounding box around the great circle arc between two points
+    // on a spherical surface, handling edge cases like poles and antimeridian crossing.
+    // Args: Latitudes and longitudes in radians
+    // Returns: [phiMin, phiMax, lambdaMin, lambdaMax] in radians
+
+    // === Edge Case: Same Points ===
+    if (isClose(phi1Rad, phi2Rad) && isClose(lambda1Rad, lambda2Rad)) {
+        return [phi1Rad, phi1Rad, lambda1Rad, lambda1Rad];
+    }
+
+    // === Edge Case: Antipodal Points ===
+    const deltaLambdaNorm = mod(lambda1Rad - lambda2Rad + Math.PI, 2 * Math.PI) - Math.PI;
+    if (isClose(phi1Rad, -phi2Rad) && isClose(Math.abs(deltaLambdaNorm), Math.PI)) {
+        // Path covers all longitudes and passes through poles
+        return [-Math.PI / 2, Math.PI / 2, -Math.PI, Math.PI];
+    }
+
+    // === Longitude Bounds ===
+    let lambda1Adj = lambda1Rad;
+    let lambda2Adj = lambda2Rad;
+
+    // Handle antimeridian crossing
+    let deltaLambda = lambda2Rad - lambda1Rad;
+    if (deltaLambda > Math.PI) {
+        deltaLambda -= 2 * Math.PI;
+    } else if (deltaLambda <= -Math.PI) {
+        deltaLambda += 2 * Math.PI;
+    }
+
+    const crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
+
+    if (crossesAntimeridian) {
+        // Add 2*pi to the smaller longitude
+        if (lambda1Rad < lambda2Rad) {
+            lambda1Adj += 2 * Math.PI;
+        } else {
+            lambda2Adj += 2 * Math.PI;
+        }
+    }
+
+    const lambdaMin = Math.min(lambda1Adj, lambda2Adj);
+    const lambdaMax = Math.max(lambda1Adj, lambda2Adj);
+
+    // === Latitude Bounds ===
+    let phiMin = Math.min(phi1Rad, phi2Rad);
+    let phiMax = Math.max(phi1Rad, phi2Rad);
+
+    // === Vertex Check ===
+    // Check the maximum/minimum latitude reached by the great circle
+    const theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
+    const theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
+
+    const cosPhi1 = Math.cos(phi1Rad);
+    if (!isClose(cosPhi1, 0)) { // Starting point is not a pole
+        // Compute the absolute latitude of the vertex
+        const argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
+        const phiVtxAbs = Math.acos(Math.min(Math.max(argAcos, -1.0), 1.0));
+
+        // Check if the path crosses the northern vertex
+        if (isClose(theta12, 0) && phiVtxAbs > phiMax) { // Starting due north
+            phiMax = phiVtxAbs;
+        } else if (isClose(Math.abs(theta12), Math.PI) && -phiVtxAbs < phiMin) { // Starting due south
+            phiMin = -phiVtxAbs;
+        } else {
+            // General case: Check if the path crosses the vertex
+            const finalBearingAtP2 = mod(theta21 + Math.PI + Math.PI, 2 * Math.PI) - Math.PI;
+
+            // Northern vertex check
+            if ((-Math.PI / 2 < theta12 && theta12 < Math.PI / 2) &&
+                !(finalBearingAtP2 >= -Math.PI / 2 && finalBearingAtP2 <= Math.PI / 2)) {
+                if (phiVtxAbs > phiMax) {
+                    phiMax = phiVtxAbs;
+                }
+            }
+
+            // Southern vertex check
+            if (!(theta12 >= -Math.PI / 2 && theta12 <= Math.PI / 2) &&
+                (-Math.PI / 2 < finalBearingAtP2 && finalBearingAtP2 < Math.PI / 2)) {
+                if (-phiVtxAbs < phiMin) {
+                    phiMin = -phiVtxAbs;
+                }
+            }
+        }
+    }
+
+    return [phiMin, phiMax, lambdaMin, lambdaMax];
+}
+
+
+
+
+// --- Example Usage ---
+function degreesToRadians(deg) {
+    return deg * Math.PI / 180;
+}
+
+function radiansToDegrees(rad) {
+    return rad * 180 / Math.PI;
+}
+
+
+export { getGreatCircleArcBBox };
+
+// Test Case 1: London to Tokyo
+const lat1Deg = 51.5, lon1Deg = -0.1;
+const lat2Deg = 35.7, lon2Deg = 139.7;
+
+const phi1 = degreesToRadians(lat1Deg);
+const lambda1 = degreesToRadians(lon1Deg);
+const phi2 = degreesToRadians(lat2Deg);
+const lambda2 = degreesToRadians(lon2Deg);
+
+const [phiMinRad, phiMaxRad, lambdaMinRad, lambdaMaxRad] = getGreatCircleArcBBox(phi1, lambda1, phi2, lambda2);
+
+const phiMinDeg = radiansToDegrees(phiMinRad);
+const phiMaxDeg = radiansToDegrees(phiMaxRad);
+const lambdaMinDeg = radiansToDegrees(lambdaMinRad);
+const lambdaMaxDeg = radiansToDegrees(lambdaMaxRad);
+
+console.log("Input Points (Radians):");
+console.log(`  P1: Latitude=${lat1Deg}, Longitude=${lon1Deg}`);
+console.log(`  P2: Latitude=${lat2Deg}, Longitude=${lon2Deg}`);
+console.log(`  P1: Latitude=${phi1.toFixed(4)}, Longitude=${lambda1.toFixed(4)}`);
+console.log(`  P2: Latitude=${phi2.toFixed(4)}, Longitude=${lambda2.toFixed(4)}`);
+console.log("-".repeat(20));
+console.log("Bounding Box (Radians):");
+// console phys://console.log(`  Minimum Latitude (phi_min): ${phiMinRad.toFixed(4)}`);
+console.log(`  Maximum Latitude (phi_max): ${phiMaxRad.toFixed(4)}`);
+console.log(`  Minimum Longitude (lambda_min): ${lambdaMinRad.toFixed(4)}`);
+console.log(`  Maximum Longitude (lambda_max): ${lambdaMaxRad.toFixed(4)}`);
+console.log("-".repeat(20));
+console.log("Bounding Box (Degrees):");
+console.log(`  Minimum Latitude: ${phiMinDeg.toFixed(2)}°`);
+console.log(`  Maximum Latitude: ${phiMaxDeg.toFixed(2)}°`);
+console.log(`  Minimum Longitude: ${lambdaMinDeg.toFixed(2)}°`);
+console.log(`  Maximum Longitude: ${lambdaMaxDeg.toFixed(2)}°`);
+
+// --- Antimeridian Crossing Test ---
+console.log("\n" + "=".repeat(30));
+console.log("Antimeridian Crossing Test");
+const lat1DegAm = -18, lon1DegAm = 178;
+const lat2DegAm = -14, lon2DegAm = -172;
+
+const phi1Am = degreesToRadians(lat1DegAm);
+const lambda1Am = degreesToRadians(lon1DegAm);
+const phi2Am = degreesToRadians(lat2DegAm);
+const lambda2Am = degreesToRadians(lon2DegAm);
+
+const [phiMinRadAm, phiMaxRadAm, lambdaMinRadAm, lambdaMaxRadAm] = getGreatCircleArcBBox(phi1Am, lambda1Am, phi2Am, lambda2Am);
+
+const phiMinDegAm = radiansToDegrees(phiMinRadAm);
+const phiMaxDegAm = radiansToDegrees(phiMaxRadAm);
+const lambdaMinDegAm = radiansToDegrees(lambdaMinRadAm);
+const lambdaMaxDegAm = radiansToDegrees(lambdaMaxRadAm);
+
+console.log(`Input Points (Degrees): P1=(${lat1DegAm}, ${lon1DegAm}), P2=(${lat2DegAm}, ${lon2DegAm})`);
+console.log("Bounding Box (Radians):");
+console.log(`  phi_min=${phiMinRadAm.toFixed(4)}, phi_max=${phiMaxRadAm.toFixed(4)}`);
+console.log(`  lambda_min=${lambdaMinRadAm.toFixed(4)}, lambda_max=${lambdaMaxRadAm.toFixed(4)}`);
+console.log("Bounding Box (Degrees):");
+console.log(`  Min Latitude: ${phiMinDegAm.toFixed(2)}°`);
+console.log(`  Max Latitude: ${phiMaxDegAm.toFixed(2)}°`);
+console.log(`  Min Longitude: ${lambdaMinDegAm.toFixed(2)}° (178° expected)`);
+console.log(`  Max Longitude: ${lambdaMaxDegAm.toFixed(2)}° (188° expected, which is -172° + 360°)`);
+
+// --- Polar Crossing Test ---
+console.log("\n" + "=".repeat(30));
+console.log("Polar Crossing Test");
+const lat1DegP = 80, lon1DegP = 20;
+const lat2DegP = 80, lon2DegP = -100;
+
+const phi1P = degreesToRadians(lat1DegP);
+const lambda1P = degreesToRadians(lon1DegP);
+const phi2P = degreesToRadians(lat2DegP);
+const lambda2P = degreesToRadians(lon2DegP);
+
+const [phiMinRadP, phiMaxRadP, lambdaMinRadP, lambdaMaxRadP] = getGreatCircleArcBBox(phi1P, lambda1P, phi2P, lambda2P);
+
+const phiMinDegP = radiansToDegrees(phiMinRadP);
+const phiMaxDegP = radiansToDegrees(phiMaxRadP);
+const lambdaMinDegP = radiansToDegrees(lambdaMinRadP);
+const lambdaMaxDegP = radiansToDegrees(lambdaMaxRadP);
+
+console.log(`Input Points (Degrees): P1=(${lat1DegP}, ${lon1DegP}), P2=(${lat2DegP}, ${lon2DegP})`);
+console.log("Bounding Box (Radians):");
+console.log(`  phi_min=${phiMinRadP.toFixed(4)}, phi_max=${phiMaxRadP.toFixed(4)}`);
+console.log(`  lambda_min=${lambdaMinRadP.toFixed(4)}, lambda_max=${lambdaMaxRadP.toFixed(4)}`);
+console.log("Bounding Box (Degrees):");
+console.log(`  Min Latitude: ${phiMinDegP.toFixed(2)}°`);
+console.log(`  Max Latitude: ${phiMaxDegP.toFixed(2)}° (Should be close to North Pole > 80°)`);
+console.log(`  Min Longitude: ${lambdaMinDegP.toFixed(2)}°`);
+console.log(`  Max Longitude: ${lambdaMaxDegP.toFixed(2)}°`);
+
+
+
+// --- line points intersection with bbox ---
+

package/Math/constants.ts

@@ -0,0 +1,8 @@
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
+
+export {
+    WORLD_RADIUS_3D,
+    WORLD_RADIUS_MERCATOR
+}
+

package/Math/methodology/arc-part-on-screen.ts

@@ -0,0 +1,47 @@
+import { Plane } from "../plane";
+import { Vector3D } from "../vector3d";
+import { Arc } from "../arc";
+
+
+
+const Radians = Math.PI / 180;
+
+export class ArcPartOnScreen {
+    private _oldLookInfo: { CenterLong: number, CenterLat: number, Distance: number, Tilt: number, NorthAng: number };
+    private _boundPlane: Plane;
+
+    constructor() {
+        this._boundPlane = new Plane(new Vector3D(0, 0, 0), 0);
+        this._oldLookInfo = { CenterLong: 0, CenterLat: -190, Distance: 0, Tilt: 0, NorthAng: 0 };
+    }
+
+
+    updateBoundPlane(lookInfo): boolean {
+        if (this._oldLookInfo && this._oldLookInfo.CenterLong === lookInfo.CenterLong && this._oldLookInfo.CenterLat === lookInfo.CenterLat) {
+            return false;
+        }
+        /**
+         * lookInfo {CenterLong: 47.75355881750585, CenterLat: 42.3417076206803, Distance: 2286603.4020860917, Tilt: 0.05, NorthAng: -13.829359965098265}
+         */
+        this._oldLookInfo.CenterLong = lookInfo.CenterLong;
+        this._oldLookInfo.CenterLat = lookInfo.CenterLat;
+        this._oldLookInfo.Distance = lookInfo.Distance;
+        this._oldLookInfo.Tilt = lookInfo.Tilt;
+        this._oldLookInfo.NorthAng = lookInfo.NorthAng;
+
+        Plane.fromGlobeLookInfo(Radians * lookInfo.CenterLong, Radians * lookInfo.CenterLat, lookInfo.Distance, this._boundPlane);
+        return true;
+    }
+
+
+
+    getArcPartOnScreen(arc: Arc, target: Arc): boolean {
+        // _imaginaryPlane.set(arc.greatCirclePlaneNormalVector, arc.pointA.dot(arc.greatCirclePlaneNormalVector));
+        // const intersection = _imaginaryPlane.intersectionPlane(this._boundPlane);
+        // if (!(intersection instanceof Ray)) return false;
+        // _ray.copy(intersection as Ray);
+        // const [point1, point2] = _ray.intersectionSphere(_unitShphereCenter, _unitShphereRadius) as [Vector3D, Vector3D];
+        const result = arc.intersectionMedium(this._boundPlane, target);
+        return !(result === null);
+    }
+}

package/Math/methods.js

@@ -1,6 +1,5 @@
 
-const WORLD_RADIUS_3D = 6378.137;
-const WORLD_RADIUS_MERCATOR = 6378136.99911;
+import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './constants.ts';
 
 /**
  * @typedef {Array<number>} vec3 [x, y, z]
@@ -193,7 +192,6 @@ const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
 
 export {
     RADIANS,
-    WORLD_RADIUS_3D,
     normalize3,
     dot3,
     length3,