mooncakes.io

camera
→
core
→
examples
→
multiview
→
ransac
→
README
U
Aabb3
U
Affine2D
U
CalibrationObservation
U
CalibrationReport
U
CameraIntrinsics
U
CameraPose
U
ConsensusReport
U
Distortion
U
EssentialMatrix
U
Frustum
U
FundamentalMatrix
U
GeometryError
U
Homography
U
ImageSize
U
InlierMask
U
Line2
U
Mat3
U
Mat34
U
Mat4
U
Plane3
U
Point2
U
Point3
U
PointMatch
U
PointTrack
U
Quadratic
U
Quaternion
U
RansacConfig
U
RansacResult
U
Ray3
U
ReconstructionReport
U
Rect2
U
RigidTransform
U
RollingShutter
U
StereoPair
U
Triangle3
U
TriangulatedPoint
U
Vec2
U
Vec3
V
adaptive_iteration_bound
V
almost_equal
V
calibration_report
V
clamp
V
depth_from_disparity
V
disparity_from_depth
V
distance3
V
distort_point
V
epipolar_residual
V
estimate_affine
V
estimate_essential_from_fundamental
V
estimate_fundamental
V
estimate_fundamental_from_translation
V
estimate_fundamental_ransac
V
estimate_homography
V
estimate_homography_from_four
V
estimate_homography_ransac
V
focal_from_fov
V
homography_reprojection_error
V
horizontal_fov
V
identity3
V
identity4
V
mat34_from_rows
V
mat3_from_rows
V
mean
V
median
V
mutual_matches
V
nearest_matches
V
normalized_to_pixel
V
percentile
V
pixel_to_normalized
V
point2_from_homogeneous
V
project_point
V
project_point_with_pose
V
projection_jacobian
V
quaternion_from_axis_angle
V
reconstruction_report
V
rect2_from_points
V
report_from_residuals
V
reprojection_error
V
required_iterations
V
robust_scale
V
solve_2x2
V
solve_3x3
V
triangulate_from_rays
V
triangulated_point_is_in_front
V
triangulation_angle
V
triangulation_is_well_conditioned
V
undistort_point_iterative
V
vertical_fov

README

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

#
GeometryError

pub(all) suberror GeometryError {
  DegenerateInput(String)
  NotEnoughPoints(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

#
Aabb3

source

pub(all) struct Aabb3 {
  min : Point3
  max : Point3
} derive(Eq, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
Debug)

#
Mat3::add

source

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

#
Mat3::det

source

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

#
Mat3::frobenius_norm

source

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

#
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::mul

source

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

#
Mat3::mul_vec3

source

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

#
Mat3::scale

source

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

#
Mat3::sub

source

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

#
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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

#
Plane3

source

pub(all) struct Plane3 {
  normal : Vec3
  offset : Double
} derive(Eq, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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

#
Quadratic

source

pub(all) struct Quadratic {
  a : Double
  b : Double
  c : Double
} derive(Eq, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
Debug)

#
Quaternion::conjugate

source

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

#
Quaternion::identity

source

fn Quaternion::identity() -> Quaternion

#
Quaternion::mul

source

fn Quaternion::mul(a : Quaternion, b : Quaternion) -> Quaternion

#
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
Debug)

#
RigidTransform::apply

source

fn RigidTransform::apply(t : RigidTransform, p : Point3) -> Point3

#
RigidTransform::compose

source

fn RigidTransform::compose(a : RigidTransform, b : RigidTransform) -> RigidTransform

#
RigidTransform::identity

source

fn RigidTransform::identity() -> RigidTransform

#
RigidTransform::inverse

source

fn RigidTransform::inverse(t : RigidTransform) -> RigidTransform

#
RigidTransform::new

source

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

#
Triangle3

source

pub(all) struct Triangle3 {
  a : Point3
  b : Point3
  c : Point3
} derive(Eq, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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, @moonbitlang/core/debug.Debug
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

#
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

#
bounding_radius

source

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

#
centroid3

source

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

#
clamp

source

fn clamp(x : Double, lo~ : Double, hi~ : Double) -> 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

#
covariance_2d

source

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

#
covariance_3d

source

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

#
cumulative_lengths

source

fn cumulative_lengths(points : ArrayView[Point2]) -> 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

#
finite_difference

source

fn finite_difference(f : (Double) -> Double, x : 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

#
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_table

source

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

#
interquartile_range

source

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

#
lerp_vec3

source

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

#
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_from_rows

source

fn mat3_from_rows(r0 : (Double, Double, Double), r1 : (Double, Double, Double), r2 : (Double, Double, Double)) -> 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

#
max_error

source

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

#
mean

source

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

#
mean_point2

source

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

#
median

source

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

#
newton_step

source

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

#
normal_equation_2d

source

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

#
normalize_weights

source

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

#
orthogonal_component

source

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

#
outer_product

source

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

#
percentile

source

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

#
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

#
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_vector

source

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

#
quaternion_from_axis_angle

source

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

#
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

#
reprojection_error

source

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

#
resample_polyline

source

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

#
residual_statistics

source

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

#
rms_error

source

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

#
robust_scale

source

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

#
robust_z_scores

source

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

#
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]

#
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

#
smoothstep

source

fn smoothstep(edge0~ : Double, edge1~ : Double, x~ : Double) -> 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_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

#
square

source

fn square(x : Double) -> Double

#
squared_norm_array

source

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

#
triangle_plane_distance

source

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

#
trimmed_mean

source

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

#
variance

source

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

#
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

#
z_score

source

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

Source Files

Site source Report issue Packages Build queue Skills Statistics

#GeometryError

#Aabb3

#Aabb3::center

#Aabb3::contains

#Aabb3::expand

#Aabb3::from_points

#Aabb3::volume

#Circle2

#Circle2::contains

#Circle2::new

#Circle2::signed_distance

#Line2

#Line2::from_points

#Line2::intersect

#Line2::project

#Line2::signed_distance

#Mat3

#Mat3::add

#Mat3::det

#Mat3::frobenius_norm

#Mat3::inverse

#Mat3::is_orthonormal

#Mat3::mul

#Mat3::mul_vec3

#Mat3::scale

#Mat3::sub

#Mat3::transpose

#Mat34

#Mat34::transform_point

#Mat4

#Mat4::mul

#Mat4::transform_point

#Mat4::transpose

#Plane3

#Plane3::from_points

#Plane3::project

#Plane3::ray_hit

#Plane3::signed_distance

#Point2

#Point2::minus

#Point2::new

#Point2::to_homogeneous

#Point2::to_vec

#Point2::translate

#Point3

#Point3::minus

#Point3::new

#Point3::to_vec

#Point3::translate

#Quadratic

#Quadratic::derivative

#Quadratic::evaluate

#Quadratic::new

#Quadratic::roots

#Quaternion

#Quaternion::conjugate

#Quaternion::identity

#Quaternion::mul

#Quaternion::new

#Quaternion::norm

#Quaternion::normalize

#Quaternion::rotate

#Quaternion::to_mat3

#Ray3

#Ray3::closest_midpoint

#Ray3::closest_separation

#Ray3::new

#Ray3::point_at

#Rect2

#Rect2::area

#Rect2::center

#Rect2::contains

#Rect2::expand

#Rect2::from_center_size

#Rect2::height

#Rect2::intersection

#Rect2::new

#Rect2::union

#Rect2::width

#RigidTransform

#
GeometryError

#
Aabb3

#
Aabb3::center

#
Aabb3::contains

#
Aabb3::expand

#
Aabb3::from_points

#
Aabb3::volume

#
Circle2

#
Circle2::contains

#
Circle2::new

#
Circle2::signed_distance

#
Line2

#
Line2::from_points

#
Line2::intersect

#
Line2::project

#
Line2::signed_distance

#
Mat3

#
Mat3::add

#
Mat3::det

#
Mat3::frobenius_norm

#
Mat3::inverse

#
Mat3::is_orthonormal

#
Mat3::mul

#
Mat3::mul_vec3

#
Mat3::scale

#
Mat3::sub

#
Mat3::transpose

#
Mat34

#
Mat34::transform_point

#
Mat4

#
Mat4::mul

#
Mat4::transform_point

#
Mat4::transpose

#
Plane3

#
Plane3::from_points

#
Plane3::project

#
Plane3::ray_hit

#
Plane3::signed_distance

#
Point2

#
Point2::minus

#
Point2::new

#
Point2::to_homogeneous

#
Point2::to_vec

#
Point2::translate

#
Point3

#
Point3::minus

#
Point3::new

#
Point3::to_vec

#
Point3::translate

#
Quadratic

#
Quadratic::derivative

#
Quadratic::evaluate

#
Quadratic::new

#
Quadratic::roots

#
Quaternion

#
Quaternion::conjugate

#
Quaternion::identity

#
Quaternion::mul

#
Quaternion::new

#
Quaternion::norm

#
Quaternion::normalize

#
Quaternion::rotate

#
Quaternion::to_mat3

#
Ray3

#
Ray3::closest_midpoint

#
Ray3::closest_separation

#
Ray3::new

#
Ray3::point_at

#
Rect2

#
Rect2::area

#
Rect2::center

#
Rect2::contains

#
Rect2::expand

#
Rect2::from_center_size

#
Rect2::height

#
Rect2::intersection

#
Rect2::new

#
Rect2::union

#
Rect2::width

#
RigidTransform