inet::PolyhedronFace Class Reference

#include <PolyhedronFace.h>

Public Types
typedef std::vector< PolyhedronEdge * >	Edges
typedef std::vector< PolyhedronPoint * >	Points

Public Member Functions
bool	isWrapped () const
void	setToWrapped ()
std::vector< PolyhedronPoint * > &	getConflictVector ()
const std::vector< PolyhedronPoint * > &	getConflictVector () const
void	computeCentroid ()
bool	isVisibleFrom (const PolyhedronPoint *point) const
PolyhedronEdge *	getEdge (unsigned int i) const
Edges &	getEdges ()
const Edges &	getEdges () const
bool	hasConflicts () const
void	addConflictPoint (PolyhedronPoint *point)
void	computeNormalVector ()
PolyhedronEdge *	findEdge (PolyhedronEdge *edge)
Coord	getNormalVector () const
Coord	getOutwardNormalVector () const
void	pushEdge (PolyhedronEdge *edge)
Coord	getCentroid () const
void	setOutwardNormalVector (const Coord &outwardNormalVector)
	PolyhedronFace (PolyhedronPoint *p1, PolyhedronPoint *p2, PolyhedronPoint *p3)
virtual	~PolyhedronFace ()

Protected Attributes
Edges	edges
Points	pConflict
Coord	outwardNormalVector
Coord	normalVector
Coord	centroid
bool	wrapped

Member Typedef Documentation

Edges

typedef std::vector<PolyhedronEdge *> inet::PolyhedronFace::Edges

Points

typedef std::vector<PolyhedronPoint *> inet::PolyhedronFace::Points

Constructor & Destructor Documentation

PolyhedronFace()

inet::PolyhedronFace::PolyhedronFace	(	PolyhedronPoint *	p1,
		PolyhedronPoint *	p2,
		PolyhedronPoint *	p3
	)

{
    // Constructor for triangular face
    outwardNormalVector = Coord::NIL;
    normalVector = Coord::NIL;
    centroid = Coord::NIL;
    wrapped = false;
    PolyhedronEdge *edge1 = new PolyhedronEdge(p1, p2, this);
    PolyhedronEdge *edge2 = new PolyhedronEdge(p2, p3, this);
    PolyhedronEdge *edge3 = new PolyhedronEdge(p3, p1, this);
    edge1->setNextEdge(edge2);
    edge2->setNextEdge(edge3);
    edge3->setNextEdge(nullptr);
    edge1->setPrevEdge(edge3);
    edge2->setPrevEdge(edge1);
    edge3->setPrevEdge(edge2);
    pushEdge(edge1);
    pushEdge(edge2);
    pushEdge(edge3);
    computeNormalVector();
}

~PolyhedronFace()

inet::PolyhedronFace::~PolyhedronFace ( )

virtual

{
    for (auto& elem : edges)
        delete elem;
}

Member Function Documentation

addConflictPoint()

void inet::PolyhedronFace::addConflictPoint ( PolyhedronPoint *  point )

inline

{ pConflict.push_back(point); }

Referenced by inet::Polyhedron::setContlictListForNewFace().

computeCentroid()

void inet::PolyhedronFace::computeCentroid

(

)

{
    centroid = Coord(0, 0, 0);
    unsigned int numberOfPoints = edges.size();
    for (Edges::const_iterator eit = edges.begin(); eit != edges.end(); eit++) {
        PolyhedronPoint *point = (*eit)->getP1();
        centroid += *point;
    }
    ASSERT(numberOfPoints != 0);
    centroid /= numberOfPoints;
}

Referenced by pushEdge().

computeNormalVector()

void inet::PolyhedronFace::computeNormalVector

(

)

{
    normalVector = edges[0]->getEdgeVector() % edges[0]->getNextEdge()->getEdgeVector();
}

Referenced by PolyhedronFace().

findEdge()

PolyhedronEdge * inet::PolyhedronFace::findEdge

(

PolyhedronEdge *

edge

)

{
    for (auto currEdge : edges)
        if (*currEdge == *edge)
            return currEdge;
    return nullptr;
}

getCentroid()

Coord inet::PolyhedronFace::getCentroid ( ) const

inline

{ return centroid; }

Referenced by inet::Polyhedron::computeOutwardNormalVector().

getConflictVector() [1/2]

std::vector<PolyhedronPoint *>& inet::PolyhedronFace::getConflictVector ( )

inline

{ return pConflict; }

Referenced by inet::Polyhedron::setContlictListForNewFace().

getConflictVector() [2/2]

const std::vector<PolyhedronPoint *>& inet::PolyhedronFace::getConflictVector ( ) const

inline

{ return pConflict; }

getEdge()

PolyhedronEdge * inet::PolyhedronFace::getEdge

(

unsigned int

i

)

const

{
    if (i >= edges.size())
        throw cRuntimeError("Out of range with index = %d", i);
    return edges.at(i);
}

Referenced by inet::Polyhedron::computeOutwardNormalVector(), and isVisibleFrom().

getEdges() [1/2]

Edges& inet::PolyhedronFace::getEdges ( )

inline

{ return edges; }

Referenced by inet::Polyhedron::computeHorizonEdges(), inet::Polyhedron::connectFaces(), and inet::Polyhedron::mergeFaces().

getEdges() [2/2]

const Edges& inet::PolyhedronFace::getEdges ( ) const

inline

{ return edges; }

getNormalVector()

Coord inet::PolyhedronFace::getNormalVector ( ) const

inline

{ return normalVector; }

Referenced by inet::Polyhedron::areCoplanar(), and inet::Polyhedron::computeOutwardNormalVector().

getOutwardNormalVector()

Coord inet::PolyhedronFace::getOutwardNormalVector ( ) const

inline

{ return outwardNormalVector; }

Referenced by inet::Polyhedron::isVisibleFromView().

hasConflicts()

bool inet::PolyhedronFace::hasConflicts ( ) const

inline

{ return !pConflict.empty(); }

isVisibleFrom()

bool inet::PolyhedronFace::isVisibleFrom

(

const PolyhedronPoint *

point

)

const

{
    PolyhedronPoint *facePoint = getEdge(0)->getP1();
    PolyhedronPoint facePointPoint = *point - *facePoint;
    return facePointPoint * outwardNormalVector > 0;
}

Referenced by inet::Polyhedron::setContlictListForNewFace().

isWrapped()

bool inet::PolyhedronFace::isWrapped ( ) const

inline

{ return wrapped; }

Referenced by inet::Polyhedron::connectFaces(), and inet::Polyhedron::purgeWrappedFaces().

pushEdge()

void inet::PolyhedronFace::pushEdge

(

PolyhedronEdge *

edge

)

{
    edges.push_back(edge);
    // We need to recompute the centroid
    computeCentroid();
}

Referenced by PolyhedronFace().

setOutwardNormalVector()

void inet::PolyhedronFace::setOutwardNormalVector ( const Coord &  outwardNormalVector )

inline

{ this->outwardNormalVector = outwardNormalVector; }

Referenced by inet::Polyhedron::buildConvexHull(), and inet::Polyhedron::generateAndAddTetrahedronFaces().

setToWrapped()

void inet::PolyhedronFace::setToWrapped ( )

inline

{ wrapped = true; }

Member Data Documentation

centroid

Coord inet::PolyhedronFace::centroid

protected

Referenced by computeCentroid(), and PolyhedronFace().

edges

Edges inet::PolyhedronFace::edges

protected

Referenced by computeCentroid(), computeNormalVector(), findEdge(), getEdge(), pushEdge(), and ~PolyhedronFace().

normalVector

Coord inet::PolyhedronFace::normalVector

protected

Referenced by computeNormalVector(), and PolyhedronFace().

outwardNormalVector

Coord inet::PolyhedronFace::outwardNormalVector

protected

Referenced by isVisibleFrom(), and PolyhedronFace().

pConflict

Points inet::PolyhedronFace::pConflict

protected

wrapped

bool inet::PolyhedronFace::wrapped

protected

Referenced by PolyhedronFace().

---

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

• PolyhedronFace.h
• PolyhedronFace.cc