itkLargestForegroundFilledMaskImageFilter.h

Go to the documentation of this file.

#ifndef __itkLargestForegroundFilledMaskImageFilter_h
#define __itkLargestForegroundFilledMaskImageFilter_h

#include <itkImage.h>
#include <itkImageToImageFilter.h>
#include <itkNumericTraits.h>

namespace itk
{
template< class TInputImage, class TOutputImage = TInputImage >
class ITK_EXPORT LargestForegroundFilledMaskImageFilter:
  public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef TInputImage                           InputImageType;
  typedef typename InputImageType::ConstPointer InputImagePointer;
  typedef typename InputImageType::RegionType   InputImageRegionType;
  typedef typename InputImageType::PixelType    InputPixelType;

  typedef TOutputImage                         OutputImageType;
  typedef typename OutputImageType::Pointer    OutputImagePointer;
  typedef typename OutputImageType::RegionType OutputImageRegionType;
  typedef typename OutputImageType::PixelType  OutputPixelType;

  typedef LargestForegroundFilledMaskImageFilter                   Self;
  typedef ImageToImageFilter< InputImageType, OutputImageType >    Superclass;
  typedef SmartPointer< Self >                                     Pointer;
  typedef Image< unsigned short, OutputImageType::ImageDimension > IntegerImageType;
  typedef typename IntegerImageType::PixelType                     IntegerPixelType;

  itkNewMacro(Self);

  itkTypeMacro(LargestForegroundFilledMaskImageFilter, ImageToImageFilter);

  itkSetMacro(OtsuPercentileLowerThreshold, double);
  itkGetConstMacro(OtsuPercentileLowerThreshold, double);
  itkSetMacro(OtsuPercentileUpperThreshold, double);
  itkGetConstMacro(OtsuPercentileUpperThreshold, double);

  void SetOtsuPercentileThreshold(const double percentile)
  {
    this->SetOtsuPercentileLowerThreshold(percentile);
    this->SetOtsuPercentileUpperThreshold(1.0 - percentile);
  }

  double GetOtsuPercentileThreshold(void) const
  {
    return this->GetOtsuPercentileLowerThreshold();
  }

  itkSetMacro(ClosingSize, double);
  itkGetConstMacro(ClosingSize, double);
  itkSetMacro(DilateSize, double);
  itkGetConstMacro(DilateSize, double);
  itkSetMacro(InsideValue, IntegerPixelType);
  itkGetMacro(InsideValue, IntegerPixelType);
  itkSetMacro(OutsideValue, IntegerPixelType);
  itkGetMacro(OutsideValue, IntegerPixelType);
  itkSetMacro(ThresholdCorrectionFactor, double);
  itkGetConstMacro(ThresholdCorrectionFactor, double);
protected:
  LargestForegroundFilledMaskImageFilter();
  ~LargestForegroundFilledMaskImageFilter();
  void PrintSelf(std::ostream & os, Indent indent) const;

  virtual void GenerateData();

private:
  unsigned int SetLowHigh(InputPixelType & low,
                          InputPixelType & high);

  void ImageMinMax(InputPixelType & min, InputPixelType & max);

  // No longer used  double m_OtsuPercentileThreshold;
  double           m_OtsuPercentileLowerThreshold;
  double           m_OtsuPercentileUpperThreshold;
  double           m_ThresholdCorrectionFactor;
  double           m_ClosingSize;
  double           m_DilateSize;
  IntegerPixelType m_InsideValue;
  IntegerPixelType m_OutsideValue;
};
} // end namespace itk

#if ITK_TEMPLATE_TXX
#  include "itkLargestForegroundFilledMaskImageFilter.txx"
#endif

#endif