Area (Java 2 Platform SE v1.4.1_"07")

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

JavaTM 2 Platform
Std. Ed. v1.4.1_"07"

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt.geom
Class Area

    java.lang.Object
      |
      +--java.awt.geom.Area

All Implemented Interfaces:
  Cloneable, Shape

public class Area
extends Object
implements Shape, Cloneable

The `Area` class is a device-independent specification of an arbitrarily-shaped area. The `Area` object is defined as an object that performs certain binary CAG (Constructive Area Geometry) operations on other area-enclosing geometries, such as rectangles, ellipses, and polygons. The CAG operations are Add(union), Subtract, Intersect, and ExclusiveOR. For example, an `Area` can be made up of the area of a rectangle minus the area of an ellipse.

Constructor Summary
`Area()` Default constructor which creates an empty area.
`Area(Shape s)` The `Area` class creates an area geometry from the specified `Shape` object.

Method Summary
`void` | `add(Area rhs)` Adds the shape of the specified `Area` to the shape of this `Area`.
`Object` | `clone()` Returns an exact copy of this `Area` object.
`boolean` | `contains(double x, double y)` Tests if a specifed point lies inside the boundary of this `Area` object.
`boolean` | `contains(double x, double y, double w, double h)` Tests whether or not the interior of this `Area` object completely contains the specified rectangular area.
`boolean` | `contains(Point2D p)` Tests if a specified `Point2D` lies inside the boundary of the this `Area` object.
`boolean` | `contains(Rectangle2D p)` Tests whether or not the interior of this `Area` object completely contains the specified `Rectangle2D`.
`Area` | `createTransformedArea(AffineTransform t)` Creates a new `Area` object that contains the same geometry as this `Area` transformed by the specified `AffineTransform`.
`boolean` | `equals(Area other)` Tests whether the geometries of the two `Area` objects are equal.
`void` | `exclusiveOr(Area rhs)` Sets the shape of this `Area` to be the combined area of its current shape and the shape of the specified `Area`, minus their intersection.
`Rectangle` | `getBounds()` Returns a bounding `Rectangle` that completely encloses this `Area`.
`Rectangle2D` | `getBounds2D()` Returns a high precision bounding `Rectangle2D` that completely encloses this `Area`.
`PathIterator` | `getPathIterator(AffineTransform at)` Creates a `PathIterator` for the outline of this `Area` object.
`PathIterator` | `getPathIterator(AffineTransform at, double flatness)` Creates a `PathIterator` for the flattened outline of this `Area` object.
`void` | `intersect(Area rhs)` Sets the shape of this `Area` to the intersection of its current shape and the shape of the specified `Area`.
`boolean` | `intersects(double x, double y, double w, double h)` Tests whether the interior of this `Area` object intersects the interior of the specified rectangular area.
`boolean` | `intersects(Rectangle2D p)` Tests whether the interior of this `Area` object intersects the interior of the specified `Rectangle2D`.
`boolean` | `isEmpty()` Tests whether this `Area` object encloses any area.
`boolean` | `isPolygonal()` Tests whether this `Area` consists entirely of straight edged polygonal geometry.
`boolean` | `isRectangular()` Tests whether this `Area` is rectangular in shape.
`boolean` | `isSingular()` Tests whether this `Area` is comprised of a single closed subpath.
`void` | `reset()` Removes all of the geometry from this `Area` and restores it to an empty area.
`void` | `subtract(Area rhs)` Subtracts the shape of the specified `Area` from the shape of this `Area`.
`void` | `transform(AffineTransform t)` Transforms the geometry of this `Area` using the specified `AffineTransform`.

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

Constructor Detail

### Area

    public Area()

  Default constructor which creates an empty area.

### Area

    public Area(Shape s)

  The `Area` class creates an area geometry from the specified `Shape` object. The geometry is explicitly closed, if the `Shape` is not already closed. The fill rule (even-odd or winding) specified by the geometry of the `Shape` is used to determine the resulting enclosed area.

Parameters:
  `s` - the `Shape` from which the area is constructed

Method Detail

### add

    public void add(Area rhs)

  Adds the shape of the specified `Area` to the shape of this `Area`. Addition is achieved through union.

  Parameters:
    `rhs` - the `Area` to be added to the current shape

### subtract

    public void subtract(Area rhs)

  Subtracts the shape of the specified `Area` from the shape of this `Area`.

  Parameters:
    `rhs` - the `Area` to be subtracted from the current shape

### intersect

    public void intersect(Area rhs)

  Sets the shape of this `Area` to the intersection of its current shape and the shape of the specified `Area`.

  Parameters:
    `rhs` - the `Area` to be intersected with this `Area`

### exclusiveOr

    public void exclusiveOr(Area rhs)

  Sets the shape of this `Area` to be the combined area of its current shape and the shape of the specified `Area`, minus their intersection.

  Parameters:
    `rhs` - the `Area` to be exclusive ORed with this `Area`.

### reset

    public void reset()

  Removes all of the geometry from this `Area` and restores it to an empty area.

### isEmpty

    public boolean isEmpty()

  Tests whether this `Area` object encloses any area.

  Returns:
    `true` if this `Area` object represents an empty area; `false` otherwise.

### isPolygonal

    public boolean isPolygonal()

  Tests whether this `Area` consists entirely of straight edged polygonal geometry.

  Returns:
    `true` if the geometry of this `Area` consists entirely of line segments; `false` otherwise.

### isRectangular

    public boolean isRectangular()

  Tests whether this `Area` is rectangular in shape.

  Returns:
    `true` if the geometry of this `Area` is rectangular in shape; `false` otherwise.

### isSingular

    public boolean isSingular()

  Tests whether this `Area` is comprised of a single closed subpath. This method returns `true` if the path contains 0 or 1 subpaths, or `false` if the path contains more than 1 subpath. The subpaths are counted by the number of `SEG_MOVETO` segments that appear in the path.

  Returns:
    `true` if the `Area` is comprised of a single basic geometry; `false` otherwise.

### getBounds2D

    public Rectangle2D getBounds2D()

  Returns a high precision bounding `Rectangle2D` that completely encloses this `Area`.

  The Area class will attempt to return the tightest bounding box possible for the Shape. The bounding box will not be padded to include the control points of curves in the outline of the Shape, but should tightly fit the actual geometry of the outline itself.

  Specified by:
    `getBounds2D` in interface `Shape`
  Returns:
    the bounding `Rectangle2D` for the `Area`.
  See Also:
    `Shape.getBounds()`

### getBounds

    public Rectangle getBounds()

  Returns a bounding `Rectangle` that completely encloses this `Area`.

  The Area class will attempt to return the tightest bounding box possible for the Shape. The bounding box will not be padded to include the control points of curves in the outline of the Shape, but should tightly fit the actual geometry of the outline itself. Since the returned object represents the bounding box with integers, the bounding box can only be as tight as the nearest integer coordinates that encompass the geometry of the Shape.

  Specified by:
    `getBounds` in interface `Shape`
  Returns:
    the bounding `Rectangle` for the `Area`.
  See Also:
    `Shape.getBounds2D()`

### clone

    public Object clone()

  Returns an exact copy of this `Area` object.

  Overrides:
    `clone` in class `Object`
  Returns:
    Created clone object
  See Also:
    `Cloneable`

### equals

    public boolean equals(Area other)

  Tests whether the geometries of the two `Area` objects are equal.

  Parameters:
    `other` - the `Area` to be compared to this `Area`
  Returns:
    `true` if the two geometries are equal; `false` otherwise.

### transform

    public void transform(AffineTransform t)

  Transforms the geometry of this `Area` using the specified `AffineTransform`. The geometry is transformed in place, which permanently changes the enclosed area defined by this object.

  Parameters:
    `t` - the transformation used to transform the area

### createTransformedArea

    public Area createTransformedArea(AffineTransform t)

  Creates a new `Area` object that contains the same geometry as this `Area` transformed by the specified `AffineTransform`. This `Area` object is unchanged.

  Parameters:
    `t` - the specified `AffineTransform` used to transform the new `Area`
  Returns:
    a new `Area` object representing the transformed geometry.

### contains

    public boolean contains(double x,
                            double y)

  Tests if a specifed point lies inside the boundary of this `Area` object.

  Specified by:
    `contains` in interface `Shape`
  Returns:
    `true` if the point lies completely within the interior of the `Area`; `false` otherwise.

### contains

    public boolean contains(Point2D p)

  Tests if a specified `Point2D` lies inside the boundary of the this `Area` object.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `p` - the `Point2D` to test
  Returns:
    `true` if the specified `Point2D` lies completely within the interior of the `Area`; `false` otherwise.

### contains

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

  Tests whether or not the interior of this `Area` object completely contains the specified rectangular area.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `w` - the width of the specified rectangular area
    `h` - the height of the specified rectangular area
  Returns:
    `true` if the specified rectangular area lies completely within the interior of the `Area`; `false` otherwise.
  See Also:
    `Area`, `Shape.intersects(double, double, double, double)`

### contains

    public boolean contains(Rectangle2D p)

  Tests whether or not the interior of this `Area` object completely contains the specified `Rectangle2D`.

  Specified by:
    `contains` in interface `Shape`
  Parameters:
    `p` - the `Rectangle2D` to test
  Returns:
    `true` if the `Rectangle2D` lies completely within the interior of the `Area`; `false` otherwise.
  See Also:
    `Shape.contains(double, double, double, double)`

### intersects

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

  Tests whether the interior of this `Area` object intersects the interior of the specified rectangular area.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `w` - the width of the specified rectangular area
    `h` - the height of teh specified rectangular area
  Returns:
    `true` if the interior intersects the specified rectangular area; `false` otherwise;
  See Also:
    `Area`

### intersects

    public boolean intersects(Rectangle2D p)

  Tests whether the interior of this `Area` object intersects the interior of the specified `Rectangle2D`.

  Specified by:
    `intersects` in interface `Shape`
  Parameters:
    `p` - the `Rectangle2D` to test for intersection
  Returns:
    `true` if the interior intersects the specified `Rectangle2D`; `false` otherwise.
  See Also:
    `Shape.intersects(double, double, double, double)`

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at)

  Creates a `PathIterator` for the outline of this `Area` object. This `Area` object is unchanged.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
  Returns:
    the `PathIterator` object that returns the geometry of the outline of this `Area`, one segment at a time.

### getPathIterator

    public PathIterator getPathIterator(AffineTransform at,
                                        double flatness)

  Creates a `PathIterator` for the flattened outline of this `Area` object. Only uncurved path segments represented by the SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types are returned by the iterator. This `Area` object is unchanged.

  Specified by:
    `getPathIterator` in interface `Shape`
  Parameters:
    `at` - an optional `AffineTransform` to be applied to the coordinates as they are returned in the iteration, or `null` if untransformed coordinates are desired
    `flatness` - the maximum amount that the control points for a given curve can vary from colinear before a subdivided curve is replaced by a straight line connecting the endpoints
  Returns:
    the `PathIterator` object that returns the geometry of the outline of this `Area`, one segment at a time.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

JavaTM 2 Platform
Std. Ed. v1.4.1_"07"

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | 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.

Copyright 2002 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.