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 static_cast< HUV >( 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