Класс AffineTransform

public static final int TYPE_IDENTITY

Эта константа указывает, что преобразование, определённое этим объектом, является тождественным преобразованием. Тождественное преобразование — это такое преобразование, в котором координаты вывода всегда совпадают с координатами ввода. Если это преобразование отличается от тождественного, тип будет либо константой GENERAL_TRANSFORM, либо комбинацией соответствующих флаговых битов для различных преобразований координат, выполняемых этим преобразованием.

public static final int TYPE_TRANSLATION

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет сдвиг помимо преобразований, указанных другими флаговыми битами. Сдвиг перемещает координаты на постоянное значение по осям X и Y, не изменяя длину или угол векторов.

public static final int TYPE_UNIFORM_SCALE

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет равномерное масштабирование помимо преобразований, указанных другими флаговыми битами. Равномерное масштабирование умножает длину векторов на одинаковое значение по осям X и Y, не изменяя угол между векторами. Этот флаговый бит взаимно исключает флаговый бит TYPE_GENERAL_SCALE.

public static final int TYPE_GENERAL_SCALE

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет общее масштабирование помимо преобразований, указанных другими флаговыми битами. Общее масштабирование умножает длину векторов на разные значения по осям X и Y, не изменяя угол между перпендикулярными векторами. Этот флаговый бит взаимно исключает флаговый бит TYPE_UNIFORM_SCALE.

public static final int TYPE_MASK_SCALE

Эта константа — это битовая маска для любого из флаговых битов масштабирования.

public static final int TYPE_FLIP

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет отражение относительно какой-либо оси, что изменяет правую систему координат на левую помимо преобразований, указанных другими флаговыми битами. Правая система координат — это такая система, где положительная ось X вращается против часовой стрелки, чтобы наложить положительную ось Y, подобно тому, как закручиваются пальцы правой руки, когда вы смотрите на ваш большой палец. Левая система координат — это такая система, где положительная ось X вращается по часовой стрелке, чтобы наложить положительную ось Y, подобно тому, как закручиваются пальцы левой руки. Нет математического способа определить угол первоначального отражения, так как все углы отражения идентичны при соответствующем вращении.

public static final int TYPE_QUADRANT_ROTATION

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет поворот на 90 градусов, кратный целому числу, помимо преобразований, указанных другими флаговыми битами. Поворот изменяет углы векторов на одинаковое значение независимо от исходного направления вектора и не изменяет длину вектора. Этот флаговый бит взаимно исключает флаговый бит TYPE_GENERAL_ROTATION.

public static final int TYPE_GENERAL_ROTATION

Этот флаговый бит указывает, что преобразование, определённое этим объектом, выполняет поворот на произвольный угол помимо преобразований, указанных другими флаговыми битами. Поворот изменяет углы векторов на одинаковое значение независимо от исходного направления вектора и не изменяет длину вектора. Этот флаговый бит взаимно исключает флаговый бит TYPE_QUADRANT_ROTATION.

public static final int TYPE_MASK_ROTATION

Эта константа — это битовая маска для любых флаговых битов поворота.

public static final int TYPE_GENERAL_TRANSFORM

Эта константа указывает, что преобразование, определённое этим объектом, выполняет произвольное преобразование входных координат. Если это преобразование можно классифицировать по любой из вышеперечисленных констант, тип будет либо константой TYPE_IDENTITY, либо комбинацией соответствующих флаговых битов для различных преобразований координат, выполняемых этим преобразованием.

public AffineTransform()

Создаёт новый объект AffineTransform, представляющий тождественное преобразование.

public AffineTransform(AffineTransform Tx)

Создаёт новый объект AffineTransform, являющийся копией указанного объекта AffineTransform.

@ConstructorProperties({"scaleX","shearY","shearX","scaleY","translateX","translateY"}) public AffineTransform(float m00, float m10, float m01, float m11, float m02, float m12)

Создаёт новый объект AffineTransform из 6 значений с плавающей точкой, представляющих 6 задаваемых элементов матрицы преобразования 3x3.

public AffineTransform(float[] flatmatrix)

Создаёт новый объект AffineTransform из массива значений с плавающей точкой, представляющих либо 4 элемента без смещения, либо 6 задаваемых элементов матрицы преобразования 3x3. Значения извлекаются из массива как { m00 m10 m01 m11 [m02 m12]}

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

Создаёт новый объект AffineTransform из 6 значений двойной точности, представляющих 6 задаваемых элементов матрицы преобразования 3x3.

public AffineTransform(double[] flatmatrix)

Создаёт новый объект AffineTransform из массива значений двойной точности, представляющих либо 4 элемента без смещения, либо 6 задаваемых элементов матрицы преобразования 3x3. Значения извлекаются из массива как { m00 m10 m01 m11 [m02 m12]}

public static AffineTransform getTranslateInstance(double tx, double ty)

Возвращает преобразование, представляющее сдвиговое преобразование. Матрица, представляющая возвращаемое преобразование:

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

public static AffineTransform getRotateInstance(double theta)

Возвращает преобразование, представляющее поворотное преобразование. Матрица, представляющая возвращаемое преобразование:

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

Поворот на положительный угол theta поворачивает точки на положительной оси X к положительной оси Y. Обратите также внимание на обсуждение Обработки поворотов на 90 градусов выше.

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 градусов выше.

public static AffineTransform getRotateInstance(double vecx, double vecy)

Возвращает преобразование, поворачивающее координаты по вектору поворота. Все координаты поворачиваются вокруг начала координат на одинаковый угол. Величина поворота такова, что координаты вдоль прежней положительной оси X впоследствии выровняются с вектором, направленным от начала координат к указанным координатам вектора. Если и vecx и vecy равны 0, возвращается тождественное преобразование. Эта операция эквивалентна вызову:

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

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

Возвращает преобразование, поворачивающее координаты вокруг точки-якоря по вектору поворота. Все координаты поворачиваются вокруг указанных координат точки-якоря на одинаковый угол. Величина поворота такова, что координаты вдоль прежней положительной оси X впоследствии выровняются с вектором, направленным от начала координат к указанным координатам вектора. Если и vecx и vecy равны 0, возвращается тождественное преобразование. Эта операция эквивалентна вызову:

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

public static AffineTransform getQuadrantRotateInstance(int numquadrants)

Возвращает преобразование, поворачивающее координаты на указанное количество квадрантов. Эта операция эквивалентна вызову:

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

Поворот на положительное количество квадрантов поворачивает точки на положительной оси X к положительной оси Y.

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

Возвращает преобразование, которое вращает координаты на указанное количество квадрантов вокруг указанной точки якоря. Данная операция эквивалентна вызову:

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

Вращение на положительное число квадрантов поворачивает точки на положительной оси X к положительной оси Y.

public static AffineTransform getScaleInstance(double sx, double sy)

Возвращает преобразование, представляющее масштабирование. Матрица, представляющая возвращаемое преобразование:

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

public static AffineTransform getShearInstance(double shx, double shy)

Возвращает преобразование, представляющее сдвиг. Матрица, представляющая возвращаемое преобразование:

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

public int getType()

Получает биты флагов, описывающие свойства преобразования. Возвращаемое значение — одна из констант TYPE_IDENTITY или TYPE_GENERAL_TRANSFORM, или комбинация соответствующих битов флагов. Допустимая комбинация битов флагов — операция побитового ИЛИ, которая может комбинировать бит флага TYPE_TRANSLATION в дополнение к одному из битов флагов TYPE_UNIFORM_SCALE или TYPE_GENERAL_SCALE, а также к одному из битов флагов TYPE_QUADRANT_ROTATION или TYPE_GENERAL_ROTATION.

public double getDeterminant()

Возвращает определитель матрицы представления преобразования. Определитель полезен для определения возможности инвертирования преобразования и для получения одного значения, представляющего комбинированное масштабирование по осям X и Y преобразования.

Если определитель отличен от нуля, то это преобразование обратимо, и различные методы, зависящие от обратного преобразования, не должны выбрасывать исключение NoninvertibleTransformException. Если определитель равен нулю, то это преобразование необратимо, так как преобразование отображает все входные координаты на линию или точку. Если определитель близок к нулю, то операции обратного преобразования могут не иметь достаточной точности для получения осмысленных результатов.

Если это преобразование представляет равномерное масштабирование, как указано методом getType, то определитель также представляет собой квадрат коэффициента равномерного масштабирования, на который все точки расширяются или сжимаются к началу координат. Если это преобразование представляет неравномерное масштабирование или более общее преобразование, то определитель вряд ли будет представлять значение, полезное для любой цели, кроме определения возможности обратных преобразований.

Математически определитель вычисляется по формуле:

          |  m00  m01  m02  |
          |  m10  m11  m12  |  =  m00 * m11 - m01 * m10
          |   0    0    1   |
 

public void getMatrix(double[] flatmatrix)

Получает 6 значений в аффинной матрице преобразования 3x3 и помещает их в массив значений двойной точности. Значения хранятся в массиве как { m00 m10 m01 m11 m02 m12 }. Массив из 4 элементов double также может быть указан, в этом случае извлекаются только первые четыре элемента, представляющие необработанные части массива, и значения хранятся в массиве как { m00 m10 m01 m11 }

public double getScaleX()

Возвращает элемент m00 аффинной матрицы преобразования 3x3. Этот множитель матрицы определяет, как входные координаты X будут влиять на выходные координаты X, и является одним элементом масштаба преобразования. Для измерения степени, в которой координаты X растягиваются или сжимаются этим преобразованием, используйте следующий код:

     Point2D p = new Point2D.Double(1, 0);
     p = tx.deltaTransform(p, p);
     double scaleX = p.distance(0, 0);
 

public double getScaleY()

Возвращает элемент m11 аффинной матрицы преобразования 3x3. Этот множитель матрицы определяет, как входные координаты Y будут влиять на выходные координаты Y, и является одним элементом масштаба преобразования. Для измерения степени, в которой координаты Y растягиваются или сжимаются этим преобразованием, используйте следующий код:

     Point2D p = new Point2D.Double(0, 1);
     p = tx.deltaTransform(p, p);
     double scaleY = p.distance(0, 0);
 

public double getShearX()

Возвращает элемент сдвига по оси X (m01) аффинной матрицы преобразования 3x3.

public double getShearY()

Возвращает элемент сдвига по оси Y (m10) аффинной матрицы преобразования 3x3.

public double getTranslateX()

Возвращает координату X элемента перевода (m02) аффинной матрицы преобразования 3x3.

public double getTranslateY()

Возвращает координату Y элемента перевода (m12) аффинной матрицы преобразования 3x3.

public void translate(double tx, double ty)

Присоединяет к этому преобразованию преобразование сдвига. Это эквивалентно вызову concatenate(T), где T — AffineTransform, представленное следующей матрицей:

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

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 градусов выше.

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 градусов выше.

public void rotate(double vecx, double vecy)

Присоединяет к этому преобразованию преобразование, которое вращает координаты в соответствии с вектором поворота. Все координаты вращаются вокруг начала координат на одинаковый угол. Величина поворота такова, что координаты вдоль бывшей положительной оси X будут затем выровнены с вектором, направленным от начала координат к заданным координатам вектора. Если и vecx и vecy равны 0,0, к этому преобразованию не добавляется дополнительный поворот. Эта операция эквивалентна вызову:

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

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

Присоединяет к этому преобразованию преобразование, которое вращает координаты вокруг точки-якоря в соответствии с вектором поворота. Все координаты вращаются вокруг указанных координат точки-якоря на одинаковый угол. Величина поворота такова, что координаты вдоль бывшей положительной оси X будут затем выровнены с вектором, направленным от начала координат к заданным координатам вектора. Если и vecx и vecy равны 0,0, преобразование не изменяется. Этот метод эквивалентен вызову:

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

public void quadrantRotate(int numquadrants)

Присоединяет к этому преобразованию преобразование, которое вращает координаты на указанное количество четвертей. Это эквивалентно вызову:

     rotate(numquadrants * Math.PI / 2.0);
 

Поворот на положительное количество четвертей вращает точки на положительной оси X к положительной оси Y.

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

Присоединяет к этому преобразованию преобразование, которое вращает координаты на указанное количество четвертей вокруг указанной точки-якоря. Этот метод эквивалентен вызову:

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

Поворот на положительное количество четвертей вращает точки на положительной оси X к положительной оси Y.

public void scale(double sx, double sy)

Присоединяет к этому преобразованию преобразование масштабирования. Это эквивалентно вызову concatenate(S), где S — AffineTransform, представленный следующей матрицей:

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

public void shear(double shx, double shy)

Присоединяет к этому преобразованию преобразование сдвига. Это эквивалентно вызову concatenate(SH), где SH — AffineTransform, представленный следующей матрицей:

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

public void setToIdentity()

Сбрасывает это преобразование до тождественного преобразования.

public void setToTranslation(double tx, double ty)

Устанавливает это преобразование как преобразование перемещения. Матрица, представляющая это преобразование, становится:

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

public void setToRotation(double theta)

Устанавливает это преобразование как поворотное преобразование. Матрица, представляющая это преобразование, становится:

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

Поворот на положительный угол theta поворачивает точки на положительной оси X к положительной оси Y. Обратите также внимание на обсуждение Обработки поворотов на 90 градусов выше.

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 градусов выше.

public void setToRotation(double vecx, double vecy)

Устанавливает это преобразование как поворотное преобразование, которое вращает координаты в соответствии с вектором поворота. Все координаты вращаются вокруг начала координат на одинаковый угол. Величина поворота такова, что координаты вдоль бывшей положительной оси X будут затем выровнены с вектором, направленным от начала координат к заданным координатам вектора. Если и vecx и vecy равны 0,0, преобразование устанавливается в тождественное преобразование. Эта операция эквивалентна вызову:

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

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

Устанавливает это преобразование как поворотное преобразование, которое вращает координаты вокруг точки-якоря в соответствии с вектором поворота. Все координаты вращаются вокруг указанных координат точки-якоря на одинаковый угол. Величина поворота такова, что координаты вдоль бывшей положительной оси X будут затем выровнены с вектором, направленным от начала координат к заданным координатам вектора. Если и vecx и vecy равны 0,0, преобразование устанавливается в тождественное преобразование. Эта операция эквивалентна вызову:

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

public void setToQuadrantRotation(int numquadrants)

Устанавливает это преобразование как поворотное преобразование, которое вращает координаты на указанное количество четвертей. Эта операция эквивалентна вызову:

     setToRotation(numquadrants * Math.PI / 2.0);
 

Поворот на положительное количество четвертей вращает точки на положительной оси X к положительной оси Y.

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

Устанавливает это преобразование в переведённое вращательное преобразование, которое вращает координаты на указанное количество квадрантов вокруг указанной точки привязки. Эта операция эквивалентна вызову:

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

Вращение на положительное количество квадрантов поворачивает точки на положительной оси X к положительной оси Y.

public void setToScale(double sx, double sy)

Устанавливает это преобразование в масштабирующее преобразование. Матрица, представляющая это преобразование, становится:

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

public void setToShear(double shx, double shy)

Устанавливает это преобразование в сдвиговое преобразование. Матрица, представляющая это преобразование, становится:

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

public void setTransform(AffineTransform Tx)

Устанавливает это преобразование в копию преобразования в указанном AffineTransform объекте.

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

Устанавливает это преобразование в матрицу, заданную 6 значениями двойной точности.

public void concatenate(AffineTransform Tx)

Конкатенирует AffineTransform Tx с этим AffineTransform Cx наиболее удобным способом, чтобы предоставить новое пространство пользователя, которое отображается на предыдущее пространство пользователя с помощью Tx. Cx обновляется для выполнения комбинированного преобразования. Преобразование точки p с обновлённым преобразованием Cx' эквивалентно сначала преобразованию p с помощью Tx, а затем преобразованию результата с помощью исходного преобразования Cx следующим образом: Cx'(p) = Cx(Tx(p)) В матричной записи, если это преобразование Cx представлено матрицей [this] и Tx представлено матрицей [Tx], то этот метод выполняет следующее:

          [this] = [this] x [Tx]
 

public void preConcatenate(AffineTransform Tx)

Конкатенирует AffineTransform Tx с этим AffineTransform Cx менее распространённым способом, так что Tx изменяет преобразование координат относительно абсолютного пространства пикселей, а не относительно существующего пространства пользователя. Cx обновляется для выполнения комбинированного преобразования. Преобразование точки p с обновлённым преобразованием Cx' эквивалентно сначала преобразованию p с исходным преобразованием Cx, а затем преобразованию результата с помощью Tx следующим образом: Cx'(p) = Tx(Cx(p)) В матричной записи, если это преобразование Cx представлено матрицей [this] и Tx представлено матрицей [Tx], то этот метод выполняет следующее:

          [this] = [Tx] x [this]
 

public AffineTransform createInverse() throws NoninvertibleTransformException

Возвращает AffineTransform объект, представляющий обратное преобразование. Обратное преобразование Tx' этого преобразования Tx отображает координаты, преобразованные Tx, обратно в их исходные координаты. Другими словами, Tx'(Tx(p)) = p = Tx(Tx'(p)).

Если это преобразование отображает все координаты на точку или линию, то оно не будет иметь обратного, так как у координат, которые не лежат на целевой точке или линии, не будет обратного отображения. Метод getDeterminant может использоваться для определения, имеет ли это преобразование обратное, в случае чего исключение будет выброшено, если будет вызван метод createInverse.

public void invert() throws NoninvertibleTransformException

Устанавливает это преобразование в обратное самому себе. Обратное преобразование Tx' этого преобразования Tx отображает координаты, преобразованные Tx, обратно в их исходные координаты. Другими словами, Tx'(Tx(p)) = p = Tx(Tx'(p)).

Если это преобразование отображает все координаты на точку или линию, то оно не будет иметь обратного, так как у координат, которые не лежат на целевой точке или линии, не будет обратного отображения. Метод getDeterminant может использоваться для определения, имеет ли это преобразование обратное, в случае чего исключение будет выброшено, если будет вызван метод invert.

public Point2D transform(Point2D ptSrc, Point2D ptDst)

Преобразует указанную ptSrc и сохраняет результат в ptDst. Если ptDst является null, новый Point2D объект выделяется, и затем результат преобразования сохраняется в этом объекте. В любом случае ptDst, содержащий преобразованную точку, возвращается для удобства. Если ptSrc и ptDst являются одним и тем же объектом, входная точка корректно перезаписывается преобразованной точкой.

public void transform(Point2D[] ptSrc, int srcOff, Point2D[] ptDst, int dstOff, int numPts)

Преобразует массив объектов точек с помощью этого преобразования. Если какой-либо элемент массива ptDst является null, новый Point2D объект выделяется и сохраняется в этом элементе перед сохранением результатов преобразования.

Обратите внимание, что этот метод не принимает никаких мер предосторожности, чтобы избежать проблем, вызванных хранением результатов в Point2D объектах, которые будут использоваться в качестве источника для вычислений далее в массиве источников. Этот метод гарантирует, что если указанный Point2D объект является и источником, и пунктом назначения для той же операции преобразования одной точки, то результаты не будут сохранены до завершения вычислений, чтобы избежать сохранения результатов поверх операндов. Однако, если целевой Point2D объект для одной операции является тем же объектом, что и исходный Point2D объект для другой операции далее по массиву источников, то исходные координаты в этой точке перезаписываются до того, как они могут быть преобразованы.

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

Преобразует массив координат с плавающей запятой с помощью этого преобразования. Два массива координат могут быть идентичными или перекрывающимися участками одного массива, не влияя на корректность результатов. Этот метод гарантирует, что никакие исходные координаты не будут перезаписаны предыдущей операцией, прежде чем они смогут быть преобразованы. Координаты хранятся в массивах, начиная со значения смещения, указанного в порядке [x0, y0, x1, y1, ..., xn, yn].

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

Преобразует массив координат двойной точности с помощью этого преобразования. Два массива координат могут быть идентичными или перекрывающимися участками одного массива, не влияя на корректность результатов. Этот метод гарантирует, что никакие исходные координаты не будут перезаписаны предыдущей операцией, прежде чем они смогут быть преобразованы. Координаты хранятся в массивах, начиная со значения смещения, указанного в порядке [x0, y0, x1, y1, ..., xn, yn].

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

Преобразует массив координат с плавающей запятой с помощью этого преобразования и сохраняет результаты в массив с двойной точностью. Координаты хранятся в массивах, начиная со значения смещения, указанного в порядке [x0, y0, x1, y1, ..., xn, yn].

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

Преобразует массив координат двойной точности с помощью этого преобразования и сохраняет результаты в массив с плавающей запятой. Координаты хранятся в массивах, начиная со значения смещения, указанного в порядке [x0, y0, x1, y1, ..., xn, yn].

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

Обратное преобразование указанной ptSrc и сохранение результата в ptDst. Если ptDst равно null, новый объект Point2D выделяется, и результат преобразования сохраняется в этом объекте. В любом случае, ptDst, содержащий преобразованную точку, возвращается для удобства. Если ptSrc и ptDst являются одним объектом, входная точка корректно перезаписывается преобразованной точкой.

public void inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) throws NoninvertibleTransformException

Обратное преобразование массива координат двойной точности с помощью этого преобразования. Два массива координат могут быть идентичными или перекрывающимися участками одного массива, не влияя на корректность результатов. Этот метод гарантирует, что никакие исходные координаты не будут перезаписаны предыдущей операцией, прежде чем они смогут быть преобразованы. Координаты хранятся в массивах, начиная со значения смещения, указанного в порядке [x0, y0, x1, y1, ..., xn, yn].

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 являются одним объектом, входная точка корректно перезаписывается преобразованной точкой.

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].

public Shape createTransformedShape(Shape pSrc)

Возвращает новый объект Shape, определяемый геометрией указанной Shape после её преобразования с помощью этого преобразования.

public String toString()

Возвращает String, представляющее значение этого Object.

public boolean isIdentity()

Возвращает true, если это AffineTransform является тождественным преобразованием.

public Object clone()

Возвращает копию этого AffineTransform объекта.

public int hashCode()

Возвращает код хэширования для этого преобразования.

public boolean equals(Object obj)

Возвращает true, если этот AffineTransform представляет то же аффинное преобразование координат, что и указанный аргумент.