File: transform.mli

package info (click to toggle)
camlpdf 0.5-1
  • links: PTS, VCS
  • area: non-free
  • in suites: squeeze, wheezy
  • size: 1,516 kB
  • ctags: 2,689
  • sloc: ml: 18,229; ansic: 139; makefile: 139
file content (78 lines) | stat: -rw-r--r-- 2,760 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
(** Affine Transformations in Two Dimensions *)

(** A single transformation operation. *)
type transform_op =
  | Scale of (float * float) * float * float
  | Rotate of (float * float) * float
  | Translate of float * float
  | ShearX of (float * float) * float
  | ShearY of (float * float) * float

(** A list of transformations, the first at the end of the list (thus, to append
 another transformation, just cons to the beginning.) *)
type transform = transform_op list

(** The identity transform *) 
val i : transform

(** Make a string of a transform for debug purposes. *)
val string_of_transform : transform -> string

(** A transformation matrix (first row [a c e], second row [b d f], third row [0 0 1]) *)
type transform_matrix =
  {a : float; b : float; c : float; d : float; e : float; f : float}

(** The identity matrix *)
val i_matrix : transform_matrix

(** String of a transformation matrix. *)
val string_of_matrix : transform_matrix -> string

val mktranslate : float -> float -> transform_matrix

val mkscale : (float * float) -> float -> float -> transform_matrix

val mkrotate : (float * float) -> float -> transform_matrix

val mkshearx : (float * float) -> float -> transform_matrix

val mksheary : (float * float) -> float -> transform_matrix
(** Low-level functions to create transformation matrices *)

(** [compose t ts] adds operation [t] to the transform [ts]. *)
val compose : transform_op -> transform -> transform

(** [append a b] is a transform with the same effect as performing b then a *)
val append : (transform -> transform -> transform)

(** [compose a b] produces a matrix equivalent to performing [b] then [a]. *)
val matrix_compose : transform_matrix -> transform_matrix -> transform_matrix

exception NonInvertable

val matrix_invert : transform_matrix -> transform_matrix
(** Matrix inversion. *)

(** Transform a coordinate by a given transform. *) 
val transform : transform -> float * float -> float * float

(** Transform a coordinate by a given transformation matrix. *)
val transform_matrix : transform_matrix -> float * float -> float * float

(** Make a matrix from a single transformation operation *)
val matrix_of_op : transform_op -> transform_matrix

(** Make a matrix from a transform *)
val matrix_of_transform : transform -> transform_matrix

(** Decompose a transformation matrix to scale, aspect, rotation, shear,
translation in x, translation in y. Always succeeds, but results are not
guaranteed to mean anything. *)
val decompose :
  transform_matrix -> float * float * float * float * float * float

(** Recompose from the above information. It is not guaranteed that recompose
(decompose t) = t *)
val recompose :
  float -> float -> float -> float -> float -> float -> transform_matrix