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

Polygon() [1/2]

inet::Polygon::Polygon ( )

inline

{}

Polygon() [2/2]

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

computeIntersection()

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;
}

computeSize()

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;
}

getEdgeOutwardNormalVector()

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

protected

{
    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);
}

Referenced by computeIntersection().

getNormalUnitVector()

Coord inet::Polygon::getNormalUnitVector

(

)

const

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

Referenced by computeIntersection(), and getEdgeOutwardNormalVector().

getNormalVector()

Coord inet::Polygon::getNormalVector

(

)

const

{
    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;
}

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

getPoints()

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

inline

{ return points; }

Referenced by inet::Prism::computeBoundingBoxSize(), inet::Prism::computeOutwardNormalVector(), inet::Prism::computeVisibleFaces(), inet::Prism::genereateFaces(), inet::Prism::Prism(), inet::visualizer::PhysicalEnvironmentOsgVisualizer::refreshDisplay(), and inet::Prism::setBase().

isNil()

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; }

isUnspecified()

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

NIL

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

static

points

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