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
{
class PointVec;
 
class Polyline : public GeoObject
{
public:
    class SegmentIterator final
    {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = LineSegment;
        using difference_type = std::ptrdiff_t;
        using pointer = LineSegment*;
        using reference = LineSegment&;
 
        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);
 
    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 const 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:
    const std::vector<Point*>& _ply_pnts;
 
    void reverseOrientation();
 
    std::vector<std::size_t> const& getPolylinePointIDs() const
    {
        return _ply_pnt_ids;
    }
 
private:
    std::vector<std::size_t> _ply_pnt_ids;
 
    LineSegment getSegment(std::size_t i) const;
};
 
bool containsEdge(const Polyline& ply, std::size_t id0, std::size_t id1);
 
void resetPointIDs(Polyline& polyline, std::vector<std::size_t> const& mapping);
 
void markUsedPoints(Polyline const& polyline, std::vector<bool>& used_points);
 
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);
 
std::unique_ptr<Polyline> createPolyline(GeoLib::PointVec const& points_vec,
                                         std::vector<std::size_t>&& point_ids);
 
}  // namespace GeoLib