Line data    Source code

       1             : #include "RandomBlocksDescriptor.h"
       2             : #include "VolumeDescriptor.h"
       3             : #include "Error.h"
       4             : 
       5             : namespace elsa
       6             : {
       7             :     RandomBlocksDescriptor::RandomBlocksDescriptor(
       8             :         const std::vector<std::unique_ptr<DataDescriptor>>& blockDescriptors)
       9             :         : BlockDescriptor{VolumeDescriptor{determineSize(blockDescriptors)}},
      10             :           _blockDescriptors(0),
      11             :           _blockOffsets{blockDescriptors.size()}
      12         132 :     {
      13         132 :         index_t offset = 0;
      14             : 
      15         835 :         for (std::size_t i = 0; i < blockDescriptors.size(); i++) {
      16         703 :             _blockOffsets[static_cast<index_t>(i)] = offset;
      17         703 :             _blockDescriptors.emplace_back(blockDescriptors[i]->clone());
      18         703 :             offset += blockDescriptors[i]->getNumberOfCoefficients();
      19         703 :         }
      20         132 :     }
      21             : 
      22             :     RandomBlocksDescriptor::RandomBlocksDescriptor(
      23             :         std::vector<std::unique_ptr<DataDescriptor>>&& blockDescriptors)
      24             :         : BlockDescriptor{VolumeDescriptor{determineSize(blockDescriptors)}},
      25             :           _blockDescriptors{std::move(blockDescriptors)},
      26             :           _blockOffsets{_blockDescriptors.size()}
      27          28 :     {
      28          28 :         index_t offset = 0;
      29             : 
      30         184 :         for (std::size_t i = 0; i < _blockDescriptors.size(); i++) {
      31         156 :             _blockOffsets[static_cast<index_t>(i)] = offset;
      32         156 :             offset += _blockDescriptors[i]->getNumberOfCoefficients();
      33         156 :         }
      34          28 :     }
      35             : 
      36             :     index_t RandomBlocksDescriptor::getNumberOfBlocks() const
      37          60 :     {
      38          60 :         return static_cast<index_t>(_blockDescriptors.size());
      39          60 :     }
      40             : 
      41             :     const DataDescriptor& RandomBlocksDescriptor::getDescriptorOfBlock(index_t i) const
      42         142 :     {
      43         142 :         if (i < 0 || i >= _blockOffsets.size())
      44           8 :             throw InvalidArgumentError("BlockDescriptor: index i is out of bounds");
      45             : 
      46         134 :         return *_blockDescriptors[static_cast<std::size_t>(i)];
      47         134 :     }
      48             : 
      49             :     index_t RandomBlocksDescriptor::getOffsetOfBlock(index_t i) const
      50         138 :     {
      51         138 :         if (i < 0 || i >= _blockOffsets.size())
      52           4 :             throw InvalidArgumentError("BlockDescriptor: index i is out of bounds");
      53             : 
      54         134 :         return _blockOffsets[i];
      55         134 :     }
      56             : 
      57             :     RandomBlocksDescriptor* RandomBlocksDescriptor::cloneImpl() const
      58          67 :     {
      59          67 :         return new RandomBlocksDescriptor(_blockDescriptors);
      60          67 :     }
      61             : 
      62             :     bool RandomBlocksDescriptor::isEqual(const DataDescriptor& other) const
      63          22 :     {
      64          22 :         if (!BlockDescriptor::isEqual(other))
      65           3 :             return false;
      66             : 
      67             :         // static_cast as type checked in base comparison
      68          19 :         auto otherBlock = static_cast<const RandomBlocksDescriptor*>(&other);
      69             : 
      70          19 :         if (_blockDescriptors.size() != otherBlock->_blockDescriptors.size())
      71           6 :             return false;
      72             : 
      73         136 :         for (std::size_t i = 0; i < _blockDescriptors.size(); ++i)
      74         127 :             if (*_blockDescriptors[i] != *otherBlock->_blockDescriptors[i])
      75           4 :                 return false;
      76             : 
      77          13 :         return true;
      78          13 :     }
      79             : 
      80             :     IndexVector_t RandomBlocksDescriptor::determineSize(
      81             :         const std::vector<std::unique_ptr<DataDescriptor>>& blockDescriptors)
      82         160 :     {
      83         160 :         if (blockDescriptors.empty())
      84           1 :             throw InvalidArgumentError(
      85           1 :                 "RandomBlockDescriptor: list of block descriptors cannot be empty");
      86             : 
      87         159 :         index_t size = 0;
      88             : 
      89         159 :         for (const auto& desc : blockDescriptors)
      90         859 :             size += desc->getNumberOfCoefficients();
      91             : 
      92         159 :         return IndexVector_t::Constant(1, size);
      93         159 :     }
      94             : 
      95             : } // namespace elsa