001/* AffineTransform.java -- transform coordinates between two 2-D spaces
002   Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package java.awt.geom;
040
041import java.awt.Shape;
042import java.io.IOException;
043import java.io.ObjectInputStream;
044import 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 */
068public 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