AbstractPoint (RS Core TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.jts.geom.impl.AbstractGeometry
- - com.revolsys.jts.geom.impl.AbstractPoint

All Implemented Interfaces:

DataTypeProxy, Geometry, Point, Puntal, Serializable, Cloneable, Comparable<Object>

Direct Known Subclasses:

AbstractVertex, Node, PointDouble, PointDouble2D, PreparedPoint
```
public abstract class AbstractPoint
extends AbstractGeometry
implements Point
```
Represents a single point. A Point is topologically valid if and only if:
- the coordinate which defines it (if any) is a valid coordinate (i.e does not have an NaN X or Y ordinate)
Version:

1.7

See Also:
Serialized Form

Field Summary
- Fields inherited from interface com.revolsys.jts.geom.Point
  NULL_ORDINATE, X, Y, Z
- Fields inherited from interface com.revolsys.jts.geom.Geometry
  M, sortedGeometryTypes

Constructor Summary

Constructors
Constructor and Description

AbstractPoint()

Constructors
Constructor and Description
`AbstractPoint()`

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`angle2d(Point other)` Calculate the counter clockwise angle in radians of the vector from this point to another point.
`<V extends Geometry> V`	`appendVertex(Point newPoint, int... geometryId)`
`AbstractPoint`	`clone()` Creates and returns a full copy of this `Point` object.
`Point`	`clonePoint()`
`int`	`compareTo(Object other)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`.
`int`	`compareToSameClass(Geometry other)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.
`protected BoundingBox`	`computeBoundingBox()` Returns the minimum and maximum x and y values in this `Geometry` , or a null `BoundingBoxDoubleGf` if this `Geometry` is empty.
`<V extends Geometry> V`	`copy(GeometryFactory geometryFactory)` Create a copy of the geometry io the requried geometry factory.
`void`	`copyCoordinates(GeometryFactory geometryFactory, double[] coordinates)` Copy the coordinates in this point to the coordinates array parameter and convert them to the geometry factory.
`<V extends Geometry> V`	`deleteVertex(int... vertexId)`
`double`	`distance(double x, double y)`
`double`	`distance(Point point)` Computes the 2-dimensional Euclidean distance to another location.
`double`	`distance3d(Point c)` Computes the 3-dimensional Euclidean distance to another location.
`boolean`	`doEquals(int axisCount, Geometry geometry)`
`boolean`	`equals(double... coordinates)`
`boolean`	`equals(Object other)` Tests whether this geometry is structurally and numerically equal to a given `Object`.
`boolean`	`equals(Point point)`
`boolean`	`equals2d(Point c, double tolerance)` Tests if another coordinate has the same values for the X and Y ordinates.
`boolean`	`equalsExact(Geometry other, double tolerance)` Returns true if the two `Geometry`s are exactly equal, up to a specified distance tolerance.
`Geometry`	`getBoundary()` Gets the boundary of this geometry.
`int`	`getBoundaryDimension()` Returns the dimension of this `Geometry`s inherent boundary.
`double[]`	`getCoordinates()`
`DataType`	`getDataType()`
`int`	`getDimension()` Returns the dimension of this geometry.
`GeometryFactory`	`getGeometryFactory()` Gets the geometryFactory which contains the context in which this geometry was created.
`double`	`getM()`
`Point`	`getPoint()` Returns a vertex of this `Geometry` (usually, but not necessarily, the first one).
`Point`	`getPointWithin()`
`Segment`	`getSegment(int... segmentId)` Get the `Segment` at the specified vertexId (see `Segment.getSegmentId()`).
`long`	`getTime()`
`Vertex`	`getToVertex(int... vertexId)` Get the `Vertex` at the specified vertexId starting at the end of the geometry (see `Vertex.getVertexId()`).
`Vertex`	`getVertex(int... vertexId)` Get the `Vertex` at the specified vertexId (see `Vertex.getVertexId()`).
`int`	`getVertexCount()` Returns the count of this `Geometry`s vertices.
`double`	`getX()`
`double`	`getY()`
`double`	`getZ()`
`int`	`hashCode()` Gets a hash code for the Geometry.
`<V extends Geometry> V`	`insertVertex(Point newPoint, int... vertexId)`
`boolean`	`intersects(BoundingBox boundingBox)`
`boolean`	`isEmpty()` Tests whether the set of points covered by this `Geometry` is empty.
`protected boolean`	`isEquivalentClass(Geometry other)` Returns whether the two `Geometry`s are equal, from the point of view of the `equalsExact` method.
`boolean`	`isSimple()` Tests whether this `Geometry` is simple.
`boolean`	`isValid()` Tests whether this `Geometry` is topologically valid, according to the OGC SFS specification.
`Point`	`move(double... deltas)`
`<V extends Geometry> V`	`moveVertex(Point newPoint, int... vertexId)`
`Point`	`normalize()` Converts this `Geometry` to normal form (or canonical form ).
`Point`	`prepare()`
`Geometry`	`reverse()` Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.
`Reader<Segment>`	`segments()`
`Reader<Vertex>`	`vertices()` Get an `Iterable` that iterates over the `Vertex` of the geometry.

Methods inherited from class com.revolsys.jts.geom.impl.AbstractGeometry
buffer, buffer, buffer, checkNotGeometryCollection, compare, contains, containsProperly, convert, convert, convexHull, coveredBy, covers, createVertexId, crosses, difference, disjoint, distance, envelopeCovers, envelopesIntersect, equal, equals, equals, equalsExact, equalsNorm, equalsTopo, geometries, getArea, getAxisCount, getBoundingBox, getCentroid, getClassSortIndex, getCoordinateSystem, getEnvelope, getGeometries, getGeometries, getGeometry, getGeometryComponents, getGeometryCount, getGeometryType, getInteriorPoint, getLength, getNonZeroGeometryFactory, getSrid, getUserData, getVertexIndex, hasInvalidXyCoordinates, hasNonEmptyElements, hasNullElements, intersection, intersects, isAnyTargetComponentInTest, isGeometryCollection, isRectangle, isWithinDistance, overlaps, relate, relate, setUserData, setVertexIndex, symDifference, toClockwise, toCounterClockwise, toString, touches, toWkt, union, union, within

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

Methods inherited from interface com.revolsys.jts.geom.Point
getCoordinate

Methods inherited from interface com.revolsys.jts.geom.Geometry
buffer, buffer, buffer, contains, containsProperly, convert, convert, convexHull, coveredBy, covers, crosses, difference, disjoint, distance, equal, equals, equals, equalsExact, equalsNorm, equalsTopo, geometries, getArea, getAxisCount, getBoundingBox, getCentroid, getClassSortIndex, getCoordinateSystem, getEnvelope, getGeometries, getGeometries, getGeometry, getGeometryComponents, getGeometryCount, getGeometryType, getInteriorPoint, getLength, getSrid, getUserData, hasInvalidXyCoordinates, intersection, intersects, isRectangle, isWithinDistance, overlaps, relate, relate, setUserData, symDifference, toClockwise, toCounterClockwise, touches, toWkt, union, union, within

- Constructor Detail
  - AbstractPoint
```
public AbstractPoint()
```
- Method Detail
  - angle2d
```
public double angle2d(Point other)
```
    Description copied from interface: Point
    
    Calculate the counter clockwise angle in radians of the vector from this point to another point. The angle is relative to the positive x-axis relative to the positive X-axis. The angle will be in the range -PI -> PI where negative values have a clockwise orientation.
    
    Specified by:
    
    angle2d in interface Point
    
    Returns:
    The angle in radians.
  - appendVertex
```
public <V extends Geometry> V appendVertex(Point newPoint,
                                  int... geometryId)
```
    Specified by:
    
    appendVertex in interface Geometry
  - clone
```
public AbstractPoint clone()
```
    Creates and returns a full copy of this Point object. (including all coordinates contained by it).
    
    Specified by:
    
    clone in interface Geometry
    
    Specified by:
    
    clone in interface Point
    
    Overrides:
    
    clone in class AbstractGeometry
    
    Returns:
    a clone of this instance
  - clonePoint
```
public Point clonePoint()
```
    Specified by:
    
    clonePoint in interface Point
  - compareTo
```
public int compareTo(Object other)
```
    Description copied from class: AbstractGeometry
    Returns whether this Geometry is greater than, equal to, or less than another Geometry.
    If their classes are different, they are compared using the following ordering:
    - Point (lowest)
    - MultiPoint
    - LineString
    - LinearRing
    - MultiLineString
    - Polygon
    - MultiPolygon
    - GeometryCollection (highest)
    If the two Geometrys have the same class, their first elements are compared. If those are the same, the second elements are compared, etc.
    Specified by:
    
    compareTo in interface Geometry
    
    Specified by:
    
    compareTo in interface Point
    
    Specified by:
    
    compareTo in interface Comparable<Object>
    
    Overrides:
    
    compareTo in class AbstractGeometry
    
    Parameters:
    other - a Geometry with which to compare this Geometry
    
    Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than o, as defined in "Normal Form For Geometry" in the JTS Technical Specifications
  - compareToSameClass
```
public int compareToSameClass(Geometry other)
```
    Description copied from class: AbstractGeometry
    
    Returns whether this Geometry is greater than, equal to, or less than another Geometry having the same class.
    
    Specified by:
    
    compareToSameClass in interface Geometry
    
    Specified by:
    
    compareToSameClass in class AbstractGeometry
    
    Parameters:
    other - a Geometry having the same class as this Geometry
    
    Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than o, as defined in "Normal Form For Geometry" in the JTS Technical Specifications
  - computeBoundingBox
```
protected BoundingBox computeBoundingBox()
```
    Description copied from class: AbstractGeometry
    
    Returns the minimum and maximum x and y values in this Geometry , or a null BoundingBoxDoubleGf if this Geometry is empty. Unlike getEnvelopeInternal, this method calculates the BoundingBoxDoubleGf each time it is called; getEnvelopeInternal caches the result of this method.
    
    Specified by:
    
    computeBoundingBox in class AbstractGeometry
    
    Returns:
    this Geometrys bounding box; if the Geometry is empty, BoundingBoxDoubleGf#isNull will return true
  - copy
```
public <V extends Geometry> V copy(GeometryFactory geometryFactory)
```
    Description copied from interface: Geometry
    
    Create a copy of the geometry io the requried geometry factory. Projecting to the required coordinate system and applying the precision model.
    
    Specified by:
    
    copy in interface Geometry
    
    Parameters:
    geometryFactory - The geometry factory to convert the geometry to.
    
    Returns:
    The converted geometry
  - copyCoordinates
```
public void copyCoordinates(GeometryFactory geometryFactory,
                   double[] coordinates)
```
    Copy the coordinates in this point to the coordinates array parameter and convert them to the geometry factory.
    
    Specified by:
    
    copyCoordinates in interface Point
    
    Parameters:
    geometryFactory -
    coordinates -
  - deleteVertex
```
public <V extends Geometry> V deleteVertex(int... vertexId)
```
    Specified by:
    
    deleteVertex in interface Geometry
  - distance
```
public double distance(double x,
              double y)
```
    Specified by:
    
    distance in interface Point
  - distance
```
public double distance(Point point)
```
    Description copied from interface: Point
    
    Computes the 2-dimensional Euclidean distance to another location. The Z-ordinate is ignored.
    
    Specified by:
    
    distance in interface Point
    
    Returns:
    the 2-dimensional Euclidean distance between the locations
  - distance3d
```
public double distance3d(Point c)
```
    Computes the 3-dimensional Euclidean distance to another location.
    
    Specified by:
    
    distance3d in interface Point
    
    Parameters:
    c - a coordinate
    
    Returns:
    the 3-dimensional Euclidean distance between the locations
  - doEquals
```
public boolean doEquals(int axisCount,
               Geometry geometry)
```
    Specified by:
    
    doEquals in class AbstractGeometry
  - equals
```
public boolean equals(double... coordinates)
```
    Specified by:
    
    equals in interface Point
  - equals
```
public boolean equals(Object other)
```
    Description copied from class: AbstractGeometry
    
    Tests whether this geometry is structurally and numerically equal to a given Object. If the argument Object is not a Geometry, the result is false. Otherwise, the result is computed using AbstractGeometry.equals(2,Geometry).
    This method is provided to fulfill the Java contract for value-based object equality. In conjunction with AbstractGeometry.hashCode() it provides semantics which are most useful for using Geometrys as keys and values in Java collections.
    Note that to produce the expected result the input geometries should be in normal form. It is the caller's responsibility to perform this where required (using Geometry#norm() or {@link #normalize()} as appropriate).
    
    Specified by:
    
    equals in interface Geometry
    
    Overrides:
    
    equals in class AbstractGeometry
    
    Parameters:
    other - the Object to compare
    
    Returns:
    true if this geometry is exactly equal to the argument
    See Also:
    AbstractGeometry.equals(2,Geometry), AbstractGeometry.hashCode(), #norm(), AbstractGeometry.normalize()
  - equals
```
public boolean equals(Point point)
```
    Specified by:
    
    equals in interface Point
  - equals2d
```
public boolean equals2d(Point c,
               double tolerance)
```
    Tests if another coordinate has the same values for the X and Y ordinates. The Z ordinate is ignored.
    
    Specified by:
    
    equals2d in interface Point
    
    Parameters:
    other - a Coordinate with which to do the 2D comparison.
    
    Returns:
    true if other is a Coordinate with the same values for X and Y.
  - equalsExact
```
public boolean equalsExact(Geometry other,
                  double tolerance)
```
    Description copied from class: AbstractGeometry
    Returns true if the two Geometrys are exactly equal, up to a specified distance tolerance. Two Geometries are exactly equal within a distance tolerance if and only if:
    - they have the same structure
    - they have the same values for their vertices, within the given tolerance distance, in exactly the same order.
    This method does not test the values of the GeometryFactory, the SRID, or the userData fields.
    To properly test equality between different geometries, it is usually necessary to AbstractGeometry.normalize() them first.
    Specified by:
    
    equalsExact in interface Geometry
    
    Specified by:
    
    equalsExact in class AbstractGeometry
    
    Parameters:
    other - the Geometry with which to compare this Geometry
    tolerance - distance at or below which two Coordinates are considered equal
    
    Returns:
    true if this and the other Geometry have identical structure and point values, up to the distance tolerance.
    See Also:
    AbstractGeometry.equals(2,Geometry), AbstractGeometry.normalize(), #norm()
  - getBoundary
```
public Geometry getBoundary()
```
    Gets the boundary of this geometry. Zero-dimensional geometries have no boundary by definition, so an empty GeometryCollection is returned.
    
    Specified by:
    
    getBoundary in interface Geometry
    
    Specified by:
    
    getBoundary in class AbstractGeometry
    
    Returns:
    an empty GeometryCollection
    See Also:
    Geometry.getBoundary()
  - getBoundaryDimension
```
public int getBoundaryDimension()
```
    Description copied from class: AbstractGeometry
    
    Returns the dimension of this Geometrys inherent boundary.
    
    Specified by:
    
    getBoundaryDimension in interface Geometry
    
    Specified by:
    
    getBoundaryDimension in class AbstractGeometry
    
    Returns:
    the dimension of the boundary of the class implementing this interface, whether or not this object is the empty geometry. Returns Dimension.FALSE if the boundary is the empty geometry.
  - getCoordinates
```
public double[] getCoordinates()
```
    Specified by:
    
    getCoordinates in interface Point
  - getDataType
```
public DataType getDataType()
```
    Specified by:
    
    getDataType in interface DataTypeProxy
    
    Overrides:
    
    getDataType in class AbstractGeometry
  - getDimension
```
public int getDimension()
```
    Description copied from class: AbstractGeometry
    
    Returns the dimension of this geometry. The dimension of a geometry is is the topological dimension of its embedding in the 2-D Euclidean plane. In the JTS spatial model, dimension values are in the set {0,1,2}.
    Note that this is a different concept to the dimension of the vertex Coordinatess. The geometry dimension can never be greater than the coordinate dimension. For example, a 0-dimensional geometry (e.g. a Point) may have a coordinate dimension of 3 (X,Y,Z).
    
    Specified by:
    
    getDimension in interface Geometry
    
    Specified by:
    
    getDimension in class AbstractGeometry
    
    Returns:
    the topological dimension of this geometry.
  - getGeometryFactory
```
public GeometryFactory getGeometryFactory()
```
    Description copied from interface: Geometry
    
    Gets the geometryFactory which contains the context in which this geometry was created.
    
    Specified by:
    
    getGeometryFactory in interface Geometry
    
    Overrides:
    
    getGeometryFactory in class AbstractGeometry
    
    Returns:
    the geometryFactory for this geometry
  - getM
```
public double getM()
```
    Specified by:
    
    getM in interface Point
  - getPoint
```
public Point getPoint()
```
    Description copied from class: AbstractGeometry
    
    Returns a vertex of this Geometry (usually, but not necessarily, the first one). The returned coordinate should not be assumed to be an actual Point object used in the internal representation.
    
    Specified by:
    
    getPoint in interface Geometry
    
    Specified by:
    
    getPoint in class AbstractGeometry
    
    Returns:
    a Coordinates which is a vertex of this Geometry.
  - getPointWithin
```
public Point getPointWithin()
```
    Specified by:
    
    getPointWithin in interface Geometry
  - getSegment
```
public Segment getSegment(int... segmentId)
```
    Description copied from interface: Geometry
    
    Get the Segment at the specified vertexId (see Segment.getSegmentId()).
    
    Specified by:
    
    getSegment in interface Geometry
    
    Returns:
    The vertex or null if it does not exist.
  - getTime
```
public long getTime()
```
    Specified by:
    
    getTime in interface Point
  - getToVertex
```
public Vertex getToVertex(int... vertexId)
```
    Description copied from interface: Geometry
    
    Get the Vertex at the specified vertexId starting at the end of the geometry (see Vertex.getVertexId()).
    
    Specified by:
    
    getToVertex in interface Geometry
    
    Parameters:
    vertexId - The id of the vertex.
    
    Returns:
    The vertex or null if it does not exist.
  - getVertex
```
public Vertex getVertex(int... vertexId)
```
    Description copied from interface: Geometry
    
    Get the Vertex at the specified vertexId (see Vertex.getVertexId()).
    
    Specified by:
    
    getVertex in interface Geometry
    
    Parameters:
    vertexId - The id of the vertex.
    
    Returns:
    The vertex or null if it does not exist.
  - getVertexCount
```
public int getVertexCount()
```
    Description copied from interface: Geometry
    
    Returns the count of this Geometrys vertices. The Geometry s contained by composite Geometrys must be Geometry's; that is, they must implement getNumPoints
    
    Specified by:
    
    getVertexCount in interface Geometry
    
    Returns:
    the number of vertices in this Geometry
  - getX
```
public double getX()
```
    Specified by:
    
    getX in interface Point
  - getY
```
public double getY()
```
    Specified by:
    
    getY in interface Point
  - getZ
```
public double getZ()
```
    Specified by:
    
    getZ in interface Point
  - hashCode
```
public int hashCode()
```
    Description copied from class: AbstractGeometry
    
    Gets a hash code for the Geometry.
    
    Specified by:
    
    hashCode in interface Geometry
    
    Overrides:
    
    hashCode in class AbstractGeometry
    
    Returns:
    an integer value suitable for use as a hashcode
  - insertVertex
```
public <V extends Geometry> V insertVertex(Point newPoint,
                                  int... vertexId)
```
    Specified by:
    
    insertVertex in interface Geometry
  - intersects
```
public boolean intersects(BoundingBox boundingBox)
```
    Specified by:
    
    intersects in interface Geometry
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from class: AbstractGeometry
    
    Tests whether the set of points covered by this Geometry is empty.
    
    Specified by:
    
    isEmpty in interface Geometry
    
    Specified by:
    
    isEmpty in class AbstractGeometry
    
    Returns:
    true if this Geometry does not cover any points
  - isEquivalentClass
```
protected boolean isEquivalentClass(Geometry other)
```
    Description copied from class: AbstractGeometry
    
    Returns whether the two Geometrys are equal, from the point of view of the equalsExact method. Called by equalsExact . In general, two Geometry classes are considered to be "equivalent" only if they are the same class. An exception is LineString , which is considered to be equivalent to its subclasses.
    
    Overrides:
    
    isEquivalentClass in class AbstractGeometry
    
    Parameters:
    other - the Geometry with which to compare this Geometry for equality
    
    Returns:
    true if the classes of the two Geometry s are considered to be equal by the equalsExact method.
  - isSimple
```
public boolean isSimple()
```
    Description copied from class: AbstractGeometry
    Tests whether this Geometry is simple. The SFS definition of simplicity follows the general rule that a Geometry is simple if it has no points of self-tangency, self-intersection or other anomalous points.
    Simplicity is defined for each Geometry subclass as follows:
    - Valid polygonal geometries are simple, since their rings must not self-intersect. isSimple tests for this condition and reports false if it is not met. (This is a looser test than checking for validity).
    - Linear rings have the same semantics.
    - Linear geometries are simple iff they do not self-intersect at points other than boundary points.
    - Zero-dimensional geometries (points) are simple iff they have no repeated points.
    - Empty Geometrys are always simple.
    Specified by:
    
    isSimple in interface Geometry
    
    Overrides:
    
    isSimple in class AbstractGeometry
    
    Returns:
    true if this Geometry is simple
    See Also:
    AbstractGeometry.isValid()
  - isValid
```
public boolean isValid()
```
    Description copied from class: AbstractGeometry
    
    Tests whether this Geometry is topologically valid, according to the OGC SFS specification.
    For validity rules see the Javadoc for the specific Geometry subclass.
    
    Specified by:
    
    isValid in interface Geometry
    
    Overrides:
    
    isValid in class AbstractGeometry
    
    Returns:
    true if this Geometry is valid
    See Also:
    IsValidOp
  - move
```
public Point move(double... deltas)
```
    Specified by:
    
    move in interface Geometry
    
    Specified by:
    
    move in interface Point
  - moveVertex
```
public <V extends Geometry> V moveVertex(Point newPoint,
                                int... vertexId)
```
    Specified by:
    
    moveVertex in interface Geometry
  - normalize
```
public Point normalize()
```
    Description copied from class: AbstractGeometry
    
    Converts this Geometry to normal form (or canonical form ). Normal form is a unique representation for Geometry s. It can be used to test whether two Geometrys are equal in a way that is independent of the ordering of the coordinates within them. Normal form equality is a stronger condition than topological equality, but weaker than pointwise equality. The definitions for normal form use the standard lexicographical ordering for coordinates. "Sorted in order of coordinates" means the obvious extension of this ordering to sequences of coordinates.
    
    Specified by:
    
    normalize in interface Geometry
    
    Specified by:
    
    normalize in interface Point
    
    Specified by:
    
    normalize in class AbstractGeometry
    
    Returns:
    a normalized copy of this geometry.
    See Also:
    AbstractGeometry.normalize()
  - prepare
```
public Point prepare()
```
    Specified by:
    
    prepare in interface Geometry
    
    Specified by:
    
    prepare in interface Point
  - reverse
```
public Geometry reverse()
```
    Description copied from class: AbstractGeometry
    
    Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.
    
    Specified by:
    
    reverse in interface Geometry
    
    Specified by:
    
    reverse in class AbstractGeometry
    
    Returns:
    a reversed geometry
  - segments
```
public Reader<Segment> segments()
```
    Specified by:
    
    segments in interface Geometry
  - vertices
```
public Reader<Vertex> vertices()
```
    Description copied from interface: Geometry
    
    Get an Iterable that iterates over the Vertex of the geometry. For memory efficiency the Vertex returned is the same instance for each call to next on the iterator. If the vertex is required to track the previous vertex then the Vertex.clone() method must be called to get a copy of the vertex.
    
    The Iterable.iterator() method always returns the same Iterator instance. Therefore that method should not be called more than once.
    
    Specified by:
    
    vertices in interface Geometry
    
    Returns:
    The iterator over the vertices of the geometry.

Class AbstractPoint

Field Summary

Fields inherited from interface com.revolsys.jts.geom.Point

Fields inherited from interface com.revolsys.jts.geom.Geometry

Constructor Summary

Method Summary

Methods inherited from class com.revolsys.jts.geom.impl.AbstractGeometry

Methods inherited from class java.lang.Object

Methods inherited from interface com.revolsys.jts.geom.Point

Methods inherited from interface com.revolsys.jts.geom.Geometry

Constructor Detail

AbstractPoint

Method Detail

angle2d

appendVertex

clone

clonePoint

compareTo

compareToSameClass

computeBoundingBox

copy

copyCoordinates

deleteVertex

distance

distance

distance3d

doEquals

equals

equals

equals

equals2d

equalsExact

getBoundary

getBoundaryDimension

getCoordinates

getDataType

getDimension

getGeometryFactory

getM

getPoint

getPointWithin

getSegment

getTime

getToVertex

getVertex

getVertexCount

getX

getY

getZ

hashCode

insertVertex

intersects

isEmpty

isEquivalentClass

isSimple

isValid

move

moveVertex

normalize

prepare

reverse

segments

vertices