itkGrowCutSegmentationImageFilter.h

Go to the documentation of this file.

#ifndef itkGrowCutSegmentationImageFilter_h
#define itkGrowCutSegmentationImageFilter_h

#include "itkImage.h"
#include "itkImageToImageFilter.h"
#include "itkSimpleDataObjectDecorator.h"
#include "itkVectorContainer.h"
//#include "itkCommand.h"

//#include "itkGrowCutSegmentationUpdateFilter.h"

#include <iostream>
#include <list>
#include <vector>

#ifndef PixelState
enum PixelState{
    UNLABELED = 0,
    LABELED = 1,
    LOCALLY_SATURATED = 2,
    SATURATED = 3 };
#endif

namespace itk
{

/* template<class TInputImage,  */
/*   class TOutputImage, class TLabelPixelType = short,  */
/*   class TWeightPixelType = float >  */
template<class TInputImage,
  class TOutputImage,
  class TWeightPixelType = float>
  class GrowCutSegmentationImageFilter: public ImageToImageFilter<TInputImage,TOutputImage>
{

 public:
  typedef GrowCutSegmentationImageFilter               Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage> Superclass;
  typedef SmartPointer<Self>                           Pointer;
  typedef SmartPointer<const Self>                     ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(GrowCutSegmentationImageFilter,
               ImageToImageFilter);

  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension );

  typedef TInputImage                           InputImageType;
  typedef typename InputImageType::Pointer      InputImagePointer;
  typedef typename InputImageType::ConstPointer InputImageConstPointer;

  typedef typename InputImageType::PixelType InputPixelType;
  typedef typename InputImageType::IndexType InputIndexType;
  typedef typename InputImageType::SizeType  SizeType;

  typedef TOutputImage                         OutputImageType;
  typedef typename OutputImageType::Pointer    OutputImagePointer;
  typedef typename OutputImageType::RegionType OutputImageRegionType;
  typedef typename OutputImageType::PixelType  OutputPixelType;
  typedef typename OutputImageType::IndexType  OutputIndexType;
  typedef typename InputImageType::SizeType    OutputSizeType;


  typedef typename DataObject::Pointer DataObjectPointer;


  itkStaticConstMacro(InputImageDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef Index<itkGetStaticConstMacro(InputImageDimension)> IndexType;

  typedef typename InputImageType::SizeType InputSizeType;

  /* NodeContainer typedef support for storing a set of seed points */
  typedef VectorContainer<unsigned int, IndexType> NodeContainer;

  /* NodeContainer pointer support */
  typedef typename NodeContainer::Pointer NodeContainerPointer;

  enum LabelType { NoLabel, ObjectLabel, BackgroundLabel };


  /* indicates the strength of a label for a given cell */
  typedef Image<TWeightPixelType, itkGetStaticConstMacro(InputImageDimension) > WeightImageType;

  typedef typename WeightImageType::Pointer WeightImagePointer;

  typedef TWeightPixelType WeightPixelType;

  void SetInputImage( const InputImageType *in)
  {
    this->ProcessObject::SetNthInput(0, const_cast< InputImageType *>(in) );
  }

  const InputImagePointer GetInputImage( );

  void SetLabelImage( const OutputImageType *f)
  {
    this->ProcessObject::SetNthInput(1, const_cast< OutputImageType *>(f) );
    m_LabelImage = static_cast< OutputImageType *>(this->ProcessObject::GetInput(1));
  }

  const OutputImagePointer GetLabelImage();

  const WeightImagePointer GetStrengthImage();

  void SetStrengthImage( const WeightImageType *w )
  {
    this->ProcessObject::SetNthInput(2,const_cast< WeightImageType *>(w));
    //m_WeightImage = static_cast< WeightImageType *>(this->ProcessObject::GetInput(2));
  }

  const WeightImagePointer GetUpdatedStrengthImage();

  void SetStateImage( const OutputImageType *l);
  const OutputImagePointer GetStateImage();

  void SetDistancesImage( const WeightImageType *d);
  const WeightImagePointer GetDistancesImage();

  void SetMaxSaturationImage( const WeightImageType *w);
  const WeightImagePointer GetMaxSaturationImage();

  itkSetMacro( SeedStrength, double );

  itkGetConstMacro( SeedStrength, double );

  itkSetMacro( Labeled, unsigned int);
  itkGetMacro( Labeled, unsigned int);

  itkSetMacro( LocallySaturated, unsigned int);
  itkGetMacro( LocallySaturated, unsigned int);

  itkSetMacro( Saturated, unsigned int);
  itkGetMacro( Saturated, unsigned int);

  itkSetMacro( MaxIterations, unsigned int );

  itkGetConstMacro( MaxIterations, unsigned int );

  itkSetMacro( ObjectRadius, unsigned int );

  itkGetConstMacro( ObjectRadius, unsigned int );

  void SetROIStart( const OutputIndexType &start)
  {
    m_RoiStart = start;
  }

  OutputIndexType GetROIStart() const
  {
    return m_RoiStart;
  }


  void SetROIEnd(const OutputIndexType &end)
  {
    m_RoiEnd = end;
  }


  OutputIndexType GetROIEnd() const
  {
    return m_RoiEnd;
  }

  itkSetMacro( Radius, InputSizeType );

  itkGetConstMacro( Radius, InputSizeType );

  itkSetMacro(RunOneIteration, bool);
  itkGetConstMacro(RunOneIteration, bool);
  itkBooleanMacro(RunOneIteration);


  itkSetMacro(SetDistancesImage, bool);
  itkGetConstMacro(SetDistancesImage, bool);
  itkBooleanMacro(SetDistancesImage);

  itkSetMacro(SetStateImage, bool);
  itkGetConstMacro(SetStateImage, bool);
  itkBooleanMacro(SetStateImage);

  itkSetMacro(SetMaxSaturationImage, bool);
  itkGetConstMacro(SetMaxSaturationImage, bool);
  itkBooleanMacro(SetMaxSaturationImage);

 protected:

  GrowCutSegmentationImageFilter();
  ~GrowCutSegmentationImageFilter() override  = default;

   // Override since the filter needs all the data for the algorithm
  void GenerateInputRequestedRegion() override;

   // Override since the filter produces the entire dataset
  void EnlargeOutputRequestedRegion(DataObject *output) override;

  void GenerateData() override;

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

  void AfterThreadedGenerateData() override;

  void Initialize(OutputImageType* output);

  void PrintSelf ( std::ostream& os, Indent indent ) const override;

  void GrowCutSlowROI( TOutputImage *);


 private:

  GrowCutSegmentationImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); // purposely not implemented

  bool InitializeStateImage( OutputImageType *state );

  void InitializeDistancesImage(TInputImage *input,WeightImageType *distance);

  void GetRegionOfInterest();

  void ComputeLabelVolumes(TOutputImage *outputImage, std::vector< unsigned > &volumes, std::vector< unsigned > &phyVolumes);

  void MaskSegmentedImageByWeight(float upperThresh);


  WeightPixelType                            m_ConfThresh;
  InputSizeType                              m_Radius;
  OutputImagePointer                         m_LabelImage;
  WeightImagePointer                         m_WeightImage;
  unsigned int                               m_Labeled;
  unsigned int                               m_LocallySaturated;
  unsigned int                               m_Saturated;

  double                                     m_SeedStrength;
  bool                                       m_RunOneIteration;
  bool                                       m_SetStateImage;
  bool                                       m_SetDistancesImage;
  bool                                       m_SetMaxSaturationImage;

  unsigned int                               m_MaxIterations;
  unsigned int                               m_ObjectRadius;

  OutputPixelType                        m_ObjectLabel;
  OutputPixelType                        m_BackgroundLabel;
  OutputPixelType                        m_UnknownLabel;

  OutputIndexType                            m_RoiStart;
  OutputIndexType                            m_RoiEnd;

};

} // namespace itk


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

#endif