VolumeGridHelper.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 VOLUMEGRIDHELPER_H_6014714286
#define VOLUMEGRIDHELPER_H_6014714286

#include <Carna/helpers/VolumeGridHelperDetails.h>
#include <Carna/Carna.h>
#include <Carna/base/Node.h>
#include <Carna/base/math.h>
#include <Carna/base/VolumeGrid.h>
#include <Carna/base/VolumeSegment.h>
#include <Carna/base/Geometry.h>
#include <Carna/base/BoundingBox.h>
#include <memory>
#include <cmath>

namespace Carna
{

namespace helpers
{



// ----------------------------------------------------------------------------------
// VolumeGridHelperBase
// ----------------------------------------------------------------------------------

class CARNA_LIB VolumeGridHelperBase
{

public:

    const static std::size_t DEFAULT_MAX_SEGMENT_BYTESIZE = 2 * 300 * 300 * 300;

    VolumeGridHelperBase( const base::math::Vector3ui& nativeResolution );

    const base::math::Vector3ui nativeResolution;

    virtual ~VolumeGridHelperBase();

    virtual void releaseGeometryFeatures() = 0;

    struct CARNA_LIB Spacing
    {
        explicit Spacing( const base::math::Vector3f& millimeters );

        base::math::Vector3f millimeters;
    };
    
    struct CARNA_LIB Dimensions
    {
        explicit Dimensions( const base::math::Vector3f& millimeters );

        base::math::Vector3f millimeters;
    };

    virtual base::Node* createNode( unsigned int geometryType, const Spacing& spacing ) const = 0;
    
    virtual base::Node* createNode( unsigned int geometryType, const Dimensions& dimensions ) const = 0;
    
    virtual void loadData( const std::function< base::HUV( const base::math::Vector3ui& ) >& data ) = 0;

}; // VolumeGridHelperBase



// ----------------------------------------------------------------------------------
// VolumeGridHelper
// ----------------------------------------------------------------------------------

template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
class VolumeGridHelper
    : public VolumeGridHelperBase
    , public details::VolumeGridHelper::HUComponent     < SegmentHUVolumeType, SegmentNormalsVolumeType >
    , public details::VolumeGridHelper::NormalsComponent< SegmentHUVolumeType, SegmentNormalsVolumeType >
{

    NON_COPYABLE

    typedef details::VolumeGridHelper::HUComponent     < SegmentHUVolumeType, SegmentNormalsVolumeType > HUComponent;
    typedef details::VolumeGridHelper::NormalsComponent< SegmentHUVolumeType, SegmentNormalsVolumeType > NormalsComponent;

    std::unique_ptr< base::VolumeGrid< SegmentHUVolumeType, SegmentNormalsVolumeType > > myGrid;

public:

    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    VolumeGridHelper( const base::math::Vector3ui& nativeResolution, std::size_t maxSegmentBytesize = DEFAULT_MAX_SEGMENT_BYTESIZE );

    const std::size_t maxSegmentBytesize;

    const base::math::Vector3ui maxSegmentSize;

    const details::VolumeGridHelper::Partionining partitioningX;
    
    const details::VolumeGridHelper::Partionining partitioningY;
    
    const details::VolumeGridHelper::Partionining partitioningZ;

    const base::math::Vector3ui resolution;

    template< typename UnaryVector3uiToHUVFunction >
    void loadData( const UnaryVector3uiToHUVFunction& data );
    
    virtual void loadData( const std::function< base::HUV( const base::math::Vector3ui& ) >& data ) override;
    
    virtual void releaseGeometryFeatures() override;

    base::VolumeGrid< SegmentHUVolumeType, SegmentNormalsVolumeType >& grid() const;

    virtual base::Node* createNode( unsigned int geometryType, const Spacing& spacing ) const override;
    
    virtual base::Node* createNode( unsigned int geometryType, const Dimensions& dimensions ) const override;
    
protected:

    virtual base::math::Vector3ui gridResolution() const override;

private:

    base::Node* createNode
        ( unsigned int geometryType
        , const Spacing& spacing
        , const Dimensions& dimensions ) const;

    static base::math::Vector3ui computeMaxSegmentSize( const base::math::Vector3ui& nativeResolution, std::size_t maxSegmentBytesize );

}; // VolumeGridHelper


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::math::Vector3ui VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::computeMaxSegmentSize
    ( const base::math::Vector3ui& nativeResolution, std::size_t maxSegmentBytesize )
{
    const float maxSideLengthF = std::pow
        ( maxSegmentBytesize / static_cast< float >( sizeof( typename SegmentHUVolumeType::Voxel ) ), 1.f / 3 );
    const unsigned int maxSideLength = base::math::makeEven( base::math::round_ui( maxSideLengthF ), -1 );

    /* We subtract the redundant texels from effective segment size.
     * Note that this causes the effective maximum segment size to be odd.
     */
    return base::math::Vector3ui( maxSideLength - 1, maxSideLength - 1, maxSideLength - 1 );
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::VolumeGridHelper
        ( const base::math::Vector3ui& nativeResolution
        , std::size_t maxSegmentBytesize )
    : VolumeGridHelperBase( nativeResolution )
    , maxSegmentBytesize( maxSegmentBytesize )
    , maxSegmentSize( computeMaxSegmentSize( nativeResolution, maxSegmentBytesize ) )
    , partitioningX( nativeResolution.x(), maxSegmentSize.x() )
    , partitioningY( nativeResolution.y(), maxSegmentSize.y() )
    , partitioningZ( nativeResolution.z(), maxSegmentSize.z() )
    , resolution( partitioningX.totalSize(), partitioningY.totalSize(), partitioningZ.totalSize() )
{
    const base::math::Vector3ui segmentCounts
        ( partitioningX.partitionsCount()
        , partitioningY.partitionsCount()
        , partitioningZ.partitionsCount() );
    myGrid.reset( new base::VolumeGrid< SegmentHUVolumeType, SegmentNormalsVolumeType >( maxSegmentSize, segmentCounts ) );
    NormalsComponent::setGrid( *myGrid );

    CARNA_FOR_VECTOR3UI( segmentCoord, myGrid->segmentCounts )
    {
        /* Here we add the redundant texels to the buffer size considerations.
         */
        const base::math::Vector3ui segmentSize
            ( segmentCoord.x() + 1 == myGrid->segmentCounts.x() ? partitioningX.tailSize : partitioningX.regularPartitionSize + 1
            , segmentCoord.y() + 1 == myGrid->segmentCounts.y() ? partitioningY.tailSize : partitioningY.regularPartitionSize + 1
            , segmentCoord.z() + 1 == myGrid->segmentCounts.z() ? partitioningZ.tailSize : partitioningZ.regularPartitionSize + 1 );

        HUComponent     ::initializeSegment( myGrid->segmentAt( segmentCoord ), segmentSize );
        NormalsComponent::initializeSegment( myGrid->segmentAt( segmentCoord ), segmentSize );
    }
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
void VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::releaseGeometryFeatures()
{
    HUComponent     ::releaseGeometryFeatures();
    NormalsComponent::releaseGeometryFeatures();
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
template< typename UnaryVector3uiToHUVFunction >
void VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::loadData
    ( const UnaryVector3uiToHUVFunction& data )
{
    releaseGeometryFeatures();
    CARNA_FOR_VECTOR3UI( coord, resolution )
    {
        const bool outOfNativeBounds
            =  coord.x() >= nativeResolution.x()
            || coord.y() >= nativeResolution.y()
            || coord.z() >= nativeResolution.z();
        const base::HUV huv = outOfNativeBounds ? -1024 : data( coord );
        myGrid->template setVoxel< typename base::VolumeGrid< SegmentHUVolumeType, SegmentNormalsVolumeType >::HUVSelector >( coord, huv );
    }
    NormalsComponent::computeNormals();
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
void VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::loadData
    ( const std::function< base::HUV( const base::math::Vector3ui& ) >& data )
{
    loadData< std::function< base::HUV( const base::math::Vector3ui& ) > >( data );
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::VolumeGrid< SegmentHUVolumeType, SegmentNormalsVolumeType >&
    VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::grid() const
{
    return *myGrid;
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::Node* VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::createNode
    ( unsigned int geometryType, const Spacing& spacing, const Dimensions& dimensions ) const
{
    /* Compute dimensions of a regular grid segment,
     * taking the redundant texels into account.
     */
    const base::math::Vector3f regularSegmentDimensions = dimensions.millimeters.cwiseMin( base::math::Vector3f
        ( spacing.millimeters.x() * partitioningX.regularPartitionSize
        , spacing.millimeters.y() * partitioningY.regularPartitionSize
        , spacing.millimeters.z() * partitioningZ.regularPartitionSize ) );
    
    /* Create pivot node that shifts it's children to a corner.
     */
    base::Node* const pivot = new base::Node();
    pivot->localTransform = base::math::translation4f( ( regularSegmentDimensions - dimensions.millimeters ) / 2 );
    pivot->setMovable( false );

    /* Create geometry nodes for all grid segments.
     */
    CARNA_FOR_VECTOR3UI( segmentCoord, myGrid->segmentCounts )
    {
        const base::VolumeSegment< SegmentHUVolumeType, SegmentNormalsVolumeType >& segment = myGrid->segmentAt( segmentCoord );

        /* Compute dimensions of particular grid segment.
         */
        const bool isTail =
               segmentCoord.x() + 1 == myGrid->segmentCounts.x()
            || segmentCoord.y() + 1 == myGrid->segmentCounts.y()
            || segmentCoord.z() + 1 == myGrid->segmentCounts.z();
        const base::math::Vector3ui& volumeSize = segment.huVolume().size;
        const base::math::Vector3f dimensions = !isTail ? regularSegmentDimensions
            : ( ( volumeSize.cast< int >() - base::math::Vector3i( 1, 1, 1 ) )
                .cast< float >().cwiseProduct( spacing.millimeters ) );

        /* Create geometry node for particular grid segment.
         */
        base::Geometry* const geom = new base::Geometry( geometryType );
        pivot->attachChild( geom );
        HUComponent     ::attachTexture( *geom, segment );
        NormalsComponent::attachTexture( *geom, segment );
        geom->setMovable( false );
        geom->setBoundingVolume( new base::BoundingBox( 1, 1, 1 ) );
        geom->localTransform
            = base::math::translation4f( segmentCoord.cast< float >().cwiseProduct( regularSegmentDimensions )
                - ( !isTail
                    ? base::math::Vector3f( 0, 0, 0 )
                    : ( regularSegmentDimensions - dimensions ) / 2 ) )
            * base::math::scaling4f( dimensions );
    }

    /* We're done.
     */
    return pivot;
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::Node* VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::createNode
    ( unsigned int geometryType, const Spacing& spacing ) const
{
    const base::math::Vector3f dimensions
        = ( resolution.cast< int >() - base::math::Vector3i( 1, 1, 1 ) ).cast< float >().cwiseProduct( spacing.millimeters );
    return createNode( geometryType, spacing, Dimensions( dimensions ) );
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::Node* VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::createNode
    ( unsigned int geometryType, const Dimensions& dimensions ) const
{
    const base::math::Vector3f& mmDimensions = dimensions.millimeters;
    const base::math::Vector3f spacing
        = mmDimensions.cast< float >().cwiseQuotient( ( resolution.cast< int >() - base::math::Vector3i( 1, 1, 1 ) ).cast< float >() );
    return createNode( geometryType, Spacing( spacing ), dimensions );
}


template< typename SegmentHUVolumeType, typename SegmentNormalsVolumeType >
base::math::Vector3ui VolumeGridHelper< SegmentHUVolumeType, SegmentNormalsVolumeType >::gridResolution() const
{
    return resolution;
}



}  // namespace Carna :: helpers

}  // namespace Carna

#endif // VOLUMEGRIDHELPER_H_6014714286