itkImageKmeansModelEstimator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkImageKmeansModelEstimator.h,v $
  Language:  C++
  Date:      $Date: 2004/11/12 00:54:30 $
  Version:   $Revision: 1.10 $

  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 _itkImageKmeansModelEstimator_h
#define _itkImageKmeansModelEstimator_h

#include <time.h>
#include <math.h>
#include <float.h>

#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"
#include "vnl/vnl_math.h"
#include "vnl/algo/vnl_matrix_inverse.h"

#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkExceptionObject.h"

#include "itkImageModelEstimatorBase.h"

#define  ONEBAND           1
#define  GLA_CONVERGED     1
#define  GLA_NOT_CONVERGED 2
#define  LBG_COMPLETED     3

namespace itk
{

template <class TInputImage, 
          class TMembershipFunction>
class ITK_EXPORT ImageKmeansModelEstimator: 
    public ImageModelEstimatorBase<TInputImage, TMembershipFunction>
{
public:
  typedef ImageKmeansModelEstimator   Self;
  typedef ImageModelEstimatorBase<TInputImage, TMembershipFunction> Superclass;

  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageKmeansModelEstimator, ImageModelEstimatorBase);

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

  typedef typename TInputImage::PixelType::VectorType    
  InputImageVectorType;

  typedef typename TInputImage::PixelType     InputImagePixelType;

  typedef 
  ImageRegionIterator<TInputImage> InputImageIterator;

  typedef 
  ImageRegionConstIterator<TInputImage> InputImageConstIterator;     

  typedef typename TMembershipFunction::Pointer MembershipFunctionPointer ;

  typedef vnl_matrix<double> CodebookMatrixOfDoubleType; 

  typedef vnl_matrix<int>    CodebookMatrixOfIntegerType;

  void SetCodebook(CodebookMatrixOfDoubleType InCodebook);

  itkGetMacro(Codebook,CodebookMatrixOfDoubleType);

  CodebookMatrixOfDoubleType GetOutCodebook()
  { return m_Codebook; }

  itkSetMacro(Threshold,double);

  itkGetMacro(Threshold,double);

  itkSetMacro(OffsetAdd,double);

  itkGetMacro(OffsetAdd,double);

  itkSetMacro(OffsetMultiply,double);

  itkGetMacro(OffsetMultiply,double);

  itkSetMacro(MaxSplitAttempts,int);

  itkGetMacro(MaxSplitAttempts,int);

  CodebookMatrixOfDoubleType GetKmeansResults(void)
  { return m_Centroid; }

protected: 
  ImageKmeansModelEstimator();
  ~ImageKmeansModelEstimator();
  virtual void PrintSelf(std::ostream& os, Indent indent) const;

  void GenerateData() ;

  void Allocate();

  void PrintKmeansAlgorithmResults();
private:
  ImageKmeansModelEstimator(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  virtual void EstimateModels();

  void EstimateKmeansModelParameters();

  typedef typename TInputImage::SizeType ImageSizeType;

  typedef typename TInputImage::PixelType::VectorType InputPixelVectorType;

  void Reallocate(int oldSize, int newSize);

  //Local functions
  int  WithCodebookUseGLA(); // GLA stands for the Generalized Lloyd Algorithm
  int  WithoutCodebookUseLBG(); //LBG stands for the Lindo Buzo Gray Algorithm

  void NearestNeighborSearchBasic(double *distortion);
  
  void SplitCodewords(int currentSize, 
                      int numDesired, 
                      int scale);
  
  void Perturb(double *oldCodeword, 
               int scale, 
               double *newCodeword);

  CodebookMatrixOfDoubleType  m_Codebook;

  // Buffer for K-means calcualtions
  CodebookMatrixOfDoubleType  m_Centroid;

  double              m_Threshold;
  double              m_OffsetAdd;
  double              m_OffsetMultiply;
  int                 m_MaxSplitAttempts;

  //unsigned long       m_NumberOfModels;
  bool                m_ValidInCodebook;
  double              m_DoubleMaximum;
  double              m_OutputDistortion;
  int                 m_OutputNumberOfEmptyCells;

  unsigned long       m_VectorDimension;
  unsigned long       m_NumberOfCodewords;
  unsigned long       m_CurrentNumberOfCodewords;
  
  CodebookMatrixOfIntegerType  m_CodewordHistogram;
  CodebookMatrixOfDoubleType  m_CodewordDistortion;

}; // class ImageKmeansModelEstimator


} // namespace itk

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



#endif

---