Module  java.desktop
软件包  java.awt.geom

Class AffineTransform

  • All Implemented Interfaces:
    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或-1.0。 的实现Math.sin()Math.cos()相应从不为比其它任何情况下返回0.0 Math.sin(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,则这些方法将角度θ视为象限旋转。 作为经验法则,该属性适用于Math.PI/2.0小倍数附近约0.0000000211弧度(或0.00000121度)的Math.PI/2.0

    从以下版本开始:
    1.2
    另请参见:
    Serialized Form
    • Field Summary

      Fields  
      Modifier and Type Field 描述
      static int TYPE_FLIP
      该标志位指示由该对象定义的变换除了由其他标志位指示的转换之外还执行关于某个轴的镜像翻转,该轴将常规右手坐标系改变为左手系统。
      static int TYPE_GENERAL_ROTATION
      该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行任意角度的旋转。
      static int TYPE_GENERAL_SCALE
      该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行一般尺度。
      static int TYPE_GENERAL_TRANSFORM
      该常数表示由该对象定义的变换执行输入坐标的任意转换。
      static int TYPE_IDENTITY
      该常数表示由该对象定义的变换是一个身份变换。
      static int TYPE_MASK_ROTATION
      该常数是任何旋转标志位的位掩码。
      static int TYPE_MASK_SCALE
      该常数是任何刻度标志位的位掩码。
      static int TYPE_QUADRANT_ROTATION
      该标志位表示除了由其他标志位指示的转换之外,由该对象定义的变换执行了90度的几倍的象限旋转。
      static int TYPE_TRANSLATION
      该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行转换。
      static int TYPE_UNIFORM_SCALE
      该标志位表示由该对象定义的变换除了由其他标志位指示的转换之外还执行统一的标度。
    • 构造方法摘要

      构造方法  
      Constructor 描述
      AffineTransform​()
      构造一个新的 AffineTransform代表身份转换。
      AffineTransform​(double[] flatmatrix)
      从表示3x3转换矩阵的4个非转换条目或6个可指定条目的双精度值数组构造新的 AffineTransform
      AffineTransform​(double m00, double m10, double m01, double m11, double m02, double m12)
      从6个双精度值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
      AffineTransform​(float[] flatmatrix)
      从表示3x3转换矩阵的4个非转换条目或6个可指定条目的浮点值数组构造新的 AffineTransform
      AffineTransform​(float m00, float m10, float m01, float m11, float m02, float m12)
      从6个浮点值构造新的 AffineTransform ,表示3x3变换矩阵的6个可指定条目。
      AffineTransform​(AffineTransform Tx)
      构造一个新的 AffineTransform ,它是一个指定的 AffineTransform对象的副本。
    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法 
      Modifier and Type 方法 描述
      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)
      通过此变换反向转换双精度坐标数组。
      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的值的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)
      通过此转换来转换双精度坐标数组,并将结果存储到浮点数组中。
      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​()
        构造一个新的 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)
        从表示3x3转换矩阵的4个非转换条目或6个可指定条目的浮点值数组构造新的AffineTransform 将值从数组中检索为{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)
        从表示3x3转换矩阵的4个非转换条目或6个可指定条目的双精度值数组构造新的AffineTransform 将值从数组中检索为{m00 m10 m01 m11 [m02 m12]}。
        参数
        flatmatrix - 包含要在新的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   ] 
        以正角度θ旋转正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_TRANSLATION标志位以及TYPE_QUADRANT_ROTATION或TYPE_GENERAL_ROTATION标志位之一之外的组合的异或运算。
        结果
        任何适用于此变换的指示标志的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); 
        结果
        一个双重值,即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); 
        结果
        一个双重值,即3×3仿射变换矩阵的 m11元素。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • getShearX

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

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

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

        public double getTranslateY​()
        返回3x3仿射变换矩阵的平移元素(m12)的Y坐标。
        结果
        作为仿射变换矩阵的平移元素的Y坐标的双重值。
        从以下版本开始:
        1.2
        另请参见:
        getMatrix(double[])
      • translate

        public void translate​(double tx,
                              double ty)
        将此转换与转换变换相结合。 这相当于调用连接(T),其中T是由以下矩阵表示的AffineTransform
          [   1    0    tx  ]
                  [   0    1    ty  ]
                  [   0    0    1   ] 
        参数
        tx - 坐标在X轴方向上平移的距离
        ty - 坐标在Y轴方向上平移的距离
        从以下版本开始:
        1.2
      • rotate

        public void rotate​(double theta)
        使用旋转变换连接此变换。 这相当于调用连接(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)
        使用缩放变换连接此变换。 这相当于调用连接(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)
        将此变换与剪切变换相结合。 这相当于调用连接(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复制转换的 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
        结果
        ptDst转换 ptSrc ,并将结果存储在 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)
        通过此转换来转换浮点坐标数组,并将结果存储到双精度数组中。 坐标以[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
        通过此变换反向转换双精度坐标数组。 两个坐标阵列部分可以完全相同,也可以是相同阵列的重叠部分,而不影响结果的有效性。 该方法确保在前一个操作可以被转换之前,不会覆盖源坐标。 坐标以[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的值的String
        重写:
        toStringObject
        结果
        一个 String代表这个 Object的价值。
        从以下版本开始:
        1.2
      • isIdentity

        public boolean isIdentity​()
        返回 true如果这个 AffineTransform是一个身份转换。
        结果
        true如果这是AffineTransform是一个身份转换; 否则为false
        从以下版本开始:
        1.2
      • clone

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

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