AffineTransform (GNU libgcj 4.8.0 Documentation)

java.lang.Object
- java.awt.geom.AffineTransform

All Implemented Interfaces:

Serializable, Cloneable
```
public class AffineTransform
extends Object
implements Cloneable, Serializable
```
This class represents an affine transformation between two coordinate spaces in 2 dimensions. Such a transform preserves the "straightness" and "parallelness" of lines. The transform is built from a sequence of translations, scales, flips, rotations, and shears.
The transformation can be represented using matrix math on a 3x3 array. Given (x,y), the transformation (x',y') can be found by:
```
 [ x']   [ m00 m01 m02 ] [ x ]   [ m00*x + m01*y + m02 ]
 [ y'] = [ m10 m11 m12 ] [ y ] = [ m10*x + m11*y + m12 ]
 [ 1 ]   [  0   0   1  ] [ 1 ]   [          1          ]
 
```
The bottom row of the matrix is constant, so a transform can be uniquely represented (as in toString()) by "[[m00, m01, m02], [m10, m11, m12]]".
Since:

1.2

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`TYPE_FLIP` The transformation includes a flip about an axis, swapping between right-handed and left-handed coordinate systems.
`static int`	`TYPE_GENERAL_ROTATION` The transformation includes a rotation by an arbitrary angle.
`static int`	`TYPE_GENERAL_SCALE` The transformation includes a general scale - length is scaled in either or both the x and y directions, but by different amounts; without affecting angles.
`static int`	`TYPE_GENERAL_TRANSFORM` The transformation is an arbitrary conversion of coordinates which could not be decomposed into the other TYPEs.
`static int`	`TYPE_IDENTITY` The transformation is the identity (x' = x, y' = y).
`static int`	`TYPE_MASK_ROTATION` This constant checks if either variety of rotation is performed.
`static int`	`TYPE_MASK_SCALE` This constant checks if either variety of scale transform is performed.
`static int`	`TYPE_QUADRANT_ROTATION` The transformation includes a rotation of a multiple of 90 degrees (PI/2 radians).
`static int`	`TYPE_TRANSLATION` The transformation includes a translation - shifting in the x or y direction without changing length or angles.
`static int`	`TYPE_UNIFORM_SCALE` The transformation includes a uniform scale - length is scaled in both the x and y directions by the same amount, without affecting angles.

Constructor Summary

Constructors
Constructor and Description
`AffineTransform()` Construct a new identity transform: [ 1 0 0 ] [ 0 1 0 ] [ 0 0 1 ]
`AffineTransform(AffineTransform tx)` Create a new transform which copies the given one.
`AffineTransform(double[] d)` Construct a transform from a sequence of double entries.
`AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)` Construct a transform with the given matrix entries: [ m00 m01 m02 ] [ m10 m11 m12 ] [ 0 0 1 ]
`AffineTransform(float[] f)` Construct a transform from a sequence of float entries.
`AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)` Construct a transform with the given matrix entries: [ m00 m01 m02 ] [ m10 m11 m12 ] [ 0 0 1 ]

Method Summary

Methods
Modifier and Type	Method and Description
`Object`	`clone()` Create a new transform of the same run-time type, with the same transforming properties as this one.
`void`	`concatenate(AffineTransform tx)` Set this transform to the result of performing the original version of this followed by tx.
`AffineTransform`	`createInverse()` Returns a transform, which if concatenated to this one, will result in the identity transform.
`Shape`	`createTransformedShape(Shape src)` Return a new Shape, based on the given one, where the path of the shape has been transformed by this transform.
`void`	`deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int num)` Perform this transformation, less any translation, on an array of points, in (x,y) pairs, storing the results in another (possibly same) array.
`Point2D`	`deltaTransform(Point2D src, Point2D dst)` Perform this transformation, less any translation, on the given source point, and store the result in the destination (creating it if necessary).
`boolean`	`equals(Object obj)` Compares two transforms for equality.
`double`	`getDeterminant()` Return the determinant of this transform matrix.
`void`	`getMatrix(double[] d)` Return the matrix of values used in this transform.
`static AffineTransform`	`getRotateInstance(double theta)` Returns a rotation transform.
`static AffineTransform`	`getRotateInstance(double theta, double x, double y)` Returns a rotation transform about a point.
`static AffineTransform`	`getScaleInstance(double sx, double sy)` Returns a scaling transform: [ sx 0 0 ] [ 0 sy 0 ] [ 0 0 1 ]
`double`	`getScaleX()` Returns the X coordinate scaling factor of the matrix.
`double`	`getScaleY()` Returns the Y coordinate scaling factor of the matrix.
`static AffineTransform`	`getShearInstance(double shx, double shy)` Returns a shearing transform (points are shifted in the x direction based on a factor of their y coordinate, and in the y direction as a factor of their x coordinate): [ 1 shx 0 ] [ shy 1 0 ] [ 0 0 1 ]
`double`	`getShearX()` Returns the X coordinate shearing factor of the matrix.
`double`	`getShearY()` Returns the Y coordinate shearing factor of the matrix.
`static AffineTransform`	`getTranslateInstance(double tx, double ty)` Returns a translation transform: [ 1 0 tx ] [ 0 1 ty ] [ 0 0 1 ]
`double`	`getTranslateX()` Returns the X coordinate translation factor of the matrix.
`double`	`getTranslateY()` Returns the Y coordinate translation factor of the matrix.
`int`	`getType()` Returns the type of this transform.
`int`	`hashCode()` Return the hashcode for this transformation.
`void`	`inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int num)` Perform the inverse of this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array.
`Point2D`	`inverseTransform(Point2D src, Point2D dst)` Perform the inverse of this transformation on the given source point, and store the result in the destination (creating it if necessary).
`boolean`	`isIdentity()` Tests if this transformation is the identity: [ 1 0 0 ] [ 0 1 0 ] [ 0 0 1 ]
`void`	`preConcatenate(AffineTransform tx)` Set this transform to the result of performing tx followed by the original version of this.
`void`	`rotate(double theta)` Concatenate a rotation onto this transform.
`void`	`rotate(double theta, double x, double y)` Concatenate a rotation about a point onto this transform.
`void`	`scale(double sx, double sy)` Concatenate a scale onto this transform.
`void`	`setToIdentity()` Reset this transform to the identity (no transformation): [ 1 0 0 ] [ 0 1 0 ] [ 0 0 1 ]
`void`	`setToRotation(double theta)` Set this transform to a rotation.
`void`	`setToRotation(double theta, double x, double y)` Set this transform to a rotation about a point.
`void`	`setToScale(double sx, double sy)` Set this transform to a scale: [ sx 0 0 ] [ 0 sy 0 ] [ 0 0 1 ]
`void`	`setToShear(double shx, double shy)` Set this transform to a shear (points are shifted in the x direction based on a factor of their y coordinate, and in the y direction as a factor of their x coordinate): [ 1 shx 0 ] [ shy 1 0 ] [ 0 0 1 ]
`void`	`setToTranslation(double tx, double ty)` Set this transform to a translation: [ 1 0 tx ] [ 0 1 ty ] [ 0 0 1 ]
`void`	`setTransform(AffineTransform tx)` Set this transform to a copy of the given one.
`void`	`setTransform(double m00, double m10, double m01, double m11, double m02, double m12)` Set this transform to the given values: [ m00 m01 m02 ] [ m10 m11 m12 ] [ 0 0 1 ]
`void`	`shear(double shx, double shy)` Concatenate a shearing onto this transform.
`String`	`toString()` Returns a string representation of the transform, in the format: `"AffineTransform[[" + m00 + ", " + m01 + ", " + m02 + "], [" + m10 + ", " + m11 + ", " + m12 + "]]"`.
`void`	`transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int num)` Perform this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array.
`void`	`transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int num)` Perform this transformation on an array of points, in (x,y) pairs, storing the results in another array.
`void`	`transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int num)` Perform this transformation on an array of points, in (x,y) pairs, storing the results in another array.
`void`	`transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int num)` Perform this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array.
`void`	`transform(Point2D[] src, int srcOff, Point2D[] dst, int dstOff, int num)` Perform this transformation on an array of points, storing the results in another (possibly same) array.
`Point2D`	`transform(Point2D src, Point2D dst)` Perform this transformation on the given source point, and store the result in the destination (creating it if necessary).
`void`	`translate(double tx, double ty)` Concatenate a translation onto this transform.

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - TYPE_IDENTITY
```
public static final int TYPE_IDENTITY
```
    The transformation is the identity (x' = x, y' = y). All other transforms have either a combination of the appropriate transform flag bits for their type, or the type GENERAL_TRANSFORM.
    
    See Also:
    TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, getType(), Constant Field Values
  - TYPE_TRANSLATION
```
public static final int TYPE_TRANSLATION
```
    The transformation includes a translation - shifting in the x or y direction without changing length or angles.
    
    See Also:
    TYPE_IDENTITY, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, getType(), Constant Field Values
  - TYPE_UNIFORM_SCALE
```
public static final int TYPE_UNIFORM_SCALE
```
    The transformation includes a uniform scale - length is scaled in both the x and y directions by the same amount, without affecting angles. This is mutually exclusive with TYPE_GENERAL_SCALE.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, TYPE_MASK_SCALE, getType(), Constant Field Values
  - TYPE_GENERAL_SCALE
```
public static final int TYPE_GENERAL_SCALE
```
    The transformation includes a general scale - length is scaled in either or both the x and y directions, but by different amounts; without affecting angles. This is mutually exclusive with TYPE_UNIFORM_SCALE.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, TYPE_MASK_SCALE, getType(), Constant Field Values
  - TYPE_MASK_SCALE
```
public static final int TYPE_MASK_SCALE
```
    This constant checks if either variety of scale transform is performed.
    
    See Also:
    TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, Constant Field Values
  - TYPE_FLIP
```
public static final int TYPE_FLIP
```
    The transformation includes a flip about an axis, swapping between right-handed and left-handed coordinate systems. In a right-handed system, the positive x-axis rotates counter-clockwise to the positive y-axis; in a left-handed system it rotates clockwise.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, getType(), Constant Field Values
  - TYPE_QUADRANT_ROTATION
```
public static final int TYPE_QUADRANT_ROTATION
```
    The transformation includes a rotation of a multiple of 90 degrees (PI/2 radians). Angles are rotated, but length is preserved. This is mutually exclusive with TYPE_GENERAL_ROTATION.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM, TYPE_MASK_ROTATION, getType(), Constant Field Values
  - TYPE_GENERAL_ROTATION
```
public static final int TYPE_GENERAL_ROTATION
```
    The transformation includes a rotation by an arbitrary angle. Angles are rotated, but length is preserved. This is mutually exclusive with TYPE_QUADRANT_ROTATION.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_TRANSFORM, TYPE_MASK_ROTATION, getType(), Constant Field Values
  - TYPE_MASK_ROTATION
```
public static final int TYPE_MASK_ROTATION
```
    This constant checks if either variety of rotation is performed.
    
    See Also:
    TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, Constant Field Values
  - TYPE_GENERAL_TRANSFORM
```
public static final int TYPE_GENERAL_TRANSFORM
```
    The transformation is an arbitrary conversion of coordinates which could not be decomposed into the other TYPEs.
    
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, getType(), Constant Field Values
- Constructor Detail
  - AffineTransform
```
public AffineTransform()
```
    Construct a new identity transform:
```
 [ 1 0 0 ]
 [ 0 1 0 ]
 [ 0 0 1 ]
 
```
  - AffineTransform
```
public AffineTransform(AffineTransform tx)
```
    Create a new transform which copies the given one.
    
    Parameters:
    tx - the transform to copy
    
    Throws:
    
    NullPointerException - if tx is null
  - AffineTransform
```
public AffineTransform(float m00,
               float m10,
               float m01,
               float m11,
               float m02,
               float m12)
```
    Construct a transform with the given matrix entries:
```
 [ m00 m01 m02 ]
 [ m10 m11 m12 ]
 [  0   0   1  ]
 
```
    Parameters:
    m00 - the x scaling component
    m10 - the y shearing component
    m01 - the x shearing component
    m11 - the y scaling component
    m02 - the x translation component
    m12 - the y translation component
  - AffineTransform
```
public AffineTransform(float[] f)
```
    Construct a transform from a sequence of float entries. The array must have at least 4 entries, which has a translation factor of 0; or 6 entries, for specifying all parameters:
```
 [ f[0] f[2] (f[4]) ]
 [ f[1] f[3] (f[5]) ]
 [  0     0    1    ]
 
```
    Parameters:
    f - the matrix to copy from, with at least 4 (6) entries
    
    Throws:
    
    NullPointerException - if f is null
    
    ArrayIndexOutOfBoundsException - if f is too small
  - AffineTransform
```
public AffineTransform(double m00,
               double m10,
               double m01,
               double m11,
               double m02,
               double m12)
```
    Construct a transform with the given matrix entries:
```
 [ m00 m01 m02 ]
 [ m10 m11 m12 ]
 [  0   0   1  ]
 
```
    Parameters:
    m00 - the x scaling component
    m10 - the y shearing component
    m01 - the x shearing component
    m11 - the y scaling component
    m02 - the x translation component
    m12 - the y translation component
  - AffineTransform
```
public AffineTransform(double[] d)
```
    Construct a transform from a sequence of double entries. The array must have at least 4 entries, which has a translation factor of 0; or 6 entries, for specifying all parameters:
```
 [ d[0] d[2] (d[4]) ]
 [ d[1] d[3] (d[5]) ]
 [  0     0    1    ]
 
```
    Parameters:
    d - the matrix to copy from, with at least 4 (6) entries
    
    Throws:
    
    NullPointerException - if d is null
    
    ArrayIndexOutOfBoundsException - if d is too small
- Method Detail
  - getTranslateInstance
```
public static AffineTransform getTranslateInstance(double tx,
                                   double ty)
```
    Returns a translation transform:
```
 [ 1 0 tx ]
 [ 0 1 ty ]
 [ 0 0 1  ]
 
```
    Parameters:
    tx - the x translation distance
    ty - the y translation distance
    
    Returns:
    the translating transform
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double theta)
```
    Returns a rotation transform. A positive angle (in radians) rotates the positive x-axis to the positive y-axis:
```
 [ cos(theta) -sin(theta) 0 ]
 [ sin(theta)  cos(theta) 0 ]
 [     0           0      1 ]
 
```
    Parameters:
    theta - the rotation angle
    
    Returns:
    the rotating transform
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double theta,
                                double x,
                                double y)
```
    Returns a rotation transform about a point. A positive angle (in radians) rotates the positive x-axis to the positive y-axis. This is the same as calling:
```
 AffineTransform tx = new AffineTransform();
 tx.setToTranslation(x, y);
 tx.rotate(theta);
 tx.translate(-x, -y);
 
```
    The resulting matrix is:
```
 [ cos(theta) -sin(theta) x-x*cos+y*sin ]
 [ sin(theta)  cos(theta) y-x*sin-y*cos ]
 [     0           0            1       ]
 
```
    Parameters:
    theta - the rotation angle
    x - the x coordinate of the pivot point
    y - the y coordinate of the pivot point
    
    Returns:
    the rotating transform
  - getScaleInstance
```
public static AffineTransform getScaleInstance(double sx,
                               double sy)
```
    Returns a scaling transform:
```
 [ sx 0  0 ]
 [ 0  sy 0 ]
 [ 0  0  1 ]
 
```
    Parameters:
    sx - the x scaling factor
    sy - the y scaling factor
    
    Returns:
    the scaling transform
  - getShearInstance
```
public static AffineTransform getShearInstance(double shx,
                               double shy)
```
    Returns a shearing transform (points are shifted in the x direction based on a factor of their y coordinate, and in the y direction as a factor of their x coordinate):
```
 [  1  shx 0 ]
 [ shy  1  0 ]
 [  0   0  1 ]
 
```
    Parameters:
    shx - the x shearing factor
    shy - the y shearing factor
    
    Returns:
    the shearing transform
  - getType
```
public int getType()
```
    Returns the type of this transform. The result is always valid, although it may not be the simplest interpretation (in other words, there are sequences of transforms which reduce to something simpler, which this does not always detect). The result is either TYPE_GENERAL_TRANSFORM, or a bit-wise combination of TYPE_TRANSLATION, the mutually exclusive TYPE_*_ROTATIONs, and the mutually exclusive TYPE_*_SCALEs.
    
    Returns:
    The type.
    See Also:
    TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, TYPE_GENERAL_TRANSFORM
  - getDeterminant
```
public double getDeterminant()
```
    Return the determinant of this transform matrix. If the determinant is non-zero, the transform is invertible; otherwise operations which require an inverse throw a NoninvertibleTransformException. A result very near zero, due to rounding errors, may indicate that inversion results do not carry enough precision to be meaningful.
    If this is a uniform scale transformation, the determinant also represents the squared value of the scale. Otherwise, it carries little additional meaning. The determinant is calculated as:
```
 | m00 m01 m02 |
 | m10 m11 m12 | = m00 * m11 - m01 * m10
 |  0   0   1  |
 
```
    Returns:
    the determinant
    See Also:
    createInverse()
  - getMatrix
```
public void getMatrix(double[] d)
```
    Return the matrix of values used in this transform. If the matrix has fewer than 6 entries, only the scale and shear factors are returned; otherwise the translation factors are copied as well. The resulting values are:
```
 [ d[0] d[2] (d[4]) ]
 [ d[1] d[3] (d[5]) ]
 [  0     0    1    ]
 
```
    Parameters:
    d - the matrix to store the results into; with 4 (6) entries
    
    Throws:
    
    NullPointerException - if d is null
    
    ArrayIndexOutOfBoundsException - if d is too small
  - getScaleX
```
public double getScaleX()
```
    Returns the X coordinate scaling factor of the matrix.
    
    Returns:
    m00
    See Also:
    getMatrix(double[])
  - getScaleY
```
public double getScaleY()
```
    Returns the Y coordinate scaling factor of the matrix.
    
    Returns:
    m11
    See Also:
    getMatrix(double[])
  - getShearX
```
public double getShearX()
```
    Returns the X coordinate shearing factor of the matrix.
    
    Returns:
    m01
    See Also:
    getMatrix(double[])
  - getShearY
```
public double getShearY()
```
    Returns the Y coordinate shearing factor of the matrix.
    
    Returns:
    m10
    See Also:
    getMatrix(double[])
  - getTranslateX
```
public double getTranslateX()
```
    Returns the X coordinate translation factor of the matrix.
    
    Returns:
    m02
    See Also:
    getMatrix(double[])
  - getTranslateY
```
public double getTranslateY()
```
    Returns the Y coordinate translation factor of the matrix.
    
    Returns:
    m12
    See Also:
    getMatrix(double[])
  - translate
```
public void translate(double tx,
             double ty)
```
    Concatenate a translation onto this transform. This is equivalent, but more efficient than concatenate(AffineTransform.getTranslateInstance(tx, ty)).
    
    Parameters:
    tx - the x translation distance
    ty - the y translation distance
    See Also:
    getTranslateInstance(double, double), concatenate(AffineTransform)
  - rotate
```
public void rotate(double theta)
```
    Concatenate a rotation onto this transform. This is equivalent, but more efficient than concatenate(AffineTransform.getRotateInstance(theta)).
    
    Parameters:
    theta - the rotation angle
    See Also:
    getRotateInstance(double), concatenate(AffineTransform)
  - rotate
```
public void rotate(double theta,
          double x,
          double y)
```
    Concatenate a rotation about a point onto this transform. This is equivalent, but more efficient than concatenate(AffineTransform.getRotateInstance(theta, x, y)).
    
    Parameters:
    theta - the rotation angle
    x - the x coordinate of the pivot point
    y - the y coordinate of the pivot point
    See Also:
    getRotateInstance(double, double, double), concatenate(AffineTransform)
  - scale
```
public void scale(double sx,
         double sy)
```
    Concatenate a scale onto this transform. This is equivalent, but more efficient than concatenate(AffineTransform.getScaleInstance(sx, sy)).
    
    Parameters:
    sx - the x scaling factor
    sy - the y scaling factor
    See Also:
    getScaleInstance(double, double), concatenate(AffineTransform)
  - shear
```
public void shear(double shx,
         double shy)
```
    Concatenate a shearing onto this transform. This is equivalent, but more efficient than concatenate(AffineTransform.getShearInstance(sx, sy)).
    
    Parameters:
    shx - the x shearing factor
    shy - the y shearing factor
    See Also:
    getShearInstance(double, double), concatenate(AffineTransform)
  - setToIdentity
```
public void setToIdentity()
```
    Reset this transform to the identity (no transformation):
```
 [ 1 0 0 ]
 [ 0 1 0 ]
 [ 0 0 1 ]
 
```
  - setToTranslation
```
public void setToTranslation(double tx,
                    double ty)
```
    Set this transform to a translation:
```
 [ 1 0 tx ]
 [ 0 1 ty ]
 [ 0 0 1  ]
 
```
    Parameters:
    tx - the x translation distance
    ty - the y translation distance
  - setToRotation
```
public void setToRotation(double theta)
```
    Set this transform to a rotation. A positive angle (in radians) rotates the positive x-axis to the positive y-axis:
```
 [ cos(theta) -sin(theta) 0 ]
 [ sin(theta)  cos(theta) 0 ]
 [     0           0      1 ]
 
```
    Parameters:
    theta - the rotation angle
  - setToRotation
```
public void setToRotation(double theta,
                 double x,
                 double y)
```
    Set this transform to a rotation about a point. A positive angle (in radians) rotates the positive x-axis to the positive y-axis. This is the same as calling:
```
 tx.setToTranslation(x, y);
 tx.rotate(theta);
 tx.translate(-x, -y);
 
```
    The resulting matrix is:
```
 [ cos(theta) -sin(theta) x-x*cos+y*sin ]
 [ sin(theta)  cos(theta) y-x*sin-y*cos ]
 [     0           0            1       ]
 
```
    Parameters:
    theta - the rotation angle
    x - the x coordinate of the pivot point
    y - the y coordinate of the pivot point
  - setToScale
```
public void setToScale(double sx,
              double sy)
```
    Set this transform to a scale:
```
 [ sx 0  0 ]
 [ 0  sy 0 ]
 [ 0  0  1 ]
 
```
    Parameters:
    sx - the x scaling factor
    sy - the y scaling factor
  - setToShear
```
public void setToShear(double shx,
              double shy)
```
    Set this transform to a shear (points are shifted in the x direction based on a factor of their y coordinate, and in the y direction as a factor of their x coordinate):
```
 [  1  shx 0 ]
 [ shy  1  0 ]
 [  0   0  1 ]
 
```
    Parameters:
    shx - the x shearing factor
    shy - the y shearing factor
  - setTransform
```
public void setTransform(AffineTransform tx)
```
    Set this transform to a copy of the given one.
    
    Parameters:
    tx - the transform to copy
    
    Throws:
    
    NullPointerException - if tx is null
  - setTransform
```
public void setTransform(double m00,
                double m10,
                double m01,
                double m11,
                double m02,
                double m12)
```
    Set this transform to the given values:
```
 [ m00 m01 m02 ]
 [ m10 m11 m12 ]
 [  0   0   1  ]
 
```
    Parameters:
    m00 - the x scaling component
    m10 - the y shearing component
    m01 - the x shearing component
    m11 - the y scaling component
    m02 - the x translation component
    m12 - the y translation component
  - concatenate
```
public void concatenate(AffineTransform tx)
```
    Set this transform to the result of performing the original version of this followed by tx. This is commonly used when chaining transformations from one space to another. In matrix form:
```
 [ this ] = [ this ] x [ tx ]
 
```
    Parameters:
    tx - the transform to concatenate
    
    Throws:
    
    NullPointerException - if tx is null
    See Also:
    preConcatenate(AffineTransform)
  - preConcatenate
```
public void preConcatenate(AffineTransform tx)
```
    Set this transform to the result of performing tx followed by the original version of this. This is less common than normal concatenation, but can still be used to chain transformations from one space to another. In matrix form:
```
 [ this ] = [ tx ] x [ this ]
 
```
    Parameters:
    tx - the transform to concatenate
    
    Throws:
    
    NullPointerException - if tx is null
    See Also:
    concatenate(AffineTransform)
  - createInverse
```
public AffineTransform createInverse()
                              throws NoninvertibleTransformException
```
    Returns a transform, which if concatenated to this one, will result in the identity transform. This is useful for undoing transformations, but is only possible if the original transform has an inverse (ie. does not map multiple points to the same line or point). A transform exists only if getDeterminant() has a non-zero value. The inverse is calculated as:
```
 Let A be the matrix for which we want to find the inverse:

 A = [ m00 m01 m02 ]
     [ m10 m11 m12 ]
     [ 0   0   1   ]


                 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               ]


 
```
    Returns:
    a new inverse transform
    
    Throws:
    
    NoninvertibleTransformException - if inversion is not possible
    See Also:
    getDeterminant()
  - transform
```
public Point2D transform(Point2D src,
                Point2D dst)
```
    Perform this transformation on the given source point, and store the result in the destination (creating it if necessary). It is safe for src and dst to be the same.
    
    Parameters:
    src - the source point
    dst - the destination, or null
    
    Returns:
    the transformation of src, in dst if it was non-null
    
    Throws:
    
    NullPointerException - if src is null
  - transform
```
public void transform(Point2D[] src,
             int srcOff,
             Point2D[] dst,
             int dstOff,
             int num)
```
    Perform this transformation on an array of points, storing the results in another (possibly same) array. This will not create a destination array, but will create points for the null entries of the destination. The transformation is done sequentially. While having a single source and destination point be the same is safe, you should be aware that duplicate references to the same point in the source, and having the source overlap the destination, may result in your source points changing from a previous transform before it is their turn to be evaluated.
    
    Parameters:
    src - the array of source points
    srcOff - the starting offset into src
    dst - the array of destination points (may have null entries)
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null, or src has null entries
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
    
    ArrayStoreException - if new points are incompatible with dst
  - transform
```
public void transform(float[] srcPts,
             int srcOff,
             float[] dstPts,
             int dstOff,
             int num)
```
    Perform this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array. This will not create a destination array. All sources are copied before the transformation, so that no result will overwrite a point that has not yet been evaluated.
    
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
  - transform
```
public void transform(double[] srcPts,
             int srcOff,
             double[] dstPts,
             int dstOff,
             int num)
```
    Perform this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array. This will not create a destination array. All sources are copied before the transformation, so that no result will overwrite a point that has not yet been evaluated.
    
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
  - transform
```
public void transform(float[] srcPts,
             int srcOff,
             double[] dstPts,
             int dstOff,
             int num)
```
    Perform this transformation on an array of points, in (x,y) pairs, storing the results in another array. This will not create a destination array.
    
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
  - transform
```
public void transform(double[] srcPts,
             int srcOff,
             float[] dstPts,
             int dstOff,
             int num)
```
    Perform this transformation on an array of points, in (x,y) pairs, storing the results in another array. This will not create a destination array.
    
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
  - inverseTransform
```
public Point2D inverseTransform(Point2D src,
                       Point2D dst)
                         throws NoninvertibleTransformException
```
    Perform the inverse of this transformation on the given source point, and store the result in the destination (creating it if necessary). It is safe for src and dst to be the same.
    
    Parameters:
    src - the source point
    dst - the destination, or null
    
    Returns:
    the inverse transformation of src, in dst if it was non-null
    
    Throws:
    
    NullPointerException - if src is null
    
    NoninvertibleTransformException - if the inverse does not exist
    See Also:
    getDeterminant()
  - inverseTransform
```
public void inverseTransform(double[] srcPts,
                    int srcOff,
                    double[] dstPts,
                    int dstOff,
                    int num)
                      throws NoninvertibleTransformException
```
    Perform the inverse of this transformation on an array of points, in (x,y) pairs, storing the results in another (possibly same) array. This will not create a destination array. All sources are copied before the transformation, so that no result will overwrite a point that has not yet been evaluated.
    
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
    
    NoninvertibleTransformException - if the inverse does not exist
    See Also:
    getDeterminant()
  - deltaTransform
```
public Point2D deltaTransform(Point2D src,
                     Point2D dst)
```
    Perform this transformation, less any translation, on the given source point, and store the result in the destination (creating it if necessary). It is safe for src and dst to be the same. The reduced transform is equivalent to:
```
 [ x' ] = [ m00 m01 ] [ x ] = [ m00 * x + m01 * y ]
 [ y' ]   [ m10 m11 ] [ y ] = [ m10 * x + m11 * y ]
 
```
    Parameters:
    src - the source point
    dst - the destination, or null
    
    Returns:
    the delta transformation of src, in dst if it was non-null
    
    Throws:
    
    NullPointerException - if src is null
  - deltaTransform
```
public void deltaTransform(double[] srcPts,
                  int srcOff,
                  double[] dstPts,
                  int dstOff,
                  int num)
```
    Perform this transformation, less any translation, on an array of points, in (x,y) pairs, storing the results in another (possibly same) array. This will not create a destination array. All sources are copied before the transformation, so that no result will overwrite a point that has not yet been evaluated. The reduced transform is equivalent to:
```
 [ x' ] = [ m00 m01 ] [ x ] = [ m00 * x + m01 * y ]
 [ y' ]   [ m10 m11 ] [ y ] = [ m10 * x + m11 * y ]
 
```
    Parameters:
    srcPts - the array of source points
    srcOff - the starting offset into src
    dstPts - the array of destination points
    dstOff - the starting offset into dst
    num - the number of points to transform
    
    Throws:
    
    NullPointerException - if src or dst is null
    
    ArrayIndexOutOfBoundsException - if array bounds are exceeded
  - createTransformedShape
```
public Shape createTransformedShape(Shape src)
```
    Return a new Shape, based on the given one, where the path of the shape has been transformed by this transform. Notice that this uses GeneralPath, which only stores points in float precision.
    
    Parameters:
    src - the shape source to transform
    
    Returns:
    the shape, transformed by this, null if src is null.
    See Also:
    GeneralPath.transform(AffineTransform)
  - toString
```
public String toString()
```
    Returns a string representation of the transform, in the format: "AffineTransform[[" + m00 + ", " + m01 + ", " + m02 + "], [" + m10 + ", " + m11 + ", " + m12 + "]]".
    
    Overrides:
    
    toString in class Object
    
    Returns:
    the string representation
    See Also:
    Object.getClass(), Object.hashCode(), Class.getName(), Integer.toHexString(int)
  - isIdentity
```
public boolean isIdentity()
```
    Tests if this transformation is the identity:
```
 [ 1 0 0 ]
 [ 0 1 0 ]
 [ 0 0 1 ]
 
```
    Returns:
    true if this is the identity transform
  - clone
```
public Object clone()
```
    Create a new transform of the same run-time type, with the same transforming properties as this one.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    the clone
    See Also:
    Cloneable
  - hashCode
```
public int hashCode()
```
    Return the hashcode for this transformation. The formula is not documented, but appears to be the same as:
```
 long l = Double.doubleToLongBits(getScaleX());
 l = l * 31 + Double.doubleToLongBits(getShearX());
 l = l * 31 + Double.doubleToLongBits(getTranslateX());
 l = l * 31 + Double.doubleToLongBits(getShearY());
 l = l * 31 + Double.doubleToLongBits(getScaleY());
 l = l * 31 + Double.doubleToLongBits(getTranslateY());
 return (int) ((l >> 32) ^ l);
 
```
    Overrides:
    
    hashCode in class Object
    
    Returns:
    the hashcode
    See Also:
    Object.equals(Object), System.identityHashCode(Object)
  - equals
```
public boolean equals(Object obj)
```
    Compares two transforms for equality. This returns true if they have the same matrix values.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    obj - the transform to compare
    
    Returns:
    true if it is equal
    See Also:
    Object.hashCode()

Class AffineTransform

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TYPE_IDENTITY

TYPE_TRANSLATION

TYPE_UNIFORM_SCALE

TYPE_GENERAL_SCALE

TYPE_MASK_SCALE

TYPE_FLIP

TYPE_QUADRANT_ROTATION

TYPE_GENERAL_ROTATION

TYPE_MASK_ROTATION

TYPE_GENERAL_TRANSFORM

Constructor Detail

AffineTransform

AffineTransform

AffineTransform

AffineTransform

AffineTransform

AffineTransform

Method Detail

getTranslateInstance

getRotateInstance

getRotateInstance

getScaleInstance

getShearInstance

getType

getDeterminant

getMatrix

getScaleX

getScaleY

getShearX

getShearY

getTranslateX

getTranslateY

translate

rotate

rotate

scale

shear

setToIdentity

setToTranslation

setToRotation

setToRotation

setToScale

setToShear

setTransform

setTransform

concatenate

preConcatenate

createInverse

transform

transform

transform

transform

transform

transform

inverseTransform

inverseTransform

deltaTransform

deltaTransform

createTransformedShape

toString

isIdentity

clone

hashCode

equals