Module `Gg.Box3`

type t = box3: The type for 3D boxes (cuboids).

val dim : int: dim is the dimension of the boxes of type box3.

type v = v3: The type for 3D vectors.

type p = p3: The type for 3D points.

type size = size3: The type for 3D sizes.

type m = m3: The type for matrices representing linear transformations of 3D space.

Constructors, accessors and constants

val v : p3 -> size3 -> box3: v o size is a box whose origin is o and size is size.

val v_mid : p3 -> size3 -> t: v_mid mid size is a box whose mid point is mid and size is size.

val empty : box3: empty is the empty box.

val o : box3 -> p3

o b is the origin of b.

raises Invalid_argument: on empty

val ox : box3 -> float: ox b is V3.x (o b).

val oy : box3 -> float: oy b is V3.y (o b).

val oz : box3 -> float: oz b is V3.z (o b).

val size : box3 -> size3

size b is the size of b.

raises Invalid_argument: on empty

val w : box3 -> float: w b is Size3.w (size b).

val h : box3 -> float: h b is Size3.h (size b).

val d : box3 -> float: d b is Size3.d (size b).

val zero : box3: zero is a box whose origin and size is zero.

val unit : box3: unit is the unit box which extends from zero to one in all dimensions.

val of_pts : p3 -> p3 -> box3: of_pts p p' is the smallest box whose space contains p and p'.

val add_pt : box3 -> p3 -> box3: add_pt b p is the smallest box whose space contains b and p.

Functions

val min : box3 -> p3

min b is the smallest point of b (its origin).

raises Invalid_argument: on empty

val minx : box3 -> float: minx b is V3.x (min b).

val miny : box3 -> float: miny b is V3.y (min b).

val minz : box3 -> float: minz b is V3.z (min b).

val max : box3 -> p3

max b is the greatest point of b (its size added to the origin).

raises Invalid_argument: on empty

val maxx : box3 -> float: maxx b is V3.x (max b).

val maxy : box3 -> float: maxy b is V3.y (max b).

val maxz : box3 -> float: maxz b is V3.z (max b).

val mid : box3 -> p3

mid b is the mid point between min and max.

raises Invalid_argument: on empty

val midx : box3 -> float: midx b is V3.x (mid b).

val midy : box3 -> float: midy b is V3.y (mid b).

val midz : box3 -> float: midz b is V3.z (mid b).

val fbl_pt : box3 -> p3

fbl_pt b is the far-bottom-left corner of b.

raises Invalid_argument: on empty.

val fbr_pt : box3 -> p3

fbl_pt b is the far-bottom-right corner of b.

raises Invalid_argument: on empty.

val ftl_pt : box3 -> p3

fbl_pt b is the far-top-left corner of b.

raises Invalid_argument: on empty.

val ftr_pt : box3 -> p3

fbl_pt b is the far-top-right corner of b.

raises Invalid_argument: on empty.

val nbl_pt : box3 -> p3

nbl_pt b is the near-bottom-left corner of b.

raises Invalid_argument: on empty.

val nbr_pt : box3 -> p3

nbl_pt b is the near-bottom-right corner of b.

raises Invalid_argument: on empty.

val ntl_pt : box3 -> p3

nbl_pt b is the near-top-left corner of b.

raises Invalid_argument: on empty.

val ntr_pt : box3 -> p3

nbl_pt b is the near-top-right corner of b.

raises Invalid_argument: on empty.

val area : box3 -> float: area b is the surface area of b.

val volume : box3 -> float: volume b is the volume of b.

val inter : box3 -> box3 -> box3: inter b b' is a box whose space is the intersection of S(b) and S(b').

val union : box3 -> box3 -> box3: union b b' is the smallest box whose space contains S(b) and S(b').

val inset : v3 -> box3 -> box3: inset d b is b whose edges are inset in each dimension according to amounts in d. Negative values in d outset. If the resulting size is negative returns empty. Returns empty on empty.

val round : box3 -> box3: round b is the smallest box containing b with integer valued corners. Returns empty on empty.

val move : v3 -> box3 -> box3: move d b is b translated by d. Returns empty on empty.

val ltr : m3 -> box3 -> box3: ltr m b is the smallest box containing the corners of b transformed by m. Returns empty on empty.

val tr : m4 -> box3 -> box3: tr m b is the smallest box containing the corners of b transformed by m in homogenous 3D space. Returns empty on empty.

val map_f : (float -> float) -> box3 -> box3: map_f f b is the box whose origin and size are those of b with their components mapped by f. Returns empty on empty.

Predicates and comparisons

val is_empty : box3 -> bool: is_empty b is true iff b is empty.

val is_pt : box3 -> bool: is_pt b is true iff b is not empty and its size is equal to 0 in every dimension.

val is_plane : box3 -> bool: is_plane b is true iff the size of b is equal to 0 in exactly one dimension.

val is_seg : box3 -> bool: is_seg b is true iff b is not empty and its size is equal to 0 in exactly two dimensions.

val isects : box3 -> box3 -> bool: isects b b' is not (is_empty (inter b b')).

val subset : box3 -> box3 -> bool: subset b b' is true iff S(b) is included in S(b').

val mem : p3 -> box3 -> bool: mem p b is true iff p is in S(b).

val equal : box3 -> box3 -> bool: equal b b' is b = b'.

val equal_f : (float -> float -> bool) -> box3 -> box3 -> bool: equal_f eq b b' tests b and b' like equal but uses eq to test floating point values.

val compare : box3 -> box3 -> int: compare u v is Pervasives.compare u v.

val compare_f : (float -> float -> int) -> box3 -> box3 -> int: compare_f cmp b b' compares b and b' like compare but uses cmp to compare floating point values.

Printers

val pp : Stdlib.Format.formatter -> box3 -> unit: pp ppf b prints a textual representation of b on ppf.

val pp_f : (Stdlib.Format.formatter -> float -> unit) -> Stdlib.Format.formatter -> box3 -> unit: pp_f pp_fl ppf b prints b like pp but uses pp_fl to print floating point values.