| java.lang.Object
 com.vividsolutions.jump.geom.AffineTransformation
| AffineTransformation | | public class AffineTransformation implements Cloneable,CoordinateFilter(Code) | | This class represents a affine transformation on the 2D Cartesian plane.
It can be used to transform a
Coordinate or
Geometry .
An affine transformation is a mapping of the 2D plane into itself
via a series of transformations of the following basic types:
- reflection
- rotation
- scaling
- shearing
- translation
In general, affine transformations preserve straightness and parallel lines,
but do not preserve distance or shape.
An affine transformation can be represented by a 3x3
matrix in the following form:
T = | m00 m01 m02 |
| m10 m11 m12 |
| 0 0 1 |
A coordinate P = (x, y) can be transformed to a new coordinate P' = (x', y')
by representing it as a 3x1 matrix and using matrix multiplication to compute:
| x' | = T x | x |
| y' | | y |
| 1 | | 1 |
Affine transformations can be composed using the
AffineTransformation.compose method.
Composition is not commutative.
Composition is computed via multiplication of the
transformation matrices as follows:
A.compose(B) = TB x TA
This produces a transformation whose effect is that of A followed by B.
The methods
AffineTransformation.reflect ,
AffineTransformation.rotate ,
AffineTransformation.scale ,
AffineTransformation.shear , and
AffineTransformation.translate
have the effect of composing a transformation of that type with
the transformation they are applied to.
author:
Martin Davis |
| Constructor Summary | |
| public | AffineTransformation()
| | public | AffineTransformation(double[] matrix)
Constructs a new transformation whose
matrix has the specified values. | | public | AffineTransformation(double m00, double m01, double m02, double m10, double m11, double m12)
Constructs a new transformation whose
matrix has the specified values. | | public | AffineTransformation(AffineTransformation trans)
Constructs a transformation which is
a copy of the given one. | | public | AffineTransformation(Coordinate src0, Coordinate src1, Coordinate src2, Coordinate dest0, Coordinate dest1, Coordinate dest2)
Constructs a transformation
which maps the given source
points into the given destination points. |
| Method Summary | |
| public Object | clone()
| | public AffineTransformation | compose(AffineTransformation trans)
Composes the given
AffineTransformation
with this transformation. | | public AffineTransformation | composeBefore(AffineTransformation trans)
Composes this transformation
with the given
AffineTransformation . | | public boolean | equals(Object obj)
Tests if an object is an
AffineTransformation
and has the same matrix as
this transformation. | | public void | filter(Coordinate pt)
| | public double | getDeterminant()
Computes the determinant of the transformation matrix. | | public AffineTransformation | getInverse()
Computes the inverse of this transformation, if one
exists.
The inverse is the transformation which when
composed with this one produces the identity
transformation.
A transformation has an inverse if and only if it
is not singular (i.e. | | public double[] | getMatrixEntries()
Gets an array containing the entries
of the transformation matrix. | | public boolean | isIdentity()
Tests if this transformation is the identity transformation. | | public AffineTransformation | reflect(double x0, double y0, double x1, double y1)
Updates the value of this transformation
to that of a reflection transformation composed
with the current value. | | public AffineTransformation | reflect(double x, double y)
Updates the value of this transformation
to that of a reflection transformation composed
with the current value. | | public static AffineTransformation | reflectionInstance(double x0, double y0, double x1, double y1)
Creates a transformation for a reflection about the
line (x0,y0) - (x1,y1). | | public static AffineTransformation | reflectionInstance(double x, double y)
Creates a transformation for a reflection about the
line (0,0) - (x,y). | | public AffineTransformation | rotate(double theta)
Updates the value of this transformation
to that of a rotation transformation composed
with the current value. | | public AffineTransformation | rotate(double sinTheta, double cosTheta)
Updates the value of this transformation
to that of a rotation transformation composed
with the current value. | | public static AffineTransformation | rotationInstance(double theta)
Creates a transformation for a rotation
about the origin
by an angle theta. | | public static AffineTransformation | rotationInstance(double sinTheta, double cosTheta)
Creates a transformation for a rotation
by an angle theta,
specified by the sine and cosine of the angle.
This allows providing exact values for sin(theta) and cos(theta)
for the common case of rotations of multiples of quarter-circles. | | public AffineTransformation | scale(double xScale, double yScale)
Updates the value of this transformation
to that of a scale transformation composed
with the current value. | | public static AffineTransformation | scaleInstance(double xScale, double yScale)
| | public AffineTransformation | setToIdentity()
Sets this transformation to be the identity transformation. | | public AffineTransformation | setToReflection(double x0, double y0, double x1, double y1)
| | public AffineTransformation | setToReflection(double x, double y)
Sets this transformation to be a reflection
about the line defined by vector (x,y). | | public AffineTransformation | setToReflectionBasic(double x0, double y0, double x1, double y1)
Explicitly computes the math for a reflection. | | public AffineTransformation | setToRotation(double sinTheta, double cosTheta)
Sets this transformation to be a rotation
by specifying the sin and cos of the rotation angle directly. | | public AffineTransformation | setToScale(double xScale, double yScale)
Sets this transformation to be a scaling. | | public AffineTransformation | setToShear(double xShear, double yShear)
Sets this transformation to be a shear. | | public AffineTransformation | setToTranslation(double dx, double dy)
Sets this transformation to be a translation. | | public AffineTransformation | setTransformation(double m00, double m01, double m02, double m10, double m11, double m12)
Sets this transformation's matrix to have the given values. | | public AffineTransformation | setTransformation(AffineTransformation trans)
| | public AffineTransformation | shear(double xShear, double yShear)
Updates the value of this transformation
to that of a shear transformation composed
with the current value. | | public static AffineTransformation | shearInstance(double xShear, double yShear)
| | public String | toString()
Gets a text representation of this transformation. | | public Coordinate | transform(Coordinate src, Coordinate dest)
| | public CoordinateSequence | transform(CoordinateSequence seq)
| | public AffineTransformation | translate(double x, double y)
Updates the value of this transformation
to that of a translation transformation composed
with the current value. | | public static AffineTransformation | translationInstance(double x, double y)
|
| AffineTransformation | | public AffineTransformation()(Code) | | Constructs a new identity transformation
|
| AffineTransformation | | public AffineTransformation(double[] matrix)(Code) | | Constructs a new transformation whose
matrix has the specified values.
Parameters:
matrix - an array containing the 6 values { m00, m01, m02, m10, m11, m12 }
throws:
NullPointerException - if matrix is null
throws:
ArrayIndexOutOfBoundsException - if matrix is too small |
| AffineTransformation | | public AffineTransformation(double m00, double m01, double m02, double m10, double m11, double m12)(Code) | | Constructs a new transformation whose
matrix has the specified values.
Parameters:
m00 - the entry for the [0, 0] element in the transformation matrix
Parameters:
m01 - the entry for the [0, 1] element in the transformation matrix
Parameters:
m02 - the entry for the [0, 2] element in the transformation matrix
Parameters:
m10 - the entry for the [1, 0] element in the transformation matrix
Parameters:
m11 - the entry for the [1, 1] element in the transformation matrix
Parameters:
m12 - the entry for the [1, 2] element in the transformation matrix |
| AffineTransformation | | public AffineTransformation(AffineTransformation trans)(Code) | | Constructs a transformation which is
a copy of the given one.
Parameters:
trans - the transformation to copy |
| AffineTransformation | | public AffineTransformation(Coordinate src0, Coordinate src1, Coordinate src2, Coordinate dest0, Coordinate dest1, Coordinate dest2)(Code) | | Constructs a transformation
which maps the given source
points into the given destination points.
Parameters:
src0 - source point 0
Parameters:
src1 - source point 1
Parameters:
src2 - source point 2
Parameters:
dest0 - the mapped point for source point 0
Parameters:
dest1 - the mapped point for source point 1
Parameters:
dest2 - the mapped point for source point 2 |
| clone | | public Object clone()(Code) | | Clones this transformation
a copy of this transformation |
| compose | | public AffineTransformation compose(AffineTransformation trans)(Code) | | Composes the given
AffineTransformation
with this transformation.
This produces a transformation whose effect
is equal to applying this transformation
followed by the argument transformation.
Mathematically,
A.compose(B) = TB x TA
Parameters:
trans - an affine transformation this transformation, with an updated matrix |
| composeBefore | | public AffineTransformation composeBefore(AffineTransformation trans)(Code) | | Composes this transformation
with the given
AffineTransformation .
This produces a transformation whose effect
is equal to applying the argument transformation
followed by this transformation.
Mathematically,
A.composeBefore(B) = TA x TB
Parameters:
trans - an affine transformation this transformation, with an updated matrix |
| equals | | public boolean equals(Object obj)(Code) | | Tests if an object is an
AffineTransformation
and has the same matrix as
this transformation.
Parameters:
obj - an object to test true if the given object is equal to this object |
| filter | | public void filter(Coordinate pt)(Code) | | |
| getDeterminant | | public double getDeterminant()(Code) | | Computes the determinant of the transformation matrix.
The determinant is computed as:
| m00 m01 m02 |
| m10 m11 m12 | = m00 * m11 - m01 * m10
| 0 0 1 |
If the determinant is zero,
the transform is singular (not invertible),
and operations which attempt to compute
an inverse will throw a NoninvertibleTransformException.
the determinant of the transformation
See Also: AffineTransformation.getInverse() |
| getInverse | | public AffineTransformation getInverse() throws NoninvertibleTransformationException(Code) | | Computes the inverse of this transformation, if one
exists.
The inverse is the transformation which when
composed with this one produces the identity
transformation.
A transformation has an inverse if and only if it
is not singular (i.e. its
determinant is non-zero).
Geometrically, an transformation is non-invertible
if it maps the plane to a line or a point.
If no inverse exists this method
will throw a NoninvertibleTransformationException.
The matrix of the inverse is equal to the
inverse of the matrix for the transformation.
It is computed as follows:
1
inverse(A) = --- x adjoint(A)
det
= 1 | m11 -m01 m01*m12-m02*m11 |
--- x | -m10 m00 -m00*m12+m10*m02 |
det | 0 0 m00*m11-m10*m01 |
= | m11/det -m01/det m01*m12-m02*m11/det |
| -m10/det m00/det -m00*m12+m10*m02/det |
| 0 0 1 |
a new inverse transformation
throws:
NoninvertibleTransformationException -
See Also: AffineTransformation.getDeterminant() |
| getMatrixEntries | | public double[] getMatrixEntries()(Code) | | Gets an array containing the entries
of the transformation matrix.
Only the 6 non-trivial entries are returned,
in the sequence:
m00, m01, m02, m10, m11, m12
an array of length 6 |
| isIdentity | | public boolean isIdentity()(Code) | | Tests if this transformation is the identity transformation.
true if this is the identity transformation |
| reflect | | public AffineTransformation reflect(double x0, double y0, double x1, double y1)(Code) | | Updates the value of this transformation
to that of a reflection transformation composed
with the current value.
Parameters:
x0 - the x-ordinate of a point on the line to reflect around
Parameters:
y0 - the y-ordinate of a point on the line to reflect around
Parameters:
x1 - the x-ordinate of a point on the line to reflect around
Parameters:
y1 - the y-ordinate of a point on the line to reflect around this transformation, with an updated matrix |
| reflect | | public AffineTransformation reflect(double x, double y)(Code) | | Updates the value of this transformation
to that of a reflection transformation composed
with the current value.
Parameters:
x - the x-ordinate of the line to reflect around
Parameters:
y - the y-ordinate of the line to reflect around this transformation, with an updated matrix |
| reflectionInstance | | public static AffineTransformation reflectionInstance(double x0, double y0, double x1, double y1)(Code) | | Creates a transformation for a reflection about the
line (x0,y0) - (x1,y1).
Parameters:
x0 - the x-ordinate of a point on the reflection line
Parameters:
y0 - the y-ordinate of a point on the reflection line
Parameters:
x1 - the x-ordinate of a another point on the reflection line
Parameters:
y1 - the y-ordinate of a another point on the reflection line a transformation for the reflection |
| reflectionInstance | | public static AffineTransformation reflectionInstance(double x, double y)(Code) | | Creates a transformation for a reflection about the
line (0,0) - (x,y).
Parameters:
x - the x-ordinate of a point on the reflection line
Parameters:
y - the y-ordinate of a point on the reflection line a transformation for the reflection |
| rotate | | public AffineTransformation rotate(double theta)(Code) | | Updates the value of this transformation
to that of a rotation transformation composed
with the current value.
Parameters:
theta - the angle to rotate by this transformation, with an updated matrix |
| rotate | | public AffineTransformation rotate(double sinTheta, double cosTheta)(Code) | | Updates the value of this transformation
to that of a rotation transformation composed
with the current value.
Parameters:
sinTheta - the sine of the angle to rotate by
Parameters:
cosTheta - the cosine of the angle to rotate by this transformation, with an updated matrix |
| rotationInstance | | public static AffineTransformation rotationInstance(double theta)(Code) | | Creates a transformation for a rotation
about the origin
by an angle theta.
Positive angles correspond to a rotation
in the counter-clockwise direction.
Parameters:
theta - the rotation angle, in radians a transformation for the rotation |
| rotationInstance | | public static AffineTransformation rotationInstance(double sinTheta, double cosTheta)(Code) | | Creates a transformation for a rotation
by an angle theta,
specified by the sine and cosine of the angle.
This allows providing exact values for sin(theta) and cos(theta)
for the common case of rotations of multiples of quarter-circles.
Parameters:
sinTheta - the sine of the rotation angle
Parameters:
cosTheta - the cosine of the rotation angle a transformation for the rotation |
| scale | | public AffineTransformation scale(double xScale, double yScale)(Code) | | Updates the value of this transformation
to that of a scale transformation composed
with the current value.
Parameters:
xScale - the value to scale by in the x direction
Parameters:
yScale - the value to scale by in the y direction this transformation, with an updated matrix |
| setToIdentity | | public AffineTransformation setToIdentity()(Code) | | Sets this transformation to be the identity transformation.
The identity transformation has the matrix:
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |
this transformation, with an updated matrix |
| setToReflection | | public AffineTransformation setToReflection(double x, double y)(Code) | | Sets this transformation to be a reflection
about the line defined by vector (x,y).
The transformation for a reflection
is computed by:
d = sqrt(x2 + y2)
sin = x / d;
cos = x / d;
Tref = Trot(sin, cos) x Tscale(1, -1) x Trot(-sin, cos)
Parameters:
x - the x-component of the reflection line vector
Parameters:
y - the y-component of the reflection line vector this transformation, with an updated matrix |
| setToReflectionBasic | | public AffineTransformation setToReflectionBasic(double x0, double y0, double x1, double y1)(Code) | | Explicitly computes the math for a reflection. May not work.
Parameters:
x0 -
Parameters:
y0 -
Parameters:
x1 -
Parameters:
y1 - this transformation, with an updated matrix |
| setToRotation | | public AffineTransformation setToRotation(double sinTheta, double cosTheta)(Code) | | Sets this transformation to be a rotation
by specifying the sin and cos of the rotation angle directly.
The transformation matrix for the rotation
has the value:
| cosTheta -sinTheta 0 |
| sinTheta cosTheta 0 |
| 0 0 1 |
Parameters:
sinTheta - the sine of the rotation angle
Parameters:
cosTheta - the cosine of the rotation angle this transformation, with an updated matrix |
| setToScale | | public AffineTransformation setToScale(double xScale, double yScale)(Code) | | Sets this transformation to be a scaling.
The transformation matrix for a scale
has the value:
| xScale 0 dx |
| 1 yScale dy |
| 0 0 1 |
Parameters:
xScale - the amount to scale x-ordinates by
Parameters:
yScale - the amount to scale y-ordinates by this transformation, with an updated matrix |
| setToShear | | public AffineTransformation setToShear(double xShear, double yShear)(Code) | | Sets this transformation to be a shear.
The transformation matrix for a shear
has the value:
| 1 xShear 0 |
| yShear 1 0 |
| 0 0 1 |
Note that a shear of (1, 1) is not
equal to shear(1, 0) composed with shear(0, 1).
Instead, shear(1, 1) corresponds to a mapping onto the
line x = y.
Parameters:
xShear - the x component to shear by
Parameters:
yShear - the y component to shear by this transformation, with an updated matrix |
| setToTranslation | | public AffineTransformation setToTranslation(double dx, double dy)(Code) | | Sets this transformation to be a translation.
For a translation by the vector (x, y)
the transformation matrix has the value:
| 1 0 dx |
| 1 0 dy |
| 0 0 1 |
Parameters:
dx - the x component to translate by
Parameters:
dy - the y component to translate by this transformation, with an updated matrix |
| setTransformation | | public AffineTransformation setTransformation(double m00, double m01, double m02, double m10, double m11, double m12)(Code) | | Sets this transformation's matrix to have the given values.
Parameters:
m00 - the entry for the [0, 0] element in the transformation matrix
Parameters:
m01 - the entry for the [0, 1] element in the transformation matrix
Parameters:
m02 - the entry for the [0, 2] element in the transformation matrix
Parameters:
m10 - the entry for the [1, 0] element in the transformation matrix
Parameters:
m11 - the entry for the [1, 1] element in the transformation matrix
Parameters:
m12 - the entry for the [1, 2] element in the transformation matrix this transformation, with an updated matrix |
| setTransformation | | public AffineTransformation setTransformation(AffineTransformation trans)(Code) | | Sets this transformation to be a copy of the given one
Parameters:
trans - a transformation to copy this transformation, with an updated matrix |
| shear | | public AffineTransformation shear(double xShear, double yShear)(Code) | | Updates the value of this transformation
to that of a shear transformation composed
with the current value.
Parameters:
xShear - the value to shear by in the x direction
Parameters:
yShear - the value to shear by in the y direction this transformation, with an updated matrix |
| toString | | public String toString()(Code) | | Gets a text representation of this transformation.
The string is of the form:
AffineTransformation[[m00, m01, m02], [m10, m11, m12]]
a string representing this transformation |
| transform | | public Coordinate transform(Coordinate src, Coordinate dest)(Code) | | |
| transform | | public CoordinateSequence transform(CoordinateSequence seq)(Code) | | |
| translate | | public AffineTransformation translate(double x, double y)(Code) | | Updates the value of this transformation
to that of a translation transformation composed
with the current value.
Parameters:
x - the value to translate by in the x direction
Parameters:
y - the value to translate by in the y direction this transformation, with an updated matrix |
|
|