| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* AffineTransform.java -- transform coordinates between two 2-D spaces 2: Copyright (C) 2000, 2001, 2002, 2004 Free Software Foundation 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.awt.geom; 40: 41: import java.awt.Shape; 42: import java.io.IOException; 43: import java.io.ObjectInputStream; 44: import java.io.Serializable; 45: 46: /** 47: * This class represents an affine transformation between two coordinate 48: * spaces in 2 dimensions. Such a transform preserves the "straightness" 49: * and "parallelness" of lines. The transform is built from a sequence of 50: * translations, scales, flips, rotations, and shears. 51: * 52: * <p>The transformation can be represented using matrix math on a 3x3 array. 53: * Given (x,y), the transformation (x',y') can be found by: 54: * <pre> 55: * [ x'] [ m00 m01 m02 ] [ x ] [ m00*x + m01*y + m02 ] 56: * [ y'] = [ m10 m11 m12 ] [ y ] = [ m10*x + m11*y + m12 ] 57: * [ 1 ] [ 0 0 1 ] [ 1 ] [ 1 ] 58: * </pre> 59: * The bottom row of the matrix is constant, so a transform can be uniquely 60: * represented (as in {@link #toString()}) by 61: * "[[m00, m01, m02], [m10, m11, m12]]". 62: * 63: * @author Tom Tromey (tromey@cygnus.com) 64: * @author Eric Blake (ebb9@email.byu.edu) 65: * @since 1.2 66: * @status partially updated to 1.4, still has some problems 67: */ 68: public class AffineTransform implements Cloneable, Serializable 69: { 70: /** 71: * Compatible with JDK 1.2+. 72: */ 73: private static final long serialVersionUID = 1330973210523860834L; 74: 75: /** 76: * The transformation is the identity (x' = x, y' = y). All other transforms 77: * have either a combination of the appropriate transform flag bits for 78: * their type, or the type GENERAL_TRANSFORM. 79: * 80: * @see #TYPE_TRANSLATION 81: * @see #TYPE_UNIFORM_SCALE 82: * @see #TYPE_GENERAL_SCALE 83: * @see #TYPE_FLIP 84: * @see #TYPE_QUADRANT_ROTATION 85: * @see #TYPE_GENERAL_ROTATION 86: * @see #TYPE_GENERAL_TRANSFORM 87: * @see #getType() 88: */ 89: public static final int TYPE_IDENTITY = 0; 90: 91: /** 92: * The transformation includes a translation - shifting in the x or y 93: * direction without changing length or angles. 94: * 95: * @see #TYPE_IDENTITY 96: * @see #TYPE_UNIFORM_SCALE 97: * @see #TYPE_GENERAL_SCALE 98: * @see #TYPE_FLIP 99: * @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
| GNU Classpath (0.95) |