001    /* AffineTransform.java -- transform coordinates between two 2-D spaces
002       Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package java.awt.geom;
040    
041    import java.awt.Shape;
042    import java.io.IOException;
043    import java.io.ObjectInputStream;
044    import java.io.Serializable;
045    
046    /**
047     * This class represents an affine transformation between two coordinate
048     * spaces in 2 dimensions. Such a transform preserves the "straightness"
049     * and "parallelness" of lines. The transform is built from a sequence of
050     * translations, scales, flips, rotations, and shears.
051     *
052     * <p>The transformation can be represented using matrix math on a 3x3 array.
053     * Given (x,y), the transformation (x',y') can be found by:
054     * <pre>
055     * [ x']   [ m00 m01 m02 ] [ x ]   [ m00*x + m01*y + m02 ]
056     * [ y'] = [ m10 m11 m12 ] [ y ] = [ m10*x + m11*y + m12 ]
057     * [ 1 ]   [  0   0   1  ] [ 1 ]   [          1          ]
058     * </pre>
059     * The bottom row of the matrix is constant, so a transform can be uniquely
060     * represented (as in {@link #toString()}) by 
061     * "[[m00, m01, m02], [m10, m11, m12]]".
062     *
063     * @author Tom Tromey (tromey@cygnus.com)
064     * @author Eric Blake (ebb9@email.byu.edu)
065     * @since 1.2
066     * @status partially updated to 1.4, still has some problems
067     */
068    public class AffineTransform implements Cloneable, Serializable
069    {
070      /**
071       * Compatible with JDK 1.2+.
072       */
073      private static final long serialVersionUID = 1330973210523860834L;
074    
075      /**
076       * The transformation is the identity (x' = x, y' = y). All other transforms
077       * have either a combination of the appropriate transform flag bits for
078       * their type, or the type GENERAL_TRANSFORM.
079       *
080       * @see #TYPE_TRANSLATION
081       * @see #TYPE_UNIFORM_SCALE
082       * @see #TYPE_GENERAL_SCALE
083       * @see #TYPE_FLIP
084       * @see #TYPE_QUADRANT_ROTATION
085       * @see #TYPE_GENERAL_ROTATION
086       * @see #TYPE_GENERAL_TRANSFORM
087       * @see #getType()
088       */
089      public static final int TYPE_IDENTITY = 0;
090    
091      /**
092       * The transformation includes a translation - shifting in the x or y
093       * direction without changing length or angles.
094       *
095       * @see #TYPE_IDENTITY
096       * @see #TYPE_UNIFORM_SCALE
097       * @see #TYPE_GENERAL_SCALE
098       * @see #TYPE_FLIP
099       * @see #TYPE_QUADRANT_ROTATION
100       * @see #TYPE_GENERAL_ROTATION
101       * @see #TYPE_GENERAL_TRANSFORM
102       * @see #getType()
103       */
104      public static final int TYPE_TRANSLATION = 1;
105    
106      /**
107       * The transformation includes a uniform scale - length is scaled in both
108       * the x and y directions by the same amount, without affecting angles.
109       * This is mutually exclusive with TYPE_GENERAL_SCALE.
110       *
111       * @see #TYPE_IDENTITY
112       * @see #TYPE_TRANSLATION
113       * @see #TYPE_GENERAL_SCALE
114       * @see #TYPE_FLIP
115       * @see #TYPE_QUADRANT_ROTATION
116       * @see #TYPE_GENERAL_ROTATION
117       * @see #TYPE_GENERAL_TRANSFORM
118       * @see #TYPE_MASK_SCALE
119       * @see #getType()
120       */
121      public static final int TYPE_UNIFORM_SCALE = 2;
122    
123      /**
124       * The transformation includes a general scale - length is scaled in either
125       * or both the x and y directions, but by different amounts; without
126       * affecting angles. This is mutually exclusive with TYPE_UNIFORM_SCALE.
127       *
128       * @see #TYPE_IDENTITY
129       * @see #TYPE_TRANSLATION
130       * @see #TYPE_UNIFORM_SCALE
131       * @see #TYPE_FLIP
132       * @see #TYPE_QUADRANT_ROTATION
133       * @see #TYPE_GENERAL_ROTATION
134       * @see #TYPE_GENERAL_TRANSFORM
135       * @see #TYPE_MASK_SCALE
136       * @see #getType()
137       */
138      public static final int TYPE_GENERAL_SCALE = 4;
139    
140      /**
141       * This constant checks if either variety of scale transform is performed.
142       *
143       * @see #TYPE_UNIFORM_SCALE
144       * @see #TYPE_GENERAL_SCALE
145       */
146      public static final int TYPE_MASK_SCALE = 6;
147    
148      /**
149       * The transformation includes a flip about an axis, swapping between
150       * right-handed and left-handed coordinate systems. In a right-handed
151       * system, the positive x-axis rotates counter-clockwise to the positive
152       * y-axis; in a left-handed system it rotates clockwise.
153       *
154       * @see #TYPE_IDENTITY
155       * @see #TYPE_TRANSLATION
156       * @see #TYPE_UNIFORM_SCALE
157       * @see #TYPE_GENERAL_SCALE
158       * @see #TYPE_QUADRANT_ROTATION
159       * @see #TYPE_GENERAL_ROTATION
160       * @see #TYPE_GENERAL_TRANSFORM
161       * @see #getType()
162       */
163      public static final int TYPE_FLIP = 64;
164    
165      /**
166       * The transformation includes a rotation of a multiple of 90 degrees (PI/2
167       * radians). Angles are rotated, but length is preserved. This is mutually
168       * exclusive with TYPE_GENERAL_ROTATION.
169       *
170       * @see #TYPE_IDENTITY
171       * @see #TYPE_TRANSLATION
172       * @see #TYPE_UNIFORM_SCALE
173       * @see #TYPE_GENERAL_SCALE
174       * @see #TYPE_FLIP
175       * @see #TYPE_GENERAL_ROTATION
176       * @see #TYPE_GENERAL_TRANSFORM
177       * @see #TYPE_MASK_ROTATION
178       * @see #getType()
179       */
180      public static final int TYPE_QUADRANT_ROTATION = 8;
181    
182      /**
183       * The transformation includes a rotation by an arbitrary angle. Angles are
184       * rotated, but length is preserved. This is mutually exclusive with
185       * TYPE_QUADRANT_ROTATION.
186       *
187       * @see #TYPE_IDENTITY
188       * @see #TYPE_TRANSLATION
189       * @see #TYPE_UNIFORM_SCALE
190       * @see #TYPE_GENERAL_SCALE
191       * @see #TYPE_FLIP
192       * @see #TYPE_QUADRANT_ROTATION
193       * @see #TYPE_GENERAL_TRANSFORM
194       * @see #TYPE_MASK_ROTATION
195       * @see #getType()
196       */
197      public static final int TYPE_GENERAL_ROTATION = 16;
198    
199      /**
200       * This constant checks if either variety of rotation is performed.
201       *
202       * @see #TYPE_QUADRANT_ROTATION
203       * @see #TYPE_GENERAL_ROTATION
204       */
205      public static final int TYPE_MASK_ROTATION = 24;
206    
207      /**
208       * The transformation is an arbitrary conversion of coordinates which
209       * could not be decomposed into the other TYPEs.
210       *
211       * @see #TYPE_IDENTITY
212       * @see #TYPE_TRANSLATION
213       * @see #TYPE_UNIFORM_SCALE
214       * @see #TYPE_GENERAL_SCALE
215       * @see #TYPE_FLIP
216       * @see #TYPE_QUADRANT_ROTATION
217       * @see #TYPE_GENERAL_ROTATION
218       * @see #getType()
219       */
220      public static final int TYPE_GENERAL_TRANSFORM = 32;
221    
222      /**
223       * The X coordinate scaling element of the transform matrix.
224       *
225       * @serial matrix[0,0]
226       */
227      private double m00;
228    
229      /**
230       * The Y coordinate shearing element of the transform matrix.
231       *
232       * @serial matrix[1,0]
233       */
234      private double m10;
235    
236      /**
237       * The X coordinate shearing element of the transform matrix.
238       *
239       * @serial matrix[0,1]
240       */
241      private double m01;
242    
243      /**
244       * The Y coordinate scaling element of the transform matrix.
245       *
246       * @serial matrix[1,1]
247       */
248      private double m11;
249    
250      /**
251       * The X coordinate translation element of the transform matrix.
252       *
253       * @serial matrix[0,2]
254       */
255      private double m02;
256    
257      /**
258       * The Y coordinate translation element of the transform matrix.
259       *
260       * @serial matrix[1,2]
261       */
262      private double m12;
263    
264      /** The type of this transform. */
265      private transient int type;
266    
267      /**
268       * Construct a new identity transform:
269       * <pre>
270       * [ 1 0 0 ]
271       * [ 0 1 0 ]
272       * [ 0 0 1 ]
273       * </pre>
274       */
275      public AffineTransform()
276      {
277        m00 = m11 = 1;
278      }
279    
280      /**
281       * Create a new transform which copies the given one.
282       *
283       * @param tx the transform to copy
284       * @throws NullPointerException if tx is null
285       */
286      public AffineTransform(AffineTransform tx)
287      {
288        setTransform(tx);
289      }
290    
291      /**
292       * Construct a transform with the given matrix entries:
293       * <pre>
294       * [ m00 m01 m02 ]
295       * [ m10 m11 m12 ]
296       * [  0   0   1  ]
297       * </pre>
298       *
299       * @param m00 the x scaling component
300       * @param m10 the y shearing component
301       * @param m01 the x shearing component
302       * @param m11 the y scaling component
303       * @param m02 the x translation component
304       * @param m12 the y translation component
305       */
306      public AffineTransform(float m00, float m10,
307                             float m01, float m11,
308                             float m02, float m12)
309      {
310        this.m00 = m00;
311        this.m10 = m10;
312        this.m01 = m01;
313        this.m11 = m11;
314        this.m02 = m02;
315        this.m12 = m12;
316        updateType();
317      }
318    
319      /**
320       * Construct a transform from a sequence of float entries. The array must
321       * have at least 4 entries, which has a translation factor of 0; or 6
322       * entries, for specifying all parameters:
323       * <pre>
324       * [ f[0] f[2] (f[4]) ]
325       * [ f[1] f[3] (f[5]) ]
326       * [  0     0    1    ]
327       * </pre>
328       *
329       * @param f the matrix to copy from, with at least 4 (6) entries
330       * @throws NullPointerException if f is null
331       * @throws ArrayIndexOutOfBoundsException if f is too small
332       */
333      public AffineTransform(float[] f)
334      {
335        m00 = f[0];
336        m10 = f[1];
337        m01 = f[2];
338        m11 = f[3];
339        if (f.length >= 6)
340          {
341            m02 = f[4];
342            m12 = f[5];
343          }
344        updateType();
345      }
346    
347      /**
348       * Construct a transform with the given matrix entries:
349       * <pre>
350       * [ m00 m01 m02 ]
351       * [ m10 m11 m12 ]
352       * [  0   0   1  ]
353       * </pre>
354       *
355       * @param m00 the x scaling component
356       * @param m10 the y shearing component
357       * @param m01 the x shearing component
358       * @param m11 the y scaling component
359       * @param m02 the x translation component
360       * @param m12 the y translation component
361       */
362      public AffineTransform(double m00, double m10, double m01,
363                             double m11, double m02, double m12)
364      {
365        this.m00 = m00;
366        this.m10 = m10;
367        this.m01 = m01;
368        this.m11 = m11;
369        this.m02 = m02;
370        this.m12 = m12;
371        updateType();
372      }
373    
374      /**
375       * Construct a transform from a sequence of double entries. The array must
376       * have at least 4 entries, which has a translation factor of 0; or 6
377       * entries, for specifying all parameters:
378       * <pre>
379       * [ d[0] d[2] (d[4]) ]
380       * [ d[1] d[3] (d[5]) ]
381       * [  0     0    1    ]
382       * </pre>
383       *
384       * @param d the matrix to copy from, with at least 4 (6) entries
385       * @throws NullPointerException if d is null
386       * @throws ArrayIndexOutOfBoundsException if d is too small
387       */
388      public AffineTransform(double[] d)
389      {
390        m00 = d[0];
391        m10 = d[1];
392        m01 = d[2];
393        m11 = d[3];
394        if (d.length >= 6)
395          {
396            m02 = d[4];
397            m12 = d[5];
398          }
399        updateType();
400      }
401    
402      /**
403       * Returns a translation transform:
404       * <pre>
405       * [ 1 0 tx ]
406       * [ 0 1 ty ]
407       * [ 0 0 1  ]
408       * </pre>
409       *
410       * @param tx the x translation distance
411       * @param ty the y translation distance
412       * @return the translating transform
413       */
414      public static AffineTransform getTranslateInstance(double tx, double ty)
415      {
416        AffineTransform t = new AffineTransform();
417        t.m02 = tx;
418        t.m12 = ty;
419        t.type = (tx == 0 && ty == 0) ? TYPE_UNIFORM_SCALE : TYPE_TRANSLATION;
420        return t;
421      }
422    
423      /**
424       * Returns a rotation transform. A positive angle (in radians) rotates
425       * the positive x-axis to the positive y-axis:
426       * <pre>
427       * [ cos(theta) -sin(theta) 0 ]
428       * [ sin(theta)  cos(theta) 0 ]
429       * [     0           0      1 ]
430       * </pre>
431       *
432       * @param theta the rotation angle
433       * @return the rotating transform
434       */
435      public static AffineTransform getRotateInstance(double theta)
436      {
437        AffineTransform t = new AffineTransform();
438        t.setToRotation(theta);
439        return t;
440      }
441    
442      /**
443       * Returns a rotation transform about a point. A positive angle (in radians)
444       * rotates the positive x-axis to the positive y-axis. This is the same
445       * as calling:
446       * <pre>
447       * AffineTransform tx = new AffineTransform();
448       * tx.setToTranslation(x, y);
449       * tx.rotate(theta);
450       * tx.translate(-x, -y);
451       * </pre>
452       *
453       * <p>The resulting matrix is: 
454       * <pre>
455       * [ cos(theta) -sin(theta) x-x*cos+y*sin ]
456       * [ sin(theta)  cos(theta) y-x*sin-y*cos ]
457       * [     0           0            1       ]
458       * </pre>
459       *
460       * @param theta the rotation angle
461       * @param x the x coordinate of the pivot point
462       * @param y the y coordinate of the pivot point
463       * @return the rotating transform
464       */
465      public static AffineTransform getRotateInstance(double theta,
466                                                      double x, double y)
467      {
468        AffineTransform t = new AffineTransform();
469        t.setToTranslation(x, y);
470        t.rotate(theta);
471        t.translate(-x, -y);
472        return t;
473      }
474    
475      /**
476       * Returns a scaling transform:
477       * <pre>
478       * [ sx 0  0 ]
479       * [ 0  sy 0 ]
480       * [ 0  0  1 ]
481       * </pre>
482       *
483       * @param sx the x scaling factor
484       * @param sy the y scaling factor
485       * @return the scaling transform
486       */
487      public static AffineTransform getScaleInstance(double sx, double sy)
488      {
489        AffineTransform t = new AffineTransform();
490        t.setToScale(sx, sy);
491        return t;
492      }
493    
494      /**
495       * Returns a shearing transform (points are shifted in the x direction based
496       * on a factor of their y coordinate, and in the y direction as a factor of
497       * their x coordinate):
498       * <pre>
499       * [  1  shx 0 ]
500       * [ shy  1  0 ]
501       * [  0   0  1 ]
502       * </pre>
503       *
504       * @param shx the x shearing factor
505       * @param shy the y shearing factor
506       * @return the shearing transform
507       */
508      public static AffineTransform getShearInstance(double shx, double shy)
509      {
510        AffineTransform t = new AffineTransform();
511        t.setToShear(shx, shy);
512        return t;
513      }
514    
515      /**
516       * Returns the type of this transform. The result is always valid, although
517       * it may not be the simplest interpretation (in other words, there are
518       * sequences of transforms which reduce to something simpler, which this
519       * does not always detect). The result is either TYPE_GENERAL_TRANSFORM,
520       * or a bit-wise combination of TYPE_TRANSLATION, the mutually exclusive
521       * TYPE_*_ROTATIONs, and the mutually exclusive TYPE_*_SCALEs.
522       *
523       * @return The type.
524       * 
525       * @see #TYPE_IDENTITY
526       * @see #TYPE_TRANSLATION
527       * @see #TYPE_UNIFORM_SCALE
528       * @see #TYPE_GENERAL_SCALE
529       * @see #TYPE_QUADRANT_ROTATION
530       * @see #TYPE_GENERAL_ROTATION
531       * @see #TYPE_GENERAL_TRANSFORM
532       */
533      public int getType()
534      {
535        return type;
536      }
537    
538      /**
539       * Return the determinant of this transform matrix. If the determinant is
540       * non-zero, the transform is invertible; otherwise operations which require
541       * an inverse throw a NoninvertibleTransformException. A result very near
542       * zero, due to rounding errors, may indicate that inversion results do not
543       * carry enough precision to be meaningful.
544       *
545       * <p>If this is a uniform scale transformation, the determinant also
546       * represents the squared value of the scale. Otherwise, it carries little
547       * additional meaning. The determinant is calculated as:
548       * <pre>
549       * | m00 m01 m02 |
550       * | m10 m11 m12 | = m00 * m11 - m01 * m10
551       * |  0   0   1  |
552       * </pre>
553       *
554       * @return the determinant
555       * @see #createInverse()
556       */
557      public double getDeterminant()
558      {
559        return m00 * m11 - m01 * m10;
560      }
561    
562      /**
563       * Return the matrix of values used in this transform. If the matrix has
564       * fewer than 6 entries, only the scale and shear factors are returned;
565       * otherwise the translation factors are copied as well. The resulting
566       * values are:
567       * <pre>
568       * [ d[0] d[2] (d[4]) ]
569       * [ d[1] d[3] (d[5]) ]
570       * [  0     0    1    ]
571       * </pre>
572       *
573       * @param d the matrix to store the results into; with 4 (6) entries
574       * @throws NullPointerException if d is null
575       * @throws ArrayIndexOutOfBoundsException if d is too small
576       */
577      public void getMatrix(double[] d)
578      {
579        d[0] = m00;
580        d[1] = m10;
581        d[2] = m01;
582        d[3] = m11;
583        if (d.length >= 6)
584          {
585            d[4] = m02;
586            d[5] = m12;
587          }
588      }
589    
590      /**
591       * Returns the X coordinate scaling factor of the matrix.
592       *
593       * @return m00
594       * @see #getMatrix(double[])
595       */
596      public double getScaleX()
597      {
598        return m00;
599      }
600    
601      /**
602       * Returns the Y coordinate scaling factor of the matrix.
603       *
604       * @return m11
605       * @see #getMatrix(double[])
606       */
607      public double getScaleY()
608      {
609        return m11;
610      }
611    
612      /**
613       * Returns the X coordinate shearing factor of the matrix.
614       *
615       * @return m01
616       * @see #getMatrix(double[])
617       */
618      public double getShearX()
619      {
620        return m01;
621      }
622    
623      /**
624       * Returns the Y coordinate shearing factor of the matrix.
625       *
626       * @return m10
627       * @see #getMatrix(double[])
628       */
629      public double getShearY()
630      {
631        return m10;
632      }
633    
634      /**
635       * Returns the X coordinate translation factor of the matrix.
636       *
637       * @return m02
638       * @see #getMatrix(double[])
639       */
640      public double getTranslateX()
641      {
642        return m02;
643      }
644    
645      /**
646       * Returns the Y coordinate translation factor of the matrix.
647       *
648       * @return m12
649       * @see #getMatrix(double[])
650       */
651      public double getTranslateY()
652      {
653        return m12;
654      }
655    
656      /**
657       * Concatenate a translation onto this transform. This is equivalent, but
658       * more efficient than
659       * <code>concatenate(AffineTransform.getTranslateInstance(tx, ty))</code>.
660       *
661       * @param tx the x translation distance
662       * @param ty the y translation distance
663       * @see #getTranslateInstance(double, double)
664       * @see #concatenate(AffineTransform)
665       */
666      public void translate(double tx, double ty)
667      {
668        m02 += tx * m00 + ty * m01;
669        m12 += tx * m10 + ty * m11;
670        updateType();
671      }
672    
673      /**
674       * Concatenate a rotation onto this transform. This is equivalent, but
675       * more efficient than
676       * <code>concatenate(AffineTransform.getRotateInstance(theta))</code>.
677       *
678       * @param theta the rotation angle
679       * @see #getRotateInstance(double)
680       * @see #concatenate(AffineTransform)
681       */
682      public void rotate(double theta)
683      {
684        double c = Math.cos(theta);
685        double s = Math.sin(theta);
686        double n00 = m00 *  c + m01 * s;
687        double n01 = m00 * -s + m01 * c;
688        double n10 = m10 *  c + m11 * s;
689        double n11 = m10 * -s + m11 * c;
690        m00 = n00;
691        m01 = n01;
692        m10 = n10;
693        m11 = n11;
694        updateType();
695      }
696    
697      /**
698       * Concatenate a rotation about a point onto this transform. This is
699       * equivalent, but more efficient than
700       * <code>concatenate(AffineTransform.getRotateInstance(theta, x, y))</code>.
701       *
702       * @param theta the rotation angle
703       * @param x the x coordinate of the pivot point
704       * @param y the y coordinate of the pivot point
705       * @see #getRotateInstance(double, double, double)
706       * @see #concatenate(AffineTransform)
707       */
708      public void rotate(double theta, double x, double y)
709      {
710        translate(x, y);
711        rotate(theta);
712        translate(-x, -y);
713      }
714    
715      /**
716       * Concatenate a scale onto this transform. This is equivalent, but more
717       * efficient than
718       * <code>concatenate(AffineTransform.getScaleInstance(sx, sy))</code>.
719       *
720       * @param sx the x scaling factor
721       * @param sy the y scaling factor
722       * @see #getScaleInstance(double, double)
723       * @see #concatenate(AffineTransform)
724       */
725      public void scale(double sx, double sy)
726      {
727        m00 *= sx;
728        m01 *= sy;
729        m10 *= sx;
730        m11 *= sy;
731        updateType();
732      }
733    
734      /**
735       * Concatenate a shearing onto this transform. This is equivalent, but more
736       * efficient than
737       * <code>concatenate(AffineTransform.getShearInstance(sx, sy))</code>.
738       *
739       * @param shx the x shearing factor
740       * @param shy the y shearing factor
741       * @see #getShearInstance(double, double)
742       * @see #concatenate(AffineTransform)
743       */
744      public void shear(double shx, double shy)
745      {
746        double n00 = m00 + (shy * m01);
747        double n01 = m01 + (shx * m00);
748        double n10 = m10 + (shy * m11);
749        double n11 = m11 + (shx * m10);
750        m00 = n00;
751        m01 = n01;
752        m10 = n10;
753        m11 = n11;
754        updateType();
755      }
756    
757      /**
758       * Reset this transform to the identity (no transformation):
759       * <pre>
760       * [ 1 0 0 ]
761       * [ 0 1 0 ]
762       * [ 0 0 1 ]
763       * </pre>
764       */
765      public void setToIdentity()
766      {
767        m00 = m11 = 1;
768        m01 = m02 = m10 = m12 = 0;
769        type = TYPE_IDENTITY;
770      }
771    
772      /**
773       * Set this transform to a translation:
774       * <pre>
775       * [ 1 0 tx ]
776       * [ 0 1 ty ]
777       * [ 0 0 1  ]
778       * </pre>
779       *
780       * @param tx the x translation distance
781       * @param ty the y translation distance
782       */
783      public void setToTranslation(double tx, double ty)
784      {
785        m00 = m11 = 1;
786        m01 = m10 = 0;
787        m02 = tx;
788        m12 = ty;
789        type = (tx == 0 && ty == 0) ? TYPE_UNIFORM_SCALE : TYPE_TRANSLATION;
790      }
791    
792      /**
793       * Set this transform to a rotation. A positive angle (in radians) rotates
794       * the positive x-axis to the positive y-axis:
795       * <pre>
796       * [ cos(theta) -sin(theta) 0 ]
797       * [ sin(theta)  cos(theta) 0 ]
798       * [     0           0      1 ]
799       * </pre>
800       *
801       * @param theta the rotation angle
802       */
803      public void setToRotation(double theta)
804      {
805        double c = Math.cos(theta);
806        double s = Math.sin(theta);
807        m00 = c;
808        m01 = -s;
809        m02 = 0;
810        m10 = s;
811        m11 = c;
812        m12 = 0;
813        type = (c == 1 ? TYPE_IDENTITY
814                : c == 0 || c == -1 ? TYPE_QUADRANT_ROTATION
815                : TYPE_GENERAL_ROTATION);
816      }
817    
818      /**
819       * Set this transform to a rotation about a point. A positive angle (in
820       * radians) rotates the positive x-axis to the positive y-axis. This is the
821       * same as calling:
822       * <pre>
823       * tx.setToTranslation(x, y);
824       * tx.rotate(theta);
825       * tx.translate(-x, -y);
826       * </pre>
827       *
828       * <p>The resulting matrix is: 
829       * <pre>
830       * [ cos(theta) -sin(theta) x-x*cos+y*sin ]
831       * [ sin(theta)  cos(theta) y-x*sin-y*cos ]
832       * [     0           0            1       ]
833       * </pre>
834       *
835       * @param theta the rotation angle
836       * @param x the x coordinate of the pivot point
837       * @param y the y coordinate of the pivot point
838       */
839      public void setToRotation(double theta, double x, double y)
840      {
841        double c = Math.cos(theta);
842        double s = Math.sin(theta);
843        m00 = c;
844        m01 = -s;
845        m02 = x - x * c + y * s;
846        m10 = s;
847        m11 = c;
848        m12 = y - x * s - y * c;
849        updateType();
850      }
851    
852      /**
853       * Set this transform to a scale:
854       * <pre>
855       * [ sx 0  0 ]
856       * [ 0  sy 0 ]
857       * [ 0  0  1 ]
858       * </pre>
859       *
860       * @param sx the x scaling factor
861       * @param sy the y scaling factor
862       */
863      public void setToScale(double sx, double sy)
864      {
865        m00 = sx;
866        m01 = m02 = m10 = m12 = 0;
867        m11 = sy;
868        type = (sx != sy ? TYPE_GENERAL_SCALE
869                : sx == 1 ? TYPE_IDENTITY : TYPE_UNIFORM_SCALE);
870      }
871    
872      /**
873       * Set this transform to a shear (points are shifted in the x direction based
874       * on a factor of their y coordinate, and in the y direction as a factor of
875       * their x coordinate):
876       * <pre>
877       * [  1  shx 0 ]
878       * [ shy  1  0 ]
879       * [  0   0  1 ]
880       * </pre>
881       *
882       * @param shx the x shearing factor
883       * @param shy the y shearing factor
884       */
885      public void setToShear(double shx, double shy)
886      {
887        m00 = m11 = 1;
888        m01 = shx;
889        m10 = shy;
890        m02 = m12 = 0;
891        updateType();
892      }
893    
894      /**
895       * Set this transform to a copy of the given one.
896       *
897       * @param tx the transform to copy
898       * @throws NullPointerException if tx is null
899       */
900      public void setTransform(AffineTransform tx)
901      {
902        m00 = tx.m00;
903        m01 = tx.m01;
904        m02 = tx.m02;
905        m10 = tx.m10;
906        m11 = tx.m11;
907        m12 = tx.m12;
908        type = tx.type;
909      }
910    
911      /**
912       * Set this transform to the given values:
913       * <pre>
914       * [ m00 m01 m02 ]
915       * [ m10 m11 m12 ]
916       * [  0   0   1  ]
917       * </pre>
918       *
919       * @param m00 the x scaling component
920       * @param m10 the y shearing component
921       * @param m01 the x shearing component
922       * @param m11 the y scaling component
923       * @param m02 the x translation component
924       * @param m12 the y translation component
925       */
926      public void setTransform(double m00, double m10, double m01,
927                               double m11, double m02, double m12)
928      {
929        this.m00 = m00;
930        this.m10 = m10;
931        this.m01 = m01;
932        this.m11 = m11;
933        this.m02 = m02;
934        this.m12 = m12;
935        updateType();
936      }
937    
938      /**
939       * Set this transform to the result of performing the original version of
940       * this followed by tx. This is commonly used when chaining transformations
941       * from one space to another. In matrix form:
942       * <pre>
943       * [ this ] = [ this ] x [ tx ]
944       * </pre>
945       *
946       * @param tx the transform to concatenate
947       * @throws NullPointerException if tx is null
948       * @see #preConcatenate(AffineTransform)
949       */
950      public void concatenate(AffineTransform tx)
951      {
952        double n00 = m00 * tx.m00 + m01 * tx.m10;
953        double n01 = m00 * tx.m01 + m01 * tx.m11;
954        double n02 = m00 * tx.m02 + m01 * tx.m12 + m02;
955        double n10 = m10 * tx.m00 + m11 * tx.m10;
956        double n11 = m10 * tx.m01 + m11 * tx.m11;
957        double n12 = m10 * tx.m02 + m11 * tx.m12 + m12;
958        m00 = n00;
959        m01 = n01;
960        m02 = n02;
961        m10 = n10;
962        m11 = n11;
963        m12 = n12;
964        updateType();
965      }
966    
967      /**
968       * Set this transform to the result of performing tx followed by the
969       * original version of this. This is less common than normal concatenation,
970       * but can still be used to chain transformations from one space to another.
971       * In matrix form:
972       * <pre>
973       * [ this ] = [ tx ] x [ this ]
974       * </pre>
975       *
976       * @param tx the transform to concatenate
977       * @throws NullPointerException if tx is null
978       * @see #concatenate(AffineTransform)
979       */
980      public void preConcatenate(AffineTransform tx)
981      {
982        double n00 = tx.m00 * m00 + tx.m01 * m10;
983        double n01 = tx.m00 * m01 + tx.m01 * m11;
984        double n02 = tx.m00 * m02 + tx.m01 * m12 + tx.m02;
985        double n10 = tx.m10 * m00 + tx.m11 * m10;
986        double n11 = tx.m10 * m01 + tx.m11 * m11;
987        double n12 = tx.m10 * m02 + tx.m11 * m12 + tx.m12;
988        m00 = n00;
989        m01 = n01;
990        m02 = n02;
991        m10 = n10;
992        m11 = n11;
993        m12 = n12;
994        updateType();
995      }
996    
997      /**
998       * Returns a transform, which if concatenated to this one, will result in
999       * the identity transform. This is useful for undoing transformations, but
1000       * is only possible if the original transform has an inverse (ie. does not
1001       * map multiple points to the same line or point). A transform exists only
1002       * if getDeterminant() has a non-zero value.
1003       *
1004       * The inverse is calculated as:
1005       * 
1006       * <pre>
1007       *
1008       * Let A be the matrix for which we want to find the inverse:
1009       *
1010       * A = [ m00 m01 m02 ]
1011       *     [ m10 m11 m12 ]
1012       *     [ 0   0   1   ] 
1013       *
1014       *
1015       *                 1    
1016       * inverse (A) =  ---   x  adjoint(A) 
1017       *                det 
1018       *
1019       *
1020       *
1021       *             =   1       [  m11  -m01   m01*m12-m02*m11  ]
1022       *                ---   x  [ -m10   m00  -m00*m12+m10*m02  ]
1023       *                det      [  0     0     m00*m11-m10*m01  ]
1024       *
1025       *
1026       *
1027       *             = [  m11/det  -m01/det   m01*m12-m02*m11/det ]
1028       *               [ -m10/det   m00/det  -m00*m12+m10*m02/det ]
1029       *               [   0           0          1               ]
1030       *
1031       *
1032       * </pre>
1033       *
1034       *
1035       *
1036       * @return a new inverse transform
1037       * @throws NoninvertibleTransformException if inversion is not possible
1038       * @see #getDeterminant()
1039       */
1040      public AffineTransform createInverse()
1041        throws NoninvertibleTransformException
1042      {
1043        double det = getDeterminant();
1044        if (det == 0)
1045          throw new NoninvertibleTransformException("can't invert transform");
1046        
1047        double im00 = m11 / det;
1048        double im10 = -m10 / det;
1049        double im01 = -m01 / det;
1050        double im11 = m00 / det;
1051        double im02 = (m01 * m12 - m02 * m11) / det;
1052        double im12 = (-m00 * m12 + m10 * m02) / det;
1053        
1054        return new AffineTransform (im00, im10, im01, im11, im02, im12);
1055      }
1056    
1057      /**
1058       * Perform this transformation on the given source point, and store the
1059       * result in the destination (creating it if necessary). It is safe for
1060       * src and dst to be the same.
1061       *
1062       * @param src the source point
1063       * @param dst the destination, or null
1064       * @return the transformation of src, in dst if it was non-null
1065       * @throws NullPointerException if src is null
1066       */
1067      public Point2D transform(Point2D src, Point2D dst)
1068      {
1069        if (dst == null)
1070          dst = new Point2D.Double();
1071        double x = src.getX();
1072        double y = src.getY();
1073        double nx = m00 * x + m01 * y + m02;
1074        double ny = m10 * x + m11 * y + m12;
1075        dst.setLocation(nx, ny);
1076        return dst;
1077      }
1078    
1079      /**
1080       * Perform this transformation on an array of points, storing the results
1081       * in another (possibly same) array. This will not create a destination
1082       * array, but will create points for the null entries of the destination.
1083       * The transformation is done sequentially. While having a single source
1084       * and destination point be the same is safe, you should be aware that
1085       * duplicate references to the same point in the source, and having the
1086       * source overlap the destination, may result in your source points changing
1087       * from a previous transform before it is their turn to be evaluated.
1088       *
1089       * @param src the array of source points
1090       * @param srcOff the starting offset into src
1091       * @param dst the array of destination points (may have null entries)
1092       * @param dstOff the starting offset into dst
1093       * @param num the number of points to transform
1094       * @throws NullPointerException if src or dst is null, or src has null
1095       *         entries
1096       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1097       * @throws ArrayStoreException if new points are incompatible with dst
1098       */
1099      public void transform(Point2D[] src, int srcOff,
1100                            Point2D[] dst, int dstOff, int num)
1101      {
1102        while (--num >= 0)
1103          dst[dstOff] = transform(src[srcOff++], dst[dstOff++]);
1104      }
1105    
1106      /**
1107       * Perform this transformation on an array of points, in (x,y) pairs,
1108       * storing the results in another (possibly same) array. This will not
1109       * create a destination array. All sources are copied before the
1110       * transformation, so that no result will overwrite a point that has not yet
1111       * been evaluated.
1112       *
1113       * @param srcPts the array of source points
1114       * @param srcOff the starting offset into src
1115       * @param dstPts the array of destination points
1116       * @param dstOff the starting offset into dst
1117       * @param num the number of points to transform
1118       * @throws NullPointerException if src or dst is null
1119       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1120       */
1121      public void transform(float[] srcPts, int srcOff,
1122                            float[] dstPts, int dstOff, int num)
1123      {
1124        if (srcPts == dstPts && dstOff > srcOff
1125            && num > 1 && srcOff + 2 * num > dstOff)
1126          {
1127            float[] f = new float[2 * num];
1128            System.arraycopy(srcPts, srcOff, f, 0, 2 * num);
1129            srcPts = f;
1130          }
1131        while (--num >= 0)
1132          {
1133            float x = srcPts[srcOff++];
1134            float y = srcPts[srcOff++];
1135            dstPts[dstOff++] = (float) (m00 * x + m01 * y + m02);
1136            dstPts[dstOff++] = (float) (m10 * x + m11 * y + m12);
1137          }
1138      }
1139    
1140      /**
1141       * Perform this transformation on an array of points, in (x,y) pairs,
1142       * storing the results in another (possibly same) array. This will not
1143       * create a destination array. All sources are copied before the
1144       * transformation, so that no result will overwrite a point that has not yet
1145       * been evaluated.
1146       *
1147       * @param srcPts the array of source points
1148       * @param srcOff the starting offset into src
1149       * @param dstPts the array of destination points
1150       * @param dstOff the starting offset into dst
1151       * @param num the number of points to transform
1152       * @throws NullPointerException if src or dst is null
1153       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1154       */
1155      public void transform(double[] srcPts, int srcOff,
1156                            double[] dstPts, int dstOff, int num)
1157      {
1158        if (srcPts == dstPts && dstOff > srcOff
1159            && num > 1 && srcOff + 2 * num > dstOff)
1160          {
1161            double[] d = new double[2 * num];
1162            System.arraycopy(srcPts, srcOff, d, 0, 2 * num);
1163            srcPts = d;
1164          }
1165        while (--num >= 0)
1166          {
1167            double x = srcPts[srcOff++];
1168            double y = srcPts[srcOff++];
1169            dstPts[dstOff++] = m00 * x + m01 * y + m02;
1170            dstPts[dstOff++] = m10 * x + m11 * y + m12;
1171          }
1172      }
1173    
1174      /**
1175       * Perform this transformation on an array of points, in (x,y) pairs,
1176       * storing the results in another array. This will not create a destination
1177       * array.
1178       *
1179       * @param srcPts the array of source points
1180       * @param srcOff the starting offset into src
1181       * @param dstPts the array of destination points
1182       * @param dstOff the starting offset into dst
1183       * @param num the number of points to transform
1184       * @throws NullPointerException if src or dst is null
1185       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1186       */
1187      public void transform(float[] srcPts, int srcOff,
1188                            double[] dstPts, int dstOff, int num)
1189      {
1190        while (--num >= 0)
1191          {
1192            float x = srcPts[srcOff++];
1193            float y = srcPts[srcOff++];
1194            dstPts[dstOff++] = m00 * x + m01 * y + m02;
1195            dstPts[dstOff++] = m10 * x + m11 * y + m12;
1196          }
1197      }
1198    
1199      /**
1200       * Perform this transformation on an array of points, in (x,y) pairs,
1201       * storing the results in another array. This will not create a destination
1202       * array.
1203       *
1204       * @param srcPts the array of source points
1205       * @param srcOff the starting offset into src
1206       * @param dstPts the array of destination points
1207       * @param dstOff the starting offset into dst
1208       * @param num the number of points to transform
1209       * @throws NullPointerException if src or dst is null
1210       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1211       */
1212      public void transform(double[] srcPts, int srcOff,
1213                            float[] dstPts, int dstOff, int num)
1214      {
1215        while (--num >= 0)
1216          {
1217            double x = srcPts[srcOff++];
1218            double y = srcPts[srcOff++];
1219            dstPts[dstOff++] = (float) (m00 * x + m01 * y + m02);
1220            dstPts[dstOff++] = (float) (m10 * x + m11 * y + m12);
1221          }
1222      }
1223    
1224      /**
1225       * Perform the inverse of this transformation on the given source point,
1226       * and store the result in the destination (creating it if necessary). It
1227       * is safe for src and dst to be the same.
1228       *
1229       * @param src the source point
1230       * @param dst the destination, or null
1231       * @return the inverse transformation of src, in dst if it was non-null
1232       * @throws NullPointerException if src is null
1233       * @throws NoninvertibleTransformException if the inverse does not exist
1234       * @see #getDeterminant()
1235       */
1236      public Point2D inverseTransform(Point2D src, Point2D dst)
1237        throws NoninvertibleTransformException
1238      {
1239        return createInverse().transform(src, dst);
1240      }
1241    
1242      /**
1243       * Perform the inverse of this transformation on an array of points, in
1244       * (x,y) pairs, storing the results in another (possibly same) array. This
1245       * will not create a destination array. All sources are copied before the
1246       * transformation, so that no result will overwrite a point that has not yet
1247       * been evaluated.
1248       *
1249       * @param srcPts the array of source points
1250       * @param srcOff the starting offset into src
1251       * @param dstPts the array of destination points
1252       * @param dstOff the starting offset into dst
1253       * @param num the number of points to transform
1254       * @throws NullPointerException if src or dst is null
1255       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1256       * @throws NoninvertibleTransformException if the inverse does not exist
1257       * @see #getDeterminant()
1258       */
1259      public void inverseTransform(double[] srcPts, int srcOff,
1260                                   double[] dstPts, int dstOff, int num)
1261        throws NoninvertibleTransformException
1262      {
1263        createInverse().transform(srcPts, srcOff, dstPts, dstOff, num);
1264      }
1265    
1266      /**
1267       * Perform this transformation, less any translation, on the given source
1268       * point, and store the result in the destination (creating it if
1269       * necessary). It is safe for src and dst to be the same. The reduced
1270       * transform is equivalent to:
1271       * <pre>
1272       * [ x' ] = [ m00 m01 ] [ x ] = [ m00 * x + m01 * y ]
1273       * [ y' ]   [ m10 m11 ] [ y ] = [ m10 * x + m11 * y ]
1274       * </pre>
1275       *
1276       * @param src the source point
1277       * @param dst the destination, or null
1278       * @return the delta transformation of src, in dst if it was non-null
1279       * @throws NullPointerException if src is null
1280       */
1281      public Point2D deltaTransform(Point2D src, Point2D dst)
1282      {
1283        if (dst == null)
1284          dst = new Point2D.Double();
1285        double x = src.getX();
1286        double y = src.getY();
1287        double nx = m00 * x + m01 * y;
1288        double ny = m10 * x + m11 * y;
1289        dst.setLocation(nx, ny);
1290        return dst;
1291      }
1292    
1293      /**
1294       * Perform this transformation, less any translation, on an array of points,
1295       * in (x,y) pairs, storing the results in another (possibly same) array.
1296       * This will not create a destination array. All sources are copied before
1297       * the transformation, so that no result will overwrite a point that has
1298       * not yet been evaluated. The reduced transform is equivalent to:
1299       * <pre>
1300       * [ x' ] = [ m00 m01 ] [ x ] = [ m00 * x + m01 * y ]
1301       * [ y' ]   [ m10 m11 ] [ y ] = [ m10 * x + m11 * y ]
1302       * </pre>
1303       *
1304       * @param srcPts the array of source points
1305       * @param srcOff the starting offset into src
1306       * @param dstPts the array of destination points
1307       * @param dstOff the starting offset into dst
1308       * @param num the number of points to transform
1309       * @throws NullPointerException if src or dst is null
1310       * @throws ArrayIndexOutOfBoundsException if array bounds are exceeded
1311       */
1312      public void deltaTransform(double[] srcPts, int srcOff,
1313                                  double[] dstPts, int dstOff,
1314                                  int num)
1315      {
1316        if (srcPts == dstPts && dstOff > srcOff
1317            && num > 1 && srcOff + 2 * num > dstOff)
1318          {
1319            double[] d = new double[2 * num];
1320            System.arraycopy(srcPts, srcOff, d, 0, 2 * num);
1321            srcPts = d;
1322          }
1323        while (--num >= 0)
1324          {
1325            double x = srcPts[srcOff++];
1326            double y = srcPts[srcOff++];
1327            dstPts[dstOff++] = m00 * x + m01 * y;
1328            dstPts[dstOff++] = m10 * x + m11 * y;
1329          }
1330      }
1331    
1332      /**
1333       * Return a new Shape, based on the given one, where the path of the shape
1334       * has been transformed by this transform. Notice that this uses GeneralPath,
1335       * which only stores points in float precision.
1336       *
1337       * @param src the shape source to transform
1338       * @return the shape, transformed by this, <code>null</code> if src is 
1339       * <code>null</code>.
1340       * @see GeneralPath#transform(AffineTransform)
1341       */
1342      public Shape createTransformedShape(Shape src)
1343      {
1344        if(src == null) 
1345          return null;
1346        GeneralPath p = new GeneralPath(src);
1347        p.transform(this);
1348        return p;
1349      }
1350    
1351      /**
1352       * Returns a string representation of the transform, in the format:
1353       * <code>"AffineTransform[[" + m00 + ", " + m01 + ", " + m02 + "], ["
1354       *   + m10 + ", " + m11 + ", " + m12 + "]]"</code>.
1355       *
1356       * @return the string representation
1357       */
1358      public String toString()
1359      {
1360        return "AffineTransform[[" + m00 + ", " + m01 + ", " + m02 + "], ["
1361          + m10 + ", " + m11 + ", " + m12 + "]]";
1362      }
1363    
1364      /**
1365       * Tests if this transformation is the identity:
1366       * <pre>
1367       * [ 1 0 0 ]
1368       * [ 0 1 0 ]
1369       * [ 0 0 1 ]
1370       * </pre>
1371       *
1372       * @return true if this is the identity transform
1373       */
1374      public boolean isIdentity()
1375      {
1376        // Rather than rely on type, check explicitly.
1377        return (m00 == 1 && m01 == 0 && m02 == 0
1378                && m10 == 0 && m11 == 1 && m12 == 0);
1379      }
1380    
1381      /**
1382       * Create a new transform of the same run-time type, with the same
1383       * transforming properties as this one.
1384       *
1385       * @return the clone
1386       */
1387      public Object clone()
1388      {
1389        try
1390          {
1391            return super.clone();
1392          }
1393        catch (CloneNotSupportedException e)
1394          {
1395            throw (Error) new InternalError().initCause(e); // Impossible
1396          }
1397      }
1398    
1399      /**
1400       * Return the hashcode for this transformation. The formula is not
1401       * documented, but appears to be the same as:
1402       * <pre>
1403       * long l = Double.doubleToLongBits(getScaleX());
1404       * l = l * 31 + Double.doubleToLongBits(getShearX());
1405       * l = l * 31 + Double.doubleToLongBits(getTranslateX());
1406       * l = l * 31 + Double.doubleToLongBits(getShearY());
1407       * l = l * 31 + Double.doubleToLongBits(getScaleY());
1408       * l = l * 31 + Double.doubleToLongBits(getTranslateY());
1409       * return (int) ((l >> 32) ^ l);
1410       * </pre>
1411       *
1412       * @return the hashcode
1413       */
1414      public int hashCode()
1415      {
1416        long l = Double.doubleToLongBits(m00); 
1417        l = l * 31 + Double.doubleToLongBits(m01); 
1418        l = l * 31 + Double.doubleToLongBits(m02); 
1419        l = l * 31 + Double.doubleToLongBits(m10); 
1420        l = l * 31 + Double.doubleToLongBits(m11); 
1421        l = l * 31 + Double.doubleToLongBits(m12); 
1422        return (int) ((l >> 32) ^ l);
1423      }
1424    
1425      /**
1426       * Compares two transforms for equality. This returns true if they have the
1427       * same matrix values.
1428       *
1429       * @param obj the transform to compare
1430       * @return true if it is equal
1431       */
1432      public boolean equals(Object obj)
1433      {
1434        if (! (obj instanceof AffineTransform))
1435          return false;
1436        AffineTransform t = (AffineTransform) obj;
1437        return (m00 == t.m00 && m01 == t.m01 && m02 == t.m02
1438                && m10 == t.m10 && m11 == t.m11 && m12 == t.m12);
1439      }
1440    
1441      /**
1442       * Helper to decode the type from the matrix. This is not guaranteed
1443       * to find the optimal type, but at least it will be valid.
1444       */
1445      private void updateType()
1446      {
1447        double det = getDeterminant();
1448        if (det == 0)
1449          {
1450            type = TYPE_GENERAL_TRANSFORM;
1451            return;
1452          }
1453        // Scale (includes rotation by PI) or translation.
1454        if (m01 == 0 && m10 == 0)
1455          {
1456            if (m00 == m11)
1457              type = m00 == 1 ? TYPE_IDENTITY : TYPE_UNIFORM_SCALE;
1458            else
1459              type = TYPE_GENERAL_SCALE;
1460            if (m02 != 0 || m12 != 0)
1461              type |= TYPE_TRANSLATION;
1462          }
1463        // Rotation.
1464        else if (m00 == m11 && m01 == -m10)
1465          {
1466            type = m00 == 0 ? TYPE_QUADRANT_ROTATION : TYPE_GENERAL_ROTATION;
1467            if (det != 1)
1468              type |= TYPE_UNIFORM_SCALE;
1469            if (m02 != 0 || m12 != 0)
1470              type |= TYPE_TRANSLATION;
1471          }
1472        else
1473          type = TYPE_GENERAL_TRANSFORM;
1474      }
1475    
1476      /**
1477       * Reads a transform from an object stream.
1478       *
1479       * @param s the stream to read from
1480       * @throws ClassNotFoundException if there is a problem deserializing
1481       * @throws IOException if there is a problem deserializing
1482       */
1483      private void readObject(ObjectInputStream s)
1484        throws ClassNotFoundException, IOException
1485      {
1486        s.defaultReadObject();
1487        updateType();
1488      }
1489    } // class AffineTransform