Package org.locationtech.jts.geom

Class CoordinateArrays

java.lang.Object
org.locationtech.jts.geom.CoordinateArrays
public class CoordinateArrays extends Object
Useful utility functions for handling Coordinate arrays
Version:
1.7

  • Field Details

    • coordArrayType

      private static final Coordinate[] coordArrayType

  • Constructor Details

    • CoordinateArrays

      private CoordinateArrays()

  • Method Details

    • isRing

      public static boolean isRing(Coordinate[] pts)
      Tests whether an array of Coordinates forms a ring, by checking length and closure. Self-intersection is not checked.
      Parameters:
      pts - an array of Coordinates
      Returns:
      true if the coordinate form a ring.

    • ptNotInList

      public static Coordinate ptNotInList(Coordinate[] testPts, Coordinate[] pts)
      Finds a point in a list of points which is not contained in another list of points
      Parameters:
      testPts - the Coordinates to test
      pts - an array of Coordinates to test the input points against
      Returns:
      a Coordinate from testPts which is not in pts, ' or null

    • compare

      public static int compare(Coordinate[] pts1, Coordinate[] pts2)
      Compares two Coordinate arrays in the forward direction of their coordinates, using lexicographic ordering.
      Parameters:
      pts1 -
      pts2 -
      Returns:
      an integer indicating the order

    • increasingDirection

      public static int increasingDirection(Coordinate[] pts)
      Determines which orientation of the Coordinate array is (overall) increasing. In other words, determines which end of the array is "smaller" (using the standard ordering on Coordinate). Returns an integer indicating the increasing direction. If the sequence is a palindrome, it is defined to be oriented in a positive direction.
      Parameters:
      pts - the array of Coordinates to test
      Returns:
      1 if the array is smaller at the start or is a palindrome, -1 if smaller at the end

    • isEqualReversed

      private static boolean isEqualReversed(Coordinate[] pts1, Coordinate[] pts2)
      Determines whether two Coordinate arrays of equal length are equal in opposite directions.
      Parameters:
      pts1 -
      pts2 -
      Returns:
      true if the two arrays are equal in opposite directions.

    • copyDeep

      public static Coordinate[] copyDeep(Coordinate[] coordinates)
      Creates a deep copy of the argument Coordinate array.
      Parameters:
      coordinates - an array of Coordinates
      Returns:
      a deep copy of the input

    • copyDeep

      public static void copyDeep(Coordinate[] src, int srcStart, Coordinate[] dest, int destStart, int length)
      Creates a deep copy of a given section of a source Coordinate array into a destination Coordinate array. The destination array must be an appropriate size to receive the copied coordinates.
      Parameters:
      src - an array of Coordinates
      srcStart - the index to start copying from
      dest - the
      destStart - the destination index to start copying to
      length - the number of items to copy

    • toCoordinateArray

      public static Coordinate[] toCoordinateArray(Collection coordList)
      Converts the given Collection of Coordinates into a Coordinate array.

    • hasRepeatedPoints

      public static boolean hasRepeatedPoints(Coordinate[] coord)
      Returns whether #equals returns true for any two consecutive Coordinates in the given array.

    • atLeastNCoordinatesOrNothing

      public static Coordinate[] atLeastNCoordinatesOrNothing(int n, Coordinate[] c)
      Returns either the given coordinate array if its length is greater than the given amount, or an empty coordinate array.

    • removeRepeatedPoints

      public static Coordinate[] removeRepeatedPoints(Coordinate[] coord)
      If the coordinate array argument has repeated points, constructs a new array containing no repeated points. Otherwise, returns the argument.
      See Also:

    • removeNull

      public static Coordinate[] removeNull(Coordinate[] coord)
      Collapses a coordinate array to remove all null elements.
      Parameters:
      coord - the coordinate array to collapse
      Returns:
      an array containing only non-null elements

    • reverse

      public static void reverse(Coordinate[] coord)
      Reverses the coordinates in an array in-place.

    • equals

      public static boolean equals(Coordinate[] coord1, Coordinate[] coord2)
      Returns true if the two arrays are identical, both null, or pointwise equal (as compared using Coordinate#equals)
      See Also:

    • equals

      public static boolean equals(Coordinate[] coord1, Coordinate[] coord2, Comparator coordinateComparator)
      Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined Comparator for Coordinate s
      Parameters:
      coord1 - an array of Coordinates
      coord2 - an array of Coordinates
      coordinateComparator - a Comparator for Coordinates

    • minCoordinate

      public static Coordinate minCoordinate(Coordinate[] coordinates)
      Returns the minimum coordinate, using the usual lexicographic comparison.
      Parameters:
      coordinates - the array to search
      Returns:
      the minimum coordinate in the array, found using compareTo
      See Also:

    • scroll

      public static void scroll(Coordinate[] coordinates, Coordinate firstCoordinate)
      Shifts the positions of the coordinates until firstCoordinate is first.
      Parameters:
      coordinates - the array to rearrange
      firstCoordinate - the coordinate to make first

    • indexOf

      public static int indexOf(Coordinate coordinate, Coordinate[] coordinates)
      Returns the index of coordinate in coordinates. The first position is 0; the second, 1; etc.
      Parameters:
      coordinate - the Coordinate to search for
      coordinates - the array to search
      Returns:
      the position of coordinate, or -1 if it is not found

    • extract

      public static Coordinate[] extract(Coordinate[] pts, int start, int end)
      Extracts a subsequence of the input Coordinate array from indices start to end (inclusive). The input indices are clamped to the array size; If the end index is less than the start index, the extracted array will be empty.
      Parameters:
      pts - the input array
      start - the index of the start of the subsequence to extract
      end - the index of the end of the subsequence to extract
      Returns:
      a subsequence of the input array

    • envelope

      public static Envelope envelope(Coordinate[] coordinates)
      Computes the envelope of the coordinates.
      Parameters:
      coordinates - the coordinates to scan
      Returns:
      the envelope of the coordinates

    • intersection

      public static Coordinate[] intersection(Coordinate[] coordinates, Envelope env)
      Extracts the coordinates which intersect an Envelope.
      Parameters:
      coordinates - the coordinates to scan
      env - the envelope to intersect with
      Returns:
      an array of the coordinates which intersect the envelope