A package for working with affine transformations. For new projects, I recommend CoordinateTransformations instead.

In julia, type

`Pkg.add("AffineTransforms")`

An affine transformation is of the form

`y = A*x + b`

This is the "forward" transformation. The "inverse" transformation is therefore

`x = A\(y-b)`

Create an affine transformation with

`tfm = AffineTransform(A, b)`

The following are all different ways of computing the forward transform:

```
y = tfm * x
y = tformfwd(tfm, x)
y = similar(x); tformfwd!(y, tfm, x)
```

Similarly, the following are all different ways of computing the inverse transform:

```
x = tfm\y
x = tforminv(tfm, y)
x = similar(y); tforminv!(x, tfm, y)
```

```
tformeye(T, nd)
tformeye(nd)
```

Creates the identity transformation in `nd`

dimensions.

`tformtranslate(v)`

Creates a shift (translation) transformation

```
tformrotate(angle) # creates a 2d rotation
tformrotate(axis, angle) # creates a 3d rotation
tformrotate(axis) # creates a 3d rotation
```

In 3d, these constructors work with angle-axis representation, where `axis`

is a 3-vector.
When `angle`

is provided, `axis`

is used as if it were normalized to have unit length.
If you just specify `axis`

, then `norm(axis)`

is used for the `angle`

.

`tformscale(scale::Real, nd)`

Creates a scaling transformation, where `A`

will have `scale`

along the diagonal.

`tformrigid(p)`

Particularly useful for optimization of rigid transformations.
If `length(p) == 3`

, this creates a 2d transform, where `p[1]`

is the rotation angle, `p[2:3]`

are
the two components of translation.
If `length(p) == 6`

, this creates a 3d transform, where `p[1:3]`

is `axis`

for `tformrotate`

,
and `p[4:6]`

are the three components of translation.

`rotationparameters(R)`

Converts a 2d or 3d rotation matrix `R`

into an `angle`

(in 2d) or the `axis`

representation (in 3d).