BufferedNormalMap3D.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 - 2016 Leonid Kostrykin
 *
 *  Chair of Medical Engineering (mediTEC)
 *  RWTH Aachen University
 *  Pauwelsstr. 20
 *  52074 Aachen
 *  Germany
 * 
 * 
 *  Copyright (C) 2021 - 2025 Leonid Kostrykin
 * 
 */
 
#ifndef BUFFEREDNORMALMAP3D_H_6014714286
#define BUFFEREDNORMALMAP3D_H_6014714286
 
#include <LibCarna/base/NormalMap3D.hpp>
#include <LibCarna/base/Composition.hpp>
#include <LibCarna/base/LibCarnaException.hpp>
#include <LibCarna/base/text.hpp>
#include <vector>
#include <memory>
#include <type_traits>
#include <climits>
 
namespace LibCarna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// BufferedNormalMap3D
// ----------------------------------------------------------------------------------
 
template< typename BufferedVectorComponentType, typename BufferType >
class BufferedNormalMap3D : public NormalMap3D
{
 
    static_assert
        ( std::is_integral< BufferedVectorComponentType >::value
        , "Only integral buffer vector component types allowed." );
 
public:
 
    typedef BufferType Buffer;
 
    typedef BufferedVectorComponentType BufferedVectorComponent;
 
    BufferedNormalMap3D( const math::Vector3ui& size, Association< BufferType >* buffer )
        : NormalMap3D( size )
        , myBuffer( buffer )
    {
        checkBuffer();
    }
 
    explicit BufferedNormalMap3D( const math::Vector3ui& size )
        : NormalMap3D( size )
        , myBuffer( new Composition< BufferType >
            ( new BufferType( 4 * sizeof( BufferedVectorComponentType ) * size.x() * size.y() * size.z() ) ) )
    {
        checkBuffer();
    }
 
    static float decodeComponent( BufferedVectorComponentType encodedVectorComponent )
    {
        const float range = static_cast< float >( static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::max() )
            - static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::min() ) );
        const signed long x = encodedVectorComponent;
        const float fraction = ( x - static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::min() ) ) / range;
        return ( fraction - 0.5f ) * 2;
    }
 
    static BufferedVectorComponentType encodeComponent( float actualVectorComponent )
    {
        LIBCARNA_ASSERT_EX
            ( std::abs( actualVectorComponent ) <= 1
            , "Unnormalized vector! Component: " + text::lexical_cast< std::string >( actualVectorComponent ) );
        
        const signed long range = static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::max() )
            - static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::min() );
        const signed long result = static_cast< signed long >( ( ( actualVectorComponent + 1 ) * range ) / 2 )
            + static_cast< signed long >( std::numeric_limits< BufferedVectorComponentType >::min() );
        return static_cast< BufferedVectorComponentType >( result );
    }
 
    math::Vector3f operator()( const math::Vector3ui& location ) const
    {
        return ( *this )( location.x(), location.y(), location.z() );
    }
 
    math::Vector3f operator()
        ( unsigned int x
        , unsigned int y
        , unsigned int z ) const
    {
        math::Vector3f result;
        const std::size_t index = 4 * ( x + size.x() * y + size.y() * size.x() * z );
        result.x() = decodeComponent( myBuffer->get()->at( index + 0 ) );
        result.y() = decodeComponent( myBuffer->get()->at( index + 1 ) );
        result.z() = decodeComponent( myBuffer->get()->at( index + 2 ) );
        return result;
    }
 
    void setVoxel( const math::Vector3ui& location, const math::Vector3f& normal )
    {
        this->setVoxel( location.x(), location.y(), location.z(), normal );
    }
 
    void setVoxel( unsigned int x, unsigned int y, unsigned int z, const math::Vector3f& normal )
    {
        LIBCARNA_ASSERT( x < size.x() && y < size.y() && z < size.z() );
        const std::size_t index = 4 * ( x + size.x() * y + size.y() * size.x() * z );
        myBuffer->get()->at( index + 0 ) = encodeComponent( normal.x() );
        myBuffer->get()->at( index + 1 ) = encodeComponent( normal.y() );
        myBuffer->get()->at( index + 2 ) = encodeComponent( normal.z() );
    }
 
    BufferType& buffer()
    {
        return **myBuffer;
    }
    
    const BufferType& buffer() const
    {
        return **myBuffer;
    }
 
protected:
 
    const std::unique_ptr< Association< BufferType > > myBuffer;
 
private:
 
    void checkBuffer()
    {
        LIBCARNA_ASSERT_EX
            ( myBuffer.get() && myBuffer->get()
            , "No volume data buffer supplied!" );
 
        LIBCARNA_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 "
                << 4 * sizeof( BufferedVectorComponentType ) * size.x() * size.y() * size.z()
                << " bytes!" );
    }
 
}; // BufferedNormalMap3D
 
 
 
}  // namespace LibCarna :: base
 
}  // namespace LibCarna
 
#endif // BUFFEREDNORMALMAP3D_H_6014714286