inet::Prism Class Reference

This class represents 3 dimensional prism with a polygon base face. More...

#include <Prism.h>

Inheritance diagram for inet::Prism:

Public Types
typedef std::vector< Polygon >	Faces
typedef std::vector< Coord >	Points

Public Member Functions
	Prism ()
	Prism (double height, const Polygon &base)
double	getHeight () const
void	setHeight (double height)
const Polygon &	getBase () const
void	setBase (const Polygon &base)
const Faces &	getFaces () const
virtual Coord	computeBoundingBoxSize () const override
	Computes the 3 dimensional size of the shapes's bounding box. More...
virtual bool	computeIntersection (const LineSegment &lineSegment, Coord &intersection1, Coord &intersection2, Coord &normal1, Coord &normal2) const override
	Computes the intersection with the given line segment in the shape's coordinate system. More...
void	computeVisibleFaces (std::vector< std::vector< Coord >> &faces, const RotationMatrix &rotation, const RotationMatrix &viewRotation) const
Public Member Functions inherited from inet::ShapeBase
	ShapeBase ()
virtual	~ShapeBase ()

Protected Member Functions
void	genereateFaces ()
Coord	computeOutwardNormalVector (unsigned int faceId) const
void	computeOutwardNormalVectors ()
bool	isVisibleFromPoint (unsigned int faceId, const Coord &point, const RotationMatrix &rotation) const
bool	isVisibleFromView (unsigned int faceId, const RotationMatrix &viewRotation, const RotationMatrix &rotation) const

Protected Attributes
double	height
Polygon	base
std::vector< Polygon >	faces
std::vector< Coord >	normalVectorsForFaces

Detailed Description

This class represents 3 dimensional prism with a polygon base face.

Member Typedef Documentation

Faces

typedef std::vector<Polygon> inet::Prism::Faces

Points

typedef std::vector<Coord> inet::Prism::Points

Constructor & Destructor Documentation

Prism() [1/2]

inet::Prism::Prism ( )

inline

: height(0) {}

Prism() [2/2]

inet::Prism::Prism	(	double	height,
		const Polygon &	base
	)

                                               :
    height(height),
    base(base)
{
    if (height > 0) {
        if (base.getPoints().size() >= 3) {
            genereateFaces();
            computeOutwardNormalVectors();
        }
        else
            throw cRuntimeError("We need at least three points to construct a prism");
    }
    else
        throw cRuntimeError("A prism has a positive height");
}

Member Function Documentation

computeBoundingBoxSize()

Coord inet::Prism::computeBoundingBoxSize ( ) const

overridevirtual

Computes the 3 dimensional size of the shapes's bounding box.

Implements inet::ShapeBase.

{
    Coord min = base.getPoints()[0];
    Coord max = min;
    for (const auto& elem : base.getPoints()) {
        min = min.min(elem);
        max = max.max(elem);
    }
    return max - min + Coord(0, 0, height);
}

computeIntersection()

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

overridevirtual

Computes the intersection with the given line segment in the shape's coordinate system.

Implements inet::ShapeBase.

{
    // Note: based on http://geomalgorithms.com/a13-_intersect-4.html
    const auto& p0 = lineSegment.getPoint1();
    const auto& p1 = lineSegment.getPoint2();
    if (p0 == p1) {
        normal1 = normal2 = Coord::NIL;
        return false;
    }
    Coord segmentDirection = p1 - p0;
    double tE = 0;
    double tL = 1;
    for (unsigned int i = 0; i < faces.size(); i++) {
        const auto& face = faces[i];
        const auto& normalVec = normalVectorsForFaces[i];
        const std::vector<Coord>& pointList = face.getPoints();
        const auto& f0 = pointList[0];
        double N = (f0 - p0) * normalVec;
        double D = segmentDirection * normalVec;
        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;
}

computeOutwardNormalVector()

Coord inet::Prism::computeOutwardNormalVector ( unsigned int  faceId ) const

protected

{
    Polygon face = faces[faceId];
    Polygon testFace = faces[(faceId + 1) % faces.size()];
    const std::vector<Coord>& testPoints = testFace.getPoints();
    // This is a good test point: for convex polygons, the centroid is always an interior point.
    Coord testCentroid;
    for (auto& testPoint : testPoints)
        testCentroid += testPoint;
    testCentroid /= testPoints.size();
    Coord facePoint = face.getPoints()[0];
    Coord faceNormal = face.getNormalVector();
    if ((testCentroid - facePoint) * faceNormal > 0)
        return faceNormal * (-1);
    return faceNormal;
}

Referenced by computeOutwardNormalVectors().

computeOutwardNormalVectors()

void inet::Prism::computeOutwardNormalVectors ( )

protected

{
    normalVectorsForFaces.clear();
    for (unsigned int i = 0; i < faces.size(); i++)
        normalVectorsForFaces.push_back(computeOutwardNormalVector(i));
}

Referenced by Prism(), setBase(), and setHeight().

computeVisibleFaces()

void inet::Prism::computeVisibleFaces	(	std::vector< std::vector< Coord >> &	faces,
		const RotationMatrix &	rotation,
		const RotationMatrix &	viewRotation
	)		const

{
    for (unsigned int i = 0; i < this->faces.size(); i++) {
        const Polygon& face = this->faces.at(i);
        if (isVisibleFromView(i, viewRotation, rotation)) {
            const std::vector<Coord>& facePoints = face.getPoints();
            std::vector<Coord> points;
            for (const auto& facePoint : facePoints)
                points.push_back(facePoint);
            faces.push_back(points);
        }
    }
}

Referenced by inet::Cuboid::computeVisibleFaces(), and inet::visualizer::PhysicalEnvironmentCanvasVisualizer::refreshDisplay().

genereateFaces()

void inet::Prism::genereateFaces ( )

protected

{
    faces.clear();
    faces.push_back(base);
    // TODO Coord baseNormalUnitVector = base.getNormalUnitVector();
    const std::vector<Coord>& basePoints = base.getPoints();
    std::vector<Coord> translatedCopyPoints;
    for (auto& basePoint : basePoints) {
        Coord point = basePoint;
        point.z += height;
        translatedCopyPoints.push_back(point);
    }
    Polygon translatedCopy(translatedCopyPoints);
    faces.push_back(translatedCopy);
    unsigned int basePointsSize = basePoints.size();
    for (unsigned int i = 0; i < basePointsSize; i++) {
        std::vector<Coord> facePoints;
        facePoints.push_back(basePoints[i]);
        facePoints.push_back(translatedCopyPoints[i]);
        facePoints.push_back(translatedCopyPoints[(i + 1) % basePointsSize]);
        facePoints.push_back(basePoints[(i + 1) % basePointsSize]);
        Polygon face(facePoints);
        faces.push_back(face);
    }
}

Referenced by Prism(), setBase(), and setHeight().

getBase()

const Polygon& inet::Prism::getBase ( ) const

inline

{ return base; }

Referenced by inet::visualizer::PhysicalEnvironmentOsgVisualizer::refreshDisplay().

getFaces()

const Faces& inet::Prism::getFaces ( ) const

inline

{ return faces; }

Referenced by inet::visualizer::PhysicalEnvironmentOsgVisualizer::refreshDisplay().

getHeight()

double inet::Prism::getHeight ( ) const

inline

{ return height; }

Referenced by inet::visualizer::PhysicalEnvironmentOsgVisualizer::refreshDisplay().

isVisibleFromPoint()

bool inet::Prism::isVisibleFromPoint ( unsigned int  faceId, const Coord &  point, const RotationMatrix &  rotation  ) const

protected

{
    const std::vector<Coord>& polygonPoints = faces.at(faceId).getPoints();
    Coord facePoint = polygonPoints.at(0);
    Coord facePointPoint = point - facePoint;
    Coord rotatedFaceNormal = rotation.rotateVector(normalVectorsForFaces.at(faceId));
    return facePointPoint * rotatedFaceNormal > 0;
}

isVisibleFromView()

bool inet::Prism::isVisibleFromView ( unsigned int  faceId, const RotationMatrix &  viewRotation, const RotationMatrix &  rotation  ) const

protected

{
    Coord zNormal(0, 0, 1);
    Coord rotatedFaceNormal = viewRotation.rotateVector(rotation.rotateVector(normalVectorsForFaces.at(faceId)));
    return rotatedFaceNormal * zNormal > 0;
}

Referenced by computeVisibleFaces().

setBase()

void inet::Prism::setBase

(

const Polygon &

base

)

{
    if (base.getPoints() != this->base.getPoints()) {
        if (base.getPoints().size() >= 3) {
            this->base = base;
            genereateFaces();
            computeOutwardNormalVectors();
        }
        else
            throw cRuntimeError("We need at least three points to construct a prism");
    }
}

setHeight()

void inet::Prism::setHeight

(

double

height

)

{
    if (height != this->height) {
        if (height > 0) {
            this->height = height;
            genereateFaces();
            computeOutwardNormalVectors();
        }
        else
            throw cRuntimeError("A prism has a positive height");
    }
}

Member Data Documentation

base

Polygon inet::Prism::base

protected

Referenced by computeBoundingBoxSize(), genereateFaces(), Prism(), and setBase().

faces

std::vector<Polygon> inet::Prism::faces

protected

Referenced by computeIntersection(), computeOutwardNormalVector(), computeOutwardNormalVectors(), computeVisibleFaces(), genereateFaces(), and isVisibleFromPoint().

height

double inet::Prism::height

protected

Referenced by computeBoundingBoxSize(), genereateFaces(), Prism(), and setHeight().

normalVectorsForFaces

std::vector<Coord> inet::Prism::normalVectorsForFaces

protected

Referenced by computeIntersection(), computeOutwardNormalVectors(), isVisibleFromPoint(), and isVisibleFromView().

---

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

• Prism.h
• Prism.cc