Класс 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,0, возвращается тождественное преобразование. Эта операция эквивалентна вызову:

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

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

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

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

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 представляет ту же аффинную координатную трансформацию, что и указанный аргумент.