awt/java/awt/geom/Ellipse2D.java - platform/frameworks/base - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 /**
  * @author Denis M. Kishenko
  * @version $Revision$
  */

 package java.awt.geom;

 import java.util.NoSuchElementException;

 import org.apache.harmony.awt.internal.nls.Messages;

 /**
  * The Class Ellipse2D describes an ellipse defined by a rectangular area in
  * which it is inscribed.
  *
  * @since Android 1.0
  */
 public abstract class Ellipse2D extends RectangularShape {

     /**
      * The Class Float is the subclass of Ellipse2D that has all of its data
      * values stored with float-level precision.
      *
      * @since Android 1.0
      */
     public static class Float extends Ellipse2D {

         /**
          * The x coordinate of the upper left corner of the ellipse's bounding
          * rectangle.
          */
         public float x;

         /**
          * The y coordinate of the upper left corner of the ellipse's bounding
          * rectangle.
          */
         public float y;

         /**
          * The width of the ellipse's bounding rectangle.
          */
         public float width;

         /**
          * The height of the ellipse's bounding rectangle.
          */
         public float height;

         /**
          * Instantiates a new float-valued Ellipse2D.
          */
         public Float() {
         }

         /**
          * Instantiates a new float-valued Ellipse2D with the specified data.
          *
          * @param x
          *            the x coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param y
          *            the y coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param width
          *            the width of the ellipse's bounding rectangle.
          * @param height
          *            the height of the ellipse's bounding rectangle.
          */
         public Float(float x, float y, float width, float height) {
             setFrame(x, y, width, height);
         }

         @Override
         public double getX() {
             return x;
         }

         @Override
         public double getY() {
             return y;
         }

         @Override
         public double getWidth() {
             return width;
         }

         @Override
         public double getHeight() {
             return height;
         }

         @Override
         public boolean isEmpty() {
             return width <= 0.0 || height <= 0.0;
         }

         /**
          * Sets the data of the ellipse's bounding rectangle.
          *
          * @param x
          *            the x coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param y
          *            the y coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param width
          *            the width of the ellipse's bounding rectangle.
          * @param height
          *            the height of the ellipse's bounding rectangle.
          */
         public void setFrame(float x, float y, float width, float height) {
             this.x = x;
             this.y = y;
             this.width = width;
             this.height = height;
         }

         @Override
         public void setFrame(double x, double y, double width, double height) {
             this.x = (float)x;
             this.y = (float)y;
             this.width = (float)width;
             this.height = (float)height;
         }

         public Rectangle2D getBounds2D() {
             return new Rectangle2D.Float(x, y, width, height);
         }
     }

     /**
      * The Class Double is the subclass of Ellipse2D that has all of its data
      * values stored with double-level precision.
      *
      * @since Android 1.0
      */
     public static class Double extends Ellipse2D {

         /**
          * The x coordinate of the upper left corner of the ellipse's bounding
          * rectangle.
          */
         public double x;

         /**
          * The y coordinate of the upper left corner of the ellipse's bounding
          * rectangle.
          */
         public double y;

         /**
          * The width of the ellipse's bounding rectangle.
          */
         public double width;

         /**
          * The height of the ellipse's bounding rectangle.
          */
         public double height;

         /**
          * Instantiates a new double-valued Ellipse2D.
          */
         public Double() {
         }

         /**
          * Instantiates a new double-valued Ellipse2D with the specified data.
          *
          * @param x
          *            the x coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param y
          *            the y coordinate of the upper left corner of the ellipse's
          *            bounding rectangle.
          * @param width
          *            the width of the ellipse's bounding rectangle.
          * @param height
          *            the height of the ellipse's bounding rectangle.
          */
         public Double(double x, double y, double width, double height) {
             setFrame(x, y, width, height);
         }

         @Override
         public double getX() {
             return x;
         }

         @Override
         public double getY() {
             return y;
         }

         @Override
         public double getWidth() {
             return width;
         }

         @Override
         public double getHeight() {
             return height;
         }

         @Override
         public boolean isEmpty() {
             return width <= 0.0 || height <= 0.0;
         }

         @Override
         public void setFrame(double x, double y, double width, double height) {
             this.x = x;
             this.y = y;
             this.width = width;
             this.height = height;
         }

         public Rectangle2D getBounds2D() {
             return new Rectangle2D.Double(x, y, width, height);
         }
     }

     /*
      * Ellipse2D path iterator
      */
     /**
      * The subclass of PathIterator to traverse an Ellipse2D.
      */
     class Iterator implements PathIterator {

         /*
          * Ellipse is subdivided into four quarters by x and y axis. Each part
          * approximated by cubic Bezier curve. Arc in first quarter is started
          * in (a, 0) and finished in (0, b) points. Control points for cubic
          * curve wiil be (a, 0), (a, m), (n, b) and (0, b) where n and m are
          * calculated based on requirement Bezier curve in point 0.5 should lay
          * on the arc.
          */

         /**
          * The coefficient to calculate control points of Bezier curves.
          */
         final double u = 2.0 / 3.0 * (Math.sqrt(2.0) - 1.0);

         /**
          * The points coordinates calculation table.
          */
         final double points[][] = {
                 {
                         1.0, 0.5 + u, 0.5 + u, 1.0, 0.5, 1.0
                 }, {
                         0.5 - u, 1.0, 0.0, 0.5 + u, 0.0, 0.5
                 }, {
                         0.0, 0.5 - u, 0.5 - u, 0.0, 0.5, 0.0
                 }, {
                         0.5 + u, 0.0, 1.0, 0.5 - u, 1.0, 0.5
                 }
         };

         /**
          * The x coordinate of left-upper corner of the ellipse bounds.
          */
         double x;

         /**
          * The y coordinate of left-upper corner of the ellipse bounds.
          */
         double y;

         /**
          * The width of the ellipse bounds.
          */
         double width;

         /**
          * The height of the ellipse bounds.
          */
         double height;

         /**
          * The path iterator transformation.
          */
         AffineTransform t;

         /**
          * The current segment index.
          */
         int index;

         /**
          * Constructs a new Ellipse2D.Iterator for given ellipse and
          * transformation
          *
          * @param e
          *            the source Ellipse2D object.
          * @param t
          *            the affine transformation object.
          */
         Iterator(Ellipse2D e, AffineTransform t) {
             this.x = e.getX();
             this.y = e.getY();
             this.width = e.getWidth();
             this.height = e.getHeight();
             this.t = t;
             if (width < 0.0 || height < 0.0) {
                 index = 6;
             }
         }

         public int getWindingRule() {
             return WIND_NON_ZERO;
         }

         public boolean isDone() {
             return index > 5;
         }

         public void next() {
             index++;
         }

         public int currentSegment(double[] coords) {
             if (isDone()) {
                 // awt.4B=Iterator out of bounds
                 throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
             }
             if (index == 5) {
                 return SEG_CLOSE;
             }
             int type;
             int count;
             if (index == 0) {
                 type = SEG_MOVETO;
                 count = 1;
                 double p[] = points[3];
                 coords[0] = x + p[4] * width;
                 coords[1] = y + p[5] * height;
             } else {
                 type = SEG_CUBICTO;
                 count = 3;
                 double p[] = points[index - 1];
                 int j = 0;
                 for (int i = 0; i < 3; i++) {
                     coords[j] = x + p[j++] * width;
                     coords[j] = y + p[j++] * height;
                 }
             }
             if (t != null) {
                 t.transform(coords, 0, coords, 0, count);
             }
             return type;
         }

         public int currentSegment(float[] coords) {
             if (isDone()) {
                 // awt.4B=Iterator out of bounds
                 throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
             }
             if (index == 5) {
                 return SEG_CLOSE;
             }
             int type;
             int count;
             if (index == 0) {
                 type = SEG_MOVETO;
                 count = 1;
                 double p[] = points[3];
                 coords[0] = (float)(x + p[4] * width);
                 coords[1] = (float)(y + p[5] * height);
             } else {
                 type = SEG_CUBICTO;
                 count = 3;
                 int j = 0;
                 double p[] = points[index - 1];
                 for (int i = 0; i < 3; i++) {
                     coords[j] = (float)(x + p[j++] * width);
                     coords[j] = (float)(y + p[j++] * height);
                 }
             }
             if (t != null) {
                 t.transform(coords, 0, coords, 0, count);
             }
             return type;
         }

     }

     /**
      * Instantiates a new Ellipse2D.
      */
     protected Ellipse2D() {
     }

     public boolean contains(double px, double py) {
         if (isEmpty()) {
             return false;
         }

         double a = (px - getX()) / getWidth() - 0.5;
         double b = (py - getY()) / getHeight() - 0.5;

         return a * a + b * b < 0.25;
     }

     public boolean intersects(double rx, double ry, double rw, double rh) {
         if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
             return false;
         }

         double cx = getX() + getWidth() / 2.0;
         double cy = getY() + getHeight() / 2.0;

         double rx1 = rx;
         double ry1 = ry;
         double rx2 = rx + rw;
         double ry2 = ry + rh;

         double nx = cx < rx1 ? rx1 : (cx > rx2 ? rx2 : cx);
         double ny = cy < ry1 ? ry1 : (cy > ry2 ? ry2 : cy);

         return contains(nx, ny);
     }

     public boolean contains(double rx, double ry, double rw, double rh) {
         if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
             return false;
         }

         double rx1 = rx;
         double ry1 = ry;
         double rx2 = rx + rw;
         double ry2 = ry + rh;

         return contains(rx1, ry1) && contains(rx2, ry1) && contains(rx2, ry2) && contains(rx1, ry2);
     }

     public PathIterator getPathIterator(AffineTransform at) {
         return new Iterator(this, at);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	/**
	* @author Denis M. Kishenko
	* @version $Revision$
	*/

	package java.awt.geom;

	import java.util.NoSuchElementException;

	import org.apache.harmony.awt.internal.nls.Messages;

	/**
	* The Class Ellipse2D describes an ellipse defined by a rectangular area in
	* which it is inscribed.
	*
	* @since Android 1.0
	*/
	public abstract class Ellipse2D extends RectangularShape {

	/**
	* The Class Float is the subclass of Ellipse2D that has all of its data
	* values stored with float-level precision.
	*
	* @since Android 1.0
	*/
	public static class Float extends Ellipse2D {

	/**
	* The x coordinate of the upper left corner of the ellipse's bounding
	* rectangle.
	*/
	public float x;

	/**
	* The y coordinate of the upper left corner of the ellipse's bounding
	* rectangle.
	*/
	public float y;

	/**
	* The width of the ellipse's bounding rectangle.
	*/
	public float width;

	/**
	* The height of the ellipse's bounding rectangle.
	*/
	public float height;

	/**
	* Instantiates a new float-valued Ellipse2D.
	*/
	public Float() {
	}

	/**
	* Instantiates a new float-valued Ellipse2D with the specified data.
	*
	* @param x
	* the x coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param y
	* the y coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param width
	* the width of the ellipse's bounding rectangle.
	* @param height
	* the height of the ellipse's bounding rectangle.
	*/
	public Float(float x, float y, float width, float height) {
	setFrame(x, y, width, height);
	}

	@Override
	public double getX() {
	return x;
	}

	@Override
	public double getY() {
	return y;
	}

	@Override
	public double getWidth() {
	return width;
	}

	@Override
	public double getHeight() {
	return height;
	}

	@Override
	public boolean isEmpty() {
	return width <= 0.0 \|\| height <= 0.0;
	}

	/**
	* Sets the data of the ellipse's bounding rectangle.
	*
	* @param x
	* the x coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param y
	* the y coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param width
	* the width of the ellipse's bounding rectangle.
	* @param height
	* the height of the ellipse's bounding rectangle.
	*/
	public void setFrame(float x, float y, float width, float height) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
	}

	@Override
	public void setFrame(double x, double y, double width, double height) {
	this.x = (float)x;
	this.y = (float)y;
	this.width = (float)width;
	this.height = (float)height;
	}

	public Rectangle2D getBounds2D() {
	return new Rectangle2D.Float(x, y, width, height);
	}
	}

	/**
	* The Class Double is the subclass of Ellipse2D that has all of its data
	* values stored with double-level precision.
	*
	* @since Android 1.0
	*/
	public static class Double extends Ellipse2D {

	/**
	* The x coordinate of the upper left corner of the ellipse's bounding
	* rectangle.
	*/
	public double x;

	/**
	* The y coordinate of the upper left corner of the ellipse's bounding
	* rectangle.
	*/
	public double y;

	/**
	* The width of the ellipse's bounding rectangle.
	*/
	public double width;

	/**
	* The height of the ellipse's bounding rectangle.
	*/
	public double height;

	/**
	* Instantiates a new double-valued Ellipse2D.
	*/
	public Double() {
	}

	/**
	* Instantiates a new double-valued Ellipse2D with the specified data.
	*
	* @param x
	* the x coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param y
	* the y coordinate of the upper left corner of the ellipse's
	* bounding rectangle.
	* @param width
	* the width of the ellipse's bounding rectangle.
	* @param height
	* the height of the ellipse's bounding rectangle.
	*/
	public Double(double x, double y, double width, double height) {
	setFrame(x, y, width, height);
	}

	@Override
	public double getX() {
	return x;
	}

	@Override
	public double getY() {
	return y;
	}

	@Override
	public double getWidth() {
	return width;
	}

	@Override
	public double getHeight() {
	return height;
	}

	@Override
	public boolean isEmpty() {
	return width <= 0.0 \|\| height <= 0.0;
	}

	@Override
	public void setFrame(double x, double y, double width, double height) {
	this.x = x;
	this.y = y;
	this.width = width;
	this.height = height;
	}

	public Rectangle2D getBounds2D() {
	return new Rectangle2D.Double(x, y, width, height);
	}
	}

	/*
	* Ellipse2D path iterator
	*/
	/**
	* The subclass of PathIterator to traverse an Ellipse2D.
	*/
	class Iterator implements PathIterator {

	/*
	* Ellipse is subdivided into four quarters by x and y axis. Each part
	* approximated by cubic Bezier curve. Arc in first quarter is started
	* in (a, 0) and finished in (0, b) points. Control points for cubic
	* curve wiil be (a, 0), (a, m), (n, b) and (0, b) where n and m are
	* calculated based on requirement Bezier curve in point 0.5 should lay
	* on the arc.
	*/

	/**
	* The coefficient to calculate control points of Bezier curves.
	*/
	final double u = 2.0 / 3.0 * (Math.sqrt(2.0) - 1.0);

	/**
	* The points coordinates calculation table.
	*/
	final double points[][] = {
	{
	1.0, 0.5 + u, 0.5 + u, 1.0, 0.5, 1.0
	}, {
	0.5 - u, 1.0, 0.0, 0.5 + u, 0.0, 0.5
	}, {
	0.0, 0.5 - u, 0.5 - u, 0.0, 0.5, 0.0
	}, {
	0.5 + u, 0.0, 1.0, 0.5 - u, 1.0, 0.5
	}
	};

	/**
	* The x coordinate of left-upper corner of the ellipse bounds.
	*/
	double x;

	/**
	* The y coordinate of left-upper corner of the ellipse bounds.
	*/
	double y;

	/**
	* The width of the ellipse bounds.
	*/
	double width;

	/**
	* The height of the ellipse bounds.
	*/
	double height;

	/**
	* The path iterator transformation.
	*/
	AffineTransform t;

	/**
	* The current segment index.
	*/
	int index;

	/**
	* Constructs a new Ellipse2D.Iterator for given ellipse and
	* transformation
	*
	* @param e
	* the source Ellipse2D object.
	* @param t
	* the affine transformation object.
	*/
	Iterator(Ellipse2D e, AffineTransform t) {
	this.x = e.getX();
	this.y = e.getY();
	this.width = e.getWidth();
	this.height = e.getHeight();
	this.t = t;
	if (width < 0.0 \|\| height < 0.0) {
	index = 6;
	}
	}

	public int getWindingRule() {
	return WIND_NON_ZERO;
	}

	public boolean isDone() {
	return index > 5;
	}

	public void next() {
	index++;
	}

	public int currentSegment(double[] coords) {
	if (isDone()) {
	// awt.4B=Iterator out of bounds
	throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
	}
	if (index == 5) {
	return SEG_CLOSE;
	}
	int type;
	int count;
	if (index == 0) {
	type = SEG_MOVETO;
	count = 1;
	double p[] = points[3];
	coords[0] = x + p[4] * width;
	coords[1] = y + p[5] * height;
	} else {
	type = SEG_CUBICTO;
	count = 3;
	double p[] = points[index - 1];
	int j = 0;
	for (int i = 0; i < 3; i++) {
	coords[j] = x + p[j++] * width;
	coords[j] = y + p[j++] * height;
	}
	}
	if (t != null) {
	t.transform(coords, 0, coords, 0, count);
	}
	return type;
	}

	public int currentSegment(float[] coords) {
	if (isDone()) {
	// awt.4B=Iterator out of bounds
	throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
	}
	if (index == 5) {
	return SEG_CLOSE;
	}
	int type;
	int count;
	if (index == 0) {
	type = SEG_MOVETO;
	count = 1;
	double p[] = points[3];
	coords[0] = (float)(x + p[4] * width);
	coords[1] = (float)(y + p[5] * height);
	} else {
	type = SEG_CUBICTO;
	count = 3;
	int j = 0;
	double p[] = points[index - 1];
	for (int i = 0; i < 3; i++) {
	coords[j] = (float)(x + p[j++] * width);
	coords[j] = (float)(y + p[j++] * height);
	}
	}
	if (t != null) {
	t.transform(coords, 0, coords, 0, count);
	}
	return type;
	}

	}

	/**
	* Instantiates a new Ellipse2D.
	*/
	protected Ellipse2D() {
	}

	public boolean contains(double px, double py) {
	if (isEmpty()) {
	return false;
	}

	double a = (px - getX()) / getWidth() - 0.5;
	double b = (py - getY()) / getHeight() - 0.5;

	return a * a + b * b < 0.25;
	}

	public boolean intersects(double rx, double ry, double rw, double rh) {
	if (isEmpty() \|\| rw <= 0.0 \|\| rh <= 0.0) {
	return false;
	}

	double cx = getX() + getWidth() / 2.0;
	double cy = getY() + getHeight() / 2.0;

	double rx1 = rx;
	double ry1 = ry;
	double rx2 = rx + rw;
	double ry2 = ry + rh;

	double nx = cx < rx1 ? rx1 : (cx > rx2 ? rx2 : cx);
	double ny = cy < ry1 ? ry1 : (cy > ry2 ? ry2 : cy);

	return contains(nx, ny);
	}

	public boolean contains(double rx, double ry, double rw, double rh) {
	if (isEmpty() \|\| rw <= 0.0 \|\| rh <= 0.0) {
	return false;
	}

	double rx1 = rx;
	double ry1 = ry;
	double rx2 = rx + rw;
	double ry2 = ry + rh;

	return contains(rx1, ry1) && contains(rx2, ry1) && contains(rx2, ry2) && contains(rx1, ry2);
	}

	public PathIterator getPathIterator(AffineTransform at) {
	return new Iterator(this, at);
	}
	}