1: /* Arc2D.java -- represents an arc in 2-D space 2: Copyright (C) 2002, 2003, 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: package java.awt.geom; 39: 40: import java.util.NoSuchElementException; 41: 42: 43: /** 44: * This class represents all arcs (segments of an ellipse in 2-D space). The 45: * arcs are defined by starting angle and extent (arc length) in degrees, as 46: * opposed to radians (like the rest of Java), and can be open, chorded, or 47: * wedge shaped. The angles are skewed according to the ellipse, so that 45 48: * degrees always points to the upper right corner (positive x, negative y) 49: * of the bounding rectangle. A positive extent draws a counterclockwise arc, 50: * and while the angle can be any value, the path iterator only traverses the 51: * first 360 degrees. Storage is up to the subclasses. 52: * 53: * @author Eric Blake (ebb9@email.byu.edu) 54: * @author Sven de Marothy (sven@physto.se) 55: * @since 1.2 56: */ 57: public abstract class Arc2D extends RectangularShape 58: { 59: /** 60: * An open arc, with no segment connecting the endpoints. This type of 61: * arc still contains the same points as a chorded version. 62: */ 63: public static final int OPEN = 0; 64: 65: /** 66: * A closed arc with a single segment connecting the endpoints (a chord). 67: */ 68: public static final int CHORD = 1; 69: 70: /** 71: * A closed arc with two segments, one from each endpoint, meeting at the 72: * center of the ellipse. 73: */ 74: public static final int PIE = 2; 75: 76: /** The closure type of this arc. This is package-private to avoid an 77: * accessor method. */ 78: int type; 79: 80: /** 81: * Create a new arc, with the specified closure type. 82: * 83: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. 84: * @throws IllegalArgumentException if type is invalid 85: */ 86: protected Arc2D(int type) 87: { 88: if (type < OPEN || type > PIE) 89: throw new IllegalArgumentException(); 90: this.type = type; 91: } 92: 93: /** 94: * Get the starting angle of the arc in degrees. 95: * 96: * @return the starting angle 97: * @see #setAngleStart(double) 98: */ 99: public abstract double getAngleStart(); 100: 101: /** 102: * Get the extent angle of the arc in degrees. 103: * 104: * @return the extent angle 105: * @see #setAngleExtent(double) 106: */ 107: public abstract double getAngleExtent(); 108: 109: /** 110: * Return the closure type of the arc. 111: * 112: * @return the closure type 113: * @see #OPEN 114: * @see #CHORD 115: * @see #PIE 116: * @see #setArcType(int) 117: */ 118: public int getArcType() 119: { 120: return type; 121: } 122: 123: /** 124: * Returns the starting point of the arc. 125: * 126: * @return the start point 127: */ 128: public Point2D getStartPoint() 129: { 130: double angle = Math.toRadians(getAngleStart()); 131: double rx = getWidth() / 2; 132: double ry = getHeight() / 2; 133: double x = getX() + rx + rx * Math.cos(angle); 134: double y = getY() + ry - ry * Math.sin(angle); 135: return new Point2D.Double(x, y); 136: } 137: 138: /** 139: * Returns the ending point of the arc. 140: * 141: * @return the end point 142: */ 143: public Point2D getEndPoint() 144: { 145: double angle = Math.toRadians(getAngleStart() + getAngleExtent()); 146: double rx = getWidth() / 2; 147: double ry = getHeight() / 2; 148: double x = getX() + rx + rx * Math.cos(angle); 149: double y = getY() + ry - ry * Math.sin(angle); 150: return new Point2D.Double(x, y); 151: } 152: 153: /** 154: * Set the parameters of the arc. The angles are in degrees, and a positive 155: * extent sweeps counterclockwise (from the positive x-axis to the negative 156: * y-axis). 157: * 158: * @param x the new x coordinate of the upper left of the bounding box 159: * @param y the new y coordinate of the upper left of the bounding box 160: * @param w the new width of the bounding box 161: * @param h the new height of the bounding box 162: * @param start the start angle, in degrees 163: * @param extent the arc extent, in degrees 164: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 165: * @throws IllegalArgumentException if type is invalid 166: */ 167: public abstract void setArc(double x, double y, double w, double h, 168: double start, double extent, int type); 169: 170: /** 171: * Set the parameters of the arc. The angles are in degrees, and a positive 172: * extent sweeps counterclockwise (from the positive x-axis to the negative 173: * y-axis). 174: * 175: * @param p the upper left point of the bounding box 176: * @param d the dimensions of the bounding box 177: * @param start the start angle, in degrees 178: * @param extent the arc extent, in degrees 179: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 180: * @throws IllegalArgumentException if type is invalid 181: * @throws NullPointerException if p or d is null 182: */ 183: public void setArc(Point2D p, Dimension2D d, double start, double extent, 184: int type) 185: { 186: setArc(p.getX(), p.getY(), d.getWidth(), d.getHeight(), start, extent, type); 187: } 188: 189: /** 190: * Set the parameters of the arc. The angles are in degrees, and a positive 191: * extent sweeps counterclockwise (from the positive x-axis to the negative 192: * y-axis). 193: * 194: * @param r the new bounding box 195: * @param start the start angle, in degrees 196: * @param extent the arc extent, in degrees 197: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 198: * @throws IllegalArgumentException if type is invalid 199: * @throws NullPointerException if r is null 200: */ 201: public void setArc(Rectangle2D r, double start, double extent, int type) 202: { 203: setArc(r.getX(), r.getY(), r.getWidth(), r.getHeight(), start, extent, type); 204: } 205: 206: /** 207: * Set the parameters of the arc from the given one. 208: * 209: * @param a the arc to copy 210: * @throws NullPointerException if a is null 211: */ 212: public void setArc(Arc2D a) 213: { 214: setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(), a.getAngleStart(), 215: a.getAngleExtent(), a.getArcType()); 216: } 217: 218: /** 219: * Set the parameters of the arc. The angles are in degrees, and a positive 220: * extent sweeps counterclockwise (from the positive x-axis to the negative 221: * y-axis). This controls the center point and radius, so the arc will be 222: * circular. 223: * 224: * @param x the x coordinate of the center of the circle 225: * @param y the y coordinate of the center of the circle 226: * @param r the radius of the circle 227: * @param start the start angle, in degrees 228: * @param extent the arc extent, in degrees 229: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 230: * @throws IllegalArgumentException if type is invalid 231: */ 232: public void setArcByCenter(double x, double y, double r, double start, 233: double extent, int type) 234: { 235: setArc(x - r, y - r, r + r, r + r, start, extent, type); 236: } 237: 238: /** 239: * Sets the parameters of the arc by finding the tangents of two lines, and 240: * using the specified radius. The arc will be circular, will begin on the 241: * tangent point of the line extending from p1 to p2, and will end on the 242: * tangent point of the line extending from p2 to p3. 243: * 244: * XXX What happens if the points are colinear, or the radius negative? 245: * 246: * @param p1 the first point 247: * @param p2 the tangent line intersection point 248: * @param p3 the third point 249: * @param r the radius of the arc 250: * @throws NullPointerException if any point is null 251: */ 252: public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3, double r) 253: { 254: if ((p2.getX() - p1.getX()) * (p3.getY() - p1.getY()) 255: - (p3.getX() - p1.getX()) * (p2.getY() - p1.getY()) > 0) 256: { 257: Point2D p = p3; 258: p3 = p1; 259: p1 = p; 260: } 261: 262: // normalized tangent vectors 263: double dx1 = (p1.getX() - p2.getX()) / p1.distance(p2); 264: double dy1 = (p1.getY() - p2.getY()) / p1.distance(p2); 265: double dx2 = (p2.getX() - p3.getX()) / p3.distance(p2); 266: double dy2 = (p2.getY() - p3.getY()) / p3.distance(p2); 267: double theta1 = Math.atan2(dx1, dy1); 268: double theta2 = Math.atan2(dx2, dy2); 269: 270: double dx = r * Math.cos(theta2) - r * Math.cos(theta1); 271: double dy = -r * Math.sin(theta2) + r * Math.sin(theta1); 272: 273: if (theta1 < 0) 274: theta1 += 2 * Math.PI; 275: if (theta2 < 0) 276: theta2 += 2 * Math.PI; 277: if (theta2 < theta1) 278: theta2 += 2 * Math.PI; 279: 280: // Vectors of the lines, not normalized, note we change 281: // the direction of line 2. 282: dx1 = p1.getX() - p2.getX(); 283: dy1 = p1.getY() - p2.getY(); 284: dx2 = p3.getX() - p2.getX(); 285: dy2 = p3.getY() - p2.getY(); 286: 287: // Calculate the tangent point to the second line 288: double t2 = -(dx1 * dy - dy1 * dx) / (dx2 * dy1 - dx1 * dy2); 289: double x2 = t2 * (p3.getX() - p2.getX()) + p2.getX(); 290: double y2 = t2 * (p3.getY() - p2.getY()) + p2.getY(); 291: 292: // calculate the center point 293: double x = x2 - r * Math.cos(theta2); 294: double y = y2 + r * Math.sin(theta2); 295: 296: setArc(x - r, y - r, 2 * r, 2 * r, Math.toDegrees(theta1), 297: Math.toDegrees(theta2 - theta1), getArcType()); 298: } 299: 300: /** 301: * Set the start, in degrees. 302: * 303: * @param start the new start angle 304: * @see #getAngleStart() 305: */ 306: public abstract void setAngleStart(double start); 307: 308: /** 309: * Set the extent, in degrees. 310: * 311: * @param extent the new extent angle 312: * @see #getAngleExtent() 313: */ 314: public abstract void setAngleExtent(double extent); 315: 316: /** 317: * Sets the starting angle to the angle of the given point relative to 318: * the center of the arc. The extent remains constant; in other words, 319: * this rotates the arc. 320: * 321: * @param p the new start point 322: * @throws NullPointerException if p is null 323: * @see #getStartPoint() 324: * @see #getAngleStart() 325: */ 326: public void setAngleStart(Point2D p) 327: { 328: // Normalize. 329: double x = p.getX() - (getX() + getWidth() / 2); 330: double y = p.getY() - (getY() + getHeight() / 2); 331: setAngleStart(Math.toDegrees(Math.atan2(-y, x))); 332: } 333: 334: /** 335: * Sets the starting and extent angles to those of the given points 336: * relative to the center of the arc. The arc will be non-empty, and will 337: * extend counterclockwise. 338: * 339: * @param x1 the first x coordinate 340: * @param y1 the first y coordinate 341: * @param x2 the second x coordinate 342: * @param y2 the second y coordinate 343: * @see #setAngleStart(Point2D) 344: */ 345: public void setAngles(double x1, double y1, double x2, double y2) 346: { 347: // Normalize the points. 348: double mx = getX(); 349: double my = getY(); 350: double mw = getWidth(); 351: double mh = getHeight(); 352: x1 = x1 - (mx + mw / 2); 353: y1 = y1 - (my + mh / 2); 354: x2 = x2 - (mx + mw / 2); 355: y2 = y2 - (my + mh / 2); 356: double start = Math.toDegrees(Math.atan2(-y1, x1)); 357: double extent = Math.toDegrees(Math.atan2(-y2, x2)) - start; 358: if (extent < 0) 359: extent += 360; 360: setAngleStart(start); 361: setAngleExtent(extent); 362: } 363: 364: /** 365: * Sets the starting and extent angles to those of the given points 366: * relative to the center of the arc. The arc will be non-empty, and will 367: * extend counterclockwise. 368: * 369: * @param p1 the first point 370: * @param p2 the second point 371: * @throws NullPointerException if either point is null 372: * @see #setAngleStart(Point2D) 373: */ 374: public void setAngles(Point2D p1, Point2D p2) 375: { 376: setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY()); 377: } 378: 379: /** 380: * Set the closure type of this arc. 381: * 382: * @param type one of {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 383: * @throws IllegalArgumentException if type is invalid 384: * @see #getArcType() 385: */ 386: public void setArcType(int type) 387: { 388: if (type < OPEN || type > PIE) 389: throw new IllegalArgumentException(); 390: this.type = type; 391: } 392: 393: /** 394: * Sets the location and bounds of the ellipse of which this arc is a part. 395: * 396: * @param x the new x coordinate 397: * @param y the new y coordinate 398: * @param w the new width 399: * @param h the new height 400: * @see #getFrame() 401: */ 402: public void setFrame(double x, double y, double w, double h) 403: { 404: setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type); 405: } 406: 407: /** 408: * Gets the bounds of the arc. This is much tighter than 409: * <code>getBounds</code>, as it takes into consideration the start and 410: * end angles, and the center point of a pie wedge, rather than just the 411: * overall ellipse. 412: * 413: * @return the bounds of the arc 414: * @see #getBounds() 415: */ 416: public Rectangle2D getBounds2D() 417: { 418: double extent = getAngleExtent(); 419: if (Math.abs(extent) >= 360) 420: return makeBounds(getX(), getY(), getWidth(), getHeight()); 421: 422: // Find the minimal bounding box. This determined by its extrema, 423: // which are the center, the endpoints of the arc, and any local 424: // maximum contained by the arc. 425: double rX = getWidth() / 2; 426: double rY = getHeight() / 2; 427: double centerX = getX() + rX; 428: double centerY = getY() + rY; 429: 430: Point2D p1 = getStartPoint(); 431: Rectangle2D result = makeBounds(p1.getX(), p1.getY(), 0, 0); 432: result.add(getEndPoint()); 433: 434: if (type == PIE) 435: result.add(centerX, centerY); 436: if (containsAngle(0)) 437: result.add(centerX + rX, centerY); 438: if (containsAngle(90)) 439: result.add(centerX, centerY - rY); 440: if (containsAngle(180)) 441: result.add(centerX - rX, centerY); 442: if (containsAngle(270)) 443: result.add(centerX, centerY + rY); 444: 445: return result; 446: } 447: 448: /** 449: * Construct a bounding box in a precision appropriate for the subclass. 450: * 451: * @param x the x coordinate 452: * @param y the y coordinate 453: * @param w the width 454: * @param h the height 455: * @return the rectangle for use in getBounds2D 456: */ 457: protected abstract Rectangle2D makeBounds(double x, double y, double w, 458: double h); 459: 460: /** 461: * Tests if the given angle, in degrees, is included in the arc. 462: * All angles are normalized to be between 0 and 360 degrees. 463: * 464: * @param a the angle to test 465: * @return true if it is contained 466: */ 467: public boolean containsAngle(double a) 468: { 469: double start = getAngleStart(); 470: double extent = getAngleExtent(); 471: double end = start + extent; 472: 473: if (extent == 0) 474: return false; 475: 476: if (extent >= 360 || extent <= -360) 477: return true; 478: 479: if (extent < 0) 480: { 481: end = start; 482: start += extent; 483: } 484: 485: start %= 360; 486: while (start < 0) 487: start += 360; 488: 489: end %= 360; 490: while (end < start) 491: end += 360; 492: 493: a %= 360; 494: while (a < start) 495: a += 360; 496: 497: return a >= start && a < end; // starting angle included, ending angle not 498: } 499: 500: /** 501: * Determines if the arc contains the given point. If the bounding box 502: * is empty, then this will return false. 503: * 504: * The area considered 'inside' an arc of type OPEN is the same as the 505: * area inside an equivalent filled CHORD-type arc. The area considered 506: * 'inside' a CHORD-type arc is the same as the filled area. 507: * 508: * @param x the x coordinate to test 509: * @param y the y coordinate to test 510: * @return true if the point is inside the arc 511: */ 512: public boolean contains(double x, double y) 513: { 514: double w = getWidth(); 515: double h = getHeight(); 516: double extent = getAngleExtent(); 517: if (w <= 0 || h <= 0 || extent == 0) 518: return false; 519: 520: double mx = getX() + w / 2; 521: double my = getY() + h / 2; 522: double dx = (x - mx) * 2 / w; 523: double dy = (y - my) * 2 / h; 524: if ((dx * dx + dy * dy) >= 1.0) 525: return false; 526: 527: double angle = Math.toDegrees(Math.atan2(-dy, dx)); 528: if (getArcType() == PIE) 529: return containsAngle(angle); 530: 531: double a1 = Math.toRadians(getAngleStart()); 532: double a2 = Math.toRadians(getAngleStart() + extent); 533: double x1 = mx + getWidth() * Math.cos(a1) / 2; 534: double y1 = my - getHeight() * Math.sin(a1) / 2; 535: double x2 = mx + getWidth() * Math.cos(a2) / 2; 536: double y2 = my - getHeight() * Math.sin(a2) / 2; 537: double sgn = ((x2 - x1) * (my - y1) - (mx - x1) * (y2 - y1)) * ((x2 - x1) * (y 538: - y1) - (x - x1) * (y2 - y1)); 539: 540: if (Math.abs(extent) > 180) 541: { 542: if (containsAngle(angle)) 543: return true; 544: return sgn > 0; 545: } 546: else 547: { 548: if (! containsAngle(angle)) 549: return false; 550: return sgn < 0; 551: } 552: } 553: 554: /** 555: * Tests if a given rectangle intersects the area of the arc. 556: * 557: * For a definition of the 'inside' area, see the contains() method. 558: * @see #contains(double, double) 559: * 560: * @param x the x coordinate of the rectangle 561: * @param y the y coordinate of the rectangle 562: * @param w the width of the rectangle 563: * @param h the height of the rectangle 564: * @return true if the two shapes share common points 565: */ 566: public boolean intersects(double x, double y, double w, double h) 567: { 568: double extent = getAngleExtent(); 569: if (extent == 0) 570: return false; 571: 572: if (contains(x, y) || contains(x, y + h) || contains(x + w, y) 573: || contains(x + w, y + h)) 574: return true; 575: 576: Rectangle2D rect = new Rectangle2D.Double(x, y, w, h); 577: 578: double a = getWidth() / 2.0; 579: double b = getHeight() / 2.0; 580: 581: double mx = getX() + a; 582: double my = getY() + b; 583: double x1 = mx + a * Math.cos(Math.toRadians(getAngleStart())); 584: double y1 = my - b * Math.sin(Math.toRadians(getAngleStart())); 585: double x2 = mx + a * Math.cos(Math.toRadians(getAngleStart() + extent)); 586: double y2 = my - b * Math.sin(Math.toRadians(getAngleStart() + extent)); 587: 588: if (getArcType() != CHORD) 589: { 590: // check intersections against the pie radii 591: if (rect.intersectsLine(mx, my, x1, y1)) 592: return true; 593: if (rect.intersectsLine(mx, my, x2, y2)) 594: return true; 595: } 596: else// check the chord 597: if (rect.intersectsLine(x1, y1, x2, y2)) 598: return true; 599: 600: // Check the Arc segment against the four edges 601: double dx; 602: 603: // Check the Arc segment against the four edges 604: double dy; 605: dy = y - my; 606: dx = a * Math.sqrt(1 - ((dy * dy) / (b * b))); 607: if (! java.lang.Double.isNaN(dx)) 608: { 609: if (mx + dx >= x && mx + dx <= x + w 610: && containsAngle(Math.toDegrees(Math.atan2(-dy, dx)))) 611: return true; 612: if (mx - dx >= x && mx - dx <= x + w 613: && containsAngle(Math.toDegrees(Math.atan2(-dy, -dx)))) 614: return true; 615: } 616: dy = (y + h) - my; 617: dx = a * Math.sqrt(1 - ((dy * dy) / (b * b))); 618: if (! java.lang.Double.isNaN(dx)) 619: { 620: if (mx + dx >= x && mx + dx <= x + w 621: && containsAngle(Math.toDegrees(Math.atan2(-dy, dx)))) 622: return true; 623: if (mx - dx >= x && mx - dx <= x + w 624: && containsAngle(Math.toDegrees(Math.atan2(-dy, -dx)))) 625: return true; 626: } 627: dx = x - mx; 628: dy = b * Math.sqrt(1 - ((dx * dx) / (a * a))); 629: if (! java.lang.Double.isNaN(dy)) 630: { 631: if (my + dy >= y && my + dy <= y + h 632: && containsAngle(Math.toDegrees(Math.atan2(-dy, dx)))) 633: return true; 634: if (my - dy >= y && my - dy <= y + h 635: && containsAngle(Math.toDegrees(Math.atan2(dy, dx)))) 636: return true; 637: } 638: 639: dx = (x + w) - mx; 640: dy = b * Math.sqrt(1 - ((dx * dx) / (a * a))); 641: if (! java.lang.Double.isNaN(dy)) 642: { 643: if (my + dy >= y && my + dy <= y + h 644: && containsAngle(Math.toDegrees(Math.atan2(-dy, dx)))) 645: return true; 646: if (my - dy >= y && my - dy <= y + h 647: && containsAngle(Math.toDegrees(Math.atan2(dy, dx)))) 648: return true; 649: } 650: 651: // Check whether the arc is contained within the box 652: if (rect.contains(mx, my)) 653: return true; 654: 655: return false; 656: } 657: 658: /** 659: * Tests if a given rectangle is contained in the area of the arc. 660: * 661: * @param x the x coordinate of the rectangle 662: * @param y the y coordinate of the rectangle 663: * @param w the width of the rectangle 664: * @param h the height of the rectangle 665: * @return true if the arc contains the rectangle 666: */ 667: public boolean contains(double x, double y, double w, double h) 668: { 669: double extent = getAngleExtent(); 670: if (extent == 0) 671: return false; 672: 673: if (! (contains(x, y) && contains(x, y + h) && contains(x + w, y) 674: && contains(x + w, y + h))) 675: return false; 676: 677: Rectangle2D rect = new Rectangle2D.Double(x, y, w, h); 678: 679: double a = getWidth() / 2.0; 680: double b = getHeight() / 2.0; 681: 682: double mx = getX() + a; 683: double my = getY() + b; 684: double x1 = mx + a * Math.cos(Math.toRadians(getAngleStart())); 685: double y1 = my - b * Math.sin(Math.toRadians(getAngleStart())); 686: double x2 = mx + a * Math.cos(Math.toRadians(getAngleStart() + extent)); 687: double y2 = my - b * Math.sin(Math.toRadians(getAngleStart() + extent)); 688: if (getArcType() != CHORD) 689: { 690: // check intersections against the pie radii 691: if (rect.intersectsLine(mx, my, x1, y1)) 692: return false; 693: 694: if (rect.intersectsLine(mx, my, x2, y2)) 695: return false; 696: } 697: else if (rect.intersectsLine(x1, y1, x2, y2)) 698: return false; 699: return true; 700: } 701: 702: /** 703: * Tests if a given rectangle is contained in the area of the arc. 704: * 705: * @param r the rectangle 706: * @return true if the arc contains the rectangle 707: */ 708: public boolean contains(Rectangle2D r) 709: { 710: return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight()); 711: } 712: 713: /** 714: * Returns an iterator over this arc, with an optional transformation. 715: * This iterator is threadsafe, so future modifications to the arc do not 716: * affect the iteration. 717: * 718: * @param at the transformation, or null 719: * @return a path iterator 720: */ 721: public PathIterator getPathIterator(AffineTransform at) 722: { 723: return new ArcIterator(this, at); 724: } 725: 726: /** 727: * This class is used to iterate over an arc. Since ellipses are a subclass 728: * of arcs, this is used by Ellipse2D as well. 729: * 730: * @author Eric Blake (ebb9@email.byu.edu) 731: */ 732: static final class ArcIterator implements PathIterator 733: { 734: /** The current iteration. */ 735: private int current; 736: 737: /** The last iteration. */ 738: private final int limit; 739: 740: /** The optional transformation. */ 741: private final AffineTransform xform; 742: 743: /** The x coordinate of the bounding box. */ 744: private final double x; 745: 746: /** The y coordinate of the bounding box. */ 747: private final double y; 748: 749: /** The width of the bounding box. */ 750: private final double w; 751: 752: /** The height of the bounding box. */ 753: private final double h; 754: 755: /** The start angle, in radians (not degrees). */ 756: private final double start; 757: 758: /** The extent angle, in radians (not degrees). */ 759: private final double extent; 760: 761: /** The arc closure type. */ 762: private final int type; 763: 764: /** 765: * Construct a new iterator over an arc. 766: * 767: * @param a the arc 768: * @param xform the transform 769: */ 770: public ArcIterator(Arc2D a, AffineTransform xform) 771: { 772: this.xform = xform; 773: x = a.getX(); 774: y = a.getY(); 775: w = a.getWidth(); 776: h = a.getHeight(); 777: double start = Math.toRadians(a.getAngleStart()); 778: double extent = Math.toRadians(a.getAngleExtent()); 779: 780: this.start = start; 781: this.extent = extent; 782: 783: type = a.type; 784: if (w < 0 || h < 0) 785: limit = -1; 786: else if (extent == 0) 787: limit = type; 788: else if (Math.abs(extent) <= Math.PI / 2.0) 789: limit = type + 1; 790: else if (Math.abs(extent) <= Math.PI) 791: limit = type + 2; 792: else if (Math.abs(extent) <= 3.0 * (Math.PI / 2.0)) 793: limit = type + 3; 794: else 795: limit = type + 4; 796: } 797: 798: /** 799: * Construct a new iterator over an ellipse. 800: * 801: * @param e the ellipse 802: * @param xform the transform 803: */ 804: public ArcIterator(Ellipse2D e, AffineTransform xform) 805: { 806: this.xform = xform; 807: x = e.getX(); 808: y = e.getY(); 809: w = e.getWidth(); 810: h = e.getHeight(); 811: start = 0; 812: extent = 2 * Math.PI; 813: type = CHORD; 814: limit = (w < 0 || h < 0) ? -1 : 5; 815: } 816: 817: /** 818: * Return the winding rule. 819: * 820: * @return {@link PathIterator#WIND_NON_ZERO} 821: */ 822: public int getWindingRule() 823: { 824: return WIND_NON_ZERO; 825: } 826: 827: /** 828: * Test if the iteration is complete. 829: * 830: * @return true if more segments exist 831: */ 832: public boolean isDone() 833: { 834: return current > limit; 835: } 836: 837: /** 838: * Advance the iterator. 839: */ 840: public void next() 841: { 842: current++; 843: } 844: 845: /** 846: * Put the current segment into the array, and return the segment type. 847: * 848: * @param coords an array of 6 elements 849: * @return the segment type 850: * @throws NullPointerException if coords is null 851: * @throws ArrayIndexOutOfBoundsException if coords is too small 852: */ 853: public int currentSegment(float[] coords) 854: { 855: double[] double_coords = new double[6]; 856: int code = currentSegment(double_coords); 857: for (int i = 0; i < 6; ++i) 858: coords[i] = (float) double_coords[i]; 859: return code; 860: } 861: 862: /** 863: * Put the current segment into the array, and return the segment type. 864: * 865: * @param coords an array of 6 elements 866: * @return the segment type 867: * @throws NullPointerException if coords is null 868: * @throws ArrayIndexOutOfBoundsException if coords is too small 869: */ 870: public int currentSegment(double[] coords) 871: { 872: double rx = w / 2; 873: double ry = h / 2; 874: double xmid = x + rx; 875: double ymid = y + ry; 876: 877: if (current > limit) 878: throw new NoSuchElementException("arc iterator out of bounds"); 879: 880: if (current == 0) 881: { 882: coords[0] = xmid + rx * Math.cos(start); 883: coords[1] = ymid - ry * Math.sin(start); 884: if (xform != null) 885: xform.transform(coords, 0, coords, 0, 1); 886: return SEG_MOVETO; 887: } 888: 889: if (type != OPEN && current == limit) 890: return SEG_CLOSE; 891: 892: if ((current == limit - 1) && (type == PIE)) 893: { 894: coords[0] = xmid; 895: coords[1] = ymid; 896: if (xform != null) 897: xform.transform(coords, 0, coords, 0, 1); 898: return SEG_LINETO; 899: } 900: 901: // note that this produces a cubic approximation of the arc segment, 902: // not a true ellipsoid. there's no ellipsoid path segment code, 903: // unfortunately. the cubic approximation looks about right, though. 904: double kappa = (Math.sqrt(2.0) - 1.0) * (4.0 / 3.0); 905: double quad = (Math.PI / 2.0); 906: 907: double curr_begin; 908: double curr_extent; 909: if (extent > 0) 910: { 911: curr_begin = start + (current - 1) * quad; 912: curr_extent = Math.min((start + extent) - curr_begin, quad); 913: } 914: else 915: { 916: curr_begin = start - (current - 1) * quad; 917: curr_extent = Math.max((start + extent) - curr_begin, -quad); 918: } 919: 920: double portion_of_a_quadrant = Math.abs(curr_extent / quad); 921: 922: double x0 = xmid + rx * Math.cos(curr_begin); 923: double y0 = ymid - ry * Math.sin(curr_begin); 924: 925: double x1 = xmid + rx * Math.cos(curr_begin + curr_extent); 926: double y1 = ymid - ry * Math.sin(curr_begin + curr_extent); 927: 928: AffineTransform trans = new AffineTransform(); 929: double[] cvec = new double[2]; 930: double len = kappa * portion_of_a_quadrant; 931: double angle = curr_begin; 932: 933: // in a hypothetical "first quadrant" setting, our first control 934: // vector would be sticking up, from [1,0] to [1,kappa]. 935: // 936: // let us recall however that in java2d, y coords are upside down 937: // from what one would consider "normal" first quadrant rules, so we 938: // will *subtract* the y value of this control vector from our first 939: // point. 940: cvec[0] = 0; 941: if (extent > 0) 942: cvec[1] = len; 943: else 944: cvec[1] = -len; 945: 946: trans.scale(rx, ry); 947: trans.rotate(angle); 948: trans.transform(cvec, 0, cvec, 0, 1); 949: coords[0] = x0 + cvec[0]; 950: coords[1] = y0 - cvec[1]; 951: 952: // control vector #2 would, ideally, be sticking out and to the 953: // right, in a first quadrant arc segment. again, subtraction of y. 954: cvec[0] = 0; 955: if (extent > 0) 956: cvec[1] = -len; 957: else 958: cvec[1] = len; 959: 960: trans.rotate(curr_extent); 961: trans.transform(cvec, 0, cvec, 0, 1); 962: coords[2] = x1 + cvec[0]; 963: coords[3] = y1 - cvec[1]; 964: 965: // end point 966: coords[4] = x1; 967: coords[5] = y1; 968: 969: if (xform != null) 970: xform.transform(coords, 0, coords, 0, 3); 971: 972: return SEG_CUBICTO; 973: } 974: } // class ArcIterator 975: 976: /** 977: * This class implements an arc in double precision. 978: * 979: * @author Eric Blake (ebb9@email.byu.edu) 980: * @since 1.2 981: */ 982: public static class Double extends Arc2D 983: { 984: /** The x coordinate of the box bounding the ellipse of this arc. */ 985: public double x; 986: 987: /** The y coordinate of the box bounding the ellipse of this arc. */ 988: public double y; 989: 990: /** The width of the box bounding the ellipse of this arc. */ 991: public double width; 992: 993: /** The height of the box bounding the ellipse of this arc. */ 994: public double height; 995: 996: /** The start angle of this arc, in degrees. */ 997: public double start; 998: 999: /** The extent angle of this arc, in degrees. */ 1000: public double extent; 1001: 1002: /** 1003: * Create a new, open arc at (0,0) with 0 extent. 1004: */ 1005: public Double() 1006: { 1007: super(OPEN); 1008: } 1009: 1010: /** 1011: * Create a new arc of the given type at (0,0) with 0 extent. 1012: * 1013: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1014: * @throws IllegalArgumentException if type is invalid 1015: */ 1016: public Double(int type) 1017: { 1018: super(type); 1019: } 1020: 1021: /** 1022: * Create a new arc with the given dimensions. 1023: * 1024: * @param x the x coordinate 1025: * @param y the y coordinate 1026: * @param w the width 1027: * @param h the height 1028: * @param start the start angle, in degrees 1029: * @param extent the extent, in degrees 1030: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1031: * @throws IllegalArgumentException if type is invalid 1032: */ 1033: public Double(double x, double y, double w, double h, double start, 1034: double extent, int type) 1035: { 1036: super(type); 1037: this.x = x; 1038: this.y = y; 1039: width = w; 1040: height = h; 1041: this.start = start; 1042: this.extent = extent; 1043: } 1044: 1045: /** 1046: * Create a new arc with the given dimensions. 1047: * 1048: * @param r the bounding box 1049: * @param start the start angle, in degrees 1050: * @param extent the extent, in degrees 1051: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1052: * @throws IllegalArgumentException if type is invalid 1053: * @throws NullPointerException if r is null 1054: */ 1055: public Double(Rectangle2D r, double start, double extent, int type) 1056: { 1057: super(type); 1058: x = r.getX(); 1059: y = r.getY(); 1060: width = r.getWidth(); 1061: height = r.getHeight(); 1062: this.start = start; 1063: this.extent = extent; 1064: } 1065: 1066: /** 1067: * Return the x coordinate of the bounding box. 1068: * 1069: * @return the value of x 1070: */ 1071: public double getX() 1072: { 1073: return x; 1074: } 1075: 1076: /** 1077: * Return the y coordinate of the bounding box. 1078: * 1079: * @return the value of y 1080: */ 1081: public double getY() 1082: { 1083: return y; 1084: } 1085: 1086: /** 1087: * Return the width of the bounding box. 1088: * 1089: * @return the value of width 1090: */ 1091: public double getWidth() 1092: { 1093: return width; 1094: } 1095: 1096: /** 1097: * Return the height of the bounding box. 1098: * 1099: * @return the value of height 1100: */ 1101: public double getHeight() 1102: { 1103: return height; 1104: } 1105: 1106: /** 1107: * Return the start angle of the arc, in degrees. 1108: * 1109: * @return the value of start 1110: */ 1111: public double getAngleStart() 1112: { 1113: return start; 1114: } 1115: 1116: /** 1117: * Return the extent of the arc, in degrees. 1118: * 1119: * @return the value of extent 1120: */ 1121: public double getAngleExtent() 1122: { 1123: return extent; 1124: } 1125: 1126: /** 1127: * Tests if the arc contains points. 1128: * 1129: * @return true if the arc has no interior 1130: */ 1131: public boolean isEmpty() 1132: { 1133: return width <= 0 || height <= 0; 1134: } 1135: 1136: /** 1137: * Sets the arc to the given dimensions. 1138: * 1139: * @param x the x coordinate 1140: * @param y the y coordinate 1141: * @param w the width 1142: * @param h the height 1143: * @param start the start angle, in degrees 1144: * @param extent the extent, in degrees 1145: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1146: * @throws IllegalArgumentException if type is invalid 1147: */ 1148: public void setArc(double x, double y, double w, double h, double start, 1149: double extent, int type) 1150: { 1151: this.x = x; 1152: this.y = y; 1153: width = w; 1154: height = h; 1155: this.start = start; 1156: this.extent = extent; 1157: setArcType(type); 1158: } 1159: 1160: /** 1161: * Sets the start angle of the arc. 1162: * 1163: * @param start the new start angle 1164: */ 1165: public void setAngleStart(double start) 1166: { 1167: this.start = start; 1168: } 1169: 1170: /** 1171: * Sets the extent angle of the arc. 1172: * 1173: * @param extent the new extent angle 1174: */ 1175: public void setAngleExtent(double extent) 1176: { 1177: this.extent = extent; 1178: } 1179: 1180: /** 1181: * Creates a tight bounding box given dimensions that more precise than 1182: * the bounding box of the ellipse. 1183: * 1184: * @param x the x coordinate 1185: * @param y the y coordinate 1186: * @param w the width 1187: * @param h the height 1188: */ 1189: protected Rectangle2D makeBounds(double x, double y, double w, double h) 1190: { 1191: return new Rectangle2D.Double(x, y, w, h); 1192: } 1193: } // class Double 1194: 1195: /** 1196: * This class implements an arc in float precision. 1197: * 1198: * @author Eric Blake (ebb9@email.byu.edu) 1199: * @since 1.2 1200: */ 1201: public static class Float extends Arc2D 1202: { 1203: /** The x coordinate of the box bounding the ellipse of this arc. */ 1204: public float x; 1205: 1206: /** The y coordinate of the box bounding the ellipse of this arc. */ 1207: public float y; 1208: 1209: /** The width of the box bounding the ellipse of this arc. */ 1210: public float width; 1211: 1212: /** The height of the box bounding the ellipse of this arc. */ 1213: public float height; 1214: 1215: /** The start angle of this arc, in degrees. */ 1216: public float start; 1217: 1218: /** The extent angle of this arc, in degrees. */ 1219: public float extent; 1220: 1221: /** 1222: * Create a new, open arc at (0,0) with 0 extent. 1223: */ 1224: public Float() 1225: { 1226: super(OPEN); 1227: } 1228: 1229: /** 1230: * Create a new arc of the given type at (0,0) with 0 extent. 1231: * 1232: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1233: * @throws IllegalArgumentException if type is invalid 1234: */ 1235: public Float(int type) 1236: { 1237: super(type); 1238: } 1239: 1240: /** 1241: * Create a new arc with the given dimensions. 1242: * 1243: * @param x the x coordinate 1244: * @param y the y coordinate 1245: * @param w the width 1246: * @param h the height 1247: * @param start the start angle, in degrees 1248: * @param extent the extent, in degrees 1249: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1250: * @throws IllegalArgumentException if type is invalid 1251: */ 1252: public Float(float x, float y, float w, float h, float start, 1253: float extent, int type) 1254: { 1255: super(type); 1256: this.x = x; 1257: this.y = y; 1258: width = w; 1259: height = h; 1260: this.start = start; 1261: this.extent = extent; 1262: } 1263: 1264: /** 1265: * Create a new arc with the given dimensions. 1266: * 1267: * @param r the bounding box 1268: * @param start the start angle, in degrees 1269: * @param extent the extent, in degrees 1270: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1271: * @throws IllegalArgumentException if type is invalid 1272: * @throws NullPointerException if r is null 1273: */ 1274: public Float(Rectangle2D r, float start, float extent, int type) 1275: { 1276: super(type); 1277: x = (float) r.getX(); 1278: y = (float) r.getY(); 1279: width = (float) r.getWidth(); 1280: height = (float) r.getHeight(); 1281: this.start = start; 1282: this.extent = (float) extent; 1283: } 1284: 1285: /** 1286: * Return the x coordinate of the bounding box. 1287: * 1288: * @return the value of x 1289: */ 1290: public double getX() 1291: { 1292: return x; 1293: } 1294: 1295: /** 1296: * Return the y coordinate of the bounding box. 1297: * 1298: * @return the value of y 1299: */ 1300: public double getY() 1301: { 1302: return y; 1303: } 1304: 1305: /** 1306: * Return the width of the bounding box. 1307: * 1308: * @return the value of width 1309: */ 1310: public double getWidth() 1311: { 1312: return width; 1313: } 1314: 1315: /** 1316: * Return the height of the bounding box. 1317: * 1318: * @return the value of height 1319: */ 1320: public double getHeight() 1321: { 1322: return height; 1323: } 1324: 1325: /** 1326: * Return the start angle of the arc, in degrees. 1327: * 1328: * @return the value of start 1329: */ 1330: public double getAngleStart() 1331: { 1332: return start; 1333: } 1334: 1335: /** 1336: * Return the extent of the arc, in degrees. 1337: * 1338: * @return the value of extent 1339: */ 1340: public double getAngleExtent() 1341: { 1342: return extent; 1343: } 1344: 1345: /** 1346: * Tests if the arc contains points. 1347: * 1348: * @return true if the arc has no interior 1349: */ 1350: public boolean isEmpty() 1351: { 1352: return width <= 0 || height <= 0; 1353: } 1354: 1355: /** 1356: * Sets the arc to the given dimensions. 1357: * 1358: * @param x the x coordinate 1359: * @param y the y coordinate 1360: * @param w the width 1361: * @param h the height 1362: * @param start the start angle, in degrees 1363: * @param extent the extent, in degrees 1364: * @param type the arc type: {@link #OPEN}, {@link #CHORD}, or {@link #PIE} 1365: * @throws IllegalArgumentException if type is invalid 1366: */ 1367: public void setArc(double x, double y, double w, double h, double start, 1368: double extent, int type) 1369: { 1370: this.x = (float) x; 1371: this.y = (float) y; 1372: width = (float) w; 1373: height = (float) h; 1374: this.start = (float) start; 1375: this.extent = (float) extent; 1376: setArcType(type); 1377: } 1378: 1379: /** 1380: * Sets the start angle of the arc. 1381: * 1382: * @param start the new start angle 1383: */ 1384: public void setAngleStart(double start) 1385: { 1386: this.start = (float) start; 1387: } 1388: 1389: /** 1390: * Sets the extent angle of the arc. 1391: * 1392: * @param extent the new extent angle 1393: */ 1394: public void setAngleExtent(double extent) 1395: { 1396: this.extent = (float) extent; 1397: } 1398: 1399: /** 1400: * Creates a tight bounding box given dimensions that more precise than 1401: * the bounding box of the ellipse. 1402: * 1403: * @param x the x coordinate 1404: * @param y the y coordinate 1405: * @param w the width 1406: * @param h the height 1407: */ 1408: protected Rectangle2D makeBounds(double x, double y, double w, double h) 1409: { 1410: return new Rectangle2D.Float((float) x, (float) y, (float) w, (float) h); 1411: } 1412: } // class Float 1413: } // class Arc2D