Module Scad_ml.Affine3

Affine transformation matrices for transforming 3d vectors (V3.t), and 3d shapes (Scad.t) via OpenSCAD's own multmatrix, (see Scad.affine).

A 3d affine transformation matrix.

To be used with OpenSCADs multmatrix, which is applied in this library with Scad.affine.

type row = float * float * float * float
type t = {
r0c0 : float;
r0c1 : float;
r0c2 : float;
r0c3 : float;
r1c0 : float;
r1c1 : float;
r1c2 : float;
r1c3 : float;
r2c0 : float;
r2c1 : float;
r2c2 : float;
r2c3 : float;
r3c0 : float;
r3c1 : float;
r3c2 : float;
r3c3 : float;
}
val id : t

The identity matrix.

Basic Matrix Operations

val mul : t -> t -> t

mul a b

Multiply the matrices a and b.

val add : t -> t -> t

add a b

Element by element addition of the matrices a and b.

val sub : t -> t -> t

sub a b

Element by element subtraction of the matrix b from a.

val emul : t -> t -> t

emul a b

Element by element multiplication of the matrices a and b.

val ediv : t -> t -> t

ediv a b

Element by element division of the matrix a by b.

val smul : t -> float -> t

smul t s

Multiply each element of the matrix t by the scalar s.

val sdiv : t -> float -> t

sdiv t s

Divide each element of the matrix t by the scalar s.

val sadd : t -> float -> t

sadd t s

Add the scalar s to each element of the matrix t.

val ssub : t -> float -> t

ssub t s

Subtract the scalar s to from each element of the matrix t.

val transpose : t -> t

transpose t

Transpose the rows and columns of t.

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

map f t

Apply the function f to all elements of t.

val trace : t -> float

trace t

Sum the elements on the main diagonal (upper left to lower right) of t.

val get : t -> int -> int -> float

get t r c

Get the element at row and column of t. Equivalent to t.(r).(c). Raises Invalid_argument if access is out of bounds.

val compose : t -> t -> t

compose a b

Compose the affine transformations a and b. Equivalent to mul b a, which when applied, will perform the transformation a, then the transformation b.

val (%>) : t -> t -> t

a %> b

Alias to compose.

val (%) : t -> t -> t

a % b

Mathematical composition of affine transformations a and b, equivalent to mul a b.

Construction by Rows

val of_rows : row -> row -> row -> t

of_rows rows

Create an affine transformation matrix from three rows. The last row is set to 0., 0., 0., 1..

val of_row_matrix_exn : float array array -> t

of_row_matrix_exn m

Convert the float matrix m into a t if it is the correct shape (4 x 4), otherwise raise Invalid_argument.

val of_row_matrix : float array array -> ( t, string ) Stdlib.result

of_row_matrix m

Convert the float matrix m into a t if it is the correct shape (4 x 4).

Transforms

val scale : V3.t -> t

scale v

Create an affine transformation matrix from the xyz scaling vector v.

val translate : V3.t -> t

translate v

Create an affine transformation matrix from the xyz translation vector v.

val xtrans : float -> t

xtrans x

Create an affine transformation matrix that applies a translation of x distance along the x-axis.

val ytrans : float -> t

ytrans y

Create an affine transformation matrix that applies a translation of y distance along the y-axis.

val ztrans : float -> t

ztrans z

Create an affine transformation matrix that applies a translation of z distance along the z-axis.

val mirror : V3.t -> t

mirror ax

Create an affine transformation matrix that applies a reflection across the axis ax.

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

xrot ?about r

Create an affine transformation matrix that applies a x-axis rotation of r radians around the origin (or the point about if provided).

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

yrot ?about r

Create an affine transformation matrix that applies a y-axis rotation of r radians around the origin (or the point about if provided).

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

zrot ?about r

Create an affine transformation matrix that applies a z-axis rotation of r radians around the origin (or the point about if provided).

val rotate : ?about:V3.t -> V3.t -> t

rotate ?about r

Create an affine transformation matrix that applies the euler (zyx) rotation represented by r radians around the origin (or the point about if provided).

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

axis_rotate ?about ax r

Create an affine transfomation matrix that applies a rotation of r radians around the axis ax through the origin (or the point about if provided).

val align : V3.t -> V3.t -> t

align a b

Compute an affine transformation matrix that would bring the vector a into alignment with b.

val skew : ?xy:float -> ?xz:float -> ?yx:float -> ?yz:float -> ?zx:float -> ?zy:float -> unit -> t

skew ?xy ?xz ?yx ?yz ?zx ?zy ()

Create an affine transformation matrix that applies a skew transformation with the given skew factor multipliers. Factors default to 0. if not provided.

  • xy: skew along the x-axis as you get farther from the y-axis
  • xz: skew along the x-axis as you get farther from the z-axis
  • yx: skew along the y-axis as you get farther from the x-axis
  • yz: skew along the y-axis as you get farther from the z-axis
  • zx: skew along the z-axis as you get farther from the x-axis
  • zy: skew along the z-axis as you get farther from the y-axis
val skew_xy : float -> float -> t

skew_xy xa ya

Create an affine transformation matrix that applies a skew transformation along the xy plane.

  • xa: skew angle (in radians) in the direction of the x-axis
  • ya: skew angle (in radians) in the direction of the y-axis
val skew_xz : float -> float -> t

skew_xz xa za

Create and affine transformation matrix that applies a skew transformation along the xz plane.

  • xa: skew angle (in radians) in the direction of the x-axis
  • za: skew angle (in radians) in the direction of the z-axis
val skew_yz : float -> float -> t

skew_yz ya za

Create and affine transformation matrix that applies a skew transformation along the yz plane.

  • ya: skew angle (in radians) in the direction of the y-axis
  • za: skew angle (in radians) in the direction of the z-axis
val transform : t -> V3.t -> V3.t

transform t v

Apply the affine transformation matrix t to the vector v.

Output

val to_string : t -> string

to_string t

Convert the matrix t to a simple string representation compatible with OpenSCAD multmatrix.

Conversions

val project : t -> Affine2.t

project t

Project t down into a 2d affine transformation matrix (z axis components dropped).

val of_quaternion : ?trans:V3.t -> Quaternion.t -> Affine3.t

of_quaternion q

Create an affine transformation matrix equivalent to the quaternion q.