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 39 of file Polyline.h.

#include <Polyline.h>

Inheritance diagram for GeoLib::Polyline:

[legend]

Collaboration diagram for GeoLib::Polyline:

[legend]

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

28: _ply_pnts(pnt_vec) {}

GeoLib::Polyline::_ply_pnts

const std::vector< Point * > & _ply_pnts

Definition Polyline.h:211

Referenced by constructPolylineFromSegments().

◆ Polyline() [2/2]

GeoLib::Polyline::Polyline ( const Polyline & ply )

Copy constructor

Parameters

ply Polyline

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

Definition at line 35 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::Legacy::readPolylinePointVector(), and GeoLib::Polygon::splitPolygonAtPoint().

◆ begin()

SegmentIterator GeoLib::Polyline::begin ( ) const

inline

Definition at line 188 of file Polyline.h.

188{ 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 302 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 190 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 190 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 315 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().

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

◆ getGeoType()

GEOTYPE GeoLib::Polyline::getGeoType ( ) const

inlineoverridevirtual

return a geometry type

Implements GeoLib::GeoObject.

Definition at line 105 of file Polyline.h.

105{ return GEOTYPE::POLYLINE; }

GeoLib::GEOTYPE::POLYLINE

@ 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 109 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(), MeshGeoToolsLib::markNodesOutSideOfPolygon(), GeoLib::markUsedPoints(), GeoLib::GEOObjects::mergePolylines(), GeoLib::operator==(), GeoLib::resetPointIDs(), GeoLib::rotatePolygonPointsToXY(), and LinearEditDialog::setupDialog().

◆ getNumberOfSegments()

std::size_t GeoLib::Polyline::getNumberOfSegments ( ) const

Definition at line 114 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 179 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(), LinearEditDialog::on_comboBox_currentIndexChanged(), 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 160 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::resetPointIDs(), FileIO::GMSH::GMSHPolygonTree::writeLineLoop(), and FileIO::GMSH::GMSHPolygonTree::writeSubPolygonsAsLineConstraints().

◆ getPointsVec()

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

Definition at line 185 of file Polyline.cpp.

{
    return _ply_pnts;
}

References _ply_pnts.

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

◆ getPolylinePointIDs()

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

inlineprotected

Definition at line 215 of file Polyline.h.

    {
        return _ply_pnt_ids;
    }

References _ply_pnt_ids.

◆ getSegment()

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

private

Definition at line 166 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 55 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 119 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 129 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 154 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 )

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 97 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 356 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 173 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 90 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

private

position of pointers to the geometric points

Definition at line 222 of file Polyline.h.

Referenced by 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 211 of file Polyline.h.

Referenced by addPoint(), 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

Detailed Description

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

◆ Polyline() [1/2]

◆ Polyline() [2/2]

◆ ~Polyline()

Member Function Documentation

◆ addPoint()

◆ begin()

◆ closePolyline()

◆ constructPolylineFromSegments()

◆ end()

◆ getDistanceAlongPolyline()

◆ getGeoType()

◆ getNumberOfPoints()

◆ getNumberOfSegments()

◆ getPoint()

◆ getPointID()

◆ getPointsVec()

◆ getPolylinePointIDs()

◆ getSegment()

◆ insertPoint()

◆ isClosed()

◆ isCoplanar()

◆ isPointIDInPolyline()

◆ operator=()

◆ removePoint()

◆ reverseOrientation()

◆ setPointID()

Friends And Related Symbol Documentation

◆ Polygon

Member Data Documentation

◆ _ply_pnt_ids

◆ _ply_pnts