BufferedIntensityVolume.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2021 Leonid Kostrykin
 *
 */
 
#ifndef BUFFEREDINTENSITYVOLUME_H_6014714286
#define BUFFEREDINTENSITYVOLUME_H_6014714286
 
#include <Carna/base/IntensityVolume.h>
#include <Carna/base/Composition.h>
#include <Carna/base/CarnaException.h>
#include <vector>
#include <memory>
 
namespace Carna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// BufferedIntensityVolume
// ----------------------------------------------------------------------------------
 
template< typename VoxelType, typename BufferType >
class BufferedIntensityVolume : public IntensityVolume
{
 
public:
 
    typedef BufferType Buffer;
 
    typedef VoxelType Voxel;
 
    BufferedIntensityVolume( const math::Vector3ui& size, Association< BufferType >* buffer )
        : IntensityVolume( size )
        , myBuffer( buffer )
    {
        initializeBuffer();
    }
 
    explicit BufferedIntensityVolume( const math::Vector3ui& size )
        : IntensityVolume( size )
        , myBuffer( new Composition< BufferType >( new BufferType( size.x() * size.y() * size.z() ) ) )
    {
        initializeBuffer();
    }
 
    static float bufferValueToIntensity( VoxelType bufferValue )
    {
        return bufferValue / static_cast< float >( ( 1 << ( 8 * sizeof( VoxelType ) ) ) - 1 );
    }
 
    static VoxelType intensityToBufferValue( float intensity )
    {
        CARNA_ASSERT_EX( 0 <= intensity && intensity <= 1, "Intensity out of range: " << intensity ); // TODO: check how much this slows down?
        const auto valueMax = ( 1 << ( 8 * sizeof( VoxelType ) ) ) - 1;
        float value = intensity * valueMax + 0.5f;
        if( value > valueMax ) value = valueMax;
        return static_cast< VoxelType >( value );
    }
 
    float 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 bufferValueToIntensity( myBuffer->get()->at( index ) );
    }
 
    float 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, float intensity )
    {
        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 ) = intensityToBufferValue( intensity );
    }
 
    void setVoxel( const math::Vector3ui& at, float intensity )
    {
        this->setVoxel( at.x(), at.y(), at.z(), intensity );
    }
 
    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!" );
    }
 
}; // BufferedIntensityVolume
 
 
 
}  // namespace Carna :: base
 
}  // namespace Carna
 
#endif // BUFFEREDINTENSITYVOLUME_H_6014714286