SrcLib/core/fwData/include/fwData/TransferFunction.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 __FWDATA_TRANSFERFUNCTION_HPP__
#define __FWDATA_TRANSFERFUNCTION_HPP__

#include "fwData/config.hpp"
#include "fwData/Object.hpp"

fwCampAutoDeclareDataMacro((fwData)(TransferFunction), FWDATA_API);

namespace fwData
{

class FWDATA_CLASS_API TransferFunction : public Object
{

public:

    fwCoreClassDefinitionsWithFactoryMacro( (TransferFunction)(::fwData::Object), (()),
                                            ::fwData::factory::New< TransferFunction >)

    

    fwCampMakeFriendDataMacro((fwData)(TransferFunction))

    struct TFColor
    {
        typedef double ColorType;

        ColorType r;
        ColorType g;
        ColorType b;
        ColorType a;

        // Default constructor
        TFColor()
        {
            r = 0.0;
            g = 0.0;
            b = 0.0;
            a = 0.0;
        }

        TFColor( ColorType _r, ColorType _g, ColorType _b, ColorType _a )
        {
            r = _r;
            g = _g;
            b = _b;
            a = _a;
        }

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

        inline bool operator== (const TFColor& _color) const
        {
            return (r == _color.r && g == _color.g && b == _color.b && a == _color.a);
        }

    };


    typedef enum
    {
        LINEAR,
        NEAREST
    } InterpolationMode;

    typedef double TFValueType;
    typedef std::vector<TFValueType> TFValueVectorType;

    typedef std::vector<TFColor> TFColorVectorType;
    typedef std::map< TFValueType, TFColor > TFDataType;

    typedef std::pair< TFValueType, TFValueType > TFValuePairType;

    FWDATA_API TransferFunction(::fwData::Object::Key key);

    FWDATA_API virtual ~TransferFunction();

    // Initialize a default TF.
    FWDATA_API void initTF();

    // Create a default TF
    FWDATA_API static TransferFunction::sptr createDefaultTF();

    FWDATA_API void shallowCopy( const Object::csptr& _source ) override;

    FWDATA_API void cachedDeepCopy(const Object::csptr& _source, DeepCopyCacheType& cache) override;

    FWDATA_API TFValueVectorType getTFValues() const;

    FWDATA_API TFValueVectorType getScaledValues() const;

    FWDATA_API TFValuePairType getMinMaxTFValues() const;

    FWDATA_API TFValuePairType getWLMinMax() const;

    FWDATA_API void setWLMinMax(const TFValuePairType& minMax);

    FWDATA_API TFValueType getNearestValue( TFValueType value ) const;

    FWDATA_API const TFDataType& getTFData() const;

    FWDATA_API void setTFData( const TFDataType& tfData );

    FWDATA_API void addTFColor( TFValueType value, const TFColor& color );

    FWDATA_API void eraseTFValue( TFValueType value);

    FWDATA_API void clear();

    FWDATA_API TFColorVectorType getTFColors() const;

    FWDATA_API TFColor getNearestColor( TFValueType value ) const;

    FWDATA_API TFColor getLinearColor( TFValueType value ) const;

    FWDATA_API TFColor getInterpolatedColor( TFValueType value ) const;

    // Get the color associated to the value.
    FWDATA_API const TFColor& getTFColor( TFValueType value ) const;

    InterpolationMode  getInterpolationMode () const;

    void setInterpolationMode (InterpolationMode val);

    double  getLevel () const;
    void setLevel (double val);

    double getWindow () const;
    void setWindow (double val);

    const std::string& getName () const;
    void setName (const std::string& val);

    bool  getIsClamped () const;
    void setIsClamped (bool val);

    const TFColor& getBackgroundColor () const;
    void setBackgroundColor (const TFColor& val);

    FWDATA_API static const std::string s_DEFAULT_TF_NAME;

    typedef ::fwCom::Signal< void () > PointsModifiedSignalType;
    FWDATA_API static const ::fwCom::Signals::SignalKeyType s_POINTS_MODIFIED_SIG;

    typedef ::fwCom::Signal< void (double, double) > WindowingModifiedSignalType;
    FWDATA_API static const ::fwCom::Signals::SignalKeyType s_WINDOWING_MODIFIED_SIG;
private:

    double m_level;

    double m_window;

    std::string m_name;

    TFColor m_backgroundColor;

    TFDataType m_tfData;

    InterpolationMode m_interpolationMode;

    bool m_isClamped;

};

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

inline TransferFunction::TFColor TransferFunction::getInterpolatedColor( TFValueType value ) const
{
    TFColor color;

    if(m_interpolationMode == LINEAR)
    {
        color = this->getLinearColor(value);
    }
    else if(m_interpolationMode == NEAREST)
    {
        color = this->getNearestColor(value);
    }
    return color;
}

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

inline TransferFunction::InterpolationMode TransferFunction::getInterpolationMode () const
{
    return m_interpolationMode;
}

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

inline void TransferFunction::setInterpolationMode (InterpolationMode val)
{
    m_interpolationMode = val;
}

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

inline double TransferFunction::getLevel () const
{
    return m_level;
}

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

inline void TransferFunction::setLevel (double val)
{
    m_level = val;
}

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

inline double TransferFunction::getWindow () const
{
    return m_window;
}

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

inline void TransferFunction::setWindow (double val)
{
    m_window = val;
}

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

inline const std::string& TransferFunction::getName () const
{
    return m_name;
}

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

inline void TransferFunction::setName (const std::string& val)
{
    m_name = val;
}

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

inline bool TransferFunction::getIsClamped () const
{
    return m_isClamped;
}

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

inline void TransferFunction::setIsClamped (bool val)
{
    m_isClamped = val;
}

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

inline const TransferFunction::TFColor& TransferFunction::getBackgroundColor () const
{
    return m_backgroundColor;
}

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

inline void TransferFunction::setBackgroundColor (const TFColor& val)
{
    m_backgroundColor = val;
}

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

} // namespace fwData

#endif // __FWDATA_TRANSFERFUNCTION_HPP__