https://openjdk.java.net/ 
/*
 * 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 Rectangle2D class describes a rectangle defined by a location (x,y) and dimension (w x h). 

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
/**
 * 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 Rectangle2D. 
Since:1.2
/**
     * 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 Rectangle2D. 
Since:1.2
/**
     * 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 Rectangle2D. 
Since:1.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 Rectangle2D. 
Since:1.2
/**
     * The bitmask that indicates that a point lies below
     * this {@code Rectangle2D}.
     * @since 1.2
     */
    public static final int OUT_BOTTOM = 8;

    
The Float class defines a rectangle specified in float coordinates. 
Since:1.2
/**
     * 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 Rectangle2D. 
Since:1.2
@serial
/**
         * The X coordinate of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public float x;

        
The Y coordinate of this Rectangle2D. 
Since:1.2
@serial
/**
         * The Y coordinate of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public float y;

        
The width of this Rectangle2D. 
Since:1.2
@serial
/**
         * The width of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public float width;

        
The height of this Rectangle2D. 
Since:1.2
@serial
/**
         * The height of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public float height;

        
Constructs a new Rectangle2D, initialized to location (0.0, 0.0) and size (0.0, 0.0). 
Since:1.2
/**
         * Constructs a new {@code Rectangle2D}, initialized to
         * location (0.0,&nbsp;0.0) and size (0.0,&nbsp;0.0).
         * @since 1.2
         */
        public Float() {
        }

        
Constructs and initializes a Rectangle2D from the specified float coordinates. 
Params:
  • x – the X coordinate of the upper-left corner of the newly constructed Rectangle2D
  • y – the Y coordinate of the upper-left corner of the newly constructed Rectangle2D
  • w – the width of the newly constructed Rectangle2D
  • h – the height of the newly constructed Rectangle2D
Since:1.2
/**
         * 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
/**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getX() {
            return (double) x;
        }

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
Sets the location and size of this Rectangle2D to the specified float values. 
Params:
  • x – the X coordinate of the upper-left corner of this Rectangle2D
  • y – the Y coordinate of the upper-left corner of this Rectangle2D
  • w – the width of this Rectangle2D
  • h – the height of this Rectangle2D
Since:1.2
/**
         * 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
/**
         * {@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
/**
         * {@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
/**
         * {@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
/**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D getBounds2D() {
            return new Float(x, y, width, height);
        }

        
{@inheritDoc}

Since:1.2
/**
         * {@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
/**
         * {@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 String representation of this Rectangle2D. 
Returns:a String representing this Rectangle2D.
Since:1.2
/**
         * 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 Double class defines a rectangle specified in double coordinates. 
Since:1.2
/**
     * 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 Rectangle2D. 
Since:1.2
@serial
/**
         * The X coordinate of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public double x;

        
The Y coordinate of this Rectangle2D. 
Since:1.2
@serial
/**
         * The Y coordinate of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public double y;

        
The width of this Rectangle2D. 
Since:1.2
@serial
/**
         * The width of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public double width;

        
The height of this Rectangle2D. 
Since:1.2
@serial
/**
         * The height of this {@code Rectangle2D}.
         * @since 1.2
         * @serial
         */
        public double height;

        
Constructs a new Rectangle2D, initialized to location (0, 0) and size (0, 0). 
Since:1.2
/**
         * Constructs a new {@code Rectangle2D}, initialized to
         * location (0,&nbsp;0) and size (0,&nbsp;0).
         * @since 1.2
         */
        public Double() {
        }

        
Constructs and initializes a Rectangle2D from the specified double coordinates. 
Params:
  • x – the X coordinate of the upper-left corner of the newly constructed Rectangle2D
  • y – the Y coordinate of the upper-left corner of the newly constructed Rectangle2D
  • w – the width of the newly constructed Rectangle2D
  • h – the height of the newly constructed Rectangle2D
Since:1.2
/**
         * 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
/**
         * {@inheritDoc}
         * @since 1.2
         */
        public double getX() {
            return x;
        }

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
{@inheritDoc}

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

        
{@inheritDoc}

Since:1.2
/**
         * {@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
/**
         * {@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
/**
         * {@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
/**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D getBounds2D() {
            return new Double(x, y, width, height);
        }

        
{@inheritDoc}

Since:1.2
/**
         * {@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
/**
         * {@inheritDoc}
         * @since 1.2
         */
        public Rectangle2D createUnion(Rectangle2D r) {
            Rectangle2D dest = new Rectangle2D.Double();
            Rectangle2D.union(this, r, dest);
            return dest;
        }

        
Returns the String representation of this Rectangle2D. 
Returns:a String representing this Rectangle2D.
Since:1.2
/**
         * 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 Also:
Since:1.2
/**
     * 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 Rectangle2D to the specified double values. 
Params:
  • x – the X coordinate of the upper-left corner of this Rectangle2D
  • y – the Y coordinate of the upper-left corner of this Rectangle2D
  • w – the width of this Rectangle2D
  • h – the height of this Rectangle2D
Since:1.2
/**
     * 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 Rectangle2D to be the same as the specified Rectangle2D. 
Params:
  • r – the specified Rectangle2D
Since:1.2
/**
     * 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 Rectangle2D. 
Params:
  • x1 – the X coordinate of the start point of the specified
          line segment
  • y1 – the Y coordinate of the start point of the specified
          line segment
  • x2 – the X coordinate of the end point of the specified
          line segment
  • y2 – the Y coordinate of the end point of the specified
          line segment
Returns:true if the specified line segment intersects the interior of this Rectangle2D; false otherwise.
Since:1.2
/**
     * 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}; {@code 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 Rectangle2D. 
Params:
  • l – the specified Line2D to test for intersection with the interior of this Rectangle2D
Returns:true if the specified Line2D intersects the interior of this Rectangle2D; false otherwise.
Since:1.2
/**
     * 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 {@code 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 Rectangle2D. This method computes a binary OR of the appropriate mask values indicating, for each side of this Rectangle2D, whether or not the specified coordinates are on the same side of the edge as the rest of this Rectangle2D. 
Params:
  • x – the specified X coordinate
  • y – the specified Y coordinate
See Also:
Returns:the logical OR of all appropriate out codes.
Since:1.2
/**
     * 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 Point2D lies with respect to this Rectangle2D. This method computes a binary OR of the appropriate mask values indicating, for each side of this Rectangle2D, whether or not the specified Point2D is on the same side of the edge as the rest of this Rectangle2D. 
Params:
  • p – the specified Point2D
See Also:
Returns:the logical OR of all appropriate out codes.
Since:1.2
/**
     * 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 Rectangle2D to the specified rectangular values. 
Params:
  • x – the X coordinate of the upper-left corner of this Rectangle2D
  • y – the Y coordinate of the upper-left corner of this Rectangle2D
  • w – the width of this Rectangle2D
  • h – the height of this Rectangle2D
Since:1.2
/**
     * 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
/**
     * {@inheritDoc}
     * @since 1.2
     */
    public Rectangle2D getBounds2D() {
        return (Rectangle2D) clone();
    }

    
{@inheritDoc}

Since:1.2
/**
     * {@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
/**
     * {@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
/**
     * {@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 Rectangle2D object representing the intersection of this Rectangle2D with the specified Rectangle2D. 
Params:
  • r – the Rectangle2D to be intersected with this Rectangle2D
Returns:the largest Rectangle2D contained in both the specified Rectangle2D and in this Rectangle2D.
Since:1.2
/**
     * 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 Rectangle2D objects and puts the result into the specified destination 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. 
Params:
  • src1 – the first of a pair of Rectangle2D objects to be intersected with each other
  • src2 – the second of a pair of Rectangle2D objects to be intersected with each other
  • dest – the Rectangle2D that holds the results of the intersection of src1 and src2
Since:1.2
/**
     * 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 Rectangle2D object representing the union of this Rectangle2D with the specified Rectangle2D. 
Params:
  • r – the Rectangle2D to be combined with this Rectangle2D
Returns:the smallest Rectangle2D containing both the specified Rectangle2D and this Rectangle2D.
Since:1.2
/**
     * 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 Rectangle2D objects and puts the result into the specified destination 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. 
Params:
  • src1 – the first of a pair of Rectangle2D objects to be combined with each other
  • src2 – the second of a pair of Rectangle2D objects to be combined with each other
  • dest – the Rectangle2D that holds the results of the union of src1 and src2
Since:1.2
/**
     * 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 newx and newy, to this Rectangle2D. The resulting Rectangle2D is the smallest Rectangle2D that contains both the original Rectangle2D and the specified point. 
 After adding a point, a call to contains with the added point as an argument does not necessarily return true. The contains method does not return 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, contains returns false for that point. 
Params:
  • newx – the X coordinate of the new point
  • newy – the Y coordinate of the new point
Since:1.2
/**
     * Adds a point, specified by the double precision arguments
     * {@code newx} and {@code newy}, to this
     * {@code Rectangle2D}.  The resulting {@code 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 {@code 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 {@code 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 Point2D object pt to this Rectangle2D. The resulting Rectangle2D is the smallest Rectangle2D that contains both the original Rectangle2D and the specified Point2D. 
 After adding a point, a call to contains with the added point as an argument does not necessarily return true. The contains method does not return 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, contains returns false for that point. 
Params:
  • pt – the new Point2D to add to this Rectangle2D.
Since:1.2
/**
     * Adds the {@code Point2D} object {@code pt} to this
     * {@code Rectangle2D}.
     * The resulting {@code Rectangle2D} is the smallest
     * {@code Rectangle2D} that contains both the original
     * {@code Rectangle2D} and the specified {@code 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 {@code 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 {@code 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 Rectangle2D object to this Rectangle2D. The resulting Rectangle2D is the union of the two Rectangle2D objects. 
Params:
  • r – the Rectangle2D to add to this Rectangle2D.
Since:1.2
/**
     * Adds a {@code Rectangle2D} object to this
     * {@code Rectangle2D}.  The resulting {@code 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 Rectangle2D. The iterator for this class is multi-threaded safe, which means that this Rectangle2D class guarantees that modifications to the geometry of this Rectangle2D object do not affect any iterations of that geometry that are already in process. 
Params:
  • at – an optional AffineTransform to be applied to the coordinates as they are returned in the iteration, or null if untransformed coordinates are desired
Returns: the PathIterator object that returns the geometry of the outline of this Rectangle2D, one segment at a time.
Since:1.2
/**
     * 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 Rectangle2D. Since rectangles are already flat, the flatness parameter is ignored. The iterator for this class is multi-threaded safe, which means that this Rectangle2D class guarantees that modifications to the geometry of this Rectangle2D object do not affect any iterations of that geometry that are already in process. 
Params:
  • at – an optional AffineTransform to be applied to the coordinates as they are returned in the iteration, or null if untransformed coordinates are desired
  • 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 flatness parameter is ignored.
Returns: the PathIterator object that returns the geometry of the outline of this Rectangle2D, one segment at a time.
Since:1.2
/**
     * 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 Rectangle2D. 
Returns:the hashcode for this Rectangle2D.
Since:1.2
/**
     * 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 Object is equal to this Rectangle2D. The specified Object is equal to this Rectangle2D if it is an instance of Rectangle2D and if its location and size are the same as this Rectangle2D. 
Params:
  • obj – an Object to be compared with this Rectangle2D.
Returns: true if obj is an instance of Rectangle2D and has the same values; false otherwise.
Since:1.2
/**
     * Determines whether or not the specified {@code Object} is
     * equal to this {@code Rectangle2D}.  The specified
     * {@code Object} is equal to this {@code 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 {@code 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;
    }
}