@equinor/esv-intersection/src/utils/arc-length.ts

Intersection component package with testing and automatic documentation.

import Vector2 from '@equinor/videx-vector2';
import { Vector } from 'curve-interpolator/dist/src/core/interfaces';

type fx = (n: number) => Vector;

/*
 * Methods for calculating length of a curve
 */
export class ArcLength {
  /**
   * Calculate using an adaptive bisect method
   * @param {Number} func Curve function returning [x,y]
   * @param {Number} minLimit Min limit
   * @param {Number} maxLimit Max limit
   * @param {Number} tolerance Result tolerance
   * @param {Number} minDepth Min recursive depth before accepting solution
   * @param {Number} maxDepth Max recursive depth
   */
  static bisect(
    func: fx,
    minLimit = 0,
    maxLimit = 1,
    tolerance = 0.005,
    minDepth = 4,
    maxDepth = 10,
  ): number {
    const calcRec = (
      a: number,
      b: number,
      aVal: number[],
      bVal: number[],
      span: number,
      tolerance: number,
      depth = 0,
    ): number => {
      const mid = (a + b) / 2;
      const midVal = func(mid) as number[];
      const spanA = Vector2.distance(aVal, midVal);
      const spanB = Vector2.distance(midVal, bVal);
      const length = spanA + spanB;
      if (
        (depth >= minDepth && Math.abs(length - span) < tolerance) ||
        depth >= maxDepth
      ) {
        return length;
      }
      const tol = tolerance / 2;
      const d = depth + 1;
      return (
        calcRec(a, mid, aVal, midVal, spanA, tol, d) +
        calcRec(mid, b, midVal, bVal, spanB, tol, d)
      );
    };
    const aVal = func(minLimit) as number[];
    const bVal = func(maxLimit) as number[];
    const span = Vector2.distance(aVal, bVal);
    const res = calcRec(minLimit, maxLimit, aVal, bVal, span, tolerance);
    return res;
  }

  /**
   * Calculate using trapezoid method
   * @param {Number} func Curve function returning [x,y]
   * @param {Number} minLimit Min limit
   * @param {Number} maxLimit Max limit
   * @param {Number} segments Number of segments
   */
  static trapezoid(
    func: fx,
    minLimit = 0,
    maxLimit = 1,
    segments = 1000,
  ): number {
    let length = 0;
    let lastPos = func(minLimit) as number[];
    const step = (maxLimit - minLimit) / (segments - 1);
    for (let i = 1; i < segments; i++) {
      const pos = func(minLimit + i * step) as number[];
      const delta = Vector2.distance(lastPos, pos);
      length += delta;
      lastPos = pos;
    }
    return length;
  }
}