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(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             :           lut_(radius, alpha, order)
      14         873 :     {
      15             :         // sanity checks
      16         873 :         auto dim = domainDescriptor.getNumberOfDimensions();
      17         873 :         if (dim < 2 || dim > 3) {
      18           0 :             throw InvalidArgumentError("BlobProjector: only supporting 2d/3d operations");
      19           0 :         }
      20             : 
      21         873 :         if (dim != rangeDescriptor.getNumberOfDimensions()) {
      22           0 :             throw InvalidArgumentError("BlobProjector: domain and range dimension need to match");
      23           0 :         }
      24             : 
      25         873 :         if (rangeDescriptor.getNumberOfGeometryPoses() == 0) {
      26           0 :             throw InvalidArgumentError("BlobProjector: rangeDescriptor without any geometry");
      27           0 :         }
      28         873 :     }
      29             : 
      30             :     template <typename data_t>
      31             :     BlobProjector<data_t>::BlobProjector(const VolumeDescriptor& domainDescriptor,
      32             :                                          const DetectorDescriptor& rangeDescriptor)
      33             :         : BlobProjector(2, 10.83, 2, domainDescriptor, rangeDescriptor)
      34         873 :     {
      35         873 :     }
      36             : 
      37             :     template <typename data_t>
      38             :     BlobProjector<data_t>* BlobProjector<data_t>::_cloneImpl() const
      39           0 :     {
      40           0 :         return new BlobProjector(downcast<VolumeDescriptor>(*this->_domainDescriptor),
      41           0 :                                  downcast<DetectorDescriptor>(*this->_rangeDescriptor));
      42           0 :     }
      43             : 
      44             :     template <typename data_t>
      45             :     bool BlobProjector<data_t>::_isEqual(const LinearOperator<data_t>& other) const
      46           0 :     {
      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           0 :     }
      53             : 
      54             :     template <typename data_t>
      55             :     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             :           lut_(domainDescriptor.getNumberOfDimensions(), degree)
      60           0 :     {
      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           0 :         }
      66             : 
      67           0 :         if (dim != rangeDescriptor.getNumberOfDimensions()) {
      68           0 :             throw InvalidArgumentError(
      69           0 :                 "BSplineProjector: domain and range dimension need to match");
      70           0 :         }
      71             : 
      72           0 :         if (rangeDescriptor.getNumberOfGeometryPoses() == 0) {
      73           0 :             throw InvalidArgumentError("BSplineProjector: rangeDescriptor without any geometry");
      74           0 :         }
      75           0 :     }
      76             : 
      77             :     template <typename data_t>
      78             :     BSplineProjector<data_t>::BSplineProjector(const VolumeDescriptor& domainDescriptor,
      79             :                                                const DetectorDescriptor& rangeDescriptor)
      80             :         : BSplineProjector(2, domainDescriptor, rangeDescriptor)
      81           0 :     {
      82           0 :     }
      83             : 
      84             :     template <typename data_t>
      85             :     data_t BSplineProjector<data_t>::weight(data_t distance) const
      86           0 :     {
      87           0 :         return lut_(distance);
      88           0 :     }
      89             : 
      90             :     template <typename data_t>
      91             :     index_t BSplineProjector<data_t>::support() const
      92           0 :     {
      93           0 :         return static_cast<index_t>(2);
      94           0 :     }
      95             : 
      96             :     template <typename data_t>
      97             :     BSplineProjector<data_t>* BSplineProjector<data_t>::_cloneImpl() const
      98           0 :     {
      99           0 :         return new BSplineProjector(downcast<VolumeDescriptor>(*this->_domainDescriptor),
     100           0 :                                     downcast<DetectorDescriptor>(*this->_rangeDescriptor));
     101           0 :     }
     102             : 
     103             :     template <typename data_t>
     104             :     bool BSplineProjector<data_t>::_isEqual(const LinearOperator<data_t>& other) const
     105           0 :     {
     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           0 :     }
     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