## com.vividsolutions.jts.geom
Class Point

    java.lang.Object
      com.vividsolutions.jts.geom.Geometry
          com.vividsolutions.jts.geom.Point

All Implemented Interfaces:
  java.lang.Cloneable, java.lang.Comparable, Puntal, java.io.Serializable

public class Point
extends Geometry
implements Puntal

Basic implementation of `Point`.

Version:
  1.7
See Also:
  Serialized Form

Field Summary

Fields inherited from class com.vividsolutions.jts.geom.Geometry
`envelope, factory, SRID`

Constructor Summary
`Point(Coordinate coordinate, PrecisionModel precisionModel, int SRID)` Deprecated. Use GeometryFactory instead
`Point(CoordinateSequence coordinates, GeometryFactory factory)`

Method Summary
`void` `apply(CoordinateFilter filter)` Performs an operation with or on this `Geometry`'s coordinates.
`void` `apply(CoordinateSequenceFilter filter)` Performs an operation on the coordinates in this `Geometry`'s `CoordinateSequence`s.
`void` `apply(GeometryComponentFilter filter)` Performs an operation with or on this Geometry and its component Geometry's.
`void` `apply(GeometryFilter filter)` Performs an operation with or on this `Geometry` and its subelement `Geometry`s (if any).
`java.lang.Object` `clone()` Creates and returns a full copy of this `Point` object.
`protected int` `compareToSameClass(java.lang.Object other)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.
`protected int` `compareToSameClass(java.lang.Object other, CoordinateSequenceComparator comp)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` of the same class.
`protected Envelope` `computeEnvelopeInternal()` Returns the minimum and maximum x and y values in this `Geometry` , or a null `Envelope` if this `Geometry` is empty.
`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.
`Coordinate` `getCoordinate()` Returns a vertex of this `Geometry` (usually, but not necessarily, the first one).
`Coordinate[]` `getCoordinates()` Returns an array containing the values of all the vertices for this geometry.
`CoordinateSequence` `getCoordinateSequence()`
`int` `getDimension()` Returns the dimension of this geometry.
`java.lang.String` `getGeometryType()` Returns the name of this object's `com.vivid.jts.geom` interface.
`int` `getNumPoints()` Returns the count of this `Geometry`s vertices.
`double` `getX()`
`double` `getY()`
`boolean` `isEmpty()` Returns whether or not the set of points in this `Geometry` is empty.
`boolean` `isSimple()` Tests whether this `Geometry` is simple.
`boolean` `isValid()` A Point is valid iff: the coordinate which defines it is a valid coordinate (i.e does not have an NaN X or Y ordinate)
`void` `normalize()` Converts this `Geometry` to normal form (or canonical form ).
`Geometry` `reverse()` Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.

Methods inherited from class com.vividsolutions.jts.geom.Geometry

`buffer, buffer, buffer, checkNotGeometryCollection, compare, compareTo, compareTo, contains, convexHull, coveredBy, covers, crosses, difference, disjoint, distance, equal, equals, equalsExact, geometryChanged, geometryChangedAction, getArea, getCentroid, getEnvelope, getEnvelopeInternal, getFactory, getGeometryN, getInteriorPoint, getLength, getNumGeometries, getPrecisionModel, getSRID, getUserData, hasNonEmptyElements, hasNullElements, intersection, intersects, isEquivalentClass, isGeometryCollection, isRectangle, isWithinDistance, overlaps, relate, relate, setSRID, setUserData, symDifference, toString, toText, touches, union, union, within`

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

Constructor Detail

### Point

    public Point(Coordinate coordinate,
                 PrecisionModel precisionModel,
                 int SRID)

  Deprecated. Use GeometryFactory instead

  Constructs a `Point` with the given coordinate.

Parameters:
  `coordinate` - the coordinate on which to base this `Point` , or `null` to create the empty geometry.
  `precisionModel` - the specification of the grid of allowable points for this `Point`
  `SRID` - the ID of the Spatial Reference System used by this `Point`

### Point

    public Point(CoordinateSequence coordinates,
                 GeometryFactory factory)

Parameters:
  `coordinates` - contains the single coordinate on which to base this `Point` , or `null` to create the empty geometry.

Method Detail

### getCoordinates

    public Coordinate[] getCoordinates()

  Description copied from class: `Geometry`
  Returns an array containing the values of all the vertices for this geometry. If the geometry is a composite, the array will contain all the vertices for the components, in the order in which the components occur in the geometry.

  In general, the array cannot be assumed to be the actual internal storage for the vertices. Thus modifying the array may not modify the geometry itself. Use the `CoordinateSequence.setOrdinate(int, int, double)` method (possibly on the components) to modify the underlying data. If the coordinates are modified, `Geometry.geometryChanged()` must be called afterwards.

  Specified by:
    `getCoordinates` in class `Geometry`
  Returns:
    the vertices of this `Geometry`
  See Also:
    `geometryChanged`, `CoordinateSequence.setOrdinate(int, int, double)`

### getNumPoints

    public int getNumPoints()

  Description copied from class: `Geometry`
  Returns the count of this `Geometry`s vertices. The `Geometry` s contained by composite `Geometry`s must be Geometry's; that is, they must implement `getNumPoints`

  Specified by:
    `getNumPoints` in class `Geometry`
  Returns:
    the number of vertices in this `Geometry`

### isEmpty

    public boolean isEmpty()

  Description copied from class: `Geometry`
  Returns whether or not the set of points in this `Geometry` is empty.

  Specified by:
    `isEmpty` in class `Geometry`
  Returns:
    `true` if this `Geometry` equals the empty geometry

### isSimple

    public boolean isSimple()

  Description copied from class: `Geometry`
  Tests whether this `Geometry` is simple. In general, the SFS specification of simplicity follows the rule:
  - A Geometry is simple iff the only self-intersections are at boundary points.
  Simplicity is defined for each `Geometry` subclass as follows:
  - Valid polygonal geometries are simple by definition, so `isSimple` trivially returns true.
  - 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 `Geometry`s are always simple

  Overrides:
    `isSimple` in class `Geometry`
  Returns:
    `true` if this `Geometry` has any points of self-tangency, self-intersection or other anomalous points
  See Also:
    `Geometry.isValid()`

### isValid

    public boolean isValid()

  A Point is valid iff:
  - the coordinate which defines it is a valid coordinate (i.e does not have an NaN X or Y ordinate)

  Overrides:
    `isValid` in class `Geometry`
  Returns:
    true iff the Point is valid
  See Also:
    `IsValidOp`

### getDimension

    public int getDimension()

  Description copied from class: `Geometry`
  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 `Coordinate`s. 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 class `Geometry`
  Returns:
    the topological dimension of this geometry.

### getBoundaryDimension

    public int getBoundaryDimension()

  Description copied from class: `Geometry`
  Returns the dimension of this `Geometry`s inherent boundary.

  Specified by:
    `getBoundaryDimension` in class `Geometry`
  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.

### getX

    public double getX()

### getY

    public double getY()

### getCoordinate

    public Coordinate getCoordinate()

  Description copied from class: `Geometry`
  Returns a vertex of this `Geometry` (usually, but not necessarily, the first one). The returned coordinate should not be assumed to be an actual Coordinate object used in the internal representation.

  Specified by:
    `getCoordinate` in class `Geometry`
  Returns:
    a `Coordinate` which is a vertex of this `Geometry`.

### getGeometryType

    public java.lang.String getGeometryType()

  Description copied from class: `Geometry`
  Returns the name of this object's `com.vivid.jts.geom` interface.

  Specified by:
    `getGeometryType` in class `Geometry`
  Returns:
    the name of this `Geometry`s most specific `com.vividsolutions.jts.geom` interface

### 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 class `Geometry`
  Returns:
    an empty GeometryCollection
  See Also:
    `Geometry.getBoundary()`

### computeEnvelopeInternal

    protected Envelope computeEnvelopeInternal()

  Description copied from class: `Geometry`
  Returns the minimum and maximum x and y values in this `Geometry` , or a null `Envelope` if this `Geometry` is empty. Unlike `getEnvelopeInternal`, this method calculates the `Envelope` each time it is called; `getEnvelopeInternal` caches the result of this method.

  Specified by:
    `computeEnvelopeInternal` in class `Geometry`
  Returns:
    this `Geometry`s bounding box; if the `Geometry` is empty, `Envelope#isNull` will return `true`

### equalsExact

    public boolean equalsExact(Geometry other,
                               double tolerance)

  Description copied from class: `Geometry`
  Returns true if the two `Geometry`s 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 class
  - they have the same values for their vertices, within the given tolerance distance, in exactly the same order.
  If this and the other `Geometry`s are composites and any children are not `Geometry`s, returns `false`.

  Specified by:
    `equalsExact` in class `Geometry`
  Parameters:
    `other` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this and the other `Geometry` are of the same class and have equal internal data.

### apply

    public void apply(CoordinateFilter filter)

  Description copied from class: `Geometry`
  Performs an operation with or on this `Geometry`'s coordinates. If this method modifies any coordinate values, `Geometry.geometryChanged()` must be called to update the geometry state. Note that you cannot use this method to modify this Geometry if its underlying CoordinateSequence's #get method returns a copy of the Coordinate, rather than the actual Coordinate stored (if it even stores Coordinate objects at all).

  Specified by:
    `apply` in class `Geometry`
  Parameters:
    `filter` - the filter to apply to this `Geometry`'s coordinates

### apply

    public void apply(CoordinateSequenceFilter filter)

  Description copied from class: `Geometry`
  Performs an operation on the coordinates in this `Geometry`'s `CoordinateSequence`s. If the filter reports that a coordinate value has been changed, `Geometry.geometryChanged()` will be called automatically.

  Specified by:
    `apply` in class `Geometry`
  Parameters:
    `filter` - the filter to apply

### apply

    public void apply(GeometryFilter filter)

  Description copied from class: `Geometry`
  Performs an operation with or on this `Geometry` and its subelement `Geometry`s (if any). Only GeometryCollections and subclasses have subelement Geometry's.

  Specified by:
    `apply` in class `Geometry`
  Parameters:
    `filter` - the filter to apply to this `Geometry` (and its children, if it is a `GeometryCollection`).

### apply

    public void apply(GeometryComponentFilter filter)

  Description copied from class: `Geometry`
  Performs an operation with or on this Geometry and its component Geometry's. Only GeometryCollections and Polygons have component Geometry's; for Polygons they are the LinearRings of the shell and holes.

  Specified by:
    `apply` in class `Geometry`
  Parameters:
    `filter` - the filter to apply to this `Geometry`.

### clone

    public java.lang.Object clone()

  Creates and returns a full copy of this `Point` object. (including all coordinates contained by it).

  Overrides:
    `clone` in class `Geometry`
  Returns:
    a clone of this instance

### reverse

    public Geometry reverse()

  Description copied from class: `Geometry`
  Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.

  Specified by:
    `reverse` in class `Geometry`
  Returns:
    a reversed geometry

### normalize

    public void normalize()

  Description copied from class: `Geometry`
  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 `Geometry`s 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 class `Geometry`

### compareToSameClass

    protected int compareToSameClass(java.lang.Object other)

  Description copied from class: `Geometry`
  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.

  Specified by:
    `compareToSameClass` in class `Geometry`
  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

### compareToSameClass

    protected int compareToSameClass(java.lang.Object other,
                                     CoordinateSequenceComparator comp)

  Description copied from class: `Geometry`
  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` of the same class. using the given `CoordinateSequenceComparator`.

  Specified by:
    `compareToSameClass` in class `Geometry`
  Parameters:
    `other` - a `Geometry` having the same class as this `Geometry`
    `comp` - a `CoordinateSequenceComparator`
  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

### getCoordinateSequence

    public CoordinateSequence getCoordinateSequence()