@pirireis/webglobeplugins 0.11.1-alpha → 0.12.0-alpha

package/Math/arc-cdf-points.js

@@ -0,0 +1,252 @@
+// --- Utility Functions for 3D Vector Operations --- (Assumed to be the same as provided)
+/**
+ * Normalizes a 3D vector to unit length.
+ * @param v The input vector.
+ * @returns The normalized vector. Returns [0,0,0] if the input vector is a zero vector.
+ */
+function vec3Normalize(v) {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (len < 1e-9) { // Use a small epsilon to handle near-zero vectors
+        return [0, 0, 0];
+    }
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+/**
+ * Calculates the dot product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The dot product.
+ */
+function vec3Dot(v1, v2) {
+    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+}
+/**
+ * Calculates the cross product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The cross product vector.
+ */
+function vec3Cross(v1, v2) {
+    return [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0]
+    ];
+}
+/**
+ * Scales a 3D vector by a scalar.
+ * @param v The input vector.
+ * @param s The scalar value.
+ * @returns The scaled vector.
+ */
+function vec3Scale(v, s) {
+    return [v[0] * s, v[1] * s, v[2] * s];
+}
+/**
+ * Adds two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Add(v1, v2) {
+    return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
+}
+/**
+ * Subtracts the second 3D vector from the first.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Sub(v1, v2) {
+    return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
+}
+/**
+ * Clamps a numerical value within a specified range.
+ * @param value The value to clamp.
+ * @param min The minimum allowed value.
+ * @param max The maximum allowed value.
+ * @returns The clamped value.
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}
+/**
+ * Rotates a vector around a given axis by a specified angle using Rodrigues' rotation formula.
+ * The axis must be a unit vector for correct results.
+ * @param v The vector to rotate.
+ * @param axis The unit axis of rotation.
+ * @param angle The angle of rotation in radians.
+ * @returns The rotated vector.
+ */
+function rotateVector(v, axis, angle) {
+    const cosAngle = Math.cos(angle);
+    const sinAngle = Math.sin(angle);
+    const oneMinusCos = 1.0 - cosAngle;
+    const dotAxisV = vec3Dot(axis, v);
+    const crossAxisV = vec3Cross(axis, v);
+    // Rodrigues' rotation formula:
+    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
+    const term1 = vec3Scale(v, cosAngle);
+    const term2 = vec3Scale(crossAxisV, sinAngle);
+    const term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
+    return vec3Add(vec3Add(term1, term2), term3);
+}
+// --- Main Function for Arc Point Generation (CORRECTED) ---
+/**
+ * Generates points on the shortest arc between p0 and p1 on a unit sphere.
+ * The arc is formed by rotating p0 around axisA. The density of points
+ * is higher closer to the attractionPoint, controlled by an exponential falloff.
+ *
+ * @param p0 The starting point of the arc (will be normalized).
+ * @param p1 The ending point of the arc (will be normalized).
+ * @param axisA The axis of rotation (will be normalized).
+ * @param attractionPoint The point on the unit sphere that attracts sampled points (will be normalized).
+ * @param pointCount The total number of points to generate on the arc, including p0 and p1. > evenSpacedPointCount.
+ * @param attractionStrength Controls the density bias via exponential decay.
+ * A value of 0 results in uniform sampling.
+ * Higher positive values (e.g., 10, 50, 200) result in exponentially stronger attraction.
+ * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
+ */
+export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, attractionStrength, adaptiveStrength = true, evenSpacedPointCount = null) {
+    // 0. Add evenly distanced points
+    let t_even_index = 0;
+    evenSpacedPointCount = evenSpacedPointCount ?? Math.floor(pointCount / 2.5);
+    const t_event = Array.from({ length: evenSpacedPointCount }, (_, i) => i / (evenSpacedPointCount - 1));
+    const sampledPoints = [];
+    const epsilon = 1e-9;
+    // 1. Normalize all input vectors
+    let nP0 = vec3Normalize(p0);
+    let nP1 = vec3Normalize(p1);
+    let nAxisA = vec3Normalize(axisA);
+    let nAttractionPoint = vec3Normalize(attractionPoint);
+    // Handle edge cases for pointCount
+    if (pointCount < 1)
+        return [];
+    if (pointCount === 1)
+        return [nP0];
+    // 2. Determine the total rotation angle
+    const p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
+    const p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
+    if (vec3Dot(p0Projected, p0Projected) < epsilon * epsilon || vec3Dot(p1Projected, p1Projected) < epsilon * epsilon) {
+        console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc. Falling back to linear interpolation.");
+        for (let i = 0; i < pointCount; i++) {
+            const t = i / (pointCount - 1);
+            sampledPoints.push(vec3Normalize(vec3Add(vec3Scale(nP0, 1 - t), vec3Scale(nP1, t))));
+        }
+        return sampledPoints;
+    }
+    const nP0Projected = vec3Normalize(p0Projected);
+    const nP1Projected = vec3Normalize(p1Projected);
+    const crossProj = vec3Cross(nP0Projected, nP1Projected);
+    const totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
+    if (adaptiveStrength)
+        attractionStrength *= Math.pow(Math.max(1, (totalRotationAngle + 0.1)), 3); // Scale attraction strength by the arc length
+    if (Math.abs(totalRotationAngle) < epsilon) {
+        for (let i = 0; i < pointCount; i++)
+            sampledPoints.push(nP0);
+        return sampledPoints;
+    }
+    // 3. Find alpha_A: the angle parameter where the arc is closest to the attractionPoint
+    const alpha_A = (() => {
+        const dotProduct = vec3Dot(nP0, nAttractionPoint);
+        return Math.acos(dotProduct);
+    })();
+    // 4. Define the PDF and CDF based on an exponential decay model
+    const t_peak = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
+    const s = Math.max(0, attractionStrength);
+    const area1 = (1 - Math.exp(-s * t_peak));
+    const area2 = (1 - Math.exp(-s * (1 - t_peak)));
+    const totalIntegratedArea = (area1 + area2) / s;
+    const cdfAtPeak = (area1 / s) / totalIntegratedArea;
+    // 5. Generate deterministic points using inverse transform sampling
+    for (let i = 0; i < pointCount - evenSpacedPointCount; i++) {
+        const u = (pointCount === 1) ? 0.5 : (i + 1) / (pointCount - evenSpacedPointCount + 1);
+        let t_sampled;
+        if (s < epsilon) {
+            t_sampled = u;
+        }
+        else {
+            // Correctly calculate the area under the two parts of the exponential PDF
+            if (totalIntegratedArea < epsilon) {
+                t_sampled = u; // Fallback for extreme strength values
+            }
+            else {
+                if (u <= cdfAtPeak) {
+                    // *** BUG FIX START ***
+                    // Correctly invert the CDF for the first part: [0, t_peak]
+                    const u_prime = u / cdfAtPeak;
+                    t_sampled = t_peak + Math.log(Math.exp(-s * t_peak) + u_prime * (1 - Math.exp(-s * t_peak))) / s;
+                }
+                else {
+                    // Correctly invert the CDF for the second part: [t_peak, 1]
+                    const u_double_prime = (u - cdfAtPeak) / (1 - cdfAtPeak);
+                    t_sampled = t_peak - Math.log(1 - u_double_prime * (1 - Math.exp(-s * (1 - t_peak)))) / s;
+                }
+                // *** BUG FIX END ***
+            }
+        }
+        t_sampled = clamp(t_sampled, 0, 1);
+        while (t_even_index < evenSpacedPointCount && t_sampled > t_event[t_even_index]) {
+            const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
+            const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+            sampledPoints.push(currentPoint);
+            t_even_index++;
+        }
+        const actualRotationAngle = totalRotationAngle * t_sampled;
+        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+        sampledPoints.push(currentPoint);
+    }
+    while (t_even_index < evenSpacedPointCount) {
+        const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
+        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+        sampledPoints.push(currentPoint);
+        t_even_index++;
+    }
+    return sampledPoints;
+}
+// // --- Example Usage (for demonstration and testing) ---
+// // Example 1: Basic arc, very strong attraction point in the middle
+// const p0_ex1: Vec3 = [1, 0, 0];
+// const p1_ex1: Vec3 = [0, 1, 0]; // 90 deg rotation around Z-axis
+// const axisA_ex1: Vec3 = [0, 0, 1];
+// const attractionPoint_ex1: Vec3 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
+// const numPoints_ex1 = 21;
+// const strength_ex1 = 50.0; // Very strong attraction with the new exponential model
+// console.log("--- Example 1: Attraction point in the middle of the arc (Exponentially Strong) ---");
+// const points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
+// console.log(`Generated ${points1.length} points.`);
+// // With high strength, points should be extremely clustered around the attraction point.
+// const sequentialDistances1 = points1.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points1[i - 1], p);
+// });
+// console.log("Distances near the start:", sequentialDistances1.slice(1, 5).map(d => d.toFixed(5)));
+// console.log("Distances near the middle (attraction point):", sequentialDistances1.slice(9, 13).map(d => d.toFixed(5)));
+// console.log("Distances near the end:", sequentialDistances1.slice(-4).map(d => d.toFixed(5)));
+// // Expected: Distances near the middle should be MUCH smaller than at the ends.
+// // Example 2: Attraction point near p0, very high strength
+// const p0_ex2: Vec3 = [1, 0, 0];
+// const p1_ex2: Vec3 = [0, 1, 0];
+// const axisA_ex2: Vec3 = [0, 0, 1];
+// const attractionPoint_ex2: Vec3 = [0.99, 0.01, 0]; // Very close to P0
+// const numPoints_ex2 = 10;
+// const strength_ex2 = 100.0; // Extremely strong attraction
+// console.log("\n--- Example 2: Attraction point near the start (p0) ---");
+// const points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
+// console.log(`Generated ${points2.length} points.`);
+// console.log("First 5 points (should be very close to each other and p0):", points2.slice(0, 5).map(p => p.map(coord => coord.toFixed(5))));
+// console.log("Last 5 points (should be very spread out):", points2.slice(-5).map(p => p.map(coord => coord.toFixed(5))));
+// // Example 4: No attraction (uniform distribution)
+// const p0_ex4: Vec3 = [1, 0, 0];
+// const p1_ex4: Vec3 = [0, 1, 0];
+// const axisA_ex4: Vec3 = [0, 0, 1];
+// const attractionPoint_ex4: Vec3 = [1, 0, 0]; // Irrelevant when strength is 0
+// const numPoints_ex4 = 11;
+// const strength_ex4 = 0.0; // No attraction (uniform)
+// console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
+// const points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
+// const sequentialDistances4 = points4.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points4[i - 1], p);
+// });
+// console.log("Sequential distances (should be almost identical):", sequentialDistances4.slice(1).map(d => d.toFixed(5)));

package/Math/{arc-generate-points.js → arc-generate-points copy.js }

@@ -124,6 +124,7 @@ function solveQuadratic(a, b, c, minVal, maxVal) {
     // Case 2: Quadratic equation
     const discriminant = b * b - 4 * a * c;
     if (discriminant < -epsilon) { // No real roots (discriminant is significantly negative)
+        console.log("No real roots for the quadratic equation.");
         return null;
     }
     if (discriminant < epsilon) { // One real root (discriminant is close to zero)
@@ -224,6 +225,7 @@ export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, st
     // We search over `t` from 0 to 1, and map to actual rotation angles.
     let alpha_A = 0.0; // This will be the actual rotation angle
     let minAngleToAttraction = Math.PI; // Initialize with max possible angle
+    // TODO: USE GEOMETRY INSTEAD OF MARKOV CHOICE
     const testSteps = 1000; // Granularity for finding alpha_A
     for (let i = 0; i <= testSteps; i++) {
         const t_test = i / testSteps; // Normalized parameter [0, 1]
@@ -236,6 +238,8 @@ export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, st
             alpha_A = currentAlpha;
         }
     }
+    // minAngleToAttraction = 0.0;
+    console.log("generated alpha_A:", alpha_A, "minAngleToAttraction:", minAngleToAttraction);
     // 4. Define the PDF parameters (for normalized parameter t in [0,1])
     // The density function for 't' (normalized angle from 0 to 1)
     const minDensity = 1.0;

package/Math/arc-generate-points-exponantial.js

@@ -0,0 +1,254 @@
+// --- Utility Functions for 3D Vector Operations --- (Assumed to be the same as provided)
+/**
+ * Normalizes a 3D vector to unit length.
+ * @param v The input vector.
+ * @returns The normalized vector. Returns [0,0,0] if the input vector is a zero vector.
+ */
+function vec3Normalize(v) {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (len < 1e-9) { // Use a small epsilon to handle near-zero vectors
+        return [0, 0, 0];
+    }
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+/**
+ * Calculates the dot product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The dot product.
+ */
+function vec3Dot(v1, v2) {
+    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+}
+/**
+ * Calculates the cross product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The cross product vector.
+ */
+function vec3Cross(v1, v2) {
+    return [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0]
+    ];
+}
+/**
+ * Scales a 3D vector by a scalar.
+ * @param v The input vector.
+ * @param s The scalar value.
+ * @returns The scaled vector.
+ */
+function vec3Scale(v, s) {
+    return [v[0] * s, v[1] * s, v[2] * s];
+}
+/**
+ * Adds two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Add(v1, v2) {
+    return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
+}
+/**
+ * Subtracts the second 3D vector from the first.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Sub(v1, v2) {
+    return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
+}
+/**
+ * Clamps a numerical value within a specified range.
+ * @param value The value to clamp.
+ * @param min The minimum allowed value.
+ * @param max The maximum allowed value.
+ * @returns The clamped value.
+ */
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}
+function vec3Distance(v1, v2) {
+    const dx = v1[0] - v2[0];
+    const dy = v1[1] - v2[1];
+    const dz = v1[2] - v2[2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+/**
+ * Rotates a vector around a given axis by a specified angle using Rodrigues' rotation formula.
+ * The axis must be a unit vector for correct results.
+ * @param v The vector to rotate.
+ * @param axis The unit axis of rotation.
+ * @param angle The angle of rotation in radians.
+ * @returns The rotated vector.
+ */
+function rotateVector(v, axis, angle) {
+    const cosAngle = Math.cos(angle);
+    const sinAngle = Math.sin(angle);
+    const oneMinusCos = 1.0 - cosAngle;
+    const dotAxisV = vec3Dot(axis, v);
+    const crossAxisV = vec3Cross(axis, v);
+    // Rodrigues' rotation formula:
+    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
+    const term1 = vec3Scale(v, cosAngle);
+    const term2 = vec3Scale(crossAxisV, sinAngle);
+    const term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
+    return vec3Add(vec3Add(term1, term2), term3);
+}
+// --- Main Function for Arc Point Generation (CORRECTED) ---
+/**
+ * Generates points on the shortest arc between p0 and p1 on a unit sphere.
+ * The arc is formed by rotating p0 around axisA. The density of points
+ * is higher closer to the attractionPoint, controlled by an exponential falloff.
+ *
+ * @param p0 The starting point of the arc (will be normalized).
+ * @param p1 The ending point of the arc (will be normalized).
+ * @param axisA The axis of rotation (will be normalized).
+ * @param attractionPoint The point on the unit sphere that attracts sampled points (will be normalized).
+ * @param pointCount The total number of points to generate on the arc, including p0 and p1.
+ * @param attractionStrength Controls the density bias via exponential decay.
+ * A value of 0 results in uniform sampling.
+ * Higher positive values (e.g., 10, 50, 200) result in exponentially stronger attraction.
+ * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
+ */
+export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, attractionStrength) {
+    const sampledPoints = [];
+    const epsilon = 1e-9;
+    // 1. Normalize all input vectors
+    let nP0 = vec3Normalize(p0);
+    let nP1 = vec3Normalize(p1);
+    let nAxisA = vec3Normalize(axisA);
+    let nAttractionPoint = vec3Normalize(attractionPoint);
+    // Handle edge cases for pointCount
+    if (pointCount < 1)
+        return [];
+    if (pointCount === 1)
+        return [nP0];
+    // 2. Determine the total rotation angle
+    const p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
+    const p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
+    if (vec3Dot(p0Projected, p0Projected) < epsilon * epsilon || vec3Dot(p1Projected, p1Projected) < epsilon * epsilon) {
+        console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc. Falling back to linear interpolation.");
+        for (let i = 0; i < pointCount; i++) {
+            const t = i / (pointCount - 1);
+            sampledPoints.push(vec3Normalize(vec3Add(vec3Scale(nP0, 1 - t), vec3Scale(nP1, t))));
+        }
+        return sampledPoints;
+    }
+    const nP0Projected = vec3Normalize(p0Projected);
+    const nP1Projected = vec3Normalize(p1Projected);
+    const crossProj = vec3Cross(nP0Projected, nP1Projected);
+    const totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
+    if (Math.abs(totalRotationAngle) < epsilon) {
+        for (let i = 0; i < pointCount; i++)
+            sampledPoints.push(nP0);
+        return sampledPoints;
+    }
+    // 3. Find alpha_A: the angle parameter where the arc is closest to the attractionPoint
+    const alpha_A = (() => {
+        const dotProduct = vec3Dot(nP0, nAttractionPoint);
+        return Math.acos(dotProduct);
+    })();
+    // let alpha_A = 0.0;    
+    // let minAngleToAttraction = Math.PI;
+    // const testSteps = 1000;
+    // for (let i = 0; i <= testSteps; i++) {
+    //     const t_test = i / testSteps;
+    //     const currentAlpha = totalRotationAngle * t_test;
+    //     const pArcTest = rotateVector(nP0, nAxisA, currentAlpha);
+    //     const dotProduct = clamp(vec3Dot(pArcTest, nAttractionPoint), -1.0, 1.0);
+    //     const currentAngle = Math.acos(dotProduct);
+    //     if (currentAngle < minAngleToAttraction) {
+    //         minAngleToAttraction = currentAngle;
+    //         alpha_A = currentAlpha;
+    //     }
+    // }
+    // 4. Define the PDF and CDF based on an exponential decay model
+    const t_peak = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
+    const s = Math.max(0, attractionStrength);
+    // 5. Generate deterministic points using inverse transform sampling
+    for (let i = 0; i < pointCount; i++) {
+        const u = (pointCount === 1) ? 0.5 : i / (pointCount - 1);
+        let t_sampled;
+        if (s < epsilon) {
+            t_sampled = u;
+        }
+        else {
+            // Correctly calculate the area under the two parts of the exponential PDF
+            const area1 = (1 - Math.exp(-s * t_peak));
+            const area2 = (1 - Math.exp(-s * (1 - t_peak)));
+            const totalIntegratedArea = (area1 + area2) / s;
+            if (totalIntegratedArea < epsilon) {
+                t_sampled = u; // Fallback for extreme strength values
+            }
+            else {
+                const cdfAtPeak = (area1 / s) / totalIntegratedArea;
+                if (u <= cdfAtPeak) {
+                    // *** BUG FIX START ***
+                    // Correctly invert the CDF for the first part: [0, t_peak]
+                    const u_prime = u / cdfAtPeak;
+                    t_sampled = t_peak + Math.log(Math.exp(-s * t_peak) + u_prime * (1 - Math.exp(-s * t_peak))) / s;
+                }
+                else {
+                    // Correctly invert the CDF for the second part: [t_peak, 1]
+                    const u_double_prime = (u - cdfAtPeak) / (1 - cdfAtPeak);
+                    t_sampled = t_peak - Math.log(1 - u_double_prime * (1 - Math.exp(-s * (1 - t_peak)))) / s;
+                }
+                // *** BUG FIX END ***
+            }
+        }
+        t_sampled = clamp(t_sampled, 0, 1);
+        const actualRotationAngle = totalRotationAngle * t_sampled;
+        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+        sampledPoints.push(currentPoint);
+    }
+    return sampledPoints;
+}
+// // --- Example Usage (for demonstration and testing) ---
+// // Example 1: Basic arc, very strong attraction point in the middle
+// const p0_ex1: Vec3 = [1, 0, 0];
+// const p1_ex1: Vec3 = [0, 1, 0]; // 90 deg rotation around Z-axis
+// const axisA_ex1: Vec3 = [0, 0, 1];
+// const attractionPoint_ex1: Vec3 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
+// const numPoints_ex1 = 21;
+// const strength_ex1 = 50.0; // Very strong attraction with the new exponential model
+// console.log("--- Example 1: Attraction point in the middle of the arc (Exponentially Strong) ---");
+// const points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
+// console.log(`Generated ${points1.length} points.`);
+// // With high strength, points should be extremely clustered around the attraction point.
+// const sequentialDistances1 = points1.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points1[i - 1], p);
+// });
+// console.log("Distances near the start:", sequentialDistances1.slice(1, 5).map(d => d.toFixed(5)));
+// console.log("Distances near the middle (attraction point):", sequentialDistances1.slice(9, 13).map(d => d.toFixed(5)));
+// console.log("Distances near the end:", sequentialDistances1.slice(-4).map(d => d.toFixed(5)));
+// // Expected: Distances near the middle should be MUCH smaller than at the ends.
+// // Example 2: Attraction point near p0, very high strength
+// const p0_ex2: Vec3 = [1, 0, 0];
+// const p1_ex2: Vec3 = [0, 1, 0];
+// const axisA_ex2: Vec3 = [0, 0, 1];
+// const attractionPoint_ex2: Vec3 = [0.99, 0.01, 0]; // Very close to P0
+// const numPoints_ex2 = 10;
+// const strength_ex2 = 100.0; // Extremely strong attraction
+// console.log("\n--- Example 2: Attraction point near the start (p0) ---");
+// const points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
+// console.log(`Generated ${points2.length} points.`);
+// console.log("First 5 points (should be very close to each other and p0):", points2.slice(0, 5).map(p => p.map(coord => coord.toFixed(5))));
+// console.log("Last 5 points (should be very spread out):", points2.slice(-5).map(p => p.map(coord => coord.toFixed(5))));
+// // Example 4: No attraction (uniform distribution)
+// const p0_ex4: Vec3 = [1, 0, 0];
+// const p1_ex4: Vec3 = [0, 1, 0];
+// const axisA_ex4: Vec3 = [0, 0, 1];
+// const attractionPoint_ex4: Vec3 = [1, 0, 0]; // Irrelevant when strength is 0
+// const numPoints_ex4 = 11;
+// const strength_ex4 = 0.0; // No attraction (uniform)
+// console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
+// const points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
+// const sequentialDistances4 = points4.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points4[i - 1], p);
+// });
+// console.log("Sequential distances (should be almost identical):", sequentialDistances4.slice(1).map(d => d.toFixed(5)));

package/Math/arc.js

@@ -1,4 +1,4 @@
-import { create as vec3create, set as vec3set, cross, dot, normalize, clone as vec3clone, copy as vec3copy, equals as vec3equals, lengthSquared, fromUnitVectorLongLat, subtract, applyQuaternion, toUnitVectorLongLat } from "./vec3";
+import { create as vec3create, set as vec3set, cross, dot, normalize, clone as vec3clone, copy as vec3copy, equals as vec3equals, lengthSquared, fromLongLatToUnitVector, subtract, applyQuaternion, fromUnitVectorToLongLat } from "./vec3";
 import { create as planeCreate, fromPoints as planeFromPoints, distanceToPoint as planeDistanceToPoint, projectPoint as planeProjectPoint } from "./plane";
 import { create as quaternionCreate, fromAxisAngle } from "./quaternion";
 import { EPSILON } from "./constants";
@@ -97,10 +97,10 @@ function populatePoints(out, arc, count, pointOfProjection = undefined) {
 function _oppositePointsHandle(p0, p1, outNormal, outCoverPlane) {
     // first choice pass through Anitkabir 
     const radians = Math.PI / 180;
-    fromUnitVectorLongLat(_0vector, [39.9334 * radians, 32.8597 * radians]); // Anitkabir
+    fromLongLatToUnitVector(_0vector, [39.9334 * radians, 32.8597 * radians]); // Anitkabir
     if (vec3equals(p0, _0vector) || vec3equals(p1, _0vector)) {
         // if Anitkabir is too close to p0 or p1, use Selanic
-        fromUnitVectorLongLat(_0vector, [37.0016 * radians, 35.3213 * radians]); // Selanic
+        fromLongLatToUnitVector(_0vector, [37.0016 * radians, 35.3213 * radians]); // Selanic
     }
     planeFromPoints({ normal: outNormal, distance: 0 }, p0, _0vector, p1);
     cross(outCoverPlane.normal, outNormal, p0);
@@ -156,7 +156,7 @@ quaternionReuseCount = 1) {
     // The loop generates all points *except* the very last one.
     for (let i = 0; i < count - 1; i++) {
         // First, store the longitude/latitude of the current point.
-        toUnitVectorLongLat(_longLat, currentPoint);
+        fromUnitVectorToLongLat(_longLat, currentPoint);
         out[i * 2] = _longLat[0];
         out[i * 2 + 1] = _longLat[1];
         // --- OPTIMIZATION LOGIC ---
@@ -182,7 +182,7 @@ quaternionReuseCount = 1) {
     if (count > 0) {
         const finalIndex = count - 1;
         const endPoint = is0Closer ? inArc.p1 : inArc.p0;
-        toUnitVectorLongLat(_longLat, endPoint);
+        fromUnitVectorToLongLat(_longLat, endPoint);
         out[finalIndex * 2] = _longLat[0];
         out[finalIndex * 2 + 1] = _longLat[1];
     }