GeoLib::Polygon Class Reference

Detailed Description

A polygon is a (closed) polyline. Thus class Polygon is derived from class Polyline.

Definition at line 19 of file Polygon.h.

#include <Polygon.h>

Inheritance diagram for GeoLib::Polygon:

Collaboration diagram for GeoLib::Polygon:

Public Member Functions
	Polygon (const Polyline &ply, bool init=true)
	Polygon (Polygon const &other)
Polygon &	operator= (Polygon const &rhs)=delete
	~Polygon () override
bool	initialise ()
bool	isPntInPolygon (MathLib::Point3d const &pnt) const
bool	containsSegment (GeoLib::LineSegment const &segment) const
bool	isPolylineInPolygon (const Polyline &ply) const
bool	isPartOfPolylineInPolygon (const Polyline &ply) const
bool	getNextIntersectionPointPolygonLine (GeoLib::LineSegment const &seg, GeoLib::Point &intersection_pnt, std::size_t &seg_num) const
std::list< Polygon * > const &	computeListOfSimplePolygons ()
Public Member Functions inherited from GeoLib::Polyline
	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

Private Member Functions
void	ensureCCWOrientation ()
void	splitPolygonAtIntersection (const std::list< Polygon * >::const_iterator &polygon_it)
void	splitPolygonAtPoint (const std::list< Polygon * >::iterator &polygon_it)

Private Attributes
std::list< Polygon * >	_simple_polygon_list
AABB	_aabb

Friends
bool	operator== (Polygon const &lhs, Polygon const &rhs)

Additional Inherited Members
Static Public Member Functions inherited from GeoLib::Polyline
static Polyline *	constructPolylineFromSegments (const std::vector< Polyline * > &ply_vec, double prox=0.0)
Protected Member Functions inherited from GeoLib::Polyline
void	reverseOrientation ()
std::vector< std::size_t > const &	getPolylinePointIDs () const
Protected Attributes inherited from GeoLib::Polyline
const std::vector< Point * > &	_ply_pnts

Constructor & Destructor Documentation

Polygon() [1/2]

GeoLib::Polygon::Polygon ( const Polyline & ply, bool init = true )

explicit

constructor checks if the given polyline is closed, and assures that the orientation is clock wise.

Parameters

ply	closed Polyline
init	if true, check if polyline is closed, calculate bounding box

Definition at line 124 of file Polygon.cpp.

    : Polyline(ply), _aabb(ply.getPointsVec(), ply.getPolylinePointIDs())
{
    if (init)
    {
        initialise();
    }
    _simple_polygon_list.push_back(this);
}

References GeoLib::Polyline::Polyline(), _aabb, _simple_polygon_list, GeoLib::Polyline::getPointsVec(), GeoLib::Polyline::getPolylinePointIDs(), and initialise().

Referenced by Polygon(), GeoLib::PolygonWithSegmentMarker::PolygonWithSegmentMarker(), operator=(), operator==, and splitPolygonAtPoint().

Polygon() [2/2]

GeoLib::Polygon::Polygon

(

Polygon const &

other

)

Definition at line 134 of file Polygon.cpp.

                                     : Polyline(other), _aabb(other._aabb)
{
    _simple_polygon_list.push_back(this);
    auto sub_polygon_it(other._simple_polygon_list.begin());
    for (sub_polygon_it++;  // the first entry is the polygon itself, skip the
                            // entry
         sub_polygon_it != other._simple_polygon_list.end();
         ++sub_polygon_it)
    {
        _simple_polygon_list.emplace_back(new Polygon(*(*sub_polygon_it)));
    }
}

References Polygon(), GeoLib::Polyline::Polyline(), _aabb, _simple_polygon_list, and GeoLib::Polyline::Polygon.

~Polygon()

GeoLib::Polygon::~Polygon ( )

override

Definition at line 147 of file Polygon.cpp.

{
    // remove polygons from list
    for (auto& polygon : _simple_polygon_list)
    {
        // the first entry of the list can be a pointer the object itself
        if (polygon != this)
        {
            delete polygon;
        }
    }
}

References _simple_polygon_list.

Member Function Documentation

computeListOfSimplePolygons()

std::list< Polygon * > const & GeoLib::Polygon::computeListOfSimplePolygons

(

)

Subdivides a self-intersecting polygon into a list of non-intersecting shapes.

Definition at line 682 of file Polygon.cpp.

{
    splitPolygonAtPoint(_simple_polygon_list.begin());
    splitPolygonAtIntersection(_simple_polygon_list.begin());
 
    for (auto polygon : _simple_polygon_list)
    {
        polygon->initialise();
    }
    return _simple_polygon_list;
}

References _simple_polygon_list, splitPolygonAtIntersection(), and splitPolygonAtPoint().

containsSegment()

bool GeoLib::Polygon::containsSegment

(

GeoLib::LineSegment const &

segment

)

const

Checks if the straight line segment is contained within the polygon.

Parameters

segment

the straight line segment that is checked with

Returns

true if the straight line segment is within the polygon, else false

Definition at line 250 of file Polygon.cpp.

{
    std::vector<GeoLib::Point> s(getAllIntersectionPoints(*this, segment));
 
    GeoLib::Point const& a{segment.getBeginPoint()};
    GeoLib::Point const& b{segment.getEndPoint()};
    // no intersections -> check if at least one point of segment is in polygon
    if (s.empty())
    {
        return (isPntInPolygon(a));
    }
 
    const double tol(std::numeric_limits<float>::epsilon());
 
    // one intersection, intersection in line segment end point
    if (s.size() == 1)
    {
        const double sqr_dist_as(MathLib::sqrDist(a, s[0]));
        if (sqr_dist_as < tol)
        {
            return (isPntInPolygon(b));
        }
 
        const double sqr_dist_bs(MathLib::sqrDist(b, s[0]));
        if (sqr_dist_bs < tol)
        {
            return (isPntInPolygon(a));
        }
    }
 
    // Sorting the intersection with respect to the distance to the point a.
    // This induces a partition of the line segment into sub segments.
    std::sort(s.begin(), s.end(),
              [&a](GeoLib::Point const& p0, GeoLib::Point const& p1)
              { return MathLib::sqrDist(a, p0) < MathLib::sqrDist(a, p1); });
 
    // remove sub segments with almost zero length
    for (std::size_t k(0); k < s.size() - 1;)
    {
        if (MathLib::sqrDist(s[k], s[k + 1]) < tol)
        {
            s.erase(s.begin() + k + 1);
        }
        else
        {
            k++;
        }
    }
 
    // Check if all sub segments are within the polygon.
    if (!isPntInPolygon(GeoLib::Point(0.5 * (a[0] + s[0][0]),
                                      0.5 * (a[1] + s[0][1]),
                                      0.5 * (a[2] + s[0][2]))))
    {
        return false;
    }
    const std::size_t n_sub_segs(s.size() - 1);
    for (std::size_t k(0); k < n_sub_segs; k++)
    {
        if (!isPntInPolygon(GeoLib::Point(0.5 * (s[k][0] + s[k + 1][0]),
                                          0.5 * (s[k][1] + s[k + 1][1]),
                                          0.5 * (s[k][2] + s[k + 1][2]))))
        {
            return false;
        }
    }
    return isPntInPolygon(GeoLib::Point(0.5 * (s[0][0] + b[0]),
                                        0.5 * (s[0][1] + b[1]),
                                        0.5 * (s[0][2] + b[2])));
}

References GeoLib::getAllIntersectionPoints(), GeoLib::LineSegment::getBeginPoint(), GeoLib::LineSegment::getEndPoint(), isPntInPolygon(), and MathLib::sqrDist().

ensureCCWOrientation()

void GeoLib::Polygon::ensureCCWOrientation ( )

private

Definition at line 388 of file Polygon.cpp.

{
    // *** pre processing: rotate points to xy-plan
    // *** copy points to vector - last point is identical to the first
    std::size_t n_pnts(this->getNumberOfPoints() - 1);
    std::vector<GeoLib::Point*> tmp_polygon_pnts;
    for (std::size_t k(0); k < n_pnts; k++)
    {
        tmp_polygon_pnts.push_back(new GeoLib::Point(*(this->getPoint(k))));
    }
 
    // rotate copied points into x-y-plane
    GeoLib::rotatePointsToXY(tmp_polygon_pnts);
 
    for (auto& tmp_polygon_pnt : tmp_polygon_pnts)
    {
        (*tmp_polygon_pnt)[2] =
            0.0;  // should be -= d but there are numerical errors
    }
 
    // *** get the left most upper point
    std::size_t min_x_max_y_idx(0);  // for orientation check
    for (std::size_t k(0); k < n_pnts; k++)
    {
        if ((*(tmp_polygon_pnts[k]))[0] <=
            (*(tmp_polygon_pnts[min_x_max_y_idx]))[0])
        {
            if ((*(tmp_polygon_pnts[k]))[0] <
                (*(tmp_polygon_pnts[min_x_max_y_idx]))[0])
            {
                min_x_max_y_idx = k;
            }
            else if ((*(tmp_polygon_pnts[k]))[1] >
                     (*(tmp_polygon_pnts[min_x_max_y_idx]))[1])
            {
                min_x_max_y_idx = k;
            }
        }
    }
    // *** determine orientation
    GeoLib::Orientation orient;
    if (0 < min_x_max_y_idx && min_x_max_y_idx < n_pnts - 2)
    {
        orient = GeoLib::getOrientation(*tmp_polygon_pnts[min_x_max_y_idx - 1],
                                        *tmp_polygon_pnts[min_x_max_y_idx],
                                        *tmp_polygon_pnts[min_x_max_y_idx + 1]);
    }
    else
    {
        if (0 == min_x_max_y_idx)
        {
            orient = GeoLib::getOrientation(*tmp_polygon_pnts[n_pnts - 1],
                                            *tmp_polygon_pnts[0],
                                            *tmp_polygon_pnts[1]);
        }
        else
        {
            orient = GeoLib::getOrientation(*tmp_polygon_pnts[n_pnts - 2],
                                            *tmp_polygon_pnts[n_pnts - 1],
                                            *tmp_polygon_pnts[0]);
        }
    }
 
    if (orient != GeoLib::CCW)
    {
        reverseOrientation();
    }
 
    for (std::size_t k(0); k < n_pnts; k++)
    {
        delete tmp_polygon_pnts[k];
    }
}

References GeoLib::CCW, GeoLib::Polyline::getNumberOfPoints(), GeoLib::getOrientation(), GeoLib::Polyline::getPoint(), GeoLib::Polyline::reverseOrientation(), and GeoLib::rotatePointsToXY().

Referenced by initialise().

getNextIntersectionPointPolygonLine()

bool GeoLib::Polygon::getNextIntersectionPointPolygonLine	(	GeoLib::LineSegment const &	seg,
		GeoLib::Point &	intersection_pnt,
		std::size_t &	seg_num ) const

Calculates the next intersection point between the line segment seg and the polygon starting with segment seg_num.

Parameters

seg	(input) Line segment to compute intersection.
intersection_pnt	(output) next intersection point
seg_num	(in/out) the number of the polygon segment that is intersecting

Returns

true, if there was an intersection, i.e., the intersection_pnt and seg_num contains new valid values

Definition at line 354 of file Polygon.cpp.

{
    if (_simple_polygon_list.size() == 1)
    {
        for (auto seg_it(begin() + seg_num); seg_it != end(); ++seg_it)
        {
            if (GeoLib::lineSegmentIntersect(*seg_it, seg, intersection_pnt))
            {
                seg_num = seg_it.getSegmentNumber();
                return true;
            }
        }
    }
    else
    {
        for (auto const* polygon : _simple_polygon_list)
        {
            for (auto seg_it(polygon->begin()); seg_it != polygon->end();
                 ++seg_it)
            {
                if (GeoLib::lineSegmentIntersect(*seg_it, seg,
                                                 intersection_pnt))
                {
                    seg_num = seg_it.getSegmentNumber();
                    return true;
                }
            }
        }
    }
    return false;
}

References _simple_polygon_list, GeoLib::Polyline::begin(), GeoLib::Polyline::end(), and GeoLib::lineSegmentIntersect().

initialise()

bool GeoLib::Polygon::initialise

(

)

Definition at line 160 of file Polygon.cpp.

{
    if (this->isClosed())
    {
        ensureCCWOrientation();
        return true;
    }
    WARN("Polygon::initialise(): base polyline is not closed.");
    return false;
}

References ensureCCWOrientation(), GeoLib::Polyline::isClosed(), and WARN().

Referenced by Polygon().

isPartOfPolylineInPolygon()

bool GeoLib::Polygon::isPartOfPolylineInPolygon

(

const Polyline &

ply

)

const

Method checks first if at least one (end!) point of a line segment of the polyline is inside of the polygon. If this test fails each line segment of the polyline will be tested against each polygon segment for intersection.

Parameters

ply	the polyline that should be checked

Returns

true if a part of the polyline is within the polygon

Definition at line 328 of file Polygon.cpp.

{
    const std::size_t ply_size(ply.getNumberOfPoints());
    // check points
    for (std::size_t k(0); k < ply_size; k++)
    {
        if (isPntInPolygon(*(ply.getPoint(k))))
        {
            return true;
        }
    }
 
    auto polygon_segment_intersects_line = [&](auto const& polygon_seg)
    {
        GeoLib::Point s;
        return std::any_of(ply.begin(), ply.end(),
                           [&polygon_seg, &s](auto const& polyline_seg) {
                               return GeoLib::lineSegmentIntersect(
                                   polyline_seg, polygon_seg, s);
                           });
    };
 
    return std::any_of(std::cbegin(*this), std::cend(*this),
                       polygon_segment_intersects_line);
}

References GeoLib::Polyline::Polyline(), GeoLib::Polyline::begin(), GeoLib::Polyline::end(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPoint(), and isPntInPolygon().

isPntInPolygon()

bool GeoLib::Polygon::isPntInPolygon

(

MathLib::Point3d const &

pnt

)

const

Method checks if the given point is inside the polygon. The method requires that the polygon has clock wise orientation.

Parameters

pnt

the Point

Returns

if point is inside the polygon true, else false

Definition at line 194 of file Polygon.cpp.

{
    auto const [min_aabb_pnt, max_aabb_pnt] = _aabb.getMinMaxPoints();
 
    if (pnt[0] < min_aabb_pnt[0] || max_aabb_pnt[0] < pnt[0] ||
        pnt[1] < min_aabb_pnt[1] || max_aabb_pnt[1] < pnt[1])
    {
        return false;
    }
 
    if (_simple_polygon_list.size() == 1)
    {
        std::size_t n_intersections(0);
        const std::size_t n_nodes(getNumberOfPoints() - 1);
        for (std::size_t k(0); k < n_nodes; k++)
        {
            if (((*(getPoint(k)))[1] <= pnt[1] &&
                 pnt[1] <= (*(getPoint(k + 1)))[1]) ||
                ((*(getPoint(k + 1)))[1] <= pnt[1] &&
                 pnt[1] <= (*(getPoint(k)))[1]))
            {
                switch (getEdgeType(*getPoint(k), *getPoint(k + 1), pnt))
                {
                    case EdgeType::TOUCHING:
                        return true;
                    case EdgeType::CROSSING:
                        n_intersections++;
                        break;
                    case EdgeType::INESSENTIAL:
                        break;
                    default:
                        // do nothing
                        ;
                }
            }
        }
        if (n_intersections % 2 == 1)
        {
            return true;
        }
    }
    else
    {
        for (auto it(_simple_polygon_list.begin()++);
             it != _simple_polygon_list.end();
             ++it)
        {
            if ((*it)->isPntInPolygon(pnt))
            {
                return true;
            }
        }
    }
    return false;
}

References _aabb, _simple_polygon_list, GeoLib::CROSSING, GeoLib::getEdgeType(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPoint(), GeoLib::INESSENTIAL, and GeoLib::TOUCHING.

Referenced by containsSegment(), isPartOfPolylineInPolygon(), main(), MeshGeoToolsLib::markNodesOutSideOfPolygon(), and FileIO::FEFLOWMeshInterface::setMaterialIDs().

isPolylineInPolygon()

bool GeoLib::Polygon::isPolylineInPolygon

(

const Polyline &

ply

)

const

Method checks if all points of the polyline ply are inside of the polygon.

Parameters

ply	the polyline that should be checked

Definition at line 321 of file Polygon.cpp.

{
    return std::all_of(ply.begin(), ply.end(),
                       [this](auto const& segment)
                       { return containsSegment(segment); });
}

References GeoLib::Polyline::Polyline(), GeoLib::Polyline::begin(), and GeoLib::Polyline::end().

operator=()

Polygon & GeoLib::Polygon::operator= ( Polygon const & rhs )

delete

References Polygon(), and GeoLib::Polyline::Polyline().

splitPolygonAtIntersection()

void GeoLib::Polygon::splitPolygonAtIntersection ( const std::list< Polygon * >::const_iterator & polygon_it )

private

Definition at line 462 of file Polygon.cpp.

{
    GeoLib::Polyline::SegmentIterator seg_it0((*polygon_it)->begin());
    GeoLib::Polyline::SegmentIterator seg_it1((*polygon_it)->begin());
    GeoLib::Point intersection_pnt;
    if (!GeoLib::lineSegmentsIntersect(*polygon_it, seg_it0, seg_it1,
                                       intersection_pnt))
    {
        return;
    }
 
    std::size_t idx0(seg_it0.getSegmentNumber());
    std::size_t idx1(seg_it1.getSegmentNumber());
    // adding intersection point to pnt_vec
    std::size_t const intersection_pnt_id(_ply_pnts.size());
    const_cast<std::vector<Point*>&>(_ply_pnts).push_back(
        new GeoLib::Point(intersection_pnt));
 
    // split Polygon
    if (idx0 > idx1)
    {
        std::swap(idx0, idx1);
    }
 
    GeoLib::Polyline polyline0{(*polygon_it)->getPointsVec()};
    for (std::size_t k(0); k <= idx0; k++)
    {
        polyline0.addPoint((*polygon_it)->getPointID(k));
    }
    polyline0.addPoint(intersection_pnt_id);
    for (std::size_t k(idx1 + 1); k < (*polygon_it)->getNumberOfPoints(); k++)
    {
        polyline0.addPoint((*polygon_it)->getPointID(k));
    }
 
    GeoLib::Polyline polyline1{(*polygon_it)->getPointsVec()};
    polyline1.addPoint(intersection_pnt_id);
    for (std::size_t k(idx0 + 1); k <= idx1; k++)
    {
        polyline1.addPoint((*polygon_it)->getPointID(k));
    }
    polyline1.addPoint(intersection_pnt_id);
 
    // remove the polygon except the first
    if (*polygon_it != this)
    {
        delete *polygon_it;
    }
    // erase polygon_it and add two new polylines
    auto polygon1_it = _simple_polygon_list.insert(
        _simple_polygon_list.erase(polygon_it), new GeoLib::Polygon(polyline1));
    auto polygon0_it = _simple_polygon_list.insert(
        polygon1_it, new GeoLib::Polygon(polyline0));
 
    splitPolygonAtIntersection(polygon0_it);
    splitPolygonAtIntersection(polygon1_it);
}

References GeoLib::Polyline::_ply_pnts, _simple_polygon_list, GeoLib::Polyline::addPoint(), GeoLib::Polyline::SegmentIterator::getSegmentNumber(), GeoLib::lineSegmentsIntersect(), and splitPolygonAtIntersection().

Referenced by computeListOfSimplePolygons(), and splitPolygonAtIntersection().

splitPolygonAtPoint()

void GeoLib::Polygon::splitPolygonAtPoint ( const std::list< Polygon * >::iterator & polygon_it )

private

Definition at line 521 of file Polygon.cpp.

{
    std::size_t const n((*polygon_it)->getNumberOfPoints() - 1);
    std::vector<std::size_t> id_vec(n);
    std::vector<std::size_t> perm(n);
    for (std::size_t k(0); k < n; k++)
    {
        id_vec[k] = (*polygon_it)->getPointID(k);
        perm[k] = k;
    }
 
    BaseLib::quicksort(id_vec, 0, n, perm);
 
    for (std::size_t k(0); k < n - 1; k++)
    {
        if (id_vec[k] == id_vec[k + 1])
        {
            std::size_t idx0 = perm[k];
            std::size_t idx1 = perm[k + 1];
 
            if (idx0 > idx1)
            {
                std::swap(idx0, idx1);
            }
 
            // create two closed polylines
            GeoLib::Polyline polyline0{*(*polygon_it)};
            for (std::size_t j(0); j <= idx0; j++)
            {
                polyline0.addPoint((*polygon_it)->getPointID(j));
            }
            for (std::size_t j(idx1 + 1);
                 j < (*polygon_it)->getNumberOfPoints();
                 j++)
            {
                polyline0.addPoint((*polygon_it)->getPointID(j));
            }
 
            GeoLib::Polyline polyline1{*(*polygon_it)};
            for (std::size_t j(idx0); j <= idx1; j++)
            {
                polyline1.addPoint((*polygon_it)->getPointID(j));
            }
 
            // remove the polygon except the first
            if (*polygon_it != this)
            {
                delete *polygon_it;
            }
            // erase polygon_it and add two new polygons
            auto polygon1_it = _simple_polygon_list.insert(
                _simple_polygon_list.erase(polygon_it), new Polygon(polyline1));
            auto polygon0_it = _simple_polygon_list.insert(
                polygon1_it, new Polygon(polyline0));
 
            splitPolygonAtPoint(polygon0_it);
            splitPolygonAtPoint(polygon1_it);
 
            return;
        }
    }
}

References Polygon(), _simple_polygon_list, GeoLib::Polyline::addPoint(), GeoLib::Polyline::Polygon, BaseLib::quicksort(), and splitPolygonAtPoint().

Referenced by computeListOfSimplePolygons(), and splitPolygonAtPoint().

Friends And Related Symbol Documentation

operator==

bool operator== ( Polygon const & lhs, Polygon const & rhs )

friend

comparison operator for polygons

Parameters

lhs	the first polygon
rhs	the second polygon

Returns

true, if the polygons describe the same geometrical object

Definition at line 585 of file Polygon.cpp.

{
    if (lhs.getNumberOfPoints() != rhs.getNumberOfPoints())
    {
        return false;
    }
 
    const std::size_t n(lhs.getNumberOfPoints());
    const std::size_t start_pnt(lhs.getPointID(0));
 
    // search start point of first polygon in second polygon
    bool nfound(true);
    std::size_t k(0);
    for (; k < n - 1 && nfound; k++)
    {
        if (start_pnt == rhs.getPointID(k))
        {
            nfound = false;
            break;
        }
    }
 
    // case: start point not found in second polygon
    if (nfound)
    {
        return false;
    }
 
    // *** determine direction
    // opposite direction
    if (k == n - 2)
    {
        for (k = 1; k < n - 1; k++)
        {
            if (lhs.getPointID(k) != rhs.getPointID(n - 1 - k))
            {
                return false;
            }
        }
        return true;
    }
 
    // same direction - start point of first polygon at arbitrary position in
    // second polygon
    if (lhs.getPointID(1) == rhs.getPointID(k + 1))
    {
        std::size_t j(k + 2);
        for (; j < n - 1; j++)
        {
            if (lhs.getPointID(j - k) != rhs.getPointID(j))
            {
                return false;
            }
        }
        j = 0;  // new start point at second polygon
        for (; j < k + 1; j++)
        {
            if (lhs.getPointID(n - (k + 2) + j + 1) != rhs.getPointID(j))
            {
                return false;
            }
        }
        return true;
    }
    // opposite direction with start point of first polygon at arbitrary
    // position
    // *** ATTENTION
    WARN(
        "operator==(Polygon const& lhs, Polygon const& rhs) - not tested case "
        "(implementation is probably buggy) - please contact "
        "thomas.fischer@ufz.de mentioning the problem.");
    // in second polygon
    if (lhs.getPointID(1) == rhs.getPointID(k - 1))
    {
        std::size_t j(k - 2);
        for (; j > 0; j--)
        {
            if (lhs.getPointID(k - 2 - j) != rhs.getPointID(j))
            {
                return false;
            }
        }
        // new start point at second polygon - the point n-1 of a polygon is
        // equal to the first point of the polygon (for this reason: n-2)
        j = n - 2;
        for (; j > k - 1; j--)
        {
            if (lhs.getPointID(n - 2 + j + k - 2) != rhs.getPointID(j))
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

References Polygon(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointID(), and WARN().

Member Data Documentation

_aabb

AABB GeoLib::Polygon::_aabb

private

Definition at line 97 of file Polygon.h.

Referenced by Polygon(), Polygon(), and isPntInPolygon().

_simple_polygon_list

std::list<Polygon*> GeoLib::Polygon::_simple_polygon_list

private

Definition at line 96 of file Polygon.h.

Referenced by Polygon(), Polygon(), ~Polygon(), computeListOfSimplePolygons(), getNextIntersectionPointPolygonLine(), isPntInPolygon(), splitPolygonAtIntersection(), and splitPolygonAtPoint().

---

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

• Polygon.h
• Polygon.cpp