@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/Math/angle-calculation.js

@@ -1,13 +1,14 @@
-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 };
+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/Math/arc-cdf-points.ts

@@ -0,0 +1,329 @@
+import { Radians, Vec3, Quaternion, } from './types';
+import { fromAxisAngle } from './quaternion';
+import { applyQuaternion, clone } from './vec3';
+// --- 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: Vec3): Vec3 {
+    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: Vec3, v2: Vec3): number {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: Vec3, s: number): Vec3 {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: number, min: number, max: number): number {
+    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: Vec3, axis: Vec3, angle: number): Vec3 {
+    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: Vec3,
+    p1: Vec3,
+    axisA: Vec3,
+    attractionPoint: Vec3,
+    pointCount: number,
+    attractionStrength: number,
+    adaptiveStrength: boolean = true,
+    evenSpacedPointCount: number | null = null
+): Vec3[] {
+    // 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: Vec3[] = [];
+    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: number;
+
+        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;
+}
+
+
+const _rotationQuaternion = /*@__PURE__*/[0, 0, 0, 1] as Quaternion;
+
+export function evenlySpacedArcPoints(
+    p0: Vec3,
+    axisA: Vec3,
+    coverAngle: Radians,
+    pointCount: number
+): Vec3[] {
+    if (pointCount < 1) return [];
+    if (pointCount === 1) return [vec3Normalize(p0)];
+
+    const point = vec3Normalize(p0);
+    const stepAngle = coverAngle / (pointCount - 1);
+    fromAxisAngle(_rotationQuaternion, axisA, stepAngle);
+
+    const sampledPoints: Vec3[] = new Array<Vec3>(pointCount);
+    sampledPoints[0] = clone(point);
+
+    // Start from index 1 since we already have the first point
+    for (let i = 1; i < pointCount; i++) {
+        applyQuaternion(point, point, _rotationQuaternion);
+        sampledPoints[i] = clone(point);
+    }
+
+    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-exponantial.ts

@@ -0,0 +1,299 @@
+import { Vec3 } from './types';
+
+// --- 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: Vec3): Vec3 {
+    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: Vec3, v2: Vec3): number {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: Vec3, s: number): Vec3 {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: Vec3, v2: Vec3): Vec3 {
+    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: number, min: number, max: number): number {
+    return Math.max(min, Math.min(value, max));
+}
+
+
+function vec3Distance(v1: Vec3, v2: Vec3): number {
+    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: Vec3, axis: Vec3, angle: number): Vec3 {
+    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: Vec3,
+    p1: Vec3,
+    axisA: Vec3,
+    attractionPoint: Vec3,
+    pointCount: number,
+    attractionStrength: number
+): Vec3[] {
+    const sampledPoints: Vec3[] = [];
+    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: number;
+
+        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)));