Polyline.h

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <vector>
 
// GeoLib
#include "GeoObject.h"
#include "LineSegment.h"
#include "Point.h"
 
// MathLib
#include "MathLib/Point3d.h"
 
namespace GeoLib
{
enum class Location
{
    LEFT,
    RIGHT,
    BEYOND,
    BEHIND,
    BETWEEN,
    SOURCE,
    DESTINATION
};
 
class Polyline : public GeoObject
{
public:
    class SegmentIterator final
        : public std::iterator<std::forward_iterator_tag, LineSegment>
    {
    public:
        explicit SegmentIterator(Polyline const& polyline,
                                 std::size_t segment_number);
 
        SegmentIterator(SegmentIterator const& src);
 
        SegmentIterator() = delete;
        ~SegmentIterator() = default;
 
        SegmentIterator& operator=(SegmentIterator const& rhs);
 
        std::size_t getSegmentNumber() const;
 
        SegmentIterator& operator++();
 
        LineSegment operator*() const;
 
        LineSegment operator*();
 
        bool operator==(SegmentIterator const& other) const;
 
        bool operator!=(SegmentIterator const& other) const;
 
        SegmentIterator& operator+=(std::vector<GeoLib::Point>::difference_type n);
 
        SegmentIterator operator+(std::vector<GeoLib::Point>::difference_type n);
 
        SegmentIterator& operator-=(std::vector<GeoLib::Point>::difference_type n);
 
        SegmentIterator operator-(std::vector<GeoLib::Point>::difference_type n);
 
    private:
        GeoLib::Polyline const* _polyline;
        std::vector<GeoLib::Point*>::size_type _segment_number;
    };
 
    friend class Polygon;
    explicit Polyline(const std::vector<Point*>& pnt_vec);
    Polyline(const Polyline& ply);
    Polyline& operator=(Polyline const& other) = delete;
 
    ~Polyline() override = default;
 
    GEOTYPE getGeoType() const override { return GEOTYPE::POLYLINE; }
 
    virtual bool addPoint(std::size_t pnt_id);
 
    virtual bool insertPoint(std::size_t pos, std::size_t pnt_id);
 
    virtual void removePoint(std::size_t pos);
 
    void closePolyline();
 
    static Polyline* constructPolylineFromSegments(const std::vector<Polyline*> &ply_vec,
                                                   double prox = 0.0);
 
    std::size_t getNumberOfPoints() const;
 
    std::size_t getNumberOfSegments() const;
 
    bool isClosed() const;
 
    bool isCoplanar() const;
 
    bool isPointIDInPolyline(std::size_t pnt_id) const;
 
    std::size_t getPointID(std::size_t i) const;
 
    void setPointID(std::size_t idx, std::size_t id);
 
    const Point* getPoint(std::size_t i) const;
 
    SegmentIterator begin() const
    {
        return SegmentIterator(*this, 0);
    }
 
    SegmentIterator end() const
    {
        return SegmentIterator(*this, getNumberOfSegments());
    }
 
    std::vector<Point*> const& getPointsVec () const;
 
    double getDistanceAlongPolyline(const MathLib::Point3d& pnt,
        const double epsilon_radius) const;
 
protected:
    Location getLocationOfPoint(std::size_t k,
                                MathLib::Point3d const& pnt) const;
 
    const std::vector<Point*> &_ply_pnts;
    std::vector<std::size_t> _ply_pnt_ids;
 
private:
    LineSegment getSegment(std::size_t i) const;
    LineSegment getSegment(std::size_t i);
};
 
bool containsEdge (const Polyline& ply, std::size_t id0, std::size_t id1);
 
bool operator==(Polyline const& lhs, Polyline const& rhs);
 
bool pointsAreIdentical(const std::vector<Point*> &pnt_vec, std::size_t i, std::size_t j,
                        double prox);
}  // namespace GeoLib