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 Rotation &rotation, const Rotation &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 Rotation &rotation) const
bool	isVisibleFromView (unsigned int faceId, const Rotation &viewRotation, const Rotation &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

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

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

Constructor & Destructor Documentation

inet::Prism::Prism ( )

inline

: height(0) {}

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

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

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
    Coord p0 = lineSegment.getPoint1();
    Coord 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++)
    {
        Polygon face = faces[i];
        Coord normalVec = normalVectorsForFaces[i];
        const std::vector<Coord>& pointList = face.getPoints();
        Coord 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;
}

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

protected

Referenced by computeOutwardNormalVectors().

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

void inet::Prism::computeOutwardNormalVectors ( )

protected

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

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

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

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

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

void inet::Prism::genereateFaces ( )

protected

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

{
    faces.clear();
    faces.push_back(base);
    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);
    }
}

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

inline

{ return base; }

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

inline

{ return faces; }

double inet::Prism::getHeight ( ) const

inline

{ return height; }

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

protected

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

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

protected

Referenced by computeVisibleFaces().

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

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

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

Polygon inet::Prism::base

protected

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

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

protected

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

double inet::Prism::height

protected

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

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