libjava/java/awt/geom/Ellipse2D.java

   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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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