🥮 mooncakes.io
    Sign in

    python123-ops/moon-cv-geometry/core does not have a README file

    GeometryError

    source
    pub(all) suberror GeometryError {
      DegenerateInput(String)
      NotEnoughPoints(String)
    } derive(Eq, 
    Debug    )

    Aabb3

    source
    pub(all) struct Aabb3 {
      min : Point3
      max : Point3
    } derive(Eq, 
    Debug    )

    Aabb3::center

    source
    fn Aabb3::center(box : Aabb3) -> Point3

    Aabb3::contains

    source
    fn Aabb3::contains(box : Aabb3, p : Point3) -> Bool

    Aabb3::expand

    source
    fn Aabb3::expand(box : Aabb3, margin : Double) -> Aabb3

    Aabb3::from_points

    source
    fn Aabb3::from_points(points : ArrayView[Point3]) -> Aabb3 raise GeometryError

    Aabb3::volume

    source
    fn Aabb3::volume(box : Aabb3) -> Double

    Circle2

    source
    pub(all) struct Circle2 {
      center : Point2
      radius : Double
    } derive(Eq, 
    Debug    )

    Circle2::contains

    source
    fn Circle2::contains(circle : Circle2, point : Point2) -> Bool

    Circle2::new

    source
    fn Circle2::new(center~ : Point2, radius~ : Double) -> Circle2 raise GeometryError

    Circle2::signed_distance

    source
    fn Circle2::signed_distance(circle : Circle2, point : Point2) -> Double

    Line2

    source
    pub(all) struct Line2 {
      normal : Vec2
      offset : Double
    } derive(Eq, 
    Debug    )

    Line2::from_points

    source
    fn Line2::from_points(a : Point2, b : Point2) -> Line2 raise GeometryError

    Line2::intersect

    source
    fn Line2::intersect(a : Line2, b : Line2) -> Point2?

    Line2::project

    source
    fn Line2::project(line : Line2, point : Point2) -> Point2

    Line2::signed_distance

    source
    fn Line2::signed_distance(line : Line2, point : Point2) -> Double

    Mat3

    source
    pub(all) struct Mat3 {
      m00 : Double
      m01 : Double
      m02 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m20 : Double
      m21 : Double
      m22 : Double
    } derive(Eq, 
    Debug    )

    Mat3::add

    source
    fn Mat3::add(a : Mat3, b : Mat3) -> Mat3

    Mat3::det

    source
    fn Mat3::det(m : Mat3) -> Double

    Mat3::diagonal

    source
    fn Mat3::diagonal(matrix : Mat3) -> Vec3

    Mat3::frobenius_norm

    source
    fn Mat3::frobenius_norm(m : Mat3) -> Double

    Mat3::hadamard

    source
    fn Mat3::hadamard(a : Mat3, b : Mat3) -> Mat3

    Mat3::inverse

    source
    fn Mat3::inverse(m : Mat3) -> Mat3 raise GeometryError

    Mat3::is_orthonormal

    source
    fn Mat3::is_orthonormal(m : Mat3, tolerance? : Double) -> Bool

    Mat3::is_symmetric

    source
    fn Mat3::is_symmetric(matrix : Mat3, tolerance? : Double) -> Bool

    Mat3::mul

    source
    fn Mat3::mul(a : Mat3, b : Mat3) -> Mat3

    Mat3::mul_vec3

    source
    fn Mat3::mul_vec3(m : Mat3, v : Vec3) -> Vec3

    Mat3::off_diagonal_norm

    source
    fn Mat3::off_diagonal_norm(matrix : Mat3) -> Double

    Mat3::power

    source
    fn Mat3::power(matrix : Mat3, exponent : Int) -> Mat3

    Mat3::scale

    source
    fn Mat3::scale(m : Mat3, value : Double) -> Mat3

    Mat3::sub

    source
    fn Mat3::sub(a : Mat3, b : Mat3) -> Mat3

    Mat3::trace

    source
    fn Mat3::trace(matrix : Mat3) -> Double

    Mat3::transpose

    source
    fn Mat3::transpose(m : Mat3) -> Mat3

    Mat34

    source
    pub(all) struct Mat34 {
      m00 : Double
      m01 : Double
      m02 : Double
      m03 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m13 : Double
      m20 : Double
      m21 : Double
      m22 : Double
      m23 : Double
    } derive(Eq, 
    Debug    )

    Mat34::transform_point

    source
    fn Mat34::transform_point(m : Mat34, p : Point3) -> Point3

    Mat4

    source
    pub(all) struct Mat4 {
      m00 : Double
      m01 : Double
      m02 : Double
      m03 : Double
      m10 : Double
      m11 : Double
      m12 : Double
      m13 : Double
      m20 : Double
      m21 : Double
      m22 : Double
      m23 : Double
      m30 : Double
      m31 : Double
      m32 : Double
      m33 : Double
    } derive(Eq, 
    Debug    )

    Mat4::mul

    source
    fn Mat4::mul(a : Mat4, b : Mat4) -> Mat4

    Mat4::transform_point

    source
    fn Mat4::transform_point(m : Mat4, p : Point3) -> Point3 raise GeometryError

    Mat4::transpose

    source
    fn Mat4::transpose(m : Mat4) -> Mat4

    NumericRange

    source
    pub(all) struct NumericRange {
      min : Double
      max : Double
    } derive(Eq, 
    Debug    )

    Plane3

    source
    pub(all) struct Plane3 {
      normal : Vec3
      offset : Double
    } derive(Eq, 
    Debug    )

    Plane3::from_points

    source
    fn Plane3::from_points(a : Point3, b : Point3, c : Point3) -> Plane3 raise GeometryError

    Plane3::project

    source
    fn Plane3::project(plane : Plane3, point : Point3) -> Point3

    Plane3::ray_hit

    source
    fn Plane3::ray_hit(plane : Plane3, ray : Ray3) -> Double?

    Plane3::signed_distance

    source
    fn Plane3::signed_distance(plane : Plane3, point : Point3) -> Double

    Point2

    source
    pub(all) struct Point2 {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    Point2::minus

    source
    fn Point2::minus(a : Point2, b : Point2) -> Vec2

    Point2::new

    source
    fn Point2::new(x~ : Double, y~ : Double) -> Point2

    Point2::to_homogeneous

    source
    fn Point2::to_homogeneous(p : Point2) -> Vec3

    Point2::to_vec

    source
    fn Point2::to_vec(p : Point2) -> Vec2

    Point2::translate

    source
    fn Point2::translate(p : Point2, v : Vec2) -> Point2

    Point3

    source
    pub(all) struct Point3 {
      x : Double
      y : Double
      z : Double
    } derive(Eq, 
    Debug    )

    Point3::minus

    source
    fn Point3::minus(a : Point3, b : Point3) -> Vec3

    Point3::new

    source
    fn Point3::new(x~ : Double, y~ : Double, z~ : Double) -> Point3

    Point3::to_vec

    source
    fn Point3::to_vec(p : Point3) -> Vec3

    Point3::translate

    source
    fn Point3::translate(p : Point3, v : Vec3) -> Point3

    PointCloud

    source
    pub(all) struct PointCloud {
      points : Array[Point3]
    } derive(Eq, 
    Debug    )

    PointCloud::bounds

    source
    fn PointCloud::bounds(cloud : PointCloud) -> Aabb3 raise GeometryError

    PointCloud::centroid

    source
    fn PointCloud::centroid(cloud : PointCloud) -> Point3 raise GeometryError

    PointCloud::depth_range

    source
    fn PointCloud::depth_range(cloud : PointCloud) -> (Double, Double) raise GeometryError

    PointCloud::filter_depth

    source
    fn PointCloud::filter_depth(cloud : PointCloud, minimum~ : Double, maximum~ : Double) -> PointCloud raise GeometryError

    PointCloud::from_points

    source
    fn PointCloud::from_points(points : ArrayView[Point3]) -> PointCloud

    PointCloud::is_empty

    source
    fn PointCloud::is_empty(cloud : PointCloud) -> Bool

    PointCloud::length

    source
    fn PointCloud::length(cloud : PointCloud) -> Int

    PointCloud::positive_depth_ratio

    source
    fn PointCloud::positive_depth_ratio(cloud : PointCloud) -> Double

    PointCloud::rms_radius

    source
    fn PointCloud::rms_radius(cloud : PointCloud) -> Double raise GeometryError

    PointCloud::valid_depth_count

    source
    fn PointCloud::valid_depth_count(cloud : PointCloud) -> Int

    PointCloudPipelineSummary

    source
    pub(all) struct PointCloudPipelineSummary {
      count : Int
      centroid : Point3
      minimum : Point3
      maximum : Point3
      radius : Double
      mean_distance : Double
      maximum_distance : Double
    } derive(Eq, 
    Debug    )

    Production point-cloud operators used by calibration and reconstruction.

    The functions in this file deliberately operate on plain arrays. This keeps the package usable in Wasm, native batch tools, and embedded applications without forcing callers to adopt a storage backend.

    Quadratic

    source
    pub(all) struct Quadratic {
      a : Double
      b : Double
      c : Double
    } derive(Eq, 
    Debug    )

    Quadratic::derivative

    source
    fn Quadratic::derivative(q : Quadratic, x : Double) -> Double

    Quadratic::evaluate

    source
    fn Quadratic::evaluate(q : Quadratic, x : Double) -> Double

    Quadratic::new

    source
    fn Quadratic::new(a~ : Double, b~ : Double, c~ : Double) -> Quadratic

    Quadratic::roots

    source
    fn Quadratic::roots(q : Quadratic) -> Array[Double] raise GeometryError

    Quaternion

    source
    pub(all) struct Quaternion {
      w : Double
      x : Double
      y : Double
      z : Double
    } derive(Eq, 
    Debug    )

    Quaternion::conjugate

    source
    fn Quaternion::conjugate(q : Quaternion) -> Quaternion

    Quaternion::identity

    source
    fn Quaternion::identity() -> Quaternion

    Quaternion::mul

    source

    Quaternion::new

    source
    fn Quaternion::new(w~ : Double, x~ : Double, y~ : Double, z~ : Double) -> Quaternion

    Quaternion::norm

    source
    fn Quaternion::norm(q : Quaternion) -> Double

    Quaternion::normalize

    source
    fn Quaternion::normalize(q : Quaternion) -> Quaternion raise GeometryError

    Quaternion::rotate

    source
    fn Quaternion::rotate(q : Quaternion, v : Vec3) -> Vec3

    Quaternion::to_mat3

    source
    fn Quaternion::to_mat3(q : Quaternion) -> Mat3

    Ray3

    source
    pub(all) struct Ray3 {
      origin : Point3
      direction : Vec3
    } derive(Eq, 
    Debug    )

    Ray3::closest_midpoint

    source
    fn Ray3::closest_midpoint(a : Ray3, b : Ray3) -> Point3 raise GeometryError

    Ray3::closest_separation

    source
    fn Ray3::closest_separation(a : Ray3, b : Ray3) -> Double raise GeometryError

    Ray3::new

    source
    fn Ray3::new(origin~ : Point3, direction~ : Vec3) -> Ray3 raise GeometryError

    Ray3::point_at

    source
    fn Ray3::point_at(ray : Ray3, depth : Double) -> Point3

    Rect2

    source
    pub(all) struct Rect2 {
      min : Point2
      max : Point2
    } derive(Eq, 
    Debug    )

    Rect2::area

    source
    fn Rect2::area(rect : Rect2) -> Double

    Rect2::center

    source
    fn Rect2::center(rect : Rect2) -> Point2

    Rect2::contains

    source
    fn Rect2::contains(rect : Rect2, p : Point2) -> Bool

    Rect2::expand

    source
    fn Rect2::expand(rect : Rect2, margin : Double) -> Rect2 raise GeometryError

    Rect2::from_center_size

    source
    fn Rect2::from_center_size(center~ : Point2, width~ : Double, height~ : Double) -> Rect2 raise GeometryError

    Rect2::height

    source
    fn Rect2::height(rect : Rect2) -> Double

    Rect2::intersection

    source
    fn Rect2::intersection(a : Rect2, b : Rect2) -> Rect2?

    Rect2::new

    source
    fn Rect2::new(min~ : Point2, max~ : Point2) -> Rect2 raise GeometryError

    Rect2::union

    source
    fn Rect2::union(a : Rect2, b : Rect2) -> Rect2

    Rect2::width

    source
    fn Rect2::width(rect : Rect2) -> Double

    RigidTransform

    source
    pub(all) struct RigidTransform {
      rotation : Mat3
      translation : Vec3
    } derive(Eq, 
    Debug    )

    RigidTransform::apply

    source

    RigidTransform::compose

    source

    RigidTransform::identity

    source
    fn RigidTransform::identity() -> RigidTransform

    RigidTransform::inverse

    source

    RigidTransform::new

    source
    fn RigidTransform::new(rotation~ : Mat3, translation~ : Vec3) -> RigidTransform

    ScalarGrid

    source
    pub(all) struct ScalarGrid {
      width : Int
      height : Int
      values : Array[Double]
    }

    Regular scalar grid used for masks, heatmaps, and calibration residuals.

    ScalarGrid::bilinear

    source
    fn ScalarGrid::bilinear(grid : ScalarGrid, x : Double, y : Double) -> Double?

    ScalarGrid::contains

    source
    fn ScalarGrid::contains(grid : ScalarGrid, x : Int, y : Int) -> Bool

    ScalarGrid::get

    source
    fn ScalarGrid::get(grid : ScalarGrid, x : Int, y : Int) -> Double?

    ScalarGrid::height

    source
    fn ScalarGrid::height(grid : ScalarGrid) -> Int

    ScalarGrid::length

    source
    fn ScalarGrid::length(grid : ScalarGrid) -> Int

    ScalarGrid::map

    source
    fn ScalarGrid::map(grid : ScalarGrid, f : (Double) -> Double) -> ScalarGrid

    ScalarGrid::mean

    source
    fn ScalarGrid::mean(grid : ScalarGrid) -> Double

    ScalarGrid::min_max

    source
    fn ScalarGrid::min_max(grid : ScalarGrid) -> (Double, Double)?

    ScalarGrid::new

    source
    fn ScalarGrid::new(width~ : Int, height~ : Int, fill~ : Double) -> ScalarGrid

    ScalarGrid::set

    source
    fn ScalarGrid::set(grid : ScalarGrid, x : Int, y : Int, value : Double) -> Bool

    ScalarGrid::sum

    source
    fn ScalarGrid::sum(grid : ScalarGrid) -> Double

    ScalarGrid::width

    source
    fn ScalarGrid::width(grid : ScalarGrid) -> Int

    StreamingSummary

    source
    pub(all) struct StreamingSummary {
      count : Int
      mean : Double
      variance : Double
      minimum : Double
      maximum : Double
    } derive(Eq, 
    Debug    )

    Online scalar statistics for long-running reconstruction jobs.

    StreamingSummary::is_empty

    source
    fn StreamingSummary::is_empty(summary : StreamingSummary) -> Bool

    StreamingSummary::population_variance

    source
    fn StreamingSummary::population_variance(summary : StreamingSummary) -> Double

    StreamingSummary::range

    source
    fn StreamingSummary::range(summary : StreamingSummary) -> Double

    StreamingSummary::sample_variance

    source
    fn StreamingSummary::sample_variance(summary : StreamingSummary) -> Double

    StreamingSummary::standard_deviation

    source
    fn StreamingSummary::standard_deviation(summary : StreamingSummary) -> Double

    TransformChain

    source
    pub(all) struct TransformChain {
      transforms : Array[RigidTransform]
    } derive(Eq, 
    Debug    )

    TransformChain::append

    source
    fn TransformChain::append(chain : TransformChain, transform : RigidTransform) -> TransformChain

    TransformChain::apply

    source
    fn TransformChain::apply(chain : TransformChain, point : Point3) -> Point3

    TransformChain::compose

    source

    TransformChain::inverse

    source

    TransformChain::is_empty

    source
    fn TransformChain::is_empty(chain : TransformChain) -> Bool

    TransformChain::length

    source
    fn TransformChain::length(chain : TransformChain) -> Int

    TransformChain::new

    source

    Triangle3

    source
    pub(all) struct Triangle3 {
      a : Point3
      b : Point3
      c : Point3
    } derive(Eq, 
    Debug    )

    Triangle3::area

    source
    fn Triangle3::area(t : Triangle3) -> Double

    Triangle3::barycentric

    source
    fn Triangle3::barycentric(t : Triangle3, p : Point3) -> (Double, Double, Double) raise GeometryError

    Triangle3::centroid

    source
    fn Triangle3::centroid(t : Triangle3) -> Point3

    Triangle3::new

    source
    fn Triangle3::new(a~ : Point3, b~ : Point3, c~ : Point3) -> Triangle3

    Triangle3::normal

    source
    fn Triangle3::normal(t : Triangle3) -> Vec3 raise GeometryError

    Vec2

    source
    pub(all) struct Vec2 {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    Vec2::add

    source
    fn Vec2::add(a : Vec2, b : Vec2) -> Vec2

    Vec2::dot

    source
    fn Vec2::dot(a : Vec2, b : Vec2) -> Double

    Vec2::new

    source
    fn Vec2::new(x~ : Double, y~ : Double) -> Vec2

    Vec2::norm

    source
    fn Vec2::norm(v : Vec2) -> Double

    Vec2::norm2

    source
    fn Vec2::norm2(v : Vec2) -> Double

    Vec2::normalize

    source
    fn Vec2::normalize(v : Vec2) -> Vec2 raise GeometryError

    Vec2::scale

    source
    fn Vec2::scale(v : Vec2, s : Double) -> Vec2

    Vec2::sub

    source
    fn Vec2::sub(a : Vec2, b : Vec2) -> Vec2

    Vec3

    source
    pub(all) struct Vec3 {
      x : Double
      y : Double
      z : Double
    } derive(Eq, 
    Debug    )

    Vec3::add

    source
    fn Vec3::add(a : Vec3, b : Vec3) -> Vec3

    Vec3::cross

    source
    fn Vec3::cross(a : Vec3, b : Vec3) -> Vec3

    Vec3::dot

    source
    fn Vec3::dot(a : Vec3, b : Vec3) -> Double

    Vec3::new

    source
    fn Vec3::new(x~ : Double, y~ : Double, z~ : Double) -> Vec3

    Vec3::norm

    source
    fn Vec3::norm(v : Vec3) -> Double

    Vec3::norm2

    source
    fn Vec3::norm2(v : Vec3) -> Double

    Vec3::normalize

    source
    fn Vec3::normalize(v : Vec3) -> Vec3 raise GeometryError

    Vec3::scale

    source
    fn Vec3::scale(v : Vec3, s : Double) -> Vec3

    Vec3::sub

    source
    fn Vec3::sub(a : Vec3, b : Vec3) -> Vec3

    abs

    source
    fn abs(x : Double) -> Double

    add_arrays

    source
    fn add_arrays(a : ArrayView[Double], b : ArrayView[Double]) -> Array[Double] raise GeometryError

    add_scalars

    source
    fn add_scalars(left : ArrayView[Double], right : ArrayView[Double]) -> Array[Double]

    Batch arithmetic helpers for solver assembly and deterministic tests.

    all_close

    source
    fn all_close(a : ArrayView[Double], b : ArrayView[Double], tolerance? : Double) -> Bool

    almost_equal

    source
    fn almost_equal(a : Double, b : Double, eps? : Double) -> Bool

    angle_between

    source
    fn angle_between(a : Vec3, b : Vec3) -> Double raise GeometryError

    barycentric3_contains

    source
    fn barycentric3_contains(weights : (Double, Double, Double), tolerance? : Double) -> Bool

    barycentric_2d

    source
    fn barycentric_2d(a : Point2, b : Point2, c : Point2, p : Point2) -> (Double, Double, Double) raise GeometryError

    barycentric_contains

    source
    fn barycentric_contains(weights : (Double, Double, Double), tolerance? : Double) -> Bool

    batch_cross

    source
    fn batch_cross(left : ArrayView[Vec3], right : ArrayView[Vec3]) -> Array[Vec3]

    batch_dot

    source
    fn batch_dot(left : ArrayView[Vec3], right : ArrayView[Vec3]) -> Array[Double]

    batch_norms

    source
    fn batch_norms(vectors : ArrayView[Vec3]) -> Array[Double]

    bilerp2

    source
    fn bilerp2(a : Double, b : Double, c : Double, d : Double, x : Double, y : Double) -> Double

    bounding_radius

    source
    fn bounding_radius(points : ArrayView[Point3], center : Point3) -> Double

    catmull_rom_sample

    source
    fn catmull_rom_sample(points : ArrayView[Double], count_per_segment : Int) -> Array[Double]

    centroid3

    source
    fn centroid3(points : ArrayView[Point3]) -> Point3 raise GeometryError

    centroid_after_transform

    source
    fn centroid_after_transform(transform : RigidTransform, points : ArrayView[Point3]) -> Point3 raise GeometryError

    clamp

    source
    fn clamp(x : Double, lo~ : Double, hi~ : Double) -> Double

    clamp_scalars

    source
    fn clamp_scalars(values : ArrayView[Double], minimum : Double, maximum : Double) -> Array[Double]

    clamp_unit

    source
    fn clamp_unit(value : Double) -> Double

    closest_point_on_segment

    source
    fn closest_point_on_segment(a : Point2, b : Point2, point : Point2) -> Point2

    closest_point_on_triangle

    source
    fn closest_point_on_triangle(t : Triangle3, point : Point3) -> Point3 raise GeometryError

    combine_quality_scores

    source
    fn combine_quality_scores(scores : ArrayView[Double], weights : ArrayView[Double]) -> Double raise GeometryError

    compose_inverse_transforms

    source
    fn compose_inverse_transforms(transforms : ArrayView[RigidTransform]) -> RigidTransform

    compose_transforms

    source
    fn compose_transforms(transforms : ArrayView[RigidTransform]) -> RigidTransform

    condition_proxy2

    source
    fn condition_proxy2(points : ArrayView[Point2]) -> Double raise GeometryError

    condition_proxy3

    source
    fn condition_proxy3(points : ArrayView[Point3]) -> Double raise GeometryError

    coordinate_extent2

    source
    fn coordinate_extent2(points : ArrayView[Point2]) -> Double raise GeometryError

    coordinate_extent3

    source
    fn coordinate_extent3(points : ArrayView[Point3]) -> Double raise GeometryError

    coordinate_finite_point2

    source
    fn coordinate_finite_point2(p : Point2) -> Bool

    coordinate_finite_point3

    source
    fn coordinate_finite_point3(p : Point3) -> Bool

    correlation_streaming

    source
    fn correlation_streaming(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    cosine_interpolation2

    source
    fn cosine_interpolation2(left : Double, right : Double, amount : Double) -> Double

    cosine_similarity_values

    source
    fn cosine_similarity_values(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    count_above

    source
    fn count_above(values : ArrayView[Double], threshold : Double) -> Int

    count_below

    source
    fn count_below(values : ArrayView[Double], threshold : Double) -> Int

    covariance_2d

    source
    fn covariance_2d(points : ArrayView[Point2]) -> Mat3 raise GeometryError

    covariance_3d

    source
    fn covariance_3d(points : ArrayView[Point3]) -> Mat4 raise GeometryError

    covariance_streaming

    source
    fn covariance_streaming(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    cubic_hermite2

    source
    fn cubic_hermite2(p0 : Double, p1 : Double, tangent0 : Double, tangent1 : Double, amount : Double) -> Double

    cubic_hermite_sample

    source
    fn cubic_hermite_sample(p0 : Double, p1 : Double, tangent0 : Double, tangent1 : Double, count~ : Int) -> Array[Double]

    cubic_interpolation2

    source
    fn cubic_interpolation2(a : Double, b : Double, c : Double, d : Double, amount : Double) -> Double

    cumulative_lengths

    source
    fn cumulative_lengths(points : ArrayView[Point2]) -> Array[Double]

    cumulative_sum

    source
    fn cumulative_sum(values : ArrayView[Double]) -> Array[Double]

    damped_update

    source
    fn damped_update(current : Double, gradient : Double, damping? : Double) -> Double

    distance2

    source
    fn distance2(a : Point2, b : Point2) -> Double

    distance3

    source
    fn distance3(a : Point3, b : Point3) -> Double

    dot_array

    source
    fn dot_array(a : ArrayView[Double], b : ArrayView[Double]) -> Double raise GeometryError

    dot_scalars

    source
    fn dot_scalars(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    downsample_grid

    source
    fn downsample_grid(grid : ScalarGrid, factor : Int) -> ScalarGrid

    duplicate_count2

    source
    fn duplicate_count2(points : ArrayView[Point2], tolerance~ : Double) -> Int

    duplicate_count3

    source
    fn duplicate_count3(points : ArrayView[Point3], tolerance~ : Double) -> Int

    duplicate_point_indices

    source
    fn duplicate_point_indices(points : ArrayView[Point2], tolerance : Double) -> Array[Int]

    exponentially_weighted_mean

    source
    fn exponentially_weighted_mean(values : ArrayView[Double], decay : Double) -> Double raise GeometryError

    exponentially_weighted_variance

    source
    fn exponentially_weighted_variance(values : ArrayView[Double], decay : Double) -> Double

    finite_difference

    source
    fn finite_difference(f : (Double) -> Double, x : Double, epsilon? : Double) -> Double

    finite_difference2

    source
    fn finite_difference2(values : ArrayView[Double]) -> Array[Double]

    finite_difference_gradient

    source
    fn finite_difference_gradient(function : (Double) -> Double, value : Double, epsilon : Double) -> Double

    finite_difference_hessian

    source
    fn finite_difference_hessian(function : (Double) -> Double, value : Double, epsilon : Double) -> Double

    finite_difference_vec

    source
    fn finite_difference_vec(f : (Double) -> Vec3, x : Double, epsilon? : Double) -> Vec3

    finite_point2

    source
    fn finite_point2(p : Point2) -> Bool

    finite_point3

    source
    fn finite_point3(p : Point3) -> Bool

    finite_points3

    source
    fn finite_points3(points : ArrayView[Point3]) -> Array[Point3]

    Filter NaN and infinity values before passing data to a solver.

    finite_scalars

    source
    fn finite_scalars(values : ArrayView[Double]) -> Array[Double]

    finite_vec2

    source
    fn finite_vec2(v : Vec2) -> Bool

    Coordinate-system checks shared by camera and multiview entry points.

    finite_vec3

    source
    fn finite_vec3(v : Vec3) -> Bool

    fixed_point_history

    source
    fn fixed_point_history(initial : Double, update : (Double) -> Double, iterations : Int) -> Array[Double]

    fixed_point_iterate

    source
    fn fixed_point_iterate(initial : Double, update : (Double) -> Double, iterations~ : Int) -> Double

    Iterate a scalar fixed-point update with explicit iteration bounds.

    fixed_point_residual

    source
    fn fixed_point_residual(value : Double, update : (Double) -> Double) -> Double

    fixed_point_until

    source
    fn fixed_point_until(initial : Double, update : (Double) -> Double, tolerance : Double, maximum_iterations : Int) -> Double

    gradient_descent_1d

    source
    fn gradient_descent_1d(initial : Double, gradient : (Double) -> Double, step : Double, iterations : Int) -> Array[Double]

    gradient_step

    source
    fn gradient_step(value : Double, gradient : Double, step : Double) -> Double

    has_area2

    source
    fn has_area2(points : ArrayView[Point2], minimum_area : Double) -> Bool

    has_non_collinear_triplet

    source
    fn has_non_collinear_triplet(points : ArrayView[Point2], tolerance : Double) -> Bool

    has_volume3

    source
    fn has_volume3(points : ArrayView[Point3], minimum_volume : Double) -> Bool

    hermite_point2

    source
    fn hermite_point2(p0 : Point2, p1 : Point2, tangent0 : Vec2, tangent1 : Vec2, amount : Double) -> Point2

    hermite_point3

    source
    fn hermite_point3(p0 : Point3, p1 : Point3, tangent0 : Vec3, tangent1 : Vec3, amount : Double) -> Point3

    hermite_scalar

    source
    fn hermite_scalar(p0~ : Double, p1~ : Double, tangent0~ : Double, tangent1~ : Double, amount~ : Double) -> Double

    identity3

    source
    fn identity3() -> Mat3

    identity4

    source
    fn identity4() -> Mat4

    interpolate_array

    source
    fn interpolate_array(values : ArrayView[Double], amount : Double) -> Double

    interpolate_pose

    source
    fn interpolate_pose(a : RigidTransform, b : RigidTransform, amount : Double) -> RigidTransform

    Interpolate a rigid pose for timestamp alignment and motion compensation.

    interpolate_rotation

    source
    fn interpolate_rotation(a : Mat3, b : Mat3, amount : Double) -> Mat3

    Linearly blend rotations in quaternion space, preserving unit length.

    interpolate_table

    source
    fn interpolate_table(x : Double, xs : ArrayView[Double], ys : ArrayView[Double]) -> Double raise GeometryError

    interpolation_monotonic

    source
    fn interpolation_monotonic(values : ArrayView[Double]) -> Bool

    interpolation_range

    source
    fn interpolation_range(values : ArrayView[Double]) -> Double

    interquartile_range

    source
    fn interquartile_range(values : ArrayView[Double]) -> Double raise GeometryError

    interquartile_range2

    source
    fn interquartile_range2(values : ArrayView[Double]) -> Double raise GeometryError

    inverse_lerp2

    source
    fn inverse_lerp2(left : Double, right : Double, value : Double) -> Double

    inverse_transform_points_batch

    source
    fn inverse_transform_points_batch(transform : RigidTransform, points : ArrayView[Point3]) -> Array[Point3]

    is_collinear2

    source
    fn is_collinear2(points : ArrayView[Point2], tolerance~ : Double) -> Bool

    Test whether a 2D sample is collinear within a metric tolerance.

    is_collinear3

    source
    fn is_collinear3(points : ArrayView[Point3], tolerance~ : Double) -> Bool

    is_rotation_matrix

    source
    fn is_rotation_matrix(m : Mat3) -> Bool

    Check orthogonality and handedness with a scale-aware tolerance.

    l1_distance

    source
    fn l1_distance(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    l2_distance

    source
    fn l2_distance(left : ArrayView[Double], right : ArrayView[Double]) -> Double

    lerp2

    source
    fn lerp2(left : Double, right : Double, amount : Double) -> Double

    Linear interpolation and clamped interpolation helpers.

    lerp2_clamped

    source
    fn lerp2_clamped(left : Double, right : Double, amount : Double) -> Double

    lerp_vec3

    source
    fn lerp_vec3(a : Vec3, b : Vec3, amount : Double) -> Vec3

    line_search_backtrack

    source
    fn line_search_backtrack(function : (Double) -> Double, start : Double, direction : Double, initial_step : Double, shrink : Double, maximum : Int) -> Double

    linear_interpolate

    source
    fn linear_interpolate(a : Double, b : Double, amount : Double) -> Double

    mat34_from_rows

    source
    fn mat34_from_rows(r0 : (Double, Double, Double, Double), r1 : (Double, Double, Double, Double), r2 : (Double, Double, Double, Double)) -> Mat34

    mat3_add_batch

    source
    fn mat3_add_batch(left : ArrayView[Mat3], right : ArrayView[Mat3]) -> Array[Mat3]

    mat3_apply_batch

    source
    fn mat3_apply_batch(matrix : Mat3, vectors : ArrayView[Vec3]) -> Array[Vec3]

    Apply a 3x3 matrix to a batch of vectors.

    mat3_apply_points

    source
    fn mat3_apply_points(matrix : Mat3, points : ArrayView[Point3]) -> Array[Point3]

    mat3_determinants

    source
    fn mat3_determinants(matrices : ArrayView[Mat3]) -> Array[Double]

    mat3_frobenius_batch

    source
    fn mat3_frobenius_batch(matrices : ArrayView[Mat3]) -> Array[Double]

    mat3_from_rows

    source
    fn mat3_from_rows(r0 : (Double, Double, Double), r1 : (Double, Double, Double), r2 : (Double, Double, Double)) -> Mat3

    mat3_scale_batch

    source
    fn mat3_scale_batch(matrices : ArrayView[Mat3], scale : Double) -> Array[Mat3]

    mat3_transpose_batch

    source
    fn mat3_transpose_batch(matrices : ArrayView[Mat3]) -> Array[Mat3]

    mat4_from_rows

    source
    fn mat4_from_rows(r0 : (Double, Double, Double, Double), r1 : (Double, Double, Double, Double), r2 : (Double, Double, Double, Double), r3 : (Double, Double, Double, Double)) -> Mat4

    matrix3_from_diagonal

    source
    fn matrix3_from_diagonal(diagonal : Vec3) -> Mat3

    matrix3_is_finite

    source
    fn matrix3_is_finite(matrix : Mat3) -> Bool

    max_error

    source
    fn max_error(errors : ArrayView[Double]) -> Double raise GeometryError

    max_residual

    source
    fn max_residual(residuals : ArrayView[Double]) -> Double

    mean

    source
    fn mean(values : ArrayView[Double]) -> Double raise GeometryError

    mean_point2

    source
    fn mean_point2(points : ArrayView[Point2]) -> Point2 raise GeometryError

    mean_scalars

    source
    fn mean_scalars(values : ArrayView[Double]) -> Double

    median

    source
    fn median(values : ArrayView[Double]) -> Double raise GeometryError

    median_absolute_deviation

    source
    fn median_absolute_deviation(values : ArrayView[Double]) -> Double raise GeometryError

    Return a robust median absolute deviation estimate.

    median_absolute_deviation2

    source
    fn median_absolute_deviation2(values : ArrayView[Double]) -> Double raise GeometryError

    merge_point_clouds

    source
    fn merge_point_clouds(left : PointCloud, right : PointCloud) -> PointCloud

    merge_streaming_summary

    source
    fn merge_streaming_summary(left : StreamingSummary, right : StreamingSummary) -> StreamingSummary

    mesh_centroid

    source
    fn mesh_centroid(vertices : ArrayView[Point3]) -> Point3 raise GeometryError

    mesh_diagonal

    source
    fn mesh_diagonal(vertices : ArrayView[Point3]) -> Double raise GeometryError

    mesh_surface_area

    source
    fn mesh_surface_area(vertices : ArrayView[Point3], triangles : ArrayView[(Int, Int, Int)]) -> Double

    nearest_neighbor_distances

    source
    fn nearest_neighbor_distances(points : ArrayView[Point3]) -> Array[Double]

    newton_step

    source
    fn newton_step(q : Quadratic, x : Double) -> Double raise GeometryError

    norm_scalars

    source
    fn norm_scalars(values : ArrayView[Double]) -> Double

    normal_equation_2d

    source
    fn normal_equation_2d(x : ArrayView[Point2], values : ArrayView[Double]) -> Vec2 raise GeometryError

    normalize_points2

    source
    fn normalize_points2(points : ArrayView[Point2]) -> Array[Point2] raise GeometryError

    normalize_points3

    source
    fn normalize_points3(points : ArrayView[Point3]) -> Array[Point3] raise GeometryError

    normalize_quality_score

    source
    fn normalize_quality_score(value : Double, lower : Double, upper : Double) -> Double

    normalize_residual_vector

    source
    fn normalize_residual_vector(residuals : ArrayView[Double]) -> Array[Double]

    normalize_vectors

    source
    fn normalize_vectors(vectors : ArrayView[Vec3]) -> Array[Vec3] raise GeometryError

    normalize_weights

    source
    fn normalize_weights(weights : ArrayView[Double]) -> Array[Double] raise GeometryError

    normalized_residuals

    source
    fn normalized_residuals(residuals : ArrayView[Double], scale : Double) -> Array[Double]

    orthogonal_component

    source
    fn orthogonal_component(v : Vec3, axis : Vec3) -> Vec3 raise GeometryError

    orthogonal_projection_batch

    source
    fn orthogonal_projection_batch(vectors : ArrayView[Vec3], axis : Vec3) -> Array[Vec3] raise GeometryError

    orthogonalize_rotation

    source
    fn orthogonalize_rotation(m : Mat3) -> Mat3 raise GeometryError

    Project a near-rotation onto SO(3) using a stable transpose averaging pass.

    outer_product

    source
    fn outer_product(a : Vec3, b : Vec3) -> Mat3

    outer_products

    source
    fn outer_products(vectors : ArrayView[Vec3]) -> Array[Mat3]

    pairwise_distances

    source
    fn pairwise_distances(points : ArrayView[Point3]) -> Array[Double]

    pairwise_transform_distances

    source
    fn pairwise_transform_distances(transform : RigidTransform, points : ArrayView[Point3]) -> Array[Double]

    percentile

    source
    fn percentile(values : ArrayView[Double], fraction~ : Double) -> Double raise GeometryError

    percentile_range

    source
    fn percentile_range(values : ArrayView[Double], lower : Double, upper : Double) -> NumericRange raise GeometryError

    Approximate a percentile interval using sorted samples.

    point2_from_homogeneous

    source
    fn point2_from_homogeneous(v : Vec3) -> Point2 raise GeometryError

    point2_lerp

    source
    fn point2_lerp(a : Point2, b : Point2, amount : Double) -> Point2

    point3_lerp

    source
    fn point3_lerp(a : Point3, b : Point3, amount : Double) -> Point3

    point_cloud_abs

    source
    fn point_cloud_abs(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_align_centroids

    source
    fn point_cloud_align_centroids(source : ArrayView[Point3], target : ArrayView[Point3]) -> Array[Point3]

    point_cloud_axis_center

    source
    fn point_cloud_axis_center(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_maximum

    source
    fn point_cloud_axis_maximum(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_mean

    source
    fn point_cloud_axis_mean(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_median

    source
    fn point_cloud_axis_median(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_minimum

    source
    fn point_cloud_axis_minimum(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_normalized

    source
    fn point_cloud_axis_normalized(points : ArrayView[Point3], axis : Int) -> Array[Double]

    point_cloud_axis_offset

    source
    fn point_cloud_axis_offset(points : ArrayView[Point3], ox : Double, oy : Double, oz : Double) -> Array[Point3]

    point_cloud_axis_quantile

    source
    fn point_cloud_axis_quantile(points : ArrayView[Point3], axis : Int, quantile : Double) -> Double

    point_cloud_axis_range

    source
    fn point_cloud_axis_range(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_axis_scale

    source
    fn point_cloud_axis_scale(points : ArrayView[Point3], sx : Double, sy : Double, sz : Double) -> Array[Point3]

    point_cloud_axis_values

    source
    fn point_cloud_axis_values(points : ArrayView[Point3], axis : Int) -> Array[Double]

    point_cloud_batch_checksums

    source
    fn point_cloud_batch_checksums(batches : ArrayView[Array[Point3]]) -> Array[Double]

    point_cloud_batch_flatten

    source
    fn point_cloud_batch_flatten(batches : ArrayView[Array[Point3]]) -> Array[Point3]

    point_cloud_batch_largest

    source
    fn point_cloud_batch_largest(batches : ArrayView[Array[Point3]]) -> Array[Point3]

    point_cloud_batch_nonempty

    source
    fn point_cloud_batch_nonempty(batches : ArrayView[Array[Point3]]) -> Array[Array[Point3]]

    point_cloud_batch_quality

    source
    fn point_cloud_batch_quality(batches : ArrayView[Array[Point3]], minimum_count : Int, maximum_radius : Double) -> Array[Double]

    point_cloud_batch_smallest

    source
    fn point_cloud_batch_smallest(batches : ArrayView[Array[Point3]]) -> Array[Point3]

    point_cloud_batch_total

    source
    fn point_cloud_batch_total(batches : ArrayView[Array[Point3]]) -> Int

    point_cloud_bounds

    source
    fn point_cloud_bounds(points : ArrayView[Point3]) -> (Point3, Point3)

    point_cloud_centered

    source
    fn point_cloud_centered(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_centroid

    source
    fn point_cloud_centroid(points : ArrayView[Point3]) -> Point3

    point_cloud_centroid_delta

    source
    fn point_cloud_centroid_delta(left : ArrayView[Point3], right : ArrayView[Point3]) -> Vec3

    point_cloud_centroid_distance

    source
    fn point_cloud_centroid_distance(left : ArrayView[Point3], right : ArrayView[Point3]) -> Double

    point_cloud_chamfer

    source
    fn point_cloud_chamfer(left : ArrayView[Point3], right : ArrayView[Point3]) -> Double

    point_cloud_chamfer_one_way

    source
    fn point_cloud_chamfer_one_way(left : ArrayView[Point3], right : ArrayView[Point3]) -> Double

    point_cloud_checksum

    source
    fn point_cloud_checksum(points : ArrayView[Point3]) -> Double

    point_cloud_checksum_matches

    source
    fn point_cloud_checksum_matches(points : ArrayView[Point3], checksum : Double, tolerance : Double) -> Bool

    point_cloud_chunk

    source
    fn point_cloud_chunk(points : ArrayView[Point3], chunk_size : Int) -> Array[Array[Point3]]

    point_cloud_count_finite

    source
    fn point_cloud_count_finite(points : ArrayView[Point3]) -> Int

    point_cloud_count_within

    source
    fn point_cloud_count_within(points : ArrayView[Point3], center : Point3, radius : Double) -> Int

    point_cloud_csv

    source
    fn point_cloud_csv(points : ArrayView[Point3]) -> String

    point_cloud_csv_row

    source
    fn point_cloud_csv_row(point : Point3) -> String

    point_cloud_density

    source
    fn point_cloud_density(points : ArrayView[Point3], center : Point3, radius : Double) -> Double

    point_cloud_distance_histogram

    source
    fn point_cloud_distance_histogram(points : ArrayView[Point3], bins : Int, maximum : Double) -> Array[Int]

    point_cloud_distances

    source
    fn point_cloud_distances(points : ArrayView[Point3], center : Point3) -> Array[Double]

    point_cloud_drop

    source
    fn point_cloud_drop(points : ArrayView[Point3], count : Int) -> Array[Point3]

    point_cloud_filter_box

    source
    fn point_cloud_filter_box(points : ArrayView[Point3], minimum : Point3, maximum : Point3) -> Array[Point3]

    point_cloud_filter_radius

    source
    fn point_cloud_filter_radius(points : ArrayView[Point3], center : Point3, radius : Double) -> Array[Point3]

    point_cloud_finite_ratio

    source
    fn point_cloud_finite_ratio(points : ArrayView[Point3]) -> Double

    point_cloud_flat_dimension

    source
    fn point_cloud_flat_dimension(values : ArrayView[Double]) -> Int

    point_cloud_flat_is_valid

    source
    fn point_cloud_flat_is_valid(values : ArrayView[Double]) -> Bool

    point_cloud_flat_remainder

    source
    fn point_cloud_flat_remainder(values : ArrayView[Double]) -> Int

    point_cloud_from_flat

    source
    fn point_cloud_from_flat(values : ArrayView[Double]) -> Array[Point3]

    point_cloud_hausdorff

    source
    fn point_cloud_hausdorff(left : ArrayView[Point3], right : ArrayView[Point3]) -> Double

    point_cloud_hausdorff_one_way

    source
    fn point_cloud_hausdorff_one_way(left : ArrayView[Point3], right : ArrayView[Point3]) -> Double

    point_cloud_health_batch

    source
    fn point_cloud_health_batch(points : ArrayView[Array[Point3]], minimum_count : Int, maximum_radius : Double, tolerance : Double) -> Array[Double]

    point_cloud_health_batch_mean

    source
    fn point_cloud_health_batch_mean(points : ArrayView[Array[Point3]], minimum_count : Int, maximum_radius : Double, tolerance : Double) -> Double

    point_cloud_health_count

    source
    fn point_cloud_health_count(points : ArrayView[Point3]) -> Int

    Lightweight point-cloud health indicators for service-level monitoring.

    point_cloud_health_density

    source
    fn point_cloud_health_density(points : ArrayView[Point3], radius : Double) -> Double

    point_cloud_health_duplicates

    source
    fn point_cloud_health_duplicates(points : ArrayView[Point3], tolerance : Double) -> Double

    point_cloud_health_finite

    source
    fn point_cloud_health_finite(points : ArrayView[Point3]) -> Double

    point_cloud_health_label

    source
    fn point_cloud_health_label(score : Double) -> String

    point_cloud_health_radius

    source
    fn point_cloud_health_radius(points : ArrayView[Point3], maximum : Double) -> Double

    point_cloud_health_report

    source
    fn point_cloud_health_report(points : ArrayView[Point3], minimum_count : Int, maximum_radius : Double, tolerance : Double) -> String

    point_cloud_health_score

    source
    fn point_cloud_health_score(points : ArrayView[Point3], minimum_count : Int, maximum_radius : Double, tolerance : Double) -> Double

    point_cloud_histogram_peak

    source
    fn point_cloud_histogram_peak(histogram : ArrayView[Int]) -> Int

    point_cloud_histogram_probability

    source
    fn point_cloud_histogram_probability(histogram : ArrayView[Int]) -> Array[Double]

    point_cloud_histogram_total

    source
    fn point_cloud_histogram_total(histogram : ArrayView[Int]) -> Int

    point_cloud_interleave

    source
    fn point_cloud_interleave(left : ArrayView[Point3], right : ArrayView[Point3]) -> Array[Point3]

    point_cloud_intersection

    source
    fn point_cloud_intersection(left : ArrayView[Point3], right : ArrayView[Point3], tolerance : Double) -> Array[Point3]

    point_cloud_is_degenerate

    source
    fn point_cloud_is_degenerate(points : ArrayView[Point3], tolerance : Double) -> Bool

    point_cloud_is_finite

    source
    fn point_cloud_is_finite(points : ArrayView[Point3]) -> Bool

    point_cloud_is_planar_xy

    source
    fn point_cloud_is_planar_xy(points : ArrayView[Point3], tolerance : Double) -> Bool

    point_cloud_is_planar_xz

    source
    fn point_cloud_is_planar_xz(points : ArrayView[Point3], tolerance : Double) -> Bool

    point_cloud_is_planar_yz

    source
    fn point_cloud_is_planar_yz(points : ArrayView[Point3], tolerance : Double) -> Bool

    point_cloud_json_number

    source
    fn point_cloud_json_number(value : Double) -> String

    point_cloud_lerp

    source
    fn point_cloud_lerp(a : Point3, b : Point3, amount : Double) -> Point3

    point_cloud_lift_xy

    source
    fn point_cloud_lift_xy(points : ArrayView[Point2], depth : Double) -> Array[Point3]

    point_cloud_lift_xz

    source
    fn point_cloud_lift_xz(points : ArrayView[Point2], depth : Double) -> Array[Point3]

    point_cloud_lift_yz

    source
    fn point_cloud_lift_yz(points : ArrayView[Point2], depth : Double) -> Array[Point3]

    point_cloud_match_score

    source
    fn point_cloud_match_score(left : ArrayView[Point3], right : ArrayView[Point3], tolerance : Double) -> Double

    point_cloud_mean_distance

    source
    fn point_cloud_mean_distance(points : ArrayView[Point3], center : Point3) -> Double

    point_cloud_merge

    source
    fn point_cloud_merge(left : ArrayView[Point3], right : ArrayView[Point3]) -> Array[Point3]

    point_cloud_nearest_distance

    source
    fn point_cloud_nearest_distance(point : Point3, points : ArrayView[Point3]) -> Double

    point_cloud_nearest_distances

    source
    fn point_cloud_nearest_distances(points : ArrayView[Point3]) -> Array[Double]

    point_cloud_normalize_radius

    source
    fn point_cloud_normalize_radius(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_outlier_flags

    source
    fn point_cloud_outlier_flags(points : ArrayView[Point3], threshold : Double) -> Array[Bool]

    point_cloud_overlap

    source
    fn point_cloud_overlap(left : ArrayView[Point3], right : ArrayView[Point3], tolerance : Double) -> Double

    point_cloud_pairwise_distances

    source
    fn point_cloud_pairwise_distances(points : ArrayView[Point3]) -> Array[Double]

    point_cloud_pairwise_maximum

    source
    fn point_cloud_pairwise_maximum(points : ArrayView[Point3]) -> Double

    point_cloud_pairwise_mean

    source
    fn point_cloud_pairwise_mean(points : ArrayView[Point3]) -> Double

    point_cloud_path_length

    source
    fn point_cloud_path_length(points : ArrayView[Point3]) -> Double

    point_cloud_pipeline_summary

    source
    fn point_cloud_pipeline_summary(points : ArrayView[Point3]) -> PointCloudPipelineSummary

    point_cloud_project_xy

    source
    fn point_cloud_project_xy(points : ArrayView[Point3]) -> Array[Point2]

    point_cloud_project_xz

    source
    fn point_cloud_project_xz(points : ArrayView[Point3]) -> Array[Point2]

    point_cloud_project_yz

    source
    fn point_cloud_project_yz(points : ArrayView[Point3]) -> Array[Point2]

    point_cloud_quality_gap

    source
    fn point_cloud_quality_gap(before : ArrayView[Double], after : ArrayView[Double]) -> Double

    point_cloud_quality_improved

    source
    fn point_cloud_quality_improved(before : ArrayView[Double], after : ArrayView[Double], tolerance : Double) -> Bool

    point_cloud_quality_label

    source
    fn point_cloud_quality_label(score : Double) -> String

    point_cloud_quality_labels

    source
    fn point_cloud_quality_labels(scores : ArrayView[Double]) -> Array[String]

    point_cloud_quality_maximum

    source
    fn point_cloud_quality_maximum(scores : ArrayView[Double]) -> Double

    point_cloud_quality_mean

    source
    fn point_cloud_quality_mean(scores : ArrayView[Double]) -> Double

    point_cloud_quality_minimum

    source
    fn point_cloud_quality_minimum(scores : ArrayView[Double]) -> Double

    point_cloud_quality_pass_count

    source
    fn point_cloud_quality_pass_count(scores : ArrayView[Double], threshold : Double) -> Int

    point_cloud_quality_pass_ratio

    source
    fn point_cloud_quality_pass_ratio(scores : ArrayView[Double], threshold : Double) -> Double

    point_cloud_quality_report

    source
    fn point_cloud_quality_report(points : ArrayView[Point3], minimum_count : Int, maximum_radius : Double) -> String

    point_cloud_quality_score

    source
    fn point_cloud_quality_score(points : ArrayView[Point3], minimum_count : Int, maximum_radius : Double) -> Double

    point_cloud_quality_weighted

    source
    fn point_cloud_quality_weighted(scores : ArrayView[Double], weights : ArrayView[Double]) -> Double

    point_cloud_quality_with_reference

    source
    fn point_cloud_quality_with_reference(points : ArrayView[Point3], reference : ArrayView[Point3], tolerance : Double) -> Double

    point_cloud_radius

    source
    fn point_cloud_radius(points : ArrayView[Point3], center : Point3) -> Double

    point_cloud_radius_histogram

    source
    fn point_cloud_radius_histogram(points : ArrayView[Point3], center : Point3, bins : Int) -> Array[Int]

    point_cloud_reflect_x

    source
    fn point_cloud_reflect_x(points : ArrayView[Point3]) -> Array[Point3]

    Additional point-cloud transforms for streaming reconstruction jobs.

    point_cloud_reflect_y

    source
    fn point_cloud_reflect_y(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_reflect_z

    source
    fn point_cloud_reflect_z(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_remove_duplicates

    source
    fn point_cloud_remove_duplicates(points : ArrayView[Point3], tolerance : Double) -> Array[Point3]

    point_cloud_remove_outliers

    source
    fn point_cloud_remove_outliers(points : ArrayView[Point3], threshold : Double) -> Array[Point3]

    point_cloud_resample_line

    source
    fn point_cloud_resample_line(start : Point3, end : Point3, count : Int) -> Array[Point3]

    point_cloud_safe_mean_distance

    source
    fn point_cloud_safe_mean_distance(points : ArrayView[Point3]) -> Double

    point_cloud_safe_radius

    source
    fn point_cloud_safe_radius(points : ArrayView[Point3]) -> Double

    point_cloud_sample_endpoints

    source
    fn point_cloud_sample_endpoints(points : ArrayView[Point3], count : Int) -> Array[Point3]

    point_cloud_sample_uniform

    source
    fn point_cloud_sample_uniform(points : ArrayView[Point3], count : Int) -> Array[Point3]

    point_cloud_scale

    source
    fn point_cloud_scale(points : ArrayView[Point3], scale : Double) -> Array[Point3]

    point_cloud_sign

    source
    fn point_cloud_sign(points : ArrayView[Point3]) -> Array[Point3]

    point_cloud_squared_distances

    source
    fn point_cloud_squared_distances(points : ArrayView[Point3], center : Point3) -> Array[Double]

    point_cloud_stride

    source
    fn point_cloud_stride(points : ArrayView[Point3], stride : Int) -> Array[Point3]

    point_cloud_subtract_reference

    source
    fn point_cloud_subtract_reference(points : ArrayView[Point3], reference : ArrayView[Point3], tolerance : Double) -> Array[Point3]

    point_cloud_symmetric_overlap

    source
    fn point_cloud_symmetric_overlap(left : ArrayView[Point3], right : ArrayView[Point3], tolerance : Double) -> Double

    point_cloud_take

    source
    fn point_cloud_take(points : ArrayView[Point3], count : Int) -> Array[Point3]

    point_cloud_to_flat

    source
    fn point_cloud_to_flat(points : ArrayView[Point3]) -> Array[Double]

    Export and validation helpers for point-cloud service boundaries.

    point_cloud_translate

    source
    fn point_cloud_translate(points : ArrayView[Point3], offset : Vec3) -> Array[Point3]

    point_cloud_union

    source
    fn point_cloud_union(left : ArrayView[Point3], right : ArrayView[Point3], tolerance : Double) -> Array[Point3]

    point_cloud_validate

    source
    fn point_cloud_validate(points : ArrayView[Point3], minimum_count : Int, minimum_finite_ratio : Double) -> Bool

    point_cloud_variance_axis

    source
    fn point_cloud_variance_axis(points : ArrayView[Point3], axis : Int) -> Double

    point_cloud_voxel_count

    source
    fn point_cloud_voxel_count(points : ArrayView[Point3], voxel : Double) -> Int

    point_cloud_voxel_sample

    source
    fn point_cloud_voxel_sample(points : ArrayView[Point3], voxel : Double) -> Array[Point3]

    point_cloud_weighted_centroid

    source
    fn point_cloud_weighted_centroid(points : ArrayView[Point3], weights : ArrayView[Double]) -> Point3

    point_cloud_weighted_radius

    source
    fn point_cloud_weighted_radius(points : ArrayView[Point3], weights : ArrayView[Double]) -> Double

    points2_are_finite

    source
    fn points2_are_finite(points : ArrayView[Point2]) -> Bool

    points3_are_finite

    source
    fn points3_are_finite(points : ArrayView[Point3]) -> Bool

    polygon_centroid

    source
    fn polygon_centroid(points : ArrayView[Point2]) -> Point2 raise GeometryError

    polygon_signed_area

    source
    fn polygon_signed_area(points : ArrayView[Point2]) -> Double raise GeometryError

    polyline_length

    source
    fn polyline_length(points : ArrayView[Point2]) -> Double

    polynomial_residuals

    source
    fn polynomial_residuals(q : Quadratic, values : ArrayView[Double]) -> Array[Double]

    project_box

    source
    fn project_box(value : Double, minimum : Double, maximum : Double) -> Double

    project_box_batch

    source
    fn project_box_batch(values : ArrayView[Double], minimum : Double, maximum : Double) -> Array[Double]

    project_vector

    source
    fn project_vector(v : Vec3, axis : Vec3) -> Vec3 raise GeometryError

    quantile_linear

    source
    fn quantile_linear(values : ArrayView[Double], probability : Double) -> Double raise GeometryError

    Linear-interpolated quantile for deterministic robust estimators.

    quaternion_from_axis_angle

    source
    fn quaternion_from_axis_angle(axis : Vec3, angle : Double) -> Quaternion raise GeometryError

    range_scalars

    source
    fn range_scalars(values : ArrayView[Double]) -> Double

    rect2_from_points

    source
    fn rect2_from_points(points : ArrayView[Point2]) -> Rect2 raise GeometryError

    relative_error

    source
    fn relative_error(actual : Double, expected : Double) -> Double

    remap2

    source
    fn remap2(value : Double, source_min : Double, source_max : Double, target_min : Double, target_max : Double) -> Double

    remove_duplicate_points

    source
    fn remove_duplicate_points(points : ArrayView[Point2], tolerance : Double) -> Array[Point2]

    reprojection_error

    source
    fn reprojection_error(a : Point2, b : Point2) -> Double

    resample_array

    source
    fn resample_array(values : ArrayView[Double], count : Int) -> Array[Double]

    resample_polyline

    source
    fn resample_polyline(points : ArrayView[Point2], samples~ : Int) -> Array[Point2] raise GeometryError

    residual_gradient

    source
    fn residual_gradient(predicted : ArrayView[Double], observed : ArrayView[Double]) -> Array[Double]

    residual_jacobian_diagonal

    source
    fn residual_jacobian_diagonal(jacobian : ArrayView[Double], residuals : ArrayView[Double]) -> Array[Double]

    residual_percentile

    source
    fn residual_percentile(residuals : ArrayView[Double], percentile : Double) -> Double raise GeometryError

    residual_statistics

    source
    fn residual_statistics(errors : ArrayView[Double]) -> (Double, Double, Double) raise GeometryError

    residual_sum_squares

    source
    fn residual_sum_squares(predicted : ArrayView[Double], observed : ArrayView[Double]) -> Double

    rms_error

    source
    fn rms_error(errors : ArrayView[Double]) -> Double raise GeometryError

    robust_clip

    source
    fn robust_clip(values : ArrayView[Double], center~ : Double, scale~ : Double, multiplier~ : Double) -> Array[Double]

    robust_scale

    source
    fn robust_scale(values : ArrayView[Double]) -> Double raise GeometryError

    robust_threshold

    source
    fn robust_threshold(values : ArrayView[Double], minimum~ : Double, multiplier~ : Double) -> Double raise GeometryError

    robust_weighted_centroid3

    source
    fn robust_weighted_centroid3(points : ArrayView[Point3], weights : ArrayView[Double]) -> Point3 raise GeometryError

    Compute a weighted 3D centroid with explicit weight validation.

    robust_weighted_covariance3

    source
    fn robust_weighted_covariance3(points : ArrayView[Point3], weights : ArrayView[Double]) -> Mat3 raise GeometryError

    Weighted covariance matrix for uncertainty propagation and outlier gating.

    robust_z_scores

    source
    fn robust_z_scores(values : ArrayView[Double]) -> Array[Double] raise GeometryError

    robust_z_scores2

    source
    fn robust_z_scores2(values : ArrayView[Double]) -> Array[Double] raise GeometryError

    rotate_about_point

    source
    fn rotate_about_point(rotation : Mat3, center : Point3, point : Point3) -> Point3

    rotate_points

    source
    fn rotate_points(rotation : Mat3, points : ArrayView[Point3]) -> Array[Point3]

    Batch-apply a rotation while retaining point-array order.

    rotate_points_about_point

    source
    fn rotate_points_about_point(rotation : Mat3, center : Point3, points : ArrayView[Point3]) -> Array[Point3]

    rotation_between

    source
    fn rotation_between(from : Vec3, to : Vec3) -> Mat3 raise GeometryError

    Return a shortest-arc rotation between two non-zero directions.

    rotation_from_axis_angle

    source
    fn rotation_from_axis_angle(axis : Vec3, angle : Double) -> Mat3 raise GeometryError

    Construct a proper rotation with Rodrigues' formula.

    rotation_residual

    source
    fn rotation_residual(m : Mat3) -> Double

    Measure how far a matrix is from the SO(3) manifold.

    running_maximum

    source
    fn running_maximum(values : ArrayView[Double]) -> Array[Double]

    running_mean

    source
    fn running_mean(values : ArrayView[Double]) -> Array[Double]

    running_median_approx

    source
    fn running_median_approx(values : ArrayView[Double]) -> Array[Double]

    running_minimum

    source
    fn running_minimum(values : ArrayView[Double]) -> Array[Double]

    running_variance

    source
    fn running_variance(values : ArrayView[Double]) -> Array[Double]

    safe_divide

    source
    fn safe_divide(numerator : Double, denominator : Double) -> Double raise GeometryError

    safe_rms

    source
    fn safe_rms(errors : ArrayView[Double]) -> Double

    scale_array

    source
    fn scale_array(values : ArrayView[Double], scale : Double) -> Array[Double]

    scale_mesh

    source
    fn scale_mesh(vertices : ArrayView[Point3], scale : Double) -> Array[Point3]

    scale_points

    source
    fn scale_points(points : ArrayView[Point3], scale : Double) -> Array[Point3]

    scale_scalars

    source
    fn scale_scalars(values : ArrayView[Double], scale : Double) -> Array[Double]

    scale_vectors

    source
    fn scale_vectors(vectors : ArrayView[Vec3], scale : Double) -> Array[Vec3]

    second_difference2

    source
    fn second_difference2(values : ArrayView[Double]) -> Array[Double]

    segment_distance

    source
    fn segment_distance(a : Point2, b : Point2, point : Point2) -> Double

    skew_symmetric

    source
    fn skew_symmetric(v : Vec3) -> Mat3

    smootherstep

    source
    fn smootherstep(edge0~ : Double, edge1~ : Double, x~ : Double) -> Double

    smootherstep2

    source
    fn smootherstep2(amount : Double) -> Double

    smoothstep

    source
    fn smoothstep(edge0~ : Double, edge1~ : Double, x~ : Double) -> Double

    smoothstep2

    source
    fn smoothstep2(amount : Double) -> Double

    soft_threshold

    source
    fn soft_threshold(value : Double, threshold : Double) -> Double

    soft_threshold_batch

    source
    fn soft_threshold_batch(values : ArrayView[Double], threshold : Double) -> Array[Double]

    solve_2x2

    source
    fn solve_2x2(a00~ : Double, a01~ : Double, a10~ : Double, a11~ : Double, b0~ : Double, b1~ : Double) -> Vec2 raise GeometryError

    solve_3x3

    source
    fn solve_3x3(a : Mat3, b : Vec3) -> Vec3 raise GeometryError

    solve_diagonal

    source
    fn solve_diagonal(diagonal : ArrayView[Double], values : ArrayView[Double]) -> Array[Double] raise GeometryError

    solve_linear_2x2

    source
    fn solve_linear_2x2(a00 : Double, a01 : Double, a10 : Double, a11 : Double, b0 : Double, b1 : Double) -> (Double, Double) raise GeometryError

    solve_newton

    source
    fn solve_newton(q : Quadratic, initial~ : Double, iterations? : Int) -> Double raise GeometryError

    solve_symmetric_3x3

    source
    fn solve_symmetric_3x3(a : Mat3, b : Vec3) -> Vec3 raise GeometryError

    solver_best_value

    source
    fn solver_best_value(history : ArrayView[Double], minimization : Bool) -> Double

    solver_converged

    source
    fn solver_converged(history : ArrayView[Double], tolerance : Double) -> Bool

    solver_improvement

    source
    fn solver_improvement(history : ArrayView[Double], minimization : Bool) -> Double

    spread2

    source
    fn spread2(points : ArrayView[Point2]) -> Double raise GeometryError

    spread3

    source
    fn spread3(points : ArrayView[Point3]) -> Double raise GeometryError

    square

    source
    fn square(x : Double) -> Double

    squared_norm_array

    source
    fn squared_norm_array(values : ArrayView[Double]) -> Double

    streaming_add

    source
    fn streaming_add(summary : StreamingSummary, value : Double) -> Unit

    streaming_summary

    source
    fn streaming_summary(values : ArrayView[Double]) -> StreamingSummary

    streaming_summary_chunks

    source
    fn streaming_summary_chunks(chunks : ArrayView[Array[Double]]) -> StreamingSummary

    subtract_scalars

    source
    fn subtract_scalars(left : ArrayView[Double], right : ArrayView[Double]) -> Array[Double]

    support_ratio2

    source
    fn support_ratio2(points : ArrayView[Point2], tolerance : Double) -> Double

    support_ratio3

    source
    fn support_ratio3(points : ArrayView[Point3], tolerance : Double) -> Double

    transform_bounds

    source
    fn transform_bounds(transform : RigidTransform, points : ArrayView[Point3]) -> Aabb3 raise GeometryError

    transform_centroid

    source
    fn transform_centroid(transform : RigidTransform, points : ArrayView[Point3]) -> Point3 raise GeometryError

    transform_chain_batch

    source
    fn transform_chain_batch(chain : TransformChain, points : ArrayView[Point3]) -> Array[Point3]

    transform_distance

    source
    fn transform_distance(left : RigidTransform, right : RigidTransform) -> Double

    transform_interpolate

    source
    fn transform_interpolate(left : RigidTransform, right : RigidTransform, amount : Double) -> RigidTransform

    transform_is_identity

    source
    fn transform_is_identity(transform : RigidTransform, tolerance : Double) -> Bool

    transform_point_with_scale

    source
    fn transform_point_with_scale(transform : RigidTransform, point : Point3, scale : Double) -> Point3

    transform_points

    source
    fn transform_points(chain : TransformChain, points : ArrayView[Point3]) -> Array[Point3]

    transform_points_batch

    source
    fn transform_points_batch(transform : RigidTransform, points : ArrayView[Point3]) -> Array[Point3]

    Apply a rigid transform to a point batch.

    transform_points_with_scale

    source
    fn transform_points_with_scale(transform : RigidTransform, points : ArrayView[Point3], scale : Double) -> Array[Point3]

    transform_relative

    source
    fn transform_relative(left : RigidTransform, right : RigidTransform) -> RigidTransform

    transform_relative_points

    source
    fn transform_relative_points(left : RigidTransform, right : RigidTransform, points : ArrayView[Point3]) -> Array[Point3]

    transform_rms_radius

    source
    fn transform_rms_radius(transform : RigidTransform, points : ArrayView[Point3]) -> Double raise GeometryError

    transform_rotation_residual

    source
    fn transform_rotation_residual(transform : RigidTransform) -> Double

    transform_trajectory_length

    source
    fn transform_trajectory_length(transforms : ArrayView[RigidTransform]) -> Double

    transform_trajectory_sample

    source
    fn transform_trajectory_sample(transforms : ArrayView[RigidTransform], amount : Double) -> RigidTransform

    transform_trajectory_sample_many

    source
    fn transform_trajectory_sample_many(transforms : ArrayView[RigidTransform], count : Int) -> Array[RigidTransform]

    transform_translation_norm

    source
    fn transform_translation_norm(transform : RigidTransform) -> Double

    transform_vectors

    source
    fn transform_vectors(chain : TransformChain, vectors : ArrayView[Vec3]) -> Array[Vec3]

    transform_vectors_batch

    source
    fn transform_vectors_batch(transform : RigidTransform, vectors : ArrayView[Vec3]) -> Array[Vec3]

    translate_mesh

    source
    fn translate_mesh(vertices : ArrayView[Point3], translation : Vec3) -> Array[Point3]

    translate_points

    source
    fn translate_points(points : ArrayView[Point3], translation : Vec3) -> Array[Point3]

    translate_vectors

    source
    fn translate_vectors(vectors : ArrayView[Vec3], translation : Vec3) -> Array[Vec3]

    triangle_area3

    source
    fn triangle_area3(a : Point3, b : Point3, c : Point3) -> Double

    triangle_centroid3

    source
    fn triangle_centroid3(a : Point3, b : Point3, c : Point3) -> Point3

    triangle_plane_distance

    source
    fn triangle_plane_distance(t : Triangle3, point : Point3) -> Double raise GeometryError

    trilerp2

    source
    fn trilerp2(corners : ArrayView[Double], x : Double, y : Double, z : Double) -> Double

    trimmed_mean

    source
    fn trimmed_mean(values : ArrayView[Double], trim_fraction? : Double) -> Double raise GeometryError

    tukey_fences

    source
    fn tukey_fences(values : ArrayView[Double], multiplier? : Double) -> (Double, Double) raise GeometryError

    unique_triangle_edges

    source
    fn unique_triangle_edges(triangles : ArrayView[(Int, Int, Int)]) -> Array[(Int, Int)]

    Compute unique undirected edges from a triangle index buffer.

    validate_correspondences3d2d

    source
    fn validate_correspondences3d2d(points3 : ArrayView[Point3], points2 : ArrayView[Point2], minimum : Int) -> Bool

    Validate paired 2D/3D correspondences before estimation.

    values_inside_fences

    source
    fn values_inside_fences(values : ArrayView[Double], lower : Double, upper : Double) -> Array[Double]

    variance

    source
    fn variance(values : ArrayView[Double]) -> Double raise GeometryError

    variance_scalars

    source
    fn variance_scalars(values : ArrayView[Double]) -> Double

    vector_covariance_trace

    source
    fn vector_covariance_trace(vectors : ArrayView[Vec3]) -> Double

    vector_mean

    source
    fn vector_mean(vectors : ArrayView[Vec3]) -> Vec3

    vector_sum

    source
    fn vector_sum(vectors : ArrayView[Vec3]) -> Vec3

    vectors3_are_nonzero

    source
    fn vectors3_are_nonzero(vectors : ArrayView[Vec3], tolerance : Double) -> Bool

    weighted_centroid3

    source
    fn weighted_centroid3(points : ArrayView[Point3], weights : ArrayView[Double]) -> Point3 raise GeometryError

    weighted_mean

    source
    fn weighted_mean(values : ArrayView[Double], weights : ArrayView[Double]) -> Double raise GeometryError

    weighted_mean2

    source
    fn weighted_mean2(values : ArrayView[Double], weights : ArrayView[Double]) -> Double raise GeometryError

    weighted_variance2

    source
    fn weighted_variance2(values : ArrayView[Double], weights : ArrayView[Double]) -> Double raise GeometryError

    winsorize

    source
    fn winsorize(values : ArrayView[Double], center : Double, scale : Double, limit? : Double) -> Array[Double]

    Winsorize measurements to a symmetric robust interval.

    z_score

    source
    fn z_score(value : Double, center : Double, spread : Double) -> Double raise GeometryError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io