itkActiveShapeModelCalculator.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkActiveShapeModelCalculator.h,v $
  Language:  C++
  Date:      $Date: 2004/10/09 01:46:37 $
  Version:   $Revision: 1.1 $

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

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

#include "vnl/vnl_vector.h"
#include "vnl/vnl_matrix.h"
#include "vnl/vnl_math.h"
#include "vnl/algo/vnl_matrix_inverse.h"
#include <vnl/algo/vnl_generalized_eigensystem.h>
#include <vnl/algo/vnl_symmetric_eigensystem.h>

#include "itkImageSliceConstIteratorWithIndex.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageLinearIteratorWithIndex.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkGradientMagnitudeImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkDanielssonDistanceMapImageFilter.h"
#include "itkBinaryThinningImageFilter.h"
#include "itkBinaryPruningImageFilter.h"
#include "itkPointSet.h"
#include "itkVector.h"
#include "itkListSample.h"
#include "itkExceptionObject.h"

#include "itkConceptChecking.h"

#include <vector>
#include <list>

namespace itk{

template < class TImage >
class ITK_EXPORT ActiveShapeModelCalculator : public Object
{
public:
  typedef ActiveShapeModelCalculator<TImage>                              Self;
  typedef Object                                                          Superclass;
  typedef SmartPointer<Self>                                              Pointer;
  typedef SmartPointer<const Self>                                        ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ActiveShapeModelCalculator, Object);

  typedef float                                                           PixelType;
  typedef unsigned char                                                   Pixel8bitsType;

  typedef Vector< double, 2 >                                             Vector2DType;
  typedef Vector< double, 3 >                                             Vector3DType;
  typedef Vector< unsigned int, 2 >                                       MeasurementVectorType ;
  typedef std::vector< unsigned int>                                      VectorType;
  typedef vnl_vector<double>                                              VectorOfDoubleType;

  
  typedef vnl_matrix<double>                                              MatrixOfDoubleType;
  typedef vnl_matrix<int>                                                 MatrixOfIntegerType;

  typedef TImage                                                          Image3DType;
  typedef Image< PixelType, 2 >                                           Image2DType;
  typedef Image< Pixel8bitsType, 2 >                                      Image2D8bitsType;
  typedef Image< Pixel8bitsType, 3 >                                      Image3D8bitsType;

  typedef typename Image2D8bitsType::IndexType                            IndexType;
  typedef typename Image3DType::IndexType                                 Index3DType;

  typedef typename Image2DType::Pointer                                   Image2DPointer;
  typedef typename Image3DType::ConstPointer                              Image3DConstPointer;

  typedef PointSet< unsigned short, 2 >                                   PointSetType;
  typedef typename PointSetType::PointType                                PointType;

  typedef typename PointSetType::PointsContainer                          PointsContainer;
  typedef typename PointSetType::PointDataContainer                       PointDataContainer;

  typedef std::list<IndexType>                                            List2DType;
  typedef Statistics::ListSample< MeasurementVectorType >                 SampleType;

  typedef ImageLinearIteratorWithIndex< Image2DType >                     LinearIteratorType;
  typedef ImageSliceConstIteratorWithIndex< Image3DType >                 SliceIteratorType;
  typedef ImageRegionConstIterator< Image3D8bitsType  >                   ConstIteratorType;
  typedef ImageRegionIterator< Image2D8bitsType >                         IteratorType;
  typedef NeighborhoodIterator< Image2D8bitsType >                        NeighborIteratorType;
  typedef typename PointsContainer::Iterator                              PointsIterator;

  typedef GradientMagnitudeImageFilter< Image3DType, Image3DType >        GradientFilterType;
  typedef BinaryThresholdImageFilter<Image3DType, Image3DType >           BinaryFilterType;
  typedef BinaryThresholdImageFilter<Image2DType, Image2D8bitsType >      BinaryFilterType1;
  typedef BinaryThresholdImageFilter<Image3DType, Image3D8bitsType >      BinaryFilterType2;
  typedef DanielssonDistanceMapImageFilter< Image3DType, Image3DType >    DistanceMapFilterType;
  typedef BinaryThinningImageFilter< Image2D8bitsType, Image2D8bitsType > ThinFilterType;
  typedef BinaryPruningImageFilter< Image2D8bitsType, Image2D8bitsType >  PruneFilterType;

  virtual void SetImage( const Image3DType * image )
    {
    if ( m_Image != image )
      {
      m_Image = image;
      this->Modified();
      m_Valid = false;
      }
    }

  void SetLowerThresholdGradient(const double &lt)
  { m_LowerThreshold = lt; }
  const double &GetLowerThresholdGradient() const
  { return m_LowerThreshold; }

  void SetUpperThresholdMeanDistance(const double &ut1)
  { m_UpperThreshold1 = ut1; }
  const double &GetUpperThresholdMeanDistance() const
  { return m_UpperThreshold1; }

  void SetUpperThresholdDistance(const double &ut2)
  { m_UpperThreshold2 = ut2; }
  const double &GetUpperThresholdDistance() const
  { return m_UpperThreshold2; }

  void SetTolerance(const double &t)
  { m_Tolerance = t; }
  const double &GetTolerance() const
  { return m_Tolerance; }

  void SetPruneIteration(const unsigned int &t)
  { m_PruneIteration = t; }
  const unsigned int &GetPruneIteration() const
  { return m_PruneIteration; }

  const unsigned int &GetNumberOfTrainingImages() const
  { return m_NumberOfTrainingImages; }



  void GenerateData( );

  VectorOfDoubleType  GetMeanShape();

  VectorOfDoubleType  GetEigenvalues();

  MatrixOfDoubleType  GetEigenvector();

protected:

  ActiveShapeModelCalculator(): m_NumberOfTrainingImages(0)
  {
    m_LowerThreshold      = 10.0; // default value
    m_UpperThreshold1     = 1.0;  // default value
    m_UpperThreshold2     = 1.0;  // default value
    m_Tolerance           = 2.0;  // default value
    m_PruneIteration      = 3;    // default value
    m_NumberOfTrainingImages = 0;
    m_EigenVectors.set_size(0,0);
    m_EigenValues.set_size(0);
    m_Means.set_size(0);
    m_Valid = false;
    m_Image = NULL;
  }

  ~ActiveShapeModelCalculator() {}

  void PrintSelf(std::ostream& os, Indent indent) const
  {
    Superclass::PrintSelf(os,indent);
    os << indent << "LowerThreshold: " << m_LowerThreshold << std::endl;
    os << indent << "UpperThreshold1: " << m_UpperThreshold1 << std::endl;
    os << indent << "UpperThreshold2: " << m_UpperThreshold2 << std::endl;
    os << indent << "Tolerance: " << m_Tolerance << std::endl;
    os << indent << "Number of training images: " << m_NumberOfTrainingImages << std::endl;
    os << indent << "Number of iteration for Prunig filter: " << m_PruneIteration << std::endl;
    itkDebugMacro(<<"                                    ");
    itkDebugMacro(<<"Results of the shape model");
    itkDebugMacro(<<"====================================");

    itkDebugMacro(<< "The mean shape: ");
    
    itkDebugMacro(<< m_Means);

    itkDebugMacro(<< " ");
    itkDebugMacro(<< "==================   ");

    itkDebugMacro(<< "The eigen values: ");
    
    itkDebugMacro(<< m_EigenValues);

    itkDebugMacro(<< " ");
    itkDebugMacro(<< "==================   ");

    itkDebugMacro(<< "The eigen vectors: ");


    for(unsigned int i = 0; i < m_Means.size(); i++) 
    {
    itkDebugMacro(<< m_EigenVectors.get_row(i));
    }  

    itkDebugMacro(<< " ");
    itkDebugMacro(<< "+++++++++++++++++++++++++");
  }// end PrintSelf


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

  bool                  m_Valid;                      // Have parameters been computed yet?
  float                 m_LowerThreshold;
  float                 m_UpperThreshold1;
  float                 m_UpperThreshold2;
  float                 m_Tolerance;
  VectorOfDoubleType    m_Means; 
  MatrixOfDoubleType    m_EigenVectors;
  VectorOfDoubleType    m_EigenValues;
  unsigned int          m_NumberOfTrainingImages;
  unsigned int          m_PruneIteration;
  Image3DConstPointer   m_Image;

}; // class ActiveShapeModelCalculator
  
} // end of namespace itk

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

#endif

---