@pirireis/webglobeplugins 0.16.4 → 0.17.0

package/Math/angle-calculation.js

@@ -1,3 +1,4 @@
+const Radians = Math.PI / 180;
 function bearingRealAngle(long, lat, endLong, endLat) {
     const rLong = Radians * long;
     const rLat = Radians * lat;

package/Math/arc.js

@@ -10,6 +10,15 @@ const _originPlane = /*@__PURE__*/ planeCreate(vec3create(0, 0, 1), 0);
 // dont change distance of _originPlane
 const _rotationQuaternion = /*@__PURE__*/ quaternionCreate();
 const _longLat = /*@__PURE__*/ [0, 0];
+// Normalize angles to [0, 2π)
+function normalizeLon(angle) {
+    while (angle < 0)
+        angle += 2 * Math.PI;
+    while (angle >= 2 * Math.PI)
+        angle -= 2 * Math.PI;
+    return angle;
+}
+;
 function create(p0, p1) {
     const normal = vec3create(0, 0, 0);
     cross(normal, p0, p1);
@@ -25,7 +34,6 @@ function create(p0, p1) {
         // Handle opposite points case
         const tempPlane = planeCreate(vec3create(), 0);
         _oppositePointsHandle(p0, p1, normal, tempPlane);
-        vec3copy(coverPlaneNormal, tempPlane.normal);
         distance = tempPlane.distance;
     }
     return {
@@ -43,6 +51,7 @@ function set(out, p0, p1) {
     vec3copy(out.p0, p0);
     vec3copy(out.p1, p1);
     cross(out.normal, p0, p1);
+    normalize(out.normal, out.normal); // ← ADD THIS LINE - normalize the normal vector!
     vec3set(_0vector, p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]);
     const ls = lengthSquared(_0vector);
     if (ls > EPSILON) {
@@ -52,6 +61,8 @@ function set(out, p0, p1) {
     else {
         _oppositePointsHandle(p0, p1, out.normal, out.coverPlane);
     }
+    // Also update coverAngle to match what create() does
+    out.coverAngle = Math.acos(dot(p0, p1));
 }
 function copy(out, a) {
     vec3copy(out.p0, a.p0);
@@ -119,6 +130,7 @@ function _oppositePointsHandle(p0, p1, outNormal, outCoverPlane) {
     }
     planeFromPoints({ normal: outNormal, distance: 0 }, p0, _0vector, p1);
     cross(outCoverPlane.normal, outNormal, p0);
+    normalize(outCoverPlane.normal, outCoverPlane.normal);
 }
 function _populatePointsWithClosestPointInsideArc(out, arc, count, closestPoint) {
     // two parts divided by closest point will be populated seperately
@@ -199,4 +211,82 @@ function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0,
         out[finalIndex * 2 + 1] = _longLat[1];
     }
 }
-export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints };
+function calculateZLimitPoint(inArc, out) {
+    // The arc's plane is perpendicular to the equator, so the arc is on the equator.
+    // All points have z=0, so there's no unique z-limit point.
+    if (Math.abs(inArc.normal[2]) > 1 - EPSILON) {
+        return false;
+    }
+    // The Z-limit points of a great circle are the two points on it that are
+    // closest to the North and South poles. Their 3D coordinates can be
+    // calculated from the normal vector of the great circle's plane.
+    const nz = inArc.normal[2];
+    const n_xy_len = Math.sqrt(inArc.normal[0] * inArc.normal[0] + inArc.normal[1] * inArc.normal[1]);
+    // Candidate 1: Highest Z value (closest to North Pole)
+    const p_max_z = vec3.create(-inArc.normal[0] * nz / n_xy_len, -inArc.normal[1] * nz / n_xy_len, n_xy_len);
+    // Candidate 2: Lowest Z value (closest to South Pole)
+    const p_min_z = vec3.create(inArc.normal[0] * nz / n_xy_len, inArc.normal[1] * nz / n_xy_len, -n_xy_len);
+    // Now, we check if either of these points lie on the given arc segment.
+    // A point is on the shorter arc if its projection onto the cover plane's
+    // normal is on the positive side.
+    const d_max = dot(p_max_z, inArc.coverPlane.normal);
+    const d_min = dot(p_min_z, inArc.coverPlane.normal);
+    if (d_max >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_max_z);
+        return true;
+    }
+    if (d_min >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_min_z);
+        return true;
+    }
+    return false;
+}
+function doesArcPassThroughMeridian(inArc, meridians) {
+    const result = new Array(meridians.length).fill(false);
+    // Get longitude angles for p0 and p1
+    const p0Lon = Math.atan2(inArc.p0[1], inArc.p0[0]);
+    const p1Lon = Math.atan2(inArc.p1[1], inArc.p1[0]);
+    if (inArc.p0[2] >= 1 - EPSILON || inArc.p1[2] >= 1 - EPSILON) {
+        return result;
+    }
+    const p0LonNorm = normalizeLon(p0Lon);
+    const p1LonNorm = normalizeLon(p1Lon);
+    // Determine if we're taking the shorter or longer arc
+    let startLon = p0LonNorm;
+    let endLon = p1LonNorm;
+    // Calculate the angular difference both ways
+    const diff1 = normalizeLon(endLon - startLon);
+    // Take the shorter path (great circle property)
+    const takeShorterPath = diff1 <= Math.PI;
+    if (!takeShorterPath) {
+        // Swap start and end for the shorter path
+        [startLon, endLon] = [endLon, startLon];
+    }
+    for (let i = 0; i < meridians.length; i++) {
+        const meridian = normalizeLon(meridians[i]);
+        // Check if meridian is between start and end longitudes
+        if (takeShorterPath) {
+            if (startLon <= endLon) {
+                // Normal case: no wraparound
+                result[i] = meridian >= startLon && meridian <= endLon;
+            }
+            else {
+                // Wraparound case: arc crosses 0°/360°
+                result[i] = meridian >= startLon || meridian <= endLon;
+            }
+        }
+        else {
+            // Taking the longer path
+            if (startLon <= endLon) {
+                // Arc goes the long way around
+                result[i] = meridian <= startLon || meridian >= endLon;
+            }
+            else {
+                // Normal case for long path
+                result[i] = meridian >= endLon && meridian <= startLon;
+            }
+        }
+    }
+    return result;
+}
+export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints, calculateZLimitPoint, doesArcPassThroughMeridian };

package/Math/circle-cdf-points.js

@@ -1,4 +1,4 @@
-import { RADIANS } from "./methods";
+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.
@@ -60,7 +60,7 @@ function globeFindPointByPolar(out, globe, centerLong, centerLat, radius, ratios
     }
 }
 function globeFindPointByPolarHalfCircle(out, globe, centerLong, centerLat, radius, rotation, ratios) {
-    const rotCentigrade = rotation / RADIANS + 720;
+    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;

package/Math/circle.js

@@ -1,4 +1,4 @@
-import { RADIANS } from './methods';
+import { RADIAN } from './methods';
 import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar, clone } from './vec3';
 const _0vec3 = [0, 0, 0];
 function closestAzimuthAngle(circleProperties, point) {
@@ -15,7 +15,7 @@ function closestAzimuthAngle(circleProperties, point) {
 }
 function createCircleClosestAzimuthAngleProperties(circle) {
     const normal = Array(3);
-    fromLongLatToUnitVector(normal, [circle.center[0] * RADIANS, circle.center[1] * RADIANS]);
+    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);

package/Math/contour/quadtreecontours.js

@@ -0,0 +1,300 @@
+// © 2019 3D Robotics. License: Apache-2.0
+const OUTSIDE = 0;
+const ABOVE = 1;
+const BELOW = 2;
+const WITHIN = 3;
+// Build mipmap layer N from layer N+1
+function mipmapReduce({ min, max, width, height, scale }) {
+    const outWidth = Math.ceil(width / 2);
+    const outHeight = Math.ceil(height / 2);
+    function reduceWith(data, reduce) {
+        const out = new Float32Array(outWidth * outHeight);
+        let x;
+        let y;
+        for (y = 0; y < Math.floor(height / 2); y++) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)], data[(y * 2 + 1) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 1)]);
+            }
+            if (x < outWidth) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 1) * width + (x * 2 + 0)]);
+            }
+        }
+        if (y < outHeight) {
+            for (x = 0; x < Math.floor(width / 2); x++) {
+                out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)], data[(y * 2 + 0) * width + (x * 2 + 1)]);
+            }
+        }
+        //@ts-ignore
+        if (x < outWidth && y < outHeight) {
+            //@ts-ignore
+            out[y * outWidth + x] = reduce(data[(y * 2 + 0) * width + (x * 2 + 0)]);
+        }
+        return out;
+    }
+    function minFinite(...args) {
+        let r = Infinity;
+        for (let i = 0; i < args.length; i++) {
+            const v = args[i];
+            if (v < r)
+                r = v;
+        }
+        return r;
+    }
+    function maxFinite(...args) {
+        let r = -Infinity;
+        for (let i = 0; i < args.length; i++) {
+            const v = args[i];
+            if (v > r)
+                r = v;
+        }
+        return r;
+    }
+    return {
+        min: reduceWith(min, minFinite),
+        max: reduceWith(max, maxFinite),
+        width: outWidth,
+        height: outHeight,
+        scale: scale * 2,
+    };
+}
+class ContourMipmap {
+    levels;
+    constructor(raster, width, height) {
+        // Bottom mipmap layer is just the raster: at each pixel the minimum and maximum are the same
+        this.levels = [{ min: raster, max: raster, width, height, scale: 1 }];
+        while (this.levels[0].width > 1 || this.levels[0].height > 1) {
+            this.levels.unshift(mipmapReduce(this.levels[0]));
+        }
+    }
+    // Get the minimum elevation in the mipmap
+    min() { return this.levels[0].min[0]; }
+    // Get the maximum elevation in the mipmap
+    max() { return this.levels[0].max[0]; }
+    // Get an array of contour levels for a specified contour interval
+    intervals(interval) {
+        if (interval <= 0)
+            throw new Error('Contour interval must be positive');
+        const min = this.min();
+        const max = this.max();
+        const levels = [];
+        let level = Math.ceil(min / interval) * interval;
+        while (level < max) {
+            levels.push(level);
+            level += interval;
+        }
+        return levels;
+    }
+    // Walk the quadtree for a specified contour level, and pass quadtree nodes
+    // and contour line segments to the callbacks. This is used for visualizing
+    // the quadtree; in most cases you should use .contour() instead, which
+    // assembles the line segments into lines and rings.
+    evaluateContour(contourLevel, { maxMipmapLevel }, addLine, addNode) {
+        maxMipmapLevel = maxMipmapLevel || this.levels.length - 1;
+        // Test the mipmap at the given coordinate and level, returning whether the contour line is ABOVE, BELOW, or WITHIN this mipmap cell
+        // If the mipmap is out of bounds or NaN at that point, OUTSIDE is returned.
+        const evaluate = (l, x, y) => {
+            const ml = this.levels[l];
+            const i = ml.width * y + x;
+            if (x >= ml.width || y >= ml.height || !Number.isFinite(ml.min[i]) || !Number.isFinite(ml.max[i]))
+                return OUTSIDE;
+            if (ml.min[i] >= contourLevel)
+                return ABOVE;
+            if (ml.max[i] < contourLevel)
+                return BELOW;
+            // If we've reached the maximum mipmap level, arbitrarily decide that cells that contain
+            // the contour elevation go inside the contour line.
+            if (l >= maxMipmapLevel)
+                return ABOVE;
+            return WITHIN;
+        };
+        // Add any vertical contour lines that exist between passed mipmap cell and
+        // its horizontal neighbor to the right. If the line exists at this mipmap
+        // level, it is added directly, otherwise split the edge and recurse at a
+        // more detailed mipmap level.
+        const edgeH = (l, x, y) => {
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x + 1, y);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x + 1, y + 1, x + 1, y);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                // reverse order of coordinates compared to case above so that lines
+                // go counterclockwise around the region above the contour value
+                addLine(l, x + 1, y, x + 1, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeH(l + 1, x * 2 + 1, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        };
+        // Like edgeH, but for horizontal contour lines between the passed cell
+        // and its vertical neighbor below.
+        const edgeV = (l, x, y) => {
+            const e1 = evaluate(l, x, y);
+            const e2 = evaluate(l, x, y + 1);
+            if (e1 === ABOVE && e2 === BELOW) {
+                addLine(l, x, y + 1, x + 1, y + 1);
+            }
+            else if (e2 === ABOVE && e1 === BELOW) {
+                addLine(l, x + 1, y + 1, x, y + 1);
+            }
+            else if (e1 === WITHIN || e2 === WITHIN) {
+                edgeV(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 1);
+            }
+        };
+        // Add all contour lines within a mipmap cell.
+        // It recurses into the four quadrants of the cell, and also uses edgeH and
+        // edgeV to add the contour lines that exist between quadrants.
+        const node = (l, x, y) => {
+            const e = evaluate(l, x, y);
+            if (e === WITHIN) {
+                node(l + 1, x * 2 + 0, y * 2 + 0);
+                node(l + 1, x * 2 + 1, y * 2 + 0);
+                node(l + 1, x * 2 + 0, y * 2 + 1);
+                node(l + 1, x * 2 + 1, y * 2 + 1);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeV(l + 1, x * 2 + 0, y * 2 + 0);
+                edgeH(l + 1, x * 2 + 0, y * 2 + 1);
+                edgeV(l + 1, x * 2 + 1, y * 2 + 0);
+            }
+            else {
+                if (addNode)
+                    addNode(l, x, y, e);
+            }
+        };
+        node(0, 0, 0);
+    }
+    // Generate a contour line for a specified value
+    //
+    // level: Value in the input array at which to draw a contour line
+    // opts: {
+    //   maxMipmapLevel: Maximum recursion depth in the mipmap. As if you rescaled
+    //                   the input to a maximum dimension of 2^n pixels.
+    //                   (default unlimited)
+    //   minPoints: Lines and rings with fewer points are removed. (default 0)
+    //   smoothKernelWidth: Width of the rectangular filter for smoothing (default 2)
+    //   smoothCycles: Number of iterations of smoothing (default 2)
+    // }
+    //
+    // Returns an array of lines, where each line is an array of [x, y] pairs.
+    contour(level, { maxMipmapLevel, smoothKernelWidth = 2, smoothCycles = 2, minPoints = 0 } = {}) {
+        // Use the quadtree algorithm to generate line segments that make up the contour
+        const segments = [];
+        this.evaluateContour(level, { maxMipmapLevel }, (l, x1, y1, x2, y2) => {
+            const scale = this.levels[l].scale;
+            const start = [scale * x1, scale * y1];
+            const end = [scale * x2, scale * y2];
+            segments.push({ start, end });
+        });
+        segments.sort((a, b) => key(a.start) - key(b.start));
+        // .. and then join them together into rings
+        // An arbitrary function to use a 2D point as a Map key
+        function key(a) { return a[0] + a[1] * 65536; }
+        const fragmentStart = new Map();
+        const fragmentEnd = new Map();
+        const rings = [];
+        segments.forEach(({ start, end }) => {
+            const a = fragmentEnd.get(key(start));
+            const b = fragmentStart.get(key(end));
+            if (a && b) {
+                fragmentEnd.delete(key(start));
+                fragmentStart.delete(key(end));
+                if (a === b) {
+                    // Close a ring
+                    a.push(end);
+                    rings.push(a);
+                }
+                else {
+                    // Join two lines together
+                    const c = a.concat(b);
+                    fragmentStart.set(key(c[0]), c);
+                    fragmentEnd.set(key(c[c.length - 1]), c);
+                }
+            }
+            else if (a) {
+                // Extend an existing line from the end
+                fragmentEnd.delete(key(start));
+                a.push(end);
+                fragmentEnd.set(key(end), a);
+            }
+            else if (b) {
+                // Extend an existing line from the start
+                fragmentStart.delete(key(end));
+                b.unshift(start);
+                fragmentStart.set(key(start), b);
+            }
+            else {
+                // New line doesn't connect to any existing line
+                const c = [start, end];
+                fragmentStart.set(key(start), c);
+                fragmentEnd.set(key(end), c);
+            }
+            if (fragmentStart.size !== fragmentEnd.size) {
+                console.error(`Contour remaining fragment size mismatch ${fragmentStart.size} ${fragmentEnd.size}`);
+            }
+        });
+        const smoothOpts = {
+            kernelWidth: smoothKernelWidth,
+            cycles: smoothCycles,
+        };
+        // Closed rings and any unclosed line strings
+        return [...rings, ...fragmentStart.values()]
+            .filter(l => l.length >= minPoints && l.length >= smoothKernelWidth * 2)
+            .map(l => smooth(l, smoothOpts));
+    }
+}
+// Smooth a line by repeatedly applying a rectangular filter to approximate
+// a gaussian filter. It detects closed loops and preserves them.
+// The line is passed as an array of `[x, y]` pairs.
+//
+// kernelWidth: Width of the rectangular filter kernel
+// cycles: Number of times to apply the kernel
+function smooth(line, { kernelWidth = 2, cycles = 2 }) {
+    const isLoop = line[0][0] === line[line.length - 1][0] && line[0][1] === line[line.length - 1][1];
+    let pointAt;
+    if (isLoop) {
+        pointAt = (i) => line[(i + line.length) % line.length];
+    }
+    else {
+        pointAt = (i) => line[Math.min(Math.max(i, 0), line.length - 1)];
+    }
+    const sc = 1.0 / (kernelWidth * 2);
+    for (let cycle = 0; cycle < cycles; cycle++) {
+        let px = 0;
+        let py = 0;
+        if (isLoop) {
+            for (let i = line.length - kernelWidth; i < line.length; i++) {
+                px += line[i][0];
+                py += line[i][1];
+            }
+        }
+        else {
+            px = line[0][0] * kernelWidth;
+            py = line[0][1] * kernelWidth;
+        }
+        for (let i = 0; i < kernelWidth; i++) {
+            px += line[i][0];
+            py += line[i][1];
+        }
+        const res = line.slice();
+        for (let i = 0; i < line.length; i++) {
+            res[i] = [px * sc, py * sc];
+            px += pointAt(i + kernelWidth)[0] - pointAt(i - kernelWidth)[0];
+            py += pointAt(i + kernelWidth)[1] - pointAt(i - kernelWidth)[1];
+        }
+        if (isLoop) {
+            // Keep the loop closed
+            res[res.length - 1] = res[0].slice();
+        }
+        line = res;
+    }
+    return line;
+}
+function scaleParameters(minLongitude, minLatitude, maxLongitude, maxLatitude, width, height) {
+    const scaleX = (maxLongitude - minLongitude) / width;
+    const scaleY = (maxLatitude - minLatitude) / height;
+    return { scaleX, scaleY };
+}
+export default ContourMipmap;
+export { scaleParameters };

package/Math/finite-line-2d.js

@@ -0,0 +1,58 @@
+function junctionPoint(out, inLine, origin, slope) {
+    const x0 = inLine[0];
+    const y0 = inLine[1];
+    const x1 = inLine[0];
+    const y1 = inLine[1];
+    const m1 = (y1 - y0) / (x1 - x0); // slope of line
+    const b1 = y0 - m1 * x0; // y-intercept of line
+    const m2 = slope;
+    const b2 = origin[1] - m2 * origin[0]; // y-intercept of line
+    if (m1 === m2) {
+        return 0; // parallel lines
+    }
+    const x = (b2 - b1) / (m1 - m2);
+    const y = m1 * x + b1;
+    // check if point is within line segment
+    if (x < Math.min(x0, x1) || x > Math.max(x0, x1) ||
+        y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+        return 0;
+    }
+    out[0] = x;
+    out[1] = y;
+    return 1;
+}
+export function junctionVerticalOrHorizontalLines(out, inLine1, value, isVertical) {
+    const x0 = inLine1[0];
+    const y0 = inLine1[1];
+    const x1 = inLine1[0];
+    const y1 = inLine1[1];
+    if (isVertical) {
+        // vertical line x = value
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        const y = m1 * value + b1;
+        // check if point is within line segment
+        if (y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+            return 0;
+        }
+        out[0] = value;
+        out[1] = y;
+        return 1;
+    }
+    else {
+        // horizontal line y = value
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        if (m1 === 0) {
+            return 0; // parallel lines
+        }
+        const x = (value - b1) / m1;
+        // check if point is within line segment
+        if (x < Math.min(x0, x1) || x > Math.max(x0, x1)) {
+            return 0;
+        }
+        out[0] = x;
+        out[1] = value;
+        return 1;
+    }
+}

package/Math/juction/arc-plane.js

@@ -1,9 +1,9 @@
 import { EPSILON } from "../constants";
-import { create as vec3create, copy as vec3copy, dot, distanceSquared, } from "../vec3";
+import { create as vec3create, copy as vec3copy, dot, distanceSquared, copy, normalize } from "../vec3";
 import { create as lineCreate } from "../line";
 import { create as planeCreate, distanceToPoint, getUnitSphereRadiusAngle } from "../plane";
 import { copy as arcCopy, set as arcSet } from "../arc";
-import { planePlaneJuction } from "./plane-plane";
+import { planePlaneJunction } from "./plane-plane";
 import { lineSphereIntersection } from "./line-sphere";
 const _intersectionLine = /*@__PURE__*/ lineCreate();
 const _originPlane = /*@__PURE__*/ planeCreate();
@@ -39,9 +39,9 @@ export function arcSlice(out, inArc, junctionPlane) {
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
     vec3copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, junctionPlane);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
     if (!isPlaneJunctions) { // case C: planes are parallel. 
-        if (junctionPlane.distance <= 0) {
+        if (junctionPlane.distance <= 0) { // same direction
             arcCopy(out[0], inArc);
             return 1; // No intersection
         }
@@ -53,23 +53,35 @@ export function arcSlice(out, inArc, junctionPlane) {
     // calculate the intersection points
     const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
     if (!isSphereIntersection) {
-        // other edge caes should be covered by now
         return 0; // No intersection
     }
-    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
-    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
-    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > -EPSILON;
-    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > -EPSILON;
+    // ← ADD NORMALIZATION HERE
+    normalize(_intersectionPoints[0], _intersectionPoints[0]);
+    normalize(_intersectionPoints[1], _intersectionPoints[1]);
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > EPSILON;
+    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > EPSILON;
+    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > EPSILON;
     if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
         return 0; // No intersection
     }
     if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
         // calculate which points are closer
+        if (dot(inArc.coverPlane.normal, junctionPlane.normal) > 1 - EPSILON) {
+            arcCopy(out[0], inArc);
+            return 1;
+        }
+        else if (dot(inArc.coverPlane.normal, junctionPlane.normal) < -1 + EPSILON) {
+            return 0;
+        }
+        // Determine which intersection point is closer to p0
         const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
         const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        arcSet(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        arcSet(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        const closerToP0 = p0i0DistanceSquared < p0i1DistanceSquared ? 0 : 1;
+        // The visible portion is from p0 to the closer intersection point
+        arcSet(out[0], inArc.p0, _intersectionPoints[closerToP0]);
+        // The second arc goes from the farther point to p1
+        arcSet(out[1], _intersectionPoints[1 - closerToP0], inArc.p1);
         return 2;
     }
     if (i0IsCovered && i1IsCovered) {
@@ -86,3 +98,46 @@ export function arcSlice(out, inArc, junctionPlane) {
     arcSet(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
     return 1;
 }
+function showArc(arc) {
+    return `Arc: p0(${arc.p0[0].toFixed(2)}, ${arc.p0[1].toFixed(2)}, ${arc.p0[2]}) - p1(${arc.p1[0]}, ${arc.p1[1].toFixed(2)}, ${arc.p1[2].toFixed(2)})`;
+}
+function showPlane(plane) {
+    return `Plane: n(${plane.normal[0].toFixed(2)}, ${plane.normal[1].toFixed(2)}, ${plane.normal[2].toFixed(2)}) d(${plane.distance.toFixed(2)})`;
+}
+export function pointsOnArc(inArc, junctionPlane, out) {
+    // case A: junction plane is too far
+    if (Math.abs(junctionPlane.distance) > 1) {
+        return 0;
+    }
+    // Calculate plane-plane intersection
+    vec3copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
+    // case B: planes are parallel
+    if (!isPlaneJunctions) {
+        return 0;
+    }
+    // Calculate intersection points with unit sphere
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
+    // case C: intersection line does not intersect the unit sphere
+    if (!isSphereIntersection) {
+        return 0;
+    }
+    // Check which intersection points are covered by the arc
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+    // Check which endpoints are visible
+    let count = 0;
+    // Add covered intersection points
+    if (i0IsCovered) {
+        copy(out[count], _intersectionPoints[0]);
+        count++;
+    }
+    if (Math.abs(Math.abs(junctionPlane.distance) - 1) < EPSILON) {
+        return count; // Tangent case, only one intersection point
+    }
+    if (i1IsCovered) {
+        copy(out[count], _intersectionPoints[1]);
+        count++;
+    }
+    return count;
+}

package/Math/juction/line-sphere.js

@@ -3,18 +3,18 @@ import { at } from "../line";
 const _0vector = /*@__PURE__*/ create(0, 0, 0);
 export function lineSphereIntersection(out, inLine, inSphere) {
     subtract(_0vector, inLine.origin, inSphere.center);
+    const dirLengthSq = lengthSquared(inLine.direction);
+    const dot_ = dot(_0vector, inLine.direction);
     const distanceSquared = lengthSquared(_0vector);
     const radiusSquared = inSphere.radius * inSphere.radius;
-    const dot_ = dot(_0vector, inLine.direction);
-    const dotSquared = dot_ * dot_;
-    const discriminant = dotSquared + radiusSquared - distanceSquared;
+    const discriminant = dot_ * dot_ - dirLengthSq * (distanceSquared - radiusSquared);
     if (discriminant < 0) {
         return false; // no intersection
     }
     else {
-        const a = Math.sqrt(discriminant);
-        const t1 = -dot_ - a;
-        const t2 = -dot_ + a;
+        const sqrtDiscriminant = Math.sqrt(discriminant);
+        const t1 = (-dot_ - sqrtDiscriminant) / dirLengthSq;
+        const t2 = (-dot_ + sqrtDiscriminant) / dirLengthSq;
         at(out[0], inLine, t1);
         at(out[1], inLine, t2);
         return true;