#include <BVHTree.h>

Classes
class	Axis

struct	AxisComparator

class	BVHTreeVisitor

Public Member Functions
	BVHTree (const Coord &boundingMin, const Coord &boundingMax, std::vector< const IPhysicalObject * > &objects, unsigned int start, unsigned int end, Axis axis, unsigned int leafCapacity)

virtual	~BVHTree ()

void	lineSegmentQuery (const LineSegment &lineSegment, const IVisitor *visitor) const

Protected Member Functions
bool	isLeaf () const

void	buildHierarchy (std::vector< const IPhysicalObject * > &objects, unsigned int start, unsigned int end, Axis axis)

void	computeBoundingBox (Coord &boundingMin, Coord &boundingMax, std::vector< const IPhysicalObject * > &objects, unsigned int start, unsigned int end) const

bool	intersectWithLineSegment (const LineSegment &lineSegment) const

Protected Attributes
unsigned int	leafCapacity

std::string	axisOrder

Coord	boundingMin

Coord	boundingMax

Coord	center

BVHTree *	left

BVHTree *	right

std::vector< const IPhysicalObject * >	objects

Constructor & Destructor Documentation

inet::BVHTree::BVHTree	(	const Coord &	boundingMin,
		const Coord &	boundingMax,
		std::vector< const IPhysicalObject * > &	objects,
		unsigned int	start,
		unsigned int	end,
		Axis	axis,
		unsigned int	leafCapacity
	)

Referenced by buildHierarchy().

 {
     this->left = nullptr;
     this->right = nullptr;
     this->boundingMin = boundingMin;
     this->boundingMax = boundingMax;
     this->center = (boundingMax - boundingMin) / 2 + boundingMin;
     this->leafCapacity = leafCapacity;
     buildHierarchy(objects, start, end, axis);
 }

inet::BVHTree::~BVHTree ( )

virtual

 {
     delete left;
     delete right;
 }

Member Function Documentation

void inet::BVHTree::buildHierarchy	(	std::vector< const IPhysicalObject * > &	objects,
		unsigned int	start,
		unsigned int	end,
		Axis	axis
	)

protected

Referenced by BVHTree().

 {
     if (end - start + 1 <= leafCapacity)
     {
         for (unsigned int i = start; i <= end; i++)
            this->objects.push_back(objects[i]);
     }
     else
     {
         auto s = objects.begin();
         auto e = s;
         std::advance(s, start);
         std::advance(e, end + 1);
         sort(s, e, AxisComparator(axis.getCurrentAxis()));
         axis.getNextAxis();
         Coord boundingMin, boundingMax;
         computeBoundingBox(boundingMin, boundingMax, objects, start, (start + end) / 2);
         left = new BVHTree(boundingMin, boundingMax, objects, start, (start + end) / 2, axis, leafCapacity);
         computeBoundingBox(boundingMin, boundingMax, objects, 1 + (start + end) / 2, end);
         right = new BVHTree(boundingMin, boundingMax, objects, 1 + (start + end) / 2, end, axis, leafCapacity);
     }
 }

void inet::BVHTree::computeBoundingBox	(	Coord &	boundingMin,
		Coord &	boundingMax,
		std::vector< const IPhysicalObject * > &	objects,
		unsigned int	start,
		unsigned int	end
	)		const

protected

Referenced by buildHierarchy().

 {
     double xMin = std::numeric_limits<double>::max();
     double yMin = xMin;
     double zMin = xMin;
     double xMax = -std::numeric_limits<double>::max();
     double yMax = xMax;
     double zMax = xMax;
     for (unsigned int i = start; i <= end; i++)
     {
         const IPhysicalObject *phyObj = objects[i];
         Coord pos = phyObj->getPosition();
         Coord size = phyObj->getShape()->computeBoundingBoxSize();
         size /= 2;
         Coord objMaxBounding = pos + size;
         Coord objMinBounding = pos - size;
         if (objMaxBounding.x > xMax)
             xMax = objMaxBounding.x;
         if (objMaxBounding.y > yMax)
             yMax = objMaxBounding.y;
         if (objMaxBounding.z > zMax)
             zMax = objMaxBounding.z;
         if (objMinBounding.x < xMin)
             xMin = objMinBounding.x;
         if (objMinBounding.y < yMin)
             yMin = objMinBounding.y;
         if (objMinBounding.z < zMin)
             zMin = objMinBounding.z;
     }
     boundingMin = Coord(xMin, yMin, zMin);
     boundingMax = Coord(xMax, yMax, zMax);
 }

bool inet::BVHTree::intersectWithLineSegment ( const LineSegment & lineSegment ) const

protected

Referenced by lineSegmentQuery().

 {
     Coord size = Coord(boundingMax.x - boundingMin.x, boundingMax.y - boundingMin.y, boundingMax.z - boundingMin.z);
     Coord p0 = lineSegment.getPoint1() - center;
     Coord p1 = lineSegment.getPoint2() - center;
     Cuboid cuboid(size);
     LineSegment translatedLineSegment(p0, p1);
     Coord intersection1, intersection2, normal1, normal2; // TODO: implement a bool computeIntersection(lineSegment) function
     return cuboid.computeIntersection(translatedLineSegment, intersection1, intersection2, normal1, normal2);
 }

bool inet::BVHTree::isLeaf ( ) const

protected

Referenced by lineSegmentQuery().

 {
     return objects.size() != 0;
 }

void inet::BVHTree::lineSegmentQuery	(	const LineSegment &	lineSegment,
		const IVisitor *	visitor
	)		const

Referenced by lineSegmentQuery(), and inet::physicalenvironment::BVHObjectCache::visitObjects().

 {
     if (isLeaf())
     {
         for (auto & elem : objects)
             // TODO: avoid dynamic_cast
             visitor->visit(dynamic_cast<const cObject *>(elem));
     }
     else if (intersectWithLineSegment(lineSegment))
     {
         left->lineSegmentQuery(lineSegment, visitor);
         right->lineSegmentQuery(lineSegment, visitor);
     }
 }