LCOV - code coverage report
Current view: top level - projectors - TraverseAABB.cpp (source / functions) Hit Total Coverage
Test: test_coverage.info.cleaned Lines: 57 57 100.0 %
Date: 2022-05-27 02:48:28 Functions: 11 11 100.0 %

          Line data    Source code
       1             : #include "TraverseAABB.h"
       2             : #include "Intersection.h"
       3             : 
       4             : namespace elsa
       5             : {
       6      291536 :     TraverseAABB::TraverseAABB(const BoundingBox& aabb, const RealRay_t& r) : _aabb{aabb}
       7             :     {
       8             :         // compute the first intersection
       9      291536 :         calculateAABBIntersections(r);
      10      291536 :         if (!isInBoundingBox()) // early abort if necessary
      11       23012 :             return;
      12             : 
      13             :         // determine whether we go up/down or left/right
      14      268524 :         initStepDirection(r.direction());
      15             : 
      16             :         // select the initial voxel (closest to the entry point)
      17      268524 :         selectClosestVoxel();
      18             : 
      19             :         // initialize the step sizes for the step parameter
      20      268524 :         initDelta(r.direction());
      21             : 
      22             :         // initialize the maximum step parameters
      23      268524 :         initMax(r.direction());
      24             :     }
      25             : 
      26     5158776 :     void TraverseAABB::updateTraverse()
      27             :     {
      28             :         // --> select the index that has lowest t value
      29             :         index_t indexToChange;
      30     5158776 :         _tMax.minCoeff(&indexToChange);
      31             : 
      32             :         // --> step into the current direction
      33     5158776 :         _currentPos(indexToChange) += _stepDirection(indexToChange);
      34             : 
      35             :         // --> update the tMax for next iteration
      36     5158776 :         _tMax(indexToChange) += _tDelta(indexToChange);
      37             : 
      38             :         // --> check if we are still in bounding box
      39     5158776 :         _isInAABB = isCurrentPositionInAABB(indexToChange);
      40     5158776 :     }
      41             : 
      42     4544444 :     real_t TraverseAABB::updateTraverseAndGetDistance()
      43             :     {
      44             :         // --> select the index that has lowest t value
      45             :         index_t indexToChange;
      46     4544444 :         _tMax.minCoeff(&indexToChange);
      47             : 
      48             :         // --> compute the distance
      49     4544444 :         real_t tEntry = _tExit;
      50     4544444 :         _tExit = _tMax(indexToChange);
      51             : 
      52             :         // --> do the update
      53     4544444 :         updateTraverse();
      54             : 
      55     4544444 :         return (_tExit - tEntry);
      56             :     }
      57             : 
      58     5741861 :     bool TraverseAABB::isInBoundingBox() const { return _isInAABB; }
      59             : 
      60     5440093 :     IndexVector_t TraverseAABB::getCurrentVoxel() const
      61             :     {
      62     5440093 :         return _currentPos.template cast<IndexVector_t::Scalar>();
      63             :     }
      64             : 
      65      291536 :     void TraverseAABB::calculateAABBIntersections(const RealRay_t& r)
      66             :     {
      67             :         // entry and exit point parameters
      68             :         real_t tmin;
      69             : 
      70             :         // --> calculate intersection parameter and if the volume is hit
      71      291536 :         auto opt = Intersection::withRay(_aabb, r);
      72             : 
      73      291536 :         if (opt) { // hit!
      74      268524 :             _isInAABB = true;
      75      268524 :             tmin = opt->_tmin;
      76             : 
      77             :             // --> get points at which they intersect
      78      268524 :             _entryPoint = r.pointAt(tmin);
      79             : 
      80             :             // --> because of floating point error it can happen, that values are out of
      81             :             // the bounding box, this can lead to errors
      82             :             _entryPoint =
      83      268524 :                 (_entryPoint.array() < _aabb._min.array()).select(_aabb._min, _entryPoint);
      84             :             _entryPoint =
      85      268524 :                 (_entryPoint.array() > _aabb._max.array()).select(_aabb._max, _entryPoint);
      86             :         }
      87      291536 :     }
      88             : 
      89      268524 :     void TraverseAABB::initStepDirection(const RealVector_t& rd)
      90             :     {
      91      268524 :         _stepDirection = rd.array().sign();
      92      268524 :     }
      93             : 
      94      268524 :     void TraverseAABB::selectClosestVoxel()
      95             :     {
      96      537048 :         RealVector_t lowerCorner = _entryPoint.array().floor();
      97             :         lowerCorner =
      98      268524 :             ((lowerCorner.array() == _entryPoint.array()) && (_stepDirection.array() < 0.0))
      99      268524 :                 .select(lowerCorner.array() - 1, lowerCorner);
     100             : 
     101      268524 :         _currentPos = lowerCorner;
     102             : 
     103             :         // check if we are still inside the aabb
     104      268524 :         if ((_currentPos.array() >= _aabb._max.array()).any()
     105      268524 :             || (_currentPos.array() < _aabb._min.array()).any())
     106          12 :             _isInAABB = false;
     107      268524 :     }
     108             : 
     109      268524 :     void TraverseAABB::initDelta(const RealVector_t& rd)
     110             :     {
     111      268524 :         RealVector_t tdelta = _stepDirection.template cast<real_t>().cwiseQuotient(rd);
     112             : 
     113      268524 :         _tDelta = (Eigen::abs(rd.array()) > _EPS.array()).select(tdelta, _MAX);
     114      268524 :     }
     115             : 
     116      268524 :     void TraverseAABB::initMax(const RealVector_t& rd)
     117             :     {
     118             :         RealVector_t tmax =
     119      268524 :             (((rd.array() > 0.0f).select(_currentPos.array() + 1., _currentPos)).matrix()
     120      537048 :              - _entryPoint)
     121      268524 :                 .cwiseQuotient(rd)
     122      268524 :                 .matrix();
     123             : 
     124      268524 :         _tMax = (Eigen::abs(rd.array()) > _EPS.array()).select(tmax, _MAX);
     125      268524 :     }
     126             : 
     127     5158776 :     bool TraverseAABB::isCurrentPositionInAABB(index_t index) const
     128             :     {
     129     5158776 :         return _currentPos(index) < _aabb._max(index) && _currentPos(index) >= _aabb._min(index);
     130             :     }
     131             : 
     132             : } // namespace elsa

Generated by: LCOV version 1.15