LCOV - code coverage report
Current view: top level - projectors - LutProjector.cpp (source / functions) Hit Total Coverage
Test: test_coverage.info.cleaned Lines: 0 46 0.0 %
Date: 2022-08-04 03:43:28 Functions: 0 20 0.0 %

          Line data    Source code
       1             : #include "LutProjector.h"
       2             : #include "Timer.h"
       3             : #include "SliceTraversal.h"
       4             : #include "Assertions.h"
       5             : 
       6             : namespace elsa
       7             : {
       8             :     template <typename data_t>
       9           0 :     BlobProjector<data_t>::BlobProjector(data_t radius, data_t alpha, data_t order,
      10             :                                          const VolumeDescriptor& domainDescriptor,
      11             :                                          const DetectorDescriptor& rangeDescriptor)
      12             :         : LutProjector<data_t, BlobProjector<data_t>>(domainDescriptor, rangeDescriptor),
      13           0 :           lut_(radius, alpha, order)
      14             :     {
      15             :         // sanity checks
      16           0 :         auto dim = domainDescriptor.getNumberOfDimensions();
      17           0 :         if (dim < 2 || dim > 3) {
      18           0 :             throw InvalidArgumentError("BlobProjector: only supporting 2d/3d operations");
      19             :         }
      20             : 
      21           0 :         if (dim != rangeDescriptor.getNumberOfDimensions()) {
      22           0 :             throw InvalidArgumentError("BlobProjector: domain and range dimension need to match");
      23             :         }
      24             : 
      25           0 :         if (rangeDescriptor.getNumberOfGeometryPoses() == 0) {
      26           0 :             throw InvalidArgumentError("BlobProjector: rangeDescriptor without any geometry");
      27             :         }
      28           0 :     }
      29             : 
      30             :     template <typename data_t>
      31           0 :     BlobProjector<data_t>::BlobProjector(const VolumeDescriptor& domainDescriptor,
      32             :                                          const DetectorDescriptor& rangeDescriptor)
      33           0 :         : BlobProjector(2, 10.83, 2, domainDescriptor, rangeDescriptor)
      34             :     {
      35           0 :     }
      36             : 
      37             :     template <typename data_t>
      38           0 :     BlobProjector<data_t>* BlobProjector<data_t>::_cloneImpl() const
      39             :     {
      40           0 :         return new BlobProjector(downcast<VolumeDescriptor>(*this->_domainDescriptor),
      41           0 :                                  downcast<DetectorDescriptor>(*this->_rangeDescriptor));
      42             :     }
      43             : 
      44             :     template <typename data_t>
      45           0 :     bool BlobProjector<data_t>::_isEqual(const LinearOperator<data_t>& other) const
      46             :     {
      47           0 :         if (!Base::isEqual(other))
      48           0 :             return false;
      49             : 
      50           0 :         auto otherOp = downcast_safe<BlobProjector>(&other);
      51           0 :         return static_cast<bool>(otherOp);
      52             :     }
      53             : 
      54             :     template <typename data_t>
      55           0 :     BSplineProjector<data_t>::BSplineProjector(data_t degree,
      56             :                                                const VolumeDescriptor& domainDescriptor,
      57             :                                                const DetectorDescriptor& rangeDescriptor)
      58             :         : LutProjector<data_t, BSplineProjector<data_t>>(domainDescriptor, rangeDescriptor),
      59           0 :           lut_(domainDescriptor.getNumberOfDimensions(), degree)
      60             :     {
      61             :         // sanity checks
      62           0 :         auto dim = domainDescriptor.getNumberOfDimensions();
      63           0 :         if (dim < 2 || dim > 3) {
      64           0 :             throw InvalidArgumentError("BSplineProjector: only supporting 2d/3d operations");
      65             :         }
      66             : 
      67           0 :         if (dim != rangeDescriptor.getNumberOfDimensions()) {
      68           0 :             throw InvalidArgumentError(
      69             :                 "BSplineProjector: domain and range dimension need to match");
      70             :         }
      71             : 
      72           0 :         if (rangeDescriptor.getNumberOfGeometryPoses() == 0) {
      73           0 :             throw InvalidArgumentError("BSplineProjector: rangeDescriptor without any geometry");
      74             :         }
      75           0 :     }
      76             : 
      77             :     template <typename data_t>
      78           0 :     BSplineProjector<data_t>::BSplineProjector(const VolumeDescriptor& domainDescriptor,
      79             :                                                const DetectorDescriptor& rangeDescriptor)
      80           0 :         : BSplineProjector(2, domainDescriptor, rangeDescriptor)
      81             :     {
      82           0 :     }
      83             : 
      84             :     template <typename data_t>
      85           0 :     data_t BSplineProjector<data_t>::weight(data_t distance) const
      86             :     {
      87           0 :         return lut_(distance);
      88             :     }
      89             : 
      90             :     template <typename data_t>
      91           0 :     index_t BSplineProjector<data_t>::support() const
      92             :     {
      93           0 :         return static_cast<index_t>(2);
      94             :     }
      95             : 
      96             :     template <typename data_t>
      97           0 :     BSplineProjector<data_t>* BSplineProjector<data_t>::_cloneImpl() const
      98             :     {
      99           0 :         return new BSplineProjector(downcast<VolumeDescriptor>(*this->_domainDescriptor),
     100           0 :                                     downcast<DetectorDescriptor>(*this->_rangeDescriptor));
     101             :     }
     102             : 
     103             :     template <typename data_t>
     104           0 :     bool BSplineProjector<data_t>::_isEqual(const LinearOperator<data_t>& other) const
     105             :     {
     106           0 :         if (!Base::isEqual(other))
     107           0 :             return false;
     108             : 
     109           0 :         auto otherOp = downcast_safe<BSplineProjector>(&other);
     110           0 :         return static_cast<bool>(otherOp);
     111             :     }
     112             : 
     113             :     // ------------------------------------------
     114             :     // explicit template instantiation
     115             :     template class BlobProjector<float>;
     116             :     template class BlobProjector<double>;
     117             : 
     118             :     template class BSplineProjector<float>;
     119             :     template class BSplineProjector<double>;
     120             : } // namespace elsa

Generated by: LCOV version 1.14