站内搜索: 请输入搜索关键词
当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

AffineTransform (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版

概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法

java.awt.geom
类 AffineTransform

java.lang.Object
  继承者 java.awt.geom.AffineTransform
所有已实现的接口：
Serializable, Cloneable
public class AffineTransform
extends Object
implements Cloneable, Serializable

AffineTransform 类表示 2D 仿射变换，它执行从 2D 坐标到其他 2D 坐标的线性映射，保留了线的“直线性”和“平行性”。可以使用一系列平移、缩放、翻转、旋转和剪切来构造仿射变换。

这样的坐标变换可以使用一个 3 行乘 3 列的矩阵来表示，最后一行默认为 [ 0 0 1 ]。此矩阵将源坐标 (x, y) 变换为目标坐标 (x', y')，方法是将坐标视为列向量，并用矩阵乘以坐标向量，步骤如下： 

        [ x']   [  m00  m01  m02  ] [ x ]   [ m00x + m01y + m02 ]
        [ y'] = [  m10  m11  m12  ] [ y ] = [ m10x + m11y + m12 ]
        [ 1 ]   [   0    0    1   ] [ 1 ]   [         1         ]

另请参见：
序列化表格

字段摘要
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
          此标志位指示此对象定义的变换除了执行其他标志位指定的变换外，还执行统一缩放操作。
 
构造方法摘要
AffineTransform()
          构造一个表示 Identity 变换的新 AffineTransform。
AffineTransform(AffineTransform Tx)
          构造一个新 AffineTransform，让它作为指定的 AffineTransform 对象的副本。
AffineTransform(double[] flatmatrix)
          根据 double 精度值数组构造一个新 AffineTransform，该数组要么表示 3x3 变换矩阵的 4 非平移条目，要么表示它的 6 可指定条目。
AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)
          根据表示 3x3 变换矩阵 6 个可指定条目的 6 个 double 精度值构造一个新 AffineTransform。
AffineTransform(float[] flatmatrix)
          根据一个浮点值数组构造一个新 AffineTransform，该数组要么表示 3x3 变换矩阵的 4 个非平移条目，要么表示其 6 个可指定条目。
AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)
          根据表示 6 个 3x3 变换矩阵可指定条目的 6 个浮点值构造一个新 AffineTransform。
 
方法摘要
 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)
          如果此 AffineTransform 与指定的参数表示相同的仿射坐标变换，则返回 true。
 double getDeterminant()
          返回变换的矩阵表示形式的决定因子。
 void getMatrix(double[] flatmatrix)
          在 3x3 仿射变换矩阵中检索 6 个可指定值，并将其置于 double 精度值的数组中。
static AffineTransform getRotateInstance(double theta)
          返回表示旋转变换的变换。
static AffineTransform getRotateInstance(double theta, double x, double y)
          返回绕锚点旋转坐标的变换。
static AffineTransform getScaleInstance(double sx, double sy)
          返回表示缩放变换的变换。
 double getScaleX()
          返回 3x3 仿射变换矩阵缩放元素 (m00) 的 X 坐标。
 double getScaleY()
          返回 3x3 仿射变换矩阵缩放元素 (m11) 的 Y 坐标。
static AffineTransform getShearInstance(double shx, double shy)
          返回表示剪切变换的变换。
 double getShearX()
          返回 3x3 仿射变换矩阵剪切元素 (m01) 的 X 坐标。
 double getShearY()
          返回 3x3 仿射变换矩阵剪切元素 (m10) 的 Y 坐标。
static AffineTransform getTranslateInstance(double tx, double ty)
          返回表示平移变换的变换。
 double getTranslateX()
          返回 3x3 仿射变换矩阵平移元素 (m02) 的 X 坐标。
 double getTranslateY()
          返回 3x3 仿射变换矩阵平移元素 (m12) 的 Y 坐标。
 int getType()
          检索描述此变换的转换属性的标志位。
 int hashCode()
          返回此变换的哈希码。
 void inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
          通过此变换逆向变换 double 精度坐标数组。
 Point2D inverseTransform(Point2D ptSrc, Point2D ptDst)
          逆向变换指定的 ptSrc 并将结果存储在 ptDst 中。
 boolean isIdentity()
          如果此 AffineTransform 是恒等变换，则返回 true。
 void preConcatenate(AffineTransform Tx)
          以不常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，从而 Tx 相对于绝对像素空间（而非相对于现有用户空间）修改坐标变换。
 void rotate(double theta)
          连接此变换与旋转变换。
 void rotate(double theta, double x, double y)
          连接此变换与绕锚点旋转坐标的变换。
 void scale(double sx, double sy)
          连接此变换与缩放变换。
 void setToIdentity()
          将此变换重置为 Identity 变换。
 void setToRotation(double theta)
          将此变换设置为旋转变换。
 void setToRotation(double theta, double x, double y)
          将此变换设置为平移的旋转变换。
 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 个 double 精度值指定的矩阵。
 void shear(double shx, double shy)
          连接此变换与剪切变换。
 String toString()
          返回表示此 Object 值的 String。
 void transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
          通过此变换变换 double 精度坐标数组。
 void transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)
          通过此变换变换 double 精度坐标数组并将结果存储在 float 数组中。
 void transform(float[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)
          通过此变换变换浮点坐标数组并将结果存储在 double 数组中。
 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)
          连接此变换与平移变换。
 
从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, wait, wait, wait
 

字段详细信息

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(), 常量字段值

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(), 常量字段值

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(), 常量字段值

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(), 常量字段值

TYPE_MASK_SCALE

public static final int TYPE_MASK_SCALE
此常量是所有缩放标志位的位掩码。

另请参见：
TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, 常量字段值

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(), 常量字段值

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(), 常量字段值

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(), 常量字段值

TYPE_MASK_ROTATION

public static final int TYPE_MASK_ROTATION
此常量是所有旋转标志位的位掩码。

另请参见：
TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, 常量字段值

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(), 常量字段值
构造方法详细信息

AffineTransform

public AffineTransform()
构造一个表示 Identity 变换的新 AffineTransform。

AffineTransform

public AffineTransform(AffineTransform Tx)
构造一个新 AffineTransform，让它作为指定的 AffineTransform 对象的副本。

参数：
Tx - 要复制的 AffineTransform 对象

AffineTransform

public AffineTransform(float m00,
                       float m10,
                       float m01,
                       float m11,
                       float m02,
                       float m12)
根据表示 6 个 3x3 变换矩阵可指定条目的 6 个浮点值构造一个新 AffineTransform。

参数：
m00, m01, m02, m10, m11, m12 - 组成 3x3 变换矩阵的 6 个浮点值

AffineTransform

public AffineTransform(float[] flatmatrix)
根据一个浮点值数组构造一个新 AffineTransform，该数组要么表示 3x3 变换矩阵的 4 个非平移条目，要么表示其 6 个可指定条目。从该数组中检索到的值为 { m00 m10 m01 m11 [m02 m12]}。

参数：
flatmatrix - 包含要在新 AffineTransform 对象中设置的值的 float 数组。假定数组的长度至少为 4。如果数组的长度小于 6，则仅采用前 4 个值。如果数组的长度大于 6，则采用前 6 个值。

AffineTransform

public AffineTransform(double m00,
                       double m10,
                       double m01,
                       double m11,
                       double m02,
                       double m12)
根据表示 3x3 变换矩阵 6 个可指定条目的 6 个 double 精度值构造一个新 AffineTransform。

参数：
m00, m01, m02, m10, m11, m12 - 组成 3x3 变换矩阵的 6 个浮点值

AffineTransform

public AffineTransform(double[] flatmatrix)
根据 double 精度值数组构造一个新 AffineTransform，该数组要么表示 3x3 变换矩阵的 4 非平移条目，要么表示它的 6 可指定条目。从该数组中检索到的值为 { m00 m10 m01 m11 [m02 m12]}。

参数：
flatmatrix - 包含要在新 AffineTransform 对象中设置的值的 double 数组。假定数组的长度至少为 4。如果数组的长度小于 6，则仅采用前 4 个值。如果数组的长度大于 6，则采用前 6 个值。
方法详细信息

getTranslateInstance

public static AffineTransform getTranslateInstance(double tx,
                                                   double ty)
返回表示平移变换的变换。表示返回变换的矩阵是： 
                [   1    0    tx  ]
                [   0    1    ty  ]
                [   0    0    1   ]

参数：
tx - 坐标在 X 轴方向上平移的距离
ty - 坐标在 Y 轴方向上平移的距离
返回：
表示平移变换的 AffineTransform 对象，该对象是利用指定向量创建的。

getRotateInstance

public static AffineTransform getRotateInstance(double theta)
返回表示旋转变换的变换。表示返回变换的矩阵是： 
                [   cos(theta)    -sin(theta)    0   ]
                [   sin(theta)     cos(theta)    0   ]
                [       0              0         1   ]
使用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度
返回：
使用指定旋转角度创建的、作为旋转变换的 AffineTransform 对象。

getRotateInstance

public static AffineTransform getRotateInstance(double theta,
                                                double x,
                                                double y)
返回绕锚点旋转坐标的变换。此操作等效于：平移坐标，使锚点位于原点 (S1)，然后绕新原点 (S2) 旋转它们，最后再平移，将中间原点恢复为初始锚点 (S3) 的坐标。

此操作等效于以下调用序列： 

            AffineTransform Tx = new AffineTransform();
            Tx.setToTranslation(x, y);  // S3: final translation
            Tx.rotate(theta);           // S2: rotate around anchor
            Tx.translate(-x, -y);       // S1: translate anchor to origin
表示返回变换的矩阵是： 
                [   cos(theta)    -sin(theta)    x-x*cos+y*sin  ]
                [   sin(theta)     cos(theta)    y-x*sin-y*cos  ]
                [       0              0               1        ]
用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度
x, y - 旋转的锚点坐标
返回：
按指定的旋转角度绕指定点旋转坐标的 AffineTransform 对象。

getScaleInstance

public static AffineTransform getScaleInstance(double sx,
                                               double sy)
返回表示缩放变换的变换。表示返回变换的矩阵是： 
                [   sx   0    0   ]
                [   0    sy   0   ]
                [   0    0    1   ]

参数：
sx - 坐标沿 X 轴方向缩放的因子
sy - 坐标沿 Y 轴方向缩放的因子
返回：
按指定因子缩放坐标的 AffineTransform 对象。

getShearInstance

public static AffineTransform getShearInstance(double shx,
                                               double shy)
返回表示剪切变换的变换。表示返回变换的矩阵是： 
                [   1   shx   0   ]
                [  shy   1    0   ]
                [   0    0    1   ]

参数：
shx - 坐标在 X 正半轴方向上进行位移的乘数，与其 Y 坐标的因子一样
shy - 坐标在 Y 正半轴方向上进行位移的乘数，与其 X 坐标的因子一样
返回：
按指定乘数剪切坐标的 AffineTransform 对象。

getType

public int getType()
检索描述此变换的转换属性的标志位。返回值要么为常量 TYPE_IDENTITY 或 TYPE_GENERAL_TRANSFORM 中的一个，要么为适当标志位的组合。标志位的有效组合是一个异或操作，该操作除了组合 TYPE_UNIFORM_SCALE 或 TYPE_GENERAL_SCALE 标志位以及 TYPE_QUADRANT_ROTATION 或 TYPE_GENERAL_ROTATION 标志位之外，还可以组合 TYPE_TRANSLATION 标志位。

返回：
应用于此变换的所有指示标志的 OR 组合
另请参见：
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。如果决定因子为零，则此变换是不可逆的，因为变换将所有输入坐标映射到线或点上。如果决定因子很接近零，则生成有意义结果的逆向变换操作可能不够精确。

如果 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 个可指定值，并将其置于 double 精度值的数组中。在该数组中存储的值为 { m00 m10 m01 m11 m02 m12 }。也可以指定包含 4 个 double 的数组，在这种情况下，仅检索表示数组中非变换部分的前四个元素，并将值作为 { m00 m10 m01 m11 } 存储到数组中

参数：
flatmatrix - 用于存储返回值的 double 数组。
另请参见：
getScaleX(), getScaleY(), getShearX(), getShearY(), getTranslateX(), getTranslateY()

getScaleX

public double getScaleX()
返回 3x3 仿射变换矩阵缩放元素 (m00) 的 X 坐标。

返回：
作为仿射变换矩阵缩放元素的 X 坐标的 double 值。
另请参见：
getMatrix(double[])

getScaleY

public double getScaleY()
返回 3x3 仿射变换矩阵缩放元素 (m11) 的 Y 坐标。

返回：
作为仿射变换矩阵缩放元素的 Y 坐标的 double 值。
另请参见：
getMatrix(double[])

getShearX

public double getShearX()
返回 3x3 仿射变换矩阵剪切元素 (m01) 的 X 坐标。

返回：
作为仿射变换矩阵剪切元素的 X 坐标的 double 值。
另请参见：
getMatrix(double[])

getShearY

public double getShearY()
返回 3x3 仿射变换矩阵剪切元素 (m10) 的 Y 坐标。

返回：
作为仿射变换矩阵剪切元素的 Y 坐标的 double 值。
另请参见：
getMatrix(double[])

getTranslateX

public double getTranslateX()
返回 3x3 仿射变换矩阵平移元素 (m02) 的 X 坐标。

返回：
作为仿射变换矩阵平移元素的 X 坐标的 double 值。
另请参见：
getMatrix(double[])

getTranslateY

public double getTranslateY()
返回 3x3 仿射变换矩阵平移元素 (m12) 的 Y 坐标。

返回：
作为仿射变换矩阵平移元素的 Y 坐标的 double 值。
另请参见：
getMatrix(double[])

translate

public void translate(double tx,
                      double ty)
连接此变换与平移变换。这等效于调用 concatenate(T)，其中 T 为 AffineTransform，由以下矩阵表示： 
                [   1    0    tx  ]
                [   0    1    ty  ]
                [   0    0    1   ]

参数：
tx - 坐标在 X 轴方向上平移的距离
ty - 坐标在 Y 轴方向上平移的距离

rotate

public void rotate(double theta)
连接此变换与旋转变换。这等效于调用 concatenate(R)，其中 R 为 AffineTransform，由以下矩阵表示： 
                [   cos(theta)    -sin(theta)    0   ]
                [   sin(theta)     cos(theta)    0   ]
                [       0              0         1   ]
使用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度

rotate

public void rotate(double theta,
                   double x,
                   double y)
连接此变换与绕锚点旋转坐标的变换。此操作等效于：平移坐标，使锚点位于原点 (S1)，然后绕新原点 (S2) 旋转它们，最后再平移，将中间原点恢复为初始锚点 (S3) 的坐标。

此操作等效于以下调用序列： 

                translate(x, y);        // S3: final translation
                rotate(theta);          // S2: rotate around anchor
                translate(-x, -y);      // S1: translate anchor to origin
使用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度
x, y - 旋转的锚点坐标

scale

public void scale(double sx,
                  double sy)
连接此变换与缩放变换。这等效于调用 concatenate(S)，其中 S 为 AffineTransform，由以下矩阵表示： 
                [   sx   0    0   ]
                [   0    sy   0   ]
                [   0    0    1   ]

参数：
sx - 坐标沿 X 轴方向缩放的因子
sy - 坐标沿 Y 轴方向缩放的因子

shear

public void shear(double shx,
                  double shy)
连接此变换与剪切变换。这等效于调用 concatenate(SH)，其中 SH 为 AffineTransform，由以下矩阵表示： 
                [   1   shx   0   ]
                [  shy   1    0   ]
                [   0    0    1   ]

参数：
shx - 坐标在 X 正半轴方向上进行位移的乘数，与其 Y 坐标的因子一样
shy - 坐标在 Y 正半轴方向上进行位移的乘数，与其 X 坐标的因子一样

setToIdentity

public void setToIdentity()
将此变换重置为 Identity 变换。

setToTranslation

public void setToTranslation(double tx,
                             double ty)
将此变换设置为平移变换。表示此变换的矩阵将变成： 
                [   1    0    tx  ]
                [   0    1    ty  ]
                [   0    0    1   ]

参数：
tx - 坐标在 X 轴方向上平移的距离
ty - 坐标在 Y 轴方向上平移的距离

setToRotation

public void setToRotation(double theta)
将此变换设置为旋转变换。表示此变换的矩阵将变成： 
                [   cos(theta)    -sin(theta)    0   ]
                [   sin(theta)     cos(theta)    0   ]
                [       0              0         1   ]
使用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度

setToRotation

public void setToRotation(double theta,
                          double x,
                          double y)
将此变换设置为平移的旋转变换。此操作等效于：平移坐标，使锚点位于原点 (S1)，然后绕新原点 (S2) 旋转它们，最后再平移，将中间原点恢复为初始锚点 (S3) 的坐标。

此操作等效于以下调用序列： 

            setToTranslation(x, y);     // S3: final translation
            rotate(theta);              // S2: rotate around anchor
            translate(-x, -y);          // S1: translate anchor to origin
表示此变换的矩阵将变成： 
                [   cos(theta)    -sin(theta)    x-x*cos+y*sin  ]
                [   sin(theta)     cos(theta)    y-x*sin-y*cos  ]
                [       0              0               1        ]
使用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：
theta - 用弧度表示的旋转角度
x, y - 旋转的锚点坐标

setToScale

public void setToScale(double sx,
                       double sy)
将此变换设置为缩放变换。表示此变换的矩阵将变成： 
                [   sx   0    0   ]
                [   0    sy   0   ]
                [   0    0    1   ]

参数：
sx - 坐标沿 X 轴方向缩放的因子
sy - 坐标沿 Y 轴方向缩放的因子

setToShear

public void setToShear(double shx,
                       double shy)
将此变换设置为剪切变换。表示此变换的矩阵将变成： 
                [   1   shx   0   ]
                [  shy   1    0   ]
                [   0    0    1   ]

参数：
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 个 double 精度值指定的矩阵。

参数：
m00, m01, m02, m10, m11, m12 - 组成 3x3 变换矩阵的 6 个浮点值

concatenate

public void concatenate(AffineTransform Tx)
以最常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，以提供由 Tx 映射到以前用户空间的新用户空间。更新 Cx 以执行组合变换。通过更新变换 Cx' 变换点 p 等效于首先通过 Tx 变换 p，然后通过初始变换 Cx 变换所得结果，如下所示：Cx'(p) = Cx(Tx(p))。在矩阵符号中，如果此变换 Cx 由矩阵 [this] 表示，Tx 由矩阵 [Tx] 表示，则此方法执行以下操作： 
                [this] = [this] x [Tx]

参数：
Tx - 要与此 AffineTransform 对象相连接的 AffineTransform 对象。
另请参见：
preConcatenate(java.awt.geom.AffineTransform)

preConcatenate

public void preConcatenate(AffineTransform Tx)
以不常用的方式将 AffineTransform Tx 连接到此 AffineTransform Cx，从而 Tx 相对于绝对像素空间（而非相对于现有用户空间）修改坐标变换。更新 Cx 以执行组合变换。通过更新变换 Cx' 变换点 p 等效于首先通过初始变换 Cx 变换 p，然后通过 Tx 变换所得结果，如下所示：Cx'(p) = Tx(Cx(p))。在矩阵符号中，如果此变换 Cx 由矩阵 [this] 表示并且 Tx 由矩阵 [Tx] 表示，则此方法执行以下操作： 
                [this] = [Tx] x [this]

参数：
Tx - 要与此 AffineTransform 对象相连接的 AffineTransform 对象。
另请参见：
concatenate(java.awt.geom.AffineTransform)

createInverse

public AffineTransform createInverse()
                              throws NoninvertibleTransformException
返回表示逆向变换的 AffineTransform 对象。此变换 Tx 的逆向变换 Tx' 将由 Tx 变换的坐标映射回其初始坐标。换句话说，Tx'(Tx(p)) = p = Tx(Tx'(p))。

如果此变换将所有坐标映射到点或线上，那么它将不能进行逆向变换，因为不依赖于目标点或线的坐标没有逆向映射。getDeterminant 方法可用于确定是否此变换不可逆，若不可逆，则调用 createInverse 方法时将抛出异常。

返回：
表示逆向变换的新 AffineTransform 对象。
抛出：
NoninvertibleTransformException - 如果矩阵不可逆。
另请参见：
getDeterminant()

transform

public Point2D transform(Point2D ptSrc,
                         Point2D ptDst)
变换指定的 ptSrc 并将结果存储在 ptDst 中。如果 ptDst 为 null，则分配一个新的 Point2D 对象，然后将变换的结果存储在此对象中。在任何一种情况下，为方便起见，都将返回包含变换点的 ptDst。如果 ptSrc 和 ptDst 是同一个对象，则用变换点正确地改写输入点。

参数：
ptSrc - 要变换的指定 Point2D
ptDst - 存储变换 ptSrc 结果的指定 Point2D
返回：
变换 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)
通过此变换变换 double 精度坐标数组。两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，这对结果的有效性都没有影响。此方法可确保在变换源坐标之前，它们不会被以前的操作改写。这些坐标从指示偏移量开始按照 [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)
通过此变换变换浮点坐标数组并将结果存储在 double 数组中。这些坐标从指定偏移量开始按照 [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)
通过此变换变换 double 精度坐标数组并将结果存储在 float 数组中。这些坐标从指定偏移量开始按照 [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
通过此变换逆向变换 double 精度坐标数组。两个坐标数组部分可以完全相同，也可以是同一数组的重叠部分，这对结果的有效性都没有影响。此方法可确保在变换源坐标之前，它们不会被以前的操作改写。这些坐标从指定偏移量开始按照 [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) ] [  x  ]   [ m00x + m01y ]
        [  y' ] = [  m10  m11 (m12) ] [  y  ] = [ m10x + m11y ]
        [ (1) ]   [  (0)  (0) ( 1 ) ] [ (1) ]   [     (1)     ]
如果 ptDst 为 null，则分配一个新的 Point2D 对象，然后将变换的结果存储在此对象中。在任何一种情况下，为方便起见，都将返回包含变换点的 ptDst。如果 ptSrc 和 ptDst 是同一个对象，则变换点将正确地改写输入点。

参数：
ptSrc - 要进行 delta 变换的距离向量
ptDst - 得到的变换距离向量
返回：
ptDst，它包含变换的结果。

deltaTransform

public void deltaTransform(double[] srcPts,
                           int srcOff,
                           double[] dstPts,
                           int dstOff,
                           int numPts)
通过此变换变换相对距离向量数组。使用以下方程式变换相对距离向量，不应用仿射变换矩阵的平移组件： 
        [  x' ]   [  m00  m01 (m02) ] [  x  ]   [ m00x + m01y ]
        [  y' ] = [  m10  m11 (m12) ] [  y  ] = [ 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 对象。

toString

public String toString()
返回表示此 Object 值的 String。

覆盖：
类 Object 中的 toString
返回：
表示此 Object 值的 String。

isIdentity

public boolean isIdentity()
如果此 AffineTransform 是恒等变换，则返回 true。

返回：
如果此 AffineTransform 是恒等变换，则返回 true；否则返回 false。

clone

public Object clone()
返回此 AffineTransform 对象的副本。

覆盖：
类 Object 中的 clone
返回：
作为此 AffineTransform 对象副本的 Object。
另请参见：
Cloneable

hashCode

public int hashCode()
返回此变换的哈希码。

覆盖：
类 Object 中的 hashCode
返回：
此变换的哈希码。
另请参见：
Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object obj)
如果此 AffineTransform 与指定的参数表示相同的仿射坐标变换，则返回 true。

覆盖：
类 Object 中的 equals
参数：
obj - 要测试与此 AffineTransform 相等性的 Object
返回：
如果 obj 等于此 AffineTransform 对象，则返回 true；否则返回 false。
另请参见：
Object.hashCode(), Hashtable
概述  软件包   类  使用  树  已过时  索引  帮助 
JavaTM 2 Platform
Standard Ed. 5.0
 上一个类   下一个类 框架    无框架    
摘要： 嵌套 | 字段 | 构造方法 | 方法 详细信息： 字段 | 构造方法 | 方法
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。