Interface DirectPosition

All Superinterfaces:
Position
All Known Implementing Classes:
Abstract­Direct­Position, Direct­Position1D, Direct­Position2D, General­Direct­Position, Immutable­Direct­Position
@UML(identifier="DirectPosition", specification=ISO_19107) public interface DirectPosition extends Position
Holds the coordinates for a position within some coordinate reference system. Since Direct­Positions, as data types, will often be included in larger objects (such as geometries) that have references to coordinate reference system, the get­Coordinate­Reference­System() method may returns null if this particular Direct­Position is included in a larger object with such a reference to a coordinate reference system. In this case, the coordinate reference system is implicitly assumed to take on the value of the containing object's coordinate reference system.
Since:
1.0

  • Method Details

    • getCoordinateReferenceSystem

      @UML(identifier="coordinateReferenceSystem", obligation=MANDATORY, specification=ISO_19107) CoordinateReferenceSystem getCoordinateReferenceSystem()
      The coordinate reference system in which the coordinate is given. May be null if this particular Direct­Position is included in a larger object with such a reference to a coordinate reference system. In this case, the coordinate reference system is implicitly assumed to take on the value of the containing object's coordinate reference system.
      Returns:
      The coordinate reference system, or null.

    • getDimension

      @UML(identifier="dimension", obligation=MANDATORY, specification=ISO_19107) int getDimension()
      The length of coordinate sequence (the number of entries). This is determined by the coordinate reference system.
      Returns:
      The dimensionality of this position.

    • getCoordinate

      @UML(identifier="coordinate", obligation=MANDATORY, specification=ISO_19107) double[] getCoordinate()
      A copy of the ordinates presented as an array of double values. Please note that this is only a copy (the real values may be stored in another format) so changes to the returned array will not affect the source DirectPosition. 
      final int dim = position.getDimension();
for (int i=0; i<dim; i++) {
    position.getOrdinate(i); // no copy overhead
}
      To manipulate ordinates, the following idiom can be used: 
      position.setOrdinate(i, value); // edit in place
      There are a couple reasons for requerying a copy:

      • We want an array of coordinates with the intend to modify it for computation purpose (without modifying the original Direct­Position), or we want to protect the array from future Direct­Position changes.
      • If Direct­Position​.get­Ordinates() is guaranteed to not return the backing array, then we can work directly on this array. If we don't have this guarantee, then we must conservatively clone the array in every cases.
      • Cloning the returned array is useless if the implementation cloned the array or was forced to returns a new array anyway (for example because the coordinates were computed on the fly)

      Precedence is given to data integrity over get­Ordinates() performance. Performance concern can be avoided with usage of get­Ordinate(int).

      Returns:
      A copy of the coordinates. Changes in the returned array will not be reflected back in this Direct­Position object.

    • getOrdinate

      double getOrdinate(int dimension) throws IndexOutOfBoundsException
      Returns the ordinate at the specified dimension.
      Parameters:
      dimension - The dimension in the range 0 to dimension-1.
      Returns:
      The coordinate at the specified dimension.
      Throws:
      Index­Out­Of­Bounds­Exception - If the given index is negative or is equal or greater than the envelope dimension.

    • setOrdinate

      void setOrdinate(int dimension, double value) throws IndexOutOfBoundsException, UnsupportedOperationException
      Sets the ordinate value along the specified dimension.
      Parameters:
      dimension - the dimension for the ordinate of interest.
      value - the ordinate value of interest.
      Throws:
      Index­Out­Of­Bounds­Exception - If the given index is negative or is equal or greater than the envelope dimension.
      Unsupported­Operation­Exception - if this direct position is immutable.

    • equals

      boolean equals(Object object)
      Compares this direct position with the specified object for equality. Two direct positions are considered equal if the following conditions are meet:

      Overrides:
      equals in class Object
      Parameters:
      object - The object to compare with this direct position for equality.
      Returns:
      true if the given object is equal to this direct position.
      Since:
      2.1

    • hashCode

      int hashCode()
      Returns a hash code value for this direct position. This method should returns the same value as: Arrays​.hash­Code(get­Coordinate()) + get­Coordinate­Reference­System().hash­Code() where the right hand side of the addition is omitted if the coordinate reference system is null.
      Overrides:
      hash­Code in class Object
      Returns:
      A hash code value for this direct position.
      Since:
      2.1