@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{Math/circle-cdf-points.ts → webglobeplugins/Math/circle-cdf-points.js}

@@ -1,143 +1,78 @@
-import { Globe, CentigradeDegree } from "../types";
-import { RADIAN } 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 / RADIAN + 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
-}
+import { RADIAN } from "./methods";
+function createCummulativeTemplate(numberOfPoints, strength, denseRatio = 0.5 // Ratio of points to be densely packed at the start.
+) {
+    // 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, numberOfPoints, denseRatio = 0.5, strengthMultiplier = 2.4) {
+    const stash = [];
+    for (let i = 0; i < levels; i++) {
+        const template = createCummulativeTemplate(numberOfPoints, i * strengthMultiplier, denseRatio);
+        stash.push(template);
+    }
+    return stash;
+}
+function globeFindPointByPolar(out, globe, centerLong, centerLat, radius, ratios) {
+    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, globe, centerLong, centerLat, radius, rotation, ratios) {
+    const rotCentigrade = rotation / RADIAN + 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 → webglobeplugins/Math/circle.js}

@@ -1,49 +1,33 @@
-import { Circle, CircleClosestAzimuthAngleProperties, LongLat, Plane, Vec3 } from '../Math/types.js';
-import { RADIAN } 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] * RADIAN, circle.center[1] * RADIAN]);
-    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 };
+import { RADIAN } from './methods';
+import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar, clone } from './vec3';
+const _0vec3 = [0, 0, 0];
+function closestAzimuthAngle(circleProperties, point) {
+    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) {
+    const normal = Array(3);
+    fromLongLatToUnitVector(normal, [circle.center[0] * RADIAN, circle.center[1] * RADIAN]);
+    const N = 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 → webglobeplugins/Math/constants.js}

@@ -1,12 +1,4 @@
-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
-}
-
-
+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 };