itkBayesianClassifierImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBayesianClassifierImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2010-01-30 21:05:25 $
  Version:   $Revision: 1.17 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkBayesianClassifierImageFilter_h
#define __itkBayesianClassifierImageFilter_h

#include "itkVectorImage.h"
#include "itkImageToImageFilter.h"
#include "itkMaximumDecisionRule.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"

namespace itk
{
  
template < class TInputVectorImage, class TLabelsType=unsigned char, 
           class TPosteriorsPrecisionType=double, class TPriorsPrecisionType=double >
class ITK_EXPORT BayesianClassifierImageFilter :
    public ImageToImageFilter< 
              TInputVectorImage, Image< TLabelsType, 
              ::itk::GetImageDimension< TInputVectorImage >::ImageDimension > >
{
public:
  typedef BayesianClassifierImageFilter     Self;
  typedef ImageToImageFilter< 
    TInputVectorImage,
    Image< TLabelsType, 
           ::itk::GetImageDimension< 
    TInputVectorImage >::ImageDimension > > Superclass;
  typedef SmartPointer<Self>                Pointer;
  typedef SmartPointer<const Self>          ConstPointer;

  itkNewMacro( Self );

  itkTypeMacro( BayesianClassifierImageFilter, ImageToImageFilter );

  typedef typename Superclass::InputImageType        InputImageType;

  itkStaticConstMacro( Dimension, unsigned int, 
                       ::itk::GetImageDimension< InputImageType >::ImageDimension );

  typedef Image< TLabelsType, 
          itkGetStaticConstMacro(Dimension) >        OutputImageType;
  typedef typename InputImageType::ConstPointer      InputImagePointer;
  typedef typename OutputImageType::Pointer          OutputImagePointer;
  typedef typename InputImageType::RegionType        ImageRegionType;
  
  typedef ImageRegionConstIterator< InputImageType > InputImageIteratorType;
  typedef ImageRegionIterator< OutputImageType >     OutputImageIteratorType;

  typedef typename InputImageType::PixelType              InputPixelType;
  typedef typename OutputImageType::PixelType             OutputPixelType;

  typedef VectorImage< TPriorsPrecisionType, 
     itkGetStaticConstMacro(Dimension) >                  PriorsImageType;
  typedef typename PriorsImageType::PixelType             PriorsPixelType;
  typedef typename PriorsImageType::Pointer               PriorsImagePointer;
  typedef ImageRegionConstIterator< PriorsImageType >     PriorsImageIteratorType;

  typedef TInputVectorImage                               MembershipImageType;
  typedef typename MembershipImageType::PixelType         MembershipPixelType;
  typedef typename MembershipImageType::Pointer           MembershipImagePointer;
  typedef ImageRegionConstIterator< MembershipImageType > MembershipImageIteratorType;

  typedef VectorImage< TPosteriorsPrecisionType, 
     itkGetStaticConstMacro(Dimension) >                  PosteriorsImageType;
  typedef typename PosteriorsImageType::PixelType         PosteriorsPixelType;
  typedef typename PosteriorsImageType::Pointer           PosteriorsImagePointer;
  typedef ImageRegionIterator< PosteriorsImageType >      PosteriorsImageIteratorType;

  typedef MaximumDecisionRule                             DecisionRuleType;
  typedef DecisionRuleType::Pointer                       DecisionRulePointer;

  typedef typename Superclass::DataObjectPointer          DataObjectPointer;

  typedef itk::Image< TPosteriorsPrecisionType, 
       itkGetStaticConstMacro(Dimension) >                ExtractedComponentImageType;

  typedef ImageToImageFilter< 
                   ExtractedComponentImageType, 
                   ExtractedComponentImageType  >         SmoothingFilterType;
  typedef typename SmoothingFilterType::Pointer           SmoothingFilterPointer;

  void SetSmoothingFilter( SmoothingFilterType * );
  itkGetConstMacro( SmoothingFilter, SmoothingFilterPointer );

  virtual void SetPriors( const PriorsImageType * );

  itkSetMacro( NumberOfSmoothingIterations, unsigned int );
  itkGetConstMacro( NumberOfSmoothingIterations, unsigned int );

  virtual DataObjectPointer MakeOutput(unsigned int idx);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(UnsignedIntConvertibleToLabelsCheck,
    (Concept::Convertible<unsigned int, TLabelsType>));
  itkConceptMacro(PosteriorsAdditiveOperatorsCheck,
    (Concept::AdditiveOperators<TPosteriorsPrecisionType>));
  itkConceptMacro(IntConvertibleToPosteriorsCheck,
    (Concept::Convertible<int, TPosteriorsPrecisionType>));
  itkConceptMacro(InputHasNumericTraitsCheck,
    (Concept::HasNumericTraits<typename InputPixelType::ValueType>));
  itkConceptMacro(PosteriorsHasNumericTraitsCheck,
    (Concept::HasNumericTraits<TPosteriorsPrecisionType>));
  itkConceptMacro(PriorsHasNumericTraitsCheck,
    (Concept::HasNumericTraits<TPriorsPrecisionType>));
  itkConceptMacro(InputPriorsPosteriorsMultiplyOperatorCheck,
    (Concept::MultiplyOperator<typename InputPixelType::ValueType,
                               PriorsPixelType, PosteriorsPixelType>));

#endif

protected:

  BayesianClassifierImageFilter();
  virtual ~BayesianClassifierImageFilter() {}
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void GenerateData();

  virtual void GenerateOutputInformation(void);

  virtual void ComputeBayesRule();
  virtual void NormalizeAndSmoothPosteriors();
  virtual void ClassifyBasedOnPosteriors();
  PosteriorsImageType *GetPosteriorImage();

private:

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

  bool m_UserProvidedPriors;

  bool m_UserProvidedSmoothingFilter;

  SmoothingFilterPointer  m_SmoothingFilter;

  unsigned int m_NumberOfSmoothingIterations;

};

} // end namespace itk


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

#endif