MedicalImageHelpers.hpp

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

#pragma once

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

#include <fwData/Image.hpp>
#include <fwData/Integer.hpp>
#include <fwData/Point.hpp>

#include <fwTools/Dispatcher.hpp>
#include <fwTools/DynamicTypeKeyTypeMapping.hpp>
#include <fwTools/IntrinsicTypes.hpp>
#include <fwTools/NumericRoundCast.hxx>

#include <numeric>
#include <utility> // std::pair

namespace fwDataTools
{
namespace fieldHelper
{

template <class T> struct bitwise_or : std::binary_function <T, T, T>
{
    // ------------------------------------------------------------------------------

    T operator() (const T& x, const T& y) const
    {
        return x|y;
    }
};

class FWDATATOOLS_CLASS_API MedicalImageHelpers
{
public:

    FWDATATOOLS_API static bool checkLandmarks( ::fwData::Image::sptr _pImg );

    FWDATATOOLS_API static bool checkImageValidity( ::fwData::Image::csptr _pImg );

    FWDATATOOLS_API static bool checkImageSliceIndex( ::fwData::Image::sptr _pImg );

    FWDATATOOLS_API static ::fwData::Point::sptr   getImageSliceIndices( ::fwData::Image::sptr _pImg );

    FWDATATOOLS_API static bool checkComment( ::fwData::Image::sptr _pImg );

    FWDATATOOLS_API static ::fwData::Image::sptr initialize( ::fwData::Image::sptr imgSrc,
                                                             ::fwData::Image::sptr imgToInitialize =
                                                                 ::fwData::Image::sptr());

    template < typename INT_INDEX>
    static bool isPixelNull(::fwData::Image::sptr image, INT_INDEX& point);

    FWDATATOOLS_API static bool isBufNull(const ::fwData::Image::BufferType* buf, const unsigned int len);

    template < typename T, typename INT_INDEX>
    static void setPixel(::fwData::Image::sptr image, INT_INDEX& point, T& value);

    template < typename T >
    static void setPixel(::fwData::Image::sptr pImage, ::fwData::Point::sptr point, T& value);

    template < typename T >
    static SPTR( ::fwData::Image::BufferType ) getPixelBufferInImageSpace(::fwData::Image::sptr image, T &value);

    template < typename MINMAXTYPE >
    static void getMinMax(const ::fwData::Image::csptr _img, MINMAXTYPE& _min, MINMAXTYPE& _max);

};

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

template < typename VALUE >
class PixelCastAndSetFunctor
{
public:
    class Param
    {
    public:
        typedef VALUE ValueType;
        typedef SPTR ( ::fwData::Image::BufferType ) BufferTypeSptr;

        Param(ValueType& v) :
            value(v)
        {
        }

        const ValueType& value;
        BufferTypeSptr res;
    };

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

    template < typename IMAGE >
    void operator()( Param& param )
    {
        unsigned char imageTypeSize = sizeof(IMAGE);

        IMAGE val = ::fwTools::numericRoundCast<IMAGE>(param.value);

        ::fwData::Image::BufferType* buf = reinterpret_cast< ::fwData::Image::BufferType* > (&val);

        SPTR( ::fwData::Image::BufferType ) res( new ::fwData::Image::BufferType[imageTypeSize] );
        std::copy(buf, buf+imageTypeSize, res.get());
        param.res = res;
    }

};

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

template < typename VALUE, typename INT_INDEX >
class CastAndSetFunctor
{
public:
    class Param
    {
    public:
        typedef VALUE ValueType;
        typedef INT_INDEX PointType;

        Param(PointType& p, ValueType& v) :
            value(v),
            point(p)
        {
        }

        ::fwData::Image::sptr image;
        const ValueType& value;
        const PointType& point;
    };

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

    template < typename IMAGE >
    void operator()( Param& param )
    {
        ::fwDataTools::helper::Image imagehelper(param.image);
        IMAGE* buffer                         = static_cast < IMAGE* > (imagehelper.getBuffer());
        const INT_INDEX& p                    = param.point;
        const ::fwData::Image::SizeType& size = param.image->getSize();
        const int& sx                         = size[0];
        const int& sy                         = size[1];
        const int& offset                     = p[0] + sx*p[1] + p[2]*sx*sy;
        *(buffer+offset) = ::fwTools::numericRoundCast<IMAGE>(param.value);
    }

};

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

template < typename T >
void MedicalImageHelpers::setPixel(::fwData::Image::sptr image, ::fwData::Point::sptr point, T& value)
{
    setPixel(image, point->getCoord(), value);
}

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

template < typename T, typename INT_INDEX>
void MedicalImageHelpers::setPixel(::fwData::Image::sptr image, INT_INDEX& point, T& value)
{
    typename CastAndSetFunctor<T, INT_INDEX>::Param param(point, value);
    param.image = image;

    ::fwTools::DynamicType type = image->getPixelType();
    ::fwTools::Dispatcher< ::fwTools::IntrinsicTypes, CastAndSetFunctor<T, INT_INDEX> >::invoke( type, param );
}

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

template < typename T >
SPTR( ::fwData::Image::BufferType ) MedicalImageHelpers::getPixelBufferInImageSpace(::fwData::Image::sptr image,
                                                                                    T &value)
{
    typename PixelCastAndSetFunctor<T>::Param param(value);

    ::fwTools::DynamicType type = image->getPixelType();
    ::fwTools::Dispatcher< ::fwTools::IntrinsicTypes, PixelCastAndSetFunctor<T> >::invoke( type, param );
    return param.res;
}

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

template < typename INT_INDEX >
class CastAndCheckFunctor
{
public:
    class Param
    {
    public:
        typedef INT_INDEX PointType;

        Param(PointType& p, bool& b) :
            point(p),
            isNull(b)
        {
        }

        ::fwData::Image::sptr image;
        const PointType& point;
        bool& isNull;
    };

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

    template < typename IMAGE >
    void operator()( Param& param )
    {
        ::fwDataTools::helper::Image imagehelper(param.image);
        IMAGE* buffer                         = static_cast < IMAGE* > (imagehelper.getBuffer());
        const INT_INDEX& p                    = param.point;
        const std::vector<std::int32_t>& size = param.image->getSize();
        const int& sx                         = size[0];
        const int& sy                         = size[1];
        const int& offset                     = p[0] + sx*p[1] + p[2]*sx*sy;
        param.isNull = (*(buffer+offset) == 0);
    }

};

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

template < typename INT_INDEX>
bool MedicalImageHelpers::isPixelNull(::fwData::Image::sptr image, INT_INDEX& point)
{
    ::fwDataTools::helper::Image imageLock( image );
    const unsigned char imageTypeSize = image->getPixelType().sizeOf();
    ::fwData::Image::BufferType* buf =
        static_cast< ::fwData::Image::BufferType*> (imageLock.getPixelBuffer(point[0], point[1], point[2]));

    return isBufNull(buf, imageTypeSize);
}

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

template < typename T >
class MinMaxFunctor
{
public:
    class Param
    {
    public:

        Param(::fwData::Image::csptr _img, T& _min, T& _max) :
            image(_img),
            min(_min),
            max(_max)
        {
        }

        ::fwData::Image::csptr image;
        T& min;
        T& max;
    };

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

    template < typename IMAGE >
    void operator()( Param& param )
    {
        ::fwDataTools::helper::ImageGetter imageLock( param.image );
        IMAGE* buffer                         = static_cast < IMAGE* > (imageLock.getBuffer());
        const ::fwData::Image::SizeType& size = param.image->getSize();
        ::fwData::Image::SizeType::value_type len = static_cast< ::fwData::Image::SizeType::value_type >(
            std::accumulate(size.begin(), size.end(), 1, std::multiplies< ::fwData::Image::SizeType::value_type >()));
        T& min = param.min;
        T& max = param.max;

        typedef std::numeric_limits<IMAGE> ImgLimits;
        IMAGE imin = ImgLimits::max();
        IMAGE imax = ImgLimits::lowest();

        IMAGE* bufEnd = buffer + len;
        IMAGE currentVoxel;

        for (IMAGE* voxel = buffer; voxel < bufEnd; ++voxel )
        {
            currentVoxel = *voxel;

            if ( currentVoxel < imin )
            {
                imin = currentVoxel;
            }
            else if (currentVoxel > imax)
            {
                imax = currentVoxel;
            }
        }

        typedef std::numeric_limits<T> TLimits;
        T minT = TLimits::lowest();
        T maxT = TLimits::max();

        min = ( imin < minT ) ? minT : static_cast< T > (imin);
        max = ( imax > maxT ) ? maxT : static_cast< T > (imax);

    }

};

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

template < typename MINMAXTYPE >
void MedicalImageHelpers::getMinMax(const ::fwData::Image::csptr _img, MINMAXTYPE& _min, MINMAXTYPE& _max)
{
    typename MinMaxFunctor<MINMAXTYPE>::Param param(_img, _min, _max);

    ::fwTools::DynamicType type = _img->getPixelType();
    ::fwTools::Dispatcher< ::fwTools::IntrinsicTypes, MinMaxFunctor<MINMAXTYPE> >::invoke( type, param );
}

} // fieldHelper
} // fwDataTools