Source for java.awt.geom.Arc2D

   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