JTS Topology Suite - v 1.12

## com.vividsolutions.jts.geom
Class CoordinateArrays

    java.lang.Object
      com.vividsolutions.jts.geom.CoordinateArrays

    public class CoordinateArrays

extends java.lang.Object

Useful utility functions for handling Coordinate arrays

Version:
  1.7

Nested Class Summary
`static class` `CoordinateArrays.BidirectionalComparator` A `Comparator` for `Coordinate` arrays modulo their directionality.
`static class` `CoordinateArrays.ForwardComparator` A `Comparator` for `Coordinate` arrays in the forward direction of their coordinates, using lexicographic ordering.

Constructor Summary
`CoordinateArrays()`

Method Summary
`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.
`static int` `compare(Coordinate[] pts1, Coordinate[] pts2)` Compares two `Coordinate` arrays in the forward direction of their coordinates, using lexicographic ordering.
`static Coordinate[]` `copyDeep(Coordinate[] coordinates)` Creates a deep copy of the argument `Coordinate` array.
`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.
`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)
`static boolean` `equals(Coordinate[] coord1, Coordinate[] coord2, java.util.Comparator coordinateComparator)` Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined `CoordinateArrays.ForwardComparator` for `Coordinate` s
`static Coordinate[]` `extract(Coordinate[] pts, int start, int end)` Extracts a subsequence of the input `Coordinate` array from indices `start` to `end` (inclusive).
`static boolean` `hasRepeatedPoints(Coordinate[] coord)` Returns whether #equals returns true for any two consecutive Coordinates in the given array.
`static int` `increasingDirection(Coordinate[] pts)` Determines which orientation of the `Coordinate` array is (overall) increasing.
`static int` `indexOf(Coordinate coordinate, Coordinate[] coordinates)` Returns the index of `coordinate` in `coordinates`.
`static boolean` `isRing(Coordinate[] pts)` Tests whether an array of `Coordinate`s forms a ring, by checking length and closure.
`static Coordinate` `minCoordinate(Coordinate[] coordinates)` Returns the minimum coordinate, using the usual lexicographic comparison.
`static Coordinate` `ptNotInList(Coordinate[] testPts, Coordinate[] pts)` Finds a point in a list of points which is not contained in another list of points
`static Coordinate[]` `removeRepeatedPoints(Coordinate[] coord)` If the coordinate array argument has repeated points, constructs a new array containing no repeated points.
`static void` `reverse(Coordinate[] coord)` Reverses the coordinates in an array in-place.
`static void` `scroll(Coordinate[] coordinates, Coordinate firstCoordinate)` Shifts the positions of the coordinates until `firstCoordinate` is first.
`static Coordinate[]` `toCoordinateArray(java.util.Collection coordList)` Converts the given Collection of Coordinates into a Coordinate array.

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

Constructor Detail

### CoordinateArrays

    public CoordinateArrays()

Method Detail

### isRing

    public static boolean isRing(Coordinate[] pts)

  Tests whether an array of `Coordinate`s 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 `Coordinate`s to test
    `pts` - an array of `Coordinate`s 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

### 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(java.util.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:
    `hasRepeatedPoints(Coordinate[])`

### 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:
    `Coordinate.equals(Object)`

### equals

    public static boolean equals(Coordinate[] coord1,
                                 Coordinate[] coord2,
                                 java.util.Comparator coordinateComparator)

  Returns true if the two arrays are identical, both null, or pointwise equal, using a user-defined `CoordinateArrays.ForwardComparator` 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:
    `Coordinate.compareTo(Object)`

### 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

JTS Topology Suite - v 1.12