CoordinateSequence.h

/**********************************************************************
 *
 * 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.
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/export.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 std::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);
 
 
    bool isRing() const;
 
    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