模块  java.desktop
软件包  java.awt.geom

Class AffineTransform

  • 实现的所有接口
    SerializableCloneable

    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         ] 

    Handling 90-Degree Rotations

    AffineTransform类中的rotate方法的某些变体中,双精度参数指定以弧度表示的旋转角度。 这些方法对大约90度的旋转(包括诸如180度,270度和360度的倍数)具有特殊处理,因此可以更有效地处理象限旋转的常见情况。 这种特殊处理可以使角度非常接近90度的倍数,就好像它们是90度的精确倍数一样。 对于90度的小倍数,作为象限旋转处理的角度范围大约为0.00000121度。 本节解释了为什么需要这种特殊护理以及如何实施。

    由于90度以弧度表示为PI/2 ,并且由于PI是超越(因此是无理的)数字,因此不可能精确地表示90度的倍数作为以弧度测量的精确双精度值。 因此,理论上不可能使用这些值来描述象限旋转(90,180,270或360度)。 双精度浮点值可以非常接近PI/2的非零倍数, PI/2不足以使正弦或余弦精确到PI/2或-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,则这些方法将角度θ视为象限旋转。 根据经验,此属性适用于大约0.0000000211弧度(或0.00000121度)的范围,大约为Math.PI/2.0小倍数。

    从以下版本开始:
    1.2
    另请参见:
    Serialized Form
    • 字段汇总

      字段  
      变量和类型 字段 描述
      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​(double[] flatmatrix)
      从一组双精度值构造一个新的 AffineTransform ,表示4个非翻译条目或3x3变换矩阵的6个可指定条目。
      AffineTransform​(double m00, double m10, double m01, double m11, double m02, double m12)
      从6个双精度值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
      AffineTransform​(float[] flatmatrix)
      从浮点值数组构造新的 AffineTransform ,表示4个非转换条目或3x3转换矩阵的6个可指定条目。
      AffineTransform​(float m00, float m10, float m01, float m11, float m02, float m12)
      从6个浮点值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
      AffineTransform​(AffineTransform Tx)
      构造一个新的 AffineTransform ,它是指定的 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指定的相对距离向量, 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元素。
      double getScaleY()
      返回3x3仿射变换矩阵的 m11元素。
      static AffineTransform getShearInstance​(double shx, double shy)
      返回表示剪切变换的变换。
      double getShearX()
      返回3x3仿射变换矩阵的X坐标剪切元素(m01)。
      double getShearY()
      返回3x3仿射变换矩阵的Y坐标剪切元素(m10)。
      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)
      Inverse通过此变换转换双精度坐标数组。
      Point2D inverseTransform​(Point2D ptSrc, Point2D ptDst)
      反转换指定的 ptSrc并将结果存储在 ptDst
      void invert()
      将此变换设置为自身的反转。
      boolean isIdentity()
      如果此 AffineTransform是标识转换,则返回 true
      void preConcatenate​(AffineTransform Tx)
      串接的 AffineTransform TxAffineTransform 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()
      将此变换重置为Identity变换。
      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​(double m00, double m10, double m01, double m11, double m02, double m12)
      将此变换设置为由6个双精度值指定的矩阵。
      void setTransform​(AffineTransform Tx)
      将此变换设置为指定的 AffineTransform对象中的变换副本。
      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)
      将此转换与转换转换连接在一起。
    • 构造方法详细信息

      • AffineTransform

        public AffineTransform()
        构造一个表示Identity转换的新 AffineTransform
        从以下版本开始:
        1.2
      • AffineTransform

        public AffineTransform​(AffineTransform Tx)
        构造一个新的 AffineTransform ,它是指定的 AffineTransform对象的副本。
        参数
        Tx - 要复制的 AffineTransform对象
        从以下版本开始:
        1.2
      • AffineTransform

        @ConstructorProperties({"scaleX","shearY","shearX","scaleY","translateX","translateY"})
        public AffineTransform​(float m00,
                               float m10,
                               float m01,
                               float m11,
                               float m02,
                               float m12)
        从6个浮点值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
        参数
        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 ,表示4个非转换条目或3x3转换矩阵的6个可指定条目。 从阵列中检索值为{m00 m10 m01 m11 [m02 m12]}。
        参数
        flatmatrix - 包含要在新AffineTransform对象中设置的值的float数组。 假设数组的长度至少为4.如果数组的长度小于6,则仅获取前4个值。 如果数组的长度大于6,则采用前6个值。
        从以下版本开始:
        1.2
      • AffineTransform

        public AffineTransform​(double m00,
                               double m10,
                               double m01,
                               double m11,
                               double m02,
                               double m12)
        从6个双精度值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
        参数
        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 ,表示4个非转换条目或3x3转换矩阵的6个可指定条目。 从阵列中检索值为{m00 m10 m01 m11 [m02 m12]}。
        参数
        flatmatrix - 包含要在新AffineTransform对象中设置的值的double数组。 假设数组的长度至少为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   ] 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面的Handling 90-Degree Rotations的讨论。
        参数
        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        ] 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面对Handling 90-Degree Rotations的讨论。
        参数
        theta - 以弧度为单位测量的旋转角度
        anchorx - 旋转锚点的X坐标
        anchory - 旋转锚点的Y坐标
        结果
        一个 AffineTransform对象,它按指定的旋转角度旋转指定点周围的坐标。
        从以下版本开始:
        1.2
      • getRotateInstance

        public static AffineTransform getRotateInstance​(double vecx,
                                                        double vecy)
        返回根据旋转矢量旋转坐标的变换。 所有坐标围绕原点旋转相同的量。 旋转量使得沿着前正X轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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_IDENTITYTYPE_TRANSLATIONTYPE_UNIFORM_SCALETYPE_GENERAL_SCALETYPE_QUADRANT_ROTATIONTYPE_GENERAL_ROTATIONTYPE_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个双精度数组,在这种情况下,只检索表示数组非变换部分的前四个元素,并将值存储到数组中{m00 m10 m01 m11}
        参数
        flatmatrix - 用于存储返回值的double数组。
        从以下版本开始:
        1.2
        另请参见:
        getScaleX()getScaleY()getShearX()getShearY()getTranslateX()getTranslateY()
      • getScaleX

        public double getScaleX()
        返回3x3仿射变换矩阵的m00元素。 此矩阵因子确定输入X坐标将如何影响输出X坐标,并且是变换比例的一个元素。 要测量此变换拉伸或收缩X坐标的全部量,请使用以下代码:
          Point2D p = new Point2D.Double(1, 0);
             p = tx.deltaTransform(p, p);
             double scaleX = p.distance(0, 0); 
        结果
        m00值是3x3仿射变换矩阵的 m00元素。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getScaleY

        public double getScaleY()
        返回3x3仿射变换矩阵的m11元素。 此矩阵因子确定输入Y坐标将如何影响输出Y坐标,并且是变换比例的一个元素。 要测量此变换拉伸或收缩Y坐标的全部量,请使用以下代码:
          Point2D p = new Point2D.Double(0, 1);
             p = tx.deltaTransform(p, p);
             double scaleY = p.distance(0, 0); 
        结果
        m11值是3x3仿射变换矩阵的 m11元素。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getShearX

        public double getShearX()
        返回3x3仿射变换矩阵的X坐标剪切元素(m01)。
        结果
        一个double值,它是仿射变换矩阵的剪切元素的X坐标。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getShearY

        public double getShearY()
        返回3x3仿射变换矩阵的Y坐标剪切元素(m10)。
        结果
        一个double值,它是仿射变换矩阵的剪切元素的Y坐标。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getTranslateX

        public double getTranslateX()
        返回3x3仿射变换矩阵的平移元素(m02)的X坐标。
        结果
        double值,它是仿射变换矩阵的平移元素的X坐标。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getTranslateY

        public double getTranslateY()
        返回3x3仿射变换矩阵的平移元素(m12)的Y坐标。
        结果
        double值,它是仿射变换矩阵的平移元素的Y坐标。
        从以下版本开始:
        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   ] 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面的Handling 90-Degree Rotations的讨论。
        参数
        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 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面对Handling 90-Degree Rotations的讨论。
        参数
        theta - 以弧度为单位测量的旋转角度
        anchorx - 旋转锚点的X坐标
        anchory - 旋转锚点的Y坐标
        从以下版本开始:
        1.2
      • rotate

        public void rotate​(double vecx,
                           double vecy)
        将此变换与根据旋转矢量旋转坐标的变换连接。 所有坐标围绕原点旋转相同的量。 旋转量使得沿着前正X轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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()
        将此变换重置为Identity变换。
        从以下版本开始:
        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   ] 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面的Handling 90-Degree Rotations的讨论。
        参数
        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        ] 
        通过正角度θ旋转使正X轴上的点朝向正Y轴旋转。 另请注意上面的Handling 90-Degree Rotations的讨论。
        参数
        theta - 以弧度为单位测量的旋转角度
        anchorx - 旋转锚点的X坐标
        anchory - 旋转锚点的Y坐标
        从以下版本开始:
        1.2
      • setToRotation

        public void setToRotation​(double vecx,
                                  double vecy)
        将此变换设置为旋转变换,该旋转变换根据旋转矢量旋转坐标。 所有坐标围绕原点旋转相同的量。 旋转量使得沿着前正X轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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轴的坐标随后将与从原点指向指定矢量坐标的矢量对齐。 如果vecxvecy均为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相当于首先将p变换Tx ,然后将结果变换为原始变换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 TxAffineTransform 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 如果ptDstnull ,则分配新的Point2D对象,然后将转换的结果存储在此对象中。 在任何一种情况下,为方便起见,返回包含转换点的ptDst 如果ptSrcptDst是同一个对象,则使用转换后的点正确覆盖输入点。
        参数
        ptSrc - 要转换的指定 Point2D
        ptDst - 存储转换结果的指定 Point2D ptSrc
        结果
        转换 ptSrc并将结果存储在 ptDst之后的 ptDst
        从以下版本开始:
        1.2
      • transform

        public void transform​(Point2D[] ptSrc,
                              int srcOff,
                              Point2D[] ptDst,
                              int dstOff,
                              int numPts)
        通过此变换转换点对象数组。 如果ptDst数组的任何元素为nullPoint2D在存储转换结果之前分配新的Point2D对象并将其存储到该元素中。

        请注意,此方法不会采取任何预防措施来避免将结果存储到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)
        通过此变换转换浮点坐标数组,并将结果存储到双精度数组中。 坐标存储在数组中,从指定的偏移量开始,顺序为[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)
        通过此变换转换双精度坐标数组,并将结果存储到浮点数组中。 坐标存储在数组中,从指定的偏移量开始,顺序为[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 如果ptDstnull ,则分配新的Point2D对象,然后将转换的结果存储在此对象中。 在任何一种情况下,为方便起见,都会返回包含转换点的ptDst 如果ptSrcptDst是同一个对象,则使用转换后的点正确覆盖输入点。
        参数
        ptSrc - 要进行逆变换的点
        ptDst - 生成的转换点
        结果
        ptDst ,其中包含逆变换的结果。
        异常
        NoninvertibleTransformException - 如果矩阵不能反转。
        从以下版本开始:
        1.2
      • inverseTransform

        public void inverseTransform​(double[] srcPts,
                                     int srcOff,
                                     double[] dstPts,
                                     int dstOff,
                                     int numPts)
                              throws NoninvertibleTransformException
        Inverse通过此变换转换双精度坐标数组。 两个坐标数组部分可以完全相同,也可以是相同数组的重叠部分,而不会影响结果的有效性。 此方法可确保在转换之前,之前的操作不会覆盖任何源坐标。 坐标存储在数组中,从指定的偏移量开始,顺序为[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指定的相对距离向量, ptSrc结果存储在ptDst 使用以下等式转换相对距离矢量而不应用仿射变换矩阵的平移分量:
          [  x' ]   [  m00  m01 (m02) ] [  x  ]   [ m00x + m01y ]
          [  y' ] = [  m10  m11 (m12) ] [  y  ] = [ m10x + m11y ]
          [ (1) ]   [  (0)  (0) ( 1 ) ] [ (1) ]   [     (1)     ] 
        如果ptDstnull ,则分配新的Point2D对象,然后将转换的结果存储在此对象中。 在任何一种情况下,为方便起见,都会返回包含转换点的ptDst 如果ptSrcptDst是同一个对象,则使用转换后的点正确覆盖输入点。
        参数
        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()
        返回String ,表示此Object的值。
        重写:
        toString ,类 Object
        结果
        a String表示这个 Object的值。
        从以下版本开始:
        1.2
      • isIdentity

        public boolean isIdentity()
        如果此 AffineTransform是标识转换,则返回 true
        结果
        true AffineTransform是身份转换; 否则为false
        从以下版本开始:
        1.2
      • clone

        public Object clone()
        返回此 AffineTransform对象的副本。
        重写:
        cloneObject
        结果
        Object是此 AffineTransform对象的副本。
        从以下版本开始:
        1.2
        另请参见:
        Cloneable
      • equals

        public boolean equals​(Object obj)
        如果此 AffineTransform表示与指定参数相同的仿射坐标变换,则返回 true
        重写:
        equalsObject
        参数
        obj -将 Object要测试其相等与此 AffineTransform
        结果
        true如果obj于此AffineTransform对象; 否则为false
        从以下版本开始:
        1.2
        另请参见:
        Object.hashCode()HashMap