| /* |
| * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package java.awt.geom; |
| |
| import java.io.Serializable; |
| |
| /** |
| * <CODE>Arc2D</CODE> is the abstract superclass for all objects that |
| * store a 2D arc defined by a framing rectangle, |
| * start angle, angular extent (length of the arc), and a closure type |
| * (<CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>). |
| * <p> |
| * <a name="inscribes"> |
| * The arc is a partial section of a full ellipse which |
| * inscribes the framing rectangle of its parent {@link RectangularShape}. |
| * </a> |
| * <a name="angles"> |
| * The angles are specified relative to the non-square |
| * framing rectangle such that 45 degrees always falls on the line from |
| * the center of the ellipse to the upper right corner of the framing |
| * rectangle. |
| * As a result, if the framing rectangle is noticeably longer along one |
| * axis than the other, the angles to the start and end of the arc segment |
| * will be skewed farther along the longer axis of the frame. |
| * </a> |
| * <p> |
| * The actual storage representation of the coordinates is left to |
| * the subclass. |
| * |
| * @author Jim Graham |
| * @since 1.2 |
| */ |
| public abstract class Arc2D extends RectangularShape { |
| |
| /** |
| * The closure type for an open arc with no path segments |
| * connecting the two ends of the arc segment. |
| * @since 1.2 |
| */ |
| public final static int OPEN = 0; |
| |
| /** |
| * The closure type for an arc closed by drawing a straight |
| * line segment from the start of the arc segment to the end of the |
| * arc segment. |
| * @since 1.2 |
| */ |
| public final static int CHORD = 1; |
| |
| /** |
| * The closure type for an arc closed by drawing straight line |
| * segments from the start of the arc segment to the center |
| * of the full ellipse and from that point to the end of the arc segment. |
| * @since 1.2 |
| */ |
| public final static int PIE = 2; |
| |
| /** |
| * This class defines an arc specified in {@code float} precision. |
| * @since 1.2 |
| */ |
| public static class Float extends Arc2D implements Serializable { |
| /** |
| * The X coordinate of the upper-left corner of the framing |
| * rectangle of the arc. |
| * @since 1.2 |
| * @serial |
| */ |
| public float x; |
| |
| /** |
| * The Y coordinate of the upper-left corner of the framing |
| * rectangle of the arc. |
| * @since 1.2 |
| * @serial |
| */ |
| public float y; |
| |
| /** |
| * The overall width of the full ellipse of which this arc is |
| * a partial section (not considering the |
| * angular extents). |
| * @since 1.2 |
| * @serial |
| */ |
| public float width; |
| |
| /** |
| * The overall height of the full ellipse of which this arc is |
| * a partial section (not considering the |
| * angular extents). |
| * @since 1.2 |
| * @serial |
| */ |
| public float height; |
| |
| /** |
| * The starting angle of the arc in degrees. |
| * @since 1.2 |
| * @serial |
| */ |
| public float start; |
| |
| /** |
| * The angular extent of the arc in degrees. |
| * @since 1.2 |
| * @serial |
| */ |
| public float extent; |
| |
| /** |
| * Constructs a new OPEN arc, initialized to location (0, 0), |
| * size (0, 0), angular extents (start = 0, extent = 0). |
| * @since 1.2 |
| */ |
| public Float() { |
| super(OPEN); |
| } |
| |
| /** |
| * Constructs a new arc, initialized to location (0, 0), |
| * size (0, 0), angular extents (start = 0, extent = 0), and |
| * the specified closure type. |
| * |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Float(int type) { |
| super(type); |
| } |
| |
| /** |
| * Constructs a new arc, initialized to the specified location, |
| * size, angular extents, and closure type. |
| * |
| * @param x The X coordinate of the upper-left corner of |
| * the arc's framing rectangle. |
| * @param y The Y coordinate of the upper-left corner of |
| * the arc's framing rectangle. |
| * @param w The overall width of the full ellipse of which |
| * this arc is a partial section. |
| * @param h The overall height of the full ellipse of which this |
| * arc is a partial section. |
| * @param start The starting angle of the arc in degrees. |
| * @param extent The angular extent of the arc in degrees. |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Float(float x, float y, float w, float h, |
| float start, float extent, int type) { |
| super(type); |
| this.x = x; |
| this.y = y; |
| this.width = w; |
| this.height = h; |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * Constructs a new arc, initialized to the specified location, |
| * size, angular extents, and closure type. |
| * |
| * @param ellipseBounds The framing rectangle that defines the |
| * outer boundary of the full ellipse of which this arc is a |
| * partial section. |
| * @param start The starting angle of the arc in degrees. |
| * @param extent The angular extent of the arc in degrees. |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Float(Rectangle2D ellipseBounds, |
| float start, float extent, int type) { |
| super(type); |
| this.x = (float) ellipseBounds.getX(); |
| this.y = (float) ellipseBounds.getY(); |
| this.width = (float) ellipseBounds.getWidth(); |
| this.height = (float) ellipseBounds.getHeight(); |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getX() { |
| return (double) x; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getY() { |
| return (double) y; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getWidth() { |
| return (double) width; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getHeight() { |
| return (double) height; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public double getAngleStart() { |
| return (double) start; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public double getAngleExtent() { |
| return (double) extent; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public boolean isEmpty() { |
| return (width <= 0.0 || height <= 0.0); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setArc(double x, double y, double w, double h, |
| double angSt, double angExt, int closure) { |
| this.setArcType(closure); |
| this.x = (float) x; |
| this.y = (float) y; |
| this.width = (float) w; |
| this.height = (float) h; |
| this.start = (float) angSt; |
| this.extent = (float) angExt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setAngleStart(double angSt) { |
| this.start = (float) angSt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setAngleExtent(double angExt) { |
| this.extent = (float) angExt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| protected Rectangle2D makeBounds(double x, double y, |
| double w, double h) { |
| return new Rectangle2D.Float((float) x, (float) y, |
| (float) w, (float) h); |
| } |
| |
| /* |
| * JDK 1.6 serialVersionUID |
| */ |
| private static final long serialVersionUID = 9130893014586380278L; |
| |
| /** |
| * Writes the default serializable fields to the |
| * <code>ObjectOutputStream</code> followed by a byte |
| * indicating the arc type of this <code>Arc2D</code> |
| * instance. |
| * |
| * @serialData |
| * <ol> |
| * <li>The default serializable fields. |
| * <li> |
| * followed by a <code>byte</code> indicating the arc type |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * </ol> |
| */ |
| private void writeObject(java.io.ObjectOutputStream s) |
| throws java.io.IOException |
| { |
| s.defaultWriteObject(); |
| |
| s.writeByte(getArcType()); |
| } |
| |
| /** |
| * Reads the default serializable fields from the |
| * <code>ObjectInputStream</code> followed by a byte |
| * indicating the arc type of this <code>Arc2D</code> |
| * instance. |
| * |
| * @serialData |
| * <ol> |
| * <li>The default serializable fields. |
| * <li> |
| * followed by a <code>byte</code> indicating the arc type |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * </ol> |
| */ |
| private void readObject(java.io.ObjectInputStream s) |
| throws java.lang.ClassNotFoundException, java.io.IOException |
| { |
| s.defaultReadObject(); |
| |
| try { |
| setArcType(s.readByte()); |
| } catch (IllegalArgumentException iae) { |
| throw new java.io.InvalidObjectException(iae.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * This class defines an arc specified in {@code double} precision. |
| * @since 1.2 |
| */ |
| public static class Double extends Arc2D implements Serializable { |
| /** |
| * The X coordinate of the upper-left corner of the framing |
| * rectangle of the arc. |
| * @since 1.2 |
| * @serial |
| */ |
| public double x; |
| |
| /** |
| * The Y coordinate of the upper-left corner of the framing |
| * rectangle of the arc. |
| * @since 1.2 |
| * @serial |
| */ |
| public double y; |
| |
| /** |
| * The overall width of the full ellipse of which this arc is |
| * a partial section (not considering the angular extents). |
| * @since 1.2 |
| * @serial |
| */ |
| public double width; |
| |
| /** |
| * The overall height of the full ellipse of which this arc is |
| * a partial section (not considering the angular extents). |
| * @since 1.2 |
| * @serial |
| */ |
| public double height; |
| |
| /** |
| * The starting angle of the arc in degrees. |
| * @since 1.2 |
| * @serial |
| */ |
| public double start; |
| |
| /** |
| * The angular extent of the arc in degrees. |
| * @since 1.2 |
| * @serial |
| */ |
| public double extent; |
| |
| /** |
| * Constructs a new OPEN arc, initialized to location (0, 0), |
| * size (0, 0), angular extents (start = 0, extent = 0). |
| * @since 1.2 |
| */ |
| public Double() { |
| super(OPEN); |
| } |
| |
| /** |
| * Constructs a new arc, initialized to location (0, 0), |
| * size (0, 0), angular extents (start = 0, extent = 0), and |
| * the specified closure type. |
| * |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Double(int type) { |
| super(type); |
| } |
| |
| /** |
| * Constructs a new arc, initialized to the specified location, |
| * size, angular extents, and closure type. |
| * |
| * @param x The X coordinate of the upper-left corner |
| * of the arc's framing rectangle. |
| * @param y The Y coordinate of the upper-left corner |
| * of the arc's framing rectangle. |
| * @param w The overall width of the full ellipse of which this |
| * arc is a partial section. |
| * @param h The overall height of the full ellipse of which this |
| * arc is a partial section. |
| * @param start The starting angle of the arc in degrees. |
| * @param extent The angular extent of the arc in degrees. |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Double(double x, double y, double w, double h, |
| double start, double extent, int type) { |
| super(type); |
| this.x = x; |
| this.y = y; |
| this.width = w; |
| this.height = h; |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * Constructs a new arc, initialized to the specified location, |
| * size, angular extents, and closure type. |
| * |
| * @param ellipseBounds The framing rectangle that defines the |
| * outer boundary of the full ellipse of which this arc is a |
| * partial section. |
| * @param start The starting angle of the arc in degrees. |
| * @param extent The angular extent of the arc in degrees. |
| * @param type The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public Double(Rectangle2D ellipseBounds, |
| double start, double extent, int type) { |
| super(type); |
| this.x = ellipseBounds.getX(); |
| this.y = ellipseBounds.getY(); |
| this.width = ellipseBounds.getWidth(); |
| this.height = ellipseBounds.getHeight(); |
| this.start = start; |
| this.extent = extent; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getX() { |
| return x; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getY() { |
| return y; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getWidth() { |
| return width; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public double getHeight() { |
| return height; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public double getAngleStart() { |
| return start; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public double getAngleExtent() { |
| return extent; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public boolean isEmpty() { |
| return (width <= 0.0 || height <= 0.0); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setArc(double x, double y, double w, double h, |
| double angSt, double angExt, int closure) { |
| this.setArcType(closure); |
| this.x = x; |
| this.y = y; |
| this.width = w; |
| this.height = h; |
| this.start = angSt; |
| this.extent = angExt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setAngleStart(double angSt) { |
| this.start = angSt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| public void setAngleExtent(double angExt) { |
| this.extent = angExt; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * @since 1.2 |
| */ |
| protected Rectangle2D makeBounds(double x, double y, |
| double w, double h) { |
| return new Rectangle2D.Double(x, y, w, h); |
| } |
| |
| /* |
| * JDK 1.6 serialVersionUID |
| */ |
| private static final long serialVersionUID = 728264085846882001L; |
| |
| /** |
| * Writes the default serializable fields to the |
| * <code>ObjectOutputStream</code> followed by a byte |
| * indicating the arc type of this <code>Arc2D</code> |
| * instance. |
| * |
| * @serialData |
| * <ol> |
| * <li>The default serializable fields. |
| * <li> |
| * followed by a <code>byte</code> indicating the arc type |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * </ol> |
| */ |
| private void writeObject(java.io.ObjectOutputStream s) |
| throws java.io.IOException |
| { |
| s.defaultWriteObject(); |
| |
| s.writeByte(getArcType()); |
| } |
| |
| /** |
| * Reads the default serializable fields from the |
| * <code>ObjectInputStream</code> followed by a byte |
| * indicating the arc type of this <code>Arc2D</code> |
| * instance. |
| * |
| * @serialData |
| * <ol> |
| * <li>The default serializable fields. |
| * <li> |
| * followed by a <code>byte</code> indicating the arc type |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * </ol> |
| */ |
| private void readObject(java.io.ObjectInputStream s) |
| throws java.lang.ClassNotFoundException, java.io.IOException |
| { |
| s.defaultReadObject(); |
| |
| try { |
| setArcType(s.readByte()); |
| } catch (IllegalArgumentException iae) { |
| throw new java.io.InvalidObjectException(iae.getMessage()); |
| } |
| } |
| } |
| |
| private int type; |
| |
| /** |
| * This is an abstract class that cannot be instantiated directly. |
| * Type-specific implementation subclasses are available for |
| * instantiation and provide a number of formats for storing |
| * the information necessary to satisfy the various accessor |
| * methods below. |
| * <p> |
| * This constructor creates an object with a default closure |
| * type of {@link #OPEN}. It is provided only to enable |
| * serialization of subclasses. |
| * |
| * @see java.awt.geom.Arc2D.Float |
| * @see java.awt.geom.Arc2D.Double |
| */ |
| protected Arc2D() { |
| this(OPEN); |
| } |
| |
| /** |
| * This is an abstract class that cannot be instantiated directly. |
| * Type-specific implementation subclasses are available for |
| * instantiation and provide a number of formats for storing |
| * the information necessary to satisfy the various accessor |
| * methods below. |
| * |
| * @param type The closure type of this arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @see java.awt.geom.Arc2D.Float |
| * @see java.awt.geom.Arc2D.Double |
| * @since 1.2 |
| */ |
| protected Arc2D(int type) { |
| setArcType(type); |
| } |
| |
| /** |
| * Returns the starting angle of the arc. |
| * |
| * @return A double value that represents the starting angle |
| * of the arc in degrees. |
| * @see #setAngleStart |
| * @since 1.2 |
| */ |
| public abstract double getAngleStart(); |
| |
| /** |
| * Returns the angular extent of the arc. |
| * |
| * @return A double value that represents the angular extent |
| * of the arc in degrees. |
| * @see #setAngleExtent |
| * @since 1.2 |
| */ |
| public abstract double getAngleExtent(); |
| |
| /** |
| * Returns the arc closure type of the arc: {@link #OPEN}, |
| * {@link #CHORD}, or {@link #PIE}. |
| * @return One of the integer constant closure types defined |
| * in this class. |
| * @see #setArcType |
| * @since 1.2 |
| */ |
| public int getArcType() { |
| return type; |
| } |
| |
| /** |
| * Returns the starting point of the arc. This point is the |
| * intersection of the ray from the center defined by the |
| * starting angle and the elliptical boundary of the arc. |
| * |
| * @return A <CODE>Point2D</CODE> object representing the |
| * x,y coordinates of the starting point of the arc. |
| * @since 1.2 |
| */ |
| public Point2D getStartPoint() { |
| double angle = Math.toRadians(-getAngleStart()); |
| double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth(); |
| double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight(); |
| return new Point2D.Double(x, y); |
| } |
| |
| /** |
| * Returns the ending point of the arc. This point is the |
| * intersection of the ray from the center defined by the |
| * starting angle plus the angular extent of the arc and the |
| * elliptical boundary of the arc. |
| * |
| * @return A <CODE>Point2D</CODE> object representing the |
| * x,y coordinates of the ending point of the arc. |
| * @since 1.2 |
| */ |
| public Point2D getEndPoint() { |
| double angle = Math.toRadians(-getAngleStart() - getAngleExtent()); |
| double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth(); |
| double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight(); |
| return new Point2D.Double(x, y); |
| } |
| |
| /** |
| * Sets the location, size, angular extents, and closure type of |
| * this arc to the specified double values. |
| * |
| * @param x The X coordinate of the upper-left corner of the arc. |
| * @param y The Y coordinate of the upper-left corner of the arc. |
| * @param w The overall width of the full ellipse of which |
| * this arc is a partial section. |
| * @param h The overall height of the full ellipse of which |
| * this arc is a partial section. |
| * @param angSt The starting angle of the arc in degrees. |
| * @param angExt The angular extent of the arc in degrees. |
| * @param closure The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public abstract void setArc(double x, double y, double w, double h, |
| double angSt, double angExt, int closure); |
| |
| /** |
| * Sets the location, size, angular extents, and closure type of |
| * this arc to the specified values. |
| * |
| * @param loc The <CODE>Point2D</CODE> representing the coordinates of |
| * the upper-left corner of the arc. |
| * @param size The <CODE>Dimension2D</CODE> representing the width |
| * and height of the full ellipse of which this arc is |
| * a partial section. |
| * @param angSt The starting angle of the arc in degrees. |
| * @param angExt The angular extent of the arc in degrees. |
| * @param closure The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public void setArc(Point2D loc, Dimension2D size, |
| double angSt, double angExt, int closure) { |
| setArc(loc.getX(), loc.getY(), size.getWidth(), size.getHeight(), |
| angSt, angExt, closure); |
| } |
| |
| /** |
| * Sets the location, size, angular extents, and closure type of |
| * this arc to the specified values. |
| * |
| * @param rect The framing rectangle that defines the |
| * outer boundary of the full ellipse of which this arc is a |
| * partial section. |
| * @param angSt The starting angle of the arc in degrees. |
| * @param angExt The angular extent of the arc in degrees. |
| * @param closure The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public void setArc(Rectangle2D rect, double angSt, double angExt, |
| int closure) { |
| setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(), |
| angSt, angExt, closure); |
| } |
| |
| /** |
| * Sets this arc to be the same as the specified arc. |
| * |
| * @param a The <CODE>Arc2D</CODE> to use to set the arc's values. |
| * @since 1.2 |
| */ |
| public void setArc(Arc2D a) { |
| setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(), |
| a.getAngleStart(), a.getAngleExtent(), a.type); |
| } |
| |
| /** |
| * Sets the position, bounds, angular extents, and closure type of |
| * this arc to the specified values. The arc is defined by a center |
| * point and a radius rather than a framing rectangle for the full ellipse. |
| * |
| * @param x The X coordinate of the center of the arc. |
| * @param y The Y coordinate of the center of the arc. |
| * @param radius The radius of the arc. |
| * @param angSt The starting angle of the arc in degrees. |
| * @param angExt The angular extent of the arc in degrees. |
| * @param closure The closure type for the arc: |
| * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. |
| * @since 1.2 |
| */ |
| public void setArcByCenter(double x, double y, double radius, |
| double angSt, double angExt, int closure) { |
| setArc(x - radius, y - radius, radius * 2.0, radius * 2.0, |
| angSt, angExt, closure); |
| } |
| |
| /** |
| * Sets the position, bounds, and angular extents of this arc to the |
| * specified value. The starting angle of the arc is tangent to the |
| * line specified by points (p1, p2), the ending angle is tangent to |
| * the line specified by points (p2, p3), and the arc has the |
| * specified radius. |
| * |
| * @param p1 The first point that defines the arc. The starting |
| * angle of the arc is tangent to the line specified by points (p1, p2). |
| * @param p2 The second point that defines the arc. The starting |
| * angle of the arc is tangent to the line specified by points (p1, p2). |
| * The ending angle of the arc is tangent to the line specified by |
| * points (p2, p3). |
| * @param p3 The third point that defines the arc. The ending angle |
| * of the arc is tangent to the line specified by points (p2, p3). |
| * @param radius The radius of the arc. |
| * @since 1.2 |
| */ |
| public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3, |
| double radius) { |
| double ang1 = Math.atan2(p1.getY() - p2.getY(), |
| p1.getX() - p2.getX()); |
| double ang2 = Math.atan2(p3.getY() - p2.getY(), |
| p3.getX() - p2.getX()); |
| double diff = ang2 - ang1; |
| if (diff > Math.PI) { |
| ang2 -= Math.PI * 2.0; |
| } else if (diff < -Math.PI) { |
| ang2 += Math.PI * 2.0; |
| } |
| double bisect = (ang1 + ang2) / 2.0; |
| double theta = Math.abs(ang2 - bisect); |
| double dist = radius / Math.sin(theta); |
| double x = p2.getX() + dist * Math.cos(bisect); |
| double y = p2.getY() + dist * Math.sin(bisect); |
| // REMIND: This needs some work... |
| if (ang1 < ang2) { |
| ang1 -= Math.PI / 2.0; |
| ang2 += Math.PI / 2.0; |
| } else { |
| ang1 += Math.PI / 2.0; |
| ang2 -= Math.PI / 2.0; |
| } |
| ang1 = Math.toDegrees(-ang1); |
| ang2 = Math.toDegrees(-ang2); |
| diff = ang2 - ang1; |
| if (diff < 0) { |
| diff += 360; |
| } else { |
| diff -= 360; |
| } |
| setArcByCenter(x, y, radius, ang1, diff, type); |
| } |
| |
| /** |
| * Sets the starting angle of this arc to the specified double |
| * value. |
| * |
| * @param angSt The starting angle of the arc in degrees. |
| * @see #getAngleStart |
| * @since 1.2 |
| */ |
| public abstract void setAngleStart(double angSt); |
| |
| /** |
| * Sets the angular extent of this arc to the specified double |
| * value. |
| * |
| * @param angExt The angular extent of the arc in degrees. |
| * @see #getAngleExtent |
| * @since 1.2 |
| */ |
| public abstract void setAngleExtent(double angExt); |
| |
| /** |
| * Sets the starting angle of this arc to the angle that the |
| * specified point defines relative to the center of this arc. |
| * The angular extent of the arc will remain the same. |
| * |
| * @param p The <CODE>Point2D</CODE> that defines the starting angle. |
| * @see #getAngleStart |
| * @since 1.2 |
| */ |
| public void setAngleStart(Point2D p) { |
| // Bias the dx and dy by the height and width of the oval. |
| double dx = getHeight() * (p.getX() - getCenterX()); |
| double dy = getWidth() * (p.getY() - getCenterY()); |
| setAngleStart(-Math.toDegrees(Math.atan2(dy, dx))); |
| } |
| |
| /** |
| * Sets the starting angle and angular extent of this arc using two |
| * sets of coordinates. The first set of coordinates is used to |
| * determine the angle of the starting point relative to the arc's |
| * center. The second set of coordinates is used to determine the |
| * angle of the end point relative to the arc's center. |
| * The arc will always be non-empty and extend counterclockwise |
| * from the first point around to the second point. |
| * |
| * @param x1 The X coordinate of the arc's starting point. |
| * @param y1 The Y coordinate of the arc's starting point. |
| * @param x2 The X coordinate of the arc's ending point. |
| * @param y2 The Y coordinate of the arc's ending point. |
| * @since 1.2 |
| */ |
| public void setAngles(double x1, double y1, double x2, double y2) { |
| double x = getCenterX(); |
| double y = getCenterY(); |
| double w = getWidth(); |
| double h = getHeight(); |
| // Note: reversing the Y equations negates the angle to adjust |
| // for the upside down coordinate system. |
| // Also we should bias atans by the height and width of the oval. |
| double ang1 = Math.atan2(w * (y - y1), h * (x1 - x)); |
| double ang2 = Math.atan2(w * (y - y2), h * (x2 - x)); |
| ang2 -= ang1; |
| if (ang2 <= 0.0) { |
| ang2 += Math.PI * 2.0; |
| } |
| setAngleStart(Math.toDegrees(ang1)); |
| setAngleExtent(Math.toDegrees(ang2)); |
| } |
| |
| /** |
| * Sets the starting angle and angular extent of this arc using |
| * two points. The first point is used to determine the angle of |
| * the starting point relative to the arc's center. |
| * The second point is used to determine the angle of the end point |
| * relative to the arc's center. |
| * The arc will always be non-empty and extend counterclockwise |
| * from the first point around to the second point. |
| * |
| * @param p1 The <CODE>Point2D</CODE> that defines the arc's |
| * starting point. |
| * @param p2 The <CODE>Point2D</CODE> that defines the arc's |
| * ending point. |
| * @since 1.2 |
| */ |
| public void setAngles(Point2D p1, Point2D p2) { |
| setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY()); |
| } |
| |
| /** |
| * Sets the closure type of this arc to the specified value: |
| * <CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>. |
| * |
| * @param type The integer constant that represents the closure |
| * type of this arc: {@link #OPEN}, {@link #CHORD}, or |
| * {@link #PIE}. |
| * |
| * @throws IllegalArgumentException if <code>type</code> is not |
| * 0, 1, or 2.+ |
| * @see #getArcType |
| * @since 1.2 |
| */ |
| public void setArcType(int type) { |
| if (type < OPEN || type > PIE) { |
| throw new IllegalArgumentException("invalid type for Arc: "+type); |
| } |
| this.type = type; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * Note that the arc |
| * <a href="Arc2D.html#inscribes">partially inscribes</a> |
| * the framing rectangle of this {@code RectangularShape}. |
| * |
| * @since 1.2 |
| */ |
| public void setFrame(double x, double y, double w, double h) { |
| setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type); |
| } |
| |
| /** |
| * Returns the high-precision framing rectangle of the arc. The framing |
| * rectangle contains only the part of this <code>Arc2D</code> that is |
| * in between the starting and ending angles and contains the pie |
| * wedge, if this <code>Arc2D</code> has a <code>PIE</code> closure type. |
| * <p> |
| * This method differs from the |
| * {@link RectangularShape#getBounds() getBounds} in that the |
| * <code>getBounds</code> method only returns the bounds of the |
| * enclosing ellipse of this <code>Arc2D</code> without considering |
| * the starting and ending angles of this <code>Arc2D</code>. |
| * |
| * @return the <CODE>Rectangle2D</CODE> that represents the arc's |
| * framing rectangle. |
| * @since 1.2 |
| */ |
| public Rectangle2D getBounds2D() { |
| if (isEmpty()) { |
| return makeBounds(getX(), getY(), getWidth(), getHeight()); |
| } |
| double x1, y1, x2, y2; |
| if (getArcType() == PIE) { |
| x1 = y1 = x2 = y2 = 0.0; |
| } else { |
| x1 = y1 = 1.0; |
| x2 = y2 = -1.0; |
| } |
| double angle = 0.0; |
| for (int i = 0; i < 6; i++) { |
| if (i < 4) { |
| // 0-3 are the four quadrants |
| angle += 90.0; |
| if (!containsAngle(angle)) { |
| continue; |
| } |
| } else if (i == 4) { |
| // 4 is start angle |
| angle = getAngleStart(); |
| } else { |
| // 5 is end angle |
| angle += getAngleExtent(); |
| } |
| double rads = Math.toRadians(-angle); |
| double xe = Math.cos(rads); |
| double ye = Math.sin(rads); |
| x1 = Math.min(x1, xe); |
| y1 = Math.min(y1, ye); |
| x2 = Math.max(x2, xe); |
| y2 = Math.max(y2, ye); |
| } |
| double w = getWidth(); |
| double h = getHeight(); |
| x2 = (x2 - x1) * 0.5 * w; |
| y2 = (y2 - y1) * 0.5 * h; |
| x1 = getX() + (x1 * 0.5 + 0.5) * w; |
| y1 = getY() + (y1 * 0.5 + 0.5) * h; |
| return makeBounds(x1, y1, x2, y2); |
| } |
| |
| /** |
| * Constructs a <code>Rectangle2D</code> of the appropriate precision |
| * to hold the parameters calculated to be the framing rectangle |
| * of this arc. |
| * |
| * @param x The X coordinate of the upper-left corner of the |
| * framing rectangle. |
| * @param y The Y coordinate of the upper-left corner of the |
| * framing rectangle. |
| * @param w The width of the framing rectangle. |
| * @param h The height of the framing rectangle. |
| * @return a <code>Rectangle2D</code> that is the framing rectangle |
| * of this arc. |
| * @since 1.2 |
| */ |
| protected abstract Rectangle2D makeBounds(double x, double y, |
| double w, double h); |
| |
| /* |
| * Normalizes the specified angle into the range -180 to 180. |
| */ |
| static double normalizeDegrees(double angle) { |
| if (angle > 180.0) { |
| if (angle <= (180.0 + 360.0)) { |
| angle = angle - 360.0; |
| } else { |
| angle = Math.IEEEremainder(angle, 360.0); |
| // IEEEremainder can return -180 here for some input values... |
| if (angle == -180.0) { |
| angle = 180.0; |
| } |
| } |
| } else if (angle <= -180.0) { |
| if (angle > (-180.0 - 360.0)) { |
| angle = angle + 360.0; |
| } else { |
| angle = Math.IEEEremainder(angle, 360.0); |
| // IEEEremainder can return -180 here for some input values... |
| if (angle == -180.0) { |
| angle = 180.0; |
| } |
| } |
| } |
| return angle; |
| } |
| |
| /** |
| * Determines whether or not the specified angle is within the |
| * angular extents of the arc. |
| * |
| * @param angle The angle to test. |
| * |
| * @return <CODE>true</CODE> if the arc contains the angle, |
| * <CODE>false</CODE> if the arc doesn't contain the angle. |
| * @since 1.2 |
| */ |
| public boolean containsAngle(double angle) { |
| double angExt = getAngleExtent(); |
| boolean backwards = (angExt < 0.0); |
| if (backwards) { |
| angExt = -angExt; |
| } |
| if (angExt >= 360.0) { |
| return true; |
| } |
| angle = normalizeDegrees(angle) - normalizeDegrees(getAngleStart()); |
| if (backwards) { |
| angle = -angle; |
| } |
| if (angle < 0.0) { |
| angle += 360.0; |
| } |
| |
| |
| return (angle >= 0.0) && (angle < angExt); |
| } |
| |
| /** |
| * Determines whether or not the specified point is inside the boundary |
| * of the arc. |
| * |
| * @param x The X coordinate of the point to test. |
| * @param y The Y coordinate of the point to test. |
| * |
| * @return <CODE>true</CODE> if the point lies within the bound of |
| * the arc, <CODE>false</CODE> if the point lies outside of the |
| * arc's bounds. |
| * @since 1.2 |
| */ |
| public boolean contains(double x, double y) { |
| // Normalize the coordinates compared to the ellipse |
| // having a center at 0,0 and a radius of 0.5. |
| double ellw = getWidth(); |
| if (ellw <= 0.0) { |
| return false; |
| } |
| double normx = (x - getX()) / ellw - 0.5; |
| double ellh = getHeight(); |
| if (ellh <= 0.0) { |
| return false; |
| } |
| double normy = (y - getY()) / ellh - 0.5; |
| double distSq = (normx * normx + normy * normy); |
| if (distSq >= 0.25) { |
| return false; |
| } |
| double angExt = Math.abs(getAngleExtent()); |
| if (angExt >= 360.0) { |
| return true; |
| } |
| boolean inarc = containsAngle(-Math.toDegrees(Math.atan2(normy, |
| normx))); |
| if (type == PIE) { |
| return inarc; |
| } |
| // CHORD and OPEN behave the same way |
| if (inarc) { |
| if (angExt >= 180.0) { |
| return true; |
| } |
| // point must be outside the "pie triangle" |
| } else { |
| if (angExt <= 180.0) { |
| return false; |
| } |
| // point must be inside the "pie triangle" |
| } |
| // The point is inside the pie triangle iff it is on the same |
| // side of the line connecting the ends of the arc as the center. |
| double angle = Math.toRadians(-getAngleStart()); |
| double x1 = Math.cos(angle); |
| double y1 = Math.sin(angle); |
| angle += Math.toRadians(-getAngleExtent()); |
| double x2 = Math.cos(angle); |
| double y2 = Math.sin(angle); |
| boolean inside = (Line2D.relativeCCW(x1, y1, x2, y2, 2*normx, 2*normy) * |
| Line2D.relativeCCW(x1, y1, x2, y2, 0, 0) >= 0); |
| return inarc ? !inside : inside; |
| } |
| |
| /** |
| * Determines whether or not the interior of the arc intersects |
| * the interior of the specified rectangle. |
| * |
| * @param x The X coordinate of the rectangle's upper-left corner. |
| * @param y The Y coordinate of the rectangle's upper-left corner. |
| * @param w The width of the rectangle. |
| * @param h The height of the rectangle. |
| * |
| * @return <CODE>true</CODE> if the arc intersects the rectangle, |
| * <CODE>false</CODE> if the arc doesn't intersect the rectangle. |
| * @since 1.2 |
| */ |
| public boolean intersects(double x, double y, double w, double h) { |
| |
| double aw = getWidth(); |
| double ah = getHeight(); |
| |
| if ( w <= 0 || h <= 0 || aw <= 0 || ah <= 0 ) { |
| return false; |
| } |
| double ext = getAngleExtent(); |
| if (ext == 0) { |
| return false; |
| } |
| |
| double ax = getX(); |
| double ay = getY(); |
| double axw = ax + aw; |
| double ayh = ay + ah; |
| double xw = x + w; |
| double yh = y + h; |
| |
| // check bbox |
| if (x >= axw || y >= ayh || xw <= ax || yh <= ay) { |
| return false; |
| } |
| |
| // extract necessary data |
| double axc = getCenterX(); |
| double ayc = getCenterY(); |
| Point2D sp = getStartPoint(); |
| Point2D ep = getEndPoint(); |
| double sx = sp.getX(); |
| double sy = sp.getY(); |
| double ex = ep.getX(); |
| double ey = ep.getY(); |
| |
| /* |
| * Try to catch rectangles that intersect arc in areas |
| * outside of rectagle with left top corner coordinates |
| * (min(center x, start point x, end point x), |
| * min(center y, start point y, end point y)) |
| * and rigth bottom corner coordinates |
| * (max(center x, start point x, end point x), |
| * max(center y, start point y, end point y)). |
| * So we'll check axis segments outside of rectangle above. |
| */ |
| if (ayc >= y && ayc <= yh) { // 0 and 180 |
| if ((sx < xw && ex < xw && axc < xw && |
| axw > x && containsAngle(0)) || |
| (sx > x && ex > x && axc > x && |
| ax < xw && containsAngle(180))) { |
| return true; |
| } |
| } |
| if (axc >= x && axc <= xw) { // 90 and 270 |
| if ((sy > y && ey > y && ayc > y && |
| ay < yh && containsAngle(90)) || |
| (sy < yh && ey < yh && ayc < yh && |
| ayh > y && containsAngle(270))) { |
| return true; |
| } |
| } |
| |
| /* |
| * For PIE we should check intersection with pie slices; |
| * also we should do the same for arcs with extent is greater |
| * than 180, because we should cover case of rectangle, which |
| * situated between center of arc and chord, but does not |
| * intersect the chord. |
| */ |
| Rectangle2D rect = new Rectangle2D.Double(x, y, w, h); |
| if (type == PIE || Math.abs(ext) > 180) { |
| // for PIE: try to find intersections with pie slices |
| if (rect.intersectsLine(axc, ayc, sx, sy) || |
| rect.intersectsLine(axc, ayc, ex, ey)) { |
| return true; |
| } |
| } else { |
| // for CHORD and OPEN: try to find intersections with chord |
| if (rect.intersectsLine(sx, sy, ex, ey)) { |
| return true; |
| } |
| } |
| |
| // finally check the rectangle corners inside the arc |
| if (contains(x, y) || contains(x + w, y) || |
| contains(x, y + h) || contains(x + w, y + h)) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Determines whether or not the interior of the arc entirely contains |
| * the specified rectangle. |
| * |
| * @param x The X coordinate of the rectangle's upper-left corner. |
| * @param y The Y coordinate of the rectangle's upper-left corner. |
| * @param w The width of the rectangle. |
| * @param h The height of the rectangle. |
| * |
| * @return <CODE>true</CODE> if the arc contains the rectangle, |
| * <CODE>false</CODE> if the arc doesn't contain the rectangle. |
| * @since 1.2 |
| */ |
| public boolean contains(double x, double y, double w, double h) { |
| return contains(x, y, w, h, null); |
| } |
| |
| /** |
| * Determines whether or not the interior of the arc entirely contains |
| * the specified rectangle. |
| * |
| * @param r The <CODE>Rectangle2D</CODE> to test. |
| * |
| * @return <CODE>true</CODE> if the arc contains the rectangle, |
| * <CODE>false</CODE> if the arc doesn't contain the rectangle. |
| * @since 1.2 |
| */ |
| public boolean contains(Rectangle2D r) { |
| return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight(), r); |
| } |
| |
| private boolean contains(double x, double y, double w, double h, |
| Rectangle2D origrect) { |
| if (!(contains(x, y) && |
| contains(x + w, y) && |
| contains(x, y + h) && |
| contains(x + w, y + h))) { |
| return false; |
| } |
| // If the shape is convex then we have done all the testing |
| // we need. Only PIE arcs can be concave and then only if |
| // the angular extents are greater than 180 degrees. |
| if (type != PIE || Math.abs(getAngleExtent()) <= 180.0) { |
| return true; |
| } |
| // For a PIE shape we have an additional test for the case where |
| // the angular extents are greater than 180 degrees and all four |
| // rectangular corners are inside the shape but one of the |
| // rectangle edges spans across the "missing wedge" of the arc. |
| // We can test for this case by checking if the rectangle intersects |
| // either of the pie angle segments. |
| if (origrect == null) { |
| origrect = new Rectangle2D.Double(x, y, w, h); |
| } |
| double halfW = getWidth() / 2.0; |
| double halfH = getHeight() / 2.0; |
| double xc = getX() + halfW; |
| double yc = getY() + halfH; |
| double angle = Math.toRadians(-getAngleStart()); |
| double xe = xc + halfW * Math.cos(angle); |
| double ye = yc + halfH * Math.sin(angle); |
| if (origrect.intersectsLine(xc, yc, xe, ye)) { |
| return false; |
| } |
| angle += Math.toRadians(-getAngleExtent()); |
| xe = xc + halfW * Math.cos(angle); |
| ye = yc + halfH * Math.sin(angle); |
| return !origrect.intersectsLine(xc, yc, xe, ye); |
| } |
| |
| /** |
| * Returns an iteration object that defines the boundary of the |
| * arc. |
| * This iterator is multithread safe. |
| * <code>Arc2D</code> guarantees that |
| * modifications to the geometry of the arc |
| * do not affect any iterations of that geometry that |
| * are already in process. |
| * |
| * @param at an optional <CODE>AffineTransform</CODE> to be applied |
| * to the coordinates as they are returned in the iteration, or null |
| * if the untransformed coordinates are desired. |
| * |
| * @return A <CODE>PathIterator</CODE> that defines the arc's boundary. |
| * @since 1.2 |
| */ |
| public PathIterator getPathIterator(AffineTransform at) { |
| return new ArcIterator(this, at); |
| } |
| |
| /** |
| * Returns the hashcode for this <code>Arc2D</code>. |
| * @return the hashcode for this <code>Arc2D</code>. |
| * @since 1.6 |
| */ |
| public int hashCode() { |
| long bits = java.lang.Double.doubleToLongBits(getX()); |
| bits += java.lang.Double.doubleToLongBits(getY()) * 37; |
| bits += java.lang.Double.doubleToLongBits(getWidth()) * 43; |
| bits += java.lang.Double.doubleToLongBits(getHeight()) * 47; |
| bits += java.lang.Double.doubleToLongBits(getAngleStart()) * 53; |
| bits += java.lang.Double.doubleToLongBits(getAngleExtent()) * 59; |
| bits += getArcType() * 61; |
| return (((int) bits) ^ ((int) (bits >> 32))); |
| } |
| |
| /** |
| * Determines whether or not the specified <code>Object</code> is |
| * equal to this <code>Arc2D</code>. The specified |
| * <code>Object</code> is equal to this <code>Arc2D</code> |
| * if it is an instance of <code>Arc2D</code> and if its |
| * location, size, arc extents and type are the same as this |
| * <code>Arc2D</code>. |
| * @param obj an <code>Object</code> to be compared with this |
| * <code>Arc2D</code>. |
| * @return <code>true</code> if <code>obj</code> is an instance |
| * of <code>Arc2D</code> and has the same values; |
| * <code>false</code> otherwise. |
| * @since 1.6 |
| */ |
| public boolean equals(Object obj) { |
| if (obj == this) { |
| return true; |
| } |
| if (obj instanceof Arc2D) { |
| Arc2D a2d = (Arc2D) obj; |
| return ((getX() == a2d.getX()) && |
| (getY() == a2d.getY()) && |
| (getWidth() == a2d.getWidth()) && |
| (getHeight() == a2d.getHeight()) && |
| (getAngleStart() == a2d.getAngleStart()) && |
| (getAngleExtent() == a2d.getAngleExtent()) && |
| (getArcType() == a2d.getArcType())); |
| } |
| return false; |
| } |
| } |
