@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/Math/types.ts

@@ -1,66 +0,0 @@
-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 Plane = {
-    normal: Vec3;
-    distance: number;
-};
-
-type LongLat = [number, number]; // [longitude, latitude]
-
-type Quaternion = [number, number, number, number];
-
-type Arc = {
-    p0: Vec3;
-    p1: Vec3;
-    normal: Vec3;
-    coverPlane: Plane;
-    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
-}

package/Math/vec3.ts

@@ -1,180 +0,0 @@
-import { Vec3, LongLat, Quaternion } from './types';
-import { EPSILON } from './constants';
-
-function create(x = 0, y = 0, z = 1): Vec3 {
-    return [x, y, z];
-}
-
-function set(out: Vec3, x: number, y: number, z: number) {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-}
-
-function clone(a: Vec3): Vec3 {
-    return [a[0], a[1], a[2]];
-}
-
-function copy(out: Vec3, a: Vec3): Vec3 {
-    out[0] = a[0];
-    out[1] = a[1];
-    out[2] = a[2];
-    return out;
-}
-
-function add(out: Vec3, a: Vec3, b: Vec3): Vec3 {
-    out[0] = a[0] + b[0];
-    out[1] = a[1] + b[1];
-    out[2] = a[2] + b[2];
-    return out;
-}
-
-function subtract(out: Vec3, a: Vec3, b: Vec3) {
-    out[0] = a[0] - b[0];
-    out[1] = a[1] - b[1];
-    out[2] = a[2] - b[2];
-}
-
-function dot(a: Vec3, b: Vec3): number {
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-
-function cross(out: Vec3, a: Vec3, b: Vec3) {
-    const x = a[1] * b[2] - a[2] * b[1];
-    const y = a[2] * b[0] - a[0] * b[2];
-    const z = a[0] * b[1] - a[1] * b[0];
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-}
-
-
-function multiplyScalar(out: Vec3, a: Vec3, b: number) {
-    out[0] = a[0] * b;
-    out[1] = a[1] * b;
-    out[2] = a[2] * b;
-}
-
-function divideScalar(out: Vec3, a: Vec3, b: number) {
-    if (b === 0) {
-        throw new Error('Division by zero');
-    }
-    out[0] = a[0] / b;
-    out[1] = a[1] / b;
-    out[2] = a[2] / b;
-}
-
-function lengthSquared(a: Vec3): number {
-    return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
-}
-
-function length(a: Vec3): number {
-    return Math.sqrt(lengthSquared(a));
-}
-
-function normalize(outVec: Vec3, inVec: Vec3): void {
-    const len = length(inVec);
-    if (len === 0) {
-        // console.warn('Cannot normalize a zero vector');
-        outVec[0] = 0;
-        outVec[1] = 0;
-        outVec[2] = 0;
-        return;
-    }
-    outVec[0] = inVec[0] / len;
-    outVec[1] = inVec[1] / len;
-    outVec[2] = inVec[2] / len;
-}
-
-
-function distanceSquared(a: Vec3, b: Vec3): number {
-    const dx = a[0] - b[0];
-    const dy = a[1] - b[1];
-    const dz = a[2] - b[2];
-    return dx * dx + dy * dy + dz * dz;
-}
-
-
-function distance(a: Vec3, b: Vec3): number {
-    return Math.sqrt(distanceSquared(a, b));
-}
-
-function equals(a: Vec3, b: Vec3): boolean {
-    return (
-        Math.abs(a[0] - b[0]) < EPSILON &&
-        Math.abs(a[1] - b[1]) < EPSILON &&
-        Math.abs(a[2] - b[2]) < EPSILON
-    );
-}
-
-
-function fromUnitVectorToLongLat(out: LongLat, a: Vec3) {
-    const len = length(a);
-    if (len === 0) {
-        throw new Error('Cannot convert a zero vector to unit vector');
-    }
-    out[0] = Math.atan2(a[1], a[0]); // Longitude
-    out[1] = Math.asin(a[2] / len); // Latitude
-}
-
-function fromLongLatToUnitVector(out: Vec3, longLat: LongLat) {
-    const longitude = longLat[0];
-    const latitude = longLat[1];
-    const cosLat = Math.cos(latitude);
-    out[0] = cosLat * Math.cos(longitude);
-    out[1] = cosLat * Math.sin(longitude);
-    out[2] = Math.sin(latitude);
-}
-
-function applyQuaternion(out: Vec3, a: Vec3, q: Quaternion) {
-    const x = a[0], y = a[1], z = a[2];
-    const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
-    // Calculate the quaternion multiplication
-    const ix = qw * x + qy * z - qz * y;
-    const iy = qw * y + qz * x - qx * z;
-    const iz = qw * z + qx * y - qy * x;
-    const iw = -qx * x - qy * y - qz * z;
-    // Apply the quaternion to the vector
-    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-}
-
-
-function randomUnit(out: Vec3) {
-    const theta = Math.random() * 2 * Math.PI;
-    const phi = Math.acos(2 * Math.random() - 1);
-    out[0] = Math.sin(phi) * Math.cos(theta);
-    out[1] = Math.sin(phi) * Math.sin(theta);
-    out[2] = Math.cos(phi);
-}
-
-
-function str(a: Vec3): string {
-    return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
-}
-
-
-export {
-    create,
-    set,
-    clone,
-    copy,
-    add,
-    subtract,
-    dot,
-    cross,
-    multiplyScalar,
-    divideScalar,
-    lengthSquared,
-    length,
-    normalize,
-    distanceSquared,
-    distance,
-    equals,
-    fromUnitVectorToLongLat,
-    fromLongLatToUnitVector,
-    applyQuaternion,
-    randomUnit,
-    str
-}

package/circle-line-chain/readme.md

@@ -1,57 +0,0 @@
-# Road Map
-
-## CircleLine
-Atomic unit is the circle-line constructed from a circle and a line with start and end point which indicates the radius.
-
-### Attributes
-Main attributes: StartPoint, EndPoint, Radius
-Other attributes: Color, opacity, dash opacity, dash ratio
-
-### API
-API is the manipulation of above attributes
-
-### Implementation
-
-Buffer Orchestrater is enough.
-
-## ChainOfCircleLines
-Composit unit is a chain of circle-lines. 
-
-### Attributes
-
-Main attributes: one to many relation of a chain and its circle-lines
-
-
-# API
-- startChain(chainID) //
-- addPointToChain(chainID) 
-- editPointOfChain(chainID, pointID) // 
-- divideChain(chainID, )
-
-
-
-# Concept Formation
-
-Circle-Line has ( startPoint, endPoint )
-
-Chain Has [...circle-line] -> [ c0, c1, c2 ...] -> c0.endPoint == c1.startPoint, c1.endPoint == c2.startPoint
-
-## Modes 
- 
- Focus Mod
- - mouse icon hides and edge point icon is displayed
- 
- 
- ## interaction points ( this can be a new module)
-      changes the mouse icon
-      plugin creates them. 
-      interaction points carryin carries information about how to interact with the plugin.
-  
- - On Edges
-      Updates coordinates on right click and carry
-      deletes on right
- - on mid point of a radius line (+)
-      Addes an edge to mid points. ( deletes the old one and inserts 2)
- 
- UserInterface
- - drawNewMethod

package/depth-locator/readme.md

@@ -1,26 +0,0 @@
-# Programs
-
-1) points with depth (3d/2d), draw to framebuffer and use this until projection or data changes, has picking
-2) glow hearth-beat effect points on the target point
-3) glow plane effect on surface projection of target point
-4) a line from the target point to the surface
-5) info box on the target point
-
-all except 1 are optional
-
-# Inputs
-
-1) Target point ( long, lat, depth in meter)
-2) info box content
-
-# Derived Cases
-
-## Time dimension
-
-Either:
-1) load all points at once ordered by time. Draw range of points
-2) Select points on time window and load them. Draw them
-
-Approach 1 is simple yet it needs time series as input.
-Approach 2 flexible, memory efficient. Client side is complex.
-

package/dist/Math/angle-calculation.js

@@ -1,13 +0,0 @@
-function bearingRealAngle(long, lat, endLong, endLat) {
-    const rLong = Radians * long;
-    const rLat = Radians * lat;
-    const rEndLong = Radians * endLong;
-    const rEndLat = Radians * endLat;
-    const delta_long = rEndLong - rLong;
-    const x = Math.sin(delta_long) * Math.cos(rEndLat);
-    const y = Math.cos(rLat) * Math.sin(rEndLat) - Math.sin(rLat) * Math.cos(rEndLat) * Math.cos(delta_long);
-    let initialBearing = Math.atan2(x, y) / Radians;
-    initialBearing = (initialBearing + 360) % 360;
-    return initialBearing;
-}
-export { bearingRealAngle };

package/dist/Math/bounds/line-bbox.js

@@ -1,186 +0,0 @@
-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/dist/Math/index.js

@@ -1 +0,0 @@
-"use strict";