path: root/awt/java/awt/geom/Arc2D.java

/*
 *  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 Arc2D represents a segment of a curve inscribed in a rectangle. The
 * curve is defined by a start angle and an extent angle (the end angle minus
 * the start angle) as a pie wedge whose point is in the center of the
 * rectangle. The Arc2D as a shape may be either OPEN (including nothing but the
 * curved arc segment itself), CHORD (the curved arc segment closed by a
 * connecting segment from the end to the beginning of the arc, or PIE (the
 * segments from the end of the arc to the center of the rectangle and from the
 * center of the rectangle back to the arc's start point are included).
 * 
 * @since Android 1.0
 */
public abstract class Arc2D extends RectangularShape {

    /**
     * The arc type OPEN indicates that the shape includes only the curved arc
     * segment.
     */
    public final static int OPEN = 0;

    /**
     * The arc type CHORD indicates that as a shape the connecting segment from
     * the end point of the curved arc to the beginning point is included.
     */
    public final static int CHORD = 1;

    /**
     * The arc type PIE indicates that as a shape the two segments from the
     * arc's endpoint to the center of the rectangle and from the center of the
     * rectangle to the arc's endpoint are included.
     */
    public final static int PIE = 2;

    /**
     * The Class Float is a subclass of Arc2D in which all of the data values
     * are given as floats.
     * 
     * @see Arc2D.Double
     * @since Android 1.0
     */
    public static class Float extends Arc2D {

        /**
         * The x coordinate of the upper left corner of the rectangle that
         * contains the arc.
         */
        public float x;

        /**
         * The y coordinate of the upper left corner of the rectangle that
         * contains the arc.
         */
        public float y;

        /**
         * The width of the rectangle that contains the arc.
         */
        public float width;

        /**
         * The height of the rectangle that contains the arc.
         */
        public float height;

        /**
         * The start angle of the arc in degrees.
         */
        public float start;

        /**
         * The width angle of the arc in degrees.
         */
        public float extent;

        /**
         * Instantiates a new Arc2D of type OPEN with float values.
         */
        public Float() {
            super(OPEN);
        }

        /**
         * Instantiates a new Arc2D of the specified type with float values.
         * 
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Float(int type) {
            super(type);
        }

        /**
         * Instantiates a Arc2D with the specified float-valued data.
         * 
         * @param x
         *            the x coordinate of the upper left corner of the rectangle
         *            that contains the arc.
         * @param y
         *            the y coordinate of the upper left corner of the rectangle
         *            that contains the arc.
         * @param width
         *            the width of the rectangle that contains the arc.
         * @param height
         *            the height of the rectangle that contains the arc.
         * @param start
         *            the start angle of the arc in degrees.
         * @param extent
         *            the width angle of the arc in degrees.
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Float(float x, float y, float width, float height, float start, float extent,
                int type) {
            super(type);
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
            this.start = start;
            this.extent = extent;
        }

        /**
         * Instantiates a new Angle2D with the specified float-valued data and
         * the bounding rectangle given by the parameter bounds.
         * 
         * @param bounds
         *            the bounding rectangle of the Angle2D.
         * @param start
         *            the start angle of the arc in degrees.
         * @param extent
         *            the width angle of the arc in degrees.
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Float(Rectangle2D bounds, float start, float extent, int type) {
            super(type);
            this.x = (float)bounds.getX();
            this.y = (float)bounds.getY();
            this.width = (float)bounds.getWidth();
            this.height = (float)bounds.getHeight();
            this.start = start;
            this.extent = extent;
        }

        @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 double getAngleStart() {
            return start;
        }

        @Override
        public double getAngleExtent() {
            return extent;
        }

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

        @Override
        public void setArc(double x, double y, double width, double height, double start,
                double extent, int type) {
            this.setArcType(type);
            this.x = (float)x;
            this.y = (float)y;
            this.width = (float)width;
            this.height = (float)height;
            this.start = (float)start;
            this.extent = (float)extent;
        }

        @Override
        public void setAngleStart(double start) {
            this.start = (float)start;
        }

        @Override
        public void setAngleExtent(double extent) {
            this.extent = (float)extent;
        }

        @Override
        protected Rectangle2D makeBounds(double x, double y, double width, double height) {
            return new Rectangle2D.Float((float)x, (float)y, (float)width, (float)height);
        }

    }

    /**
     * The Class Double is a subclass of Arc2D in which all of the data values
     * are given as doubles.
     * 
     * @see Arc2D.Float
     * @since Android 1.0
     */
    public static class Double extends Arc2D {

        /**
         * The x coordinate of the upper left corner of the rectangle that
         * contains the arc.
         */
        public double x;

        /**
         * The y coordinate of the upper left corner of the rectangle that
         * contains the arc.
         */
        public double y;

        /**
         * The width of the rectangle that contains the arc.
         */
        public double width;

        /**
         * The height of the rectangle that contains the arc.
         */
        public double height;

        /**
         * The start angle of the arc in degrees.
         */
        public double start;

        /**
         * The width angle of the arc in degrees.
         */
        public double extent;

        /**
         * Instantiates a new Arc2D of type OPEN with double values.
         */
        public Double() {
            super(OPEN);
        }

        /**
         * Instantiates a new Arc2D of the specified type with double values.
         * 
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Double(int type) {
            super(type);
        }

        /**
         * Instantiates a Arc2D with the specified double-valued data.
         * 
         * @param x
         *            the x coordinate of the upper left corner of the rectangle
         *            that contains the arc.
         * @param y
         *            the y coordinate of the upper left corner of the rectangle
         *            that contains the arc.
         * @param width
         *            the width of the rectangle that contains the arc.
         * @param height
         *            the height of the rectangle that contains the arc.
         * @param start
         *            the start angle of the arc in degrees.
         * @param extent
         *            the width angle of the arc in degrees.
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Double(double x, double y, double width, double height, double start, double extent,
                int type) {
            super(type);
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
            this.start = start;
            this.extent = extent;
        }

        /**
         * Instantiates a new Angle2D with the specified float-valued data and
         * the bounding rectangle given by the parameter bounds.
         * 
         * @param bounds
         *            the bounding rectangle of the Angle2D.
         * @param start
         *            the start angle of the arc in degrees.
         * @param extent
         *            the width angle of the arc in degrees.
         * @param type
         *            the type of the new Arc2D, either {@link Arc2D#OPEN},
         *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
         */
        public Double(Rectangle2D bounds, double start, double extent, int type) {
            super(type);
            this.x = bounds.getX();
            this.y = bounds.getY();
            this.width = bounds.getWidth();
            this.height = bounds.getHeight();
            this.start = start;
            this.extent = extent;
        }

        @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 double getAngleStart() {
            return start;
        }

        @Override
        public double getAngleExtent() {
            return extent;
        }

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

        @Override
        public void setArc(double x, double y, double width, double height, double start,
                double extent, int type) {
            this.setArcType(type);
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
            this.start = start;
            this.extent = extent;
        }

        @Override
        public void setAngleStart(double start) {
            this.start = start;
        }

        @Override
        public void setAngleExtent(double extent) {
            this.extent = extent;
        }

        @Override
        protected Rectangle2D makeBounds(double x, double y, double width, double height) {
            return new Rectangle2D.Double(x, y, width, height);
        }

    }

    /**
     * The Class Iterator is the subclass of PathIterator that is used to
     * traverse the boundary of a shape of type Arc2D.
     */
    class Iterator implements PathIterator {

        /**
         * The x coordinate of the center of the arc's bounding rectangle.
         */
        double x;

        /**
         * The y coordinate of the center of the arc's bounding rectangle.
         */
        double y;

        /**
         * Half of the width of the arc's bounding rectangle (the radius in the
         * case of a circular arc).
         */
        double width;

        /**
         * Half of the height of the arc's bounding rectangle (the radius in the
         * case of a circular arc).
         */
        double height;

        /**
         * The start angle of the arc in degrees.
         */
        double angle;

        /**
         * The angle extent in degrees.
         */
        double extent;

        /**
         * The closure type of the arc.
         */
        int type;

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

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

        /**
         * The number of arc segments the source arc subdivided to be
         * approximated by Bezier curves. Depends on extent value.
         */
        int arcCount;

        /**
         * The number of line segments. Depends on closure type.
         */
        int lineCount;

        /**
         * The step to calculate next arc subdivision point.
         */
        double step;

        /**
         * The temporary value of cosinus of the current angle.
         */
        double cos;

        /**
         * The temporary value of sinus of the current angle.
         */
        double sin;

        /** The coefficient to calculate control points of Bezier curves. */
        double k;

        /**
         * The temporary value of x coordinate of the Bezier curve control
         * vector.
         */
        double kx;

        /**
         * The temporary value of y coordinate of the Bezier curve control
         * vector.
         */
        double ky;

        /**
         * The x coordinate of the first path point (MOVE_TO).
         */
        double mx;

        /**
         * The y coordinate of the first path point (MOVE_TO).
         */
        double my;

        /**
         * Constructs a new Arc2D.Iterator for given line and transformation
         * 
         * @param a
         *            the source Arc2D object.
         * @param t
         *            the AffineTransformation.
         */
        Iterator(Arc2D a, AffineTransform t) {
            if (width < 0 || height < 0) {
                arcCount = 0;
                lineCount = 0;
                index = 1;
                return;
            }

            this.width = a.getWidth() / 2.0;
            this.height = a.getHeight() / 2.0;
            this.x = a.getX() + width;
            this.y = a.getY() + height;
            this.angle = -Math.toRadians(a.getAngleStart());
            this.extent = -a.getAngleExtent();
            this.type = a.getArcType();
            this.t = t;

            if (Math.abs(extent) >= 360.0) {
                arcCount = 4;
                k = 4.0 / 3.0 * (Math.sqrt(2.0) - 1.0);
                step = Math.PI / 2.0;
                if (extent < 0.0) {
                    step = -step;
                    k = -k;
                }
            } else {
                arcCount = (int)Math.rint(Math.abs(extent) / 90.0);
                step = Math.toRadians(extent / arcCount);
                k = 4.0 / 3.0 * (1.0 - Math.cos(step / 2.0)) / Math.sin(step / 2.0);
            }

            lineCount = 0;
            if (type == Arc2D.CHORD) {
                lineCount++;
            } else if (type == Arc2D.PIE) {
                lineCount += 2;
            }
        }

        public int getWindingRule() {
            return WIND_NON_ZERO;
        }

        public boolean isDone() {
            return index > arcCount + lineCount;
        }

        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$
            }
            int type;
            int count;
            if (index == 0) {
                type = SEG_MOVETO;
                count = 1;
                cos = Math.cos(angle);
                sin = Math.sin(angle);
                kx = k * width * sin;
                ky = k * height * cos;
                coords[0] = mx = x + cos * width;
                coords[1] = my = y + sin * height;
            } else if (index <= arcCount) {
                type = SEG_CUBICTO;
                count = 3;
                coords[0] = mx - kx;
                coords[1] = my + ky;
                angle += step;
                cos = Math.cos(angle);
                sin = Math.sin(angle);
                kx = k * width * sin;
                ky = k * height * cos;
                coords[4] = mx = x + cos * width;
                coords[5] = my = y + sin * height;
                coords[2] = mx + kx;
                coords[3] = my - ky;
            } else if (index == arcCount + lineCount) {
                type = SEG_CLOSE;
                count = 0;
            } else {
                type = SEG_LINETO;
                count = 1;
                coords[0] = x;
                coords[1] = y;
            }
            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$
            }
            int type;
            int count;
            if (index == 0) {
                type = SEG_MOVETO;
                count = 1;
                cos = Math.cos(angle);
                sin = Math.sin(angle);
                kx = k * width * sin;
                ky = k * height * cos;
                coords[0] = (float)(mx = x + cos * width);
                coords[1] = (float)(my = y + sin * height);
            } else if (index <= arcCount) {
                type = SEG_CUBICTO;
                count = 3;
                coords[0] = (float)(mx - kx);
                coords[1] = (float)(my + ky);
                angle += step;
                cos = Math.cos(angle);
                sin = Math.sin(angle);
                kx = k * width * sin;
                ky = k * height * cos;
                coords[4] = (float)(mx = x + cos * width);
                coords[5] = (float)(my = y + sin * height);
                coords[2] = (float)(mx + kx);
                coords[3] = (float)(my - ky);
            } else if (index == arcCount + lineCount) {
                type = SEG_CLOSE;
                count = 0;
            } else {
                type = SEG_LINETO;
                count = 1;
                coords[0] = (float)x;
                coords[1] = (float)y;
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, count);
            }
            return type;
        }

    }

    /**
     * The closure type of the arc.
     */
    private int type;

    /**
     * Instantiates a new arc2D.
     * 
     * @param type
     *            the closure type.
     */
    protected Arc2D(int type) {
        setArcType(type);
    }

    /**
     * Takes the double-valued data and creates the corresponding Rectangle2D
     * object with values either of type float or of type double depending on
     * whether this Arc2D instance is of type Float or Double.
     * 
     * @param x
     *            the x coordinate of the upper left corner of the bounding
     *            rectangle.
     * @param y
     *            the y coordinate of the upper left corner of the bounding
     *            rectangle.
     * @param width
     *            the width of the bounding rectangle.
     * @param height
     *            the height of the bounding rectangle.
     * @return the corresponding Rectangle2D object.
     */
    protected abstract Rectangle2D makeBounds(double x, double y, double width, double height);

    /**
     * Gets the start angle.
     * 
     * @return the start angle.
     */
    public abstract double getAngleStart();

    /**
     * Gets the width angle.
     * 
     * @return the width angle.
     */
    public abstract double getAngleExtent();

    /**
     * Sets the start angle.
     * 
     * @param start
     *            the new start angle.
     */
    public abstract void setAngleStart(double start);

    /**
     * Sets the width angle.
     * 
     * @param extent
     *            the new width angle.
     */
    public abstract void setAngleExtent(double extent);

    /**
     * Sets the data values that define the arc.
     * 
     * @param x
     *            the x coordinate of the upper left corner of the rectangle
     *            that contains the arc.
     * @param y
     *            the y coordinate of the upper left corner of the rectangle
     *            that contains the arc.
     * @param width
     *            the width of the rectangle that contains the arc.
     * @param height
     *            the height of the rectangle that contains the arc.
     * @param start
     *            the start angle of the arc in degrees.
     * @param extent
     *            the width angle of the arc in degrees.
     * @param type
     *            the type of the new Arc2D, either {@link Arc2D#OPEN},
     *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
     */
    public abstract void setArc(double x, double y, double width, double height, double start,
            double extent, int type);

    /**
     * Gets the arc type, either {@link Arc2D#OPEN}, {@link Arc2D#CHORD}, or
     * {@link Arc2D#PIE}.
     * 
     * @return the arc type.
     */
    public int getArcType() {
        return type;
    }

    /**
     * Sets the arc type, either {@link Arc2D#OPEN}, {@link Arc2D#CHORD}, or
     * {@link Arc2D#PIE}.
     * 
     * @param type
     *            the new arc type.
     */
    public void setArcType(int type) {
        if (type != OPEN && type != CHORD && type != PIE) {
            // awt.205=Invalid type of Arc: {0}
            throw new IllegalArgumentException(Messages.getString("awt.205", type)); //$NON-NLS-1$
        }
        this.type = type;
    }

    /**
     * Gets the start point of the arc as a Point2D.
     * 
     * @return the start point of the curved arc segment.
     */
    public Point2D getStartPoint() {
        double a = Math.toRadians(getAngleStart());
        return new Point2D.Double(getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0, getY()
                + (1.0 - Math.sin(a)) * getHeight() / 2.0);
    }

    /**
     * Gets the end point of the arc as a Point2D.
     * 
     * @return the end point of the curved arc segment.
     */
    public Point2D getEndPoint() {
        double a = Math.toRadians(getAngleStart() + getAngleExtent());
        return new Point2D.Double(getX() + (1.0 + Math.cos(a)) * getWidth() / 2.0, getY()
                + (1.0 - Math.sin(a)) * getHeight() / 2.0);
    }

    public Rectangle2D getBounds2D() {
        if (isEmpty()) {
            return makeBounds(getX(), getY(), getWidth(), getHeight());
        }
        double rx1 = getX();
        double ry1 = getY();
        double rx2 = rx1 + getWidth();
        double ry2 = ry1 + getHeight();

        Point2D p1 = getStartPoint();
        Point2D p2 = getEndPoint();

        double bx1 = containsAngle(180.0) ? rx1 : Math.min(p1.getX(), p2.getX());
        double by1 = containsAngle(90.0) ? ry1 : Math.min(p1.getY(), p2.getY());
        double bx2 = containsAngle(0.0) ? rx2 : Math.max(p1.getX(), p2.getX());
        double by2 = containsAngle(270.0) ? ry2 : Math.max(p1.getY(), p2.getY());

        if (type == PIE) {
            double cx = getCenterX();
            double cy = getCenterY();
            bx1 = Math.min(bx1, cx);
            by1 = Math.min(by1, cy);
            bx2 = Math.max(bx2, cx);
            by2 = Math.max(by2, cy);
        }
        return makeBounds(bx1, by1, bx2 - bx1, by2 - by1);
    }

    @Override
    public void setFrame(double x, double y, double width, double height) {
        setArc(x, y, width, height, getAngleStart(), getAngleExtent(), type);
    }

    /**
     * Sets the data that defines the arc.
     * 
     * @param point
     *            the upper left corner of the bounding rectangle.
     * @param size
     *            the size of the bounding rectangle.
     * @param start
     *            the start angle of the arc in degrees.
     * @param extent
     *            the angle width of the arc in degrees.
     * @param type
     *            the closure type, either {@link Arc2D#OPEN},
     *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
     */
    public void setArc(Point2D point, Dimension2D size, double start, double extent, int type) {
        setArc(point.getX(), point.getY(), size.getWidth(), size.getHeight(), start, extent, type);
    }

    /**
     * Sets the data that defines the arc.
     * 
     * @param rect
     *            the arc's bounding rectangle.
     * @param start
     *            the start angle of the arc in degrees.
     * @param extent
     *            the angle width of the arc in degrees.
     * @param type
     *            the closure type, either {@link Arc2D#OPEN},
     *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
     */
    public void setArc(Rectangle2D rect, double start, double extent, int type) {
        setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(), start, extent, type);
    }

    /**
     * Sets the data that defines the arc by copying it from another Arc2D.
     * 
     * @param arc
     *            the arc whose data is copied into this arc.
     */
    public void setArc(Arc2D arc) {
        setArc(arc.getX(), arc.getY(), arc.getWidth(), arc.getHeight(), arc.getAngleStart(), arc
                .getAngleExtent(), arc.getArcType());
    }

    /**
     * Sets the data for a circular arc by giving its center and radius.
     * 
     * @param x
     *            the x coordinate of the center of the circle.
     * @param y
     *            the y coordinate of the center of the circle.
     * @param radius
     *            the radius of the circle.
     * @param start
     *            the start angle of the arc in degrees.
     * @param extent
     *            the angle width of the arc in degrees.
     * @param type
     *            the closure type, either {@link Arc2D#OPEN},
     *            {@link Arc2D#CHORD}, or {@link Arc2D#PIE}.
     */
    public void setArcByCenter(double x, double y, double radius, double start, double extent,
            int type) {
        setArc(x - radius, y - radius, radius * 2.0, radius * 2.0, start, extent, type);
    }

    /**
     * Sets the arc data for a circular arc based on two tangent lines and the
     * radius. The two tangent lines are the lines from p1 to p2 and from p2 to
     * p3, which determine a unique circle with the given radius. The start and
     * end points of the arc are the points where the circle touches the two
     * lines, and the arc itself is the shorter of the two circle segments
     * determined by the two points (in other words, it is the piece of the
     * circle that is closer to the lines' intersection point p2 and forms a
     * concave shape with the segments from p1 to p2 and from p2 to p3).
     * 
     * @param p1
     *            a point which determines one of the two tangent lines (with
     *            p2).
     * @param p2
     *            the point of intersection of the two tangent lines.
     * @param p3
     *            a point which determines one of the two tangent lines (with
     *            p2).
     * @param radius
     *            the radius of the circular arc.
     */
    public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3, double radius) {
        // Used simple geometric calculations of arc center, radius and angles
        // by tangents
        double a1 = -Math.atan2(p1.getY() - p2.getY(), p1.getX() - p2.getX());
        double a2 = -Math.atan2(p3.getY() - p2.getY(), p3.getX() - p2.getX());
        double am = (a1 + a2) / 2.0;
        double ah = a1 - am;
        double d = radius / Math.abs(Math.sin(ah));
        double x = p2.getX() + d * Math.cos(am);
        double y = p2.getY() - d * Math.sin(am);
        ah = ah >= 0.0 ? Math.PI * 1.5 - ah : Math.PI * 0.5 - ah;
        a1 = getNormAngle(Math.toDegrees(am - ah));
        a2 = getNormAngle(Math.toDegrees(am + ah));
        double delta = a2 - a1;
        if (delta <= 0.0) {
            delta += 360.0;
        }
        setArcByCenter(x, y, radius, a1, delta, type);
    }

    /**
     * Sets a new start angle to be the angle given by the the vector from the
     * current center point to the specified point.
     * 
     * @param point
     *            the point that determines the new start angle.
     */
    public void setAngleStart(Point2D point) {
        double angle = Math.atan2(point.getY() - getCenterY(), point.getX() - getCenterX());
        setAngleStart(getNormAngle(-Math.toDegrees(angle)));
    }

    /**
     * Sets the angles in terms of vectors from the current arc center to the
     * points (x1, y1) and (x2, y2). The start angle is given by the vector from
     * the current center to the point (x1, y1) and the end angle is given by
     * the vector from the center to the point (x2, y2).
     * 
     * @param x1
     *            the x coordinate of the point whose vector from the center
     *            point determines the new start angle of the arc.
     * @param y1
     *            the y coordinate of the point whose vector from the center
     *            point determines the new start angle of the arc.
     * @param x2
     *            the x coordinate of the point whose vector from the center
     *            point determines the new end angle of the arc.
     * @param y2
     *            the y coordinate of the point whose vector from the center
     *            point determines the new end angle of the arc.
     */
    public void setAngles(double x1, double y1, double x2, double y2) {
        double cx = getCenterX();
        double cy = getCenterY();
        double a1 = getNormAngle(-Math.toDegrees(Math.atan2(y1 - cy, x1 - cx)));
        double a2 = getNormAngle(-Math.toDegrees(Math.atan2(y2 - cy, x2 - cx)));
        a2 -= a1;
        if (a2 <= 0.0) {
            a2 += 360.0;
        }
        setAngleStart(a1);
        setAngleExtent(a2);
    }

    /**
     * Sets the angles in terms of vectors from the current arc center to the
     * points p1 and p2. The start angle is given by the vector from the current
     * center to the point p1 and the end angle is given by the vector from the
     * center to the point p2.
     * 
     * @param p1
     *            the point whose vector from the center point determines the
     *            new start angle of the arc.
     * @param p2
     *            the point whose vector from the center point determines the
     *            new end angle of the arc.
     */
    public void setAngles(Point2D p1, Point2D p2) {
        setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());
    }

    /**
     * Normalizes the angle by removing extra winding (past 360 degrees) and
     * placing it in the positive degree range.
     * 
     * @param angle
     *            the source angle in degrees.
     * @return an angle between 0 and 360 degrees which corresponds to the same
     *         direction vector as the source angle.
     */
    double getNormAngle(double angle) {
        double n = Math.floor(angle / 360.0);
        return angle - n * 360.0;
    }

    /**
     * Determines whether the given angle is contained in the span of the arc.
     * 
     * @param angle
     *            the angle to test in degrees.
     * @return true, if the given angle is between the start angle and the end
     *         angle of the arc.
     */
    public boolean containsAngle(double angle) {
        double extent = getAngleExtent();
        if (extent >= 360.0) {
            return true;
        }
        angle = getNormAngle(angle);
        double a1 = getNormAngle(getAngleStart());
        double a2 = a1 + extent;
        if (a2 > 360.0) {
            return angle >= a1 || angle <= a2 - 360.0;
        }
        if (a2 < 0.0) {
            return angle >= a2 + 360.0 || angle <= a1;
        }
        return extent > 0.0 ? a1 <= angle && angle <= a2 : a2 <= angle && angle <= a1;
    }

    public boolean contains(double px, double py) {
        // Normalize point
        double nx = (px - getX()) / getWidth() - 0.5;
        double ny = (py - getY()) / getHeight() - 0.5;

        if ((nx * nx + ny * ny) > 0.25) {
            return false;
        }

        double extent = getAngleExtent();
        double absExtent = Math.abs(extent);
        if (absExtent >= 360.0) {
            return true;
        }

        boolean containsAngle = containsAngle(Math.toDegrees(-Math.atan2(ny, nx)));
        if (type == PIE) {
            return containsAngle;
        }
        if (absExtent <= 180.0 && !containsAngle) {
            return false;
        }

        Line2D l = new Line2D.Double(getStartPoint(), getEndPoint());
        int ccw1 = l.relativeCCW(px, py);
        int ccw2 = l.relativeCCW(getCenterX(), getCenterY());
        return ccw1 == 0 || ccw2 == 0 || ((ccw1 + ccw2) == 0 ^ absExtent > 180.0);
    }

    public boolean contains(double rx, double ry, double rw, double rh) {

        if (!(contains(rx, ry) && contains(rx + rw, ry) && contains(rx + rw, ry + rh) && contains(
                rx, ry + rh))) {
            return false;
        }

        double absExtent = Math.abs(getAngleExtent());
        if (type != PIE || absExtent <= 180.0 || absExtent >= 360.0) {
            return true;
        }

        Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh);

        double cx = getCenterX();
        double cy = getCenterY();
        if (r.contains(cx, cy)) {
            return false;
        }

        Point2D p1 = getStartPoint();
        Point2D p2 = getEndPoint();

        return !r.intersectsLine(cx, cy, p1.getX(), p1.getY())
                && !r.intersectsLine(cx, cy, p2.getX(), p2.getY());
    }

    @Override
    public boolean contains(Rectangle2D rect) {
        return contains(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
    }

    public boolean intersects(double rx, double ry, double rw, double rh) {

        if (isEmpty() || rw <= 0.0 || rh <= 0.0) {
            return false;
        }

        // Check: Does arc contain rectangle's points
        if (contains(rx, ry) || contains(rx + rw, ry) || contains(rx, ry + rh)
                || contains(rx + rw, ry + rh)) {
            return true;
        }

        double cx = getCenterX();
        double cy = getCenterY();
        Point2D p1 = getStartPoint();
        Point2D p2 = getEndPoint();
        Rectangle2D r = new Rectangle2D.Double(rx, ry, rw, rh);

        // Check: Does rectangle contain arc's points
        if (r.contains(p1) || r.contains(p2) || (type == PIE && r.contains(cx, cy))) {
            return true;
        }

        if (type == PIE) {
            if (r.intersectsLine(p1.getX(), p1.getY(), cx, cy)
                    || r.intersectsLine(p2.getX(), p2.getY(), cx, cy)) {
                return true;
            }
        } else {
            if (r.intersectsLine(p1.getX(), p1.getY(), p2.getX(), p2.getY())) {
                return true;
            }
        }

        // Nearest rectangle point
        double nx = cx < rx ? rx : (cx > rx + rw ? rx + rw : cx);
        double ny = cy < ry ? ry : (cy > ry + rh ? ry + rh : cy);
        return contains(nx, ny);
    }

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

}