org.geotools.geometry.jts.ReferencedEnvelope Maven / Gradle / Ivy
/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2005-2015, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library 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
* Lesser General Public License for more details.
*/
package org.geotools.geometry.jts;
import java.awt.geom.Rectangle2D;
import org.geotools.geometry.DirectPosition2D;
import org.geotools.geometry.GeneralEnvelope;
import org.geotools.metadata.i18n.ErrorKeys;
import org.geotools.metadata.i18n.Errors;
import org.geotools.referencing.CRS;
import org.geotools.util.Classes;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Envelope;
import org.opengis.geometry.BoundingBox;
import org.opengis.geometry.DirectPosition;
import org.opengis.geometry.MismatchedDimensionException;
import org.opengis.geometry.MismatchedReferenceSystemException;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.opengis.referencing.operation.CoordinateOperation;
import org.opengis.referencing.operation.CoordinateOperationFactory;
import org.opengis.referencing.operation.MathTransform;
import org.opengis.referencing.operation.TransformException;
/**
* A JTS envelope associated with a {@linkplain CoordinateReferenceSystem coordinate reference
* system}. In addition, this JTS envelope also implements the GeoAPI {@linkplain
* org.opengis.geometry.coordinate.Envelope envelope} interface for interoperability with GeoAPI.
*
* @since 2.2
* @version $Id$
* @author Jody Garnett
* @author Martin Desruisseaux
* @author Simone Giannecchini
* @see org.geotools.geometry.Envelope2D
* @see org.geotools.geometry.GeneralEnvelope
* @see org.opengis.metadata.extent.GeographicBoundingBox
*/
public class ReferencedEnvelope extends Envelope
implements org.opengis.geometry.Envelope, BoundingBox {
/** A ReferencedEnvelope containing "everything" */
public static ReferencedEnvelope EVERYTHING =
new ReferencedEnvelope(
Double.NEGATIVE_INFINITY,
Double.POSITIVE_INFINITY,
Double.NEGATIVE_INFINITY,
Double.POSITIVE_INFINITY,
null) {
private static final long serialVersionUID = -3188702602373537164L;
public boolean contains(BoundingBox bbox) {
return true;
}
public boolean contains(Coordinate p) {
return true;
}
public boolean contains(DirectPosition pos) {
return true;
}
public boolean contains(double x, double y) {
return true;
}
public boolean contains(Envelope other) {
return true;
}
public boolean isEmpty() {
return false;
}
public boolean isNull() {
return true;
}
public double getArea() {
// return super.getArea();
return Double.POSITIVE_INFINITY;
}
public void setBounds(BoundingBox arg0) {
throw new IllegalStateException("Cannot modify ReferencedEnvelope.EVERYTHING");
}
public Coordinate centre() {
return new Coordinate();
}
public void setToNull() {
// um ignore this as we are already "null"
}
public boolean equals(Object obj) {
if (obj == EVERYTHING) {
return true;
}
if (obj instanceof ReferencedEnvelope) {
ReferencedEnvelope other = (ReferencedEnvelope) obj;
if (other.crs != EVERYTHING.crs) return false;
if (other.getMinX() != EVERYTHING.getMinX()) return false;
if (other.getMinY() != EVERYTHING.getMinY()) return false;
if (other.getMaxX() != EVERYTHING.getMaxX()) return false;
if (other.getMaxY() != EVERYTHING.getMaxY()) return false;
return true;
}
return super.equals(obj);
}
public String toString() {
return "ReferencedEnvelope.EVERYTHING";
}
};
/** Serial number for compatibility with different versions. */
private static final long serialVersionUID = -3188702602373537163L;
/** The coordinate reference system, or {@code null}. */
protected CoordinateReferenceSystem crs;
/** Creates a null envelope with a null coordinate reference system. */
public ReferencedEnvelope() {
this((CoordinateReferenceSystem) null);
}
/**
* Creates a null envelope with the specified coordinate reference system.
*
* @param crs The coordinate reference system.
* @throws MismatchedDimensionException if the CRS dimension is not valid.
*/
public ReferencedEnvelope(CoordinateReferenceSystem crs) throws MismatchedDimensionException {
this.crs = crs;
checkCoordinateReferenceSystemDimension();
}
/**
* Creates an envelope for a region defined by maximum and minimum values.
*
* @param x1 The first x-value.
* @param x2 The second x-value.
* @param y1 The first y-value.
* @param y2 The second y-value.
* @param crs The coordinate reference system.
* @throws MismatchedDimensionException if the CRS dimension is not valid.
*/
public ReferencedEnvelope(
final double x1,
final double x2,
final double y1,
final double y2,
final CoordinateReferenceSystem crs)
throws MismatchedDimensionException {
super(x1, x2, y1, y2);
this.crs = crs;
checkCoordinateReferenceSystemDimension();
}
/**
* Creates an envelope for a Java2D rectangle.
*
* NOTE: if the rectangle is empty, the resulting ReferencedEnvelope will not be. In case
* this is needed use {@link #create(Rectangle2D, CoordinateReferenceSystem)
* ReferencedEnvelope.create(rectangle, crs)}
*
* @param rectangle The rectangle.
* @param crs The coordinate reference system.
* @throws MismatchedDimensionException if the CRS dimension is not valid.
* @since 2.4
*/
public ReferencedEnvelope(final Rectangle2D rectangle, final CoordinateReferenceSystem crs)
throws MismatchedDimensionException {
this(
rectangle.getMinX(),
rectangle.getMaxX(),
rectangle.getMinY(),
rectangle.getMaxY(),
crs);
}
/**
* Creates a new envelope from an existing envelope.
*
* @param envelope The envelope to initialize from
* @throws MismatchedDimensionException if the CRS dimension is not valid.
* @since 2.3
*/
public ReferencedEnvelope(final ReferencedEnvelope envelope)
throws MismatchedDimensionException {
super(envelope);
crs = envelope.getCoordinateReferenceSystem();
checkCoordinateReferenceSystemDimension();
}
/**
* Creates a new envelope from an existing bounding box.
*
*
NOTE: if the bounding box is empty, the resulting ReferencedEnvelope will not be. In case
* this is needed use {@link #create(org.opengis.geometry.Envelope, CoordinateReferenceSystem)
* ReferencedEnvelope.create(bbox, bbox.getCoordinateReferenceSystem())}
*
* @param bbox The bounding box to initialize from.
* @throws MismatchedDimensionException if the CRS dimension is not valid.
* @since 2.4
*/
public ReferencedEnvelope(final BoundingBox bbox) throws MismatchedDimensionException {
this(
bbox.getMinX(),
bbox.getMaxX(),
bbox.getMinY(),
bbox.getMaxY(),
bbox.getCoordinateReferenceSystem());
}
/**
* Creates a new envelope from an existing OGC envelope.
*
*
NOTE: if the envelope is empty, the resulting ReferencedEnvelope will not be. In case this
* is needed use {@link #create(org.opengis.geometry.Envelope, CoordinateReferenceSystem)
* ReferencedEnvelope.create(envelope, envelope.getCoordinateReferenceSystem())}
*
* @param envelope The envelope to initialize from.
* @throws MismatchedDimensionException if the CRS dimension is not valid.
* @since 2.4
*/
public ReferencedEnvelope(final org.opengis.geometry.Envelope envelope)
throws MismatchedDimensionException {
super(
envelope.getMinimum(0),
envelope.getMaximum(0),
envelope.getMinimum(1),
envelope.getMaximum(1));
this.crs = envelope.getCoordinateReferenceSystem();
checkCoordinateReferenceSystemDimension();
}
/**
* Creates a new envelope from an existing JTS envelope.
*
* @param envelope The envelope to initialize from.
* @param crs The coordinate reference system.
* @throws MismatchedDimensionExceptionif the CRS dimension is not valid.
*/
public ReferencedEnvelope(final Envelope envelope, final CoordinateReferenceSystem crs)
throws MismatchedDimensionException {
super(envelope);
this.crs = crs;
checkCoordinateReferenceSystemDimension();
}
/** Sets this envelope to the specified bounding box. */
public void init(BoundingBox bounds) {
super.init(
bounds.getMinimum(0),
bounds.getMaximum(0),
bounds.getMinimum(1),
bounds.getMaximum(1));
this.crs = bounds.getCoordinateReferenceSystem();
}
/** Returns the specified bounding box as a JTS envelope. */
private static Envelope getJTSEnvelope(final BoundingBox bbox) {
if (bbox == null) {
throw new NullPointerException("Provided bbox envelope was null");
}
if (bbox instanceof Envelope) {
return (Envelope) bbox;
}
// safe creation if empty bounds
return ReferencedEnvelope.create(bbox, bbox.getCoordinateReferenceSystem());
}
/**
* Convenience method for checking coordinate reference system validity.
*
* @throws IllegalArgumentException if the CRS dimension is not valid.
*/
protected void checkCoordinateReferenceSystemDimension() throws MismatchedDimensionException {
if (crs != null) {
final int expected = getDimension();
final int dimension = crs.getCoordinateSystem().getDimension();
if (dimension > expected) {
// check dimensions and choose ReferencedEnvelope or ReferencedEnvelope3D
// or the factory method ReferencedEnvelope.reference( CoordinateReferenceSystem )
throw new MismatchedDimensionException(
Errors.format(
ErrorKeys.MISMATCHED_DIMENSION_$3,
crs.getName().getCode(),
Integer.valueOf(dimension),
Integer.valueOf(expected)));
}
}
}
/**
* Make sure that the specified bounding box uses the same CRS than this one.
*
* @param bbox The other bounding box to test for compatibility.
* @throws MismatchedReferenceSystemException if the CRS are incompatible.
*/
protected void ensureCompatibleReferenceSystem(final BoundingBox bbox)
throws MismatchedReferenceSystemException {
if (crs != null) {
final CoordinateReferenceSystem other = bbox.getCoordinateReferenceSystem();
if (other != null) {
if (!CRS.equalsIgnoreMetadata(crs, other)) {
throw new MismatchedReferenceSystemException(
Errors.format(ErrorKeys.MISMATCHED_COORDINATE_REFERENCE_SYSTEM));
}
}
}
}
/**
* Make sure that the specified location uses the same CRS as this one.
*
* @throws MismatchedReferenceSystemException if the CRS are incompatible.
*/
protected void ensureCompatibleReferenceSystem(DirectPosition location) {
if (crs != null) {
final CoordinateReferenceSystem other = location.getCoordinateReferenceSystem();
if (other != null) {
if (!CRS.equalsIgnoreMetadata(crs, other)) {
throw new MismatchedReferenceSystemException(
Errors.format(ErrorKeys.MISMATCHED_COORDINATE_REFERENCE_SYSTEM));
}
}
}
}
/** Returns the coordinate reference system associated with this envelope. */
public CoordinateReferenceSystem getCoordinateReferenceSystem() {
return crs;
}
/** Returns the number of dimensions. */
public int getDimension() {
return 2;
}
/** Returns the minimal ordinate along the specified dimension. */
public double getMinimum(final int dimension) {
switch (dimension) {
case 0:
return getMinX();
case 1:
return getMinY();
default:
throw new IndexOutOfBoundsException(String.valueOf(dimension));
}
}
/** Returns the maximal ordinate along the specified dimension. */
public double getMaximum(final int dimension) {
switch (dimension) {
case 0:
return getMaxX();
case 1:
return getMaxY();
default:
throw new IndexOutOfBoundsException(String.valueOf(dimension));
}
}
/** Returns the center ordinate along the specified dimension. */
public double getMedian(final int dimension) {
switch (dimension) {
case 0:
return 0.5 * (getMinX() + getMaxX());
case 1:
return 0.5 * (getMinY() + getMaxY());
default:
throw new IndexOutOfBoundsException(String.valueOf(dimension));
}
}
/**
* Returns the envelope length along the specified dimension. This length is equals to the
* maximum ordinate minus the minimal ordinate.
*/
public double getSpan(final int dimension) {
switch (dimension) {
case 0:
return getWidth();
case 1:
return getHeight();
default:
throw new IndexOutOfBoundsException(String.valueOf(dimension));
}
}
/**
* A coordinate position consisting of all the minimal ordinates for each dimension for all
* points within the {@code Envelope}.
*/
public DirectPosition getLowerCorner() {
return new DirectPosition2D(crs, getMinX(), getMinY());
}
/**
* A coordinate position consisting of all the maximal ordinates for each dimension for all
* points within the {@code Envelope}.
*/
public DirectPosition getUpperCorner() {
return new DirectPosition2D(crs, getMaxX(), getMaxY());
}
/**
* Returns {@code true} if lengths along all dimension are zero.
*
* @since 2.4
*/
public boolean isEmpty() {
return super.isNull();
}
/**
* Returns {@code true} if the provided location is contained by this bounding box.
*
* @since 2.4
*/
public boolean contains(DirectPosition pos) {
ensureCompatibleReferenceSystem(pos);
return super.contains(pos.getOrdinate(0), pos.getOrdinate(1));
}
/**
* Returns {@code true} if the provided bounds are contained by this bounding box.
*
* @since 2.4
*/
public boolean contains(final BoundingBox bbox) {
ensureCompatibleReferenceSystem(bbox);
return super.contains(getJTSEnvelope(bbox));
}
/**
* Check if this bounding box intersects the provided bounds.
*
* @since 2.4
*/
public boolean intersects(final BoundingBox bbox) {
ensureCompatibleReferenceSystem(bbox);
return super.intersects(getJTSEnvelope(bbox));
}
/** Check if this bounding box intersects the provided bounds. */
@Override
public ReferencedEnvelope intersection(Envelope env) {
if (env instanceof BoundingBox) {
BoundingBox bbox = (BoundingBox) env;
ensureCompatibleReferenceSystem(bbox);
}
return new ReferencedEnvelope(super.intersection(env), this.getCoordinateReferenceSystem());
}
/**
* Include the provided bounding box, expanding as necessary.
*
* @since 2.4
*/
public void include(final BoundingBox bbox) {
if (crs == null) {
this.crs = bbox.getCoordinateReferenceSystem();
} else {
ensureCompatibleReferenceSystem(bbox);
}
expandToInclude(ReferencedEnvelope.reference(bbox));
}
/** Expand to include the provided DirectPosition */
public void expandToInclude(DirectPosition pt) {
Coordinate coordinate = new Coordinate(pt.getOrdinate(0), pt.getOrdinate(1));
expandToInclude(coordinate);
}
/** Include the provided envelope, expanding as necessary. */
@Override
public void expandToInclude(Envelope other) {
if (other instanceof BoundingBox) {
if (other.isNull()) {
return;
}
BoundingBox bbox = (BoundingBox) other;
ensureCompatibleReferenceSystem(bbox);
expandToInclude(bbox.getLowerCorner());
expandToInclude(bbox.getUpperCorner());
} else {
super.expandToInclude(other);
}
}
/**
* Include the provided coordinates, expanding as necessary.
*
* @since 2.4
*/
public void include(double x, double y) {
super.expandToInclude(x, y);
}
/**
* Initialize the bounding box with another bounding box.
*
* @since 2.4
*/
public void setBounds(final BoundingBox bbox) {
ensureCompatibleReferenceSystem(bbox);
super.init(getJTSEnvelope(bbox));
}
/**
* Returns a new bounding box which contains the transformed shape of this bounding box. This is
* a convenience method that delegate its work to the {@link #transform transform} method.
*
* @since 2.4
*/
public BoundingBox toBounds(final CoordinateReferenceSystem targetCRS)
throws TransformException {
try {
return transform(targetCRS, true);
} catch (FactoryException e) {
throw new TransformException(e.getLocalizedMessage(), e);
}
}
/**
* Transforms the referenced envelope to the specified coordinate reference system.
*
*
This method can handle the case where the envelope contains the North or South pole, or
* when it cross the ±180� longitude.
*
* @param targetCRS The target coordinate reference system.
* @param lenient {@code true} if datum shift should be applied even if there is insuffisient
* information. Otherwise (if {@code false}), an exception is thrown in such case.
* @return The transformed envelope.
* @throws FactoryException if the math transform can't be determined.
* @throws TransformException if at least one coordinate can't be transformed.
* @see CRS#transform(CoordinateOperation, org.opengis.geometry.Envelope)
*/
public ReferencedEnvelope transform(CoordinateReferenceSystem targetCRS, boolean lenient)
throws TransformException, FactoryException {
return transform(targetCRS, lenient, 5);
}
/**
* Transforms the referenced envelope to the specified coordinate reference system using the
* specified amount of points.
*
*
This method can handle the case where the envelope contains the North or South pole, or
* when it cross the ±180� longitude.
*
* @param targetCRS The target coordinate reference system.
* @param lenient {@code true} if datum shift should be applied even if there is insuffisient
* information. Otherwise (if {@code false}), an exception is thrown in such case.
* @param numPointsForTransformation The number of points to use for sampling the envelope.
* @return The transformed envelope.
* @throws FactoryException if the math transform can't be determined.
* @throws TransformException if at least one coordinate can't be transformed.
* @see CRS#transform(CoordinateOperation, org.opengis.geometry.Envelope)
* @since 2.3
*/
public ReferencedEnvelope transform(
final CoordinateReferenceSystem targetCRS,
final boolean lenient,
final int numPointsForTransformation)
throws TransformException, FactoryException {
if (crs == null) {
if (isEmpty()) {
// We don't have a CRS yet because we are still empty, being empty is
// something we can represent in the targetCRS
return new ReferencedEnvelope(targetCRS);
} else {
// really this is a the code that created this ReferencedEnvelope
throw new NullPointerException(
"Unable to transform referenced envelope, crs has not yet been provided.");
}
}
if (getDimension() != targetCRS.getCoordinateSystem().getDimension()) {
if (lenient) {
return JTS.transformTo3D(this, targetCRS, lenient, numPointsForTransformation);
} else {
throw new MismatchedDimensionException(
Errors.format(
ErrorKeys.MISMATCHED_DIMENSION_$3,
crs.getName().getCode(),
Integer.valueOf(getDimension()),
Integer.valueOf(targetCRS.getCoordinateSystem().getDimension())));
}
}
/*
* Gets a first estimation using an algorithm capable to take singularity in account
* (North pole, South pole, 180� longitude). We will expand this initial box later.
*/
CoordinateOperationFactory coordinateOperationFactory =
CRS.getCoordinateOperationFactory(lenient);
final CoordinateOperation operation =
coordinateOperationFactory.createOperation(crs, targetCRS);
final GeneralEnvelope transformed = CRS.transform(operation, this);
transformed.setCoordinateReferenceSystem(targetCRS);
/*
* Now expands the box using the usual utility methods.
*/
final ReferencedEnvelope target = new ReferencedEnvelope(transformed);
final MathTransform transform = operation.getMathTransform();
JTS.transform(this, target, transform, numPointsForTransformation);
return target;
}
/**
* Returns a hash value for this envelope. This value need not remain consistent between
* different implementations of the same class.
*/
@Override
public int hashCode() {
int code = super.hashCode() ^ (int) serialVersionUID;
if (crs != null) {
code ^= crs.hashCode();
}
return code;
}
/** Compares the specified object with this envelope for equality. */
@Override
public boolean equals(final Object object) {
if (super.equals(object)) {
final CoordinateReferenceSystem otherCRS =
(object instanceof ReferencedEnvelope)
? ((ReferencedEnvelope) object).crs
: null;
return CRS.equalsIgnoreMetadata(crs, otherCRS);
}
return false;
}
/**
* Compare the bounds of this envelope with those of another.
*
*
Note: in this test:
*
*
* - the coordinate reference systems of the envelopes are not examined
*
- only the first two dimensions of the envelopes are compared
*
- it is assumed that each dimension equates to the same axis for both envelopes
*
*
* @param other other envelope
* @param eps a small tolerance factor (e.g. 1.0e-6d) which will be scaled relative to this
* envlope's width and height
* @return true if all bounding coordinates are equal within the set tolerance; false otherwise
*/
public boolean boundsEquals2D(final org.opengis.geometry.Envelope other, double eps) {
eps *= 0.5 * (getWidth() + getHeight());
double[] delta = new double[4];
delta[0] = getMinimum(0) - other.getMinimum(0);
delta[1] = getMaximum(0) - other.getMaximum(0);
delta[2] = getMinimum(1) - other.getMinimum(1);
delta[3] = getMaximum(1) - other.getMaximum(1);
for (int i = 0; i < delta.length; i++) {
/*
* As per Envelope2D#boundsEquals we use ! here to
* catch any NaN values
*/
if (!(Math.abs(delta[i]) <= eps)) {
return false;
}
}
return true;
}
/**
* Returns a string representation of this envelope. The default implementation is okay for
* occasional formatting (for example for debugging purpose).
*/
@Override
public String toString() {
final StringBuilder buffer = new StringBuilder(Classes.getShortClassName(this)).append('[');
final int dimension = getDimension();
for (int i = 0; i < dimension; i++) {
if (i != 0) {
buffer.append(", ");
}
buffer.append(getMinimum(i)).append(" : ").append(getMaximum(i));
}
return buffer.append(']').toString();
}
/**
* Factory method to create the correct ReferencedEnvelope.
*
* @param original ReferencedEnvelope being duplicated
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d
*/
public static ReferencedEnvelope create(ReferencedEnvelope original) {
if (original instanceof ReferencedEnvelope3D) {
return new ReferencedEnvelope3D((ReferencedEnvelope3D) original);
}
return new ReferencedEnvelope(original);
}
/**
* Factory method to create the correct ReferencedEnvelope implementation for the provided
* CoordinateReferenceSystem.
*
* @param crs CoordinateReferenceSystem used to select ReferencedEnvelope implementation
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d
*/
public static ReferencedEnvelope create(CoordinateReferenceSystem crs) {
if (crs != null && crs.getCoordinateSystem().getDimension() > 2) {
return new ReferencedEnvelope3D(crs);
}
return new ReferencedEnvelope(crs);
}
/**
* Utility method to create a ReferencedEnvelope from an opengis Envelope class, supporting 2d
* as well as 3d envelopes (returning the right class).
*
* @param env The opgenis Envelope object
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d,
* results in a null/an empty envelope, if input envelope was a null/an empty envelope
* @see {@link #reference(org.opengis.geometry.Envelope)}
*/
public static ReferencedEnvelope create(
org.opengis.geometry.Envelope env, CoordinateReferenceSystem crs) {
if (env == null) {
return null;
}
if (env.getDimension() >= 3) {
// emptiness test is inside reference-method
return new ReferencedEnvelope3D((ReferencedEnvelope3D) reference(env), crs);
}
return new ReferencedEnvelope(reference(env), crs);
}
/**
* Utility method to create a ReferencedEnvelope from an opengis Envelope class, supporting 2d
* as well as 3d envelopes (returning the right class).
*
* @param env The opgenis Envelope object
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d
*/
public static ReferencedEnvelope create(ReferencedEnvelope env, CoordinateReferenceSystem crs) {
return create((org.opengis.geometry.Envelope) env, crs);
}
/**
* Utility method to create a ReferencedEnvelope from an JTS Envelope class, supporting 2d as
* well as 3d envelopes (returning the right class).
*
* @param env The JTS Envelope object
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d,
* results in a null/an empty envelope, if input envelope was a null/an empty envelope
*/
public static ReferencedEnvelope create(Envelope env, CoordinateReferenceSystem crs) {
if (env == null) {
return null;
}
if (crs != null && crs.getCoordinateSystem().getDimension() >= 3) {
if (env.isNull()) {
return new ReferencedEnvelope3D(crs);
} else {
return new ReferencedEnvelope3D(
env.getMinX(),
env.getMaxX(),
env.getMinY(),
env.getMaxY(),
Double.NaN,
Double.NaN,
crs);
}
}
if (env.isNull()) {
return new ReferencedEnvelope(crs);
} else {
return new ReferencedEnvelope(env, crs);
}
}
/**
* Cast to a ReferencedEnvelope (used to ensure that an Envelope is a ReferencedEnvelope).
*
* This method first checks if e is an instanceof {@link ReferencedEnvelope}, if it
* is, itself is returned. If not new ReferencedEnvelpe(e,null) is returned.
*
*
If e is null, null is returned.
*
* @param e The envelope. Can be null.
* @return A ReferencedEnvelope using the specified envelope, or null if the envelope was null.
*/
public static ReferencedEnvelope reference(Envelope e) {
if (e == null) {
return null;
} else {
if (e instanceof ReferencedEnvelope3D) {
return (ReferencedEnvelope3D) e;
}
if (e instanceof ReferencedEnvelope) {
return (ReferencedEnvelope) e;
}
return new ReferencedEnvelope(e, null);
}
}
/**
* Utility method to ensure that an BoundingBox in a ReferencedEnvelope.
*
*
This method first checks if e is an instanceof {@link ReferencedEnvelope}, if it
* is, itself is returned. If not new ReferencedEnvelpe(e) is returned.
*
* @param e The envelope.
*/
public static ReferencedEnvelope reference(ReferencedEnvelope e) {
return reference((org.opengis.geometry.Envelope) e);
}
/**
* Cast to a ReferencedEnvelope (used to ensure that an Envelope if a ReferencedEnvelope).
* Supporting 2d as well as 3d envelopes (returning the right class).
*
* @param env The opgenis Envelope object
* @return ReferencedEnvelope, ReferencedEnvelope3D if it is 3d,
* results in a null/an empty envelope, if input envelope was a null/an empty envelope (by
* JTS Envelope definition: getMaximum(0) < getMinimum(0))
*/
public static ReferencedEnvelope reference(org.opengis.geometry.Envelope env) {
if (env == null) {
return null;
}
if (env instanceof ReferencedEnvelope3D) {
return (ReferencedEnvelope3D) env;
}
if (env instanceof ReferencedEnvelope) {
return (ReferencedEnvelope) env;
}
if (env.getDimension() >= 3) {
// emptiness test according to org.locationtech.jts.geom.Envelope
if (env.getMaximum(0) < env.getMinimum(0)) {
return new ReferencedEnvelope3D(env.getCoordinateReferenceSystem());
} else {
return new ReferencedEnvelope3D(env);
}
}
// emptiness test according to org.locationtech.jts.geom.Envelope
if (env.getMaximum(0) < env.getMinimum(0))
return new ReferencedEnvelope(env.getCoordinateReferenceSystem());
return new ReferencedEnvelope(env);
}
/**
* Utility method to create a ReferencedEnvelope from a Java2D Rectangle class, supporting empty
* rectangles.
*
* @param rectangle The Java2D Rectangle object
* @return ReferencedEnvelope,
* results in a null/an empty envelope, if input rectangle was empty
*/
public static ReferencedEnvelope create(Rectangle2D rectangle, CoordinateReferenceSystem crs) {
if (rectangle.isEmpty()) {
return new ReferencedEnvelope(crs);
} else {
return new ReferencedEnvelope(rectangle, crs);
}
}
}