CoordinateSequence.h

Go to the documentation of this file.

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2006 Refractions Research Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************/

#ifndef GEOS_GEOM_COORDINATESEQUENCE_H
#define GEOS_GEOM_COORDINATESEQUENCE_H

#include <geos/export.h>
#include <geos/inline.h>

#include <geos/geom/Coordinate.h> // for applyCoordinateFilter

#include <vector>
#include <iosfwd> // ostream
#include <memory> // for unique_ptr typedef

// Forward declarations
namespace geos {
namespace geom {
class Envelope;
class CoordinateFilter;
class Coordinate;
}
}

namespace geos {
namespace geom { // geos::geom

class GEOS_DLL CoordinateSequence {

protected:

    CoordinateSequence() {}

    CoordinateSequence(const CoordinateSequence&) {}

public:

    typedef std::unique_ptr<CoordinateSequence> Ptr;

    virtual
    ~CoordinateSequence() {}

    virtual std::unique_ptr<CoordinateSequence> clone() const = 0;

    virtual const Coordinate& getAt(std::size_t i) const = 0;

    const Coordinate&
    back() const
    {
        return getAt(size() - 1);
    }

    const Coordinate&
    front() const
    {
        return getAt(0);
    }

    const Coordinate&
    operator[](std::size_t i) const
    {
        return getAt(i);
    }

    virtual Envelope getEnvelope() const;

    virtual void getAt(std::size_t i, Coordinate& c) const = 0;

    virtual std::size_t getSize() const = 0;

    size_t
    size() const
    {
        return getSize();
    }

    virtual void toVector(std::vector<Coordinate>& coords) const = 0;

    virtual bool isEmpty() const = 0;

    virtual void setAt(const Coordinate& c, std::size_t pos) = 0;

    std::string toString() const;

    virtual void setPoints(const std::vector<Coordinate>& v) = 0;

    bool hasRepeatedPoints() const;

    const Coordinate* minCoordinate() const;

    static bool hasRepeatedPoints(const CoordinateSequence* cl);

    static CoordinateSequence* atLeastNCoordinatesOrNothing(std::size_t n,
            CoordinateSequence* c);

    static size_t indexOf(const Coordinate* coordinate,
                          const CoordinateSequence* cl);

    static bool equals(const CoordinateSequence* cl1,
                       const CoordinateSequence* cl2);

    static void scroll(CoordinateSequence* cl, const Coordinate* firstCoordinate);

    static int increasingDirection(const CoordinateSequence& pts);


    static bool isRing(const CoordinateSequence *pts);

    static void reverse(CoordinateSequence* cl);

    enum { X, Y, Z, M };

    virtual std::size_t getDimension() const = 0;

    bool hasZ() const {
        return getDimension() > 2;
    }

    virtual double getOrdinate(std::size_t index, std::size_t ordinateIndex) const;

    virtual double
    getX(std::size_t index) const
    {
        return getOrdinate(index, X);
    }

    virtual double
    getY(std::size_t index) const
    {
        return getOrdinate(index, Y);
    }


    virtual void setOrdinate(std::size_t index, std::size_t ordinateIndex, double value) = 0;

    virtual void expandEnvelope(Envelope& env) const;

    virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
    virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract

    template <class T>
    void
    applyCoordinateFilter(T& f)
    {
        Coordinate c;
        for(std::size_t i = 0, n = size(); i < n; ++i) {
            getAt(i, c);
            f.filter(c);
            setAt(c, i);
        }
    }

};

GEOS_DLL std::ostream& operator<< (std::ostream& os, const CoordinateSequence& cs);

GEOS_DLL bool operator== (const CoordinateSequence& s1, const CoordinateSequence& s2);

GEOS_DLL bool operator!= (const CoordinateSequence& s1, const CoordinateSequence& s2);

} // namespace geos::geom
} // namespace geos

//#ifdef GEOS_INLINE
//# include "geos/geom/CoordinateSequence.inl"
//#endif

#endif // ndef GEOS_GEOM_COORDINATESEQUENCE_H