itkShapeBasedAveragingImageFilter.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkShapeBasedAveragingImageFilter_h
#define itkShapeBasedAveragingImageFilter_h
 
#include <itkImageToImageFilter.h>
#include <stdlib.h>
#include <time.h>

namespace itk
{
  
template<class TInputImage, class TOutputImage>
class ITK_EXPORT ShapeBasedAveragingImageFilter: 
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  typedef ShapeBasedAveragingImageFilter Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
  typedef SmartPointer<Self> Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  typedef Image<float, TInputImage::ImageDimension> FloatImageType; 
  typedef FloatImageType AverageDistanceMapType; 
  typedef enum 
  {
    // Simple mean. 
    MEAN = 0, 
    // Median. 
    MEDIAN = 1, 
    // Interquartile mean - more robust. 
    INTERQUARTILE_MEAN = 2,
    CORRECT_INTERQUARTILE_MEAN = 3
  } MeanModeType;
  itkNewMacro(Self);  
  itkTypeMacro(ShapeBasedAveragingImageFilter, ImageToImageFilter);
  void UnsetLabelForUndecidedPixels() { this->m_IsUserDefinedLabelForUndecidedPixels = false; }
  void SetLabelForUndecidedPixels(typename TOutputImage::PixelType value) 
  {
    this->m_IsUserDefinedLabelForUndecidedPixels = true;
    this->m_LabelForUndecidedPixels = value; 
  }
  itkSetMacro(MeanMode, MeanModeType); 
  const FloatImageType* GetAverageDistanceMap() const
  {
    return this->m_AverageDistanceMap;
  }
  const FloatImageType* GetVariabilityMap() const
  {
    return this->m_VariabilityMap;
  }
  const FloatImageType* GetProbabilityMap() const
  {
    return this->m_ProbabilityMap;
  }
  FloatImageType* GetProbabilityMap()
  {
    return this->m_ProbabilityMap;
  }
  void ComputeMRF(FloatImageType* probabilityMap, double mrf, int numberOfIterations);
      
protected:
  ShapeBasedAveragingImageFilter() : m_IsUserDefinedLabelForUndecidedPixels(false), m_LabelForUndecidedPixels(0), m_MeanMode(MEAN) 
  { 
    srand(time(NULL)); 
  }
  virtual ~ShapeBasedAveragingImageFilter() {}
  void GenerateData();
  void CalculateReliability(); 
  double CalculateVariance(typename AverageDistanceMapType::Pointer averageDistanceMap); 
  
protected:  
  bool m_IsUserDefinedLabelForUndecidedPixels; 
  typename TOutputImage::PixelType m_LabelForUndecidedPixels; 
  int m_MeanMode;
  std::vector<double> m_SegmentationReliability; 
  typename FloatImageType::Pointer m_AverageDistanceMap;  
  typename FloatImageType::Pointer m_VariabilityMap;
  typename FloatImageType::Pointer m_ProbabilityMap;


private:
  ShapeBasedAveragingImageFilter(const Self&); 
  void operator=(const Self&); 
      

}; 

    
} // end of namespace itk.

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkShapeBasedAveragingImageFilter.txx"
#endif


#endif // ITKSHAPEBASEDAVERAGINGIMAGEFILTER_H_