/*
* Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt.geom;
import java.awt.Shape;
import java.awt.Rectangle;
import java.util.Vector;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import sun.awt.geom.Curve;
import sun.awt.geom.Crossings;
import sun.awt.geom.AreaOp;
/**
* An Area
object stores and manipulates a
* resolution-independent description of an enclosed area of
* 2-dimensional space.
* Area
objects can be transformed and can perform
* various Constructive Area Geometry (CAG) operations when combined
* with other Area
objects.
* The CAG operations include area
* {@link #add addition}, {@link #subtract subtraction},
* {@link #intersect intersection}, and {@link #exclusiveOr exclusive or}.
* See the linked method documentation for examples of the various
* operations.
*
* The Area
class implements the Shape
* interface and provides full support for all of its hit-testing
* and path iteration facilities, but an Area
is more
* specific than a generalized path in a number of ways:
*
Area
objects constructed from unclosed paths
* are implicitly closed during construction as if those paths
* had been filled by the Graphics2D.fill
method.
* Area
resembles the path from which it was
* constructed only in that it describes the same enclosed
* 2-dimensional area, but may use entirely different types
* and ordering of the path segments to do so.
* Area
include:
* Area
from an unclosed (open)
* Shape
results in a closed outline in the
* Area
object.
* Area
from a Shape
* which encloses no area (even when "closed") produces an
* empty Area
. A common example of this issue
* is that producing an Area
from a line will
* be empty since the line encloses no area. An empty
* Area
will iterate no geometry in its
* PathIterator
objects.
* Shape
may be split into
* two (or more) sub-paths each enclosing one of the
* non-intersecting portions of the original path.
* Area
may take more path segments to
* describe the same geometry even when the original
* outline is simple and obvious. The analysis that the
* Area
class must perform on the path may
* not reflect the same concepts of "simple and obvious"
* as a human being perceives.
* Area
class creates an area geometry from the
* specified {@link 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.
* @param s the Shape
from which the area is constructed
* @throws NullPointerException if s
is null
* @since 1.2
*/
public Area(Shape s) {
if (s instanceof Area) {
curves = ((Area) s).curves;
} else {
curves = pathToCurves(s.getPathIterator(null));
}
}
private static VectorArea
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) * * ################ ################ ################ * ############## ############## ################ * ############ ############ ################ * ########## ########## ################ * ######## ######## ################ * ###### ###### ###### ###### * #### #### #### #### * ## ## ## ## ** @param rhs the
Area
to be added to the
* current shape
* @throws NullPointerException if rhs
is null
* @since 1.2
*/
public void add(Area rhs) {
curves = new AreaOp.AddOp().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) * * ################ ################ * ############## ############## ## * ############ ############ #### * ########## ########## ###### * ######## ######## ######## * ###### ###### ###### * #### #### #### * ## ## ## ** @param rhs the
Area
to be subtracted from the
* current shape
* @throws NullPointerException if rhs
is null
* @since 1.2
*/
public void subtract(Area rhs) {
curves = new AreaOp.SubOp().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) * * ################ ################ ################ * ############## ############## ############ * ############ ############ ######## * ########## ########## #### * ######## ######## * ###### ###### * #### #### * ## ## ** @param rhs the
Area
to be intersected with this
* Area
* @throws NullPointerException if rhs
is null
* @since 1.2
*/
public void intersect(Area rhs) {
curves = new AreaOp.IntOp().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) * * ################ ################ * ############## ############## ## ## * ############ ############ #### #### * ########## ########## ###### ###### * ######## ######## ################ * ###### ###### ###### ###### * #### #### #### #### * ## ## ## ## ** @param rhs the
Area
to be exclusive ORed with this
* Area
.
* @throws NullPointerException if rhs
is null
* @since 1.2
*/
public void exclusiveOr(Area rhs) {
curves = new AreaOp.XorOp().calculate(this.curves, rhs.curves);
invalidateBounds();
}
/**
* Removes all of the geometry from this Area
and
* restores it to an empty area.
* @since 1.2
*/
public void reset() {
curves = new Vector<>();
invalidateBounds();
}
/**
* Tests whether this Area
object encloses any area.
* @return true
if this Area
object
* represents an empty area; false
otherwise.
* @since 1.2
*/
public boolean isEmpty() {
return (curves.size() == 0);
}
/**
* Tests whether this Area
consists entirely of
* straight edged polygonal geometry.
* @return true
if the geometry of this
* Area
consists entirely of line segments;
* false
otherwise.
* @since 1.2
*/
public boolean isPolygonal() {
EnumerationArea
is rectangular in shape.
* @return true
if the geometry of this
* Area
is rectangular in shape; false
* otherwise.
* @since 1.2
*/
public boolean isRectangular() {
int size = curves.size();
if (size == 0) {
return true;
}
if (size > 3) {
return false;
}
Curve c1 = curves.get(1);
Curve c2 = 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 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 {@link PathIterator#SEG_MOVETO SEG_MOVETO} segments
* that appear in the path.
* @return true
if the Area
is comprised
* of a single basic geometry; false
otherwise.
* @since 1.2
*/
public boolean isSingular() {
if (curves.size() < 3) {
return true;
}
EnumerationArea
.
*
* 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.
* @return the bounding Rectangle2D
for the
* Area
.
* @since 1.2
*/
public Rectangle2D getBounds2D() {
return getCachedBounds().getBounds2D();
}
/**
* Returns a bounding {@link 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.
* @return the bounding Rectangle
for the
* Area
.
* @since 1.2
*/
public Rectangle getBounds() {
return getCachedBounds().getBounds();
}
/**
* Returns an exact copy of this Area
object.
* @return Created clone object
* @since 1.2
*/
public Object clone() {
return new Area(this);
}
/**
* Tests whether the geometries of the two Area
objects
* are equal.
* This method will return false if the argument is null.
* @param other the Area
to be compared to this
* Area
* @return true
if the two geometries are equal;
* false
otherwise.
* @since 1.2
*/
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;
}
VectorArea
using the specified
* {@link AffineTransform}. The geometry is transformed in place, which
* permanently changes the enclosed area defined by this object.
* @param t the transformation used to transform the area
* @throws NullPointerException if t
is null
* @since 1.2
*/
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();
}
/**
* Creates a new Area
object that contains the same
* geometry as this Area
transformed by the specified
* AffineTransform
. This Area
object
* is unchanged.
* @param t the specified AffineTransform
used to transform
* the new Area
* @throws NullPointerException if t
is null
* @return a new Area
object representing the transformed
* geometry.
* @since 1.2
*/
public Area createTransformedArea(AffineTransform t) {
Area a = new Area(this);
a.transform(t);
return a;
}
/**
* {@inheritDoc}
* @since 1.2
*/
public boolean contains(double x, double y) {
if (!getCachedBounds().contains(x, y)) {
return false;
}
EnumerationArea
object. This Area
object is unchanged.
* @param at an optional AffineTransform
to be applied to
* the coordinates as they are returned in the iteration, or
* null
if untransformed coordinates are desired
* @return the PathIterator
object that returns the
* geometry of the outline of this Area
, one
* segment at a time.
* @since 1.2
*/
public PathIterator getPathIterator(AffineTransform at) {
return new AreaIterator(curves, at);
}
/**
* 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.
* @param at an optional AffineTransform
to be
* applied to the coordinates as they are returned in the
* iteration, or null
if untransformed coordinates
* are desired
* @param 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 end points
* @return the PathIterator
object that returns the
* geometry of the outline of this Area
, one segment
* at a time.
* @since 1.2
*/
public PathIterator getPathIterator(AffineTransform at, double flatness) {
return new FlatteningPathIterator(getPathIterator(at), flatness);
}
}
class AreaIterator implements PathIterator {
private AffineTransform transform;
private Vector