V2 (scad_ml.Scad

type t = v2 = {

x : float;

y : float;

}

val v : float -> float -> t

v x y

Construct a vector from x and y coordinates.

val of_tup : (float * float) -> t

of_tup (x, y)

Construct a vector from a tuple of xy coordinates.

val to_tup : t -> float * float

to_tup t

Convert the vector t to a tuple of xy coordinates.

val zero : t

Zero vector

type line = {

a : t;

b : t;

}

A line segment between two points.

type bbox = {

min : t;

max : t;

}

Bounding box.

Comparison

val equal : t -> t -> bool

equal a b

Float equality between the vectors a and b.

val compare : t -> t -> int

compare a b

Compare the vectors a and b.

val approx : ?eps:float -> t -> t -> bool

approx ?eps a b

Returns true if the distance between vectors a and b is less than or equal to the epsilon eps.

Basic Arithmetic

val horizontal_op : ( float -> float -> float ) -> t -> t -> t

horizontal_op f a b

Hadamard (element-wise) operation between vectors a and b using the function f.

val add : t -> t -> t

add a b

Hadamard (element-wise) addition of vectors a and b.

val sub : t -> t -> t

sub a b

Hadamard (element-wise) subtraction of vector b from a.

val mul : t -> t -> t

mul a b

Hadamard (element-wise) product of vectors a and b.

val div : t -> t -> t

div a b

Hadamard (element-wise) division of vector a by b.

val neg : t -> t

neg t

Negation of all elements of t.

val sadd : t -> float -> t

add_scalar t s

Element-wise addition of s to t.

val ssub : t -> float -> t

sub_scalar t s

Element-wise subtraction of s from t.

val smul : t -> float -> t

mul_scalar t s

Element-wise multiplication of t by s.

val sdiv : t -> float -> t

div_scalar t s

Element-wise division of t by s.

Vector Math

val norm : t -> float

norm t

Calculate the vector norm (a.k.a. magnitude) of t.

val distance : t -> t -> float

distance a b

Calculate the magnitude of the difference (Hadamard subtraction) between a and b.

val normalize : t -> t

normalize t

Normalize t to a vector for which the magnitude is equal to 1. e.g. norm (normalize t) = 1.

val dot : t -> t -> float

dot a b

Vector dot product of a and b.

val cross : t -> t -> v3

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.

val mid : t -> t -> t

mid a b

Compute the midpoint between the vectors a and b.

val mean : t list -> t

mean l

Calculate the mean / average of all vectors in l.

val mean' : t array -> t

mean' a

Calculate the mean / average of all vectors in the array a.

val angle : t -> t -> float

angle a b

Calculate the angle between the vectors a and b.

val angle_points : t -> t -> t -> float

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.

val vector_axis : t -> t -> v3

vector_axis a b

Compute the vector perpendicular to the vectors a and b.

val clockwise_sign : ?eps:float -> t -> t -> t -> float

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.

val collinear : t -> t -> t -> bool

collinear p1 p2 p3

Returns true if p2 lies on the line between p1 and p3.

val lerp : t -> t -> float -> t

lerp a b u

Linearly interpolate between vectors a and b.

val lerpn : ?endpoint:bool -> t -> t -> int -> t list

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).

val distance_to_vector : t -> t -> float

distance_to_vector p v

Distance from point p to the line passing through the origin with unit direction v.

val distance_to_line : ?bounds:(bool * bool) -> line:line -> t -> float

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.).

val point_on_line : 
  ?eps:float ->
  ?bounds:(bool * bool) ->
  line:line ->
  t ->
  bool

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.)

val line_closest_point : ?bounds:(bool * bool) -> line:line -> t -> t

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.)

val lower_bounds : t -> t -> t

lower_bounds a b

Compute the lower bounds (minima of each dimension) of the vectors a and b.

val upper_bounds : t -> t -> t

upper_bounds a b

Compute the upper bounds (maxima of each dimension) of the vectors a and b.

val bbox : t -> t -> bbox

bbox a b

Compute the bounding box that contains the vectors a and b.

val bbox_intersect : bbox -> bbox -> bbox option

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 bbox_centroid : bbox -> t

bbox_centroid bb

Compute the centroid of the bounding box bb.

Utilities

val map : ( float -> float ) -> t -> t

val get_x : t -> float

val get_y : t -> float

val get_z : t -> float

val to_v2 : t -> v2

val to_string : t -> string

val deg_of_rad : t -> t

deg_of_rad t

Element-wise conversion of t from radians to degrees.

val rad_of_deg : t -> t

rad_to_deg t

Element-wise conversion of t from degrees to radians.

Infix operations

val (+@) : t -> t -> t

a +@ b

Hadamard (element-wise) addition of a and b.

val (-@) : t -> t -> t

a -@ b

Hadamard (element-wise) subtraction of b from a.

val (*@) : t -> t -> t

a *@ b

Hadamard (element-wise) product of a and b.

val (/@) : t -> t -> t

a /@ b

Hadamard (element-wise) division of a by b.

val (+$) : t -> float -> t

t +$ s

Scalar addition of the vector t and scalar s.

val (-$) : t -> float -> t

t -$ s

Scalar subtraction of the scalar s from the vector t.

val (*$) : t -> float -> t

t *$ s

Scalar multiplication of the vector t by the scalar s.

val (/$) : t -> float -> t

t /$ s

Scalar division of the vector t by the scalar s.

val ortho : t -> t

ortho t

Compute the orthoganal vector of t.

val left_of_line : ?eps:float -> line:line -> t -> float

left_of_line ?eps ~line t

Return 1. if t is left of line, -1. if it is to the right, and 0. if it falls on (within eps) the line. Float is returned as this is simply a clockwise check.

val line_intersection : 
  ?eps:float ->
  ?bounds1:(bool * bool) ->
  ?bounds2:(bool * bool) ->
  line ->
  line ->
  t option

line_intersection ?eps ?bounds1 ?bounds2 a b

Find the intersection (if it exists) between the lines a and b. bounds1 and bounds2 indicate whether the ends of a and b respectively are bounded or are infinite rays.

val line_normal : t -> t -> t

line_normal p1 p2

Calculates the normal (perpendicular vector) of the line between p1 and p2.

Transformations

Equivalent to those found in Scad. Quaternion operations are provided when this module is included in Scad_ml.

val rotate : ?about:t -> float -> t -> t

rotate ?about r t

Rotation of t by r (in radians) around the origin (or the point about if provided).

val zrot : ?about:t -> float -> t -> t

zrot ?about r t

Rotation of t by r (in radians) around the origin (or the point about if provided). Alias to rotate.

val translate : t -> t -> t

translate p t

Translate t along the vector p. Equivalent to add.

val xtrans : float -> t -> t

xtrans x t

Translate t by the distance x along the x-axis.

val ytrans : float -> t -> t

ytrans y t

Translate t by the distance y along the y-axis.

val scale : t -> t -> t

scale s t

Scale t by factors s. Equivalent to mul.

val mirror : t -> t -> t

mirror ax t

Mirrors t on a plane through the origin, defined by the normal vector ax.

2d - 3d conversion

val of_v3 : v3 -> t

of_v3 v

Drop the z coordinate from v to create a 2d vector.

val to_v3 : ?z:float -> t -> v3

to_v3 ?z v

Create a 3d vector from the 2d vector v by adding a z coordinate (default = 0.)

val lift : Plane.t -> V2.t -> V3.t

lift p t

Lift the 2d vector/point t onto the plane p. On partial application of p, a Affine3.t is computed to perform the lift transform. Alias to Plane.lift.

Additional 2d transformations

val affine : Affine2.t -> V2.t -> V2.t

affine m t

Apply 2d affine transformation matrix m to the vector t.

2d to 3d transformations

val affine3 : Affine3.t -> t -> V3.t

affine3 m t

Apply 3d affine transformation matrix m to the vector t, taking it into the 3rd dimension.

val quaternion : ?about:V3.t -> Quaternion.t -> t -> V3.t

quaternion ?about q t

Rotate t with the quaternion q around the origin (or the point about if provided), taking it into the 3rd dimension.

val axis_rotate : ?about:V3.t -> V3.t -> float -> t -> V3.t

axis_rotate ?about ax a t

Rotates the vector t around the axis ax through the origin (or the point about if provided) by the angle a, taking it into the third dimension.