| /* |
| * 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}; {@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 |
| * {@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 {@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 {@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 {@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 {@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 |
| * {@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 {@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; |
| } |
| } |
