Library
Module
Module type
Parameter
Class
Class type
3-dimensional vector type, including basic mathematical/geometrical operations and transformations, allowing for points in 3d space, and higher level types composed of them (e.g. Path3.t
, Poly3.t
, and Mesh.t
) to be manipulated.
3d vector
val v : float -> float -> float -> t
v x y z
Construct a vector from x
, y
, and z
coordinates.
val of_tup : (float * float * float) -> t
of_tup (x, y, z)
Construct a vector from a tuple of xyz coordinates.
val to_tup : t -> float * float * float
to_tup t
Convert the vector t
to a tuple of xyz coordinates.
val zero : t
Zero vector
approx ?eps a b
Returns true if the distance between vectors a
and b
is less than or equal to the epsilon eps
.
horizontal_op f a b
Hadamard (element-wise) operation between vectors a
and b
using the function f
.
val norm : t -> float
norm t
Calculate the vector norm (a.k.a. magnitude) of t
.
distance a b
Calculate the magnitude of the difference (Hadamard subtraction) between a
and b
.
normalize t
Normalize t
to a vector for which the magnitude is equal to 1. e.g. norm (normalize t) = 1.
cross a b
Vector cross product of a
and b
. In the case of 2d vectors, the cross product is performed with an assumed z = 0.
angle_points a b c
Calculate the angle between the points a
, b
, and c
.
val ccw_theta : t -> float
ccw_theta t
Calculate the angle in radians counter-clockwise t
is from the positive x-axis along the xy plane.
vector_axis a b
Compute the vector perpendicular to the vectors a
and b
.
clockwise_sign ?eps a b c
Returns the rotational ordering (around the z-axis) of the points a
, b
, and c
as a signed float, -1.
for clockwise, and 1.
for counter-clockwise. If the points are collinear (not forming a valid triangle, within the tolerance of eps
), 0.
is returned.
collinear p1 p2 p3
Returns true
if p2
lies on the line between p1
and p3
.
lerpn a b n
Linearly interpolate n
vectors between vectors a
and b
. If endpoint
is true
, the last vector will be equal to b
, otherwise, it will be about a + (b - a) * (1 - 1 / n)
.
distance_to_vector p v
Distance from point p
to the line passing through the origin with unit direction v
.
distance_to_line ?bounds ~line t
Distance between the vector t
, and any point on line
. bounds
indicates whether each end {a; b}
of line
is bounded, or a ray (default = (false, false)
, indicating an infinite line in both directions.).
point_on_line ?eps ?bounds ~line t
Return true
if the point t
falls within eps
distance of the line
. bounds
indicates whether each end {a; b}
of line
is bounded, or a ray (default = (false, false)
, indicating an infinite line in both directions.)
line_closest_point ?bounds ~line t
Find the closest point to t
lying on the provided line
. bounds
indicates whether each end {a; b}
of line
is bounded, or a ray (default = (false, false)
, indicating an infinite line in both directions.)
lower_bounds a b
Compute the lower bounds (minima of each dimension) of the vectors a
and b
.
upper_bounds a b
Compute the upper bounds (maxima of each dimension) of the vectors a
and b
.
bbox_intersect a b
Compute the intersect of the bounding boxes a
and b
.
val bbox_area : bbox -> float
bbox_area bb
Compute the area of the bounding box bb
.
val get_x : t -> float
val get_y : t -> float
val get_z : t -> float
val to_string : t -> string
val bbox_volume : bbox -> float
bbox_volume bb
Compute the volume of the bounding box bb
.
Spatial transformations. Quaternion operations are provided when this module is included in OCADml
.
xrot ?about theta t
Rotate t
by theta
radians in around the x-axis through the origin (or the point about
if provided).
yrot ?about theta t
Rotate t
by theta
radians in around the y-axis through the origin (or the point about
if provided).
zrot ?about theta t
Rotate t
by theta
radians in around the z-axis through the origin (or the point about
if provided).
rotate ?about r t
Euler (zyx) rotation of t
by the r
(in radians) around the origin (or the point about
if provided). Equivalent to xrot x t |> yrot y |> zrot z
, where {x; y; z} = r
.
mirror ax t
Mirrors t
on a plane through the origin, defined by the normal vector ax
.
of_v2 ?z v
Create a 3d vector from the 2d vector v
by adding a z
coordinate (default = 0.
)
project p t
Project the 3d vector/point t
onto the plane p
. On partial application of p
, a Affine3.t
is computed to perform the projection transform. Alias to Plane.project
.
affine m t
Apply affine transformation matrix m
to the vector t
.
val quaternion : ?about:V3.t -> Quaternion.t -> V3.t -> V3.t
quaternion ?about q t
Rotate t
with the quaternion q
around the origin (or the point about
if provided).