You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1475 lines
48 KiB
1475 lines
48 KiB
/*
|
|
* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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;
|
|
}
|
|
}
|