Line data    Source code

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