## com.vividsolutions.jts.geom
Class Envelope

    java.lang.Object
      com.vividsolutions.jts.geom.Envelope

All Implemented Interfaces:
  java.io.Serializable

public class Envelope
extends java.lang.Object
implements java.io.Serializable

Defines a rectangular region of the 2D coordinate plane. It is often used to represent the bounding box of a `Geometry`, e.g. the minimum and maximum x and y values of the `Coordinate`s.

Note that Envelopes support infinite or half-infinite regions, by using the values of `Double.POSITIVE_INFINITY` and `Double.NEGATIVE_INFINITY`.

When Envelope objects are created or initialized, the supplies extent values are automatically sorted into the correct order.

Version:
  1.7
See Also:
  Serialized Form

Constructor Summary
`Envelope()` Creates a null `Envelope`.
`Envelope(Coordinate p)` Creates an `Envelope` for a region defined by a single Coordinate.
`Envelope(Coordinate p1, Coordinate p2)` Creates an `Envelope` for a region defined by two Coordinates.
`Envelope(double x1, double x2, double y1, double y2)` Creates an `Envelope` for a region defined by maximum and minimum values.
`Envelope(Envelope env)` Create an `Envelope` from an existing Envelope.

Method Summary
`Coordinate` `centre()` Computes the coordinate of the centre of this envelope (as long as it is non-null
`boolean` `contains(Coordinate p)` Tests if the given point lies in or on the envelope.
`boolean` `contains(double x, double y)` Tests if the given point lies in or on the envelope.
`boolean` `contains(Envelope other)` Tests if the `Envelope other` lies wholely inside this `Envelope` (inclusive of the boundary).
`boolean` `covers(Coordinate p)` Tests if the given point lies in or on the envelope.
`boolean` `covers(double x, double y)` Tests if the given point lies in or on the envelope.
`boolean` `covers(Envelope other)` Tests if the `Envelope other` lies wholely inside this `Envelope` (inclusive of the boundary).
`double` `distance(Envelope env)` Computes the distance between this and another `Envelope`.
`boolean` `equals(java.lang.Object other)`
`void` `expandBy(double distance)` Expands this envelope by a given distance in all directions.
`void` `expandBy(double deltaX, double deltaY)` Expands this envelope by a given distance in all directions.
`void` `expandToInclude(Coordinate p)` Enlarges the boundary of the `Envelope` so that it contains (x,y).
`void` `expandToInclude(double x, double y)` Enlarges the boundary of the `Envelope` so that it contains (x,y).
`void` `expandToInclude(Envelope other)` Enlarges the boundary of the `Envelope` so that it contains `other`.
`double` `getHeight()` Returns the difference between the maximum and minimum y values.
`double` `getMaxX()` Returns the `Envelope`s maximum x-value.
`double` `getMaxY()` Returns the `Envelope`s maximum y-value.
`double` `getMinX()` Returns the `Envelope`s minimum x-value.
`double` `getMinY()` Returns the `Envelope`s minimum y-value.
`double` `getWidth()` Returns the difference between the maximum and minimum x values.
`int` `hashCode()`
`void` `init()` Initialize to a null `Envelope`.
`void` `init(Coordinate p)` Initialize an `Envelope` to a region defined by a single Coordinate.
`void` `init(Coordinate p1, Coordinate p2)` Initialize an `Envelope` to a region defined by two Coordinates.
`void` `init(double x1, double x2, double y1, double y2)` Initialize an `Envelope` for a region defined by maximum and minimum values.
`void` `init(Envelope env)` Initialize an `Envelope` from an existing Envelope.
`Envelope` `intersection(Envelope env)` Computes the intersection of two `Envelopes`
`boolean` `intersects(Coordinate p)` Check if the point `p` overlaps (lies inside) the region of this `Envelope`.
`static boolean` `intersects(Coordinate p1, Coordinate p2, Coordinate q)` Test the point q to see whether it intersects the Envelope defined by p1-p2
`static boolean` `intersects(Coordinate p1, Coordinate p2, Coordinate q1, Coordinate q2)` Test the envelope defined by p1-p2 for intersection with the envelope defined by q1-q2
`boolean` `intersects(double x, double y)` Check if the point `(x, y)` overlaps (lies inside) the region of this `Envelope`.
`boolean` `intersects(Envelope other)` Check if the region defined by `other` overlaps (intersects) the region of this `Envelope`.
`boolean` `isNull()` Returns `true` if this `Envelope` is a "null" envelope.
`boolean` `overlaps(Coordinate p)` Deprecated. Use #intersects instead.
`boolean` `overlaps(double x, double y)` Deprecated. Use #intersects instead.
`boolean` `overlaps(Envelope other)` Deprecated. Use #intersects instead. In the future, #overlaps may be changed to be a true overlap check; that is, whether the intersection is two-dimensional.
`void` `setToNull()` Makes this `Envelope` a "null" envelope, that is, the envelope of the empty geometry.
`java.lang.String` `toString()`
`void` `translate(double transX, double transY)` Translates this envelope by given amounts in the X and Y direction.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### Envelope

    public Envelope()

  Creates a null `Envelope`.

### Envelope

    public Envelope(double x1,
                    double x2,
                    double y1,
                    double y2)

  Creates an `Envelope` for a region defined by maximum and minimum values.

Parameters:
  `x1` - the first x-value
  `x2` - the second x-value
  `y1` - the first y-value
  `y2` - the second y-value

### Envelope

    public Envelope(Coordinate p1,
                    Coordinate p2)

  Creates an `Envelope` for a region defined by two Coordinates.

Parameters:
  `p1` - the first Coordinate
  `p2` - the second Coordinate

### Envelope

    public Envelope(Coordinate p)

  Creates an `Envelope` for a region defined by a single Coordinate.

### Envelope

    public Envelope(Envelope env)

  Create an `Envelope` from an existing Envelope.

Parameters:
  `env` - the Envelope to initialize from

Method Detail

### hashCode

    public int hashCode()

### intersects

    public static boolean intersects(Coordinate p1,
                                     Coordinate p2,
                                     Coordinate q)

  Test the point q to see whether it intersects the Envelope defined by p1-p2

  Parameters:
    `p1` - one extremal point of the envelope
    `p2` - another extremal point of the envelope
    `q` - the point to test for intersection
  Returns:
    `true` if q intersects the envelope p1-p2

### intersects

    public static boolean intersects(Coordinate p1,
                                     Coordinate p2,
                                     Coordinate q1,
                                     Coordinate q2)

  Test the envelope defined by p1-p2 for intersection with the envelope defined by q1-q2

  Parameters:
    `p1` - one extremal point of the envelope P
    `p2` - another extremal point of the envelope P
    `q1` - one extremal point of the envelope Q
    `q2` - another extremal point of the envelope Q
  Returns:
    `true` if Q intersects P

### init

    public void init()

  Initialize to a null `Envelope`.

### init

    public void init(double x1,
                     double x2,
                     double y1,
                     double y2)

  Initialize an `Envelope` for a region defined by maximum and minimum values.

  Parameters:
    `x1` - the first x-value
    `x2` - the second x-value
    `y1` - the first y-value
    `y2` - the second y-value

### init

    public void init(Coordinate p1,
                     Coordinate p2)

  Initialize an `Envelope` to a region defined by two Coordinates.

  Parameters:
    `p1` - the first Coordinate
    `p2` - the second Coordinate

### init

    public void init(Coordinate p)

  Initialize an `Envelope` to a region defined by a single Coordinate.

### init

    public void init(Envelope env)

  Initialize an `Envelope` from an existing Envelope.

  Parameters:
    `env` - the Envelope to initialize from

### setToNull

    public void setToNull()

  Makes this `Envelope` a "null" envelope, that is, the envelope of the empty geometry.

### isNull

    public boolean isNull()

  Returns `true` if this `Envelope` is a "null" envelope.

  Returns:
    `true` if this `Envelope` is uninitialized or is the envelope of the empty geometry.

### getWidth

    public double getWidth()

  Returns the difference between the maximum and minimum x values.

  Returns:
    max x - min x, or 0 if this is a null `Envelope`

### getHeight

    public double getHeight()

  Returns the difference between the maximum and minimum y values.

  Returns:
    max y - min y, or 0 if this is a null `Envelope`

### getMinX

    public double getMinX()

  Returns the `Envelope`s minimum x-value. min x > max x indicates that this is a null `Envelope`.

  Returns:
    the minimum x-coordinate

### getMaxX

    public double getMaxX()

  Returns the `Envelope`s maximum x-value. min x > max x indicates that this is a null `Envelope`.

  Returns:
    the maximum x-coordinate

### getMinY

    public double getMinY()

  Returns the `Envelope`s minimum y-value. min y > max y indicates that this is a null `Envelope`.

  Returns:
    the minimum y-coordinate

### getMaxY

    public double getMaxY()

  Returns the `Envelope`s maximum y-value. min y > max y indicates that this is a null `Envelope`.

  Returns:
    the maximum y-coordinate

### expandToInclude

    public void expandToInclude(Coordinate p)

  Enlarges the boundary of the `Envelope` so that it contains (x,y). Does nothing if (x,y) is already on or within the boundaries.

### expandBy

    public void expandBy(double distance)

  Expands this envelope by a given distance in all directions. Both positive and negative distances are supported.

  Parameters:
    `distance` - the distance to expand the envelope
  Returns:
    this envelope

### expandBy

    public void expandBy(double deltaX,
                         double deltaY)

  Expands this envelope by a given distance in all directions. Both positive and negative distances are supported.

  Parameters:
    `deltaX` - the distance to expand the envelope along the the X axis
    `deltaY` - the distance to expand the envelope along the the Y axis

### expandToInclude

    public void expandToInclude(double x,
                                double y)

  Enlarges the boundary of the `Envelope` so that it contains (x,y). Does nothing if (x,y) is already on or within the boundaries.

  Parameters:
    `x` - the value to lower the minimum x to or to raise the maximum x to
    `y` - the value to lower the minimum y to or to raise the maximum y to

### expandToInclude

    public void expandToInclude(Envelope other)

  Enlarges the boundary of the `Envelope` so that it contains `other`. Does nothing if `other` is wholly on or within the boundaries.

  Parameters:
    `other` - the `Envelope` to merge with

### translate

    public void translate(double transX,
                          double transY)

  Translates this envelope by given amounts in the X and Y direction.

  Parameters:
    `transX` - the amount to translate along the X axis
    `transY` - the amount to translate along the Y axis

### centre

    public Coordinate centre()

  Computes the coordinate of the centre of this envelope (as long as it is non-null

  Returns:
    the centre coordinate of this envelope `null` if the envelope is null

### intersection

    public Envelope intersection(Envelope env)

  Computes the intersection of two `Envelopes`

  Parameters:
    `env` - the envelope to intersect with
  Returns:
    a new Envelope representing the intersection of the envelopes (this will be the null envelope if either argument is null, or they do not intersect

### intersects

    public boolean intersects(Envelope other)

  Check if the region defined by `other` overlaps (intersects) the region of this `Envelope`.

  Parameters:
    `other` - the `Envelope` which this `Envelope` is being checked for overlapping
  Returns:
    `true` if the `Envelope`s overlap

### overlaps

    public boolean overlaps(Envelope other)

  Deprecated. Use #intersects instead. In the future, #overlaps may be changed to be a true overlap check; that is, whether the intersection is two-dimensional.

### intersects

    public boolean intersects(Coordinate p)

  Check if the point `p` overlaps (lies inside) the region of this `Envelope`.

  Returns:
    `true` if the point overlaps this `Envelope`

### overlaps

    public boolean overlaps(Coordinate p)

  Deprecated. Use #intersects instead.

### intersects

    public boolean intersects(double x,
                              double y)

  Check if the point `(x, y)` overlaps (lies inside) the region of this `Envelope`.

  Parameters:
    `x` - the x-ordinate of the point
    `y` - the y-ordinate of the point
  Returns:
    `true` if the point overlaps this `Envelope`

### overlaps

    public boolean overlaps(double x,
                            double y)

  Deprecated. Use #intersects instead.

### contains

    public boolean contains(Envelope other)

  Tests if the `Envelope other` lies wholely inside this `Envelope` (inclusive of the boundary).

  Note that this is not the same definition as the SFS `contains`, which would exclude the envelope boundary.

  Parameters:
    `other` - the `Envelope` to check
  Returns:
    true if `other` is contained in this `Envelope`
  See Also:
    `covers(Envelope)`

### contains

    public boolean contains(Coordinate p)

  Tests if the given point lies in or on the envelope.

  Note that this is not the same definition as the SFS `contains`, which would exclude the envelope boundary.

  Parameters:
    `p` - the point which this `Envelope` is being checked for containing
  Returns:
    `true` if the point lies in the interior or on the boundary of this `Envelope`.
  See Also:
    `covers(Coordinate)`

### contains

    public boolean contains(double x,
                            double y)

  Tests if the given point lies in or on the envelope.

  Note that this is not the same definition as the SFS `contains`, which would exclude the envelope boundary.

  Parameters:
    `x` - the x-coordinate of the point which this `Envelope` is being checked for containing
    `y` - the y-coordinate of the point which this `Envelope` is being checked for containing
  Returns:
    `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.
  See Also:
    `covers(double, double)`

### covers

    public boolean covers(double x,
                          double y)

  Tests if the given point lies in or on the envelope.

  Parameters:
    `x` - the x-coordinate of the point which this `Envelope` is being checked for containing
    `y` - the y-coordinate of the point which this `Envelope` is being checked for containing
  Returns:
    `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.

### covers

    public boolean covers(Coordinate p)

  Tests if the given point lies in or on the envelope.

  Parameters:
    `p` - the point which this `Envelope` is being checked for containing
  Returns:
    `true` if the point lies in the interior or on the boundary of this `Envelope`.

### covers

    public boolean covers(Envelope other)

  Tests if the `Envelope other` lies wholely inside this `Envelope` (inclusive of the boundary).

  Parameters:
    `other` - the `Envelope` to check
  Returns:
    true if this `Envelope` covers the `other`

### distance

    public double distance(Envelope env)

  Computes the distance between this and another `Envelope`. The distance between overlapping Envelopes is 0. Otherwise, the distance is the Euclidean distance between the closest points.

### equals

    public boolean equals(java.lang.Object other)

### toString

    public java.lang.String toString()