inet::Cuboid Class Reference

This class represents a 3 dimensional shape with 6 pairwise parallel faces. More...

#include <Cuboid.h>

Inheritance diagram for inet::Cuboid:

Public Member Functions
	Cuboid (const Coord &size)
const Coord &	getSize () const
void	setSize (const Coord &size)
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...
virtual 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
bool	isInsideX (const Coord &point) const
bool	isInsideY (const Coord &point) const
bool	isInsideZ (const Coord &point) const

Protected Attributes
Coord	size

Detailed Description

This class represents a 3 dimensional shape with 6 pairwise parallel faces.

Constructor & Destructor Documentation

Cuboid()

inet::Cuboid::Cuboid

(

const Coord &

size

)

                                :
    size(size)
{
}

Member Function Documentation

computeBoundingBoxSize()

virtual Coord inet::Cuboid::computeBoundingBoxSize ( ) const

inlineoverridevirtual

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

Implements inet::ShapeBase.

{ return size; }

computeIntersection()

bool inet::Cuboid::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 https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
    const auto p1 = lineSegment.getPoint1();
    const auto p2 = lineSegment.getPoint2();
    Coord direction = p1 == p2 ? Coord::ZERO : (p2 - p1).getNormalized();
    Coord m = Coord::ONE.getDividedElementwise(direction);
    m.clamp(-1E+100, 1E+100); // fix axis algined direction
    Coord n = m.getMultipliedElementwise(p1);
    Coord k = m.getAbs().getMultipliedElementwise(size / 2);
    Coord t1 = -n - k;
    Coord t2 = -n + k;
    double tN = math::maxnan(math::maxnan(t1.x, t1.y), t1.z);
    double tF = math::minnan(math::minnan(t2.x, t2.y), t2.z);
    double l = lineSegment.length();
    if (tN > tF || tF < 0.0 || tN > l) {
        intersection1 = intersection2 = normal1 = normal2 = Coord::NIL;
        return false;
    }
    else {
        if (tN < 0) {
            intersection1 = p1;
            normal1 = Coord::NIL;
        }
        else {
            intersection1 = p1 + direction * tN;
            normal1 = -direction.getSign().getMultipliedElementwise(t1.getYzx().getStep(t1).getMultipliedElementwise(t1.getZxy().getStep(t1)));
        }
        if (l < tF) {
            intersection2 = p2;
            normal2 = Coord::NIL;
        }
        else {
            intersection2 = p1 + direction * tF;
            normal2 = -direction.getSign().getMultipliedElementwise(t2.getYzx().getStep(t2).getMultipliedElementwise(t2.getZxy().getStep(t2)));
        }
        return true;
    }
}

Referenced by inet::visualizer::VisualizerBase::getContactPosition(), and inet::BvhTree::intersectWithLineSegment().

computeVisibleFaces()

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

virtual

{
    // TODO specialize
    std::vector<Coord> polygonPoints;
    polygonPoints.push_back(Coord(-size.x / 2, -size.y / 2, -size.z / 2));
    polygonPoints.push_back(Coord(-size.x / 2, size.y / 2, -size.z / 2));
    polygonPoints.push_back(Coord(size.x / 2, size.y / 2, -size.z / 2));
    polygonPoints.push_back(Coord(size.x / 2, -size.y / 2, -size.z / 2));
    Polygon base(polygonPoints);
    Prism prism(size.z, base);
    prism.computeVisibleFaces(faces, rotation, viewRotation);
}

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

getSize()

const Coord& inet::Cuboid::getSize ( ) const

inline

{ return size; }

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

isInsideX()

bool inet::Cuboid::isInsideX ( const Coord &  point ) const

inlineprotected

{ return -size.x / 2 <= point.x && point.x <= size.x / 2; }

isInsideY()

bool inet::Cuboid::isInsideY ( const Coord &  point ) const

inlineprotected

{ return -size.y / 2 <= point.y && point.y <= size.y / 2; }

isInsideZ()

bool inet::Cuboid::isInsideZ ( const Coord &  point ) const

inlineprotected

{ return -size.z / 2 <= point.z && point.z <= size.z / 2; }

setSize()

void inet::Cuboid::setSize ( const Coord &  size )

inline

{ this->size = size; }

Member Data Documentation

size

Coord inet::Cuboid::size

protected

Referenced by computeIntersection(), and computeVisibleFaces().

---

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

• Cuboid.h
• Cuboid.cc