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 50 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 More...
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 ()
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
	returns the i-th point contained in the polyline More...
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
Location	getLocationOfPoint (std::size_t k, MathLib::Point3d const &pnt) const

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

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

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 27 of file Polyline.cpp.

: _ply_pnts(pnt_vec) {}

Referenced by constructPolylineFromSegments().

Polyline() [2/2]

GeoLib::Polyline::Polyline

(

const Polyline &

ply

)

Copy constructor

Parameters

ply

Polyline

Definition at line 29 of file Polyline.cpp.

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

~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::PolylineWithSegmentMarker, and GeoLib::PolygonWithSegmentMarker.

Definition at line 34 of file Polyline.cpp.

{
    assert(pnt_id < _ply_pnts.size());
    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(), mergeGeometries(), FileIO::SwmmInterface::readLinksAsPolylines(), FileIO::Legacy::readPolylinePointVector(), GeoLib::rotatePolygonToXY(), and GeoLib::Polygon::splitPolygonAtPoint().

begin()

SegmentIterator GeoLib::Polyline::begin ( ) const

inline

Definition at line 189 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 299 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(), and main().

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 187 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 194 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 353 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 =
            Eigen::Map<Eigen::Vector3d const>(getPoint(k)->getCoords());
        auto const b =
            Eigen::Map<Eigen::Vector3d const>(getPoint(k + 1)->getCoords());
        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::calcProjPntToLineAndDists(), getNumberOfSegments(), getPoint(), and MathLib::LinAlg::norm().

Referenced by MeshGeoToolsLib::MeshNodesAlongPolyline::MeshNodesAlongPolyline().

getGeoType()

GEOTYPE GeoLib::Polyline::getGeoType ( ) const

inlineoverridevirtual

return a geometry type

Implements GeoLib::GeoObject.

Definition at line 107 of file Polyline.h.

{ return GEOTYPE::POLYLINE; }

References GeoLib::POLYLINE.

getLocationOfPoint()

Location GeoLib::Polyline::getLocationOfPoint ( std::size_t  k, MathLib::Point3d const &  pnt  ) const

protected

2D method - ignores z coordinate. It calculates the location of the point relative to the k-th line segment of the polyline. (literature reference: Computational Geometry and Computer Graphics in C++; Michael J. Laszlo)

Parameters

k	the number of line segment
pnt	the point

Returns

a value of enum LOCATION

Definition at line 312 of file Polyline.cpp.

{
    assert(k < _ply_pnt_ids.size() - 1);
 
    GeoLib::Point const& source(*(_ply_pnts[_ply_pnt_ids[k]]));
    GeoLib::Point const& dest(*(_ply_pnts[_ply_pnt_ids[k + 1]]));
    long double a[2] = {dest[0] - source[0], dest[1] - source[1]};  // vector
    long double b[2] = {pnt[0] - source[0], pnt[1] - source[1]};    // vector
 
    long double det_2x2(a[0] * b[1] - a[1] * b[0]);
 
    if (det_2x2 > std::numeric_limits<double>::epsilon())
    {
        return Location::LEFT;
    }
    if (std::numeric_limits<double>::epsilon() < std::abs(det_2x2))
    {
        return Location::RIGHT;
    }
    if (a[0] * b[0] < 0.0 || a[1] * b[1] < 0.0)
    {
        return Location::BEHIND;
    }
    if (a[0] * a[0] + a[1] * a[1] < b[0] * b[0] + b[1] * b[1])
    {
        return Location::BEYOND;
    }
    if (MathLib::sqrDist(pnt, *_ply_pnts[_ply_pnt_ids[k]]) <
        pow(std::numeric_limits<double>::epsilon(), 2))
    {
        return Location::SOURCE;
    }
    if (MathLib::sqrDist(pnt, *_ply_pnts[_ply_pnt_ids[k + 1]]) <
        std::sqrt(std::numeric_limits<double>::epsilon()))
    {
        return Location::DESTINATION;
    }
    return Location::BETWEEN;
}

References _ply_pnt_ids, _ply_pnts, GeoLib::BEHIND, GeoLib::BETWEEN, GeoLib::BEYOND, GeoLib::DESTINATION, GeoLib::LEFT, GeoLib::RIGHT, GeoLib::SOURCE, and MathLib::sqrDist().

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

getNumberOfPoints()

std::size_t GeoLib::Polyline::getNumberOfPoints

(

)

const

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

Definition at line 99 of file Polyline.cpp.

{
    return _ply_pnt_ids.size();
}

References _ply_pnt_ids.

Referenced by 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(), GeoLib::GEOObjects::mergePolylines(), GeoLib::operator==(), GeoLib::rotatePolygonToXY(), and LinearEditDialog::setupDialog().

getNumberOfSegments()

std::size_t GeoLib::Polyline::getNumberOfSegments

(

)

const

Definition at line 104 of file Polyline.cpp.

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

References _ply_pnt_ids.

Referenced by 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 176 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(), GeoLib::Polygon::getEdgeType(), isCoplanar(), GeoLib::Polygon::isPartOfPolylineInPolygon(), GeoLib::Polygon::isPntInPolygon(), LinearEditDialog::on_comboBox_currentIndexChanged(), and GeoLib::rotatePolygonToXY().

getPointID()

std::size_t GeoLib::Polyline::getPointID

(

std::size_t

i

)

const

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

Definition at line 150 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(), mergeGeometries(), GeoLib::GEOObjects::mergePolylines(), GeoLib::operator==(), FileIO::GMSH::GMSHPolygonTree::writeLineLoop(), and FileIO::GMSH::GMSHPolygonTree::writeSubPolygonsAsLineConstraints().

getPointsVec()

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

(

)

const

Definition at line 182 of file Polyline.cpp.

{
    return _ply_pnts;
}

References _ply_pnts.

Referenced by GeoLib::EarClippingTriangulation::EarClippingTriangulation(), FileIO::createSurface(), FileIO::createSurfaceWithEarClipping(), MeshGeoToolsLib::markNodesOutSideOfPolygon(), and GeoLib::Polygon::splitPolygonAtIntersection().

getSegment() [1/2]

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

private

Definition at line 163 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().

getSegment() [2/2]

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

private

Definition at line 156 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::PolylineWithSegmentMarker, and GeoLib::PolygonWithSegmentMarker.

Definition at line 51 of file Polyline.cpp.

{
    assert(pnt_id < _ply_pnts.size());
    assert(pos <= _ply_pnt_ids.size());
 
    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 109 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(), MeshGeoToolsLib::BoundaryElementsAlongPolyline::modifyEdgeNodeOrdering(), and FileIO::FEFLOWMeshInterface::setMaterialIDs().

isCoplanar()

bool GeoLib::Polyline::isCoplanar

(

)

const

returns true if the polyline is coplanar

Definition at line 119 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().

Referenced by main().

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 144 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

removePoint()

void GeoLib::Polyline::removePoint ( std::size_t  pos )

virtual

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 87 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.

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 170 of file Polyline.cpp.

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

References _ply_pnt_ids.

Friends And Related Function Documentation

Polygon

friend class Polygon

friend

Definition at line 92 of file Polyline.h.

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

Member Data Documentation

_ply_pnt_ids

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

protected

position of pointers to the geometric points

Definition at line 227 of file Polyline.h.

Referenced by addPoint(), GeoLib::Polygon::ensureCCWOrientation(), getLocationOfPoint(), getNumberOfPoints(), getNumberOfSegments(), getPoint(), getPointID(), getSegment(), insertPoint(), isClosed(), isCoplanar(), isPointIDInPolyline(), removePoint(), 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 225 of file Polyline.h.

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

---

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

• GeoLib/Polyline.h
• GeoLib/Polyline.cpp