|
JTS Topology Suite version 1.12 | ||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.vividsolutions.jts.geom.util.AffineTransformation
public class 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 |
| x' | = T x | x | | y' | | y | | 1 | | 1 |
compose(com.vividsolutions.jts.geom.util.AffineTransformation)
method.
Composition is computed via multiplication of the
transformation matrices, and is defined as:
This produces a transformation whose effect is that of A followed by B. 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.
The composition of transformations is in general not commutative.
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)
Sets this transformation to be a reflection about the line defined by a line (x0,y0) - (x1,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
- the X ordinate of one point on the reflection liney0
- the Y ordinate of one point on the reflection linex1
- the X ordinate of another point on the reflection liney1
- the Y ordinate of another point on the reflection line
public AffineTransformation setToReflection(double x0, double y0, double x1, double y1)
x0
- the X ordinate of one point on the reflection liney0
- the Y ordinate of one point on the reflection linex1
- the X ordinate of another point on the reflection liney1
- the Y ordinate of another point on the reflection line
public AffineTransformation setToReflection(double x, double y)
d = sqrt(x2 + y2) sin = y / 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)
seq
- a Geometry
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)
equals
in class java.lang.Object
obj
- an object to test
public java.lang.String toString()
AffineTransformation[[m00, m01, m02], [m10, m11, m12]]
toString
in class java.lang.Object
public java.lang.Object clone()
clone
in class java.lang.Object
|
JTS Topology Suite version 1.12 | ||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |