itkNeighborhoodFunctorImageFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef itkNeighborhoodFunctorImageFilter_h
#define itkNeighborhoodFunctorImageFilter_h
 
#include <itkImageToImageFilter.h>
#include <itkZeroFluxNeumannBoundaryCondition.h>
#include <itkConstNeighborhoodIterator.h>
#include <itkImage.h>
#include <cstdio>
 
#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()
    {
        this->DynamicMultiThreadingOff();
        m_Size.Fill(0);
        m_MaskImage = nullptr;
        m_BoundsCondition = static_cast< ImageBoundaryConditionPointerType >( &m_DefaultBoundaryCondition );
        this->SetNumberOfIndexedOutputs(FunctorType::OutputCount);
    }
    ~NeighborhoodFunctorImageFilter() override{}
 
    void BeforeThreadedGenerateData() override;
 
    void ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread,
                              ThreadIdType threadId) override;
 
 
    void GenerateInputRequestedRegion() override;
 
 
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