@math.gl/geometry 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/culling/lib/shapes/sphere-shape.ts

@@ -0,0 +1,60 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {
+  ImplicitShapeBase,
+  solveQuadratic,
+  type ImplicitShape,
+  type LocalRayIntersection
+} from './implicit-shape';
+
+const EPSILON = 1e-6;
+
+export type SphereShapeProps = {radius?: number; matrix?: readonly number[]};
+
+/** Analytic glTF sphere shape. */
+export class SphereShape extends ImplicitShapeBase {
+  readonly type = 'sphere' as const;
+  readonly radius: number;
+  constructor(props: SphereShapeProps = {}) {
+    super(props.matrix);
+    this.radius = props.radius ?? 0.5;
+    if (!Number.isFinite(this.radius) || this.radius <= 0)
+      throw new Error('Sphere radius must be greater than zero');
+  }
+  clone(): SphereShape {
+    return new SphereShape({radius: this.radius, matrix: this.matrix});
+  }
+  override equals(shape: ImplicitShape): boolean {
+    return shape instanceof SphereShape && super.equals(shape) && this.radius === shape.radius;
+  }
+  containsLocalPoint(point: readonly number[]): boolean {
+    return Math.hypot(...point) <= this.radius + EPSILON;
+  }
+  distanceToLocalPoint(point: readonly number[]): number {
+    return Math.max(0, Math.hypot(...point) - this.radius);
+  }
+  supportLocal(direction: readonly number[]): readonly number[] {
+    const length = Math.hypot(...direction);
+    return length ? direction.map(value => (value / length) * this.radius) : [this.radius, 0, 0];
+  }
+  intersectLocalRay(
+    origin: readonly number[],
+    direction: readonly number[]
+  ): LocalRayIntersection | undefined {
+    const roots = solveQuadratic(
+      dot(direction, direction),
+      2 * dot(origin, direction),
+      dot(origin, origin) - this.radius * this.radius
+    );
+    const distance = roots.find(value => value >= 0);
+    if (distance === undefined) return undefined;
+    const point = origin.map((value, i) => value + distance * direction[i]);
+    return {distance, normal: point.map(value => value / this.radius)};
+  }
+}
+
+function dot(a: readonly number[], b: readonly number[]): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}

package/src/culling/oriented-box-2d.ts

@@ -0,0 +1,165 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** A rectangle in a shared two-dimensional Euclidean coordinate space. */
+export type OrientedBox2D = {
+  /** Two finite center coordinates; arrays, typed arrays and core vectors are accepted. */
+  readonly center: Readonly<ArrayLike<number>>;
+  /** Nonnegative half-width and half-height, in the center's coordinate units. */
+  readonly halfSize: Readonly<ArrayLike<number>>;
+  /** Nonzero finite width-axis direction. Its magnitude does not change the size. */
+  readonly direction: Readonly<ArrayLike<number>>;
+};
+
+/** Test closed rectangles using their four separating axes, without allocating query objects.
+ * Directions are normalized locally; the height axis is the perpendicular of the width axis.
+ * Points and line segments (zero half-sizes) are supported. Inputs are never modified.
+ * Subtracting centers before projection avoids projecting large translated corner coordinates.
+ * @param first First rectangle in the shared coordinate space.
+ * @param second Second rectangle in the shared coordinate space.
+ * @param epsilon Nonnegative finite separation allowance in coordinate units; default zero.
+ * Touching edges/vertices intersect. A gap no larger than epsilon on every tested axis also
+ * intersects; this is a SAT allowance, not a Euclidean-distance query.
+ * @throws RangeError For invalid vectors, sizes, directions or epsilon.
+ */
+export function intersectOrientedBoxes2D(
+  first: OrientedBox2D,
+  second: OrientedBox2D,
+  epsilon = 0
+): boolean {
+  validateBox(first);
+  validateBox(second);
+  if (!Number.isFinite(epsilon) || epsilon < 0) {
+    throw new RangeError('Box separation allowance must be finite and nonnegative');
+  }
+
+  // Scale before normalizing so both huge and subnormal directions remain usable.
+  const firstDirectionScale = Math.max(Math.abs(first.direction[0]), Math.abs(first.direction[1]));
+  const secondDirectionScale = Math.max(
+    Math.abs(second.direction[0]),
+    Math.abs(second.direction[1])
+  );
+  const firstWidthX = first.direction[0] / firstDirectionScale;
+  const firstWidthY = first.direction[1] / firstDirectionScale;
+  const secondWidthX = second.direction[0] / secondDirectionScale;
+  const secondWidthY = second.direction[1] / secondDirectionScale;
+  const firstLength = Math.hypot(firstWidthX, firstWidthY);
+  const secondLength = Math.hypot(secondWidthX, secondWidthY);
+  const firstX = firstWidthX / firstLength;
+  const firstY = firstWidthY / firstLength;
+  const secondX = secondWidthX / secondLength;
+  const secondY = secondWidthY / secondLength;
+
+  // Clamp unit-axis dot products against rounding slightly above one.
+  const cosine = Math.min(1, Math.abs(firstX * secondX + firstY * secondY));
+  const sine = Math.min(1, Math.abs(firstX * secondY - firstY * secondX));
+  return (
+    overlapsOnAxis(
+      first,
+      second,
+      firstX,
+      firstY,
+      first.halfSize[0],
+      second.halfSize[0] * cosine,
+      second.halfSize[1] * sine,
+      epsilon
+    ) &&
+    overlapsOnAxis(
+      first,
+      second,
+      -firstY,
+      firstX,
+      first.halfSize[1],
+      second.halfSize[0] * sine,
+      second.halfSize[1] * cosine,
+      epsilon
+    ) &&
+    overlapsOnAxis(
+      first,
+      second,
+      secondX,
+      secondY,
+      second.halfSize[0],
+      first.halfSize[0] * cosine,
+      first.halfSize[1] * sine,
+      epsilon
+    ) &&
+    overlapsOnAxis(
+      first,
+      second,
+      -secondY,
+      secondX,
+      second.halfSize[1],
+      first.halfSize[0] * sine,
+      first.halfSize[1] * cosine,
+      epsilon
+    )
+  );
+}
+
+/** Scale each projection independently so an irrelevant huge extent cannot erase a small gap. */
+function overlapsOnAxis(
+  first: OrientedBox2D,
+  second: OrientedBox2D,
+  axisX: number,
+  axisY: number,
+  ownRadius: number,
+  otherWidthRadius: number,
+  otherHeightRadius: number,
+  epsilon: number
+): boolean {
+  const displacementX = second.center[0] - first.center[0];
+  const displacementY = second.center[1] - first.center[1];
+  // Keep a representable center difference before multiplying. If subtraction overflows,
+  // project the finite centers first; a zero axis component then stays exactly zero.
+  const projectionX = Number.isFinite(displacementX)
+    ? displacementX * axisX
+    : second.center[0] * axisX - first.center[0] * axisX;
+  const projectionY = Number.isFinite(displacementY)
+    ? displacementY * axisY
+    : second.center[1] * axisY - first.center[1] * axisY;
+  const scale =
+    Math.max(
+      ownRadius,
+      otherWidthRadius,
+      otherHeightRadius,
+      epsilon,
+      Number.isFinite(projectionX)
+        ? Math.abs(projectionX)
+        : Math.max(Math.abs(first.center[0] * axisX), Math.abs(second.center[0] * axisX)),
+      Number.isFinite(projectionY)
+        ? Math.abs(projectionY)
+        : Math.max(Math.abs(first.center[1] * axisY), Math.abs(second.center[1] * axisY))
+    ) || 1;
+  const normalizedX = Number.isFinite(projectionX)
+    ? projectionX / scale
+    : (second.center[0] * axisX) / scale - (first.center[0] * axisX) / scale;
+  const normalizedY = Number.isFinite(projectionY)
+    ? projectionY / scale
+    : (second.center[1] * axisY) / scale - (first.center[1] * axisY) / scale;
+  return (
+    Math.abs(normalizedX + normalizedY) <=
+    ownRadius / scale + otherWidthRadius / scale + otherHeightRadius / scale + epsilon / scale
+  );
+}
+
+/** Validate structural boxes before entering the scalar query kernel. */
+function validateBox(box: OrientedBox2D): void {
+  validateVector(box.center);
+  validateVector(box.halfSize);
+  validateVector(box.direction);
+  if (box.halfSize[0] < 0 || box.halfSize[1] < 0) {
+    throw new RangeError('Box half-sizes must be nonnegative');
+  }
+  if (box.direction[0] === 0 && box.direction[1] === 0) {
+    throw new RangeError('Box direction must be nonzero');
+  }
+}
+
+/** Require exactly two finite components, without copying the vector. */
+function validateVector(vector: Readonly<ArrayLike<number>>): void {
+  if (vector.length !== 2 || !Number.isFinite(vector[0]) || !Number.isFinite(vector[1])) {
+    throw new RangeError('Box vectors must have exactly two finite components');
+  }
+}

package/src/culling/queries.ts

@@ -0,0 +1,155 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Low-level Euclidean query kernels shared with spatial indexes. */
+export type QueryPoint = Readonly<ArrayLike<number>>;
+export type TriangleRayHit = {t: number; barycentric: [number, number, number]};
+
+export function validateQueryPoint(point: QueryPoint, dimension: number): void {
+  if (point.length !== dimension) throw new RangeError('Query dimension must match the index');
+  for (let i = 0; i < dimension; i++) {
+    if (!Number.isFinite(point[i])) throw new RangeError('Coordinates must be finite');
+  }
+}
+
+export function validateQueryDistance(distance: number): void {
+  if (Number.isNaN(distance) || distance < 0) throw new RangeError('Distance must be nonnegative');
+}
+
+/** Returns a unit direction; ray distances in indexes are always coordinate units. */
+export function normalizeQueryDirection(direction: QueryPoint, dimension: number): number[] {
+  validateQueryPoint(direction, dimension);
+  const scale = Math.max(...Array.from(direction, Math.abs));
+  if (scale === 0) throw new RangeError('Ray direction must be nonzero');
+  const scaled = Array.from(direction, x => x / scale);
+  const length = Math.hypot(...scaled);
+  return scaled.map(x => x / length);
+}
+
+/** Closed bounds; returns zero for an origin inside. t uses the supplied direction scale. */
+export function intersectRayBounds(
+  origin: QueryPoint,
+  direction: QueryPoint,
+  minimum: QueryPoint,
+  maximum: QueryPoint,
+  maxT = Infinity
+): number | null {
+  const dimension = origin.length;
+  if (dimension !== 2 && dimension !== 3) throw new RangeError('Bounds must be 2D or 3D');
+  validateQueryPoint(origin, dimension);
+  validateQueryPoint(direction, dimension);
+  validateQueryPoint(minimum, dimension);
+  validateQueryPoint(maximum, dimension);
+  validateQueryDistance(maxT);
+  let near = 0,
+    far = maxT,
+    nonzero = false;
+  for (let i = 0; i < dimension; i++) {
+    if (minimum[i] > maximum[i]) throw new RangeError('Bounds must be ordered');
+    nonzero ||= direction[i] !== 0;
+  }
+  if (!nonzero) throw new RangeError('Ray direction must be nonzero');
+  for (let i = 0; i < dimension; i++) {
+    if (direction[i] === 0) {
+      if (origin[i] < minimum[i] || origin[i] > maximum[i]) return null;
+      continue;
+    }
+    let a = (minimum[i] - origin[i]) / direction[i];
+    let b = (maximum[i] - origin[i]) / direction[i];
+    if (a > b) [a, b] = [b, a];
+    near = Math.max(near, a);
+    far = Math.min(far, b);
+    if (near > far) return null;
+  }
+  return Number.isFinite(near) ? near : null;
+}
+
+/** Two-sided Möller–Trumbore test; degenerates and coplanar rays have no hit. */
+export function intersectRayTriangle(
+  origin: QueryPoint,
+  direction: QueryPoint,
+  a: QueryPoint,
+  b: QueryPoint,
+  c: QueryPoint,
+  options: {backfaceCulling?: boolean; maxT?: number} = {}
+): TriangleRayHit | null {
+  for (const point of [origin, direction, a, b, c]) validateQueryPoint(point, 3);
+  if (direction[0] === 0 && direction[1] === 0 && direction[2] === 0) {
+    throw new RangeError('Ray direction must be nonzero');
+  }
+  const maxT = options.maxT ?? Infinity;
+  validateQueryDistance(maxT);
+  const e1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const e2 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  const p = cross(direction, e2);
+  const determinant = dot(e1, p);
+  if (determinant === 0 || (options.backfaceCulling && determinant < 0)) return null;
+  const offset = [origin[0] - a[0], origin[1] - a[1], origin[2] - a[2]];
+  const u = dot(offset, p) / determinant;
+  if (u < 0 || u > 1) return null;
+  const q = cross(offset, e1);
+  const v = dot(direction, q) / determinant;
+  if (v < 0 || u + v > 1) return null;
+  const t = dot(e2, q) / determinant;
+  if (!Number.isFinite(t) || t < 0 || t > maxT) return null;
+  return {t: Math.max(0, t), barycentric: [1 - u - v, u, v]};
+}
+
+/** Closest point on a filled triangle; degenerate triangles reduce to segments/points. */
+export function getClosestPointOnTriangle(
+  point: QueryPoint,
+  a: QueryPoint,
+  b: QueryPoint,
+  c: QueryPoint
+): [number, number, number] {
+  for (const value of [point, a, b, c]) validateQueryPoint(value, 3);
+  const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  const ap = [point[0] - a[0], point[1] - a[1], point[2] - a[2]];
+  const aa = dot(ab, ab),
+    bb = dot(ac, ac),
+    cc = dot(ab, ac);
+  const denominator = aa * bb - cc * cc;
+  if (denominator > 0 && Number.isFinite(denominator)) {
+    const u = (bb * dot(ap, ab) - cc * dot(ap, ac)) / denominator;
+    const v = (aa * dot(ap, ac) - cc * dot(ap, ab)) / denominator;
+    if (u >= 0 && v >= 0 && u + v <= 1) {
+      return [
+        a[0] + u * ab[0] + v * ac[0],
+        a[1] + u * ab[1] + v * ac[1],
+        a[2] + u * ab[2] + v * ac[2]
+      ];
+    }
+  }
+  let best: [number, number, number] = [a[0], a[1], a[2]];
+  let distance = Infinity;
+  for (const [start, end] of [
+    [a, b],
+    [b, c],
+    [c, a]
+  ]) {
+    const edge = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
+    const offset = [point[0] - start[0], point[1] - start[1], point[2] - start[2]];
+    const squared = dot(edge, edge);
+    const t = squared > 0 ? Math.max(0, Math.min(1, dot(offset, edge) / squared)) : 0;
+    const candidate: [number, number, number] = [
+      start[0] + t * edge[0],
+      start[1] + t * edge[1],
+      start[2] + t * edge[2]
+    ];
+    const d = Math.hypot(point[0] - candidate[0], point[1] - candidate[1], point[2] - candidate[2]);
+    if (d < distance) {
+      distance = d;
+      best = candidate;
+    }
+  }
+  return best;
+}
+
+function dot(a: QueryPoint, b: QueryPoint): number {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(a: QueryPoint, b: QueryPoint): number[] {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}

package/src/curves/bezier-curves.ts

@@ -0,0 +1,62 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumericArray} from '@math.gl/core/types';
+import {Curve, copyPoints, type CurvePoint} from './curve';
+
+abstract class BezierCurve extends Curve {
+  private readonly points: number[][];
+
+  protected constructor(points: readonly CurvePoint[]) {
+    const copied = copyPoints(points);
+    super(copied[0].length);
+    this.points = copied;
+  }
+
+  protected evaluate(t: number, result: NumericArray, derivative: boolean): void {
+    const degree = this.points.length - 1;
+    // Scalar de Casteljau evaluation avoids temporary vectors and preserves endpoints.
+    for (let i = 0; i < this.dimension; i++) {
+      let a = this.points[0][i];
+      let b = this.points[1][i];
+      let c = degree >= 2 ? this.points[2][i] : 0;
+      const d = degree === 3 ? this.points[3][i] : 0;
+      let order = degree;
+      if (derivative) {
+        a = degree * (b - a);
+        b = degree * (c - b);
+        c = degree * (d - c);
+        order--;
+      }
+      if (order === 3) {
+        a = (1 - t) * a + t * b;
+        b = (1 - t) * b + t * c;
+        c = (1 - t) * c + t * d;
+      }
+      if (order >= 2) {
+        a = (1 - t) * a + t * b;
+        b = (1 - t) * b + t * c;
+      }
+      result[i] = order >= 1 ? (1 - t) * a + t * b : a;
+    }
+  }
+}
+
+export class LineCurve extends BezierCurve {
+  constructor(start: CurvePoint, end: CurvePoint) {
+    super([start, end]);
+  }
+}
+
+export class QuadraticBezierCurve extends BezierCurve {
+  constructor(start: CurvePoint, control: CurvePoint, end: CurvePoint) {
+    super([start, control, end]);
+  }
+}
+
+export class CubicBezierCurve extends BezierCurve {
+  constructor(start: CurvePoint, control1: CurvePoint, control2: CurvePoint, end: CurvePoint) {
+    super([start, control1, control2, end]);
+  }
+}

package/src/curves/catmull-rom-curve.ts

@@ -0,0 +1,89 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumericArray} from '@math.gl/core/types';
+import {Curve, copyPoints, type CurvePoint} from './curve';
+import {HermiteCurve} from './hermite-curve';
+
+export type CatmullRomCurveOptions = {
+  closed?: boolean;
+  parameterization?: 'centripetal' | 'chordal' | 'uniform';
+  /** Uniform splines only. Default 0.5; zero gives stationary knot tangents. */
+  tension?: number;
+};
+
+export class CatmullRomCurve extends Curve {
+  readonly closed: boolean;
+  private readonly segments: HermiteCurve[];
+
+  constructor(points: readonly CurvePoint[], options: CatmullRomCurveOptions = {}) {
+    const data = copyPoints(points);
+    super(data[0].length);
+    this.closed = options.closed ?? false;
+    if (data.length < (this.closed ? 3 : 2)) throw new RangeError('Not enough spline points');
+    const mode = options.parameterization ?? 'centripetal';
+    if (!['centripetal', 'chordal', 'uniform'].includes(mode)) {
+      throw new RangeError('Unknown Catmull-Rom parameterization');
+    }
+    const tension = options.tension ?? 0.5;
+    if (!Number.isFinite(tension) || tension < 0 || tension > 1) {
+      throw new RangeError('tension must be in [0, 1]');
+    }
+    if (options.tension !== undefined && mode !== 'uniform') {
+      throw new RangeError('tension is only supported for uniform splines');
+    }
+    const point = (index: number): number[] => {
+      if (this.closed) return data[(index + data.length) % data.length];
+      if (index < 0) return data[0].map((x, i) => 2 * x - data[1][i]);
+      if (index >= data.length) {
+        return data[data.length - 1].map((x, i) => 2 * x - data[data.length - 2][i]);
+      }
+      return data[index];
+    };
+    this.segments = [];
+    for (let s = 0; s < data.length - (this.closed ? 0 : 1); s++) {
+      const p0 = point(s - 1);
+      const p1 = point(s);
+      const p2 = point(s + 1);
+      const p3 = point(s + 2);
+      const interval = (a: number[], b: number[]): number => {
+        const distance = Math.hypot(...a.map((x, i) => b[i] - x));
+        return distance ** (mode === 'chordal' ? 1 : 0.5);
+      };
+      const d1 = interval(p1, p2);
+      if (mode !== 'uniform' && d1 === 0) {
+        // A repeated knot is a stationary segment, rather than a spurious loop.
+        const zero = new Array<number>(this.dimension).fill(0);
+        this.segments.push(new HermiteCurve(p1, p2, zero, zero));
+        continue;
+      }
+      // Reuse the current interval for coincident neighbors. This is scale invariant.
+      const d0 = interval(p0, p1) || d1;
+      const d2 = interval(p2, p3) || d1;
+      const m1 = p1.map((x, i) =>
+        mode === 'uniform'
+          ? tension * (p2[i] - p0[i])
+          : d1 * ((x - p0[i]) / d0 - (p2[i] - p0[i]) / (d0 + d1) + (p2[i] - x) / d1)
+      );
+      const m2 = p2.map((x, i) =>
+        mode === 'uniform'
+          ? tension * (p3[i] - p1[i])
+          : d1 * ((x - p1[i]) / d1 - (p3[i] - p1[i]) / (d1 + d2) + (p3[i] - x) / d2)
+      );
+      this.segments.push(new HermiteCurve(p1, p2, m1, m2));
+    }
+  }
+
+  protected evaluate(t: number, result: NumericArray, derivative: boolean): void {
+    const scaled = t * this.segments.length;
+    const index = Math.min(Math.floor(scaled), this.segments.length - 1);
+    const local = scaled - index;
+    if (derivative) {
+      this.segments[index].getDerivative(local, result);
+      for (let i = 0; i < this.dimension; i++) result[i] *= this.segments.length;
+    } else {
+      this.segments[index].getPoint(local, result);
+    }
+  }
+}

package/src/curves/curve-arc-length.ts

@@ -0,0 +1,70 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumericArray} from '@math.gl/core/types';
+import {Curve, validateDivisions, validateParameter} from './curve';
+
+/** Reusable polyline approximation to a curve's cumulative arc length. */
+export class CurveArcLength {
+  readonly curve: Curve;
+  readonly divisions: number;
+  readonly length: number;
+  private readonly cumulativeLengths: Float64Array;
+
+  constructor(curve: Curve, divisions = 1024) {
+    validateDivisions(divisions);
+    this.curve = curve;
+    this.divisions = divisions;
+    this.cumulativeLengths = new Float64Array(divisions + 1);
+    let previous = curve.getPoint(0);
+    let current = new Array<number>(curve.dimension);
+    let length = 0;
+    for (let i = 1; i <= divisions; i++) {
+      curve.getPoint(i / divisions, current);
+      length += Math.hypot(
+        current[0] - previous[0],
+        current[1] - previous[1],
+        curve.dimension === 3 ? current[2] - previous[2] : 0
+      );
+      if (!Number.isFinite(length)) throw new RangeError('Curve arc length must be finite');
+      this.cumulativeLengths[i] = length;
+      [previous, current] = [current, previous];
+    }
+    this.length = length;
+  }
+
+  /** Map a fraction of total length to t, preserving endpoints and zero-length curves. */
+  getParameterAt(u: number): number {
+    validateParameter(u);
+    if (u === 0 || u === 1 || this.length === 0) return u;
+    const target = u * this.length;
+    let low = 0;
+    let high = this.divisions;
+    while (low + 1 < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (this.cumulativeLengths[middle] <= target) low = middle;
+      else high = middle;
+    }
+    const span = this.cumulativeLengths[high] - this.cumulativeLengths[low];
+    return (low + (span > 0 ? (target - this.cumulativeLengths[low]) / span : 0)) / this.divisions;
+  }
+
+  getPointAt(u: number): number[];
+  getPointAt<T extends NumericArray>(u: number, result: T): T;
+  getPointAt(u: number, result: NumericArray = new Array(this.curve.dimension)): NumericArray {
+    return this.curve.getPoint(this.getParameterAt(u), result);
+  }
+
+  /** Flat samples at approximately equal distances along the curve. */
+  getSpacedPoints(divisions = 64): Float64Array {
+    validateDivisions(divisions);
+    const points = new Float64Array((divisions + 1) * this.curve.dimension);
+    const point = new Array<number>(this.curve.dimension);
+    for (let i = 0; i <= divisions; i++) {
+      this.getPointAt(i / divisions, point);
+      points.set(point, i * this.curve.dimension);
+    }
+    return points;
+  }
+}