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