VolumeGridHelperDetails.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 VOLUMEGRIDHELPERDETAILS_H_6014714286
#define VOLUMEGRIDHELPERDETAILS_H_6014714286
 
#include <Carna/Carna.h>
#include <Carna/base/VolumeGrid.h>
#include <Carna/base/VolumeSegment.h>
#include <Carna/base/BufferedVectorFieldTexture.h>
#include <Carna/base/BufferedNormalMap3D.h>
#include <Carna/base/Geometry.h>
#include <Carna/base/Log.h>
#include <Carna/base/Stopwatch.h>
#include <Carna/base/text.h>
#include <map>
 
namespace Carna
{
 
namespace helpers
{
 
namespace details
{
 
namespace VolumeGridHelper
{
 
 
 
// ----------------------------------------------------------------------------------
// IntensityTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
struct IntensityTextureFactory
{
    typedef SegmentIntensityVolumeType SegmentIntensityVolume;
 
    typedef SegmentNormalsVolumeType SegmentNormalsVolume;
 
    static base::ManagedTexture3D& createTexture
        ( const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment );
};
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
base::ManagedTexture3D& IntensityTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::createTexture
    ( const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return base::BufferedVectorFieldTexture< SegmentIntensityVolumeType >::create( segment.intensities() );
}
 
 
 
// ----------------------------------------------------------------------------------
// NormalsTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
struct NormalsTextureFactory
{
    typedef SegmentIntensityVolumeType SegmentIntensityVolume;
 
    typedef SegmentNormalsVolumeType SegmentNormalsVolume;
    
    static base::ManagedTexture3D& createTexture
        ( const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment );
};
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
base::ManagedTexture3D& NormalsTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::createTexture
    ( const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return base::BufferedVectorFieldTexture< SegmentNormalsVolumeType >::create( segment.normals() );
}
 
 
 
// ----------------------------------------------------------------------------------
// TextureManager< TextureFactory >
// ----------------------------------------------------------------------------------
 
template< typename TextureFactory >
class TextureManager
{
 
    NON_COPYABLE
 
    mutable std::map
        < const base::VolumeSegment
            < typename TextureFactory::SegmentIntensityVolume
            , typename TextureFactory::SegmentNormalsVolume >*
        , base::ManagedTexture3D* > textures;
 
public:
 
    virtual ~TextureManager();
 
    void releaseGeometryFeatures();
 
protected:
 
    void attachTexture
        ( base::Geometry& geometry
        , unsigned int role
        , const base::VolumeSegment
            < typename TextureFactory::SegmentIntensityVolume
            , typename TextureFactory::SegmentNormalsVolume >& segment ) const;
 
private:
 
    base::ManagedTexture3D& getTexture
        ( const base::VolumeSegment
            < typename TextureFactory::SegmentIntensityVolume
            , typename TextureFactory::SegmentNormalsVolume >& segment ) const;
 
}; // TextureManager
 
 
template< typename TextureFactory >
TextureManager< TextureFactory >::~TextureManager()
{
    releaseGeometryFeatures();
}
 
 
template< typename TextureFactory >
void TextureManager< TextureFactory >::releaseGeometryFeatures()
{
    for( auto itr = textures.begin(); itr != textures.end(); ++itr )
    {
        base::ManagedTexture3D& texture = *itr->second;
        texture.release();
    }
    textures.clear();
}
 
 
template< typename TextureFactory >
void TextureManager< TextureFactory >::attachTexture
    ( base::Geometry& geometry
    , unsigned int role
    , const base::VolumeSegment
        < typename TextureFactory::SegmentIntensityVolume
        , typename TextureFactory::SegmentNormalsVolume >& segment ) const
{
    base::ManagedTexture3D& texture = getTexture( segment );
    geometry.putFeature( role, texture );
}
 
 
template< typename TextureFactory >
base::ManagedTexture3D& TextureManager< TextureFactory >::getTexture
    ( const base::VolumeSegment
        < typename TextureFactory::SegmentIntensityVolume
        , typename TextureFactory::SegmentNormalsVolume >& segment ) const
{
    auto textureItr = textures.find( &segment );
    if( textureItr == textures.end() )
    {
        /* Create the texture.
         */
        base::ManagedTexture3D& texture = TextureFactory::createTexture( segment );
        textures[ &segment ] = &texture;
        return texture;
    }
    else
    {
        /* Use previously created texture.
         */
        return *textureItr->second;
    }
}
 
 
 
// ----------------------------------------------------------------------------------
// IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
class IntensityComponent : public TextureManager< IntensityTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType > >
{
 
    unsigned int role;
 
public:
 
    const static unsigned int DEFAULT_ROLE_INTENSITIES = 0;
 
    IntensityComponent();
 
    void setIntensitiesRole( unsigned int role );
    
    unsigned int intensitiesRole() const;
 
protected:
 
    void attachTexture
        ( base::Geometry& geometry
        , const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment ) const;
 
    void initializeSegment
        ( base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment
        , const base::math::Vector3ui& size ) const;
 
}; // IntensityComponent
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::IntensityComponent()
    : role( DEFAULT_ROLE_INTENSITIES )
{
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::setIntensitiesRole( unsigned int role )
{
    this->role = role;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
unsigned int IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::intensitiesRole() const
{
    return role;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::attachTexture
    ( base::Geometry& geometry
    , const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment ) const
{
    TextureManager< IntensityTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType > >
        ::attachTexture( geometry, role, segment );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void IntensityComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::initializeSegment
    ( base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment
    , const base::math::Vector3ui& size ) const
{
    SegmentIntensityVolumeType* const intensities = new SegmentIntensityVolumeType( size );
    segment.setIntensities( new base::Composition< SegmentIntensityVolumeType >( intensities ) );
}
 
 
 
// ----------------------------------------------------------------------------------
// NormalsComponentBase
// ----------------------------------------------------------------------------------
 
class CARNA_LIB NormalsComponentBase
{
 
public:
 
    virtual ~NormalsComponentBase();
 
protected:
 
    virtual base::math::Vector3ui gridResolution() const = 0;
 
}; // NormalsComponentBase
 
 
 
// ----------------------------------------------------------------------------------
// NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
class NormalsComponent
    : public TextureManager< NormalsTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType > >
    , public NormalsComponentBase
{
 
    unsigned int role;
    base::VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >* grid;
 
public:
    
    const static unsigned int DEFAULT_ROLE_NORMALS = 1;
    
    NormalsComponent();
    
    void setNormalsRole( unsigned int role );
    
    unsigned int normalsRole() const;
 
    void computeNormals();
 
protected:
 
    void setGrid( base::VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& grid );
    
    void attachTexture
        ( base::Geometry& geometry
        , const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment ) const;
    
    void initializeSegment
        ( base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment
        , const base::math::Vector3ui& size ) const;
 
}; // NormalsComponent
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::NormalsComponent()
    : role( DEFAULT_ROLE_NORMALS )
{
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::setNormalsRole( unsigned int role )
{
    this->role = role;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
unsigned int NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::normalsRole() const
{
    return role;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::computeNormals()
{
    typedef typename base::VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::   NormalSelector    NormalSelector;
    typedef typename base::VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::IntensitySelector IntensitySelector;
 
    using base::math::Vector3ui;
    using base::math::Vector3i;
    using base::math::Vector3f;
    
    const base::Stopwatch stopwatch;
    const Vector3ui resolution = gridResolution();
 
    /* Lets start with the normals for the edge faces of the volume, that do require
     * an ad-hoc processing.
     */
    for( unsigned int dim0 = 0; dim0 < 3; ++dim0 )
    {
        for( signed int sign = -1; sign <= +1; sign += 2 )
        {
            /* Construct the normal vector along dimension 'dim0' signed with 'sign'.
             */
            Vector3f normal( 0, 0, 0 );
            normal( dim0 ) = sign;
 
            /* Write the normal vector to the whole face.
             */
            const unsigned int dim1 = ( dim0 + 1 ) % 3;
            const unsigned int dim2 = ( dim0 + 2 ) % 3;
 
            Vector3ui coord;
            coord( dim0 ) = sign < 0 ? 0 : resolution( dim0 ) - 1;
 
            for( coord( dim1 ) = 0; coord( dim1 ) < resolution( dim1 ); ++coord( dim1 ) )
            for( coord( dim2 ) = 0; coord( dim2 ) < resolution( dim2 ); ++coord( dim2 ) )
            {
                grid->template setVoxel< NormalSelector >( coord, normal );
            }
        }
    }
 
    /* Now we can process all the inner voxels regularly.
    */
    const Vector3ui coordLowerBound = Vector3ui( 1, 1, 1 );
    const Vector3ui coordUpperBound = ( resolution.cast< int >() - Vector3i( 1, 1, 1 ) ).cast< unsigned int >();
    CARNA_FOR_VECTOR3UI_EX( coord, coordUpperBound, coordLowerBound )
    {
        /* Compute the gradient vector.
         */
        const Vector3f gradient = base::math::computeFastGradient3f(
            [this, &coord]( unsigned int dx, unsigned int dy, unsigned int dz )
            {
                return grid->template getVoxel< IntensitySelector >( Vector3ui( coord.x() + dx, coord.y() + dy, coord.z() + dz ) );
            }
        );
 
        /* The normal vector points to the *reverse* direction of the gradient, i.e.
         * away from the steepest ascent.
         */
        Vector3f normal = -gradient;
        if( normal.squaredNorm() > 1e-12 )
        {
            normal.normalize();
        }
        else
        {
            normal = Vector3f( 0, 0, 0 );
        }
        grid->template setVoxel< NormalSelector >( coord, normal );
    }
    
    /* Log how long it took to compute the normals.
     */
    const unsigned int seconds = base::math::round_ui( stopwatch.result() );
    base::Log::instance().record( base::Log::verbose
        , "VolumeGridHelper finished normals computation in "
        + base::text::lexical_cast< std::string >( seconds )
        + " seconds." );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
    ::setGrid( base::VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& grid )
{
    this->grid = &grid;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::attachTexture
    ( base::Geometry& geometry
    , const base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment ) const
{
    TextureManager< NormalsTextureFactory< SegmentIntensityVolumeType, SegmentNormalsVolumeType > >
        ::attachTexture( geometry, role, segment );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::initializeSegment
    ( base::VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment
    , const base::math::Vector3ui& size ) const
{
    SegmentNormalsVolumeType* const normals = new SegmentNormalsVolumeType( size );
    segment.setNormals( new base::Composition< SegmentNormalsVolumeType >( normals ) );
}
 
 
 
// ----------------------------------------------------------------------------------
// NormalsComponent< SegmentIntensityVolumeType, void >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType >
class NormalsComponent< SegmentIntensityVolumeType, void > : public NormalsComponentBase
{
 
public:
 
    void releaseGeometryFeatures();
 
protected:
    
    void computeNormals();
    
    void setGrid( base::VolumeGrid< SegmentIntensityVolumeType, void >& grid );
    
    void attachTexture
        ( base::Geometry& geometry
        , const base::VolumeSegment< SegmentIntensityVolumeType, void >& segment ) const;
    
    void initializeSegment
        ( base::VolumeSegment< SegmentIntensityVolumeType, void >& segment
        , const base::math::Vector3ui& size ) const;
 
}; // NormalsComponent
 
 
template< typename SegmentIntensityVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, void >::releaseGeometryFeatures()
{
}
 
 
template< typename SegmentIntensityVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, void >::computeNormals()
{
}
 
 
template< typename SegmentIntensityVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, void >::setGrid
    ( base::VolumeGrid< SegmentIntensityVolumeType, void >& grid )
{
}
 
 
template< typename SegmentIntensityVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, void >::attachTexture
    ( base::Geometry& geometry
    , const base::VolumeSegment< SegmentIntensityVolumeType, void >& segment ) const
{
}
 
 
template< typename SegmentIntensityVolumeType >
void NormalsComponent< SegmentIntensityVolumeType, void >::initializeSegment
    ( base::VolumeSegment< SegmentIntensityVolumeType, void >& segment
    , const base::math::Vector3ui& size ) const
{
}
 
 
 
// ----------------------------------------------------------------------------------
// Partionining
// ----------------------------------------------------------------------------------
 
struct Partionining
{
    Partionining( std::size_t nativeSize, std::size_t regularPartitionSize )
        : regularPartitionSize( regularPartitionSize )
        , regularPartitionsCount( nativeSize / regularPartitionSize )
        , tailSize( base::math::makeEven( nativeSize % regularPartitionSize, +1 ) )
    {
        CARNA_ASSERT_EX( regularPartitionSize % 2 == 1, "Effective regular partition size must be odd!" );
    }
 
    std::size_t regularPartitionSize;
 
    std::size_t regularPartitionsCount;
 
    std::size_t tailSize;
 
    std::size_t totalSize() const
    {
        return tailSize + regularPartitionsCount * regularPartitionSize;
    }
 
    std::size_t partitionsCount() const
    {
        return regularPartitionsCount + ( tailSize > 0 ? 1 : 0 );
    }
};
 
 
 
}  // namespace VolumeGridHelper
 
}  // namespace details
 
}  // namespace Carna :: helpers
 
}  // namespace Carna
 
#endif // VOLUMEGRIDHELPERDETAILS_H_6014714286