< prev index next >

src/java.desktop/share/classes/java/awt/geom/AffineTransform.java

Print this page

        

@@ -27,11 +27,11 @@
 
 import java.awt.Shape;
 import java.beans.ConstructorProperties;
 
 /**
- * The <code>AffineTransform</code> class represents a 2D affine transform
+ * The {@code AffineTransform} class represents a 2D affine transform
  * that performs a linear mapping from 2D coordinates to other 2D
  * coordinates that preserves the "straightness" and
  * "parallelness" of lines.  Affine transformations can be constructed
  * using sequences of translations, scales, flips, rotations, and shears.
  * <p>

@@ -46,12 +46,12 @@
  *      [ y'] = [  m10  m11  m12  ] [ y ] = [ m10x + m11y + m12 ]
  *      [ 1 ]   [   0    0    1   ] [ 1 ]   [         1         ]
  * </pre>
  * <h3><a name="quadrantapproximation">Handling 90-Degree Rotations</a></h3>
  * <p>
- * In some variations of the <code>rotate</code> methods in the
- * <code>AffineTransform</code> class, a double-precision argument
+ * In some variations of the {@code rotate} methods in the
+ * {@code AffineTransform} class, a double-precision argument
  * specifies the angle of rotation in radians.
  * These methods have special handling for rotations of approximately
  * 90 degrees (including multiples such as 180, 270, and 360 degrees),
  * so that the common case of quadrant rotation is handled more
  * efficiently.

@@ -61,34 +61,34 @@
  * For small multiples of 90 degrees the range of angles treated
  * as a quadrant rotation is approximately 0.00000121 degrees wide.
  * This section explains why such special care is needed and how
  * it is implemented.
  * <p>
- * Since 90 degrees is represented as <code>PI/2</code> in radians,
+ * Since 90 degrees is represented as {@code PI/2} in radians,
  * and since PI is a transcendental (and therefore irrational) number,
  * it is not possible to exactly represent a multiple of 90 degrees as
  * an exact double precision value measured in radians.
  * As a result it is theoretically impossible to describe quadrant
  * rotations (90, 180, 270 or 360 degrees) using these values.
  * Double precision floating point values can get very close to
- * non-zero multiples of <code>PI/2</code> but never close enough
+ * non-zero multiples of {@code PI/2} but never close enough
  * for the sine or cosine to be exactly 0.0, 1.0 or -1.0.
- * The implementations of <code>Math.sin()</code> and
- * <code>Math.cos()</code> correspondingly never return 0.0
- * for any case other than <code>Math.sin(0.0)</code>.
+ * The implementations of {@code Math.sin()} and
+ * {@code Math.cos()} correspondingly never return 0.0
+ * for any case other than {@code Math.sin(0.0)}.
  * These same implementations do, however, return exactly 1.0 and
  * -1.0 for some range of numbers around each multiple of 90
  * degrees since the correct answer is so close to 1.0 or -1.0 that
  * the double precision significand cannot represent the difference
  * as accurately as it can for numbers that are near 0.0.
  * <p>
  * The net result of these issues is that if the
- * <code>Math.sin()</code> and <code>Math.cos()</code> methods
+ * {@code Math.sin()} and {@code Math.cos()} methods
  * are used to directly generate the values for the matrix modifications
  * during these radian-based rotation operations then the resulting
  * transform is never strictly classifiable as a quadrant rotation
- * even for a simple case like <code>rotate(Math.PI/2.0)</code>,
+ * even for a simple case like {@code rotate(Math.PI/2.0)},
  * due to minor variations in the matrix caused by the non-0.0 values
  * obtained for the sine and cosine.
  * If these transforms are not classified as quadrant rotations then
  * subsequent code which attempts to optimize further operations based
  * upon the type of the transform will be relegated to its most general

@@ -104,11 +104,11 @@
  * These methods therefore treat an angle <em>theta</em> as a quadrant
  * rotation if either <code>Math.sin(<em>theta</em>)</code> or
  * <code>Math.cos(<em>theta</em>)</code> returns exactly 1.0 or -1.0.
  * As a rule of thumb, this property holds true for a range of
  * approximately 0.0000000211 radians (or 0.00000121 degrees) around
- * small multiples of <code>Math.PI/2.0</code>.
+ * small multiples of {@code Math.PI/2.0}.
  *
  * @author Jim Graham
  * @since 1.2
  */
 public class AffineTransform implements Cloneable, java.io.Serializable {

@@ -465,11 +465,11 @@
         this.state = state;
         this.type = TYPE_UNKNOWN;
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> representing the
+     * Constructs a new {@code AffineTransform} representing the
      * Identity transformation.
      * @since 1.2
      */
     public AffineTransform() {
         m00 = m11 = 1.0;

@@ -477,13 +477,13 @@
         // state = APPLY_IDENTITY;              /* Not needed. */
         // type = TYPE_IDENTITY;                /* Not needed. */
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> that is a copy of
-     * the specified <code>AffineTransform</code> object.
-     * @param Tx the <code>AffineTransform</code> object to copy
+     * Constructs a new {@code AffineTransform} that is a copy of
+     * the specified {@code AffineTransform} object.
+     * @param Tx the {@code AffineTransform} object to copy
      * @since 1.2
      */
     public AffineTransform(AffineTransform Tx) {
         this.m00 = Tx.m00;
         this.m10 = Tx.m10;

@@ -494,11 +494,11 @@
         this.state = Tx.state;
         this.type = Tx.type;
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> from 6 floating point
+     * Constructs a new {@code AffineTransform} from 6 floating point
      * values representing the 6 specifiable entries of the 3x3
      * transformation matrix.
      *
      * @param m00 the X coordinate scaling element of the 3x3 matrix
      * @param m10 the Y coordinate shearing element of the 3x3 matrix

@@ -520,17 +520,17 @@
         this.m12 = m12;
         updateState();
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> from an array of
+     * Constructs a new {@code AffineTransform} from an array of
      * floating point values representing either the 4 non-translation
      * entries or the 6 specifiable entries of the 3x3 transformation
      * matrix.  The values are retrieved from the array as
      * {&nbsp;m00&nbsp;m10&nbsp;m01&nbsp;m11&nbsp;[m02&nbsp;m12]}.
      * @param flatmatrix the float array containing the values to be set
-     * in the new <code>AffineTransform</code> object. The length of the
+     * in the new {@code AffineTransform} object. The length of the
      * array is assumed to be at least 4. If the length of the array is
      * less than 6, only the first 4 values are taken. If the length of
      * the array is greater than 6, the first 6 values are taken.
      * @since 1.2
      */

@@ -545,11 +545,11 @@
         }
         updateState();
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> from 6 double
+     * Constructs a new {@code AffineTransform} from 6 double
      * precision values representing the 6 specifiable entries of the 3x3
      * transformation matrix.
      *
      * @param m00 the X coordinate scaling element of the 3x3 matrix
      * @param m10 the Y coordinate shearing element of the 3x3 matrix

@@ -570,17 +570,17 @@
         this.m12 = m12;
         updateState();
     }
 
     /**
-     * Constructs a new <code>AffineTransform</code> from an array of
+     * Constructs a new {@code AffineTransform} from an array of
      * double precision values representing either the 4 non-translation
      * entries or the 6 specifiable entries of the 3x3 transformation
      * matrix. The values are retrieved from the array as
      * {&nbsp;m00&nbsp;m10&nbsp;m01&nbsp;m11&nbsp;[m02&nbsp;m12]}.
      * @param flatmatrix the double array containing the values to be set
-     * in the new <code>AffineTransform</code> object. The length of the
+     * in the new {@code AffineTransform} object. The length of the
      * array is assumed to be at least 4. If the length of the array is
      * less than 6, only the first 4 values are taken. If the length of
      * the array is greater than 6, the first 6 values are taken.
      * @since 1.2
      */

@@ -606,11 +606,11 @@
      * </pre>
      * @param tx the distance by which coordinates are translated in the
      * X axis direction
      * @param ty the distance by which coordinates are translated in the
      * Y axis direction
-     * @return an <code>AffineTransform</code> object that represents a
+     * @return an {@code AffineTransform} object that represents a
      *  translation transformation, created with the specified vector.
      * @since 1.2
      */
     public static AffineTransform getTranslateInstance(double tx, double ty) {
         AffineTransform Tx = new AffineTransform();

@@ -630,11 +630,11 @@
      * X axis toward the positive Y axis.
      * Note also the discussion of
      * <a href="#quadrantapproximation">Handling 90-Degree Rotations</a>
      * above.
      * @param theta the angle of rotation measured in radians
-     * @return an <code>AffineTransform</code> object that is a rotation
+     * @return an {@code AffineTransform} object that is a rotation
      *  transformation, created with the specified angle of rotation.
      * @since 1.2
      */
     public static AffineTransform getRotateInstance(double theta) {
         AffineTransform Tx = new AffineTransform();

@@ -670,11 +670,11 @@
      * above.
      *
      * @param theta the angle of rotation measured in radians
      * @param anchorx the X coordinate of the rotation anchor point
      * @param anchory the Y coordinate of the rotation anchor point
-     * @return an <code>AffineTransform</code> object that rotates
+     * @return an {@code AffineTransform} object that rotates
      *  coordinates around the specified point by the specified angle of
      *  rotation.
      * @since 1.2
      */
     public static AffineTransform getRotateInstance(double theta,

@@ -691,20 +691,20 @@
      * a rotation vector.
      * All coordinates rotate about the origin by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * an identity transform is returned.
      * This operation is equivalent to calling:
      * <pre>
      *     AffineTransform.getRotateInstance(Math.atan2(vecy, vecx));
      * </pre>
      *
      * @param vecx the X coordinate of the rotation vector
      * @param vecy the Y coordinate of the rotation vector
-     * @return an <code>AffineTransform</code> object that rotates
+     * @return an {@code AffineTransform} object that rotates
      *  coordinates according to the specified rotation vector.
      * @since 1.6
      */
     public static AffineTransform getRotateInstance(double vecx, double vecy) {
         AffineTransform Tx = new AffineTransform();

@@ -718,11 +718,11 @@
      * All coordinates rotate about the specified anchor coordinates
      * by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * an identity transform is returned.
      * This operation is equivalent to calling:
      * <pre>
      *     AffineTransform.getRotateInstance(Math.atan2(vecy, vecx),
      *                                       anchorx, anchory);

@@ -730,11 +730,11 @@
      *
      * @param vecx the X coordinate of the rotation vector
      * @param vecy the Y coordinate of the rotation vector
      * @param anchorx the X coordinate of the rotation anchor point
      * @param anchory the Y coordinate of the rotation anchor point
-     * @return an <code>AffineTransform</code> object that rotates
+     * @return an {@code AffineTransform} object that rotates
      *  coordinates around the specified point according to the
      *  specified rotation vector.
      * @since 1.6
      */
     public static AffineTransform getRotateInstance(double vecx,

@@ -755,11 +755,11 @@
      *     AffineTransform.getRotateInstance(numquadrants * Math.PI / 2.0);
      * </pre>
      * Rotating by a positive number of quadrants rotates points on
      * the positive X axis toward the positive Y axis.
      * @param numquadrants the number of 90 degree arcs to rotate by
-     * @return an <code>AffineTransform</code> object that rotates
+     * @return an {@code AffineTransform} object that rotates
      *  coordinates by the specified number of quadrants.
      * @since 1.6
      */
     public static AffineTransform getQuadrantRotateInstance(int numquadrants) {
         AffineTransform Tx = new AffineTransform();

@@ -779,11 +779,11 @@
      * the positive X axis toward the positive Y axis.
      *
      * @param numquadrants the number of 90 degree arcs to rotate by
      * @param anchorx the X coordinate of the rotation anchor point
      * @param anchory the Y coordinate of the rotation anchor point
-     * @return an <code>AffineTransform</code> object that rotates
+     * @return an {@code AffineTransform} object that rotates
      *  coordinates by the specified number of quadrants around the
      *  specified anchor point.
      * @since 1.6
      */
     public static AffineTransform getQuadrantRotateInstance(int numquadrants,

@@ -805,11 +805,11 @@
      * </pre>
      * @param sx the factor by which coordinates are scaled along the
      * X axis direction
      * @param sy the factor by which coordinates are scaled along the
      * Y axis direction
-     * @return an <code>AffineTransform</code> object that scales
+     * @return an {@code AffineTransform} object that scales
      *  coordinates by the specified factors.
      * @since 1.2
      */
     public static AffineTransform getScaleInstance(double sx, double sy) {
         AffineTransform Tx = new AffineTransform();

@@ -827,11 +827,11 @@
      * </pre>
      * @param shx the multiplier by which coordinates are shifted in the
      * direction of the positive X axis as a factor of their Y coordinate
      * @param shy the multiplier by which coordinates are shifted in the
      * direction of the positive Y axis as a factor of their X coordinate
-     * @return an <code>AffineTransform</code> object that shears
+     * @return an {@code AffineTransform} object that shears
      *  coordinates by the specified multipliers.
      * @since 1.2
      */
     public static AffineTransform getShearInstance(double shx, double shy) {
         AffineTransform Tx = new AffineTransform();

@@ -1013,11 +1013,11 @@
      * If the determinant is near enough to zero then inverse transform
      * operations might not carry enough precision to produce meaningful
      * results.
      * <p>
      * If this transform represents a uniform scale, as indicated by
-     * the <code>getType</code> method then the determinant also
+     * the {@code getType} method then the determinant also
      * represents the square of the uniform scale factor by which all of
      * the points are expanded from or contracted towards the origin.
      * If this transform represents a non-uniform scale or more general
      * transform then the determinant is not likely to represent a
      * value useful for any purpose other than determining if inverse

@@ -1232,11 +1232,11 @@
     }
 
     /**
      * Concatenates this transform with a translation transformation.
      * This is equivalent to calling concatenate(T), where T is an
-     * <code>AffineTransform</code> represented by the following matrix:
+     * {@code AffineTransform} represented by the following matrix:
      * <pre>
      *          [   1    0    tx  ]
      *          [   0    1    ty  ]
      *          [   0    0    1   ]
      * </pre>

@@ -1392,11 +1392,11 @@
     }
 
     /**
      * Concatenates this transform with a rotation transformation.
      * This is equivalent to calling concatenate(R), where R is an
-     * <code>AffineTransform</code> represented by the following matrix:
+     * {@code AffineTransform} represented by the following matrix:
      * <pre>
      *          [   cos(theta)    -sin(theta)    0   ]
      *          [   sin(theta)     cos(theta)    0   ]
      *          [       0              0         1   ]
      * </pre>

@@ -1471,11 +1471,11 @@
      * coordinates according to a rotation vector.
      * All coordinates rotate about the origin by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * no additional rotation is added to this transform.
      * This operation is equivalent to calling:
      * <pre>
      *          rotate(Math.atan2(vecy, vecx));
      * </pre>

@@ -1521,11 +1521,11 @@
      * All coordinates rotate about the specified anchor coordinates
      * by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * the transform is not modified in any way.
      * This method is equivalent to calling:
      * <pre>
      *     rotate(Math.atan2(vecy, vecx), anchorx, anchory);
      * </pre>

@@ -1619,11 +1619,11 @@
     }
 
     /**
      * Concatenates this transform with a scaling transformation.
      * This is equivalent to calling concatenate(S), where S is an
-     * <code>AffineTransform</code> represented by the following matrix:
+     * {@code AffineTransform} represented by the following matrix:
      * <pre>
      *          [   sx   0    0   ]
      *          [   0    sy   0   ]
      *          [   0    0    1   ]
      * </pre>

@@ -1688,11 +1688,11 @@
     }
 
     /**
      * Concatenates this transform with a shearing transformation.
      * This is equivalent to calling concatenate(SH), where SH is an
-     * <code>AffineTransform</code> represented by the following matrix:
+     * {@code AffineTransform} represented by the following matrix:
      * <pre>
      *          [   1   shx   0   ]
      *          [  shy   1    0   ]
      *          [   0    0    1   ]
      * </pre>

@@ -1888,11 +1888,11 @@
      * coordinates according to a rotation vector.
      * All coordinates rotate about the origin by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * the transform is set to an identity transform.
      * This operation is equivalent to calling:
      * <pre>
      *     setToRotation(Math.atan2(vecy, vecx));
      * </pre>

@@ -1941,11 +1941,11 @@
      * All coordinates rotate about the specified anchor coordinates
      * by the same amount.
      * The amount of rotation is such that coordinates along the former
      * positive X axis will subsequently align with the vector pointing
      * from the origin to the specified vector coordinates.
-     * If both <code>vecx</code> and <code>vecy</code> are 0.0,
+     * If both {@code vecx} and {@code vecy} are 0.0,
      * the transform is set to an identity transform.
      * This operation is equivalent to calling:
      * <pre>
      *     setToTranslation(Math.atan2(vecy, vecx), anchorx, anchory);
      * </pre>

@@ -2165,12 +2165,12 @@
         }
     }
 
     /**
      * Sets this transform to a copy of the transform in the specified
-     * <code>AffineTransform</code> object.
-     * @param Tx the <code>AffineTransform</code> object from which to
+     * {@code AffineTransform} object.
+     * @param Tx the {@code AffineTransform} object from which to
      * copy the transform
      * @since 1.2
      */
     public void setTransform(AffineTransform Tx) {
         this.m00 = Tx.m00;

@@ -2206,27 +2206,27 @@
         this.m12 = m12;
         updateState();
     }
 
     /**
-     * Concatenates an <code>AffineTransform</code> <code>Tx</code> to
-     * this <code>AffineTransform</code> Cx in the most commonly useful
+     * Concatenates an {@code AffineTransform Tx} to
+     * this {@code AffineTransform} Cx in the most commonly useful
      * way to provide a new user space
-     * that is mapped to the former user space by <code>Tx</code>.
+     * that is mapped to the former user space by {@code Tx}.
      * Cx is updated to perform the combined transformation.
      * Transforming a point p by the updated transform Cx' is
-     * equivalent to first transforming p by <code>Tx</code> and then
+     * equivalent to first transforming p by {@code Tx} and then
      * transforming the result by the original transform Cx like this:
      * Cx'(p) = Cx(Tx(p))
      * In matrix notation, if this transform Cx is
-     * represented by the matrix [this] and <code>Tx</code> is represented
+     * represented by the matrix [this] and {@code Tx} is represented
      * by the matrix [Tx] then this method does the following:
      * <pre>
      *          [this] = [this] x [Tx]
      * </pre>
-     * @param Tx the <code>AffineTransform</code> object to be
-     * concatenated with this <code>AffineTransform</code> object.
+     * @param Tx the {@code AffineTransform} object to be
+     * concatenated with this {@code AffineTransform} object.
      * @see #preConcatenate
      * @since 1.2
      */
     @SuppressWarnings("fallthrough")
     public void concatenate(AffineTransform Tx) {

@@ -2412,30 +2412,30 @@
         }
         updateState();
     }
 
     /**
-     * Concatenates an <code>AffineTransform</code> <code>Tx</code> to
-     * this <code>AffineTransform</code> Cx
-     * in a less commonly used way such that <code>Tx</code> modifies the
+     * Concatenates an {@code AffineTransform Tx} to
+     * this {@code AffineTransform} Cx
+     * in a less commonly used way such that {@code Tx} modifies the
      * coordinate transformation relative to the absolute pixel
      * space rather than relative to the existing user space.
      * Cx is updated to perform the combined transformation.
      * Transforming a point p by the updated transform Cx' is
      * equivalent to first transforming p by the original transform
      * Cx and then transforming the result by
-     * <code>Tx</code> like this:
+     * {@code Tx} like this:
      * Cx'(p) = Tx(Cx(p))
      * In matrix notation, if this transform Cx
-     * is represented by the matrix [this] and <code>Tx</code> is
+     * is represented by the matrix [this] and {@code Tx} is
      * represented by the matrix [Tx] then this method does the
      * following:
      * <pre>
      *          [this] = [Tx] x [this]
      * </pre>
-     * @param Tx the <code>AffineTransform</code> object to be
-     * concatenated with this <code>AffineTransform</code> object.
+     * @param Tx the {@code AffineTransform} object to be
+     * concatenated with this {@code AffineTransform} object.
      * @see #concatenate
      * @since 1.2
      */
     @SuppressWarnings("fallthrough")
     public void preConcatenate(AffineTransform Tx) {

@@ -2630,25 +2630,25 @@
         }
         updateState();
     }
 
     /**
-     * Returns an <code>AffineTransform</code> object representing the
+     * Returns an {@code AffineTransform} object representing the
      * inverse transformation.
      * The inverse transform Tx' of this transform Tx
      * maps coordinates transformed by Tx back
      * to their original coordinates.
      * In other words, Tx'(Tx(p)) = p = Tx(Tx'(p)).
      * <p>
      * If this transform maps all coordinates onto a point or a line
      * then it will not have an inverse, since coordinates that do
      * not lie on the destination point or line will not have an inverse
      * mapping.
-     * The <code>getDeterminant</code> method can be used to determine if this
+     * The {@code getDeterminant} method can be used to determine if this
      * transform has no inverse, in which case an exception will be
-     * thrown if the <code>createInverse</code> method is called.
-     * @return a new <code>AffineTransform</code> object representing the
+     * thrown if the {@code createInverse} method is called.
+     * @return a new {@code AffineTransform} object representing the
      * inverse transformation.
      * @see #getDeterminant
      * @exception NoninvertibleTransformException
      * if the matrix cannot be inverted.
      * @since 1.2

@@ -2738,13 +2738,13 @@
      * <p>
      * If this transform maps all coordinates onto a point or a line
      * then it will not have an inverse, since coordinates that do
      * not lie on the destination point or line will not have an inverse
      * mapping.
-     * The <code>getDeterminant</code> method can be used to determine if this
+     * The {@code getDeterminant} method can be used to determine if this
      * transform has no inverse, in which case an exception will be
-     * thrown if the <code>invert</code> method is called.
+     * thrown if the {@code invert} method is called.
      * @see #getDeterminant
      * @exception NoninvertibleTransformException
      * if the matrix cannot be inverted.
      * @since 1.6
      */

@@ -2859,25 +2859,25 @@
             break;
         }
     }
 
     /**
-     * Transforms the specified <code>ptSrc</code> and stores the result
-     * in <code>ptDst</code>.
-     * If <code>ptDst</code> is <code>null</code>, a new {@link Point2D}
+     * Transforms the specified {@code ptSrc} and stores the result
+     * in {@code ptDst}.
+     * If {@code ptDst} is {@code null}, a new {@link Point2D}
      * object is allocated and then the result of the transformation is
      * stored in this object.
-     * In either case, <code>ptDst</code>, which contains the
+     * In either case, {@code ptDst}, which contains the
      * transformed point, is returned for convenience.
-     * If <code>ptSrc</code> and <code>ptDst</code> are the same
+     * If {@code ptSrc} and {@code ptDst} are the same
      * object, the input point is correctly overwritten with
      * the transformed point.
-     * @param ptSrc the specified <code>Point2D</code> to be transformed
-     * @param ptDst the specified <code>Point2D</code> that stores the
-     * result of transforming <code>ptSrc</code>
-     * @return the <code>ptDst</code> after transforming
-     * <code>ptSrc</code> and storing the result in <code>ptDst</code>.
+     * @param ptSrc the specified {@code Point2D} to be transformed
+     * @param ptDst the specified {@code Point2D} that stores the
+     * result of transforming {@code ptSrc}
+     * @return the {@code ptDst} after transforming
+     * {@code ptSrc} and storing the result in {@code ptDst}.
      * @since 1.2
      */
     public Point2D transform(Point2D ptSrc, Point2D ptDst) {
         if (ptDst == null) {
             if (ptSrc instanceof Point2D.Double) {

@@ -2924,26 +2924,26 @@
         /* NOTREACHED */
     }
 
     /**
      * Transforms an array of point objects by this transform.
-     * If any element of the <code>ptDst</code> array is
-     * <code>null</code>, a new <code>Point2D</code> object is allocated
+     * If any element of the {@code ptDst} array is
+     * {@code null}, a new {@code Point2D} object is allocated
      * and stored into that element before storing the results of the
      * transformation.
      * <p>
      * Note that this method does not take any precautions to
-     * avoid problems caused by storing results into <code>Point2D</code>
+     * avoid problems caused by storing results into {@code Point2D}
      * objects that will be used as the source for calculations
      * further down the source array.
-     * This method does guarantee that if a specified <code>Point2D</code>
+     * This method does guarantee that if a specified {@code Point2D}
      * object is both the source and destination for the same single point
      * transform operation then the results will not be stored until
      * the calculations are complete to avoid storing the results on
      * top of the operands.
-     * If, however, the destination <code>Point2D</code> object for one
-     * operation is the same object as the source <code>Point2D</code>
+     * If, however, the destination {@code Point2D} object for one
+     * operation is the same object as the source {@code Point2D}
      * object for another operation further down the source array then
      * the original coordinates in that point are overwritten before
      * they can be converted.
      * @param ptSrc the array containing the source point objects
      * @param ptDst the array into which the transform point objects are

@@ -3015,11 +3015,11 @@
      * can be overlapping sections of the same array without affecting the
      * validity of the results.
      * This method ensures that no source coordinates are overwritten by a
      * previous operation before they can be transformed.
      * The coordinates are stored in the arrays starting at the specified
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source point coordinates.
      * Each point is stored as a pair of x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed point coordinates
      * are returned.  Each point is stored as a pair of x,&nbsp;y
      * coordinates.

@@ -3130,11 +3130,11 @@
      * can be overlapping sections of the same array without affecting the
      * validity of the results.
      * This method ensures that no source coordinates are
      * overwritten by a previous operation before they can be transformed.
      * The coordinates are stored in the arrays starting at the indicated
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source point coordinates.
      * Each point is stored as a pair of x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed point
      * coordinates are returned.  Each point is stored as a pair of
      * x,&nbsp;y coordinates.

@@ -3241,11 +3241,11 @@
 
     /**
      * Transforms an array of floating point coordinates by this transform
      * and stores the results into an array of doubles.
      * The coordinates are stored in the arrays starting at the specified
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source point coordinates.
      * Each point is stored as a pair of x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed point coordinates
      * are returned.  Each point is stored as a pair of x,&nbsp;y
      * coordinates.

@@ -3337,11 +3337,11 @@
 
     /**
      * Transforms an array of double precision coordinates by this transform
      * and stores the results into an array of floats.
      * The coordinates are stored in the arrays starting at the specified
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source point coordinates.
      * Each point is stored as a pair of x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed point
      * coordinates are returned.  Each point is stored as a pair of
      * x,&nbsp;y coordinates.

@@ -3430,23 +3430,23 @@
 
         /* NOTREACHED */
     }
 
     /**
-     * Inverse transforms the specified <code>ptSrc</code> and stores the
-     * result in <code>ptDst</code>.
-     * If <code>ptDst</code> is <code>null</code>, a new
-     * <code>Point2D</code> object is allocated and then the result of the
+     * Inverse transforms the specified {@code ptSrc} and stores the
+     * result in {@code ptDst}.
+     * If {@code ptDst} is {@code null}, a new
+     * {@code Point2D} object is allocated and then the result of the
      * transform is stored in this object.
-     * In either case, <code>ptDst</code>, which contains the transformed
+     * In either case, {@code ptDst}, which contains the transformed
      * point, is returned for convenience.
-     * If <code>ptSrc</code> and <code>ptDst</code> are the same
+     * If {@code ptSrc} and {@code ptDst} are the same
      * object, the input point is correctly overwritten with the
      * transformed point.
      * @param ptSrc the point to be inverse transformed
      * @param ptDst the resulting transformed point
-     * @return <code>ptDst</code>, which contains the result of the
+     * @return {@code ptDst}, which contains the result of the
      * inverse transform.
      * @exception NoninvertibleTransformException  if the matrix cannot be
      *                                         inverted.
      * @since 1.2
      */

@@ -3519,11 +3519,11 @@
      * can be overlapping sections of the same array without affecting the
      * validity of the results.
      * This method ensures that no source coordinates are
      * overwritten by a previous operation before they can be transformed.
      * The coordinates are stored in the arrays starting at the specified
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source point coordinates.
      * Each point is stored as a pair of x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed point
      * coordinates are returned.  Each point is stored as a pair of
      * x,&nbsp;y coordinates.

@@ -3655,30 +3655,30 @@
         /* NOTREACHED */
     }
 
     /**
      * Transforms the relative distance vector specified by
-     * <code>ptSrc</code> and stores the result in <code>ptDst</code>.
+     * {@code ptSrc} and stores the result in {@code ptDst}.
      * A relative distance vector is transformed without applying the
      * translation components of the affine transformation matrix
      * using the following equations:
      * <pre>
      *  [  x' ]   [  m00  m01 (m02) ] [  x  ]   [ m00x + m01y ]
      *  [  y' ] = [  m10  m11 (m12) ] [  y  ] = [ m10x + m11y ]
      *  [ (1) ]   [  (0)  (0) ( 1 ) ] [ (1) ]   [     (1)     ]
      * </pre>
-     * If <code>ptDst</code> is <code>null</code>, a new
-     * <code>Point2D</code> object is allocated and then the result of the
+     * If {@code ptDst} is {@code null}, a new
+     * {@code Point2D} object is allocated and then the result of the
      * transform is stored in this object.
-     * In either case, <code>ptDst</code>, which contains the
+     * In either case, {@code ptDst}, which contains the
      * transformed point, is returned for convenience.
-     * If <code>ptSrc</code> and <code>ptDst</code> are the same object,
+     * If {@code ptSrc} and {@code ptDst} are the same object,
      * the input point is correctly overwritten with the transformed
      * point.
      * @param ptSrc the distance vector to be delta transformed
      * @param ptDst the resulting transformed distance vector
-     * @return <code>ptDst</code>, which contains the result of the
+     * @return {@code ptDst}, which contains the result of the
      * transformation.
      * @since 1.2
      */
     public Point2D deltaTransform(Point2D ptSrc, Point2D ptDst) {
         if (ptDst == null) {

@@ -3732,11 +3732,11 @@
      * can be overlapping sections of the same array without affecting the
      * validity of the results.
      * This method ensures that no source coordinates are
      * overwritten by a previous operation before they can be transformed.
      * The coordinates are stored in the arrays starting at the indicated
-     * offset in the order <code>[x0, y0, x1, y1, ..., xn, yn]</code>.
+     * offset in the order {@code [x0, y0, x1, y1, ..., xn, yn]}.
      * @param srcPts the array containing the source distance vectors.
      * Each vector is stored as a pair of relative x,&nbsp;y coordinates.
      * @param dstPts the array into which the transformed distance vectors
      * are returned.  Each vector is stored as a pair of relative
      * x,&nbsp;y coordinates.

@@ -3812,16 +3812,16 @@
         /* NOTREACHED */
     }
 
     /**
      * Returns a new {@link Shape} object defined by the geometry of the
-     * specified <code>Shape</code> after it has been transformed by
+     * specified {@code Shape} after it has been transformed by
      * this transform.
-     * @param pSrc the specified <code>Shape</code> object to be
+     * @param pSrc the specified {@code Shape} object to be
      * transformed by this transform.
-     * @return a new <code>Shape</code> object that defines the geometry
-     * of the transformed <code>Shape</code>, or null if {@code pSrc} is null.
+     * @return a new {@code Shape} object that defines the geometry
+     * of the transformed {@code Shape}, or null if {@code pSrc} is null.
      * @since 1.2
      */
     public Shape createTransformedShape(Shape pSrc) {
         if (pSrc == null) {
             return null;

@@ -3834,14 +3834,14 @@
     private static double _matround(double matval) {
         return Math.rint(matval * 1E15) / 1E15;
     }
 
     /**
-     * Returns a <code>String</code> that represents the value of this
+     * Returns a {@code String} that represents the value of this
      * {@link Object}.
-     * @return a <code>String</code> representing the value of this
-     * <code>Object</code>.
+     * @return a {@code String} representing the value of this
+     * {@code Object}.
      * @since 1.2
      */
     public String toString() {
         return ("AffineTransform[["
                 + _matround(m00) + ", "

@@ -3851,24 +3851,24 @@
                 + _matround(m11) + ", "
                 + _matround(m12) + "]]");
     }
 
     /**
-     * Returns <code>true</code> if this <code>AffineTransform</code> is
+     * Returns {@code true} if this {@code AffineTransform} is
      * an identity transform.
-     * @return <code>true</code> if this <code>AffineTransform</code> is
-     * an identity transform; <code>false</code> otherwise.
+     * @return {@code true} if this {@code AffineTransform} is
+     * an identity transform; {@code false} otherwise.
      * @since 1.2
      */
     public boolean isIdentity() {
         return (state == APPLY_IDENTITY || (getType() == TYPE_IDENTITY));
     }
 
     /**
-     * Returns a copy of this <code>AffineTransform</code> object.
-     * @return an <code>Object</code> that is a copy of this
-     * <code>AffineTransform</code> object.
+     * Returns a copy of this {@code AffineTransform} object.
+     * @return an {@code Object} that is a copy of this
+     * {@code AffineTransform} object.
      * @since 1.2
      */
     public Object clone() {
         try {
             return super.clone();

@@ -3892,17 +3892,17 @@
         bits = bits * 31 + Double.doubleToLongBits(m12);
         return (((int) bits) ^ ((int) (bits >> 32)));
     }
 
     /**
-     * Returns <code>true</code> if this <code>AffineTransform</code>
+     * Returns {@code true} if this {@code AffineTransform}
      * represents the same affine coordinate transform as the specified
      * argument.
-     * @param obj the <code>Object</code> to test for equality with this
-     * <code>AffineTransform</code>
-     * @return <code>true</code> if <code>obj</code> equals this
-     * <code>AffineTransform</code> object; <code>false</code> otherwise.
+     * @param obj the {@code Object} to test for equality with this
+     * {@code AffineTransform}
+     * @return {@code true} if {@code obj} equals this
+     * {@code AffineTransform} object; {@code false} otherwise.
      * @since 1.2
      */
     public boolean equals(Object obj) {
         if (!(obj instanceof AffineTransform)) {
             return false;
< prev index next >