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