@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/Math/bounds/line-bbox.js

@@ -1,186 +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 ---
+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/circle-cdf-points.ts

@@ -0,0 +1,143 @@
+import { Globe, CentigradeDegree } from "../types";
+import { RADIANS } from "./methods";
+import { Meter } from "./types";
+
+
+
+function createCummulativeTemplate(
+    numberOfPoints: number,
+    strength: number,
+    denseRatio: number = 0.5 // Ratio of points to be densely packed at the start.
+
+): Float64Array {
+    // Handle edge cases for the number of points.
+    if (numberOfPoints <= 0) {
+        // If zero or a negative number of points is requested, return an empty array.
+        return new Float64Array([]);
+    }
+
+    // Create the array to hold the results. Float64Array is used for high-precision floating-point numbers.
+    const distribution = new Float64Array(numberOfPoints);
+
+    if (numberOfPoints === 1) {
+        // If only one point is requested, it represents the entire range [0, 1].
+        // We place it at the start (0.0).
+        distribution[0] = 0.0;
+        return distribution;
+    }
+
+    // The exponent determines the curve of the distribution.
+    // We add 1 to the strength so that a strength of 0 results in an exponent of 1 (linear).
+    // We use Math.max(0, strength) to ensure the strength is not negative.
+
+
+    // The last index is used to normalize the position to a 0-1 range.
+    const lastIndex = numberOfPoints - 1;
+    distribution[0] = 0.0; // The first point is always at 0.0.
+    let totalWeight = 0;
+    let i = 1
+    const denseCount = numberOfPoints * denseRatio;
+    for (i; i < denseCount; i++) {
+        // Calculate the ratio of the current index to the last index.
+        // The ratio is adjusted to create a non-linear distribution.
+        totalWeight += 1;
+        distribution[i] = totalWeight; // Store the raw value in the distribution array.
+    }
+
+    for (i; i < numberOfPoints; i++) {
+        // Calculate the ratio of the current index to the last index.
+
+        const ratio = 1 + ((i - denseCount) / lastIndex) / (1 - denseRatio) * 2;
+        const step = Math.pow(ratio, strength);
+
+        totalWeight += step;
+        distribution[i] = totalWeight; // Store the raw value in the distribution array.
+
+        // Apply the power function to create a non-linear distribution.
+        // The result is normalized to the range [0, 1].
+    }
+    for (let i = 1; i < numberOfPoints; i++) {
+        // Normalize the values to ensure they sum up to 1.
+        distribution[i] = distribution[i] / totalWeight;
+    }
+    return distribution;
+}
+
+
+
+function createCummulativeTemplateStash(
+    levels: number,
+    numberOfPoints: number,
+    denseRatio: number = 0.5,
+    strengthMultiplier: number = 2.4,
+): Float64Array[] {
+    const stash: Float64Array[] = [];
+    for (let i = 0; i < levels; i++) {
+        const template = createCummulativeTemplate(numberOfPoints, i * strengthMultiplier, denseRatio);
+        stash.push(template);
+    }
+    return stash;
+}
+
+function globeFindPointByPolar(
+    out: number[] | Float64Array,
+    globe: Globe,
+    centerLong: CentigradeDegree,
+    centerLat: CentigradeDegree,
+    radius: Meter,
+    ratios: number[]) {
+    for (let i = 0; i < ratios.length; i++) {
+        const point = globe.Math.FindPointByPolar(
+            centerLong,
+            centerLat,
+            radius,
+            ratios[i]
+        );
+        out[i * 2] = point.long;
+        out[i * 2 + 1] = point.lat;
+    }
+}
+
+function globeFindPointByPolarHalfCircle(
+    out: Float64Array,
+    globe: Globe,
+    centerLong: CentigradeDegree,
+    centerLat: CentigradeDegree,
+    radius: Meter,
+    rotation: number,
+    ratios: Float64Array) {
+
+    const rotCentigrade = rotation / RADIANS + 720;
+    for (let i = 0; i < ratios.length; i++) {
+        const point = globe.Math.FindPointByPolar(
+            centerLong,
+            centerLat,
+            radius,
+            (ratios[i] * 180 + rotCentigrade) % 360
+        );
+        out[i * 2] = point.long;
+        out[i * 2 + 1] = point.lat;
+    }
+    // fill reflection
+    let offset = out.length;
+    for (let i = 0; i < ratios.length - 1; i++) {
+        const point = globe.Math.FindPointByPolar(
+            centerLong,
+            centerLat,
+            radius,
+            ((- ratios[i]) * 180 + rotCentigrade) % 360,
+        );
+
+        out[offset - 2] = point.long;
+        out[offset - 1] = point.lat;
+        offset -= 2;
+    }
+}
+
+
+
+export {
+    createCummulativeTemplateStash,
+    globeFindPointByPolar,
+    globeFindPointByPolarHalfCircle
+}

package/Math/circle.ts

@@ -0,0 +1,49 @@
+import { Circle, CircleClosestAzimuthAngleProperties, LongLat, Plane, Vec3 } from '../Math/types.js';
+import { RADIANS } from './methods';
+import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar, clone, add } from './vec3';
+
+const _0vec3: Vec3 = [0, 0, 0];
+
+function closestAzimuthAngle(
+    circleProperties: CircleClosestAzimuthAngleProperties,
+    point: Vec3
+): number {
+    const distance = dot(circleProperties.normal, point);
+    copy(_0vec3, circleProperties.normal)
+    multiplyScalar(_0vec3, _0vec3, distance);
+    subtract(_0vec3, point, _0vec3);
+    normalize(_0vec3, _0vec3);
+    const N = circleProperties.northPointProjectedToOriginPlaneNormalized
+    const _dot = dot(_0vec3, N);
+    let angle = Math.acos(_dot);
+    const z = (_0vec3[0] * N[1] - _0vec3[1] * N[0]) * circleProperties.normal[2];
+    return z < 0 ? -angle : angle;
+}
+
+
+function createCircleClosestAzimuthAngleProperties(
+    circle: Circle,
+
+): CircleClosestAzimuthAngleProperties {
+    const normal: Vec3 = Array(3) as Vec3;
+    fromLongLatToUnitVector(normal,
+        [circle.center[0] * RADIANS, circle.center[1] * RADIANS]);
+    const N: Vec3 = clone(normal);
+
+    const distance = dot([0, 0, 1], normal);
+    multiplyScalar(N, N, distance);
+    // if (N[2] >= 0) {
+    subtract(N, [0, 0, 1], N);
+    // } else {
+    //     subtract(N, [0, 0, -1], N);
+    // }
+    normalize(N, N);
+    return {
+        normal: normal,
+        northPointProjectedToOriginPlaneNormalized: N,
+    };
+}
+
+
+
+export { closestAzimuthAngle, createCircleClosestAzimuthAngleProperties };

package/Math/constants.ts

@@ -0,0 +1,12 @@
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
+
+const EPSILON = 1e-10; // Used for floating point comparisons
+
+export {
+    WORLD_RADIUS_3D,
+    WORLD_RADIUS_MERCATOR,
+    EPSILON
+}
+
+

package/Math/index.js

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