itkVectorFuzzyConnectednessImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVectorFuzzyConnectednessImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2002/11/13 00:52:54 $
  Version:   $Revision: 1.23 $

  Copyright (c) 2002 Insight 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 __itkVectorFuzzyConnectednessImageFilter_h
#define __itkVectorFuzzyConnectednessImageFilter_h

#include "itkImage.h"
#include "itkImageToImageFilter.h"
#include "itkVector.h"
#include "itkMatrix.h"
#include <vector>
#include <list>

namespace itk{

template <class TInputImage, class TOutputImage>
class VectorFuzzyConnectednessImageFilter:
  public ImageToImageFilter<TInputImage,TOutputImage>
{
public:
  typedef VectorFuzzyConnectednessImageFilter       Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage>   Superclass;
  typedef SmartPointer <Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(VectorFuzzyConnectednessImageFilter,ImageToImageFilter);

  typedef typename TInputImage::PixelType InputPixelType;
  typedef typename InputPixelType::VectorType InputVectorType;

  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);
  itkStaticConstMacro(VectorDimension, unsigned int,
                      InputPixelType::Dimension);

  typedef   Matrix<double,itkGetStaticConstMacro(VectorDimension),
                   itkGetStaticConstMacro(VectorDimension)>
            MatrixType;
  typedef   Vector<int,itkGetStaticConstMacro(VectorDimension)> VDVector;
  typedef   Vector<int,itkGetStaticConstMacro(ImageDimension)>  IDVector;

  typedef   TInputImage                           InputImageType;
  typedef   TOutputImage                          OutputImageType;
  typedef   Image <unsigned short,itkGetStaticConstMacro(ImageDimension)> UShortImage;
  typedef   typename TInputImage::IndexType       IndexType;
  typedef   typename TInputImage::SizeType        SizeType;
  typedef   typename TOutputImage::RegionType     RegionType;
  typedef   std::list<IndexType>                  ListType;
  typedef   std::vector<IDVector>                 OffsetType;
  typedef   std::vector<float>                    FloatType;
  
  itkSetMacro(Objects, int);
  itkGetMacro(Objects, int);

  itkSetMacro(SelectedObject, int);
  itkGetMacro(SelectedObject, int);  

  void SetObjectsMatrix(const MatrixType object_max,const int object_num);

  void SetObjectsSeed( const IndexType &seed, const int object_num);

  void SetObjectsMean(const VDVector, const int object_num);

  void Initialization();

protected:
  VectorFuzzyConnectednessImageFilter();
  ~VectorFuzzyConnectednessImageFilter();

  void GenerateData();

private:
  SizeType                       m_Size;
  OffsetType                     *m_SpherePointsLoc;
  int                            *m_SpherePointsNum;

  double                         m_Mask[3][3];
  double                         m_MaskTotal;
  VDVector                       m_HomoMaxDiff;
  VDVector                       m_FeaturesThreshold;
  VDVector                       m_PowerValue;
  
  int                            m_Objects;
  int                            m_SelectedObject;

  MatrixType                     *m_ObjectsCovMatrix;
  VDVector                       *m_ObjectsMean;

  VDVector                       *m_ObjectsMaxDiff;
  FloatType                      *m_ObjectsMap;
  ListType                       *m_ObjectsSeed;

  std::vector<float>             m_HomogeneityMap;
  std::vector<float>             m_ScaleMap;
  std::vector<char>              m_ScaleArray;
  std::vector<double>            m_Material;

  typename InputImageType::ConstPointer   m_InputImage;
  typename InputImageType::Pointer        m_FilterImage;
  typename UShortImage::Pointer           m_ObjectFuzzyScene;
  typename UShortImage::Pointer           m_BackgroundFuzzyScene;
  typename OutputImageType::Pointer       m_SegmentObject; 

  std::vector<unsigned short>  m_Xaffinity;
  std::vector<unsigned short>  m_Yaffinity;
  std::vector<unsigned short>  m_Zaffinity;

  void ScalePrepare();
  void Compute_LookupTable();
  void Compute_Scale();
  void Compute_Filter();
  void Compute_Affinity();
  void FastTracking(int);
  
private:
  VectorFuzzyConnectednessImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented  
};


} // end namespace itk

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

#endif

---