@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/semiplugins/shell/bbox-renderer/object.ts

@@ -1,129 +0,0 @@
-import { BBOXGlobeShellProgramCache } from './logic';
-import { BBOXGlobeShellProgram, ShellBlockManager } from './logic';
-import { Globe } from '../../../types';
-
-interface BBOXConfig {
-    minLon?: number;
-    maxLon?: number;
-    minLat?: number;
-    maxLat?: number;
-}
-
-interface WiggleConfig {
-    wiggleSpeed?: number | null;
-    wiggleInKM?: number | null;
-}
-
-interface BBOXGlobeShellOptions {
-    minLon?: number;
-    maxLon?: number;
-    minLat?: number;
-    maxLat?: number;
-    height?: number;
-    u_opacity?: number;
-    wiggleInKM?: number;
-    wiggleSpeed?: number;
-}
-
-export class BBOXGlobeShell {
-    public readonly gl: WebGL2RenderingContext;
-    public readonly globe: Globe;
-    public readonly program: BBOXGlobeShellProgram;
-    public readonly shellBlockManager: ShellBlockManager;
-    public readonly update: ShellBlockManager['update'];
-
-    private innerTime: number;
-    private texture!: WebGLTexture;
-    private bbox!: Required<BBOXConfig>;
-    private wiggleInKM: number;
-    private wiggleSpeed: number;
-
-    constructor(
-        gl: WebGL2RenderingContext,
-        globe: Globe,
-        {
-            minLon = -180,
-            maxLon = 180,
-            minLat = -90,
-            maxLat = 90,
-            height = 0,
-            u_opacity = 1,
-            wiggleInKM = 0,
-            wiggleSpeed = 0,
-        }: BBOXGlobeShellOptions = {}
-    ) {
-        this.gl = gl;
-        this.globe = globe;
-        this.program = BBOXGlobeShellProgramCache.get(globe);
-        this.shellBlockManager = this.program.getShellBlockBufferManager();
-        this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
-        this.innerTime = 0;
-        this.wiggleInKM = wiggleInKM;
-        this.wiggleSpeed = wiggleSpeed;
-        this.setBBox({ minLon, maxLon, minLat, maxLat });
-        this.setOpacity(u_opacity);
-        this.setHeight(height);
-        this.setWiggle({ wiggleSpeed, wiggleInKM });
-    }
-
-    public setTexture(texture: WebGLTexture): void {
-        this.texture = texture;
-        this.globe.DrawRender();
-    }
-
-    public setHeight(height: number): void {
-        this.shellBlockManager.update({ height });
-        this.globe.DrawRender();
-    }
-
-    public setOpacity(opacity: number): void {
-        this.shellBlockManager.update({ opacity });
-        this.globe.DrawRender();
-    }
-
-    public setBBox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 }: BBOXConfig = {}): void {
-        this.bbox = { minLon, maxLon, minLat, maxLat };
-        // x
-        const horOffset = (minLon) * Math.PI / 180;
-        const horSize = (maxLon - minLon) * Math.PI / 180;
-        // y
-        const vertOffset = (90 - maxLat) * Math.PI / 180;
-        const vertSize = (maxLat - minLat) * Math.PI / 180;
-
-
-        this.shellBlockManager.update(
-            {
-                gridSizeRad: [horSize, vertSize],
-                gridOffsetRad: [horOffset, vertOffset]
-            });
-        this.globe.DrawRender();
-    }
-
-    public setWiggle({ wiggleSpeed = null, wiggleInKM = null }: WiggleConfig): void {
-        if (wiggleInKM !== null) this.wiggleInKM = wiggleInKM;
-        if (wiggleSpeed !== null) this.wiggleSpeed = wiggleSpeed;
-        this.shellBlockManager.update({ wiggleInKM });
-    }
-
-    /**
-     * @param csRenderPass - modelView, projection, translate, mapWH, scrWH, should be set before calling this function
-     */
-    public draw(csRenderPass?: any): void {
-        this.program.draw(
-            this.texture,
-            this.shellBlockManager,
-            false,
-            csRenderPass
-        );
-        if (this.wiggleInKM > 0 && this.wiggleSpeed > 0) {
-            this.innerTime += this.wiggleSpeed;
-            this.shellBlockManager.update({ innerTime: this.innerTime });
-            this.globe.DrawRender();
-        }
-    }
-
-    public free(): void {
-        BBOXGlobeShellProgramCache.release(this.globe);
-        this.shellBlockManager.free();
-    }
-}

package/semiplugins/type.ts

@@ -1,8 +0,0 @@
-import { Color } from "../types";
-
-export type PluginStyleOptions = {
-    variativeColorsOn?: boolean; // If true, the color will be variative based on the circle's radius.
-    defaultColor: Color;
-    defaultHeightFromGroundIn3D?: number; // Default height from ground in 3D mode.
-
-}

package/terrain-plugin.mmd

@@ -1,83 +0,0 @@
----
-config:
-  theme: redux-dark
-  look: classic
-  layout: elk
-id: 2d4fb98c-b970-4dea-8e25-51a30073b15d
----
-flowchart TB
- subgraph subGraph0["Input Source"]
-        Client["Client / App Code"]
-  end
- subgraph subGraph1["WebGL Resources"]
-        VAO["VAO"]
-        UBO["UBO Handler"]
-  end
- subgraph subGraph2["TerrainPolygonSemiPlugin (Main Thread)"]
-        Init["init"]
-        Insert["insertBulk(polygons)"]
-        Delete["deleteBulk(keys)"]
-        SetBuffers["setBuffers(WorkerOutput)"]
-        Draw["draw3D()"]
-        subGraph1
-  end
- subgraph subGraph3["Async Processing"]
-        WC["WorkerContact"]
-        
-        subgraph WorkerContext ["Web Worker (worker.js)"]
-            OnMsg["onmessage"]
-            
-            subgraph CacheSystem ["Cache System (cache.ts)"]
-                C_Insert["insert/remove"]
-                C_Tri["_entry (Triangulation)"]
-                C_RBush["RBush Index"]
-                C_Search["search(bboxes)"]
-            end
-            
-            W_Loop["Loop Visible Triangles"]
-            W_Merge["Merge Buffers"]
-        end
-        
-        Core["Tessellation Core\n(partialTessellation)"]
-  end
- subgraph subGraph4["GPU Memory (WebGL)"]
-        ElemBuf["Element Array Buffer\n(Indices)"]
-        Vec3Buf["Vec3 Buffer\n(Positions)"]
-        MercBuf["Mercator XY Buffer\n(LongLats)"]
-        Shader["TextureDemTriangles Program"]
-  end
-    Client -- "1. Instantiate" --> Init
-    Init -- Create --> WC & VAO & UBO
-    Init -- Get Program --> Shader
-    Client -- "2. Input Data" --> Insert
-    Insert -- Delegate --> WC
-    
-    %% Worker Flow
-    WC -- "postMessage({queue, bboxes})" --> OnMsg
-    
-    %% Cache Operations
-    OnMsg -- "Process Queue" --> C_Insert
-    C_Insert -- "Triangulate" --> C_Tri
-    C_Tri -- "Store" --> C_RBush
-    
-    %% Render Prep Flow
-    OnMsg -- "Update View" --> C_Search
-    C_Search -- "Query" --> C_RBush
-    C_RBush -- "Visible Triangles" --> W_Loop
-    
-    %% Tessellation Loop
-    W_Loop -- "Meta + Zoom" --> Core
-    Core -- "Geometry" --> W_Loop
-    W_Loop -- "Accumulate" --> W_Merge
-    
-    %% Return to Main
-    W_Merge -- "Transferables" --> WC
-    WC -- Callback --> SetBuffers
-    
-    SetBuffers -- Upload Data --> ElemBuf & Vec3Buf & MercBuf
-    SetBuffers -- Request Render --> Client
-    Client -- "3. Render Loop" --> Draw
-    Draw -- Bind --> VAO
-    Draw -- Update --> UBO
-    Draw -- Execute --> Shader
-    Shader -- Read --> ElemBuf & Vec3Buf & MercBuf

package/tests/Math/arc-sampling-test.js

@@ -1,367 +0,0 @@
-/**
- * @file This script provides a function to generate points along an arc on a unit sphere.
- * The arc is defined by a start point, an end point, and a rotation axis.
- * The density of the sampled points can be biased towards an 'attraction point'
- * using a deterministic inverse transform sampling approach.
- */
-// --- Utility Functions for 3D Vector Operations ---
-/**
- * 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) {
-    var 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) {
-    var dx = v1[0] - v2[0];
-    var dy = v1[1] - v2[1];
-    var 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) {
-    var cosAngle = Math.cos(angle);
-    var sinAngle = Math.sin(angle);
-    var oneMinusCos = 1.0 - cosAngle;
-    var dotAxisV = vec3Dot(axis, v);
-    var crossAxisV = vec3Cross(axis, v);
-    // Rodrigues' rotation formula:
-    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
-    var term1 = vec3Scale(v, cosAngle);
-    var term2 = vec3Scale(crossAxisV, sinAngle);
-    var term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
-    return vec3Add(vec3Add(term1, term2), term3);
-}
-/**
- * Solves a quadratic equation Ax^2 + Bx + C = 0 for x, returning a root within a specified range.
- * Handles linear cases (A approx 0) and multiple roots, selecting the most appropriate one for CDF inversion.
- * @param a Coefficient A.
- * @param b Coefficient B.
- * @param c Coefficient C.
- * @param minVal The minimum expected value for the root.
- * @param maxVal The maximum expected value for the root.
- * @returns The selected root within the range, or null if no valid real root.
- */
-function solveQuadratic(a, b, c, minVal, maxVal) {
-    var epsilon = 1e-12; // Small value for floating point comparisons
-    // Case 1: Linear equation (A is close to zero)
-    if (Math.abs(a) < epsilon) {
-        if (Math.abs(b) < epsilon) {
-            // Both A and B are zero. If C is also zero, infinitely many solutions, pick minVal.
-            // Otherwise, no solutions.
-            return Math.abs(c) < epsilon ? minVal : null;
-        }
-        var x = -c / b;
-        // Check if the linear solution is within the expected range
-        return (x >= minVal - epsilon && x <= maxVal + epsilon) ? x : null;
-    }
-    // Case 2: Quadratic equation
-    var discriminant = b * b - 4 * a * c;
-    if (discriminant < -epsilon) { // No real roots (discriminant is significantly negative)
-        return null;
-    }
-    if (discriminant < epsilon) { // One real root (discriminant is close to zero)
-        var x = -b / (2 * a);
-        return (x >= minVal - epsilon && x <= maxVal + epsilon) ? x : null;
-    }
-    // Case 3: Two distinct real roots
-    var sqrtDisc = Math.sqrt(discriminant);
-    var x1 = (-b + sqrtDisc) / (2 * a);
-    var x2 = (-b - sqrtDisc) / (2 * a);
-    var validX1 = (x1 >= minVal - epsilon && x1 <= maxVal + epsilon);
-    var validX2 = (x2 >= minVal - epsilon && x2 <= maxVal + epsilon);
-    if (validX1 && validX2) {
-        // If both roots are valid, pick the one that is logically correct for CDF inversion.
-        // For an increasing CDF, we generally want the smallest valid non-negative root.
-        return Math.min(x1, x2);
-    }
-    else if (validX1) {
-        return x1;
-    }
-    else if (validX2) {
-        return x2;
-    }
-    else {
-        return null; // No valid roots within the range
-    }
-}
-// --- Main Function for Arc Point Generation ---
-/**
- * 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.
- *
- * @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 strength Controls the density bias. A value of 0 means uniform sampling.
- * Higher positive values (e.g., 1 to 10) result in stronger attraction.
- * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
- */
-function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, strength) {
-    var sampledPoints = [];
-    var epsilon = 1e-7; // General epsilon for vector comparisons
-    // 1. Normalize all input vectors
-    var nP0 = vec3Normalize(p0);
-    var nP1 = vec3Normalize(p1);
-    var nAxisA = vec3Normalize(axisA);
-    var nAttractionPoint = vec3Normalize(attractionPoint);
-    // Handle edge cases for pointCount
-    if (pointCount < 1) {
-        return sampledPoints;
-    }
-    if (pointCount === 1) {
-        sampledPoints.push(nP0);
-        return sampledPoints;
-    }
-    // 2. Determine the total rotation angle required to go from p0 to p1 around axisA
-    // Project p0 and p1 onto the plane perpendicular to axisA
-    var p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
-    var p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
-    var lenP0Proj = Math.sqrt(vec3Dot(p0Projected, p0Projected));
-    var lenP1Proj = Math.sqrt(vec3Dot(p1Projected, p1Projected));
-    // Handle cases where p0 or p1 are colinear with the rotation axis
-    if (lenP0Proj < epsilon || lenP1Proj < epsilon) {
-        // If start and end points are effectively the same (on or very near the axis)
-        if (Math.abs(vec3Dot(nP0, nP1) - 1.0) < epsilon) {
-            for (var i = 0; i < pointCount; i++) {
-                sampledPoints.push(nP0); // Return identical points as no meaningful arc exists
-            }
-            return sampledPoints;
-        }
-        else {
-            console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc by rotation around axisA to reach p1. Falling back to linear interpolation.");
-            // Fallback: simple linear interpolation and normalize
-            for (var i = 0; i < pointCount; i++) {
-                var t = i / (pointCount - 1);
-                var interpolated = vec3Add(vec3Scale(nP0, (1 - t)), vec3Scale(nP1, t));
-                sampledPoints.push(vec3Normalize(interpolated));
-            }
-            return sampledPoints;
-        }
-    }
-    var nP0Projected = vec3Normalize(p0Projected);
-    var nP1Projected = vec3Normalize(p1Projected);
-    // Calculate total rotation angle using atan2 for a signed angle
-    var crossProj = vec3Cross(nP0Projected, nP1Projected);
-    var totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
-    // If total rotation angle is negligible, all points are essentially p0
-    if (Math.abs(totalRotationAngle) < epsilon) {
-        for (var i = 0; i < pointCount; i++) {
-            sampledPoints.push(nP0);
-        }
-        return sampledPoints;
-    }
-    // 3. Find alpha_A: the angle parameter (from p0) where the arc point is closest to attractionPoint
-    // We search over `t` from 0 to 1, and map to actual rotation angles.
-    var alpha_A = 0.0; // This will be the actual rotation angle
-    var minAngleToAttraction = Math.PI; // Initialize with max possible angle
-    var testSteps = 1000; // Granularity for finding alpha_A
-    for (var i = 0; i <= testSteps; i++) {
-        var t_test = i / testSteps; // Normalized parameter [0, 1]
-        var currentAlpha = totalRotationAngle * t_test; // Actual rotation angle
-        var pArcTest = rotateVector(nP0, nAxisA, currentAlpha); // Point on arc
-        var dotProduct = clamp(vec3Dot(pArcTest, nAttractionPoint), -1.0, 1.0);
-        var currentAngle = Math.acos(dotProduct);
-        if (currentAngle < minAngleToAttraction) {
-            minAngleToAttraction = currentAngle;
-            alpha_A = currentAlpha;
-        }
-    }
-    // 4. Define the PDF parameters (for normalized parameter t in [0,1])
-    // The density function for 't' (normalized angle from 0 to 1)
-    var minDensity = 1.0;
-    // Strength ensures positive density. Higher strength gives more pronounced peak.
-    var maxDensity = minDensity + Math.max(0, strength);
-    // Normalize alpha_A to the [0, 1] range for the PDF/CDF calculations
-    // This represents the peak position (t_peak) within the normalized parameter space.
-    var alpha_A_normalized = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
-    // Normalization constant for the PDF (integral over [0,1] must be 1)
-    // Area of trapezoid = 0.5 * (base1 + base2) * height
-    // In our case, the "bases" are minDensity and maxDensity, "height" is 1 (the t-interval length)
-    var pdfArea = 0.5 * (minDensity + maxDensity);
-    var pdfNormalizationConstant = 1.0 / pdfArea;
-    // Calculate CDF value at the peak point (alpha_A_normalized)
-    // This splits the CDF into two regions for the quadratic solver
-    var cdfAtAlphaA_norm = pdfNormalizationConstant * (minDensity * alpha_A_normalized + 0.5 * (maxDensity - minDensity) * alpha_A_normalized);
-    // 5. Generate deterministic points using inverse transform sampling
-    for (var i = 0; i < pointCount; i++) {
-        // Generate uniformly spaced values `u` in [0, 1]
-        var u = i / (pointCount - 1);
-        var t_sampled = // This will be the sampled normalized parameter [0, 1]
-         void 0; // This will be the sampled normalized parameter [0, 1]
-        if (u <= cdfAtAlphaA_norm) {
-            // Case 1: The sampled point falls in the first part of the PDF (0 to alpha_A_normalized)
-            // F(t) = normConst * (minDensity * t + 0.5 * (maxDensity - minDensity) / alpha_A_normalized * t^2)
-            // Rearrange to A*t^2 + B*t + C = 0 for solving:
-            var A = (alpha_A_normalized !== 0) ? pdfNormalizationConstant * 0.5 * (maxDensity - minDensity) / alpha_A_normalized : 0;
-            var B = pdfNormalizationConstant * minDensity;
-            var C = -u;
-            var result = solveQuadratic(A, B, C, 0, alpha_A_normalized);
-            // Fallback for unexpected null (e.g., numerical issues)
-            t_sampled = result !== null ? result : (u / (cdfAtAlphaA_norm || epsilon)) * alpha_A_normalized;
-        }
-        else {
-            // Case 2: The sampled point falls in the second part of the PDF (alpha_A_normalized to 1)
-            // F(t) - cdfAtAlphaA_norm = normConst * [ maxDensity * (t - alpha_A_normalized) - 0.5 * (maxDensity - minDensity) / (1 - alpha_A_normalized) * (t - alpha_A_normalized)^2 ]
-            // Let x = t - alpha_A_normalized. Solve for x: A'*x^2 + B'*x + C' = 0
-            var rangeAfterA = 1 - alpha_A_normalized;
-            var A_prime = (rangeAfterA !== 0) ? -pdfNormalizationConstant * 0.5 * (maxDensity - minDensity) / rangeAfterA : 0;
-            var B_prime = pdfNormalizationConstant * maxDensity;
-            var C_prime = -(u - cdfAtAlphaA_norm);
-            var result_x = solveQuadratic(A_prime, B_prime, C_prime, 0, rangeAfterA);
-            // Fallback for unexpected null
-            t_sampled = (result_x !== null ? alpha_A_normalized + result_x :
-                alpha_A_normalized + (u - cdfAtAlphaA_norm) / ((1 - cdfAtAlphaA_norm) || epsilon) * rangeAfterA);
-        }
-        // Ensure t_sampled is within [0, 1] due to potential float inaccuracies
-        t_sampled = clamp(t_sampled, 0, 1);
-        // Convert the normalized parameter 't_sampled' back to the actual rotation angle
-        var actualRotationAngle = totalRotationAngle * t_sampled;
-        // Rotate the starting point p0 by this angle around axisA to get the final point
-        var currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
-        sampledPoints.push(currentPoint);
-    }
-    return sampledPoints;
-}
-// --- Example Usage (for demonstration and testing) ---
-// Example 1: Basic arc, attraction point in the middle
-var p0_ex1 = [1, 0, 0];
-var p1_ex1 = [0, 1, 0]; // 90 deg rotation around Z-axis
-var axisA_ex1 = [0, 0, 1];
-var attractionPoint_ex1 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
-var numPoints_ex1 = 50;
-var strength_ex1 = 100.0; // Strong attraction
-console.log("--- Example 1: Attraction point in the middle of the arc ---");
-var points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
-console.log("Generated ".concat(points1.length, " points."));
-// To observe concentration, you might visualize these points or calculate their 't' parameter distribution.
-// For console output, let's print a few:
-console.log("First 5 points:", points1.slice(0, 5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-console.log("Last 5 points:", points1.slice(-5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-// Expected: Points should be denser around [0.707, 0.707, 0]
-var sequentialDistances1 = points1.map(function (p, i) {
-    if (i === 0)
-        return 0; // Skip the first point
-    return vec3Distance(points1[i - 1], p);
-});
-console.log("Sequential distances between points (should be roughly equal for uniform distribution):", sequentialDistances1.map(function (d) { return d.toFixed(4); }));
-// Example 2: Attraction point near p0
-var p0_ex2 = [1, 0, 0];
-var p1_ex2 = [0, 1, 0];
-var axisA_ex2 = [0, 0, 1];
-var attractionPoint_ex2 = [0.99, 0.01, 0]; // Very close to P0
-var numPoints_ex2 = 50;
-var strength_ex2 = 10.0; // Very strong attraction
-console.log("\n--- Example 2: Attraction point near the start (p0) ---");
-var points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
-console.log("Generated ".concat(points2.length, " points."));
-console.log("First 5 points:", points2.slice(0, 5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-console.log("Last 5 points:", points2.slice(-5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-// Expected: Points should be denser near [1, 0, 0]
-// Example 3: Attraction point away from the arc (expect less concentration)
-var p0_ex3 = [1, 0, 0];
-var p1_ex3 = [0, 1, 0];
-var axisA_ex3 = [0, 0, 1];
-var attractionPoint_ex3 = [0, 0, 1]; // North pole, away from the XY plane arc
-var numPoints_ex3 = 50;
-var strength_ex3 = 5.0;
-console.log("\n--- Example 3: Attraction point away from the arc ---");
-var points3 = generateArcPoints(p0_ex3, p1_ex3, axisA_ex3, attractionPoint_ex3, numPoints_ex3, strength_ex3);
-console.log("Generated ".concat(points3.length, " points."));
-console.log("First 5 points:", points3.slice(0, 5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-console.log("Last 5 points:", points3.slice(-5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-// Expected: Points should be relatively uniformly distributed, as no point on the arc is significantly closer.
-// The "closest point" on the arc will likely be determined by its closest angular projection.
-// Example 4: No attraction (uniform distribution)
-var p0_ex4 = [1, 0, 0];
-var p1_ex4 = [0, 1, 0];
-var axisA_ex4 = [0, 0, 1];
-var attractionPoint_ex4 = [Math.sqrt(1 / 2), Math.sqrt(1 / 2), 0]; // Irrelevant when strength is 0
-var numPoints_ex4 = 50;
-var strength_ex4 = 4.0; // No attraction (uniform)
-console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
-var points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
-console.log("Generated ".concat(points4.length, " points."));
-console.log("First 5 points:", points4.slice(0, 5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-console.log("Last 5 points:", points4.slice(-5).map(function (p) { return p.map(function (coord) { return coord.toFixed(4); }); }));
-// Expected: Points should be uniformly spaced.
-var sequentialDistances = points4.map(function (p, i) {
-    if (i === 0)
-        return 0; // Skip the first point
-    return vec3Distance(points4[i - 1], p);
-});
-console.log("Sequential distances between points (should be roughly equal for uniform distribution):", sequentialDistances.map(function (d) { return d.toFixed(4); }));