VolumeGrid.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 VOLUMEGRID_H_6014714286
#define VOLUMEGRID_H_6014714286
 
#include <LibCarna/LibCarna.hpp>
#include <LibCarna/base/IntensityVolume.hpp>
#include <LibCarna/base/VolumeSegment.hpp>
#include <LibCarna/base/LibCarnaException.hpp>
 
namespace LibCarna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
class VolumeGrid
{
 
    NON_COPYABLE
 
public:
 
    typedef SegmentIntensityVolumeType SegmentIntensityVolume;
 
    typedef SegmentNormalsVolumeType SegmentNormalsVolume;
 
    typedef VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType > Segment;
 
    VolumeGrid( const math::Vector3ui& maxSegmentSize, const math::Vector3ui& segmentCounts );
 
    virtual ~VolumeGrid();
 
    const math::Vector3ui maxSegmentSize; 
    const math::Vector3ui segmentCounts;  
 
    Segment& segmentAt( const base::math::Vector3ui& location );
 
    const Segment& segmentAt( const base::math::Vector3ui& ) const;
    
    Segment& segmentAt( unsigned int segmentX, unsigned int segmentY, unsigned int segmentZ );
    
    const Segment& segmentAt( unsigned int segmentX, unsigned int segmentY, unsigned int segmentZ ) const;
 
    // ------------------------------------------------------------------------------
    // VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType > :: IntensitySelector
    // ------------------------------------------------------------------------------
 
    struct IntensitySelector
    {
        typedef typename SegmentIntensityVolumeType::Value VoxelType;
 
        static SegmentIntensityVolumeType& volume( Segment& segment );
 
        static const SegmentIntensityVolumeType& volume( const Segment& segment );
    };
    
    // ------------------------------------------------------------------------------
    // VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType > :: NormalSelector
    // ------------------------------------------------------------------------------
 
    struct NormalSelector
    {
        typedef typename SegmentNormalsVolumeType::Value VoxelType;
 
        static SegmentNormalsVolumeType& volume( Segment& segment );
 
        static const SegmentNormalsVolumeType& volume( const Segment& segment );
    };
 
    // ------------------------------------------------------------------------------
 
    template< typename Selector >
    typename Selector::VoxelType getVoxel( const math::Vector3ui& location );
 
    template< typename Selector >
    typename Selector::VoxelType getVoxel( unsigned int x, unsigned int y, unsigned int z );
    
    template< typename Selector >
    void setVoxel( const math::Vector3ui& location, const typename Selector::VoxelType& voxel );
    
    template< typename Selector >
    void setVoxel( unsigned int x, unsigned int y, unsigned int z, const typename Selector::VoxelType& voxel );
 
private:
 
    std::vector< Segment* > segments;
 
    std::size_t segmentIndex( unsigned int segmentX, unsigned int segmentY, unsigned int segmentZ ) const;
 
}; // VolumeGrid
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::VolumeGrid
        ( const math::Vector3ui& maxSegmentSize
        , const math::Vector3ui& segmentCounts )
    : maxSegmentSize( maxSegmentSize )
    , segmentCounts( segmentCounts )
{
    LIBCARNA_ASSERT( maxSegmentSize.x() > 0 && maxSegmentSize.y() > 0 && maxSegmentSize.z() > 0 );
    LIBCARNA_ASSERT(  segmentCounts.x() > 0 &&  segmentCounts.y() > 0 &&  segmentCounts.z() > 0 );
    segments.resize( segmentCounts.x() * segmentCounts.y() * segmentCounts.z() );
    for( unsigned int z = 0; z < segmentCounts.z(); ++z )
    for( unsigned int y = 0; y < segmentCounts.y(); ++y )
    for( unsigned int x = 0; x < segmentCounts.x(); ++x )
    {
        const std::size_t index = segmentIndex( x, y, z );
        Segment* const segment = new Segment( *this );
        segment->offset = math::Vector3ui( x * maxSegmentSize.x(), y * maxSegmentSize.y(), z * maxSegmentSize.z() );
        segments[ index ] = segment;
    }
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::~VolumeGrid()
{
    std::for_each( segments.begin(), segments.end(), std::default_delete< Segment >() );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
std::size_t VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::segmentIndex
    ( unsigned int segmentX
    , unsigned int segmentY
    , unsigned int segmentZ ) const
{
    return segmentX + segmentY * segmentCounts.x() + segmentZ * segmentCounts.x() * segmentCounts.y();
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
typename VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::Segment&
    VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::segmentAt
        ( const base::math::Vector3ui& p )
{
    return segmentAt( p.x(), p.y(), p.z() );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const typename VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::Segment&
    VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::segmentAt
        ( const base::math::Vector3ui& p ) const
{
    return segmentAt( p.x(), p.y(), p.z() );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
typename VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::Segment&
    VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::segmentAt
        ( unsigned int segmentX
        , unsigned int segmentY
        , unsigned int segmentZ )
{
    const std::size_t index = segmentIndex( segmentX, segmentY, segmentZ );
    Segment& segment = *segments[ index ];
    return segment;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const typename VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::Segment&
    VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::segmentAt
        ( unsigned int segmentX
        , unsigned int segmentY
        , unsigned int segmentZ ) const
{
    const std::size_t index = segmentIndex( segmentX, segmentY, segmentZ );
    const Segment& segment = *segments[ index ];
    return segment;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
template< typename Selector >
typename Selector::VoxelType VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::getVoxel
    ( unsigned int x, unsigned int y, unsigned int z )
{
    const unsigned int segmentX = x / maxSegmentSize.x();
    const unsigned int segmentY = y / maxSegmentSize.y();
    const unsigned int segmentZ = z / maxSegmentSize.z();
 
    const unsigned int localX = x % maxSegmentSize.x();
    const unsigned int localY = y % maxSegmentSize.y();
    const unsigned int localZ = z % maxSegmentSize.z();
 
    const Segment& segment = segmentAt( segmentX, segmentY, segmentZ );
    return Selector::volume( segment )( localX, localY, localZ );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
template< typename Selector >
typename Selector::VoxelType VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::getVoxel
    ( const math::Vector3ui& at )
{
    return getVoxel< Selector >( at.x(), at.y(), at.z() );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
template< typename Selector >
void VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::setVoxel
    ( unsigned int x, unsigned int y, unsigned int z, const typename Selector::VoxelType& voxel )
{
    const unsigned int segmentX = x / maxSegmentSize.x();
    const unsigned int segmentY = y / maxSegmentSize.y();
    const unsigned int segmentZ = z / maxSegmentSize.z();
 
    const unsigned int localX = x % maxSegmentSize.x();
    const unsigned int localY = y % maxSegmentSize.y();
    const unsigned int localZ = z % maxSegmentSize.z();
 
    Segment& segment = segmentAt( segmentX, segmentY, segmentZ );
    Selector::volume( segment ).setVoxel( localX, localY, localZ, voxel );
 
    /* Note that segments are not disjoint,
     * so we might need to update the redundant texels as well.
     */
    const bool updateRedundantX = localX == 0 && segmentX > 0;
    const bool updateRedundantY = localY == 0 && segmentY > 0;
    const bool updateRedundantZ = localZ == 0 && segmentZ > 0;
 
    if( updateRedundantX )
    {
        Selector::volume( segmentAt( segmentX - 1, segmentY, segmentZ ) )
            .setVoxel( maxSegmentSize.x(), localY, localZ, voxel );
    }
    if( updateRedundantY )
    {
        Selector::volume( segmentAt( segmentX, segmentY - 1, segmentZ ) )
            .setVoxel( localX, maxSegmentSize.y(), localZ, voxel );
    }
    if( updateRedundantZ )
    {
        Selector::volume( segmentAt( segmentX, segmentY, segmentZ - 1 ) )
            .setVoxel( localX, localY, maxSegmentSize.z(), voxel );
    }
 
    if( updateRedundantX && updateRedundantY )
    {
        Selector::volume( segmentAt( segmentX - 1, segmentY - 1, segmentZ ) )
            .setVoxel( maxSegmentSize.x(), maxSegmentSize.y(), localZ, voxel );
    }
    if( updateRedundantX && updateRedundantZ )
    {
        Selector::volume( segmentAt( segmentX - 1, segmentY, segmentZ - 1 ) )
            .setVoxel( maxSegmentSize.x(), localY, maxSegmentSize.z(), voxel );
    }
    if( updateRedundantY && updateRedundantZ )
    {
        Selector::volume( segmentAt( segmentX, segmentY - 1, segmentZ - 1 ) )
            .setVoxel( localX, maxSegmentSize.y(), maxSegmentSize.z(), voxel );
    }
 
    if( updateRedundantX && updateRedundantY && updateRedundantZ )
    {
        Selector::volume( segmentAt( segmentX - 1, segmentY - 1, segmentZ - 1 ) )
            .setVoxel( maxSegmentSize, voxel );
    }
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
template< typename Selector >
void VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::setVoxel
    ( const math::Vector3ui& at, const typename Selector::VoxelType& voxel )
{
    setVoxel< Selector >( at.x(), at.y(), at.z(), voxel );
}
 
 
 
// ----------------------------------------------------------------------------------
// VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType > :: IntensitySelector
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
SegmentIntensityVolumeType& VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::IntensitySelector::volume
    ( VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return segment.intensities();
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const SegmentIntensityVolumeType& VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::IntensitySelector::volume
    ( const VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return segment.intensities();
}
 
 
 
// ----------------------------------------------------------------------------------
// VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType > :: NormalSelector
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
SegmentNormalsVolumeType& VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::NormalSelector::volume
    ( VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return segment.normals();
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const SegmentNormalsVolumeType& VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::NormalSelector::volume
    ( const VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& segment )
{
    return segment.normals();
}
 
 
 
}  // namespace LibCarna :: base
 
}  // namespace LibCarna
 
#endif // VOLUMEGRID_H_6014714286