Source for java.awt.geom.Ellipse2D

   1: /* Ellipse2D.java -- represents an ellipse in 2-D space
   2:    Copyright (C) 2000, 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: package java.awt.geom;
  39: 
  40: 
  41: /**
  42:  * Ellipse2D is the shape of an ellipse.
  43:  * <BR>
  44:  * <img src="doc-files/Ellipse-1.png" width="347" height="221"
  45:  * alt="A drawing of an ellipse" /><BR>
  46:  * The ellipse is defined by it's bounding box (shown in red),
  47:  * and is defined by the implicit curve:<BR>
  48:  * <blockquote>(<i>x</i>/<i>a</i>)<sup>2</sup> +
  49:  * (<i>y</i>/<i>b</i>)<sup>2</sup> = 1<BR><BR></blockquote>
  50:  *
  51:  * @author Tom Tromey (tromey@cygnus.com)
  52:  * @author Eric Blake (ebb9@email.byu.edu)
  53:  *
  54:  * @since 1.2
  55:  */
  56: public abstract class Ellipse2D extends RectangularShape
  57: {
  58:   /**
  59:    * Ellipse2D is defined as abstract.
  60:    * Implementing classes are Ellipse2D.Float and Ellipse2D.Double.
  61:    */
  62:   protected Ellipse2D()
  63:   {
  64:   }
  65: 
  66:   /**
  67:    * Determines if a point is contained within the ellipse. <P>
  68:    * @param x - x coordinate of the point.
  69:    * @param y - y coordinate of the point.
  70:    * @return true if the point is within the ellipse, false otherwise.
  71:    */
  72:   public boolean contains(double x, double y)
  73:   {
  74:     double rx = getWidth() / 2;
  75:     double ry = getHeight() / 2;
  76:     double tx = (x - (getX() + rx)) / rx;
  77:     double ty = (y - (getY() + ry)) / ry;
  78:     return tx * tx + ty * ty < 1.0;
  79:   }
  80: 
  81:   /**
  82:    * Determines if a rectangle is completely contained within the
  83:    * ellipse. <P>
  84:    * @param x - x coordinate of the upper-left corner of the rectangle
  85:    * @param y - y coordinate of the upper-left corner of the rectangle
  86:    * @param w - width of the rectangle
  87:    * @param h - height of the rectangle
  88:    * @return true if the rectangle is completely contained, false otherwise.
  89:    */
  90:   public boolean contains(double x, double y, double w, double h)
  91:   {
  92:     double x2 = x + w;
  93:     double y2 = y + h;
  94:     return (contains(x, y) && contains(x, y2) && contains(x2, y)
  95:            && contains(x2, y2));
  96:   }
  97: 
  98:   /**
  99:    * Returns a PathIterator object corresponding to the ellipse.<P>
 100:    *
 101:    * Note: An ellipse cannot be represented exactly in PathIterator
 102:    * segments, the outline is thefore approximated with cubic
 103:    * Bezier segments.
 104:    *
 105:    * @param at an optional transform.
 106:    * @return A path iterator.
 107:    */
 108:   public PathIterator getPathIterator(AffineTransform at)
 109:   {
 110:     // An ellipse is just a complete arc.
 111:     return new Arc2D.ArcIterator(this, at);
 112:   }
 113: 
 114:   /**
 115:    * Determines if a rectangle intersects any part of the ellipse.<P>
 116:    * @param x - x coordinate of the upper-left corner of the rectangle
 117:    * @param y - y coordinate of the upper-left corner of the rectangle
 118:    * @param w - width of the rectangle
 119:    * @param h - height of the rectangle
 120:    * @return true if the rectangle intersects the ellipse, false otherwise.
 121:    */
 122:   public boolean intersects(double x, double y, double w, double h)
 123:   {
 124:     Rectangle2D r = new Rectangle2D.Double(x, y, w, h);
 125:     if (! r.intersects(getX(), getY(), getWidth(), getHeight()))
 126:       return false;
 127: 
 128:     if (contains(x, y) || contains(x, y + h) || contains(x + w, y)
 129:         || contains(x + w, y + h))
 130:       return true;
 131: 
 132:     Line2D l1 = new Line2D.Double(getX(), getY() + (getHeight() / 2),
 133:                                   getX() + getWidth(),
 134:                                   getY() + (getHeight() / 2));
 135:     Line2D l2 = new Line2D.Double(getX() + (getWidth() / 2), getY(),
 136:                                   getX() + (getWidth() / 2),
 137:                                   getY() + getHeight());
 138: 
 139:     if (l1.intersects(r) || l2.intersects(r))
 140:       return true;
 141: 
 142:     return false;
 143:   }
 144: 
 145:   /**
 146:    * An {@link Ellipse2D} that stores its coordinates using <code>double</code>
 147:    * primitives.
 148:    */
 149:   public static class Double extends Ellipse2D
 150:   {
 151:     /**
 152:      * The height of the ellipse.
 153:      */
 154:     public double height;
 155: 
 156:     /**
 157:      * The width of the ellipse.
 158:      */
 159:     public double width;
 160: 
 161:     /**
 162:      * The upper-left x coordinate of the bounding-box
 163:      */
 164:     public double x;
 165: 
 166:     /**
 167:      * The upper-left y coordinate of the bounding-box
 168:      */
 169:     public double y;
 170: 
 171:     /**
 172:      * Creates a new Ellipse2D with an upper-left coordinate of (0,0)
 173:      * and a zero size.
 174:      */
 175:     public Double()
 176:     {
 177:     }
 178: 
 179:     /**
 180:      * Creates a new Ellipse2D within a given rectangle
 181:      * using double-precision coordinates.<P>
 182:      * @param x - x coordinate of the upper-left of the bounding rectangle
 183:      * @param y - y coordinate of the upper-left of the bounding rectangle
 184:      * @param w - width of the ellipse
 185:      * @param h - height of the ellipse
 186:      */
 187:     public Double(double x, double y, double w, double h)
 188:     {
 189:       this.x = x;
 190:       this.y = y;
 191:       height = h;
 192:       width = w;
 193:     }
 194: 
 195:     /**
 196:      * Returns the bounding-box of the ellipse.
 197:      * @return The bounding box.
 198:      */
 199:     public Rectangle2D getBounds2D()
 200:     {
 201:       return new Rectangle2D.Double(x, y, width, height);
 202:     }
 203: 
 204:     /**
 205:      * Returns the height of the ellipse.
 206:      * @return The height of the ellipse.
 207:      */
 208:     public double getHeight()
 209:     {
 210:       return height;
 211:     }
 212: 
 213:     /**
 214:      * Returns the width of the ellipse.
 215:      * @return The width of the ellipse.
 216:      */
 217:     public double getWidth()
 218:     {
 219:       return width;
 220:     }
 221: 
 222:     /**
 223:      * Returns x coordinate of the upper-left corner of
 224:      * the ellipse's bounding-box.
 225:      * @return The x coordinate.
 226:      */
 227:     public double getX()
 228:     {
 229:       return x;
 230:     }
 231: 
 232:     /**
 233:      * Returns y coordinate of the upper-left corner of
 234:      * the ellipse's bounding-box.
 235:      * @return The y coordinate.
 236:      */
 237:     public double getY()
 238:     {
 239:       return y;
 240:     }
 241: 
 242:     /**
 243:      * Returns <code>true</code> if the ellipse encloses no area, and
 244:      * <code>false</code> otherwise.
 245:      *
 246:      * @return A boolean.
 247:      */
 248:     public boolean isEmpty()
 249:     {
 250:       return height <= 0 || width <= 0;
 251:     }
 252: 
 253:     /**
 254:      * Sets the geometry of the ellipse's bounding box.<P>
 255:      *
 256:      * @param x - x coordinate of the upper-left of the bounding rectangle
 257:      * @param y - y coordinate of the upper-left of the bounding rectangle
 258:      * @param w - width of the ellipse
 259:      * @param h - height of the ellipse
 260:      */
 261:     public void setFrame(double x, double y, double w, double h)
 262:     {
 263:       this.x = x;
 264:       this.y = y;
 265:       height = h;
 266:       width = w;
 267:     }
 268:   } // class Double
 269: 
 270:   /**
 271:    * An {@link Ellipse2D} that stores its coordinates using <code>float</code>
 272:    * primitives.
 273:    */
 274:   public static class Float extends Ellipse2D
 275:   {
 276:     /**
 277:      * The height of the ellipse.
 278:      */
 279:     public float height;
 280: 
 281:     /**
 282:      * The width of the ellipse.
 283:      */
 284:     public float width;
 285: 
 286:     /**
 287:      * The upper-left x coordinate of the bounding-box
 288:      */
 289:     public float x;
 290: 
 291:     /**
 292:      * The upper-left y coordinate of the bounding-box
 293:      */
 294:     public float y;
 295: 
 296:     /**
 297:      * Creates a new Ellipse2D with an upper-left coordinate of (0,0)
 298:      * and a zero size.
 299:      */
 300:     public Float()
 301:     {
 302:     }
 303: 
 304:     /**
 305:      * Creates a new Ellipse2D within a given rectangle
 306:      * using floating-point precision.<P>
 307:      * @param x - x coordinate of the upper-left of the bounding rectangle
 308:      * @param y - y coordinate of the upper-left of the bounding rectangle
 309:      * @param w - width of the ellipse
 310:      * @param h - height of the ellipse
 311:      *
 312:      */
 313:     public Float(float x, float y, float w, float h)
 314:     {
 315:       this.x = x;
 316:       this.y = y;
 317:       this.height = h;
 318:       this.width = w;
 319:     }
 320: 
 321:     /**
 322:      * Returns the bounding-box of the ellipse.
 323:      * @return The bounding box.
 324:      */
 325:     public Rectangle2D getBounds2D()
 326:     {
 327:       return new Rectangle2D.Float(x, y, width, height);
 328:     }
 329: 
 330:     /**
 331:      * Returns the height of the ellipse.
 332:      * @return The height of the ellipse.
 333:      */
 334:     public double getHeight()
 335:     {
 336:       return height;
 337:     }
 338: 
 339:     /**
 340:      * Returns the width of the ellipse.
 341:      * @return The width of the ellipse.
 342:      */
 343:     public double getWidth()
 344:     {
 345:       return width;
 346:     }
 347: 
 348:     /**
 349:      * Returns x coordinate of the upper-left corner of
 350:      * the ellipse's bounding-box.
 351:      * @return The x coordinate.
 352:      */
 353:     public double getX()
 354:     {
 355:       return x;
 356:     }
 357: 
 358:     /**
 359:      * Returns y coordinate of the upper-left corner of
 360:      * the ellipse's bounding-box.
 361:      * @return The y coordinate.
 362:      */
 363:     public double getY()
 364:     {
 365:       return y;
 366:     }
 367: 
 368:     /**
 369:      * Returns <code>true</code> if the ellipse encloses no area, and
 370:      * <code>false</code> otherwise.
 371:      *
 372:      * @return A boolean.
 373:      */
 374:     public boolean isEmpty()
 375:     {
 376:       return height <= 0 || width <= 0;
 377:     }
 378: 
 379:     /**
 380:      * Sets the geometry of the ellipse's bounding box.<P>
 381:      *
 382:      * @param x - x coordinate of the upper-left of the bounding rectangle
 383:      * @param y - y coordinate of the upper-left of the bounding rectangle
 384:      * @param w - width of the ellipse
 385:      * @param h - height of the ellipse
 386:      */
 387:     public void setFrame(float x, float y, float w, float h)
 388:     {
 389:       this.x = x;
 390:       this.y = y;
 391:       height = h;
 392:       width = w;
 393:     }
 394: 
 395:     /**
 396:      * Sets the geometry of the ellipse's bounding box.
 397:      *
 398:      * Note: This leads to a loss of precision.<P>
 399:      *
 400:      * @param x - x coordinate of the upper-left of the bounding rectangle
 401:      * @param y - y coordinate of the upper-left of the bounding rectangle
 402:      * @param w - width of the ellipse
 403:      * @param h - height of the ellipse
 404:      */
 405:     public void setFrame(double x, double y, double w, double h)
 406:     {
 407:       this.x = (float) x;
 408:       this.y = (float) y;
 409:       height = (float) h;
 410:       width = (float) w;
 411:     }
 412:   } // class Float
 413: } // class Ellipse2D