|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectcom.vividsolutions.jts.geom.util.AffineTransformation
Represents an 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:
An affine transformation can be represented by a 3x3 matrix in the following form:
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:T = | m00 m01 m02 | | m10 m11 m12 | | 0 0 1 |
Affine transformations can be composed using the| x' | = T x | x | | y' | | y | | 1 | | 1 |
compose(com.vividsolutions.jts.geom.util.AffineTransformation)
method.
The composition of transformations is in general not commutative.
transformation matrices as follows:
This produces a transformation whose effect is that of A followed by B. Composition is computed via multiplication of the The methodsA.compose(B) = TB x TA
reflect(double, double, double, double)
, rotate(double)
, scale(double, double)
, shear(double, double)
, and translate(double, double)
have the effect of composing a transformation of that type with
the transformation they are invoked on.
Affine transformations may be invertible or non-invertible.
If a transformation is invertible, then there exists
an inverse transformation which when composed produces
the identity transformation.
The getInverse()
method
computes the inverse of a transformation, if one exists.
Constructor Summary | |
AffineTransformation()
Constructs a new identity transformation |
|
AffineTransformation(AffineTransformation trans)
Constructs a transformation which is a copy of the given one. |
|
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. |
|
AffineTransformation(double[] matrix)
Constructs a new transformation whose matrix has the specified values. |
|
AffineTransformation(double m00,
double m01,
double m02,
double m10,
double m11,
double m12)
Constructs a new transformation whose matrix has the specified values. |
Method Summary | |
java.lang.Object |
clone()
Clones this transformation |
AffineTransformation |
compose(AffineTransformation trans)
Updates this transformation to be the composition of this transformation with the given AffineTransformation . |
AffineTransformation |
composeBefore(AffineTransformation trans)
Updates this transformation to be the composition of a given AffineTransformation with this transformation. |
boolean |
equals(java.lang.Object obj)
Tests if an object is an AffineTransformation and has the same matrix as this transformation. |
void |
filter(CoordinateSequence seq,
int i)
Transforms the i'th coordinate in the input sequence |
double |
getDeterminant()
Computes the determinant of the transformation matrix. |
AffineTransformation |
getInverse()
Computes the inverse of this transformation, if one exists. |
double[] |
getMatrixEntries()
Gets an array containing the entries of the transformation matrix. |
boolean |
isDone()
Reports that this filter should continue to be executed until all coordinates have been transformed. |
boolean |
isGeometryChanged()
Reports whether the execution of this filter has modified the coordinates of the geometry. |
boolean |
isIdentity()
Tests if this transformation is the identity transformation. |
AffineTransformation |
reflect(double x,
double y)
Updates the value of this transformation to that of a reflection transformation composed with the current value. |
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. |
static AffineTransformation |
reflectionInstance(double x,
double y)
Creates a transformation for a reflection about the line (0,0) - (x,y). |
static AffineTransformation |
reflectionInstance(double x0,
double y0,
double x1,
double y1)
Creates a transformation for a reflection about the line (x0,y0) - (x1,y1). |
AffineTransformation |
rotate(double theta)
Updates the value of this transformation to that of a rotation transformation composed with the current value. |
AffineTransformation |
rotate(double sinTheta,
double cosTheta)
Updates the value of this transformation to that of a rotation around the origin composed with the current value, with the sin and cos of the rotation angle specified directly. |
AffineTransformation |
rotate(double theta,
double x,
double y)
Updates the value of this transformation to that of a rotation around a given point composed with the current value. |
AffineTransformation |
rotate(double sinTheta,
double cosTheta,
double x,
double y)
Updates the value of this transformation to that of a rotation around a given point composed with the current value, with the sin and cos of the rotation angle specified directly. |
static AffineTransformation |
rotationInstance(double theta)
Creates a transformation for a rotation about the origin by an angle theta. |
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. |
static AffineTransformation |
rotationInstance(double theta,
double x,
double y)
Creates a transformation for a rotation about the point (x,y) by an angle theta. |
static AffineTransformation |
rotationInstance(double sinTheta,
double cosTheta,
double x,
double y)
Creates a transformation for a rotation about the point (x,y) by an angle theta, specified by the sine and cosine of the angle. |
AffineTransformation |
scale(double xScale,
double yScale)
Updates the value of this transformation to that of a scale transformation composed with the current value. |
static AffineTransformation |
scaleInstance(double xScale,
double yScale)
Creates a transformation for a scaling relative to the origin. |
static AffineTransformation |
scaleInstance(double xScale,
double yScale,
double x,
double y)
Creates a transformation for a scaling relative to the point (x,y). |
AffineTransformation |
setToIdentity()
Sets this transformation to be the identity transformation. |
AffineTransformation |
setToReflection(double x,
double y)
Sets this transformation to be a reflection about the line defined by vector (x,y). |
AffineTransformation |
setToReflection(double x0,
double y0,
double x1,
double y1)
|
AffineTransformation |
setToReflectionBasic(double x0,
double y0,
double x1,
double y1)
Explicitly computes the math for a reflection. |
AffineTransformation |
setToRotation(double theta)
Sets this transformation to be a rotation around the origin. |
AffineTransformation |
setToRotation(double sinTheta,
double cosTheta)
Sets this transformation to be a rotation around the origin by specifying the sin and cos of the rotation angle directly. |
AffineTransformation |
setToRotation(double theta,
double x,
double y)
Sets this transformation to be a rotation around a given point (x,y). |
AffineTransformation |
setToRotation(double sinTheta,
double cosTheta,
double x,
double y)
Sets this transformation to be a rotation around a given point (x,y) by specifying the sin and cos of the rotation angle directly. |
AffineTransformation |
setToScale(double xScale,
double yScale)
Sets this transformation to be a scaling. |
AffineTransformation |
setToShear(double xShear,
double yShear)
Sets this transformation to be a shear. |
AffineTransformation |
setToTranslation(double dx,
double dy)
Sets this transformation to be a translation. |
AffineTransformation |
setTransformation(AffineTransformation trans)
Sets this transformation to be a copy of the given one |
AffineTransformation |
setTransformation(double m00,
double m01,
double m02,
double m10,
double m11,
double m12)
Sets this transformation's matrix to have the given values. |
AffineTransformation |
shear(double xShear,
double yShear)
Updates the value of this transformation to that of a shear transformation composed with the current value. |
static AffineTransformation |
shearInstance(double xShear,
double yShear)
Creates a transformation for a shear. |
java.lang.String |
toString()
Gets a text representation of this transformation. |
Coordinate |
transform(Coordinate src,
Coordinate dest)
Applies this transformation to the src coordinate and places the results in the dest coordinate (which may be the same as the source). |
void |
transform(CoordinateSequence seq,
int i)
Applies this transformation to the i'th coordinate in the given CoordinateSequence. |
Geometry |
transform(Geometry g)
Cretaes a new @link Geometry which is the result of this transformation applied to the input Geometry. |
AffineTransformation |
translate(double x,
double y)
Updates the value of this transformation to that of a translation transformation composed with the current value. |
static AffineTransformation |
translationInstance(double x,
double y)
Creates a transformation for a translation. |
Methods inherited from class java.lang.Object |
finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
public AffineTransformation()
public AffineTransformation(double[] matrix)
matrix
- an array containing the 6 values { m00, m01, m02, m10, m11, m12 }
java.lang.NullPointerException
- if matrix is null
java.lang.ArrayIndexOutOfBoundsException
- if matrix is too smallpublic AffineTransformation(double m00, double m01, double m02, double m10, double m11, double m12)
m00
- the entry for the [0, 0] element in the transformation matrixm01
- the entry for the [0, 1] element in the transformation matrixm02
- the entry for the [0, 2] element in the transformation matrixm10
- the entry for the [1, 0] element in the transformation matrixm11
- the entry for the [1, 1] element in the transformation matrixm12
- the entry for the [1, 2] element in the transformation matrixpublic AffineTransformation(AffineTransformation trans)
trans
- the transformation to copypublic AffineTransformation(Coordinate src0, Coordinate src1, Coordinate src2, Coordinate dest0, Coordinate dest1, Coordinate dest2)
src0
- source point 0src1
- source point 1src2
- source point 2dest0
- the mapped point for source point 0dest1
- the mapped point for source point 1dest2
- the mapped point for source point 2Method Detail |
public static AffineTransformation reflectionInstance(double x0, double y0, double x1, double y1)
x0
- the x-ordinate of a point on the reflection liney0
- the y-ordinate of a point on the reflection linex1
- the x-ordinate of a another point on the reflection liney1
- the y-ordinate of a another point on the reflection line
public static AffineTransformation reflectionInstance(double x, double y)
x
- the x-ordinate of a point on the reflection liney
- the y-ordinate of a point on the reflection line
public static AffineTransformation rotationInstance(double theta)
theta
- the rotation angle, in radians
public static AffineTransformation rotationInstance(double sinTheta, double cosTheta)
sinTheta
- the sine of the rotation anglecosTheta
- the cosine of the rotation angle
public static AffineTransformation rotationInstance(double theta, double x, double y)
theta
- the rotation angle, in radiansx
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public static AffineTransformation rotationInstance(double sinTheta, double cosTheta, double x, double y)
sinTheta
- the sine of the rotation anglecosTheta
- the cosine of the rotation anglex
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public static AffineTransformation scaleInstance(double xScale, double yScale)
xScale
- the value to scale by in the x directionyScale
- the value to scale by in the y direction
public static AffineTransformation scaleInstance(double xScale, double yScale, double x, double y)
xScale
- the value to scale by in the x directionyScale
- the value to scale by in the y directionx
- the x-ordinate of the point to scale aroundy
- the y-ordinate of the point to scale around
public static AffineTransformation shearInstance(double xShear, double yShear)
xShear
- the value to shear by in the x directionyShear
- the value to shear by in the y direction
public static AffineTransformation translationInstance(double x, double y)
x
- the value to translate by in the x directiony
- the value to translate by in the y direction
public AffineTransformation setToIdentity()
| 1 0 0 | | 0 1 0 | | 0 0 1 |
public AffineTransformation setTransformation(double m00, double m01, double m02, double m10, double m11, double m12)
m00
- the entry for the [0, 0] element in the transformation matrixm01
- the entry for the [0, 1] element in the transformation matrixm02
- the entry for the [0, 2] element in the transformation matrixm10
- the entry for the [1, 0] element in the transformation matrixm11
- the entry for the [1, 1] element in the transformation matrixm12
- the entry for the [1, 2] element in the transformation matrix
public AffineTransformation setTransformation(AffineTransformation trans)
trans
- a transformation to copy
public double[] getMatrixEntries()
m00, m01, m02, m10, m11, m12
public double getDeterminant()
If the determinant is zero, the transform is singular (not invertible), and operations which attempt to compute an inverse will throw a NoninvertibleTransformException.| m00 m01 m02 | | m10 m11 m12 | = m00 * m11 - m01 * m10 | 0 0 1 |
getInverse()
public AffineTransformation getInverse() throws 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 |
NoninvertibleTransformationException
getDeterminant()
public AffineTransformation setToReflectionBasic(double x0, double y0, double x1, double y1)
x0
- y0
- x1
- y1
-
public AffineTransformation setToReflection(double x0, double y0, double x1, double y1)
public AffineTransformation setToReflection(double x, double y)
d = sqrt(x2 + y2) sin = x / d; cos = x / d; Tref = Trot(sin, cos) x Tscale(1, -1) x Trot(-sin, cos)
x
- the x-component of the reflection line vectory
- the y-component of the reflection line vector
public AffineTransformation setToRotation(double theta)
| cos(theta) -sin(theta) 0 | | sin(theta) cos(theta) 0 | | 0 0 1 |
theta
- the rotation angle, in radians
public AffineTransformation setToRotation(double sinTheta, double cosTheta)
| cosTheta -sinTheta 0 | | sinTheta cosTheta 0 | | 0 0 1 |
sinTheta
- the sine of the rotation anglecosTheta
- the cosine of the rotation angle
public AffineTransformation setToRotation(double theta, double x, double y)
| cosTheta -sinTheta x-x*cos+y*sin | | sinTheta cosTheta y-x*sin-y*cos | | 0 0 1 |
theta
- the rotation angle, in radiansx
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public AffineTransformation setToRotation(double sinTheta, double cosTheta, double x, double y)
| cosTheta -sinTheta x-x*cos+y*sin | | sinTheta cosTheta y-x*sin-y*cos | | 0 0 1 |
sinTheta
- the sine of the rotation anglecosTheta
- the cosine of the rotation anglex
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public AffineTransformation setToScale(double xScale, double yScale)
| xScale 0 dx | | 1 yScale dy | | 0 0 1 |
xScale
- the amount to scale x-ordinates byyScale
- the amount to scale y-ordinates by
public AffineTransformation setToShear(double xShear, double yShear)
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.| 1 xShear 0 | | yShear 1 0 | | 0 0 1 |
xShear
- the x component to shear byyShear
- the y component to shear by
public AffineTransformation setToTranslation(double dx, double dy)
| 1 0 dx | | 1 0 dy | | 0 0 1 |
dx
- the x component to translate bydy
- the y component to translate by
public AffineTransformation reflect(double x0, double y0, double x1, double y1)
x0
- the x-ordinate of a point on the line to reflect aroundy0
- the y-ordinate of a point on the line to reflect aroundx1
- the x-ordinate of a point on the line to reflect aroundy1
- the y-ordinate of a point on the line to reflect around
public AffineTransformation reflect(double x, double y)
x
- the x-ordinate of the line to reflect aroundy
- the y-ordinate of the line to reflect around
public AffineTransformation rotate(double theta)
theta
- the angle to rotate by, in radians
public AffineTransformation rotate(double sinTheta, double cosTheta)
sinTheta
- the sine of the angle to rotate bycosTheta
- the cosine of the angle to rotate by
public AffineTransformation rotate(double theta, double x, double y)
theta
- the angle to rotate by, in radiansx
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public AffineTransformation rotate(double sinTheta, double cosTheta, double x, double y)
sinTheta
- the sine of the angle to rotate bycosTheta
- the cosine of the angle to rotate byx
- the x-ordinate of the rotation pointy
- the y-ordinate of the rotation point
public AffineTransformation scale(double xScale, double yScale)
xScale
- the value to scale by in the x directionyScale
- the value to scale by in the y direction
public AffineTransformation shear(double xShear, double yShear)
xShear
- the value to shear by in the x directionyShear
- the value to shear by in the y direction
public AffineTransformation translate(double x, double y)
x
- the value to translate by in the x directiony
- the value to translate by in the y direction
public AffineTransformation compose(AffineTransformation trans)
AffineTransformation
.
This produces a transformation whose effect
is equal to applying this transformation
followed by the argument transformation.
Mathematically,
A.compose(B) = TB x TA
trans
- an affine transformation
public AffineTransformation composeBefore(AffineTransformation trans)
AffineTransformation
with this transformation.
This produces a transformation whose effect
is equal to applying the argument transformation
followed by this transformation.
Mathematically,
A.composeBefore(B) = TA x TB
trans
- an affine transformation
public Coordinate transform(Coordinate src, Coordinate dest)
src
- the coordinate to transformdest
- the coordinate to accept the results
public Geometry transform(Geometry g)
public void transform(CoordinateSequence seq, int i)
seq
- a CoordinateSequence
i
- the index of the coordinate to transformpublic void filter(CoordinateSequence seq, int i)
filter
in interface CoordinateSequenceFilter
seq
- a CoordinateSequence
i
- the index of the coordinate to transformpublic boolean isGeometryChanged()
CoordinateSequenceFilter
Geometry.geometryChanged()
will be executed
after this filter has finished being executed.
Most filters can simply return a constant value reflecting whether they are able to change the coordinates.
isGeometryChanged
in interface CoordinateSequenceFilter
public boolean isDone()
isDone
in interface CoordinateSequenceFilter
public boolean isIdentity()
public boolean equals(java.lang.Object obj)
obj
- an object to test
public java.lang.String toString()
AffineTransformation[[m00, m01, m02], [m10, m11, m12]]
public java.lang.Object clone()
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |