GeoLib::Polyline Class Reference

Detailed Description

Class Polyline consists mainly of a reference to a point vector and a vector that stores the indices in the point vector. A polyline consists of at least one line segment. The polyline is specified by the points of the line segments. The class Polyline stores ids of pointers to the points in the _ply_pnt_ids vector.

Definition at line 28 of file Polyline.h.

#include <Polyline.h>

Inheritance diagram for GeoLib::Polyline:

Collaboration diagram for GeoLib::Polyline:

Classes
class	SegmentIterator

Public Member Functions
	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 a geometry type
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 ()
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
	returns the i-th point contained in the polyline
SegmentIterator	begin () const
SegmentIterator	end () const
std::vector< Point * > const &	getPointsVec () const
double	getDistanceAlongPolyline (const MathLib::Point3d &pnt, const double epsilon_radius) const
Public Member Functions inherited from GeoLib::GeoObject
virtual	~GeoObject ()=default

Static Public Member Functions
static Polyline *	constructPolylineFromSegments (const std::vector< Polyline * > &ply_vec, double prox=0.0)

Protected Member Functions
void	reverseOrientation ()
std::vector< std::size_t > const &	getPolylinePointIDs () const

Protected Attributes
const std::vector< Point * > &	_ply_pnts

Private Member Functions
LineSegment	getSegment (std::size_t i) const

Private Attributes
std::vector< std::size_t >	_ply_pnt_ids

Friends
class	Polygon

Constructor & Destructor Documentation

Polyline() [1/2]

GeoLib::Polyline::Polyline ( const std::vector< Point * > & pnt_vec )

explicit

constructor

Parameters

pnt_vec

a reference to the point vector

Definition at line 17 of file Polyline.cpp.

: _ply_pnts(pnt_vec) {}

References _ply_pnts.

Referenced by GeoLib::Polygon::Polygon(), GeoLib::Polygon::Polygon(), Polyline(), GeoLib::PolylineWithSegmentMarker::PolylineWithSegmentMarker(), GeoLib::Polyline::SegmentIterator::SegmentIterator(), constructPolylineFromSegments(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPolylineInPolygon(), GeoLib::Polygon::operator=(), operator=(), and Polygon.

Polyline() [2/2]

GeoLib::Polyline::Polyline

(

const Polyline &

ply

)

Copy constructor

Parameters

ply

Polyline

Definition at line 19 of file Polyline.cpp.

    : _ply_pnts(ply._ply_pnts), _ply_pnt_ids(ply._ply_pnt_ids)
{
}

References Polyline(), _ply_pnt_ids, and _ply_pnts.

~Polyline()

GeoLib::Polyline::~Polyline ( )

overridedefault

Member Function Documentation

addPoint()

bool GeoLib::Polyline::addPoint ( std::size_t pnt_id )

virtual

Adds an id of a point at the end of the polyline if and only if the resulting segment won't be empty. The id have to be inside the (internal) _ply_pnts vector the polyline is based on.

Returns

If the point could be added the return value is true. If the addition of the point would result in empty line segment false is returned.

Reimplemented in GeoLib::PolygonWithSegmentMarker, and GeoLib::PolylineWithSegmentMarker.

Definition at line 24 of file Polyline.cpp.

{
    if (pnt_id >= _ply_pnts.size())
    {
        return false;
    }
    std::size_t const n_pnts(_ply_pnt_ids.size());
 
    // don't insert point if this would result in identical IDs for two adjacent
    // points
    if (n_pnts > 0 && _ply_pnt_ids.back() == pnt_id)
    {
        return false;
    }
 
    _ply_pnt_ids.push_back(pnt_id);
 
    return true;
}

References _ply_pnt_ids, and _ply_pnts.

Referenced by GeoLib::PolygonWithSegmentMarker::addPoint(), GeoLib::PolylineWithSegmentMarker::addPoint(), closePolyline(), createPolyline(), insertPoint(), MeshGeoToolsLib::markNodesOutSideOfPolygon(), mergeGeometries(), FileIO::SwmmInterface::readLinksAsPolylines(), FileIO::SwmmInterface::readPolygons(), FileIO::Legacy::readPolylinePointVector(), GeoLib::Polygon::splitPolygonAtIntersection(), and GeoLib::Polygon::splitPolygonAtPoint().

begin()

SegmentIterator GeoLib::Polyline::begin ( ) const

inline

Definition at line 177 of file Polyline.h.

{ return SegmentIterator(*this, 0); }

Referenced by GeoLib::computeAndInsertAllIntersectionPoints(), GeoLib::Polygon::getNextIntersectionPointPolygonLine(), FileIO::GMSH::GMSHPolygonTree::insertPolyline(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPolylineInPolygon(), GeoLib::lineSegmentsIntersect(), and MeshGeoToolsLib::mapPolylineOnSurfaceMesh().

closePolyline()

void GeoLib::Polyline::closePolyline

(

)

Closes a polyline by adding a line segment that connects start- and end-point.

Definition at line 291 of file Polyline.cpp.

{
    if (getNumberOfPoints() < 2)
    {
        ERR("Polyline::closePolyline(): Input polyline needs to be composed of "
            "at least three points.");
    }
    if (!isClosed())
    {
        addPoint(getPointID(0));
    }
}

References addPoint(), ERR(), getNumberOfPoints(), getPointID(), and isClosed().

Referenced by GEOModels::connectPolylineSegments().

constructPolylineFromSegments()

Polyline * GeoLib::Polyline::constructPolylineFromSegments ( const std::vector< Polyline * > & ply_vec, double prox = 0.0 )

static

Constructs one polyline from a vector of connected polylines. All polylines in this vector need to reference the same point vector.

Definition at line 179 of file Polyline.cpp.

{
    std::size_t nLines = ply_vec.size();
 
    auto* new_ply = new Polyline(*ply_vec[0]);
    std::vector<GeoLib::Point*> pnt_vec(new_ply->getPointsVec());
 
    std::vector<Polyline*> local_ply_vec;
    for (std::size_t i = 1; i < nLines; i++)
    {
        local_ply_vec.push_back(ply_vec[i]);
    }
 
    while (!local_ply_vec.empty())
    {
        bool ply_found(false);
        prox *= prox;  // square distance once to save time later
        for (auto it = local_ply_vec.begin(); it != local_ply_vec.end(); ++it)
        {
            if (pnt_vec == (*it)->getPointsVec())
            {
                std::size_t nPoints((*it)->getNumberOfPoints());
 
                // if (new_ply->getPointID(0) == (*it)->getPointID(0))
                if (pointsAreIdentical(pnt_vec, new_ply->getPointID(0),
                                       (*it)->getPointID(0), prox))
                {
                    auto* tmp = new Polyline((*it)->getPointsVec());
                    for (std::size_t k = 0; k < nPoints; k++)
                    {
                        tmp->addPoint((*it)->getPointID(nPoints - k - 1));
                    }
 
                    std::size_t new_ply_size(new_ply->getNumberOfPoints());
                    for (std::size_t k = 1; k < new_ply_size; k++)
                    {
                        tmp->addPoint(new_ply->getPointID(k));
                    }
                    delete new_ply;
                    new_ply = tmp;
                    ply_found = true;
                }
                // else if (new_ply->getPointID(0) ==
                // (*it)->getPointID(nPoints-1))
                else if (pointsAreIdentical(pnt_vec, new_ply->getPointID(0),
                                            (*it)->getPointID(nPoints - 1),
                                            prox))
                {
                    auto* tmp = new Polyline(**it);
                    std::size_t new_ply_size(new_ply->getNumberOfPoints());
                    for (std::size_t k = 1; k < new_ply_size; k++)
                    {
                        tmp->addPoint(new_ply->getPointID(k));
                    }
                    delete new_ply;
                    new_ply = tmp;
                    ply_found = true;
                }
                // else if (new_ply->getPointID(new_ply->getNumberOfPoints()-1)
                // == (*it)->getPointID(0))
                else if (pointsAreIdentical(
                             pnt_vec,
                             new_ply->getPointID(new_ply->getNumberOfPoints() -
                                                 1),
                             (*it)->getPointID(0), prox))
                {
                    for (std::size_t k = 1; k < nPoints; k++)
                    {
                        new_ply->addPoint((*it)->getPointID(k));
                    }
                    ply_found = true;
                }
                // else if (new_ply->getPointID(new_ply->getNumberOfPoints()-1)
                // == (*it)->getPointID(nPoints-1))
                else if (pointsAreIdentical(
                             pnt_vec,
                             new_ply->getPointID(new_ply->getNumberOfPoints() -
                                                 1),
                             (*it)->getPointID(nPoints - 1), prox))
                {
                    for (std::size_t k = 1; k < nPoints; k++)
                    {
                        new_ply->addPoint((*it)->getPointID(nPoints - k - 1));
                    }
                    ply_found = true;
                }
                if (ply_found)
                {
                    local_ply_vec.erase(it);
                    break;
                }
            }
            else
            {
                ERR("Error in Polyline::contructPolylineFromSegments() - Line "
                    "segments use different point vectors.");
            }
        }
 
        if (!ply_found)
        {
            ERR("Error in Polyline::contructPolylineFromSegments() - Not all "
                "segments are connected.");
            delete new_ply;
            new_ply = nullptr;
            break;
        }
    }
    return new_ply;
}

References Polyline(), ERR(), and GeoLib::pointsAreIdentical().

Referenced by GEOModels::connectPolylineSegments().

end()

SegmentIterator GeoLib::Polyline::end ( ) const

inline

Definition at line 179 of file Polyline.h.

    {
        return SegmentIterator(*this, getNumberOfSegments());
    }

References getNumberOfSegments().

Referenced by GeoLib::computeAndInsertAllIntersectionPoints(), GeoLib::Polygon::getNextIntersectionPointPolygonLine(), FileIO::GMSH::GMSHPolygonTree::insertPolyline(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPolylineInPolygon(), GeoLib::lineSegmentsIntersect(), and MeshGeoToolsLib::mapPolylineOnSurfaceMesh().

getDistanceAlongPolyline()

double GeoLib::Polyline::getDistanceAlongPolyline	(	const MathLib::Point3d &	pnt,
		const double	epsilon_radius ) const

returns the distance along the polyline from the beginning of the polyline

Parameters

pnt	the point on the polyline
epsilon_radius	the epsilon

Returns

the distance along the polyline between the given point and the beginning of the polyline. If the given point is not on the polyine, negative value is returned.

Definition at line 304 of file Polyline.cpp.

{
    double dist(-1.0);
    double lambda;
    bool found = false;
    double act_length_of_ply = 0.0;
    // loop over all line segments of the polyline
    for (std::size_t k = 0; k < getNumberOfSegments(); k++)
    {
        auto const& a = getPoint(k)->asEigenVector3d();
        auto const& b = getPoint(k + 1)->asEigenVector3d();
        double const seg_length((b - a).norm());
        act_length_of_ply += seg_length;
        // is the orthogonal projection of the j-th node to the
        // line g(lambda) = _ply->getPoint(k) + lambda * (_ply->getPoint(k+1) -
        // _ply->getPoint(k)) at the k-th line segment of the polyline, i.e. 0
        // <= lambda <= 1?
        if (MathLib::calcProjPntToLineAndDists(pnt, *getPoint(k),
                                               *getPoint(k + 1), lambda,
                                               dist) <= epsilon_radius)
        {
            double const lower_lambda(-epsilon_radius / seg_length);
            double const upper_lambda(1 + epsilon_radius / seg_length);
 
            if (lower_lambda <= lambda && lambda <= upper_lambda)
            {
                found = true;
                dist = act_length_of_ply + dist;
                break;
            }  // end if lambda
        }
    }  // end line segment loop
 
    if (!found)
    {
        dist = -1.0;
    }
    return dist;
}

References MathLib::Point3d::asEigenVector3d(), MathLib::calcProjPntToLineAndDists(), getNumberOfSegments(), and getPoint().

getGeoType()

GEOTYPE GeoLib::Polyline::getGeoType ( ) const

inlineoverridevirtual

return a geometry type

Implements GeoLib::GeoObject.

Definition at line 94 of file Polyline.h.

{ return GEOTYPE::POLYLINE; }

References GeoLib::POLYLINE.

getNumberOfPoints()

std::size_t GeoLib::Polyline::getNumberOfPoints

(

)

const

returns the number of points, the number of segments is about one smaller

Definition at line 98 of file Polyline.cpp.

{
    return _ply_pnt_ids.size();
}

References _ply_pnt_ids.

Referenced by GeoLib::PolygonWithSegmentMarker::PolygonWithSegmentMarker(), GEOModels::addNameForObjectPoints(), GeoLib::IO::BoostXmlGmlInterface::addPolylinesToPropertyTree(), closePolyline(), GeoLib::containsEdge(), GeoLib::EarClippingTriangulation::copyPolygonPoints(), FileIO::createSurface(), FileIO::createSurfaceWithEarClipping(), GeoLib::Polygon::ensureCCWOrientation(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPntInPolygon(), MeshGeoToolsLib::markNodesOutSideOfPolygon(), GeoLib::markUsedPoints(), GeoLib::GEOObjects::mergePolylines(), GeoLib::operator==(), GeoLib::Polygon::operator==, GeoLib::resetPointIDs(), and GeoLib::rotatePolygonPointsToXY().

getNumberOfSegments()

std::size_t GeoLib::Polyline::getNumberOfSegments

(

)

const

Definition at line 103 of file Polyline.cpp.

{
    return _ply_pnt_ids.empty() ? 0 : _ply_pnt_ids.size() - 1;
}

References _ply_pnt_ids.

Referenced by GeoLib::PolylineWithSegmentMarker::PolylineWithSegmentMarker(), end(), getDistanceAlongPolyline(), getSegment(), and GeoLib::lineSegmentsIntersect().

getPoint()

const Point * GeoLib::Polyline::getPoint

(

std::size_t

i

)

const

returns the i-th point contained in the polyline

Definition at line 168 of file Polyline.cpp.

{
    assert(i < _ply_pnt_ids.size());
    return _ply_pnts[_ply_pnt_ids[i]];
}

References _ply_pnt_ids, and _ply_pnts.

Referenced by GeoTreeModel::addChildren(), GeoLib::EarClippingTriangulation::copyPolygonPoints(), GeoLib::Polygon::ensureCCWOrientation(), getDistanceAlongPolyline(), isCoplanar(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPntInPolygon(), and GeoLib::rotatePolygonPointsToXY().

getPointID()

std::size_t GeoLib::Polyline::getPointID

(

std::size_t const

i

)

const

returns the index of the i-th polyline point in the point vector

Definition at line 149 of file Polyline.cpp.

{
    assert(i < _ply_pnt_ids.size());
    return _ply_pnt_ids[i];
}

References _ply_pnt_ids.

Referenced by GeoLib::EarClippingTriangulation::EarClippingTriangulation(), GeoTreeModel::addChildren(), GeoLib::IO::BoostXmlGmlInterface::addPolylinesToPropertyTree(), FileIO::GMSH::GMSHPolygonTree::checkIntersectionsSegmentExistingPolylines(), closePolyline(), GeoLib::containsEdge(), FileIO::createSurface(), GeoLib::markUsedPoints(), mergeGeometries(), GeoLib::GEOObjects::mergePolylines(), GeoLib::operator==(), GeoLib::Polygon::operator==, FileIO::SwmmInterface::readPolygons(), GeoLib::resetPointIDs(), FileIO::GMSH::GMSHPolygonTree::writeLineLoop(), and FileIO::GMSH::GMSHPolygonTree::writeSubPolygonsAsLineConstraints().

getPointsVec()

std::vector< Point * > const & GeoLib::Polyline::getPointsVec

(

)

const

Definition at line 174 of file Polyline.cpp.

{
    return _ply_pnts;
}

References _ply_pnts.

Referenced by GeoLib::EarClippingTriangulation::EarClippingTriangulation(), GeoLib::Polygon::Polygon(), FileIO::createSurface(), FileIO::createSurfaceWithEarClipping(), GeoLib::markUsedPoints(), and GeoLib::resetPointIDs().

getPolylinePointIDs()

std::vector< std::size_t > const & GeoLib::Polyline::getPolylinePointIDs ( ) const

inlineprotected

Definition at line 204 of file Polyline.h.

    {
        return _ply_pnt_ids;
    }

References _ply_pnt_ids.

Referenced by GeoLib::Polygon::Polygon().

getSegment()

LineSegment GeoLib::Polyline::getSegment ( std::size_t i ) const

private

Definition at line 155 of file Polyline.cpp.

{
    assert(i < getNumberOfSegments());
    return LineSegment(_ply_pnts[_ply_pnt_ids[i]],
                       _ply_pnts[_ply_pnt_ids[i + 1]], false);
}

References _ply_pnt_ids, _ply_pnts, and getNumberOfSegments().

insertPoint()

bool GeoLib::Polyline::insertPoint ( std::size_t pos, std::size_t pnt_id )

virtual

Method inserts a new point (that have to be inside the _ply_pnts vector) at the given position in the polyline if and only if the resulting segments won't be empty.

Parameters

pos	the position in the polyline, pos have to be a value into the interval [0, number of points)
pnt_id	the id of the new point in the vector of points the polyline is based on

Returns

true if the point could be inserted, else false (if empty line segments would be created).

Reimplemented in GeoLib::PolygonWithSegmentMarker, and GeoLib::PolylineWithSegmentMarker.

Definition at line 44 of file Polyline.cpp.

{
    if (pnt_id >= _ply_pnts.size())
    {
        return false;
    }
    if (pos > _ply_pnt_ids.size())
    {
        return false;
    }
 
    if (pos == _ply_pnt_ids.size())
    {
        return addPoint(pnt_id);
    }
 
    // check if inserting pnt_id would result in two identical IDs for adjacent
    // points
    if (pos == 0 && pnt_id == _ply_pnt_ids[0])
    {
        return false;
    }
    if (pos != 0)
    {
        if (pos == (_ply_pnt_ids.size() - 1) && pnt_id == _ply_pnt_ids[pos])
        {
            return false;
        }
        if (pnt_id == _ply_pnt_ids[pos - 1] || pnt_id == _ply_pnt_ids[pos])
        {
            return false;
        }
    }
 
    auto const pos_dt(
        static_cast<std::vector<std::size_t>::difference_type>(pos));
    auto it(_ply_pnt_ids.begin() + pos_dt);
    _ply_pnt_ids.insert(it, pnt_id);
 
    return true;
}

References _ply_pnt_ids, _ply_pnts, and addPoint().

Referenced by GeoLib::computeAndInsertAllIntersectionPoints(), GeoLib::PolygonWithSegmentMarker::insertPoint(), GeoLib::PolylineWithSegmentMarker::insertPoint(), FileIO::GMSH::GMSHPolygonTree::insertPolyline(), and MeshGeoToolsLib::insertSubSegments().

isClosed()

bool GeoLib::Polyline::isClosed

(

)

const

returns true if the polyline is closed

Definition at line 108 of file Polyline.cpp.

{
    if (_ply_pnt_ids.size() < 3)
    {
        return false;
    }
 
    return _ply_pnt_ids.front() == _ply_pnt_ids.back();
}

References _ply_pnt_ids.

Referenced by closePolyline(), FileIO::createSurface(), FileIO::createSurfaceWithEarClipping(), GeoLib::Polygon::initialise(), main(), anonymous_namespace{BoundaryElementsAlongPolyline.cpp}::modifyEdgeNodeOrdering(), and FileIO::FEFLOWMeshInterface::setMaterialIDs().

isCoplanar()

bool GeoLib::Polyline::isCoplanar

(

)

const

returns true if the polyline is coplanar

Definition at line 118 of file Polyline.cpp.

{
    std::size_t const n_points(_ply_pnt_ids.size());
    if (n_points < 4)
    {
        return true;
    }
 
    GeoLib::Point const& p0(*this->getPoint(0));
    GeoLib::Point const& p1(*this->getPoint(1));
    GeoLib::Point const& p2(*this->getPoint(2));
    for (std::size_t i = 3; i < n_points; ++i)
    {
        if (!MathLib::isCoplanar(p0, p1, p2, *this->getPoint(i)))
        {
            DBUG(
                "Point {:d} is not coplanar to the first three points of the "
                "line.",
                i);
            return false;
        }
    }
    return true;
}

References _ply_pnt_ids, DBUG(), getPoint(), and MathLib::isCoplanar().

isPointIDInPolyline()

bool GeoLib::Polyline::isPointIDInPolyline

(

std::size_t

pnt_id

)

const

Method tests if the given id of a point (within the vector of points the polyline is based on) is inside the polyline.

Parameters

pnt_id

the id of the point

Returns

true if the point is part of the polyline, else false

Definition at line 143 of file Polyline.cpp.

{
    return std::find(_ply_pnt_ids.begin(), _ply_pnt_ids.end(), pnt_id) !=
           _ply_pnt_ids.end();
}

References _ply_pnt_ids.

Referenced by FileIO::GMSH::GMSHPolygonTree::insertPolyline().

operator=()

Polyline & GeoLib::Polyline::operator= ( Polyline const & other )

delete

References Polyline().

removePoint()

void GeoLib::Polyline::removePoint

(

std::size_t

pos

)

Method removes a point from the polyline. The connecting line segments will be removed and the length of the polyline will be changed.

Parameters

pos	a valid position within the polyline

Definition at line 86 of file Polyline.cpp.

{
    if (pos >= _ply_pnt_ids.size())
    {
        return;
    }
 
    auto const pos_dt(
        static_cast<std::vector<std::size_t>::difference_type>(pos));
    _ply_pnt_ids.erase(_ply_pnt_ids.begin() + pos_dt);
}

References _ply_pnt_ids.

reverseOrientation()

void GeoLib::Polyline::reverseOrientation ( )

protected

Definition at line 345 of file Polyline.cpp.

{
    std::reverse(_ply_pnt_ids.begin(), _ply_pnt_ids.end());
}

References _ply_pnt_ids.

Referenced by GeoLib::Polygon::ensureCCWOrientation().

setPointID()

void GeoLib::Polyline::setPointID	(	std::size_t	idx,
		std::size_t	id )

Changes a point index for one point in a line

Parameters

idx	Index of point in line
id	ID of point in PointVec object

Definition at line 162 of file Polyline.cpp.

{
    assert(idx < _ply_pnt_ids.size());
    _ply_pnt_ids[idx] = id;
}

References _ply_pnt_ids.

Referenced by GeoLib::resetPointIDs().

Friends And Related Symbol Documentation

Polygon

friend class Polygon

friend

Definition at line 79 of file Polyline.h.

References Polyline(), and Polygon.

Referenced by GeoLib::Polygon::Polygon(), Polygon, and GeoLib::Polygon::splitPolygonAtPoint().

Member Data Documentation

_ply_pnt_ids

std::vector<std::size_t> GeoLib::Polyline::_ply_pnt_ids

private

position of pointers to the geometric points

Definition at line 211 of file Polyline.h.

Referenced by Polyline(), addPoint(), getNumberOfPoints(), getNumberOfSegments(), getPoint(), getPointID(), getPolylinePointIDs(), getSegment(), insertPoint(), isClosed(), isCoplanar(), isPointIDInPolyline(), removePoint(), reverseOrientation(), and setPointID().

_ply_pnts

const std::vector<Point*>& GeoLib::Polyline::_ply_pnts

protected

a reference to the vector of pointers to the geometric points

Definition at line 200 of file Polyline.h.

Referenced by Polyline(), Polyline(), addPoint(), getPoint(), getPointsVec(), getSegment(), insertPoint(), and GeoLib::Polygon::splitPolygonAtIntersection().

---

The documentation for this class was generated from the following files:

• Polyline.h
• Polyline.cpp