AffineTransform (Java Platform SE 8 )

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

All Implemented Interfaces:

Serializable， Cloneable
```
public class AffineTransform
extends Object
implements Cloneable, Serializable
```
的 AffineTransform类代表一个二维仿射变换进行二维线性映射坐标到二维坐标，其他保持“直线”和“平行线”。仿射变换可以用序列的翻译，构造尺度，翻转，旋转，和剪刀。
这样的坐标变换可以表示为一个3行的3列矩阵与一个隐含的最后一行的[ 0 1 0 ]。这个矩阵变换成目标坐标(x',y')源坐标(x,y)考虑他们是一个列向量乘以坐标向量的矩阵按照以下过程：
```
【x】【M00 M01 M02 ] [×] [ m00x + m01y + M02 ][你] = [ M10 M11 M12 ] [年] = [ m10x + m11y + M12 ][ 0 [ 0 [ 1 ] [ 1 ] [ 1 ] [ 1 ]
```
Handling 90-Degree Rotations

在AffineTransform班rotate方法的一些变化，双精度参数指定旋转弧度的角。这些方法有特殊处理的旋转约90度（包括倍数，如180，270，和360度），使常见的情况下，象限旋转更有效地处理。这种特殊的处理可以使角度非常接近90度的倍数，被视为如果他们是90度的精确倍数。对于90度的小倍数的角度视为一个象限旋转的范围是约0.00000121度宽。本节解释了为什么需要这样的特殊护理，以及它是如何实施的。

自从90度表示为PI/2弧度，因为π是超越数（因此不合理的），它是不可能精确地表示一个多90度作为一个确切的双精度值测量弧度。因此，它是在理论上是不可能的描述象限旋转（90，180，270或360度），使用这些值。双精度浮点值很接近PI/2零倍数但从来没有足够接近正弦或余弦正是0、1或1。实施Math.sin()和Math.cos()相应不返回0以外的任何情况下Math.sin(0.0)。这些相同的实现，然而，准确返回1和1部分左右各90度的范围，因为多数正确答案是如此接近1或1，双精度的有效不能代表差异尽可以为数近0。

这些问题最终的结果是，如果Math.sin()和Math.cos()方法用于直接生成值矩阵的修改在这些弧度的旋转操作产生的变换是不严格分类为即便是像rotate(Math.PI/2.0)简单象限旋转，由于得到的正弦和余弦的non-0.0值引起的在矩阵的微小变化。如果这些变换不被归类为象限旋转，然后随后的代码，试图优化进一步的操作的基础上的类型的变换将被降级到其最一般的实现。

由于象限旋转是相当普遍的，这个类应该迅速处理这些情况下，无论是在应用旋转的变换和应用所产生的变换的坐标。为了促进这一最优处理，以测量弧度旋转角度的方法试图检测角度打算象限轮换，这样对待他们。这些方法治疗角θ为象限旋转如果Math.sin(theta)或Math.cos(theta)恰好返回1或1。作为一个经验法则，这个属性适用范围大约为0.0000000211弧度（0.00000121度）在Math.PI/2.0小倍数。
从以下版本开始：

一点二

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`TYPE_FLIP` 该标志位表示此对象所定义的变换将对某些轴进行镜像翻转，其中除了由其他标志位表示的转换之外，还将一个通常的右手坐标系转换成左手系统。
`static int`	`TYPE_GENERAL_ROTATION` 该标志位表示由该对象定义的变换，除了由其他标志位表示的转换外，还可以任意角度旋转。
`static int`	`TYPE_GENERAL_SCALE` 该标志位表示此对象所定义的变换除了其他标志位所表示的转换之外，还可以执行一个通用的规模。
`static int`	`TYPE_GENERAL_TRANSFORM` 这个常数表示由这个对象定义的变换将执行一个输入坐标的任意转换。
`static int`	`TYPE_IDENTITY` 这个常数表示由这个对象定义的变换是一个身份转换。
`static int`	`TYPE_MASK_ROTATION` 这个常数是一个位掩码的任何旋转标志位。
`static int`	`TYPE_MASK_SCALE` 这个常量是任何规模标志位的位掩码。
`static int`	`TYPE_QUADRANT_ROTATION` 该标志位表示由该对象定义的变换，除了由其他标志位所表示的转换之外，还可以通过90度的倍数来执行一个象限旋转。
`static int`	`TYPE_TRANSLATION` 该标志位表示此对象所定义的变换，除了表示由其他标志位所表示的转换外，还执行了一个翻译。
`static int`	`TYPE_UNIFORM_SCALE` 该标志位表示此对象所定义的变换，除了表示由其他标志位所表示的转换之外，还可以执行一个统一的规模。

构造方法摘要

构造方法
Constructor and Description
`AffineTransform()` 构建代表身份转型的一个新的 `AffineTransform`。
`AffineTransform(AffineTransform Tx)` 构建了一种新的 `AffineTransform`是一份指定的 `AffineTransform`对象。
`AffineTransform(double[] flatmatrix)` 构建了从双精度值代表4非翻译作品或3x3变换矩阵的6项新 `AffineTransform`指定数组。
`AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)` 6双精度值代表的3x3变换矩阵可以构造一个新的 `AffineTransform`条目6。
`AffineTransform(float[] flatmatrix)` 构建了一种新的 `AffineTransform`从浮点值数组表示的4非翻译作品或3x3变换矩阵的具体条目6。
`AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)` 从6个浮点值表示的3x3变换矩阵可以构造一个新的 `AffineTransform`条目6。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Object`	`clone()` 返回一份本 `AffineTransform`对象。
`void`	`concatenate(AffineTransform Tx)` 将一个 `AffineTransform` `Tx`这 `AffineTransform` CX在最常用的方式为用户提供新的空间，是由 `Tx`映射到用户空间的前。
`AffineTransform`	`createInverse()` 返回一个 `AffineTransform`表示反变换。
`Shape`	`createTransformedShape(Shape pSrc)` 返回由指定的 `Shape`几何后已由该变换新的 `Shape`对象。
`void`	`deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` 通过这种变换变换一个相对距离向量的数组。
`Point2D`	`deltaTransform(Point2D ptSrc, Point2D ptDst)` 将相对距离向量指定的 `ptSrc`和商店在 `ptDst`结果。
`boolean`	`equals(Object obj)` 返回 `true`如果这 `AffineTransform`代表相同的仿射坐标变换为指定参数。
`double`	`getDeterminant()` 返回变换的矩阵表示的行列式。
`void`	`getMatrix(double[] flatmatrix)` 在3x3仿射变换矩阵并将其检索指定值为6的双精度值的数组。
`static AffineTransform`	`getQuadrantRotateInstance(int numquadrants)` 返回一个旋转坐标变换的指定数目的象限。
`static AffineTransform`	`getQuadrantRotateInstance(int numquadrants, double anchorx, double anchory)` 返回一个旋转坐标变换的指定数在指定点的象限。
`static AffineTransform`	`getRotateInstance(double theta)` 返回表示旋转变换的变换。
`static AffineTransform`	`getRotateInstance(double vecx, double vecy)` 返回一个旋转坐标的变换，根据旋转矢量。
`static AffineTransform`	`getRotateInstance(double theta, double anchorx, double anchory)` 返回一个围绕一个固定点旋转坐标的变换。
`static AffineTransform`	`getRotateInstance(double vecx, double vecy, double anchorx, double anchory)` 返回一个旋转坐标，根据旋转矢量围绕一个固定点旋转。
`static AffineTransform`	`getScaleInstance(double sx, double sy)` 返回表示缩放变换的变换。
`double`	`getScaleX()` 返回x坐标缩放元素（M00）的3x3仿射变换矩阵。
`double`	`getScaleY()` 返回Y坐标缩放元素（M11）的3x3仿射变换矩阵。
`static AffineTransform`	`getShearInstance(double shx, double shy)` 返回表示剪切转换的变换。
`double`	`getShearX()` 返回x坐标剪切元件（M01）的3x3仿射变换矩阵。
`double`	`getShearY()` 返回Y坐标剪切元件（M10）的3x3仿射变换矩阵。
`static AffineTransform`	`getTranslateInstance(double tx, double ty)` 返回表示平移变换的变换。
`double`	`getTranslateX()` 返回的翻译单元的x坐标（M02）的3x3仿射变换矩阵。
`double`	`getTranslateY()` 返回的翻译单元的y坐标（M12）的3x3仿射变换矩阵。
`int`	`getType()` 检索描述此转换的转换属性的标志位。
`int`	`hashCode()` 返回此hashCode变换。
`void`	`inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` 通过这种变换，逆变换一个双精度坐标的数组。
`Point2D`	`inverseTransform(Point2D ptSrc, Point2D ptDst)` 逆转换并存储在指定的 `ptSrc` `ptDst`结果。
`void`	`invert()` 将此转换设置为本身的逆。
`boolean`	`isIdentity()` 如果这是一个回报 `true` `AffineTransform`恒等变换。
`void`	`preConcatenate(AffineTransform Tx)` 将这 `AffineTransform` CX一个 `AffineTransform` `Tx`在一个不太常用的方式， `Tx`修改坐标变换相对于绝对像素空间而不是相对于现有的用户空间。
`void`	`quadrantRotate(int numquadrants)` 将此变换与旋转坐标变换的指定数目的象限。
`void`	`quadrantRotate(int numquadrants, double anchorx, double anchory)` 将此变换与变换旋转坐标指定数在指定点的象限。
`void`	`rotate(double theta)` 将此变换和旋转变换。
`void`	`rotate(double vecx, double vecy)` 将此变换与坐标变换，旋转，根据旋转矢量。
`void`	`rotate(double theta, double anchorx, double anchory)` 将此变换与坐标变换，旋转围绕一个锚点。
`void`	`rotate(double vecx, double vecy, double anchorx, double anchory)` 将此变换与坐标变换，旋转围绕一个锚点根据旋转矢量。
`void`	`scale(double sx, double sy)` 将此变换和比例变换。
`void`	`setToIdentity()` 重置该变换身份变换。
`void`	`setToQuadrantRotation(int numquadrants)` 设置这个变换一个旋转坐标指定数个象限旋转变换。
`void`	`setToQuadrantRotation(int numquadrants, double anchorx, double anchory)` 设置这个变换翻译旋转变换的旋转坐标系上的指定数在指定点的象限。
`void`	`setToRotation(double theta)` 将此变换设置为旋转变换。
`void`	`setToRotation(double vecx, double vecy)` 将此变换设置为根据旋转矢量旋转坐标的旋转变换。
`void`	`setToRotation(double theta, double anchorx, double anchory)` 将此转换设置为一个翻译的旋转变换。
`void`	`setToRotation(double vecx, double vecy, double anchorx, double anchory)` 将此变换设置为根据旋转矢量围绕一个固定点旋转的旋转变换。
`void`	`setToScale(double sx, double sy)` 将此转换设置为缩放转换。
`void`	`setToShear(double shx, double shy)` 将此转换设置为剪切转换。
`void`	`setToTranslation(double tx, double ty)` 将此转换设置为转换转换。
`void`	`setTransform(AffineTransform Tx)` 设置这个变换复制在指定 `AffineTransform`对象的变换。
`void`	`setTransform(double m00, double m10, double m01, double m11, double m02, double m12)` 将此转换设置为由6个双精度值指定的矩阵。
`void`	`shear(double shx, double shy)` 将此变换与剪切变换。
`String`	`toString()` 返回一个 `String`表示此 `Object`价值。
`void`	`transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` 用这个变换变换一个双精度坐标的数组。
`void`	`transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)` 通过这种变换变换一个双精度坐标的数组，并将结果存储到一个浮动的数组中。
`void`	`transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` 通过将一个浮点坐标数组转换成一个数组，并将结果存储到一个数组中的一个数组中。
`void`	`transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)` 用这个变换变换一个浮点坐标的数组。
`void`	`transform(Point2D[] ptSrc, int srcOff, Point2D[] ptDst, int dstOff, int numPts)` 用这个变换变换一个点对象的数组。
`Point2D`	`transform(Point2D ptSrc, Point2D ptDst)` 将指定的 `ptSrc`和商店在 `ptDst`结果。
`void`	`translate(double tx, double ty)` 将此变换与平移变换。

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

- Field Detail
  - TYPE_IDENTITY
```
public static final int TYPE_IDENTITY
```
    这个常数表示由这个对象定义的变换是一个身份转换。身份变换是一个在其中的输出坐标总是相同的输入坐标。如果这将是比其他任何的身份变换，类型将是恒定的general_transform或结合相应的标志位的各种坐标变换，这种变换执行。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    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
```
    该标志位表示此对象所定义的变换，除了表示由其他标志位所表示的转换外，还执行了一个翻译。平移在不改变向量的长度或角度的不变的量在x和Y的坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    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
```
    该标志位表示此对象所定义的变换，除了表示由其他标志位所表示的转换之外，还可以执行一个统一的规模。一个统一的规模乘以向量的长度在x方向和y方向相同的向量夹角不改变。这个标志位与type_general_scale标志相互排斥。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_IDENTITY， TYPE_TRANSLATION， TYPE_GENERAL_SCALE， TYPE_FLIP， TYPE_QUADRANT_ROTATION， TYPE_GENERAL_ROTATION， TYPE_GENERAL_TRANSFORM， getType()， Constant Field Values
  - TYPE_GENERAL_SCALE
```
public static final int TYPE_GENERAL_SCALE
```
    该标志位表示此对象所定义的变换除了其他标志位所表示的转换之外，还可以执行一个通用的规模。一般规模乘以向量长度不同的量在X和Y方向垂直的向量之间的角度不改变。这个标志位与type_uniform_scale标志相互排斥。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_IDENTITY， TYPE_TRANSLATION， TYPE_UNIFORM_SCALE， TYPE_FLIP， TYPE_QUADRANT_ROTATION， TYPE_GENERAL_ROTATION， TYPE_GENERAL_TRANSFORM， getType()， Constant Field Values
  - TYPE_MASK_SCALE
```
public static final int TYPE_MASK_SCALE
```
    这个常量是任何规模标志位的位掩码。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_UNIFORM_SCALE， TYPE_GENERAL_SCALE， Constant Field Values
  - TYPE_FLIP
```
public static final int TYPE_FLIP
```
    该标志位表示此对象所定义的变换将对某些轴进行镜像翻转，其中除了由其他标志位表示的转换之外，还将一个通常的右手坐标系转换成左手系统。右手坐标系统是一个正的X轴逆时针旋转，以覆盖正面的Y轴类似的方向，在你的右手卷曲的手指，当你盯着在你的拇指。左手坐标系统是一个正的X轴顺时针旋转，以覆盖的正Y轴类似的方向，在你的左手的手指卷曲。没有数学的方法来确定原来的翻转或镜像变换的角度，因为所有的翻转角度是相同的，给定一个适当的调整旋转。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    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
```
    该标志位表示由该对象定义的变换，除了由其他标志位所表示的转换之外，还可以通过90度的倍数来执行一个象限旋转。一个旋转的角度改变向量的角度相同的量，无论原来的方向的矢量和不改变的向量的长度。这个标志位与type_general_rotation标志相互排斥。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_IDENTITY， TYPE_TRANSLATION， TYPE_UNIFORM_SCALE， TYPE_GENERAL_SCALE， TYPE_FLIP， TYPE_GENERAL_ROTATION， TYPE_GENERAL_TRANSFORM， getType()， Constant Field Values
  - TYPE_GENERAL_ROTATION
```
public static final int TYPE_GENERAL_ROTATION
```
    该标志位表示由该对象定义的变换，除了由其他标志位表示的转换外，还可以任意角度旋转。一个旋转的角度改变向量的角度相同的量，无论原来的方向的矢量和不改变的向量的长度。这个标志位与type_quadrant_rotation标志相互排斥。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_IDENTITY， TYPE_TRANSLATION， TYPE_UNIFORM_SCALE， TYPE_GENERAL_SCALE， TYPE_FLIP， TYPE_QUADRANT_ROTATION， TYPE_GENERAL_TRANSFORM， getType()， Constant Field Values
  - TYPE_MASK_ROTATION
```
public static final int TYPE_MASK_ROTATION
```
    这个常数是一个位掩码的任何旋转标志位。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_QUADRANT_ROTATION， TYPE_GENERAL_ROTATION， Constant Field Values
  - TYPE_GENERAL_TRANSFORM
```
public static final int TYPE_GENERAL_TRANSFORM
```
    这个常数表示由这个对象定义的变换将执行一个输入坐标的任意转换。如果这个变换可以由任何上述常数的分类，类型可以是恒定的type_identity或结合相应的标志位的各种坐标变换，这种变换执行。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    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()
```
    构建代表身份转型的一个新的 AffineTransform。
    
    从以下版本开始：
    
    一点二
  - AffineTransform
```
public AffineTransform(AffineTransform Tx)
```
    构建了一种新的 AffineTransform是一份指定的 AffineTransform对象。
    
    参数
    
    Tx - AffineTransform对象复制
    
    从以下版本开始：
    
    一点二
  - AffineTransform
```
@ConstructorProperties(value={"scaleX","shearY","shearX","scaleY","translateX","translateY"})
public AffineTransform(float m00,
                                                                                                                     float m10,
                                                                                                                     float m01,
                                                                                                                     float m11,
                                                                                                                     float m02,
                                                                                                                     float m12)
```
    从6个浮点值表示的3x3变换矩阵可以构造一个新的 AffineTransform条目6。
    
    参数
    
    m00 - X坐标缩放的3x3的矩阵元
    
    m10 - Y坐标剪切的3x3的矩阵元
    
    m01 - x坐标剪切的3x3的矩阵元
    
    m11 - Y坐标缩放的3x3的矩阵元
    
    m02 - X坐标转换元件的3x3矩阵
    
    m12 - Y坐标转换元件的3x3矩阵
    
    从以下版本开始：
    
    一点二
  - AffineTransform
```
public AffineTransform(float[] flatmatrix)
```
    构建从浮点值数组表示的4非翻译作品或3x3变换矩阵的6项新 AffineTransform指定。该值从数组{ M00 M10 M01 M11 [ M02 M12 ]检索}。
    
    参数
    
    flatmatrix包含的值被设置在新 AffineTransform的浮点数组对象。的数组的长度被假定为至少4。如果数组的长度小于6，则只取前4个值。如果数组的长度大于6，则采取前6个值。
    
    从以下版本开始：
    
    一点二
  - AffineTransform
```
public AffineTransform(double m00,
                       double m10,
                       double m01,
                       double m11,
                       double m02,
                       double m12)
```
    6双精度值代表的3x3变换矩阵可以构造一个新的 AffineTransform条目6。
    
    参数
    
    m00 - X坐标缩放的3x3的矩阵元
    
    m10 - Y坐标剪切的3x3的矩阵元
    
    m01 - x坐标剪切的3x3的矩阵元
    
    m11 - Y坐标缩放的3x3的矩阵元
    
    m02 - X坐标转换元件的3x3矩阵
    
    m12 - Y坐标转换元件的3x3矩阵
    
    从以下版本开始：
    
    一点二
  - AffineTransform
```
public AffineTransform(double[] flatmatrix)
```
    构建了从双精度值代表4非翻译作品或3x3变换矩阵的6项新 AffineTransform指定数组。该值从数组{ M00 M10 M01 M11 [ M02 M12 ]检索}。
    
    参数
    
    flatmatrix含值是建立在新的 AffineTransform双数组对象。的数组的长度被假定为至少4。如果数组的长度小于6，则只取前4个值。如果数组的长度大于6，则采取前6个值。
    
    从以下版本开始：
    
    一点二
- 方法详细信息
  - getTranslateInstance
```
public static AffineTransform getTranslateInstance(double tx,
                                                   double ty)
```
    返回表示平移变换的变换。表示返回的变换矩阵：
```
[ 1 ] 0 TX[ 0 ] 1度["0 1 0"]
```
    参数
    
    tx -距离坐标转换在X轴方向
    
    ty -距离坐标转化在Y轴方向
    
    结果
    
    一个 AffineTransform表示平移变换，用指定的向量生成。
    
    从以下版本开始：
    
    一点二
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double theta)
```
    返回表示旋转变换的变换。表示返回的变换矩阵：
```
【cos（θ）罪（θ）0 ]【sin（θ）cos（θ）0 ]["0 1 0"]
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    结果
    
    这是一个旋转变换 AffineTransform对象与指定旋转角度创建。
    
    从以下版本开始：
    
    一点二
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double theta,
                                                double anchorx,
                                                double anchory)
```
    返回一个围绕一个固定点旋转坐标的变换。这个操作等于平移坐标，定位点在原点（S1），然后转动他们的新来源（S2），并最终将使中间的起源是恢复到原来的定位点坐标（S3）。
    此操作相当于下面的调用序列：
```
Tx =新affinetransform()点；Tx.translate（anchorx，anchory）；// S3：最后的翻译tx.rotate（θ）；// S2：绕锚Tx.translate（- anchorx，- anchory）；// S1：把锚的起源
```
    矩阵表示返回的变换：
```
【cos（θ）罪（θ）X-X×COS + Y *罪]【sin（θ）cos（θ）* *因为] sin-y Y-X["0 1 0"]
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    结果
    
    一个 AffineTransform对象旋转坐标在指定点指定旋转角度。
    
    从以下版本开始：
    
    一点二
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double vecx,
                                                double vecy)
```
    返回一个旋转坐标的变换，根据旋转矢量。所有的坐标由相同数量的原点旋转。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy 0，身份转换返回。这个操作是相当于调用：
```
点。getrotateinstance（数学。但（极其，vecx））；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    结果
    
    一个 AffineTransform对象旋转坐标根据指定的旋转矢量。
    
    从以下版本开始：
    
    一点六
  - getRotateInstance
```
public static AffineTransform getRotateInstance(double vecx,
                                                double vecy,
                                                double anchorx,
                                                double anchory)
```
    返回一个旋转坐标，根据旋转矢量围绕一个固定点旋转。所有的坐标旋转指定的锚定坐标由相同的金额。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy 0，身份转换返回。这个操作是相当于调用：
```
点。getrotateinstance（数学。但（极其，vecx），anchorx，anchory）；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    结果
    
    一个 AffineTransform对象旋转坐标在指定点按指定的旋转矢量。
    
    从以下版本开始：
    
    一点六
  - getQuadrantRotateInstance
```
public static AffineTransform getQuadrantRotateInstance(int numquadrants)
```
    返回一个旋转坐标变换的指定数目的象限。这个操作是相当于调用：
```
点。getrotateinstance（numquadrants * math.pi / 2）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    结果
    
    一个 AffineTransform对象旋转坐标指定数目的象限。
    
    从以下版本开始：
    
    一点六
  - getQuadrantRotateInstance
```
public static AffineTransform getQuadrantRotateInstance(int numquadrants,
                                                        double anchorx,
                                                        double anchory)
```
    返回一个旋转坐标变换的指定数在指定点的象限。这个操作是相当于调用：
```
点。getrotateinstance（numquadrants * math.pi / 2，anchorx，anchory）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    结果
    
    一个 AffineTransform对象旋转坐标指定数在指定点的象限。
    
    从以下版本开始：
    
    一点六
  - getScaleInstance
```
public static AffineTransform getScaleInstance(double sx,
                                               double sy)
```
    返回表示缩放变换的变换。表示返回的变换矩阵：
```
[ 0 ] SX 0[ 0，0 ]系统["0 1 0"]
```
    参数
    
    sx -因子的坐标缩放沿X轴方向
    
    sy -因子的坐标缩放沿Y轴方向
    
    结果
    
    一个 AffineTransform对象尺度坐标指定的因素。
    
    从以下版本开始：
    
    一点二
  - getShearInstance
```
public static AffineTransform getShearInstance(double shx,
                                               double shy)
```
    返回表示剪切转换的变换。表示返回的变换矩阵：
```
[ 1，0 ] SHX[害羞0 1 ]["0 1 0"]
```
    参数
    
    shx -乘数的坐标在X轴的正方向移动的Y因子协调
    
    shy -乘数的坐标移在Y轴方向为X坐标的一个因素
    
    结果
    
    一个 AffineTransform对象剪坐标由指定的乘数。
    
    从以下版本开始：
    
    一点二
  - getType
```
public int getType()
```
    检索描述此转换的转换属性的标志位。返回值是常数type_identity或type_general_transform的任何一个，或结合相应的标志位。标记位的有效结合是一个异或操作，可以结合type_translation标志位除的type_uniform_scale或type_general_scale标志位以及任何的type_quadrant_rotation或type_general_rotation标志位。
    
    结果
    
    适用于此变换的任何指示标志的或组合
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    TYPE_IDENTITY， TYPE_TRANSLATION， TYPE_UNIFORM_SCALE， TYPE_GENERAL_SCALE， TYPE_QUADRANT_ROTATION， TYPE_GENERAL_ROTATION， TYPE_GENERAL_TRANSFORM
  - getDeterminant
```
public double getDeterminant()
```
    返回变换的矩阵表示的行列式。行列式是有用的，以确定是否该变换可以被反转，并得到一个单一的值表示的组合的X和Y缩放的变换。
    如果行列式非零，那么这种变换是可逆的，各种各样的方法，依靠反变换不需要把NoninvertibleTransformException。如果行列式为零则该变换不可倒置自变换Map输入坐标系上的线或点。如果行列式是接近足够的零，然后逆变换操作可能无法进行足够的精度，以产生有意义的结果。
    
    如果这是一个统一的尺度变换，那时getType方法的决定也代表着统一的尺度因子，所有的点都扩大或收缩对起源的平方表示。如果这个变换代表一个非均匀的尺度或更一般的变换，那么决定因素是不可能代表一个有用的值以外的任何目的，确定如果逆变换是可能的。
    
    在数学上，行列式的计算公式：
```
| M00 M01 M02 || M10 M11 M12 | = M00 * M11—M01 * M10| 0 0 1 |
```
    结果
    
    用于变换坐标的矩阵的行列式。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getType()， createInverse()， inverseTransform(java.awt.geom.Point2D, java.awt.geom.Point2D)， TYPE_UNIFORM_SCALE
  - getMatrix
```
public void getMatrix(double[] flatmatrix)
```
    在3x3仿射变换矩阵并将其检索指定值为6的双精度值的数组。值存储在数组{ M00 M10 M01 M11 M02 M12 }。4双打数组也可以指定，在这种情况下，只有前四个元素的数组部分非变换检索和值存储到数组{ M00 M10 M01 M11 }
    
    参数
    
    flatmatrix -用于存储返回值的双数组。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getScaleX()， getScaleY()， getShearX()， getShearY()， getTranslateX()， getTranslateY()
  - getScaleX
```
public double getScaleX()
```
    返回x坐标缩放元素（M00）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的缩放元素的x坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - getScaleY
```
public double getScaleY()
```
    返回Y坐标缩放元素（M11）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的缩放元素的Y坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - getShearX
```
public double getShearX()
```
    返回x坐标剪切元件（M01）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的剪切元件的X坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - getShearY
```
public double getShearY()
```
    返回Y坐标剪切元件（M10）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的剪切元件的Y坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - getTranslateX
```
public double getTranslateX()
```
    返回的翻译单元的x坐标（M02）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的平移元的x坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - getTranslateY
```
public double getTranslateY()
```
    返回的翻译单元的y坐标（M12）的3x3仿射变换矩阵。
    
    结果
    
    一个双值，是仿射变换矩阵的平移元素的Y坐标。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getMatrix(double[])
  - translate
```
public void translate(double tx,
                      double ty)
```
    将此变换与平移变换。这相当于调用连接（t），其中t是由下面的矩阵表示：
```
[ 1 ] 0 TX[ 0 ] 1度["0 1 0"]
```
    AffineTransform
    参数
    
    tx -距离坐标转换在X轴方向
    
    ty -距离坐标转化在Y轴方向
    
    从以下版本开始：
    
    一点二
  - rotate
```
public void rotate(double theta)
```
    将此变换和旋转变换。这相当于调用连接（R），其中R是一个 AffineTransform用下面的矩阵表示：
```
【cos（θ）罪（θ）0 ]【sin（θ）cos（θ）0 ]["0 1 0"]
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    从以下版本开始：
    
    一点二
  - rotate
```
public void rotate(double theta,
                   double anchorx,
                   double anchory)
```
    将此变换与坐标变换，旋转围绕一个锚点。这个操作等于平移坐标，定位点在原点（S1），然后转动他们的新来源（S2），并最终将使中间的起源是恢复到原来的定位点坐标（S3）。
    此操作相当于下面的调用序列：
```
翻译（anchorx，anchory）；// S3：最后的翻译旋转（θ）；// S2：绕锚翻译（- anchorx，- anchory）；// S1：把锚的起源
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点二
  - rotate
```
public void rotate(double vecx,
                   double vecy)
```
    将此变换与坐标变换，旋转，根据旋转矢量。所有的坐标由相同数量的原点旋转。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy是0，没有额外的旋转被添加到这个变换。这个操作是相当于调用：
```
旋转（数学。但（极其，vecx））；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    从以下版本开始：
    
    一点六
  - rotate
```
public void rotate(double vecx,
                   double vecy,
                   double anchorx,
                   double anchory)
```
    将此变换与坐标变换，旋转围绕一个锚点根据旋转矢量。所有的坐标旋转指定的锚定坐标由相同的金额。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy 0，变换是不以任何方式修改。这种方法相当于调用：
```
旋转（数学。但（极其，vecx），anchorx，anchory）；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点六
  - quadrantRotate
```
public void quadrantRotate(int numquadrants)
```
    将此变换与旋转坐标变换的指定数目的象限。这相当于说：
```
旋转（numquadrants * math.pi / 2）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    从以下版本开始：
    
    一点六
  - quadrantRotate
```
public void quadrantRotate(int numquadrants,
                           double anchorx,
                           double anchory)
```
    将此变换与变换旋转坐标指定数在指定点的象限。这种方法相当于调用：
```
旋转（numquadrants * math.pi / 2，anchorx，anchory）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点六
  - scale
```
public void scale(double sx,
                  double sy)
```
    将此变换和比例变换。这相当于调用连接（s），其中s是由下面的矩阵表示：
```
[ 0 ] SX 0[ 0，0 ]系统["0 1 0"]
```
    AffineTransform
    参数
    
    sx -因子的坐标缩放沿X轴方向
    
    sy -因子的坐标缩放沿Y轴方向
    
    从以下版本开始：
    
    一点二
  - shear
```
public void shear(double shx,
                  double shy)
```
    将此变换与剪切变换。这相当于调用连接（SH），在SH是用下面的矩阵表示一个 AffineTransform：
```
[ 1，0 ] SHX[害羞0 1 ]["0 1 0"]
```
    参数
    
    shx -乘数的坐标在X轴的正方向移动的Y因子协调
    
    shy -乘数的坐标移在Y轴方向为X坐标的一个因素
    
    从以下版本开始：
    
    一点二
  - setToIdentity
```
public void setToIdentity()
```
    重置该变换身份变换。
    
    从以下版本开始：
    
    一点二
  - setToTranslation
```
public void setToTranslation(double tx,
                             double ty)
```
    将此转换设置为转换转换。代表这个变换矩阵变为：
```
[ 1 ] 0 TX[ 0 ] 1度["0 1 0"]
```
    参数
    
    tx -距离坐标转换在X轴方向
    
    ty -距离坐标转化在Y轴方向
    
    从以下版本开始：
    
    一点二
  - setToRotation
```
public void setToRotation(double theta)
```
    将此变换设置为旋转变换。代表这个变换矩阵变为：
```
【cos（θ）罪（θ）0 ]【sin（θ）cos（θ）0 ]["0 1 0"]
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    从以下版本开始：
    
    一点二
  - setToRotation
```
public void setToRotation(double theta,
                          double anchorx,
                          double anchory)
```
    将此转换设置为一个翻译的旋转变换。这个操作等于平移坐标，定位点在原点（S1），然后转动他们的新来源（S2），并最终将使中间的起源是恢复到原来的定位点坐标（S3）。
    此操作相当于下面的调用序列：
```
settotranslation（anchorx，anchory）；// S3：最后的翻译旋转（θ）；// S2：绕锚翻译（- anchorx，- anchory）；// S1：把锚的起源
```
    矩阵表示此变换成为：
```
【cos（θ）罪（θ）X-X×COS + Y *罪]【sin（θ）cos（θ）* *因为] sin-y Y-X["0 1 0"]
```
    旋转的正角度θ的X轴Y轴旋转朝着积极点。注意上面的讨论 Handling 90-Degree Rotations。
    参数
    
    theta -弧度的旋转角度的测量
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点二
  - setToRotation
```
public void setToRotation(double vecx,
                          double vecy)
```
    将此变换设置为根据旋转矢量旋转坐标的旋转变换。所有的坐标由相同数量的原点旋转。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy 0，变换将一个身份变换。这个操作是相当于调用：
```
settorotation（数学。但（极其，vecx））；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    从以下版本开始：
    
    一点六
  - setToRotation
```
public void setToRotation(double vecx,
                          double vecy,
                          double anchorx,
                          double anchory)
```
    将此变换设置为根据旋转矢量围绕一个固定点旋转的旋转变换。所有的坐标旋转指定的锚定坐标由相同的金额。旋转的量是这样的，沿着前正X轴的坐标将随后与从原点指向指定的矢量坐标的矢量对齐。如果 vecx和 vecy 0，变换将一个身份变换。这个操作是相当于调用：
```
settotranslation（数学。但（极其，vecx），anchorx，anchory）；
```
    参数
    
    vecx -旋转矢量的x坐标
    
    vecy -旋转矢量坐标
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点六
  - setToQuadrantRotation
```
public void setToQuadrantRotation(int numquadrants)
```
    设置这个变换一个旋转坐标指定数个象限旋转变换。这个操作是相当于调用：
```
settorotation（numquadrants * math.pi / 2）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    从以下版本开始：
    
    一点六
  - setToQuadrantRotation
```
public void setToQuadrantRotation(int numquadrants,
                                  double anchorx,
                                  double anchory)
```
    设置这个变换翻译旋转变换的旋转坐标系上的指定数在指定点的象限。这个操作是相当于调用：
```
settorotation（numquadrants * math.pi / 2，anchorx，anchory）；
```
    旋转的正数的象限的X轴Y轴旋转朝着积极点。
    参数
    
    numquadrants - 90度弧数转动
    
    anchorx -旋转点的X坐标
    
    anchory -旋转点的Y坐标
    
    从以下版本开始：
    
    一点六
  - setToScale
```
public void setToScale(double sx,
                       double sy)
```
    将此转换设置为缩放转换。代表这个变换矩阵变为：
```
[ 0 ] SX 0[ 0，0 ]系统["0 1 0"]
```
    参数
    
    sx -因子的坐标缩放沿X轴方向
    
    sy -因子的坐标缩放沿Y轴方向
    
    从以下版本开始：
    
    一点二
  - setToShear
```
public void setToShear(double shx,
                       double shy)
```
    将此转换设置为剪切转换。代表这个变换矩阵变为：
```
[ 1，0 ] SHX[害羞0 1 ]["0 1 0"]
```
    参数
    
    shx -乘数的坐标在X轴的正方向移动的Y因子协调
    
    shy -乘数的坐标移在Y轴方向为X坐标的一个因素
    
    从以下版本开始：
    
    一点二
  - setTransform
```
public void setTransform(AffineTransform Tx)
```
    设置这个变换复制在指定 AffineTransform对象的变换。
    
    参数
    
    Tx -从复制变换的 AffineTransform对象
    
    从以下版本开始：
    
    一点二
  - setTransform
```
public void setTransform(double m00,
                         double m10,
                         double m01,
                         double m11,
                         double m02,
                         double m12)
```
    将此转换设置为由6个双精度值指定的矩阵。
    
    参数
    
    m00 - X坐标缩放的3x3的矩阵元
    
    m10 - Y坐标剪切的3x3的矩阵元
    
    m01 - x坐标剪切的3x3的矩阵元
    
    m11 - Y坐标缩放的3x3的矩阵元
    
    m02 - X坐标转换元件的3x3矩阵
    
    m12 - Y坐标转换元件的3x3矩阵
    
    从以下版本开始：
    
    一点二
  - concatenate
```
public void concatenate(AffineTransform Tx)
```
    将一个 AffineTransform Tx这 AffineTransform CX在最常用的方式为用户提供新的空间，是由 Tx映射到用户空间的前。CX更新进行组合变换。将点P的更新变换CX”相当于先把P的 Tx然后转换结果由原变换CX这样：CX”（P）= cx（TX（P））在矩阵表示，如果这个变换CX由矩阵[这]和 Tx由矩阵[ TX ]那么这方法如下：
```
[这] = [这]×[发送]
```
    参数
    
    Tx -要与此 AffineTransform对象级联的 AffineTransform对象。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    preConcatenate(java.awt.geom.AffineTransform)
  - preConcatenate
```
public void preConcatenate(AffineTransform Tx)
```
    将这 AffineTransform CX一个 AffineTransform Tx在一个不太常用的方式， Tx修改坐标变换相对于绝对像素空间而不是相对于现有的用户空间。CX更新进行组合变换。将点P的更新变换CX”相当于第一转换P变换CX和转化的结果 Tx这样原文：CX”（P）= TX（CX（P））在矩阵表示，如果这个变换CX由矩阵[这]和 Tx由矩阵[ TX ]那么这方法如下：
```
[这] = [发送]×[这]
```
    参数
    
    Tx -要与此 AffineTransform对象级联的 AffineTransform对象。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    concatenate(java.awt.geom.AffineTransform)
  - createInverse
```
public AffineTransform createInverse()
                              throws NoninvertibleTransformException
```
    返回一个 AffineTransform表示反变换。反变换TX的这个变换TXMap坐标转换由Tx回到他们原来的坐标。换句话说，TX”（TX（P））= P = TX（TX”（P））。
    如果这个变换将所有的坐标映射到一个点或一条线，那么它将不会有一个逆，因为不位于目标点或线的坐标将不会有一个逆映射。的getDeterminant方法可以用来确定这种变换没有逆，在这种情况下，一个例外的是如果createInverse方法叫做扔。
    
    结果
    
    一个新的 AffineTransform表示反变换。
    
    异常
    
    NoninvertibleTransformException如果矩阵不能倒。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    getDeterminant()
  - invert
```
public void invert()
            throws NoninvertibleTransformException
```
    将此转换设置为本身的逆。反变换TX的这个变换TXMap坐标转换由Tx回到他们原来的坐标。换句话说，TX”（TX（P））= P = TX（TX”（P））。
    如果这个变换将所有的坐标映射到一个点或一条线，那么它将不会有一个逆，因为不位于目标点或线的坐标将不会有一个逆映射。的getDeterminant方法可以用来确定这种变换没有逆，在这种情况下，一个例外的是如果invert方法叫做扔。
    
    异常
    
    NoninvertibleTransformException如果矩阵不能倒。
    
    从以下版本开始：
    
    一点六
    
    另请参见：
    
    getDeterminant()
  - transform
```
public Point2D transform(Point2D ptSrc,
                         Point2D ptDst)
```
    将指定的 ptSrc和商店在 ptDst结果。如果 ptDst是 null，新 Point2D对象分配和转换的结果存储在这个对象。在任何情况下， ptDst，其中包含的转换点，是返回方便。如果 ptSrc和 ptDst是相同的对象，输入点是正确覆盖转化点。
    
    参数
    
    ptSrc -指定 Point2D被转化
    
    ptDst -指定 Point2D店 ptSrc转化的结果
    
    结果
    
    改造后的 ptSrc和 ptDst存储结果的 ptDst。
    
    从以下版本开始：
    
    一点二
  - transform
```
public void transform(Point2D[] ptSrc,
                      int srcOff,
                      Point2D[] ptDst,
                      int dstOff,
                      int numPts)
```
    用这个变换变换一个点对象的数组。如果 ptDst数组的任何元素 null，新 Point2D对象分配和存储在元素之前存储转换结果。
    请注意，此方法不采取任何措施以避免存储结果为Point2D对象将被用作源的计算进一步下跌的源数组问题。这个方法并保证在指定的Point2D对象的源和目标的单点变换操作的结果不会被存储到计算完成避免顶部的操作数存储结果。如果，然而，一个操作的目标Point2D对象才可以被转换对象作为另一个操作的源Point2D对象进一步下跌，那么源阵列，点的原始坐标覆盖相同。
    
    参数
    
    ptSrc含源对象数组
    
    ptDst -数组的返回点对象的变换
    
    srcOff -偏移到第一点对象是源数组中的转化
    
    dstOff -偏移到第一个转换点的对象，存储在目标阵列位置
    
    numPts -点对象的数量被转化
    
    从以下版本开始：
    
    一点二
  - transform
```
public void transform(float[] srcPts,
                      int srcOff,
                      float[] dstPts,
                      int dstOff,
                      int numPts)
```
    用这个变换变换一个浮点坐标的数组。这两个坐标阵列部分可以完全相同或可以是相同的数组的重叠部分，而不会影响结果的有效性。这种方法可以确保没有源坐标覆盖先前的操作才可以转化。坐标存储在数组的开始在指定的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    
    参数
    
    srcPts含有源点坐标的数组。每一点存储为一对X，Y坐标的。
    
    dstPts的数组中返回转换后的点的坐标。每一点存储为一对X，Y坐标的。
    
    srcOff -偏移的第一点是源数组中的转化
    
    dstOff -偏移到第一个转换点是存储在目标阵列位置
    
    numPts -点数进行改造
    
    从以下版本开始：
    
    一点二
  - transform
```
public void transform(double[] srcPts,
                      int srcOff,
                      double[] dstPts,
                      int dstOff,
                      int numPts)
```
    用这个变换变换一个双精度坐标的数组。这两个坐标阵列部分可以完全相同或可以是相同的数组的重叠部分，而不会影响结果的有效性。这种方法可以确保没有源坐标覆盖先前的操作才可以转化。坐标存储在数组的开始显示的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    
    参数
    
    srcPts含有源点坐标的数组。每一点存储为一对X，Y坐标的。
    
    dstPts的数组中返回转换后的点的坐标。每一点存储为一对X，Y坐标的。
    
    srcOff -偏移的第一点是源数组中的转化
    
    dstOff -偏移到第一个转换点是存储在目标阵列位置
    
    numPts -点对象的数量被转化
    
    从以下版本开始：
    
    一点二
  - transform
```
public void transform(float[] srcPts,
                      int srcOff,
                      double[] dstPts,
                      int dstOff,
                      int numPts)
```
    通过将一个浮点坐标数组转换成一个数组，并将结果存储到一个数组中的一个数组中。坐标存储在数组的开始在指定的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    
    参数
    
    srcPts含有源点坐标的数组。每一点存储为一对X，Y坐标的。
    
    dstPts的数组中返回转换后的点的坐标。每一点存储为一对X，Y坐标的。
    
    srcOff -偏移的第一点是源数组中的转化
    
    dstOff -偏移到第一个转换点是存储在目标阵列位置
    
    numPts -点数进行改造
    
    从以下版本开始：
    
    一点二
  - transform
```
public void transform(double[] srcPts,
                      int srcOff,
                      float[] dstPts,
                      int dstOff,
                      int numPts)
```
    通过这种变换变换一个双精度坐标的数组，并将结果存储到一个浮动的数组中。坐标存储在数组的开始在指定的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    
    参数
    
    srcPts含有源点坐标的数组。每一点存储为一对X，Y坐标的。
    
    dstPts的数组中返回转换后的点的坐标。每一点存储为一对X，Y坐标的。
    
    srcOff -偏移的第一点是源数组中的转化
    
    dstOff -偏移到第一个转换点是存储在目标阵列位置
    
    numPts -点对象的数量被转化
    
    从以下版本开始：
    
    一点二
  - inverseTransform
```
public Point2D inverseTransform(Point2D ptSrc,
                                Point2D ptDst)
                         throws NoninvertibleTransformException
```
    逆转换并存储在指定的 ptSrc ptDst结果。如果 ptDst是 null，新 Point2D对象分配然后转换的结果存储在这个对象。在任何情况下， ptDst，其中包含的转换点，是返回方便。如果 ptSrc和 ptDst是相同的对象，输入点是正确覆盖转化点。
    
    参数
    
    ptSrc -关键是逆转换
    
    ptDst -得到的转化点
    
    结果
    
    ptDst，其中包含了反变换的结果。
    
    异常
    
    NoninvertibleTransformException如果矩阵不能倒。
    
    从以下版本开始：
    
    一点二
  - inverseTransform
```
public void inverseTransform(double[] srcPts,
                             int srcOff,
                             double[] dstPts,
                             int dstOff,
                             int numPts)
                      throws NoninvertibleTransformException
```
    通过这种变换，逆变换一个双精度坐标的数组。这两个坐标阵列部分可以完全相同或可以是相同的数组的重叠部分，而不会影响结果的有效性。这种方法可以确保没有源坐标覆盖先前的操作才可以转化。坐标存储在数组的开始在指定的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    
    参数
    
    srcPts含有源点坐标的数组。每一点存储为一对X，Y坐标的。
    
    dstPts的数组中返回转换后的点的坐标。每一点存储为一对X，Y坐标的。
    
    srcOff -偏移的第一点是源数组中的转化
    
    dstOff -偏移到第一个转换点是存储在目标阵列位置
    
    numPts -点对象的数量被转化
    
    异常
    
    NoninvertibleTransformException如果矩阵不能倒。
    
    从以下版本开始：
    
    一点二
  - deltaTransform
```
public Point2D deltaTransform(Point2D ptSrc,
                              Point2D ptDst)
```
    将相对距离向量指定的 ptSrc和商店在 ptDst结果。相对距离向量转化没有申请使用下列方程的仿射变换矩阵的平移分量：
```
【x】【M00 M01（M02）] [×] [ m00x + m01y ][你] = [ M10 M11（M12）] [ ] = [ m10x + m11y ][（1）] [（0）（0）（1）] [（1）] [（1）]
```
    如果 ptDst是 null，新 Point2D对象分配然后转换的结果存储在这个对象。在任何情况下， ptDst，其中包含的转换点，是返回方便。如果 ptSrc和 ptDst是相同的对象，输入点是正确覆盖转化点。
    参数
    
    ptSrc的距离矢量是三角变换
    
    ptDst -得到的变换距离矢量
    
    结果
    
    ptDst，包括转型的结果。
    
    从以下版本开始：
    
    一点二
  - deltaTransform
```
public void deltaTransform(double[] srcPts,
                           int srcOff,
                           double[] dstPts,
                           int dstOff,
                           int numPts)
```
    通过这种变换变换一个相对距离向量的数组。相对距离向量转化没有申请使用下列方程的仿射变换矩阵的平移分量：
```
【x】【M00 M01（M02）] [×] [ m00x + m01y ][你] = [ M10 M11（M12）] [ ] = [ m10x + m11y ][（1）] [（0）（0）（1）] [（1）] [（1）]
```
    两坐标数组部分可以完全相同或不影响结果的有效性是同一阵列的重叠的部分。这种方法可以确保没有源坐标覆盖先前的操作才可以转化。坐标存储在数组的开始显示的顺序 [x0, y0, x1, y1, ..., xn, yn]偏移。
    参数
    
    srcPts含源距离矢量阵。每个向量存储为一对相对 X，Y坐标。
    
    dstPts的数组中返回的距离变换向量。每个向量存储为一对相对 X，Y坐标。
    
    srcOff -偏移的第一载体是源数组中的转化
    
    dstOff -偏移到第一变换向量存储在目标数组的位置
    
    numPts -矢量坐标对的数目可以转化
    
    从以下版本开始：
    
    一点二
  - createTransformedShape
```
public Shape createTransformedShape(Shape pSrc)
```
    返回由指定的 Shape几何后已由该变换新的 Shape对象。
    
    参数
    
    pSrc -指定 Shape对象是经过这种变换。
    
    结果
    
    一个新的 Shape定义转化 Shape几何，如果 pSrc为空或空。
    
    从以下版本开始：
    
    一点二
  - toString
```
public String toString()
```
    返回一个 String表示此 Object价值。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    一个 String表示此 Object价值。
    
    从以下版本开始：
    
    一点二
  - isIdentity
```
public boolean isIdentity()
```
    如果这是一个回报 true AffineTransform恒等变换。
    
    结果
    
    如果这是一 true AffineTransform恒等变换； false否则。
    
    从以下版本开始：
    
    一点二
  - clone
```
public Object clone()
```
    返回一份本 AffineTransform对象。
    
    重写：
    
    clone 方法重写，继承类 Object
    
    结果
    
    一个 Object是一份本 AffineTransform对象。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    Cloneable
  - hashCode
```
public int hashCode()
```
    返回此hashCode变换。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    用于此变换的哈希代码。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - equals
```
public boolean equals(Object obj)
```
    返回 true如果这 AffineTransform代表相同的仿射坐标变换为指定参数。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj - Object为这 AffineTransform相等测试
    
    结果
    
    true如果 obj等于这 AffineTransform对象； false否则。
    
    从以下版本开始：
    
    一点二
    
    另请参见：
    
    Object.hashCode()， HashMap

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class AffineTransform

Handling 90-Degree Rotations

Field 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

方法详细信息

getTranslateInstance

getRotateInstance

getRotateInstance

getRotateInstance

getRotateInstance

getQuadrantRotateInstance

getQuadrantRotateInstance

getScaleInstance

getShearInstance

getType

getDeterminant

getMatrix

getScaleX

getScaleY

getShearX

getShearY

getTranslateX

getTranslateY

translate

rotate

rotate

rotate

rotate

quadrantRotate

quadrantRotate

scale

shear

setToIdentity

setToTranslation

setToRotation

setToRotation

setToRotation

setToRotation

setToQuadrantRotation

setToQuadrantRotation

setToScale

setToShear

setTransform

setTransform

concatenate

preConcatenate

createInverse

invert

transform

transform

transform

transform

transform

transform

inverseTransform

inverseTransform

deltaTransform

deltaTransform

createTransformedShape

toString