AffineTransform

目录搜索

文字

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

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 坐标的线性映射，保留了线的“直线性”和“平行性”。可以使用一系列平移 (translation)、缩放 (scale)、翻转 (flip)、旋转 (rotation) 和错切 (shear) 来构造仿射变换。

这样的坐标变换可以使用一个 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         ]

处理 90 度旋转

在 AffineTransform 类的 rotate 方法的一些变量中，双精度参数指定了以弧度表示的旋转角度。这些方法为近似 90 度（包括倍数诸如 180、270 和 360 度）的旋转提供特殊的处理，以便更有效地处理象限旋转这类常见情形。这种特殊处理可以导致旋转角度非常接近于 90 度的倍数，从而可以将其视为正好是 90 度的倍数。对于 90 度的小倍数，被视为象限旋转的角度范围大约是 0.00000121 度宽。这一节解释为什么需要特别小心以及如何实现它。

因为 90 度用弧度表示是 PI/2，而 PI 是无限不循环小数（因此是无理数），所以它不能像用弧度表示的精确双精度值那样准确地表示 90 度的倍数。因此，理论上不可以使用 PI 来描述象限旋转（90、180、270 或 360 度）。双精度浮点值可以非常接近 PI/2 的非零倍数，但是不够接近到正弦或余弦能精确到 0.0、1.0 或 -1.0。只有在 Math.sin(0.0) 的情况下，Math.sin() 和 Math.cos() 实现才相应地返回 0.0。但是，对于接近每个 90 度倍数的某些范围内的数，相样的实现却返回 1.0 和 -1.0，因为正确答案是如此接近 1.0 或 -1.0，以至于双精度的有效位数无法像表示接近 0.0 的数那样精确地表示差值。

这些问题归结为：如果在执行这些基于弧度的旋转操作期间，使用 Math.sin() 和 Math.cos() 方法直接生成用于矩阵修改的值，那么严格来说，得到的变换不能归类为象限旋转（即使对于 rotate(Math.PI/2.0) 这样的简单情况也是如此），因为执行正弦和余弦操作而得到的非 0.0 值将造成矩阵的细微变化。如果这些变换不能归类为象限旋转，那么试图根据变换类型优化下一步操作的后续代码会被移交到它最通用的实现中。

因为象限旋转相当常见，所以在对变换应用旋转和对坐标应用所得变换时，此类应该快速合理地处理这些情况。为了达到最佳处理，以弧度为单位测量旋转角度的方法试图检测象限旋转的角度并以这种方式处理它们。因此，如果 Math.sin(theta) 或 Math.cos(theta) 正好返回 1.0 或 -1.0，那么这些方法会将角度 theta 视为象限旋转。实际经验证明，此特性可用于 Math.PI/2.0 的小倍数大约 0.0000000211 弧度（0.00000121 度）的范围。

从以下版本开始：: 1.2
另请参见：: 序列化表格

字段摘要
`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()` 构造一个表示恒等变换的新 `AffineTransform`。
`AffineTransform(AffineTransform Tx)` 构造一个新 `AffineTransform`，让它作为指定 `AffineTransform` 对象的副本。
`AffineTransform(double[] flatmatrix)` 根据双精度值数组构造一个新 `AffineTransform`，该数组要么表示 3x3 变换矩阵的 4 个非平移条目，要么表示它的 6 个可指定条目。
`AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12)` 根据表示 3x3 变换矩阵 6 个可指定条目的 6 个双精度值构造一个新 `AffineTransform`。
`AffineTransform(float[] flatmatrix)` 根据一个浮点值数组构造一个新 `AffineTransform`，该数组要么表示 3x3 变换矩阵的 4 个非平移条目，要么表示 3x3 变换矩阵的 6 个可指定条目。
`AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)` 根据表示 3x3 变换矩阵 6 个可指定条目的 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 个可指定值，并将其置于双精度值的数组中。
`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()` 返回 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)` 通过此变换来逆向变换双精度坐标数组。
`Point2D`	`inverseTransform(Point2D ptSrc, Point2D ptDst)` 逆向变换指定的 `ptSrc` 并将结果存储在 `ptDst` 中。
`void`	`invert()` 将此变换设置为它自身的逆变换。
`boolean`	`isIdentity()` 如果此 `AffineTransform` 是恒等变换，则返回 `true`。
`void`	`preConcatenate(AffineTransform Tx)` 以不常用的方式将 `AffineTransform` `Tx` 连接到此 `AffineTransform` Cx，从而 `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()` 返回表示此 `Object` 值的 `String`。
`void`	`transform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` 通过此变换来变换双精度坐标数组。
`void`	`transform(double[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)` 通过此变换来变换双精度坐标数组，并将结果存储在 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，要么是此变换执行的不同坐标转换的适当标志位的组合。

从以下版本开始：: 1.2
另请参见：: 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 移动坐标，不改变向量的长度和角度。

从以下版本开始：: 1.2
另请参见：: 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 标志互斥。

从以下版本开始：: 1.2
另请参见：: 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 标志互斥。

从以下版本开始：: 1.2
另请参见：: 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

此常量是所有缩放标志位的位掩码。

从以下版本开始：: 1.2
另请参见：: TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, 常量字段值

TYPE_FLIP

public static final int TYPE_FLIP

此标志位指示此对象定义的变换除了执行其他标志位指示的转换外，还执行关于某个坐标轴的镜像翻转操作，此操作将通常的右旋坐标系更改为左旋坐标系。右旋坐标系按逆时针方向旋转 X 正半轴能覆盖 Y 正半轴，类似于凝视右手拇指末端时其余手指弯曲的方向。左旋坐标系按顺时针方向旋转 X 正半轴能覆盖 Y 正半轴，类似于左手手指弯曲的方向。不存在确定初始反转或镜像变换角度的数学方式，因为给定适当的调整旋转后，翻转的所有角度都相同。

从以下版本开始：: 1.2
另请参见：: 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 标志互斥。

从以下版本开始：: 1.2
另请参见：: 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 标志互斥。

从以下版本开始：: 1.2
另请参见：: 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

此常量是所有旋转标志位的位掩码。

从以下版本开始：: 1.2
另请参见：: TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, 常量字段值

TYPE_GENERAL_TRANSFORM

public static final int TYPE_GENERAL_TRANSFORM

此常量指示此对象定义的变换执行输入坐标的任意转换操作。如果此变换能归类为上述任意一种常量，则类型要么是常量 TYPE_IDENTITY，要么是此变换所执行的各种坐标转换的适当标志位。

从以下版本开始：: 1.2
另请参见：: TYPE_IDENTITY, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_GENERAL_SCALE, TYPE_FLIP, TYPE_QUADRANT_ROTATION, TYPE_GENERAL_ROTATION, getType(), 常量字段值

构造方法详细信息

public AffineTransform()

构造一个表示恒等变换的新 AffineTransform。

从以下版本开始：: 1.2

AffineTransform

public AffineTransform(AffineTransform Tx)

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

参数：: Tx - 要复制的 AffineTransform 对象
从以下版本开始：: 1.2

AffineTransform

public AffineTransform(float m00,
                       float m10,
                       float m01,
                       float m11,
                       float m02,
                       float m12)

根据表示 3x3 变换矩阵 6 个可指定条目的 6 个浮点值构造一个新 AffineTransform。

参数：: m00 - 3x3 矩阵缩放元素的 X 坐标; m10 - 3x3 矩阵剪切元素的 Y 坐标; m01 - 3x3 矩阵剪切元素的 X 坐标; m11 - 3x3 矩阵缩放元素的 Y 坐标; m02 - 3x3 矩阵平移元素的 X 坐标; m12 - 3x3 矩阵平移元素的 Y 坐标

从以下版本开始：

1.2

AffineTransform

public AffineTransform(float[] flatmatrix)

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

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

AffineTransform

public AffineTransform(double m00,
                       double m10,
                       double m01,
                       double m11,
                       double m02,
                       double m12)

根据表示 3x3 变换矩阵 6 个可指定条目的 6 个双精度值构造一个新 AffineTransform。

参数：: m00 - 3x3 矩阵缩放元素的 X 坐标; m10 - 3x3 矩阵剪切元素的 Y 坐标; m01 - 3x3 矩阵剪切元素的 X 坐标; m11 - 3x3 矩阵缩放元素的 Y 坐标; m02 - 3x3 矩阵平移元素的 X 坐标; m12 - 3x3 矩阵平移元素的 Y 坐标

从以下版本开始：

1.2

AffineTransform

public AffineTransform(double[] flatmatrix)

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

参数：: flatmatrix - double 数组，包含要在新 AffineTransform 对象中设置的值。假定数组的长度至少为 4。如果数组的长度小于 6，则仅采用前 4 个值。如果数组的长度大于 6，则采用前 6 个值。
从以下版本开始：: 1.2

方法详细信息

getTranslateInstance

public static AffineTransform getTranslateInstance(double tx,
                                                   double ty)

返回表示平移变换的变换。表示返回变换的矩阵是：

                [   1    0    tx  ]
                [   0    1    ty  ]
                [   0    0    1   ]

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

返回：

表示平移变换的 AffineTransform 对象，该对象是使用指定向量创建的。

从以下版本开始：

1.2

getRotateInstance

public static AffineTransform getRotateInstance(double theta)

返回表示旋转变换的变换。表示返回变换的矩阵是：

                [   cos(theta)    -sin(theta)    0   ]
                [   sin(theta)     cos(theta)    0   ]
                [       0              0         1   ]

用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度
返回：: 使用指定旋转角度创建的、作为旋转变换的 AffineTransform 对象。
从以下版本开始：: 1.2

getRotateInstance

public static AffineTransform getRotateInstance(double theta,
                                                double anchorx,
                                                double anchory)

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

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

AffineTransform Tx = new AffineTransform();
Tx.translate(anchorx, anchory);    // S3:final translation
Tx.rotate(theta);                     // S2:rotate around anchor
Tx.translate(-anchorx, -anchory);  // 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 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

返回：

按指定的旋转角度绕指定点旋转坐标的 AffineTransform 对象。

从以下版本开始：

1.2

getRotateInstance

public static AffineTransform getRotateInstance(double vecx,
                                                double vecy)

返回根据旋转向量旋转坐标的变换。所有坐标以相同的量绕原点旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则返回一个恒等变换。此操作等效于调用：

AffineTransform.getRotateInstance(Math.atan2(vecy, vecx));

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标

返回：

根据指定旋转向量旋转坐标的 AffineTransform 对象。

从以下版本开始：

1.6

getRotateInstance

public static AffineTransform getRotateInstance(double vecx,
                                                double vecy,
                                                double anchorx,
                                                double anchory)

返回根据旋转向量绕锚点坐标旋转坐标的变换。所有坐标按相同的量绕指定的锚坐标旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则返回一个恒等变换。此操作等效于调用：

AffineTransform.getRotateInstance(Math.atan2(vecy, vecx),
anchorx, anchory);

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

返回：

根据指定旋转向量绕指定点旋转坐标的 AffineTransform 对象。

从以下版本开始：

1.6

getQuadrantRotateInstance

public static AffineTransform getQuadrantRotateInstance(int numquadrants)

返回按指定象限数旋转坐标的变换。此操作等效于调用：

AffineTransform.getRotateInstance(numquadrants * Math.PI / 2.0);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数
返回：: 按指定象限数旋转坐标的 AffineTransform 对象。
从以下版本开始：: 1.6

getQuadrantRotateInstance

public static AffineTransform getQuadrantRotateInstance(int numquadrants,
                                                        double anchorx,
                                                        double anchory)

返回按指定象限数绕指定锚点旋转坐标的变换。此操作等效于调用：

AffineTransform.getRotateInstance(numquadrants * Math.PI / 2.0,
anchorx, anchory);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

返回：

按指定的象限数绕指定的锚点旋转坐标的 AffineTransform 对象。

从以下版本开始：

1.6

getScaleInstance

public static AffineTransform getScaleInstance(double sx,
                                               double sy)

返回表示缩放变换的变换。表示返回变换的矩阵是：

                [   sx   0    0   ]
                [   0    sy   0   ]
                [   0    0    1   ]

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

返回：

按指定因子缩放坐标的 AffineTransform 对象。

从以下版本开始：

1.2

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 对象。

从以下版本开始：

1.2

getType

public int getType()

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

返回：: 应用于此变换的所有指示标志的 OR 组合
从以下版本开始：: 1.2
另请参见：: 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   |

返回：: 用于变换坐标的矩阵的决定因子。
从以下版本开始：: 1.2
另请参见：: 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 个 double 值的数组，在这种情况下，仅检索表示数组中非变换部分的前四个元素，并将值以 { m00 m10 m01 m11 } 的形式存储到数组中。

参数：: flatmatrix - 用于存储返回值的 double 数组。
从以下版本开始：: 1.2
另请参见：: getScaleX(), getScaleY(), getShearX(), getShearY(), getTranslateX(), getTranslateY()

getScaleX

public double getScaleX()

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

返回：: 作为仿射变换矩阵缩放元素的 X 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: getMatrix(double[])

getScaleY

public double getScaleY()

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

返回：: 作为仿射变换矩阵缩放元素的 Y 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: getMatrix(double[])

getShearX

public double getShearX()

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

返回：: 作为仿射变换矩阵错切元素的 X 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: getMatrix(double[])

getShearY

public double getShearY()

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

返回：: 作为仿射变换矩阵错切元素的 Y 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: getMatrix(double[])

getTranslateX

public double getTranslateX()

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

返回：: 作为仿射变换矩阵平移元素的 X 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: getMatrix(double[])

getTranslateY

public double getTranslateY()

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

返回：: 作为仿射变换矩阵平移元素的 Y 坐标的 double 值。
从以下版本开始：: 1.2
另请参见：: 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 轴方向上平移的距离

从以下版本开始：

1.2

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 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度
从以下版本开始：: 1.2

rotate

public void rotate(double theta,
                   double anchorx,
                   double anchory)

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

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

translate(anchorx, anchory);      // S3:final translation
rotate(theta);                    // S2:rotate around anchor
translate(-anchorx, -anchory);    // S1:translate anchor to origin

用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.2

rotate

public void rotate(double vecx,
                   double vecy)

连接此变换与根据旋转向量旋转坐标的变换。所有坐标按相同的量绕原点旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则没有附加的旋转添加到此变换。此操作等效于调用：

rotate(Math.atan2(vecy, vecx));

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标

从以下版本开始：

1.6

rotate

public void rotate(double vecx,
                   double vecy,
                   double anchorx,
                   double anchory)

连接此变换与根据旋转向量绕锚点旋转坐标的变换。所有坐标按相同的量绕指定的锚坐标旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则不以任何方式修改此变换。此方法等效于调用：

rotate(Math.atan2(vecy, vecx), anchorx, anchory);

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.6

quadrantRotate

public void quadrantRotate(int numquadrants)

连接此变换与按照指定象限数旋转坐标的变换。此方法等效于调用：

rotate(numquadrants * Math.PI / 2.0);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数
从以下版本开始：: 1.6

quadrantRotate

public void quadrantRotate(int numquadrants,
                           double anchorx,
                           double anchory)

连接此变换与按指定象限数绕指定锚点旋转坐标的变换。此方法等效于调用：

rotate(numquadrants * Math.PI / 2.0, anchorx, anchory);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.6

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 轴方向缩放的因子

从以下版本开始：

1.2

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 坐标的因子一样

从以下版本开始：

1.2

setToIdentity

public void setToIdentity()

将此变换重置为恒等变换。

从以下版本开始：: 1.2

setToTranslation

public void setToTranslation(double tx,
                             double ty)

将此变换设置为平移变换。表示此变换的矩阵将变成：

                [   1    0    tx  ]
                [   0    1    ty  ]
                [   0    0    1   ]

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

从以下版本开始：

1.2

setToRotation

public void setToRotation(double theta)

将此变换设置为旋转变换。表示此变换的矩阵将变成：

                [   cos(theta)    -sin(theta)    0   ]
                [   sin(theta)     cos(theta)    0   ]
                [       0              0         1   ]

用正角度 theta 进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度
从以下版本开始：: 1.2

setToRotation

public void setToRotation(double theta,
                          double anchorx,
                          double anchory)

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

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

setToTranslation(anchorx, anchory); // S3:final translation
rotate(theta);                      // S2:rotate around anchor
translate(-anchorx, -anchory);      // 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 正半轴旋转。还要注意上文处理 90 度旋转的讨论。

参数：: theta - 用弧度测量的旋转角度; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.2

setToRotation

public void setToRotation(double vecx,
                          double vecy)

将此变换设置为根据旋转向量旋转坐标的旋转变换。所有坐标按相同的量绕原点旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则将该变换设置为恒等变换。此操作等效于调用：

setToRotation(Math.atan2(vecy, vecx));

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标

从以下版本开始：

1.6

setToRotation

public void setToRotation(double vecx,
                          double vecy,
                          double anchorx,
                          double anchory)

将此变换设置为根据旋转向量绕锚点旋转坐标的旋转变换。所有坐标按相同的量绕指定的锚坐标旋转。旋转量使沿原 X 轴正半轴的坐标随后将与从坐标原点指向指定向量坐标的向量对齐。如果 vecx 和 vecy 都是 0.0，则将该变换设置为恒等变换。此操作等效于调用：

setToTranslation(Math.atan2(vecy, vecx), anchorx, anchory);

参数：: vecx - 旋转向量的 X 坐标; vecy - 旋转向量的 Y 坐标; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.6

setToQuadrantRotation

public void setToQuadrantRotation(int numquadrants)

将此变换设置为按指定象限数旋转坐标的旋转变换。此操作等效于调用：

setToRotation(numquadrants * Math.PI / 2.0);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数
从以下版本开始：: 1.6

setToQuadrantRotation

public void setToQuadrantRotation(int numquadrants,
                                  double anchorx,
                                  double anchory)

将此变换设置为按指定象限数绕指定锚点旋转坐标的平移旋转变换。此操作等效于调用：

setToRotation(numquadrants * Math.PI / 2.0, anchorx, anchory);

用正象限数进行的旋转将 X 正半轴上的点向 Y 正半轴旋转。

参数：: numquadrants - 要旋转的 90 度弧数; anchorx - 旋转锚点的 X 坐标; anchory - 旋转锚点的 Y 坐标

从以下版本开始：

1.6

setToScale

public void setToScale(double sx,
                       double sy)

将此变换设置为缩放变换。表示此变换的矩阵将变成：

                [   sx   0    0   ]
                [   0    sy   0   ]
                [   0    0    1   ]

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

从以下版本开始：

1.2

setToShear

public void setToShear(double shx,
                       double shy)

将此变换设置为错切变换。表示此变换的矩阵将变成：

                [   1   shx   0   ]
                [  shy   1    0   ]
                [   0    0    1   ]

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

从以下版本开始：

1.2

setTransform

public void setTransform(AffineTransform Tx)

将此变换设置为指定 AffineTransform 对象中变换的副本。

参数：: Tx - 从中复制变换的 AffineTransform 对象
从以下版本开始：: 1.2

setTransform

public void setTransform(double m00,
                         double m10,
                         double m01,
                         double m11,
                         double m02,
                         double m12)

将此变换设置为 6 个双精度值指定的矩阵。

参数：: m00 - 3x3 矩阵缩放元素的 X 坐标; m10 - 3x3 矩阵错切元素的 Y 坐标; m01 - 3x3 矩阵错切元素的 X 坐标; m11 - 3x3 矩阵缩放元素的 Y 坐标; m02 - 3x3 矩阵平移元素的 X 坐标; m12 - 3x3 矩阵平移元素的 Y 坐标

从以下版本开始：

1.2

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 对象。
从以下版本开始：: 1.2
另请参见：: 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 对象。
从以下版本开始：: 1.2
另请参见：: 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 - 如果矩阵不可逆。
从以下版本开始：: 1.2
另请参见：: getDeterminant()

invert

public void invert()
            throws NoninvertibleTransformException

将此变换设置为它自身的逆变换。此变换 Tx 的逆向变换 Tx' 将由 Tx 变换的坐标映射回其初始坐标。换句话说，Tx'(Tx(p)) = p = Tx(Tx'(p))。

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

抛出：: NoninvertibleTransformException - 如果矩阵不可逆。
从以下版本开始：: 1.6
另请参见：: 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。

从以下版本开始：

1.2

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 - 要变换的点对象数

从以下版本开始：

1.2

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 - 要变换的点数

从以下版本开始：

1.2

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 - 要变换的点对象数

从以下版本开始：

1.2

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 - 要变换的点数

从以下版本开始：

1.2

transform

public void transform(double[] srcPts,
                      int srcOff,
                      float[] dstPts,
                      int dstOff,
                      int numPts)

通过此变换来变换双精度坐标数组，并将结果存储在 float 数组中。这些坐标从指定偏移量开始按照 [x0, y0, x1, y1, ..., xn, yn] 的顺序存储在数组中。

参数：: srcPts - 包含源点坐标的数组。每个点都存储为一对 x, y 坐标。; dstPts - 从其中返回变换点坐标的数组。每个点都存储为一对 x, y 坐标。; srcOff - 源数组中要变换的第一个点的偏移量; dstOff - 目标数组中存储的第一个变换点位置的偏移量; numPts - 要变换的点对象数

从以下版本开始：

1.2

inverseTransform

public Point2D inverseTransform(Point2D ptSrc,
                                Point2D ptDst)
                         throws NoninvertibleTransformException

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

参数：: ptSrc - 要逆向变换的点; ptDst - 得到的变换点

返回：

ptDst，它包含逆向变换的结果。

抛出：

NoninvertibleTransformException - 如果矩阵不可逆。

从以下版本开始：

1.2

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 - 如果矩阵不可逆。

从以下版本开始：

1.2

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，它包含变换的结果。

从以下版本开始：

1.2

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 - 要变换的向量坐标对的数量

从以下版本开始：

1.2

createTransformedShape

public Shape createTransformedShape(Shape pSrc)

返回新的 Shape 对象，它在通过此变换之后，由指定 Shape 的几何形状定义。

参数：: pSrc - 要被此变换变换的指定 Shape 对象。
返回：: 由变换的 Shape 的几何形状所定义的新 Shape 对象；如果 pSrc 为 null，则返回 null。
从以下版本开始：: 1.2

toString

public String toString()

返回表示此 Object 值的 String。

覆盖：: 类 Object 中的 toString

返回：: 表示此 Object 值的 String。
从以下版本开始：: 1.2

isIdentity

public boolean isIdentity()

如果此 AffineTransform 是恒等变换，则返回 true。

返回：: 如果此 AffineTransform 是恒等变换，则返回 true；否则返回 false。
从以下版本开始：: 1.2

clone

public Object clone()

返回此 AffineTransform 对象的副本。

覆盖：: 类 Object 中的 clone

返回：: 作为此 AffineTransform 对象副本的 Object。
从以下版本开始：: 1.2
另请参见：: Cloneable

hashCode

public int hashCode()

返回此变换的哈希码。

覆盖：: 类 Object 中的 hashCode

返回：: 此变换的哈希码。
从以下版本开始：: 1.2
另请参见：: Object.equals(java.lang.Object), Hashtable

equals

public boolean equals(Object obj)

如果此 AffineTransform 表示与指定参数相同的仿射坐标变换，则返回 true。

覆盖：: 类 Object 中的 equals

参数：: obj - 要测试与此 AffineTransform 相等性的 Object
返回：: 如果 obj 等于此 AffineTransform 对象，则返回 true；否则返回 false。
从以下版本开始：: 1.2
另请参见：: Object.hashCode(), Hashtable

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

java.awt.geom 类 AffineTransform

处理 90 度旋转

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

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

isIdentity

clone

hashCode

equals

java.awt.geom
类 AffineTransform