itkForegroundFromBackgroundImageThresholdCalculator.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 __itkForegroundFromBackgroundImageThresholdCalculator_h
#define __itkForegroundFromBackgroundImageThresholdCalculator_h

#include <itkImage.h>
#include <itkObject.h>
#include <itkMacro.h>
#include <itkImageToHistogramFilter.h>

namespace itk
{

template < class TInputImage >
class ITK_EXPORT ForegroundFromBackgroundImageThresholdCalculator 
  : public Object
{

public:

  typedef ForegroundFromBackgroundImageThresholdCalculator Self;
  typedef Object                        Superclass;
  typedef SmartPointer< Self >          Pointer;
  typedef SmartPointer< const Self >    ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ForegroundFromBackgroundImageThresholdCalculator, Object);

  typedef TInputImage ImageType;

  typedef typename TInputImage::Pointer ImagePointer;

  typedef typename TInputImage::ConstPointer ImageConstPointer;

  typedef typename TInputImage::PixelType PixelType;

  typedef typename TInputImage::IndexType IndexType;

  typedef typename TInputImage::RegionType RegionType;

  typedef typename itk::Statistics::ImageToHistogramFilter< TInputImage > ImageToHistogramFilterType;

  typedef typename ImageToHistogramFilterType::HistogramType HistogramType;
  itkSetConstObjectMacro(Image, ImageType);

  typedef itk::Array< double > ArrayType;

  void Compute( void ) throw (ExceptionObject);

  itkGetConstMacro(Threshold, PixelType);

  void SetRegion(const RegionType & region);

  void SetVerbose( bool flag )  { m_FlgVerbose = flag; }
  void SetVerboseOn( void )  { m_FlgVerbose = true;  }
  void SetVerboseOff( void ) { m_FlgVerbose = false; }

protected:

  ForegroundFromBackgroundImageThresholdCalculator();
  virtual ~ForegroundFromBackgroundImageThresholdCalculator() { 
    DeleteArrays(); 
  }

  bool m_FlgVerbose;

  PixelType         m_Threshold;
  ImageConstPointer m_Image;

  RegionType m_Region;
  bool       m_RegionSetByUser;

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

  void WriteHistogramToTextFile( std::string fileName,
                                 HistogramType *histogram );
  
  void WriteDataToTextFile( std::string fileName,
                            itk::Array< double > *x,
                            itk::Array< double > *y );

  void Normalise( itk::Array< double > *y );

  void ComputeVariances( int iStart, int iInc,
                         unsigned int nIntensities, 
                         PixelType firstIntensity );

private:

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

  HistogramType *m_Histogram;

  ArrayType *m_Intensities;
  ArrayType *m_NumberOfPixelsCummulative;
  ArrayType *m_Sums;
  ArrayType *m_Means;
  ArrayType *m_Variances;
  ArrayType *m_IntensityBias;
  ArrayType *m_Thresholds;

  void DeleteArrays( void ) {
    if ( m_Intensities ) delete m_Intensities;
    if ( m_NumberOfPixelsCummulative ) delete m_NumberOfPixelsCummulative;
    if ( m_Sums ) delete m_Sums;
    if ( m_Means ) delete m_Means;
    if ( m_Variances ) delete m_Variances;
    if ( m_IntensityBias ) delete m_IntensityBias;
    if ( m_Thresholds ) delete m_Thresholds;

    m_Intensities              = 0;
    m_NumberOfPixelsCummulative = 0;
    m_Sums                     = 0;
    m_Means                    = 0;
    m_Variances                = 0;
    m_IntensityBias            = 0;
    m_Thresholds               = 0;
  }

  void CreateArrays( unsigned int n ) {
    DeleteArrays();

    m_Intensities              = new ArrayType( n );
    m_NumberOfPixelsCummulative = new ArrayType( n );
    m_Sums                     = new ArrayType( n );
    m_Means                    = new ArrayType( n );
    m_Variances                = new ArrayType( n );
    m_IntensityBias            = new ArrayType( n );
    m_Thresholds               = new ArrayType( n );
  }

};

} // end namespace itk

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

#endif /* __itkForegroundFromBackgroundImageThresholdCalculator_h */