## smithers.java3d Class Transformation

```java.lang.Object smithers.java3d.Transformation
```

`public class Transformationextends java.lang.Object`

Represents a transformation between two real vector spaces. For example, from 3-dimensional space to 2-dimensional space. This class is general enough to include all affine linear transformations, as well as perspective transformations.

Constructor Summary
```Transformation(int n, int m)```
Constructs a new matrix representing an identity/projection/inclusion.

Method Summary
` float[]` `apply(float[] vector)`
Apply this transformation to a vector.
` float[][]` ```apply(float[][] vector, float[][] result)```
Apply this transformation to an array of vectors.
`static Transformation` ```composition(Transformation mat1, Transformation mat2)```
Computes the transformation obtained by performing the transformation `mat1` after the transformation `mat2`.
` float` `getFactor(float[] vector)`

` float[][]` `invert(float[] vector)`

`static Transformation` `perspective(int m)`
Creates a perspective transformation.
` void` `postCompose(Transformation other)`
Appends the given operation onto this one.
` void` `preCompose(Transformation other)`
Prepends the given operation onto this one.
`static Transformation` ```rotation(int n, int axis1, int axis2, float theta)```
Creates a rotation transformation.
`static Transformation` `rotation2D(float theta)`

`static Transformation` ```rotation3DFromIntrinsicXYZ(float theta1, float theta2, float theta3)```

`static Transformation` ```rotation3DFromIntrinsicZXZ(float theta1, float theta2, float theta3)```

`static Transformation` ```scale(int n, float scale)```

`static Transformation` `translation(float... vector)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Transformation

```public Transformation(int n,
int m)```
Constructs a new matrix representing an identity/projection/inclusion. If `n==m` this is an identity transformation, if `n<m` this is a projection onto the first `n` coordinates and if `n>m` then this is an inclusion of the subspace specified by the first `m` coordinates.

Parameters:
`n` - the dimension of the space to map to
`m` - the dimension of the space to map from
Method Detail

### perspective

`public static Transformation perspective(int m)`
Creates a perspective transformation. The returned transformation maps from `m` dimensions down to `m-1`. The transformation is to project onto the first `m-1` coordinates and then divide by the final coordinate.

Parameters:
`m` - the dimension to map from
Returns:
the perspective transformation

### translation

`public static Transformation translation(float... vector)`

### scale

```public static Transformation scale(int n,
float scale)```

### rotation

```public static Transformation rotation(int n,
int axis1,
int axis2,
float theta)```
Creates a rotation transformation. The returned transformation is a rotation of `n`-dimensional space which rotates the axis indexed by `axis1` towards the axis indexed by `axis2` by an angle of `theta` radians.

Parameters:
`n` - the number of dimensions
`axis1` - the axis to rotate from
`axis2` - the axis to rotate towards
`theta` - the angle to rotate by
Returns:
the rotation

### rotation2D

`public static Transformation rotation2D(float theta)`

### rotation3DFromIntrinsicZXZ

```public static Transformation rotation3DFromIntrinsicZXZ(float theta1,
float theta2,
float theta3)```

### rotation3DFromIntrinsicXYZ

```public static Transformation rotation3DFromIntrinsicXYZ(float theta1,
float theta2,
float theta3)```

### composition

```public static Transformation composition(Transformation mat1,
Transformation mat2)```
Computes the transformation obtained by performing the transformation `mat1` after the transformation `mat2`. This is in keeping with the order in the mathematical meaning of the composition `mat1` ˆ `mat2`. `mat1` must map from the same number of dimensiona that `mat2` maps to.

Parameters:
`mat1` - the operation to apply second
`mat2` - the operation to apply first
Returns:
the composite transformation

### preCompose

`public void preCompose(Transformation other)`
Prepends the given operation onto this one. The given operation must be square of the same dimension that this one maps from.

Parameters:
`other` - the transformation to be prepended

### postCompose

`public void postCompose(Transformation other)`
Appends the given operation onto this one. The given operation must be square of the same dimension that this one maps to.

Parameters:
`other` - the transformation to be appended

### getFactor

`public float getFactor(float[] vector)`

### apply

`public float[] apply(float[] vector)`
Apply this transformation to a vector. The length of the vector must be the same as the dimension this transformation maps from.

Parameters:
`vector` - the vector to transform
Returns:
the transformed vector

### apply

```public float[][] apply(float[][] vector,
float[][] result)```
Apply this transformation to an array of vectors. Each element of `vector` must be the same as the dimension this transformation maps from. If `result` is not `null`, the result vectors will be stored in it. In this case it must have the same length as `vector`, and each element must have the length of the dimension that this transformation maps to.

Parameters:
`vector` - the vectors to transform
`result` - if not `null`, the result will be stored here
Returns:
the transformed vectors

### invert

`public float[][] invert(float[] vector)`