source: trunk/src/org/expeditee/core/bounds/Bounds.java@ 1097

package org.expeditee.core.bounds;

import java.util.HashSet;
import java.util.Set;

import org.expeditee.core.Point;

/**
 * The Bounds interface represents objects that denote a subset of points in the
 * 2-dimensional plane. All points in the plane are either inside or outside the bounds,
 * and methods are given for determining which category individual or groups of points
 * belong to. 
 * 
 * @author cts16
 */
public abstract class Bounds {

        /**
         * Whether the given (x,y) coordinate is inside the borders of this bounds.
         */
        public abstract boolean contains(int x, int y);
        
        /**
         * Whether the given point is inside the borders of this bounds.
         */
        public boolean contains(Point p)
        {
                return contains(p.x, p.y);
        }
        
        /**
         * Whether there exists a point that is within this bounds and the other bounds.
         */
        public boolean intersects(Bounds other)
        {
                if (other == null) return false;
                
                if (other instanceof AxisAlignedBoxBounds) {
                        return intersects((AxisAlignedBoxBounds) other);
                } else if (other instanceof CombinationBounds) {
                        return intersects((CombinationBounds) other);
                } else if (other instanceof EllipticalBounds) {
                        return intersects((EllipticalBounds) other);
                } else if (other instanceof PolygonBounds) {
                        return intersects((PolygonBounds) other);
                }

                return false;
        }
        public abstract boolean intersects(AxisAlignedBoxBounds other);
        public abstract boolean intersects(CombinationBounds other);
        public abstract boolean intersects(EllipticalBounds other);
        public abstract boolean intersects(PolygonBounds other);
        
        /** Gets the x-coordinate of the right-most point in this bounds. */
        public abstract int getMaxX();
        /** Gets the x-coordinate of the left-most point in this bounds. */
        public abstract int getMinX();
        /** Gets the y-coordinate of the bottom-most point in this bounds. */
        public abstract int getMaxY();
        /** Gets the y-coordinate of the top-most point in this bounds. */
        public abstract int getMinY();
        
        public Point getCentre()
        {
                return new Point((getMaxX() + getMinX()) / 2, (getMaxY() + getMinY()) / 2);
        }
        
        /** Whether the set of points covered by this bounds is the same as the other bounds. */
        public abstract boolean equals(Bounds other);
        
        /** Gets the total area covered by this bounds. */
        public abstract double getArea();
        
        /** Whether the given point lies on the border of this bounds (within the given area). */
        public abstract boolean perimeterContains(Point p, double error);
        
        /** Whether the other bounds is entirely inside this bounds. */
        public boolean completelyContains(Bounds other)
        {
                if (other == null) return false;
                
                if (other instanceof AxisAlignedBoxBounds) {
                        return completelyContains((AxisAlignedBoxBounds) other);
                } else if (other instanceof CombinationBounds) {
                        return completelyContains((CombinationBounds) other);
                } else if (other instanceof EllipticalBounds) {
                        return completelyContains((EllipticalBounds) other);
                } else if (other instanceof PolygonBounds) {
                        return completelyContains((PolygonBounds) other);
                }

                return false;
        }
        public abstract boolean completelyContains(AxisAlignedBoxBounds other);
        public abstract boolean completelyContains(CombinationBounds other);
        public abstract boolean completelyContains(EllipticalBounds other);
        public abstract boolean completelyContains(PolygonBounds other);
        
        /** Translates the bounds by the given x/y amounts. */
        public abstract Bounds translate(int x, int y);
        
        /** Gets all points contained by the bounds. */
        public Set<Point> getAllContainedPoints()
        {
                Set<Point> ret = new HashSet<Point>();
                for (int x = getMinX(); x <= getMaxX(); x++) {
                        for (int y = getMinY(); y <= getMaxY(); y++) {
                                if (contains(x, y)) ret.add(new Point(x, y));
                        }
                }
                
                return ret;
        }
        
        @Override
        public abstract Bounds clone();
}