Java example source code file (Rectangle2D.java)

This example Java source code file (Rectangle2D.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

double, float, out_bottom, out_left, out_right, out_top, pathiterator, rectangle2d, rectangularshape, rectiterator, serializable, string

The Rectangle2D.java Java example source code

/*
 * Copyright (c) 1997, 2006, 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.io.Serializable;

/**
 * The <code>Rectangle2D class describes a rectangle
 * defined by a location {@code (x,y)} and dimension
 * {@code (w x h)}.
 * <p>
 * This class is only the abstract superclass for all objects that
 * store a 2D rectangle.
 * The actual storage representation of the coordinates is left to
 * the subclass.
 *
 * @author      Jim Graham
 * @since 1.2
 */
public abstract class Rectangle2D extends RectangularShape {
    /**
     * The bitmask that indicates that a point lies to the left of
     * this <code>Rectangle2D.
     * @since 1.2
     */
    public static final int OUT_LEFT = 1;

    /**
     * The bitmask that indicates that a point lies above
     * this <code>Rectangle2D.
     * @since 1.2
     */
    public static final int OUT_TOP = 2;

    /**
     * The bitmask that indicates that a point lies to the right of
     * this <code>Rectangle2D.
     * @since 1.2
     */
    public static final int OUT_RIGHT = 4;

    /**
     * The bitmask that indicates that a point lies below
     * this <code>Rectangle2D.
     * @since 1.2
     */
    public static final int OUT_BOTTOM = 8;

    /**
     * The <code>Float class defines a rectangle specified in float
     * coordinates.
     * @since 1.2
     */
    public static class Float extends Rectangle2D implements Serializable {
        /**
         * The X coordinate of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public float x;

        /**
         * The Y coordinate of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public float y;

        /**
         * The width of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public float width;

        /**
         * The height of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public float height;

        /**
         * Constructs a new <code>Rectangle2D, initialized to
         * location (0.0, 0.0) and size (0.0, 0.0).
         * @since 1.2
         */
        public Float() {
        }

        /**
         * Constructs and initializes a <code>Rectangle2D
         * from the specified <code>float coordinates.
         *
         * @param x the X coordinate of the upper-left corner
         *          of the newly constructed <code>Rectangle2D
         * @param y the Y coordinate of the upper-left corner
         *          of the newly constructed <code>Rectangle2D
         * @param w the width of the newly constructed
         *          <code>Rectangle2D
         * @param h the height of the newly constructed
         *          <code>Rectangle2D
         * @since 1.2
        */
        public Float(float x, float y, float w, float h) {
            setRect(x, y, w, h);
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getX() {
            return (double) x;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getY() {
            return (double) y;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getWidth() {
            return (double) width;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getHeight() {
            return (double) height;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public boolean isEmpty() {
            return (width <= 0.0f) || (height <= 0.0f);
        }

        /**
         * Sets the location and size of this <code>Rectangle2D
         * to the specified <code>float values.
         *
         * @param x the X coordinate of the upper-left corner
         *          of this <code>Rectangle2D
         * @param y the Y coordinate of the upper-left corner
         *          of this <code>Rectangle2D
         * @param w the width of this <code>Rectangle2D
         * @param h the height of this <code>Rectangle2D
         * @since 1.2
         */
        public void setRect(float x, float y, float w, float h) {
            this.x = x;
            this.y = y;
            this.width = w;
            this.height = h;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public void setRect(double x, double y, double w, double h) {
            this.x = (float) x;
            this.y = (float) y;
            this.width = (float) w;
            this.height = (float) h;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        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();
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public int outcode(double x, double y) {
            /*
             * Note on casts to double below.  If the arithmetic of
             * x+w or y+h is done in float, then some bits may be
             * lost if the binary exponents of x/y and w/h are not
             * similar.  By converting to double before the addition
             * we force the addition to be carried out in double to
             * avoid rounding error in the comparison.
             *
             * See bug 4320890 for problems that this inaccuracy causes.
             */
            int out = 0;
            if (this.width <= 0) {
                out |= OUT_LEFT | OUT_RIGHT;
            } else if (x < this.x) {
                out |= OUT_LEFT;
            } else if (x > this.x + (double) this.width) {
                out |= OUT_RIGHT;
            }
            if (this.height <= 0) {
                out |= OUT_TOP | OUT_BOTTOM;
            } else if (y < this.y) {
                out |= OUT_TOP;
            } else if (y > this.y + (double) this.height) {
                out |= OUT_BOTTOM;
            }
            return out;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D getBounds2D() {
            return new Float(x, y, width, height);
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D createIntersection(Rectangle2D r) {
            Rectangle2D dest;
            if (r instanceof Float) {
                dest = new Rectangle2D.Float();
            } else {
                dest = new Rectangle2D.Double();
            }
            Rectangle2D.intersect(this, r, dest);
            return dest;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D createUnion(Rectangle2D r) {
            Rectangle2D dest;
            if (r instanceof Float) {
                dest = new Rectangle2D.Float();
            } else {
                dest = new Rectangle2D.Double();
            }
            Rectangle2D.union(this, r, dest);
            return dest;
        }

        /**
         * Returns the <code>String representation of this
         * <code>Rectangle2D.
         * @return a <code>String representing this
         * <code>Rectangle2D.
         * @since 1.2
         */
        public String toString() {
            return getClass().getName()
                + "[x=" + x +
                ",y=" + y +
                ",w=" + width +
                ",h=" + height + "]";
        }

        /*
         * JDK 1.6 serialVersionUID
         */
        private static final long serialVersionUID = 3798716824173675777L;
    }

    /**
     * The <code>Double class defines a rectangle specified in
     * double coordinates.
     * @since 1.2
     */
    public static class Double extends Rectangle2D implements Serializable {
        /**
         * The X coordinate of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public double x;

        /**
         * The Y coordinate of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public double y;

        /**
         * The width of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public double width;

        /**
         * The height of this <code>Rectangle2D.
         * @since 1.2
         * @serial
         */
        public double height;

        /**
         * Constructs a new <code>Rectangle2D, initialized to
         * location (0, 0) and size (0, 0).
         * @since 1.2
         */
        public Double() {
        }

        /**
         * Constructs and initializes a <code>Rectangle2D
         * from the specified <code>double coordinates.
         *
         * @param x the X coordinate of the upper-left corner
         *          of the newly constructed <code>Rectangle2D
         * @param y the Y coordinate of the upper-left corner
         *          of the newly constructed <code>Rectangle2D
         * @param w the width of the newly constructed
         *          <code>Rectangle2D
         * @param h the height of the newly constructed
         *          <code>Rectangle2D
         * @since 1.2
         */
        public Double(double x, double y, double w, double h) {
            setRect(x, y, w, h);
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getX() {
            return x;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getY() {
            return y;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getWidth() {
            return width;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getHeight() {
            return height;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public boolean isEmpty() {
            return (width <= 0.0) || (height <= 0.0);
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public void setRect(double x, double y, double w, double h) {
            this.x = x;
            this.y = y;
            this.width = w;
            this.height = h;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public void setRect(Rectangle2D r) {
            this.x = r.getX();
            this.y = r.getY();
            this.width = r.getWidth();
            this.height = r.getHeight();
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public int outcode(double x, double y) {
            int out = 0;
            if (this.width <= 0) {
                out |= OUT_LEFT | OUT_RIGHT;
            } else if (x < this.x) {
                out |= OUT_LEFT;
            } else if (x > this.x + this.width) {
                out |= OUT_RIGHT;
            }
            if (this.height <= 0) {
                out |= OUT_TOP | OUT_BOTTOM;
            } else if (y < this.y) {
                out |= OUT_TOP;
            } else if (y > this.y + this.height) {
                out |= OUT_BOTTOM;
            }
            return out;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D getBounds2D() {
            return new Double(x, y, width, height);
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D createIntersection(Rectangle2D r) {
            Rectangle2D dest = new Rectangle2D.Double();
            Rectangle2D.intersect(this, r, dest);
            return dest;
        }

        /**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D createUnion(Rectangle2D r) {
            Rectangle2D dest = new Rectangle2D.Double();
            Rectangle2D.union(this, r, dest);
            return dest;
        }

        /**
         * Returns the <code>String representation of this
         * <code>Rectangle2D.
         * @return a <code>String representing this
         * <code>Rectangle2D.
         * @since 1.2
         */
        public String toString() {
            return getClass().getName()
                + "[x=" + x +
                ",y=" + y +
                ",w=" + width +
                ",h=" + height + "]";
        }

        /*
         * JDK 1.6 serialVersionUID
         */
        private static final long serialVersionUID = 7771313791441850493L;
    }

    /**
     * This is an abstract class that cannot be instantiated directly.
     * Type-specific implementation subclasses are available for
     * instantiation and provide a number of formats for storing
     * the information necessary to satisfy the various accessor
     * methods below.
     *
     * @see java.awt.geom.Rectangle2D.Float
     * @see java.awt.geom.Rectangle2D.Double
     * @see java.awt.Rectangle
     * @since 1.2
     */
    protected Rectangle2D() {
    }

    /**
     * Sets the location and size of this <code>Rectangle2D
     * to the specified <code>double values.
     *
     * @param x the X coordinate of the upper-left corner
     *          of this <code>Rectangle2D
     * @param y the Y coordinate of the upper-left corner
     *          of this <code>Rectangle2D
     * @param w the width of this <code>Rectangle2D
     * @param h the height of this <code>Rectangle2D
     * @since 1.2
     */
    public abstract void setRect(double x, double y, double w, double h);

    /**
     * Sets this <code>Rectangle2D to be the same as the specified
     * <code>Rectangle2D.
     * @param r the specified <code>Rectangle2D
     * @since 1.2
     */
    public void setRect(Rectangle2D r) {
        setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
    }

    /**
     * Tests if the specified line segment intersects the interior of this
     * <code>Rectangle2D.
     *
     * @param x1 the X coordinate of the start point of the specified
     *           line segment
     * @param y1 the Y coordinate of the start point of the specified
     *           line segment
     * @param x2 the X coordinate of the end point of the specified
     *           line segment
     * @param y2 the Y coordinate of the end point of the specified
     *           line segment
     * @return <code>true if the specified line segment intersects
     * the interior of this <code>Rectangle2D; false
     * otherwise.
     * @since 1.2
     */
    public boolean intersectsLine(double x1, double y1, double x2, double y2) {
        int out1, out2;
        if ((out2 = outcode(x2, y2)) == 0) {
            return true;
        }
        while ((out1 = outcode(x1, y1)) != 0) {
            if ((out1 & out2) != 0) {
                return false;
            }
            if ((out1 & (OUT_LEFT | OUT_RIGHT)) != 0) {
                double x = getX();
                if ((out1 & OUT_RIGHT) != 0) {
                    x += getWidth();
                }
                y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
                x1 = x;
            } else {
                double y = getY();
                if ((out1 & OUT_BOTTOM) != 0) {
                    y += getHeight();
                }
                x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
                y1 = y;
            }
        }
        return true;
    }

    /**
     * Tests if the specified line segment intersects the interior of this
     * <code>Rectangle2D.
     * @param l the specified {@link Line2D} to test for intersection
     * with the interior of this <code>Rectangle2D
     * @return <code>true if the specified Line2D
     * intersects the interior of this <code>Rectangle2D;
     * <code>false otherwise.
     * @since 1.2
     */
    public boolean intersectsLine(Line2D l) {
        return intersectsLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
    }

    /**
     * Determines where the specified coordinates lie with respect
     * to this <code>Rectangle2D.
     * This method computes a binary OR of the appropriate mask values
     * indicating, for each side of this <code>Rectangle2D,
     * whether or not the specified coordinates are on the same side
     * of the edge as the rest of this <code>Rectangle2D.
     * @param x the specified X coordinate
     * @param y the specified Y coordinate
     * @return the logical OR of all appropriate out codes.
     * @see #OUT_LEFT
     * @see #OUT_TOP
     * @see #OUT_RIGHT
     * @see #OUT_BOTTOM
     * @since 1.2
     */
    public abstract int outcode(double x, double y);

    /**
     * Determines where the specified {@link Point2D} lies with
     * respect to this <code>Rectangle2D.
     * This method computes a binary OR of the appropriate mask values
     * indicating, for each side of this <code>Rectangle2D,
     * whether or not the specified <code>Point2D is on the same
     * side of the edge as the rest of this <code>Rectangle2D.
     * @param p the specified <code>Point2D
     * @return the logical OR of all appropriate out codes.
     * @see #OUT_LEFT
     * @see #OUT_TOP
     * @see #OUT_RIGHT
     * @see #OUT_BOTTOM
     * @since 1.2
     */
    public int outcode(Point2D p) {
        return outcode(p.getX(), p.getY());
    }

    /**
     * Sets the location and size of the outer bounds of this
     * <code>Rectangle2D to the specified rectangular values.
     *
     * @param x the X coordinate of the upper-left corner
     *          of this <code>Rectangle2D
     * @param y the Y coordinate of the upper-left corner
     *          of this <code>Rectangle2D
     * @param w the width of this <code>Rectangle2D
     * @param h the height of this <code>Rectangle2D
     * @since 1.2
     */
    public void setFrame(double x, double y, double w, double h) {
        setRect(x, y, w, h);
    }

    /**
     * {@inheritDoc}
     * @since 1.2
     */
    public Rectangle2D getBounds2D() {
        return (Rectangle2D) clone();
    }

    /**
     * {@inheritDoc}
     * @since 1.2
     */
    public boolean contains(double x, double y) {
        double x0 = getX();
        double y0 = getY();
        return (x >= x0 &&
                y >= y0 &&
                x < x0 + getWidth() &&
                y < y0 + getHeight());
    }

    /**
     * {@inheritDoc}
     * @since 1.2
     */
    public boolean intersects(double x, double y, double w, double h) {
        if (isEmpty() || w <= 0 || h <= 0) {
            return false;
        }
        double x0 = getX();
        double y0 = getY();
        return (x + w > x0 &&
                y + h > y0 &&
                x < x0 + getWidth() &&
                y < y0 + getHeight());
    }

    /**
     * {@inheritDoc}
     * @since 1.2
     */
    public boolean contains(double x, double y, double w, double h) {
        if (isEmpty() || w <= 0 || h <= 0) {
            return false;
        }
        double x0 = getX();
        double y0 = getY();
        return (x >= x0 &&
                y >= y0 &&
                (x + w) <= x0 + getWidth() &&
                (y + h) <= y0 + getHeight());
    }

    /**
     * Returns a new <code>Rectangle2D object representing the
     * intersection of this <code>Rectangle2D with the specified
     * <code>Rectangle2D.
     * @param r the <code>Rectangle2D to be intersected with
     * this <code>Rectangle2D
     * @return the largest <code>Rectangle2D contained in both
     *          the specified <code>Rectangle2D and in this
     *          <code>Rectangle2D.
     * @since 1.2
     */
    public abstract Rectangle2D createIntersection(Rectangle2D r);

    /**
     * Intersects the pair of specified source <code>Rectangle2D
     * objects and puts the result into the specified destination
     * <code>Rectangle2D object.  One of the source rectangles
     * can also be the destination to avoid creating a third Rectangle2D
     * object, but in this case the original points of this source
     * rectangle will be overwritten by this method.
     * @param src1 the first of a pair of <code>Rectangle2D
     * objects to be intersected with each other
     * @param src2 the second of a pair of <code>Rectangle2D
     * objects to be intersected with each other
     * @param dest the <code>Rectangle2D that holds the
     * results of the intersection of <code>src1 and
     * <code>src2
     * @since 1.2
     */
    public static void intersect(Rectangle2D src1,
                                 Rectangle2D src2,
                                 Rectangle2D dest) {
        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());
        dest.setFrame(x1, y1, x2-x1, y2-y1);
    }

    /**
     * Returns a new <code>Rectangle2D object representing the
     * union of this <code>Rectangle2D with the specified
     * <code>Rectangle2D.
     * @param r the <code>Rectangle2D to be combined with
     * this <code>Rectangle2D
     * @return the smallest <code>Rectangle2D containing both
     * the specified <code>Rectangle2D and this
     * <code>Rectangle2D.
     * @since 1.2
     */
    public abstract Rectangle2D createUnion(Rectangle2D r);

    /**
     * Unions the pair of source <code>Rectangle2D objects
     * and puts the result into the specified destination
     * <code>Rectangle2D object.  One of the source rectangles
     * can also be the destination to avoid creating a third Rectangle2D
     * object, but in this case the original points of this source
     * rectangle will be overwritten by this method.
     * @param src1 the first of a pair of <code>Rectangle2D
     * objects to be combined with each other
     * @param src2 the second of a pair of <code>Rectangle2D
     * objects to be combined with each other
     * @param dest the <code>Rectangle2D that holds the
     * results of the union of <code>src1 and
     * <code>src2
     * @since 1.2
     */
    public static void union(Rectangle2D src1,
                             Rectangle2D src2,
                             Rectangle2D dest) {
        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());
        dest.setFrameFromDiagonal(x1, y1, x2, y2);
    }

    /**
     * Adds a point, specified by the double precision arguments
     * <code>newx and newy, to this
     * <code>Rectangle2D.  The resulting Rectangle2D
     * is the smallest <code>Rectangle2D that
     * contains both the original <code>Rectangle2D and the
     * specified point.
     * <p>
     * After adding a point, a call to <code>contains with the
     * added point as an argument does not necessarily return
     * <code>true. The contains method does not
     * return <code>true for points on the right or bottom
     * edges of a rectangle. Therefore, if the added point falls on
     * the left or bottom edge of the enlarged rectangle,
     * <code>contains returns false for that point.
     * @param newx the X coordinate of the new point
     * @param newy the Y coordinate of the new point
     * @since 1.2
     */
    public void add(double newx, double newy) {
        double x1 = Math.min(getMinX(), newx);
        double x2 = Math.max(getMaxX(), newx);
        double y1 = Math.min(getMinY(), newy);
        double y2 = Math.max(getMaxY(), newy);
        setRect(x1, y1, x2 - x1, y2 - y1);
    }

    /**
     * Adds the <code>Point2D object pt to this
     * <code>Rectangle2D.
     * The resulting <code>Rectangle2D is the smallest
     * <code>Rectangle2D that contains both the original
     * <code>Rectangle2D and the specified Point2D.
     * <p>
     * After adding a point, a call to <code>contains with the
     * added point as an argument does not necessarily return
     * <code>true. The contains
     * method does not return <code>true for points on the right
     * or bottom edges of a rectangle. Therefore, if the added point falls
     * on the left or bottom edge of the enlarged rectangle,
     * <code>contains returns false for that point.
     * @param     pt the new <code>Point2D to add to this
     * <code>Rectangle2D.
     * @since 1.2
     */
    public void add(Point2D pt) {
        add(pt.getX(), pt.getY());
    }

    /**
     * Adds a <code>Rectangle2D object to this
     * <code>Rectangle2D.  The resulting Rectangle2D
     * is the union of the two <code>Rectangle2D objects.
     * @param r the <code>Rectangle2D to add to this
     * <code>Rectangle2D.
     * @since 1.2
     */
    public void add(Rectangle2D r) {
        double x1 = Math.min(getMinX(), r.getMinX());
        double x2 = Math.max(getMaxX(), r.getMaxX());
        double y1 = Math.min(getMinY(), r.getMinY());
        double y2 = Math.max(getMaxY(), r.getMaxY());
        setRect(x1, y1, x2 - x1, y2 - y1);
    }

    /**
     * Returns an iteration object that defines the boundary of this
     * <code>Rectangle2D.
     * The iterator for this class is multi-threaded safe, which means
     * that this <code>Rectangle2D class guarantees that
     * modifications to the geometry of this <code>Rectangle2D
     * object do not affect any iterations of that geometry that
     * are already in process.
     * @param at an optional <code>AffineTransform to be applied to
     * the coordinates as they are returned in the iteration, or
     * <code>null if untransformed coordinates are desired
     * @return    the <code>PathIterator object that returns the
     *          geometry of the outline of this
     *          <code>Rectangle2D, one segment at a time.
     * @since 1.2
     */
    public PathIterator getPathIterator(AffineTransform at) {
        return new RectIterator(this, at);
    }

    /**
     * Returns an iteration object that defines the boundary of the
     * flattened <code>Rectangle2D.  Since rectangles are already
     * flat, the <code>flatness parameter is ignored.
     * The iterator for this class is multi-threaded safe, which means
     * that this <code>Rectangle2D class guarantees that
     * modifications to the geometry of this <code>Rectangle2D
     * object do not affect any iterations of that geometry that
     * are already in process.
     * @param at an optional <code>AffineTransform to be applied to
     * the coordinates as they are returned in the iteration, or
     * <code>null if untransformed coordinates are desired
     * @param flatness the maximum distance that the line segments used to
     * approximate the curved segments are allowed to deviate from any
     * point on the original curve.  Since rectangles are already flat,
     * the <code>flatness parameter is ignored.
     * @return    the <code>PathIterator object that returns the
     *          geometry of the outline of this
     *          <code>Rectangle2D, one segment at a time.
     * @since 1.2
     */
    public PathIterator getPathIterator(AffineTransform at, double flatness) {
        return new RectIterator(this, at);
    }

    /**
     * Returns the hashcode for this <code>Rectangle2D.
     * @return the hashcode for this <code>Rectangle2D.
     * @since 1.2
     */
    public int hashCode() {
        long bits = java.lang.Double.doubleToLongBits(getX());
        bits += java.lang.Double.doubleToLongBits(getY()) * 37;
        bits += java.lang.Double.doubleToLongBits(getWidth()) * 43;
        bits += java.lang.Double.doubleToLongBits(getHeight()) * 47;
        return (((int) bits) ^ ((int) (bits >> 32)));
    }

    /**
     * Determines whether or not the specified <code>Object is
     * equal to this <code>Rectangle2D.  The specified
     * <code>Object is equal to this Rectangle2D
     * if it is an instance of <code>Rectangle2D and if its
     * location and size are the same as this <code>Rectangle2D.
     * @param obj an <code>Object to be compared with this
     * <code>Rectangle2D.
     * @return     <code>true if obj is an instance
     *                     of <code>Rectangle2D and has
     *                     the same values; <code>false otherwise.
     * @since 1.2
     */
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof Rectangle2D) {
            Rectangle2D r2d = (Rectangle2D) obj;
            return ((getX() == r2d.getX()) &&
                    (getY() == r2d.getY()) &&
                    (getWidth() == r2d.getWidth()) &&
                    (getHeight() == r2d.getHeight()));
        }
        return false;
    }
}