@pirireis/webglobeplugins 0.17.0 → 1.0.2

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

@@ -1,78 +1,143 @@
-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 };
+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
+}

package/Math/{circle.js → circle.ts}

@@ -1,33 +1,49 @@
-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 };
+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 };

package/Math/{constants.js → constants.ts}

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