VolumeSegment.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 VOLUMESEGMENT_H_6014714286
#define VOLUMESEGMENT_H_6014714286
 
#include <LibCarna/LibCarna.hpp>
#include <LibCarna/base/Association.hpp>
#include <LibCarna/base/LibCarnaException.hpp>
#include <LibCarna/base/VolumeGrid.hpp>
#include <memory>
 
namespace LibCarna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >
// ----------------------------------------------------------------------------------
 
template< typename SegmentNormalsVolumeType >
class VolumeSegmentNormalsComponent
{
 
    NON_COPYABLE
 
    std::unique_ptr< Association< SegmentNormalsVolumeType > > myNormals;
 
public:
    
    virtual ~VolumeSegmentNormalsComponent();
    
    void setNormals( Association< SegmentNormalsVolumeType >* volume );
 
    SegmentNormalsVolumeType& normals();
 
    const SegmentNormalsVolumeType& normals() const;
    
    bool hasNormals() const;
 
}; // VolumeSegmentNormalsComponent
 
 
template< typename SegmentNormalsVolumeType >
VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::~VolumeSegmentNormalsComponent()
{
}
 
 
template< typename SegmentNormalsVolumeType >
void VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::setNormals( Association< SegmentNormalsVolumeType >* normals )
{
    myNormals.reset( normals );
}
 
 
template< typename SegmentNormalsVolumeType >
SegmentNormalsVolumeType& VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::normals()
{
    LIBCARNA_ASSERT( hasNormals() );
    return **myNormals;
}
 
 
template< typename SegmentNormalsVolumeType >
const SegmentNormalsVolumeType& VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::normals() const
{
    LIBCARNA_ASSERT( hasNormals() );
    return **myNormals;
}
 
 
template< typename SegmentNormalsVolumeType >
bool VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::hasNormals() const
{
    return myNormals.get() != nullptr && myNormals->get() != nullptr;
}
 
 
 
// ----------------------------------------------------------------------------------
// VolumeSegmentNormalsComponent< void >
// ----------------------------------------------------------------------------------
 
template< >
class VolumeSegmentNormalsComponent< void >
{
 
public:
 
    virtual ~VolumeSegmentNormalsComponent();
 
}; // VolumeSegmentNormalsComponent
 
 
inline VolumeSegmentNormalsComponent< void >::~VolumeSegmentNormalsComponent()
{
}
 
 
 
// ----------------------------------------------------------------------------------
// VolumeSegment
// ----------------------------------------------------------------------------------
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
class VolumeSegment : public VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >
{
 
    NON_COPYABLE
 
public:
    
    typedef VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType > Grid;
    
    typedef SegmentIntensityVolumeType IntensityVolume;
    
    typedef SegmentNormalsVolumeType NormalsVolume;
 
    Grid& grid;
 
    VolumeSegment( Grid& grid );
 
    void setIntensities( Association< SegmentIntensityVolumeType >* intensities );
 
    SegmentIntensityVolumeType& intensities();
 
    const SegmentIntensityVolumeType& intensities() const;
 
    bool hasIntensities() const;
 
    math::Vector3ui offset;
 
private:
 
    std::unique_ptr< Association< SegmentIntensityVolumeType > > myIntensities;
 
}; // VolumeSegment
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::VolumeSegment
        ( VolumeGrid< SegmentIntensityVolumeType, SegmentNormalsVolumeType >& grid )
    : grid( grid )
{
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
void VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::setIntensities( Association< SegmentIntensityVolumeType >* intensities )
{
    myIntensities.reset( intensities );
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
SegmentIntensityVolumeType& VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::intensities()
{
    LIBCARNA_ASSERT( hasIntensities() );
    return **myIntensities;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const SegmentIntensityVolumeType& VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::intensities() const
{
    LIBCARNA_ASSERT( hasIntensities() );
    return **myIntensities;
}
 
 
template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
bool VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::hasIntensities() const
{
    return myIntensities.get() != nullptr && myIntensities->get() != nullptr;
}
 
 
 
}  // namespace LibCarna :: base
 
}  // namespace LibCarna
 
#endif // VOLUMESEGMENT_H_6014714286