mitkInterpolateFilter.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/


#ifndef __mitkInterpolateFilter_h
#define __mitkInterpolateFilter_h

#include "mitkVolumeToVolumeFilter.h"
#include "mitkGlobalRegistrationFramework.h"

#ifndef MITK_REGISTRATION_VER_OOC
#include "mitkVolumeIterator.h"
#else
#include "mitkVolumeIteratorOoC.h"
#endif

#define INVALID_PIXEL   1e10

#define MITK_INTERPOLATION_MAPPING_MODE_FORWARD 0
#define MITK_INTERPOLATION_MAPPING_MODE_INVERSE 1

class MITK_REGISTRATION_API mitkInterpolateFilter : public mitkVolumeToVolumeFilter
{
public:
    MITK_TYPE(mitkInterpolateFilter, mitkVolumeToVolumeFilter)  
    virtual void PrintSelf(ostream &os);

    void SetCorrdinates(mitkVolume* coordinates) {m_CoordVolume = coordinates;}

    mitkVolume* GetCoordinates();
    
    void SetRegion(const VectorIndexType& r) { m_Region = r; }

    void GetRegion(int r[6]) {for(int i=0; i<6; i++) r[i] = m_Region[i];}

    virtual void Update();

    virtual bool InterpolatePoint(float x, float y, float z, float &value);

    virtual bool InterpolatePoint(float x, float y, float z, float* value);

    virtual bool InterpolatePoint(const VectorParameterType & index, ScalarPixelType &value);

    virtual bool InterpolatePoint(const VectorParameterType & index, VectorPixelType & value);

    void SetOutputDatatype(int dataType) {m_OutputDataType = dataType;}

    void SetDefaultPixelValue(ScalarPixelType val) { m_DefaultPixelValue = val; }

    void SetMinOutputValue(ScalarPixelType val) { m_MinOutputValue = val; }

    void SetMaxOutputValue(ScalarPixelType val) { m_MaxOutputValue = val; }

    bool IsOutsideInterpolateRegion(const VectorParameterType & index);

    bool IsOutsideInterpolateRegion(ScalarParameterType* index);
    
protected:
    mitkInterpolateFilter();
    virtual ~mitkInterpolateFilter();
    
    virtual bool Execute();
    virtual void _interpolation(const ScalarParameterType* index, ScalarPixelType* value) = 0;
    virtual void _interpolation(const ScalarParameterType* index, ScalarPixelType& value) = 0;

    mitkRCPtr<mitkVolume>           m_CoordVolume;
    mitkVolumeIteratorBase*         m_InputIterator;

    unsigned int                    m_NumberOfChannels;
    unsigned int                    m_ImageDimension;
    VectorIndexType                 m_Region;
    int                             m_Dimensions[3];
    float                           m_Spacings[3];

    int                             m_OutputDataType;

    ScalarPixelType                 m_DefaultPixelValue;
    ScalarPixelType                 m_MinOutputValue;
    ScalarPixelType                 m_MaxOutputValue;

private:
    mitkInterpolateFilter(const mitkInterpolateFilter&);
    void operator = (const mitkInterpolateFilter&);

};
//-------------------------------------------------------------------------
inline bool mitkInterpolateFilter::IsOutsideInterpolateRegion(const VectorParameterType & index)
{
    for(unsigned int i=0; i<m_ImageDimension; i++)
    {
        if(index[i] < 0) return true;
        if(index[i] >= (double) m_Dimensions[i] - 1) return true;
    }

    return false;
}
//-------------------------------------------------------------------------
inline bool mitkInterpolateFilter::IsOutsideInterpolateRegion(ScalarParameterType* index)
{
    for(unsigned int i=0; i<m_ImageDimension; i++)
    {
        if(index[i] < 0) return true;
        if(index[i] >= (double) m_Dimensions[i] - 1) return true;
    }

    return false;
}
//-------------------------------------------------------------------------

//#define DEFINED_mitkInterpolateFilter



#endif

---