Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Std. Ed. v1.3.1
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt.geom
Class Arc2D

    java.lang.Object
      |
      +--java.awt.geom.RectangularShape
            |
            +--java.awt.geom.Arc2D

All Implemented Interfaces:
  Cloneable, Shape

Direct Known Subclasses:
  Arc2D.Double, Arc2D.Float

public abstract class Arc2D
extends RectangularShape

`Arc2D` is the abstract superclass for all objects that store a 2D arc defined by a bounding rectangle, start angle, angular extent (length of the arc), and a closure type (`OPEN`, `CHORD`, or `PIE`).

The bounding rectangle defines the outer boundary of the full ellipse of which this arc is a partial section. The angles are specified relative to the non-square extents of the bounding rectangle such that 45 degrees always falls on the line from the center of the ellipse to the upper right corner of the bounding rectangle. As a result, if the bounding 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 bounds.

The actual storage representation of the coordinates is left to the subclass.

Inner Class Summary
`static class` | `Arc2D.Double` An arc specified in double precision,
`static class` | `Arc2D.Float` An arc specified in float precision,

Field Summary
`static int` | `CHORD` 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.
`static int` | `OPEN` The closure type for an open arc with no path segments connecting the two ends of the arc segment.
`static int` | `PIE` 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.

Constructor Summary
`protected` | `Arc2D(int type)` This is an abstract class that cannot be instantiated directly.

Method Summary
`boolean` | `contains(double x, double y)` Determines whether or not the specified point is inside the boundary of the arc.
`boolean` | `contains(double x, double y, double w, double h)` Determine whether or not the interior of the arc entirely contains the specified rectangle.
`boolean` | `contains(Rectangle2D r)` Determine whether or not the interior of the arc entirely contains the specified rectangle.
`boolean` | `containsAngle(double angle)` Determines whether or not the specified angle is within the angular extents of the arc.
`abstract double` | `getAngleExtent()` Returns the angular extent of the arc.
`abstract double` | `getAngleStart()` Returns the starting angle of the arc.
`int` | `getArcType()` Returns the arc closure type of the arc: `OPEN`, `CHORD`, or `PIE`.
`Rectangle2D` | `getBounds2D()` Returns the high-precision bounding box of the arc.
`Point2D` | `getEndPoint()` Returns the ending point of the arc.
`PathIterator` | `getPathIterator(AffineTransform at)` Returns an iteration object that defines the boundary of the arc.
`Point2D` | `getStartPoint()` Returns the starting point of the arc.
`boolean` | `intersects(double x, double y, double w, double h)` Determines whether or not the interior of the arc intersects the interior of the specified rectangle.
`protected abstract 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 bounding box of this arc.
`abstract void` | `setAngleExtent(double angExt)` Sets the angular extent of this arc to the specified double value.
`void` | `setAngles(double x1, double y1, double x2, double y2)` Sets the starting angle and angular extent of this arc using two sets of coordinates.
`void` | `setAngles(Point2D p1, Point2D p2)` Sets the starting angle and angular extent of this arc using two points.
`abstract void` | `setAngleStart(double angSt)` Sets the starting angle of this arc to the specified double value.
`void` | `setAngleStart(Point2D p)` Sets the starting angle of this arc to the angle that the specified point defines relative to the center of this arc.
`void` | `setArc(Arc2D a)` Sets this arc to be the same as the specified arc.
`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 double values.
`void` | `setArc(Point2D loc, Dimension2D size, double angSt, double angExt, int closure)` Sets the location, size, angular extents, and closure type of this arc to the specified values.
`void` | `setArc(Rectangle2D rect, double angSt, double angExt, int closure)` Sets the location, size, angular extents, and closure type of this arc to the specified values.
`void` | `setArcByCenter(double x, double y, double radius, double angSt, double angExt, int closure)` Sets the position, bounds, angular extents, and closure type of this arc to the specified values.
`void` | `setArcByTangent(Point2D p1, Point2D p2, Point2D p3, double radius)` Sets the position, bounds, and angular extents of this arc to the specified value.
`void` | `setArcType(int type)` Sets the closure type of this arc to the specified value: `OPEN`, `CHORD`, or `PIE`.
`void` | `setFrame(double x, double y, double w, double h)` Sets the location and size of the outer bounds of this arc to the specified values.

Methods inherited from class java.awt.geom.RectangularShape
`clone, contains, getBounds, getCenterX, getCenterY, getFrame, getHeight, getMaxX, getMaxY, getMinX, getMinY, getPathIterator, getWidth, getX, getY, intersects, isEmpty, setFrame, setFrame, setFrameFromCenter, setFrameFromCenter, setFrameFromDiagonal, setFrameFromDiagonal`

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### OPEN

    public static final int OPEN

  The closure type for an open arc with no path segments connecting the two ends of the arc segment.

### CHORD

    public static final int CHORD

  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.

### PIE

    public static final int PIE

  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.

Constructor Detail

### Arc2D

    protected Arc2D(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.
  Parameters:
    `type` - The closure type of this arc: `OPEN`, `CHORD`, or `PIE`.
  See Also:
    `Arc2D.Float`, `Arc2D.Double`

Method Detail

### getAngleStart

    public abstract double getAngleStart()

  Returns the starting angle of the arc.
  Returns:
    A double value that represents the starting angle of the arc in degrees.

### getAngleExtent

    public abstract double getAngleExtent()

  Returns the angular extent of the arc.
  Returns:
    A double value that represents the angular extent of the arc in degrees.

### getArcType

    public int getArcType()

  Returns the arc closure type of the arc: `OPEN`, `CHORD`, or `PIE`.
  Returns:
    One of the integer constant closure types defined in this class.

### getStartPoint

    public Point2D getStartPoint()

  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.
  Returns:
    A `Point2D` object representing the x,y coordinates of the starting point of the arc.

### getEndPoint

    public Point2D getEndPoint()

  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.
  Returns:
    A `Point2D` object representing the x,y coordinates of the ending point of the arc.

### setArc

    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 double values.
  Parameters:
    `x, y` - The coordinates of the upper left corner of the arc.
    `w` - The overall width of the full ellipse of which this arc is a partial section.
    `h` - The overall height of the full ellipse of which this arc is a partial section.
    `angSt` - The starting angle of the arc in degrees.
    `angExt` - The angular extent of the arc in degrees.
    `closure` - The closure type for the arc: `OPEN`, `CHORD`, or `PIE`.

### setArc

    public void setArc(Point2D loc,
                       Dimension2D size,
                       double angSt,
                       double angExt,
                       int closure)

  Sets the location, size, angular extents, and closure type of this arc to the specified values.
  Parameters:
    `loc` - The `Point2D` representing the coordinates of the upper left corner of the arc.
    `size` - The `Dimension2D` representing the width and height of the full ellipse of which this arc is a partial section.
    `angSt` - The starting angle of the arc in degrees. (Specified in double precision.)
    `angExt` - The angular extent of the arc in degrees. (Specified in double precision.)
    `closure` - The closure type for the arc: `OPEN`, `CHORD`, or `PIE`.

### setArc

    public void setArc(Rectangle2D rect,
                       double angSt,
                       double angExt,
                       int closure)

  Sets the location, size, angular extents, and closure type of this arc to the specified values.
  Parameters:
    `rect` - The bounding rectangle that defines the outer boundary of the full ellipse of which this arc is a partial section.
    `angSt` - The starting angle of the arc in degrees. (Specified in double precision.)
    `angExt` - The angular extent of the arc in degrees. (Specified in double precision.)
    `closure` - The closure type for the arc: `OPEN`, `CHORD`, or `PIE`.

### setArc

    public void setArc(Arc2D a)

  Sets this arc to be the same as the specified arc.
  Parameters:
    `a` - The `Arc2D` to use to set the arc's values.

### setArcByCenter

    public void setArcByCenter(double x,
                               double y,
                               double radius,
                               double angSt,
                               double angExt,
                               int 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 bounding box for the full ellipse.
  Parameters:
    `x, y` - The coordinates of the center of the arc. (Specified in double precision.)
    `r` - The radius of the arc. (Specified in double precision.)
    `angSt` - The starting angle of the arc in degrees. (Specified in double precision.)
    `angExt` - The angular extent of the arc in degrees. (Specified in double precision.)
    `closure` - The closure type for the arc: `OPEN`, `CHORD`, or `PIE`.

### setArcByTangent

    public void setArcByTangent(Point2D p1,
                                Point2D p2,
                                Point2D p3,
                                double radius)

  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.
  Parameters:
    `p1` - The first point that defines the arc. The starting angle of the arc is tangent to the line specified by points (p1, p2).
    `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).
    `p3` - The third point that defines the arc. The ending angle of the arc is tangent to the line specified by points (p2, p3).
    `radius` - The radius of the arc. (Specified in double precision.)

### setAngleStart

    public abstract void setAngleStart(double angSt)

  Sets the starting angle of this arc to the specified double value.
  Parameters:
    `angSt` - The starting angle of the arc in degrees.

### setAngleExtent

    public abstract void setAngleExtent(double angExt)

  Sets the angular extent of this arc to the specified double value.
  Parameters:
    `angExt` - The angular extent of the arc in degrees.

### setAngleStart

    public void setAngleStart(Point2D p)

  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.
  Parameters:
    `p` - The `Point2D` that defines the starting angle.

### setAngles

    public void setAngles(double x1,
                          double y1,
                          double x2,
                          double y2)

  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.
  Parameters:
    `x1, y1` - The coordinates of the arc's starting point.
    `x2, y2` - The coordinates of the arc's ending point.

### setAngles

    public void setAngles(Point2D p1,
                          Point2D p2)

  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.
  Parameters:
    `p1` - The `Point2D` that defines the arc's starting point.
    `p2` - The `Point2D` that defines the arc's ending point.

### setArcType

    public void setArcType(int type)

  Sets the closure type of this arc to the specified value: `OPEN`, `CHORD`, or `PIE`.
  Parameters:
    `type` - The integer constant that represents the closure type of this arc: `OPEN`, `CHORD`, or `PIE`.
  Throws:
    `IllegalArgumentException` - if `type` is not 0, 1, or 2.+

### setFrame

    public void setFrame(double x,
                         double y,
                         double w,
                         double h)

  Sets the location and size of the outer bounds of this arc to the specified values.
  Overrides:
    `setFrame` in class `RectangularShape`
  Parameters:
    `x, y` - The coordinates of the upper left corner of the arc's bounding box. (Specified in double precision.)
    `w` - The width of the arc's bounding box. (Specified in double precision.)
    `h` - The height of the arc's bounding box. (Specified in double precision.)

### getBounds2D

    public Rectangle2D getBounds2D()

  Returns the high-precision bounding box of the arc. The bounding box 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`.

  Returns:
    the `Rectangle2D` that represents the arc's bounding box.

### makeBounds

    protected abstract 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 bounding box of this arc.
  Parameters:
    `x, y` - The coordinates of the upper left corner of the bounding box. (Specified in double precision.)
    `w` - The width of the bounding box. (Specified in double precision.)
    `h` - The height of the bounding box. (Specified in double precision.)

### containsAngle

    public boolean containsAngle(double angle)

  Determines whether or not the specified angle is within the angular extents of the arc.
  Parameters:
    `angle` - The angle to test. (Specified in double precision.)
  Returns:
    `true` if the arc contains the angle, `false` if the arc doesn't contain the angle.

### contains

    public boolean contains(double x,
                            double y)

  Determines whether or not the specified point is inside the boundary of the arc.
  Parameters:
    `x, y` - The coordinates of the point to test. (Specified in double precision.)
  Returns:
    `true` if the point lies within the bound of the arc, `false` if the point lies outside of the arc's bounds.

### intersects

    public boolean intersects(double x,
                              double y,
                              double w,
                              double h)

  Determines whether or not the interior of the arc intersects the interior of the specified rectangle.
  Parameters:
    `x, y` - The coordinates of the rectangle's upper left corner. (Specified in double precision.)
    `w` - The width of the rectangle. (Specified in double precision.)
    `h` - The height of the rectangle. (Specified in double precision.)
  Returns:
    `true` if the arc intersects the rectangle, `false` if the arc doesn't intersect the rectangle.

### contains

    public boolean contains(double x,
                            double y,
                            double w,
                            double h)

  Determine whether or not the interior of the arc entirely contains the specified rectangle.
  Parameters:
    `x, y` - The coordinates of the rectangle's upper left corner. (Specified in double precision.)
    `w` - The width of the rectangle. (Specified in double precision.)
    `h` - The height of the rectangle. (Specified in double precision.)
  Returns:
    `true` if the arc contains the rectangle, `false` if the arc doesn't contain the rectangle.

### contains

    public boolean contains(Rectangle2D r)

  Determine whether or not the interior of the arc entirely contains the specified rectangle.
  Overrides:
    `contains` in class `RectangularShape`
  Parameters:
    `r` - The `Rectangle2D` to test.
  Returns:
    `true` if the arc contains the rectangle, `false` if the arc doesn't contain the rectangle.

### getPathIterator

    public PathIterator getPathIterator(AffineTransform 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.
  Parameters:
    `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or null if the untransformed coordinates are desired.
  Returns:
    A `PathIterator` that defines the arc's boundary.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JavaTM 2 Platform Std. Ed. v1.3.1
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Submit a bug or feature
For further API reference and developer documentation, see Java 2 SDK SE Developer Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

Java, Java 2D, and JDBC are trademarks or registered trademarks of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-2001 Sun Microsystems, Inc. 901 San Antonio Road
Palo Alto, California, 94303, U.S.A. All Rights Reserved.