public Area() 
{
                  
        curves = EmptyCurves;
}

Default constructor which creates an empty area.

since: 1.2 -

 public Area(Shape s) 
{
        if (s instanceof Area) {
            curves = ((Area) s).curves;
        } else {
            curves = pathToCurves(s.getPathIterator(null));
        }
}

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

Throws:

NullPointerException - if s is null

since: 1.2 -

 public  void add(Area rhs) 
{
        curves = new AreaOp.AddOp().calculate(this.curves, rhs.curves);
        invalidateBounds();
}

Adds the shape of the specified Area to the shape of this Area. The resulting shape of this Area will include the union of both shapes, or all areas that were contained in either this or the specified Area.

// Example:
Area a1 = new Area([triangle 0,0 => 8,0 => 0,8]);
Area a2 = new Area([triangle 0,0 => 8,0 => 8,8]);
a1.add(a2);

a1(before) + a2 = a1(after)

################ ################ ################
############## ############## ################
############ ############ ################
########## ########## ################
######## ######## ################
###### ###### ###### ######
#### #### #### ####
## ## ## ##

 public Object clone() 
{
        return new Area(this);
}

Returns an exact copy of this Area object.

 public boolean contains(Point2D p) 
{
        return contains(p.getX(), p.getY());
}

{@inheritDoc}

 public boolean contains(Rectangle2D r) 
{
        return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}

{@inheritDoc}

 public boolean contains(double x,
    double y) 
{
        if (!getCachedBounds().contains(x, y)) {
            return false;
        }
        Enumeration enum_ = curves.elements();
        int crossings = 0;
        while (enum_.hasMoreElements()) {
            Curve c = (Curve) enum_.nextElement();
            crossings += c.crossingsFor(x, y);
        }
        return ((crossings & 1) == 1);
}

{@inheritDoc}

 public boolean contains(double x,
    double y,
    double w,
    double h) 
{
        if (w <  0 || h <  0) {
            return false;
        }
        if (!getCachedBounds().contains(x, y, w, h)) {
            return false;
        }
        Crossings c = Crossings.findCrossings(curves, x, y, x+w, y+h);
        return (c != null && c.covers(y, y+h));
}

{@inheritDoc}

 public Area createTransformedArea(AffineTransform t) 
{
        Area a = new Area(this);
        a.transform(t);
        return a;
}

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

 public boolean equals(Area other) 
{
        // REMIND: A *much* simpler operation should be possible...
        // Should be able to do a curve-wise comparison since all Areas
        // should evaluate their curves in the same top-down order.
        if (other == this) {
            return true;
        }
        if (other == null) {
            return false;
        }
        Vector c = new AreaOp.XorOp().calculate(this.curves, other.curves);
        return c.isEmpty();
}

Tests whether the geometries of the two Area objects are equal. This method will return false if the argument is null.

 public  void exclusiveOr(Area rhs) 
{
        curves = new AreaOp.XorOp().calculate(this.curves, rhs.curves);
        invalidateBounds();
}

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. The resulting shape of this Area will include only areas that were contained in either this Area or in the specified Area, but not in both.

// Example:
Area a1 = new Area([triangle 0,0 => 8,0 => 0,8]);
Area a2 = new Area([triangle 0,0 => 8,0 => 8,8]);
a1.exclusiveOr(a2);

a1(before) xor a2 = a1(after)

################ ################
############## ############## ## ##
############ ############ #### ####
########## ########## ###### ######
######## ######## ################
###### ###### ###### ######
#### #### #### ####
## ## ## ##

 public Rectangle getBounds() 
{
        return getCachedBounds().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.

 public Rectangle2D getBounds2D() 
{
        return getCachedBounds().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.

 public PathIterator getPathIterator(AffineTransform at) 
{
        return new AreaIterator(curves, at);
}

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

 public PathIterator getPathIterator(AffineTransform at,
    double flatness) 
{
        return new FlatteningPathIterator(getPathIterator(at), 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.

 public  void intersect(Area rhs) 
{
        curves = new AreaOp.IntOp().calculate(this.curves, rhs.curves);
        invalidateBounds();
}

Sets the shape of this Area to the intersection of its current shape and the shape of the specified Area. The resulting shape of this Area will include only areas that were contained in both this Area and also in the specified Area.

// Example:
Area a1 = new Area([triangle 0,0 => 8,0 => 0,8]);
Area a2 = new Area([triangle 0,0 => 8,0 => 8,8]);
a1.intersect(a2);

a1(before) intersect a2 = a1(after)

################ ################ ################
############## ############## ############
############ ############ ########
########## ########## ####
######## ########
###### ######
#### ####
## ##

 public boolean intersects(Rectangle2D r) 
{
        return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}

{@inheritDoc}

 public boolean intersects(double x,
    double y,
    double w,
    double h) 
{
        if (w <  0 || h <  0) {
            return false;
        }
        if (!getCachedBounds().intersects(x, y, w, h)) {
            return false;
        }
        Crossings c = Crossings.findCrossings(curves, x, y, x+w, y+h);
        return (c == null || !c.isEmpty());
}

{@inheritDoc}

 public boolean isEmpty() 
{
        return (curves.size() == 0);
}

Tests whether this Area object encloses any area.

 public boolean isPolygonal() 
{
        Enumeration enum_ = curves.elements();
        while (enum_.hasMoreElements()) {
            if (((Curve) enum_.nextElement()).getOrder()  > 1) {
                return false;
            }
        }
        return true;
}

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

 public boolean isRectangular() 
{
        int size = curves.size();
        if (size == 0) {
            return true;
        }
        if (size  > 3) {
            return false;
        }
        Curve c1 = (Curve) curves.get(1);
        Curve c2 = (Curve) curves.get(2);
        if (c1.getOrder() != 1 || c2.getOrder() != 1) {
            return false;
        }
        if (c1.getXTop() != c1.getXBot() || c2.getXTop() != c2.getXBot()) {
            return false;
        }
        if (c1.getYTop() != c2.getYTop() || c1.getYBot() != c2.getYBot()) {
            // One might be able to prove that this is impossible...
            return false;
        }
        return true;
}

Tests whether this Area is rectangular in shape.

 public boolean isSingular() 
{
        if (curves.size() <  3) {
            return true;
        }
        Enumeration enum_ = curves.elements();
        enum_.nextElement(); // First Order0 "moveto"
        while (enum_.hasMoreElements()) {
            if (((Curve) enum_.nextElement()).getOrder() == 0) {
                return false;
            }
        }
        return true;
}

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.

 public  void reset() 
{
        curves = new Vector();
        invalidateBounds();
}

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

 public  void subtract(Area rhs) 
{
        curves = new AreaOp.SubOp().calculate(this.curves, rhs.curves);
        invalidateBounds();
}

Subtracts the shape of the specified Area from the shape of this Area. The resulting shape of this Area will include areas that were contained only in this Area and not in the specified Area.

// Example:
Area a1 = new Area([triangle 0,0 => 8,0 => 0,8]);
Area a2 = new Area([triangle 0,0 => 8,0 => 8,8]);
a1.subtract(a2);

a1(before) - a2 = a1(after)

################ ################
############## ############## ##
############ ############ ####
########## ########## ######
######## ######## ########
###### ###### ######
#### #### ####
## ## ##

 public  void transform(AffineTransform t) 
{
        if (t == null) {
            throw new NullPointerException("transform must not be null");
        }
        // REMIND: A simpler operation can be performed for some types
        // of transform.
        curves = pathToCurves(getPathIterator(t));
        invalidateBounds();
}

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.