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         662 :     {
      13         662 :         index_t offset = 0;
      14             : 
      15        2425 :         for (std::size_t i = 0; i < blockDescriptors.size(); i++) {
      16        1763 :             _blockOffsets[static_cast<index_t>(i)] = offset;
      17        1763 :             _blockDescriptors.emplace_back(blockDescriptors[i]->clone());
      18        1763 :             offset += blockDescriptors[i]->getNumberOfCoefficients();
      19        1763 :         }
      20         662 :     }
      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        1242 :     {
      38        1242 :         return static_cast<index_t>(_blockDescriptors.size());
      39        1242 :     }
      40             : 
      41             :     const DataDescriptor& RandomBlocksDescriptor::getDescriptorOfBlock(index_t i) const
      42        1356 :     {
      43        1356 :         if (i < 0 || i >= _blockOffsets.size())
      44           8 :             throw InvalidArgumentError("BlockDescriptor: index i is out of bounds");
      45             : 
      46        1348 :         return *_blockDescriptors[static_cast<std::size_t>(i)];
      47        1348 :     }
      48             : 
      49             :     index_t RandomBlocksDescriptor::getOffsetOfBlock(index_t i) const
      50        1296 :     {
      51        1296 :         if (i < 0 || i >= _blockOffsets.size())
      52           4 :             throw InvalidArgumentError("BlockDescriptor: index i is out of bounds");
      53             : 
      54        1292 :         return _blockOffsets[i];
      55        1292 :     }
      56             : 
      57             :     RandomBlocksDescriptor* RandomBlocksDescriptor::cloneImpl() const
      58         563 :     {
      59         563 :         return new RandomBlocksDescriptor(_blockDescriptors);
      60         563 :     }
      61             : 
      62             :     bool RandomBlocksDescriptor::isEqual(const DataDescriptor& other) const
      63          24 :     {
      64          24 :         if (!BlockDescriptor::isEqual(other))
      65           3 :             return false;
      66             : 
      67             :         // static_cast as type checked in base comparison
      68          21 :         auto otherBlock = static_cast<const RandomBlocksDescriptor*>(&other);
      69             : 
      70          21 :         if (_blockDescriptors.size() != otherBlock->_blockDescriptors.size())
      71           6 :             return false;
      72             : 
      73         142 :         for (std::size_t i = 0; i < _blockDescriptors.size(); ++i)
      74         131 :             if (*_blockDescriptors[i] != *otherBlock->_blockDescriptors[i])
      75           4 :                 return false;
      76             : 
      77          15 :         return true;
      78          15 :     }
      79             : 
      80             :     IndexVector_t RandomBlocksDescriptor::determineSize(
      81             :         const std::vector<std::unique_ptr<DataDescriptor>>& blockDescriptors)
      82         690 :     {
      83         690 :         if (blockDescriptors.empty())
      84           1 :             throw InvalidArgumentError(
      85           1 :                 "RandomBlockDescriptor: list of block descriptors cannot be empty");
      86             : 
      87         689 :         index_t size = 0;
      88             : 
      89         689 :         for (const auto& desc : blockDescriptors)
      90        1919 :             size += desc->getNumberOfCoefficients();
      91             : 
      92         689 :         return IndexVector_t::Constant(1, size);
      93         689 :     }
      94             : 
      95             : } // namespace elsa