|
GEOS 3.14.0dev
|
The internal representation of a list of coordinates inside a Geometry. More...
#include <geos.h>
Public Types | |
| enum | { X , Y , Z , M } |
| Standard ordinate index values. | |
| using | iterator = CoordinateSequenceIterator< CoordinateSequence, Coordinate > |
| using | const_iterator = CoordinateSequenceIterator< const CoordinateSequence, const Coordinate > |
| typedef std::unique_ptr< CoordinateSequence > | Ptr |
Public Member Functions | |
| CoordinateSequence () | |
| CoordinateSequence (std::size_t size, std::size_t dim=0) | |
| CoordinateSequence (std::size_t size, bool hasz, bool hasm, bool initialize=true) | |
| CoordinateSequence (const std::initializer_list< Coordinate > &) | |
| CoordinateSequence (const std::initializer_list< CoordinateXY > &) | |
| CoordinateSequence (const std::initializer_list< CoordinateXYM > &) | |
| CoordinateSequence (const std::initializer_list< CoordinateXYZM > &) | |
| std::unique_ptr< CoordinateSequence > | clone () const |
| Returns a heap-allocated deep copy of this CoordinateSequence. | |
| Envelope | getEnvelope () const |
| std::size_t | getSize () const |
| Returns the number of Coordinates. | |
| size_t | size () const |
| Returns the number of Coordinates. | |
| bool | isEmpty () const |
Returns true if list contains no coordinates. | |
| bool | isRing () const |
Tests whether an a CoordinateSequence forms a ring, by checking length and closure. Self-intersection is not checked. | |
| std::size_t | getDimension () const |
| bool | hasZ () const |
| bool | hasM () const |
| bool | hasRepeatedPoints () const |
| Returns true if contains any two consecutive points. | |
| bool | hasRepeatedOrInvalidPoints () const |
| Returns true if contains any NaN/Inf coordinates. | |
| CoordinateType | getCoordinateType () const |
| template<typename T = Coordinate> | |
| const T & | getAt (std::size_t i) const |
| Returns a read-only reference to Coordinate at position i. | |
| template<typename T = Coordinate> | |
| T & | getAt (std::size_t i) |
| Returns a reference to Coordinate at position i. | |
| template<typename T > | |
| void | getAt (std::size_t i, T &c) const |
| Write Coordinate at position i to given Coordinate. | |
| void | getAt (std::size_t i, CoordinateXY &c) const |
| const Coordinate & | operator[] (std::size_t i) const |
| Coordinate & | operator[] (std::size_t i) |
| double | getOrdinate (std::size_t index, std::size_t ordinateIndex) const |
| double | getX (std::size_t index) const |
| double | getY (std::size_t index) const |
| template<typename T = Coordinate> | |
| const T & | back () const |
| Return last Coordinate in the sequence. | |
| template<typename T = Coordinate> | |
| T & | back () |
| Return last Coordinate in the sequence. | |
| template<typename T = Coordinate> | |
| const T & | front () const |
| Return first Coordinate in the sequence. | |
| template<typename T = Coordinate> | |
| T & | front () |
| Return first Coordinate in the sequence. | |
| void | toVector (std::vector< Coordinate > &coords) const |
| Pushes all Coordinates of this sequence into the provided vector. | |
| void | toVector (std::vector< CoordinateXY > &coords) const |
| template<typename T > | |
| void | setAt (const T &c, std::size_t pos) |
| Copy Coordinate c to position pos. | |
| void | setOrdinate (std::size_t index, std::size_t ordinateIndex, double value) |
| void | setPoints (const std::vector< Coordinate > &v) |
| Substitute Coordinate list with a copy of the given vector. | |
| template<typename T = Coordinate> | |
| void | add (const T &c) |
| template<typename T > | |
| void | add (const T &c, bool allowRepeated) |
| template<typename T > | |
| void | add (const T &c, std::size_t pos) |
| Inserts the specified coordinate at the specified position in this sequence. If multiple coordinates are to be added, a multiple- insert method should be used for best performance. | |
| template<typename T > | |
| void | add (std::size_t i, const T &coord, bool allowRepeated) |
| Inserts the specified coordinate at the specified position in this list. | |
| void | add (double x, double y) |
| void | add (const CoordinateSequence &cs) |
| void | add (const CoordinateSequence &cs, bool allowRepeated) |
| void | add (const CoordinateSequence &cl, bool allowRepeated, bool forwardDirection) |
| void | add (const CoordinateSequence &cs, std::size_t from, std::size_t to) |
| void | add (const CoordinateSequence &cs, std::size_t from, std::size_t to, bool allowRepeated) |
| template<typename T , typename... Args> | |
| void | add (T begin, T end, Args... args) |
| template<typename T > | |
| void | add (std::size_t i, T from, T to) |
| void | clear () |
| void | reserve (std::size_t capacity) |
| void | resize (std::size_t capacity) |
| void | pop_back () |
| std::string | toString () const |
| Get a string representation of CoordinateSequence. | |
| const CoordinateXY * | minCoordinate () const |
| Returns lower-left Coordinate in list. | |
| bool | equalsIdentical (const CoordinateSequence &other) const |
| Returns true if the two sequences are identical (pointwise equal in all dimensions, with NaN == NaN). | |
| void | reverse () |
| Reverse Coordinate order in given CoordinateSequence. | |
| void | sort () |
| void | expandEnvelope (Envelope &env) const |
| void | closeRing (bool allowRepeated=false) |
| template<typename Filter > | |
| void | apply_rw (const Filter *filter) |
| template<typename Filter > | |
| void | apply_ro (Filter *filter) const |
| template<typename F > | |
| auto | applyAt (size_t i, F &&fun) const |
| template<typename F > | |
| void | forEach (F &&fun) const |
| template<typename T , typename F > | |
| void | forEach (F &&fun) const |
| template<typename T , typename F > | |
| void | forEach (std::size_t from, std::size_t to, F &&fun) const |
| template<typename T > | |
| Coordinates< typename std::add_const< T >::type > | items () const |
| template<typename T > | |
| Coordinates< T > | items () |
| double * | data () |
| const double * | data () const |
Static Public Member Functions | |
| static CoordinateSequence | XY (std::size_t size) |
| static CoordinateSequence | XYZ (std::size_t size) |
| static CoordinateSequence | XYZM (std::size_t size) |
| static CoordinateSequence | XYM (std::size_t size) |
| static CoordinateSequence * | atLeastNCoordinatesOrNothing (std::size_t n, CoordinateSequence *c) |
| Returns either the given CoordinateSequence if its length is greater than the given amount, or an empty CoordinateSequence. | |
| static std::size_t | indexOf (const CoordinateXY *coordinate, const CoordinateSequence *cl) |
| Return position of a Coordinate. | |
| static bool | equals (const CoordinateSequence *cl1, const CoordinateSequence *cl2) |
| Returns true if the two arrays are identical, both null, or pointwise equal in two dimensions. | |
| static void | scroll (CoordinateSequence *cl, const CoordinateXY *firstCoordinate) |
| Scroll given CoordinateSequence so to start with given Coordinate. | |
| static int | increasingDirection (const CoordinateSequence &pts) |
Determines which orientation of the Coordinate array is (overall) increasing. | |
The internal representation of a list of coordinates inside a Geometry.
A CoordinateSequence is capable of storing XY, XYZ, XYM, or XYZM Coordinates. For efficient storage, the dimensionality of the CoordinateSequence should be specified at creation using the constructor with hasz and hasm arguments. Currently most of the GEOS code base stores 2D Coordinates and accesses using the Coordinate type. Sequences used by these parts of the code must be created with constructors without hasz and hasm arguments.
If a high-dimension Coordinate coordinate is read from a low-dimension CoordinateSequence, the higher dimensions will be populated with incorrect values or a segfault may occur.
1.9.8