itkNeighborhoodFunctorImageFilter.h

Go to the documentation of this file.

#ifndef itkNeighborhoodFunctorImageFilter_h
#define itkNeighborhoodFunctorImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkImage.h"
#include "stdio.h"

#include <itkHistogramToTextureFeaturesFilter.h>
#include "itkHistogram.h"

namespace itk
{

template<typename TInputImageType, typename TFeatureImageType , class FunctorType>
class NeighborhoodFunctorImageFilter : public ImageToImageFilter< TInputImageType, TFeatureImageType>
{
public:
    typedef NeighborhoodFunctorImageFilter                          Self;
    typedef ImageToImageFilter<TInputImageType, TFeatureImageType>  Superclass;
    typedef SmartPointer< Self >                                    Pointer;
    typedef SmartPointer< const Self >                              ConstPointer;

    itkNewMacro(Self);

    itkTypeMacro(NeighborhoodFunctorImageFilter, ImageToImageFilter);

    itkStaticConstMacro(ImageDimension, unsigned int,
                        TFeatureImageType::ImageDimension);
    itkStaticConstMacro(InputImageDimension, unsigned int,
                        TInputImageType::ImageDimension);

    typedef TInputImageType                                         InputImageType;
    typedef typename TInputImageType::PixelType                     InputImagePixelType;
    typedef itk::Image<short, InputImageDimension>          MaskImageType;
    typedef typename MaskImageType::PixelType                       MaskImagePixelType;
    typedef TFeatureImageType                                       FeatureImageType;
    typedef typename FeatureImageType::PixelType                    FeaturePixelType;
    typedef itk::Size<InputImageDimension>                          SizeType;

    typedef ImageBoundaryCondition< InputImageType > * ImageBoundaryConditionPointerType;

    typedef ZeroFluxNeumannBoundaryCondition< InputImageType > DefaultBoundaryCondition;

    typedef typename Superclass::OutputImageRegionType OutputImageRegionType;

    typedef Neighborhood< InputImagePixelType, InputImageDimension > NeighborhoodType;

    void OverrideBoundaryCondition(const ImageBoundaryConditionPointerType i)
    { m_BoundsCondition = i; }

    ImageBoundaryConditionPointerType GetBoundaryCondition()
    { return m_BoundsCondition; }

    void SetNeighborhoodSize(SizeType size){m_Size = size;}
    void SetNeighborhoodSize(unsigned int size){m_Size.Fill(size);}
    SizeType GetNeighborhoodSize(){return m_Size;}

    void SetMask(const typename MaskImageType::Pointer & ptr){m_MaskImage = ptr;}

    const FunctorType & GetFunctorReference() const
    {
      return m_Functor;
    }

    FunctorType & GetFunctorReference()
    {
      return m_Functor;
    }

    void SetFunctor(const FunctorType & func)
    {
      m_Functor = func;
    }

protected:

    NeighborhoodFunctorImageFilter()
    {
        m_Size.Fill(0);
        m_MaskImage = NULL;
        m_BoundsCondition = static_cast< ImageBoundaryConditionPointerType >( &m_DefaultBoundaryCondition );
        this->SetNumberOfIndexedOutputs(FunctorType::OutputCount);
    }
    ~NeighborhoodFunctorImageFilter(){}

    void BeforeThreadedGenerateData();

    void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread,
                              ThreadIdType threadId);


    virtual void GenerateInputRequestedRegion() throw ( InvalidRequestedRegionError );


private:
    NeighborhoodFunctorImageFilter(const Self &); // purposely not implemented
    void operator=(const Self &); // purposely not implemented

    ImageBoundaryConditionPointerType m_BoundsCondition;

    DefaultBoundaryCondition m_DefaultBoundaryCondition;

    FunctorType m_Functor;

    itk::Size<InputImageDimension> m_Size;

    typename MaskImageType::Pointer m_MaskImage;

};
}

#ifndef ITK_MANUAL_INSTANTIATION
#include "../src/Features/itkNeighborhoodFunctorImageFilter.cpp"
#endif

#endif // itkFeatureImageFilter_h