MedicalImageAdaptor.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWDATATOOLS_HELPER_MEDICALIMAGEADAPTOR_HPP__
#define __FWDATATOOLS_HELPER_MEDICALIMAGEADAPTOR_HPP__

#include "fwDataTools/config.hpp"
#include "fwDataTools/helper/ImageGetter.hpp"

#include <fwCom/helper/SigSlotConnection.hpp>
#include <fwCom/Slot.hpp>
#include <fwCom/Slots.hpp>

#include <fwData/Composite.hpp>
#include <fwData/Integer.hpp>
#include <fwData/String.hpp>
#include <fwData/TransferFunction.hpp>

#include <vector>

namespace fwDataTools
{

namespace helper
{

class FWDATATOOLS_CLASS_API MedicalImageAdaptor
{

public:
    fwCoreBaseClassDefinitionsMacro( (MedicalImageAdaptor) );

    typedef enum
    {
        X_AXIS = 0,
        Y_AXIS,
        Z_AXIS
    } Orientation;

    FWDATATOOLS_API virtual ~MedicalImageAdaptor();

    FWDATATOOLS_API virtual void setOrientation( Orientation orientation );

    Orientation getOrientation() const
    {
        return m_orientation;
    }

    FWDATATOOLS_API void setTransferFunction( const ::fwData::TransferFunction::sptr& tf );

protected:

    FWDATATOOLS_API MedicalImageAdaptor(); // this class VISUVTKADAPTOR_CLASS_API must be specialized

    FWDATATOOLS_API void setOrientation( int orientation );

    FWDATATOOLS_API void getImageSpacing(double spacing[3]) const;

    FWDATATOOLS_API void getImageOrigin(double origin[3]) const;

    FWDATATOOLS_API void getImageDataSize(int size[3]) const;

    FWDATATOOLS_API void getImageSize(double size[3]) const;

    FWDATATOOLS_API void getCurrentSliceCenter(double center[3]);

    FWDATATOOLS_API void worldToSliceIndex(const double world[3], int index[3] );

    FWDATATOOLS_API void worldToImageSliceIndex(const double world[3], int index[3] );

    FWDATATOOLS_API void sliceIndexToWorld(const int index[3], double world[3] );

    FWDATATOOLS_API ::fwData::Image::sptr getImage() const;

    template< typename FLOAT_ARRAY_3 >
    void getImageSpacing(FLOAT_ARRAY_3 spacing);

    template< typename INT_INDEX >
    void getImageDataSize(INT_INDEX size);

    template< typename WORLD, typename INT_INDEX >
    void worldToSliceIndex(const WORLD world, INT_INDEX* index );

    template< typename WORLD, typename INT_INDEX >
    void worldToImageSliceIndex(const WORLD world, INT_INDEX* index );

    FWDATATOOLS_API void getPlane( double points[4][3], int sliceNumber );

    FWDATATOOLS_API bool setSliceIndex(const int index[3]);
    FWDATATOOLS_API void getSliceIndex(::fwData::Integer::sptr index[3]);

    FWDATATOOLS_API void updateImageInfos( ::fwData::Image::sptr image  );

    FWDATATOOLS_API void createTransferFunction( ::fwData::Image::sptr image );

    FWDATATOOLS_API void setOrCreateTF(const ::fwData::TransferFunction::sptr& _tf, const fwData::Image::sptr& _image);

    FWDATATOOLS_API ::fwData::TransferFunction::sptr getTransferFunction() const;

    FWDATATOOLS_API void installTFConnections();

    FWDATATOOLS_API void removeTFConnections();

    FWDATATOOLS_API void installTFSlots(::fwCom::HasSlots* hasslots);

    FWDATATOOLS_API virtual void updateTFPoints();

    FWDATATOOLS_API virtual void updateTFWindowing(double window, double level);

    typedef ::fwCom::Slot<void ()> UpdateTFPointsSlotType;
    typedef ::fwCom::Slot<void (double, double)> UpdateTFWindowingSlotType;

    UpdateTFPointsSlotType::sptr m_slotUpdateTFPoints;

    UpdateTFWindowingSlotType::sptr m_slotUpdateTFWindowing;
    Orientation m_orientation;

    ::fwData::Integer::sptr m_axialIndex;
    ::fwData::Integer::sptr m_frontalIndex;
    ::fwData::Integer::sptr m_sagittalIndex;

private:

    ::fwData::Image::wptr m_weakImage;

    ::fwData::TransferFunction::wptr m_transferFunction;

    ::fwCom::helper::SigSlotConnection m_tfConnections;
};

//------------------------------------------------------------------------------
template< typename FLOAT_ARRAY_3 >
void MedicalImageAdaptor::getImageSpacing(FLOAT_ARRAY_3 spacing)
{
    ::fwData::Image::sptr image = this->getImage();

    const ::fwData::Image::SpacingType imSpacing = image->getSpacing();
    std::copy(imSpacing.begin(), imSpacing.end(), spacing);
}

//------------------------------------------------------------------------------
template< typename INT_INDEX >
void MedicalImageAdaptor::getImageDataSize(INT_INDEX size)
{
    ::fwData::Image::sptr image = this->getImage();

    const ::fwData::Image::SizeType imSize = image->getSize();
    std::copy(imSize.begin(), imSize.end(), size);
}

//------------------------------------------------------------------------------

template< typename WORLD, typename INT_INDEX >
void MedicalImageAdaptor::worldToSliceIndex(const WORLD world, INT_INDEX* index )
{
    double spacing[3];
    this->getImageSpacing(spacing);
    double origin[3];
    this->getImageOrigin(origin);
    for ( int i = 0; i < 3; ++i )
    {
        index[i] =
            static_cast< INT_INDEX >( ( (world[i] - origin[i])/spacing[i] ) +
                                      ( ( (world[i] - origin[i])/spacing[i] ) >= 0 ? 0.5 : -0.5 ) );
    }
}

//------------------------------------------------------------------------------

template< typename WORLD, typename INT_INDEX >
void MedicalImageAdaptor::worldToImageSliceIndex(const WORLD world, INT_INDEX* index )
{
    INT_INDEX imageSize[3];
    this->getImageDataSize(imageSize);
    this->worldToSliceIndex(world, index);

    INT_INDEX idval;
    for (int i = 0; i < 3; i++)
    {
        INT_INDEX max = imageSize[i]-1;
        idval = index[i];
        if (idval < 0)
        {
            index[i] = 0;
        }
        else if (idval > max)
        {
            index[i] = max;
        }
    }
}

} //namespace helper

} //namespace fwDataTools

#endif // __FWDATATOOLS_HELPER_MEDICALIMAGEADAPTOR_HPP__