path: root/awt/java/awt/geom/Rectangle2D.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Denis M. Kishenko
 * @version $Revision$
 */
package java.awt.geom;

import java.util.NoSuchElementException;

import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.misc.HashCode;

/**
 * The Class Rectangle2D represents a rectangle whose coordinates are given 
 * with the correct precision to be used with the Graphics2D classes.
 */
public abstract class Rectangle2D extends RectangularShape {

    /** The Constant OUT_LEFT is a mask that is used to indicate that a 
     * given point is outside the rectangle and to its left. */
    public static final int OUT_LEFT   = 1;
    
    /** The Constant OUT_TOP is a mask that is used to indicate that a 
     * given point is outside the rectangle and above it. */
    public static final int OUT_TOP    = 2;
    
    /** The Constant OUT_RIGHT is a mask that is used to indicate that a 
     * given point is outside the rectangle and to its right. */
    public static final int OUT_RIGHT  = 4;
    
    /** The Constant OUT_BOTTOM is a mask that is used to indicate that a 
     * given point is outside the rectangle and above it. */
    public static final int OUT_BOTTOM = 8;

    /**
     * The Class Float is the subclass of Rectangle2D that represents a 
     * rectangle whose data values are given as floats (with float-level
     * precision).
     */
    public static class Float extends Rectangle2D {

        /** The x coordinate of the rectangle's upper left corner. */
        public float x;
        
        /** The y coordinate of the rectangle's upper left corner. */
        public float y;
        
        /** The width of the rectangle. */
        public float width;
        
        /** The height of the rectangle. */
        public float height;

        /**
         * Instantiates a new empty rectangle with float-precision data fields.
         */
        public Float() {
        }

        /**
         * Instantiates a new rectangle with the specified float-precision data.
         * 
         * @param x the x coordinate of the rectangle's upper left corner
         * @param y the y coordinate of the rectangle's upper left corner
         * @param width the width of the rectangle
         * @param height the height of the rectangle
         */
        public Float(float x, float y, float width, float height) {
            setRect(x, y, width, height);
        }

        @Override
        public double getX() {
            return x;
        }

        @Override
        public double getY() {
            return y;
        }

        @Override
        public double getWidth() {
            return width;
        }

        @Override
        public double getHeight() {
            return height;
        }

        @Override
        public boolean isEmpty() {
            return width <= 0.0f || height <= 0.0f;
        }

        /**
         * Sets the rectangle's data to the given values.
         * 
         * @param x the x coordinate of the rectangle's upper left corner
         * @param y the y coordinate of the rectangle's upper left corner
         * @param width the width of the rectangle
         * @param height the height of the rectangle
         */
        public void setRect(float x, float y, float width, float height) {
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
        }

        @Override
        public void setRect(double x, double y, double width, double height) {
            this.x = (float)x;
            this.y = (float)y;
            this.width = (float)width;
            this.height = (float)height;
        }

        @Override
        public void setRect(Rectangle2D r) {
            this.x = (float)r.getX();
            this.y = (float)r.getY();
            this.width = (float)r.getWidth();
            this.height = (float)r.getHeight();
        }

        @Override
        public int outcode(double px, double py) {
            int code = 0;

            if (width <= 0.0f) {
                code |= OUT_LEFT | OUT_RIGHT;
            } else
                if (px < x) {
                    code |= OUT_LEFT;
                } else
                    if (px > x + width) {
                        code |= OUT_RIGHT;
                    }

            if (height <= 0.0f) {
                code |= OUT_TOP | OUT_BOTTOM;
            } else
                if (py < y) {
                    code |= OUT_TOP;
                } else
                    if (py > y + height) {
                        code |= OUT_BOTTOM;
                    }

            return code;
        }

        @Override
        public Rectangle2D getBounds2D() {
            return new Float(x, y, width, height);
        }

        @Override
        public Rectangle2D createIntersection(Rectangle2D r) {
            Rectangle2D dst;
            if (r instanceof Double) {
                dst = new Rectangle2D.Double();
            } else {
                dst = new Rectangle2D.Float();
            }
            Rectangle2D.intersect(this, r, dst);
            return dst;
        }

        @Override
        public Rectangle2D createUnion(Rectangle2D r) {
            Rectangle2D dst;
            if (r instanceof Double) {
                dst = new Rectangle2D.Double();
            } else {
                dst = new Rectangle2D.Float();
            }
            Rectangle2D.union(this, r, dst);
            return dst;
        }

        @Override
        public String toString() {
            // The output format based on 1.5 release behaviour. It could be obtained in the following way
            // System.out.println(new Rectangle2D.Float().toString())
            return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
        }
    }

    /**
     * The Class Double is the subclass of Rectangle2D that represents a 
     * rectangle whose data values are given as doubles (with double-precision-level
     * precision).
     */
    public static class Double extends Rectangle2D {

        /** The x coordinate of the rectangle's upper left corner. */
        public double x;
        
        /** The y coordinate of the rectangle's upper left corner. */
        public double y;
        
        /** The width of the rectangle. */
        public double width;
        
        /** The height of the rectangle. */
        public double height;

        /**
         * Instantiates a new empty rectangle with double-precision data fields.
         */
        public Double() {
        }

        /**
         * Instantiates a new rectangle with the given double values.
         * 
         * @param x the x coordinate of the rectangle's upper left corner
         * @param y the y coordinate of the rectangle's upper left corner
         * @param width the width of the rectangle
         * @param height the height of the rectangle
         */
        public Double(double x, double y, double width, double height) {
            setRect(x, y, width, height);
        }

        @Override
        public double getX() {
            return x;
        }

        @Override
        public double getY() {
            return y;
        }

        @Override
        public double getWidth() {
            return width;
        }

        @Override
        public double getHeight() {
            return height;
        }

        @Override
        public boolean isEmpty() {
            return width <= 0.0 || height <= 0.0;
        }

        @Override
        public void setRect(double x, double y, double width, double height) {
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
        }

        @Override
        public void setRect(Rectangle2D r) {
            this.x = r.getX();
            this.y = r.getY();
            this.width = r.getWidth();
            this.height = r.getHeight();
        }

        @Override
        public int outcode(double px, double py) {
            int code = 0;

            if (width <= 0.0) {
                code |= OUT_LEFT | OUT_RIGHT;
            } else
                if (px < x) {
                    code |= OUT_LEFT;
                } else
                    if (px > x + width) {
                        code |= OUT_RIGHT;
                    }

            if (height <= 0.0) {
                code |= OUT_TOP | OUT_BOTTOM;
            } else
                if (py < y) {
                    code |= OUT_TOP;
                } else
                    if (py > y + height) {
                        code |= OUT_BOTTOM;
                    }

            return code;
        }

        @Override
        public Rectangle2D getBounds2D() {
            return new Double(x, y, width, height);
        }

        @Override
        public Rectangle2D createIntersection(Rectangle2D r) {
            Rectangle2D dst = new Rectangle2D.Double();
            Rectangle2D.intersect(this, r, dst);
            return dst;
        }

        @Override
        public Rectangle2D createUnion(Rectangle2D r) {
            Rectangle2D dest = new Rectangle2D.Double();
            Rectangle2D.union(this, r, dest);
            return dest;
        }

        @Override
        public String toString() {
            // The output format based on 1.5 release behaviour. It could be obtained in the following way
            // System.out.println(new Rectangle2D.Double().toString())
            return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
        }
    }

    /**
     * The Class Iterator provides 
     * access to the coordinates of the Rectangle2D's boundary modified 
     * by an AffineTransform. 
     */
    class Iterator implements PathIterator {

        /** The x coordinate of the rectangle's upper left corner. */
        double x;
        
        /** The y coordinate of the rectangle's upper left corner. */
        double y;
        
        
        /** The width of the rectangle. */
        double width;
        
        /** The height of the rectangle. */
        double height;
                
        /** The AffineTransform that is used to modify the coordinates 
         * that are returned by the path iterator. */
        AffineTransform t;
        
        /** The current segment index. */
        int index;
        
        /**
         * Constructs a new Rectangle2D.Iterator for given rectangle and transformation.
         * 
         * @param r - the source Rectangle2D object
         * @param at - the AffineTransform object to apply to the coordinates 
         * before returning them
         */
        Iterator(Rectangle2D r, AffineTransform at) {
            this.x = r.getX();
            this.y = r.getY();
            this.width = r.getWidth();
            this.height = r.getHeight();
            this.t = at;
            if (width < 0.0 || height < 0.0) {
                index = 6;
            }
        }

        public int getWindingRule() {
            return WIND_NON_ZERO;
        }

        public boolean isDone() {
            return index > 5;
        }

        public void next() {
            index++;
        }

        public int currentSegment(double[] coords) {
            if (isDone()) {
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            if (index == 5) {
                return SEG_CLOSE;
            }
            int type;
            if (index == 0) {
                type = SEG_MOVETO;
                coords[0] = x;
                coords[1] = y;
            } else {
                type = SEG_LINETO;
                switch(index) {
                case 1:
                    coords[0] = x + width;
                    coords[1] = y;
                    break;
                case 2:
                    coords[0] = x + width;
                    coords[1] = y + height;
                    break;
                case 3:
                    coords[0] = x;
                    coords[1] = y + height;
                    break;
                case 4:
                    coords[0] = x;
                    coords[1] = y;
                    break;
                }
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, 1);
            }
            return type;
        }

        public int currentSegment(float[] coords) {
            if (isDone()) {
                throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
            }
            if (index == 5) {
                return SEG_CLOSE;
            }
            int type;
            if (index == 0) {
                coords[0] = (float)x;
                coords[1] = (float)y;
                type = SEG_MOVETO;
            } else {
                type = SEG_LINETO;
                switch(index) {
                case 1:
                    coords[0] = (float)(x + width);
                    coords[1] = (float)y;
                    break;
                case 2:
                    coords[0] = (float)(x + width);
                    coords[1] = (float)(y + height);
                    break;
                case 3:
                    coords[0] = (float)x;
                    coords[1] = (float)(y + height);
                    break;
                case 4:
                    coords[0] = (float)x;
                    coords[1] = (float)y;
                    break;
                }
            }
            if (t != null) {
                t.transform(coords, 0, coords, 0, 1);
            }
            return type;
        }

    }

    /**
     * Instantiates a new rectangle2 d.
     */
    protected Rectangle2D() {
    }

    /**
     * Sets the rectangle's location and dimension.
     * 
     * @param x the x coordinate of the rectangle's upper left corner
     * @param y the y coordinate of the rectangle's upper left corner
     * @param width the width of the rectangle
     * @param height the height of the rectangle
     */
    public abstract void setRect(double x, double y, double width, double height);

    /**
     * Gets the location of the point with respect to the rectangle and 
     * packs the information into a single int using the bitmasks 
     * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT}, 
     * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}.
     * If the rectangle has zero or negative width, then every point
     * is regarded as being both to the left and to the right of the
     * rectangle. Similarly, if the height is zero or negative then 
     * all points are considered to be both both above and below it.
     * 
     * @param x the x coordinate of the point to check
     * @param y the y coordinate of the point to check
     * 
     * @return the point's location with respect to the rectangle.
     */
    public abstract int outcode(double x, double y);

    /**
     * Creates an new rectangle that is the intersection of this rectangle
     * with the given rectangle. The resulting rectangle may be empty. 
     * The data of this rectangle is left unchanged.
     * 
     * @param r the rectangle to intersect with this rectangle.
     * 
     * @return the new rectangle given by intersection.
     */
    public abstract Rectangle2D createIntersection(Rectangle2D r);

    /**
     * Creates an new rectangle that is the union of this rectangle
     * with the given rectangle. The new rectangle is the smallest 
     * rectangle which contains both this rectangle and the rectangle
     * specified as a parameter. The data of this rectangle is left unchanged.
     * 
     * @param r the rectangle to combine with this rectangle
     * 
     * @return the new rectangle given by union
     */
    public abstract Rectangle2D createUnion(Rectangle2D r);

    /**
     * Sets the data of this rectangle to match the data of the given 
     * rectangle.
     * 
     * @param r the rectangle whose data is to be copied into this rectangle's fields.
     */
    public void setRect(Rectangle2D r) {
        setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    @Override
    public void setFrame(double x, double y, double width, double height) {
        setRect(x, y, width, height);
    }

    public Rectangle2D getBounds2D() {
        return (Rectangle2D)clone();
    }

    /**
     * Determines whether any part of the line segment  between (and including) 
     * the two given points touches any 
     * part of the rectangle, including its boundary.
     * 
     * @param x1 the x coordinate of one of the points that determines the 
     * line segment to test
     * @param y1 the y coordinate of one of the points that determines the 
     * line segment to test
     * @param x2 the x coordinate of one of the points that determines the 
     * line segment to test
     * @param y2 the y coordinate of one of the points that determines the 
     * line segment to test
     * 
     * @return true, if at least one point of the line segment between the 
     * two points matches any point of the interior of the rectangle or the
     * rectangle's boundary.
     */
    public boolean intersectsLine(double x1, double y1, double x2, double y2) {
        double rx1 = getX();
        double ry1 = getY();
        double rx2 = rx1 + getWidth();
        double ry2 = ry1 + getHeight();
        return
            (rx1 <= x1 && x1 <= rx2 && ry1 <= y1 && y1 <= ry2) ||
            (rx1 <= x2 && x2 <= rx2 && ry1 <= y2 && y2 <= ry2) ||
            Line2D.linesIntersect(rx1, ry1, rx2, ry2, x1, y1, x2, y2) ||
            Line2D.linesIntersect(rx2, ry1, rx1, ry2, x1, y1, x2, y2);
    }

    /**
     * Determines whether any part of the specified line segment touches any 
     * part of the rectangle, including its boundary.
     * 
     * @param l the line segment to test
     * 
     * @return true, if at least one point of the given line segment 
     * matches any point of the interior of the rectangle or the
     * rectangle's boundary.
     */
    public boolean intersectsLine(Line2D l) {
        return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
    }

    /**
     * Gets the location of the point with respect to the rectangle and 
     * packs the information into a single int using the bitmasks 
     * {@link Rectangle2D#OUT_LEFT}, {@link Rectangle2D#OUT_RIGHT}, 
     * {@link Rectangle2D#OUT_TOP}, and {@link Rectangle2D#OUT_BOTTOM}.
     * If the rectangle has zero or negative width, then every point
     * is regarded as being both to the left and to the right of the
     * rectangle. Similarly, if the height is zero or negative then 
     * all points are considered to be both both above and below it.
     * 
     * @param p the point to check
     * 
     * @return the point's location with respect to the rectangle.
     */
    public int outcode(Point2D p) {
        return outcode(p.getX(), p.getY());
    }

    public boolean contains(double x, double y) {
        if (isEmpty()) {
            return false;
        }

        double x1 = getX();
        double y1 = getY();
        double x2 = x1 + getWidth();
        double y2 = y1 + getHeight();

        return
            x1 <= x && x < x2 &&
            y1 <= y && y < y2;
    }

    public boolean intersects(double x, double y, double width, double height) {
        if (isEmpty() || width <= 0.0 || height <= 0.0) {
            return false;
        }

        double x1 = getX();
        double y1 = getY();
        double x2 = x1 + getWidth();
        double y2 = y1 + getHeight();

        return
            x + width > x1 && x < x2 &&
            y + height > y1 && y < y2;
    }

    public boolean contains(double x, double y, double width, double height) {
        if (isEmpty() || width <= 0.0 || height <= 0.0) {
            return false;
        }

        double x1 = getX();
        double y1 = getY();
        double x2 = x1 + getWidth();
        double y2 = y1 + getHeight();

        return
            x1 <= x && x + width <= x2 &&
            y1 <= y && y + height <= y2;
    }

    /**
     * Changes the data values of the destination rectangle to match 
     * the intersection of the two source rectangles, leaving the 
     * two source rectangles unchanged. The resulting rectangle may be empty. 
     * 
     * @param src1 one of the two source rectangles giving the data to intersect
     * @param src2 one of the two source rectangles giving the data to intersect
     * @param dst the destination object where the data of the intersection is written
     */
    public static void intersect(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
        double x1 = Math.max(src1.getMinX(), src2.getMinX());
        double y1 = Math.max(src1.getMinY(), src2.getMinY());
        double x2 = Math.min(src1.getMaxX(), src2.getMaxX());
        double y2 = Math.min(src1.getMaxY(), src2.getMaxY());
        dst.setFrame(x1, y1, x2 - x1, y2 - y1);
    }

    /**
     * Changes the data values of the destination rectangle to match 
     * the union of the two source rectangles, leaving the 
     * two source rectangles unchanged. The union is the smallest rectangle
     * tha completely covers the two source rectangles. 
     * 
     * @param src1 one of the two source rectangles giving the data
     * @param src2 one of the two source rectangles giving the data
     * @param dst the destination object where the data of the union is written
     */
    public static void union(Rectangle2D src1, Rectangle2D src2, Rectangle2D dst) {
        double x1 = Math.min(src1.getMinX(), src2.getMinX());
        double y1 = Math.min(src1.getMinY(), src2.getMinY());
        double x2 = Math.max(src1.getMaxX(), src2.getMaxX());
        double y2 = Math.max(src1.getMaxY(), src2.getMaxY());
        dst.setFrame(x1, y1, x2 - x1, y2 - y1);
    }

    /**
     * Enlarges the rectangle so that it includes the given point.
     * 
     * @param x the x coordinate of the new point to be covered by the rectangle
     * @param y the y coordinate of the new point to be covered by the rectangle
     */
    public void add(double x, double y) {
        double x1 = Math.min(getMinX(), x);
        double y1 = Math.min(getMinY(), y);
        double x2 = Math.max(getMaxX(), x);
        double y2 = Math.max(getMaxY(), y);
        setRect(x1, y1, x2 - x1, y2 - y1);
    }

    /**
     * Enlarges the rectangle so that it includes the given point.
     * 
     * @param p the new point to be covered by the rectangle
     */
    public void add(Point2D p) {
        add(p.getX(), p.getY());
    }

    /**
     * Enlarges the rectangle so that it covers the given rectangle.
     * 
     * @param r the new rectangle to be covered by this rectangle
     */
    public void add(Rectangle2D r) {
        union(this, r, this);
    }

    public PathIterator getPathIterator(AffineTransform t) {
        return new Iterator(this, t);
    }

    @Override
    public PathIterator getPathIterator(AffineTransform t, double flatness) {
        return new Iterator(this, t);
    }

    @Override
    public int hashCode() {
        HashCode hash = new HashCode();
        hash.append(getX());
        hash.append(getY());
        hash.append(getWidth());
        hash.append(getHeight());
        return hash.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof Rectangle2D) {
            Rectangle2D r = (Rectangle2D)obj;
            return
                getX() == r.getX() &&
                getY() == r.getY() &&
                getWidth() == r.getWidth() &&
                getHeight() == r.getHeight();
        }
        return false;
    }

}