Detailed Description

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

Definition at line 30 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 135 of file Polygon.cpp.

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

References _simple_polygon_list, and initialise().

◆ Polygon() [2/2]

GeoLib::Polygon::Polygon ( Polygon const & other )

Definition at line 145 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 _simple_polygon_list, and GeoLib::Polyline::Polygon.

◆ ~Polygon()

GeoLib::Polygon::~Polygon ( )

override

Definition at line 158 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 693 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 261 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().

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

◆ ensureCCWOrientation()

void GeoLib::Polygon::ensureCCWOrientation ( )

private

Definition at line 399 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 365 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 171 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 339 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::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 205 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::AABB::getMinMaxPoints(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPoint(), GeoLib::INESSENTIAL, and GeoLib::TOUCHING.

Referenced by containsSegment(), FileIO::GMSH::GMSHPolygonTree::insertPolyline(), isPartOfPolylineInPolygon(), 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 332 of file Polygon.cpp.

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

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

Referenced by GeoLib::SimplePolygonTree::isPolygonInside().

◆ operator=()

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

delete

◆ splitPolygonAtIntersection()

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

private

Definition at line 473 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::getPointsVec(), 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 532 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 _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 596 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;
}

Member Data Documentation

◆ _aabb

AABB GeoLib::Polygon::_aabb

private

Definition at line 108 of file Polygon.h.

Referenced by isPntInPolygon().

◆ _simple_polygon_list

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

private

Definition at line 107 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:

GeoLib/Polygon.h
GeoLib/Polygon.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Constructor & Destructor Documentation

◆ Polygon() [1/2]

◆ Polygon() [2/2]

◆ ~Polygon()

Member Function Documentation

◆ computeListOfSimplePolygons()

◆ containsSegment()

◆ ensureCCWOrientation()

◆ getNextIntersectionPointPolygonLine()

◆ initialise()

◆ isPartOfPolylineInPolygon()

◆ isPntInPolygon()

◆ isPolylineInPolygon()

◆ operator=()

◆ splitPolygonAtIntersection()

◆ splitPolygonAtPoint()

Friends And Related Symbol Documentation

◆ operator==

Member Data Documentation

◆ _aabb

◆ _simple_polygon_list