| Method from java.awt.geom.Arc2D Detail: |
|---|
 public boolean contains(Rectangle2D r) {
return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight(), r);
}
Determines whether or not the interior of the arc entirely contains
the specified rectangle. |
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 specified point is inside the boundary
of the arc. |
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. |
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 angle is within the
angular extents of the arc. |
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;
} Determines whether or not the specified Object is
equal to this Arc2D. The specified
Object is equal to this Arc2D
if it is an instance of Arc2D and if its
location, size, arc extents and type are the same as this
Arc2D. |
 abstract public double getAngleExtent()
Returns the angular extent of the arc. |
abstract public double getAngleStart() Returns the starting angle of the arc. |
public int getArcType() {
return type;
} |
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);
} Returns the high-precision framing rectangle of the arc. The framing
rectangle contains only the part of this Arc2D that is
in between the starting and ending angles and contains the pie
wedge, if this Arc2D has a PIE closure type.
This method differs from the
getBounds in that the
getBounds method only returns the bounds of the
enclosing ellipse of this Arc2D without considering
the starting and ending angles of this Arc2D. |
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);
} 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. |
public PathIterator getPathIterator(AffineTransform at) {
return new ArcIterator(this, at);
} Returns an iteration object that defines the boundary of the
arc.
This iterator is multithread safe.
Arc2D guarantees that
modifications to the geometry of the arc
do not affect any iterations of that geometry that
are already in process. |
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 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. |
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)));
} Returns the hashcode for this Arc2D. |
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 intersects
the interior of the specified rectangle. |
abstract protected Rectangle2D makeBounds(double x,
double y,
double w,
double h) Constructs a Rectangle2D of the appropriate precision
to hold the parameters calculated to be the framing rectangle
of this arc. |
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;
} |
abstract public void setAngleExtent(double angExt) Sets the angular extent of this arc to the specified double
value. |
abstract public void setAngleStart(double angSt) Sets the starting angle of this arc to the specified double
value. |
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 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. |
public void setAngles(Point2D p1,
Point2D p2) {
setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());
} 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. |
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
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. |
public void setArc(Arc2D a) {
setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(),
a.getAngleStart(), a.getAngleExtent(), a.type);
} Sets this arc to be the same as the specified arc. |
public void setArc(Rectangle2D rect,
double angSt,
double angExt,
int closure) {
setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(),
angSt, angExt, closure);
} Sets the location, size, angular extents, and closure type of
this arc to the specified values. |
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. |
abstract public 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 double values. |
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, 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. |
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 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. |
public void setArcType(int type) {
if (type < OPEN || type > PIE) {
throw new IllegalArgumentException("invalid type for Arc: "+type);
}
this.type = type;
} Sets the closure type of this arc to the specified value:
OPEN, CHORD, or PIE. |
public void setFrame(double x,
double y,
double w,
double h) {
setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type);
} {@inheritDoc}
Note that the arc
partially inscribes
the framing rectangle of this {@code RectangularShape}. |
java.awt.geom.RectangularShape
Save This Page