com.hazelcast.shaded.org.locationtech.jts.geom.LinearRing Maven / Gradle / Ivy
/*
* Copyright (c) 2016 Vivid Solutions.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* and Eclipse Distribution License v. 1.0 which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v20.html
* and the Eclipse Distribution License is available at
*
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package com.hazelcast.shaded.org.locationtech.jts.geom;
/**
* Models an OGC SFS LinearRing.
* A LinearRing is a {@link LineString} which is both closed and simple.
* In other words,
* the first and last coordinate in the ring must be equal,
* and the ring must not self-intersect.
* Either orientation of the ring is allowed.
*
* A ring must have either 0 or 3 or more points.
* The first and last points must be equal (in 2D).
* If these conditions are not met, the constructors throw
* an {@link IllegalArgumentException}.
* A ring with 3 points is invalid, because it is collapsed
* and thus has a self-intersection. It is allowed to be constructed
* so that it can be represented, and repaired if needed.
*
* @version 1.7
*/
public class LinearRing extends LineString
{
/**
* The minimum number of vertices allowed in a valid non-empty ring.
* Empty rings with 0 vertices are also valid.
*/
public static final int MINIMUM_VALID_SIZE = 3;
private static final long serialVersionUID = -4261142084085851829L;
/**
* Constructs a LinearRing with the given points.
*
*@param points points forming a closed and simple linestring, or
* null or an empty array to create the empty geometry.
* This array must not contain null elements.
*
*@param precisionModel the specification of the grid of allowable points
* for this LinearRing
*@param SRID the ID of the Spatial Reference System used by this
* LinearRing
* @throws IllegalArgumentException if the ring is not closed, or has too few points
*
* @deprecated Use GeometryFactory instead
*/
public LinearRing(Coordinate points[], PrecisionModel precisionModel,
int SRID) {
this(points, new GeometryFactory(precisionModel, SRID));
validateConstruction();
}
/**
* This method is ONLY used to avoid deprecation warnings.
* @param points
* @param factory
* @throws IllegalArgumentException if the ring is not closed, or has too few points
*/
private LinearRing(Coordinate points[], GeometryFactory factory) {
this(factory.getCoordinateSequenceFactory().create(points), factory);
}
/**
* Constructs a LinearRing with the vertices
* specified by the given {@link CoordinateSequence}.
*
*@param points a sequence points forming a closed and simple linestring, or
* null to create the empty geometry.
*
* @throws IllegalArgumentException if the ring is not closed, or has too few points
*
*/
public LinearRing(CoordinateSequence points, GeometryFactory factory) {
super(points, factory);
validateConstruction();
}
private void validateConstruction() {
if (!isEmpty() && ! super.isClosed()) {
throw new IllegalArgumentException("Points of LinearRing do not form a closed linestring");
}
if (getCoordinateSequence().size() >= 1 && getCoordinateSequence().size() < MINIMUM_VALID_SIZE) {
throw new IllegalArgumentException("Invalid number of points in LinearRing (found "
+ getCoordinateSequence().size() + " - must be 0 or >= " + MINIMUM_VALID_SIZE + ")");
}
}
/**
* Returns Dimension.FALSE, since by definition LinearRings do
* not have a boundary.
*
* @return Dimension.FALSE
*/
public int getBoundaryDimension() {
return Dimension.FALSE;
}
/**
* Tests whether this ring is closed.
* Empty rings are closed by definition.
*
* @return true if this ring is closed
*/
public boolean isClosed() {
if (isEmpty()) {
// empty LinearRings are closed by definition
return true;
}
return super.isClosed();
}
public String getGeometryType() {
return Geometry.TYPENAME_LINEARRING;
}
protected int getTypeCode() {
return Geometry.TYPECODE_LINEARRING;
}
protected LinearRing copyInternal() {
return new LinearRing(points.copy(), factory);
}
public LinearRing reverse()
{
return (LinearRing) super.reverse();
}
public LinearRing reverseInternal() {
CoordinateSequence seq = points.copy();
CoordinateSequences.reverse(seq);
return getFactory().createLinearRing(seq);
}
}