BufferedHUVolume.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 - 2015 Leonid Kostrykin
 *
 *  Chair of Medical Engineering (mediTEC)
 *  RWTH Aachen University
 *  Pauwelsstr. 20
 *  52074 Aachen
 *  Germany
 *
 */
 
#ifndef BUFFEREDHUVOLUME_H_6014714286
#define BUFFEREDHUVOLUME_H_6014714286
 
#include <Carna/base/HUVolume.h>
#include <Carna/base/Composition.h>
#include <Carna/base/CarnaException.h>
#include <vector>
#include <memory>
 
namespace Carna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// BufferedHUVolume
// ----------------------------------------------------------------------------------
 
template< typename VoxelType, typename BufferType >
class BufferedHUVolume : public HUVolume
{
 
public:
 
    typedef BufferType Buffer;
 
    typedef VoxelType Voxel;
 
    BufferedHUVolume( const math::Vector3ui& size, Association< BufferType >* buffer )
        : HUVolume( size )
        , myBuffer( buffer )
    {
        initializeBuffer();
    }
 
    explicit BufferedHUVolume( const math::Vector3ui& size )
        : HUVolume( size )
        , myBuffer( new Composition< BufferType >( new BufferType( size.x() * size.y() * size.z() ) ) )
    {
        initializeBuffer();
    }
 
    static HUV bufferValueToHUV( VoxelType bufferValue )
    {
        return HUV::abs( ( bufferValue >> ( sizeof( VoxelType ) * 8 - 12 ) ) - 1024 );
    }
 
    static VoxelType HUVToBufferValue( HUV huValue )
    {
        return ( static_cast< VoxelType >( huValue + 1024 ) << ( sizeof( VoxelType ) * 8 - 12 ) );
    }
 
    HUV operator()( unsigned int x
                  , unsigned int y
                  , unsigned int z ) const
    {
        const std::size_t index = x + size.x() * y + size.y() * size.x() * z;
        return bufferValueToHUV( myBuffer->get()->at( index ) );
    }
 
    HUV operator()( const math::Vector3ui& at ) const
    {
        return ( *this )( at.x(), at.y(), at.z() );
    }
 
    void setVoxel( unsigned int x, unsigned int y, unsigned int z, HUV huv )
    {
        CARNA_ASSERT( x < size.x() && y < size.y() && z < size.z() );
        const std::size_t index = x + size.x() * y + size.y() * size.x() * z;
        myBuffer->get()->at( index ) = HUVToBufferValue( huv );
    }
 
    void setVoxel( const math::Vector3ui& at, HUV huv )
    {
        this->setVoxel( at.x(), at.y(), at.z(), huv );
    }
 
    BufferType& buffer()
    {
        return **myBuffer;
    }
    
    const BufferType& buffer() const
    {
        return **myBuffer;
    }
 
protected:
 
    const std::unique_ptr< Association< BufferType > > myBuffer;
 
private:
 
    void initializeBuffer()
    {
        CARNA_ASSERT_EX
            ( myBuffer.get() && myBuffer->get()
            , "No volume data buffer supplied!" );
 
        CARNA_ASSERT_EX
            ( myBuffer->get()->size() >= size.x() * size.y() * size.z()
            , "Supplied volume data buffer is of size "
                << myBuffer->get()->size()
                << " bytes but must be at least "
                << size.x() * size.y() * size.z()
                << " bytes!" );
    }
 
}; // BufferedHUVolume
 
 
 
}  // namespace Carna :: base
 
}  // namespace Carna
 
#endif // BUFFEREDHUVOLUME_H_6014714286