inet::Polygon Class Reference

#include <Polygon.h>

Inheritance diagram for inet::Polygon:

Public Member Functions
	Polygon ()
	Polygon (const std::vector< Coord > &points)
const std::vector< Coord > &	getPoints () const
virtual bool	isNil () const override
	Returns true if this geometric object is the same as the unspecified singleton instance of this type. More...
virtual bool	isUnspecified () const override
	Returns true if this geometric object is not completely specified. More...
virtual Coord	computeSize () const
Coord	getNormalUnitVector () const
Coord	getNormalVector () const
virtual bool	computeIntersection (const LineSegment &lineSegment, Coord &intersection1, Coord &intersection2, Coord &normal1, Coord &normal2) const
Public Member Functions inherited from inet::GeometricObjectBase
	GeometricObjectBase ()
virtual	~GeometricObjectBase ()

Static Public Attributes
static const Polygon	NIL = Polygon()

Protected Member Functions
Coord	getEdgeOutwardNormalVector (const Coord &edgeP1, const Coord &edgeP2) const

Protected Attributes
std::vector< Coord >	points

Constructor & Destructor Documentation

inet::Polygon::Polygon ( )

inline

{}

inet::Polygon::Polygon

(

const std::vector< Coord > &

points

)

{
    if (points.size() < 3)
        throw cRuntimeError("A Euclidean polygon has at least three points");
    this->points = points;
}

Member Function Documentation

bool inet::Polygon::computeIntersection ( const LineSegment &  lineSegment, Coord &  intersection1, Coord &  intersection2, Coord &  normal1, Coord &  normal2  ) const

virtual

{
    // Note: based on http://geomalgorithms.com/a13-_intersect-4.html
    Coord p0 = lineSegment.getPoint1();
    Coord p1 = lineSegment.getPoint2();
    if (p0 == p1)
    {
        normal1 = normal2 = Coord::NIL;
        return false;
    }
    Coord segmentDirection = p1 - p0;
    Coord polygonNormal = getNormalUnitVector();
    // The segment is not in the polygon's plane
    // The length of the intersection segment will be 0
    if (polygonNormal * segmentDirection != 0 || (p0 - points[0]) * polygonNormal != 0)
        return false;
    double tE = 0;
    double tL = 1;
    unsigned int pointSize = points.size();
    for (unsigned int i = 0; i < pointSize; i++)
    {
        Coord normalVec = getEdgeOutwardNormalVector(points[i], points[(i+1) % pointSize]);
        double N = normalVec * (points[i] - p0);
        double D = normalVec * segmentDirection;
        if (D < 0)
        {
            double t = N / D;
            if (t > tE)
            {
                tE = t;
                normal1 = normalVec;
                if (tE > tL)
                    return false;
            }
        }
        else if (D > 0)
        {
            double t = N / D;
            if (t < tL)
            {
                tL = t;
                normal2 = normalVec;
                if (tL < tE)
                    return false;
            }
        }
        else
        {
            if (N < 0)
                return false;
        }
    }
    if (tE == 0)
        normal1 = Coord::NIL;
    if (tL == 1)
        normal2 = Coord::NIL;
    intersection1 = p0 + segmentDirection * tE;
    intersection2 = p0 + segmentDirection * tL;
    if (intersection1 == intersection2)
    {
        normal1 = normal2 = Coord::NIL;
        return false;
    }
    return true;
}

Coord inet::Polygon::computeSize ( ) const

virtual

{
    Coord min;
    Coord max;
    for (const auto & elem : points) {
        min = min.min(elem);
        max = max.max(elem);
    }
    return max - min;
}

Coord inet::Polygon::getEdgeOutwardNormalVector ( const Coord &  edgeP1, const Coord &  edgeP2  ) const

protected

Referenced by computeIntersection().

{
    Coord polygonNormal = getNormalUnitVector();
    Coord vectorA = edgeP1 - polygonNormal;
    Coord vectorB = edgeP2 - polygonNormal;
    Coord vectorC(vectorA.y * vectorB.z - vectorA.z * vectorB.y,
                 vectorA.z * vectorB.x - vectorA.x * vectorB.z,
                 vectorA.x * vectorB.y - vectorA.y * vectorB.x);
    // The projection of a vector image v onto a plane with unit normal vector n is: p = v - (v*n)*n.
    return vectorC - polygonNormal * (vectorC * polygonNormal);
}

Coord inet::Polygon::getNormalUnitVector

(

)

const

Referenced by computeIntersection(), inet::Prism::genereateFaces(), and getEdgeOutwardNormalVector().

{
    Coord normalVec = getNormalVector();
    return normalVec / normalVec.length();
}

Coord inet::Polygon::getNormalVector

(

)

const

Referenced by inet::Prism::computeOutwardNormalVector(), and getNormalUnitVector().

{
    Coord point1 = points[0];
    Coord point2 = points[1];
    Coord point3 = points[2];
    Coord vectorA = point2 - point1;
    Coord vectorB = point3 - point1;
    Coord vectorC(vectorA.y * vectorB.z - vectorA.z * vectorB.y,
                 vectorA.z * vectorB.x - vectorA.x * vectorB.z,
                 vectorA.x * vectorB.y - vectorA.y * vectorB.x);
    return vectorC;
}

const std::vector<Coord>& inet::Polygon::getPoints ( ) const

inline

Referenced by inet::Prism::computeBoundingBoxSize(), inet::Prism::computeIntersection(), inet::Prism::computeOutwardNormalVector(), inet::Prism::computeVisibleFaces(), inet::Prism::genereateFaces(), inet::Prism::Prism(), and inet::Prism::setBase().

{ return points; }

virtual bool inet::Polygon::isNil ( ) const

inlineoverridevirtual

Returns true if this geometric object is the same as the unspecified singleton instance of this type.

Implements inet::GeometricObjectBase.

{ return this == &NIL; }

bool inet::Polygon::isUnspecified ( ) const

overridevirtual

Returns true if this geometric object is not completely specified.

Implements inet::GeometricObjectBase.

{
    for (const auto & elem : points) {
        if ((elem).isUnspecified())
            return true;
    }
    return false;
}

Member Data Documentation

const Polygon inet::Polygon::NIL = Polygon()

static

std::vector<Coord> inet::Polygon::points

protected

Referenced by computeIntersection(), computeSize(), getNormalVector(), isUnspecified(), and Polygon().

---

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

• Polygon.h
• Polygon.cc