VolumeSegment.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 VOLUMESEGMENT_H_6014714286
#define VOLUMESEGMENT_H_6014714286

#include <Carna/Carna.h>
#include <Carna/base/Association.h>
#include <Carna/base/CarnaException.h>
#include <Carna/base/VolumeGrid.h>
#include <memory>

namespace Carna
{

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()
{
    CARNA_ASSERT( hasNormals() );
    return **myNormals;
}


template< typename SegmentNormalsVolumeType >
const SegmentNormalsVolumeType& VolumeSegmentNormalsComponent< SegmentNormalsVolumeType >::normals() const
{
    CARNA_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()
{
    CARNA_ASSERT( hasIntensities() );
    return **myIntensities;
}


template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
const SegmentIntensityVolumeType& VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::intensities() const
{
    CARNA_ASSERT( hasIntensities() );
    return **myIntensities;
}


template< typename SegmentIntensityVolumeType, typename SegmentNormalsVolumeType >
bool VolumeSegment< SegmentIntensityVolumeType, SegmentNormalsVolumeType >::hasIntensities() const
{
    return myIntensities.get() != nullptr && myIntensities->get() != nullptr;
}



}  // namespace Carna :: base

}  // namespace Carna

#endif // VOLUMESEGMENT_H_6014714286