itkVesselEnhancingDiffusion3DImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkVesselEnhancingDiffusion3DImageFilter.h
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

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

#include "itkImageToImageFilter.h"
#include <vector>

namespace itk
{

template <class PixelType = short int, unsigned int NDimension = 3>
class ITK_EXPORT VesselEnhancingDiffusion3DImageFilter :
    public ImageToImageFilter<Image<PixelType, NDimension> ,
                              Image<PixelType, NDimension> >
{

public:
  typedef float                                           Precision;
  typedef Image<PixelType, NDimension>                    ImageType;
  typedef Image<Precision,NDimension>                     PrecisionImageType;

  typedef VesselEnhancingDiffusion3DImageFilter           Self;
  typedef ImageToImageFilter<ImageType,ImageType>         Superclass;
  typedef SmartPointer<Self>                              Pointer;
  typedef SmartPointer<const Self>                        ConstPointer;

  itkNewMacro(Self);
  itkTypeMacro(VesselEnhancingDiffusion3DImageFilter, ImageToImageFilter);

  itkSetMacro(TimeStep, Precision);
  itkSetMacro(Iterations, unsigned int);
  itkSetMacro(RecalculateVesselness, unsigned int);

  itkSetMacro(Alpha, Precision);
  itkSetMacro(Beta, Precision);
  itkSetMacro(Gamma, Precision);

  itkSetMacro(Epsilon, Precision);
  itkSetMacro(Omega, Precision);
  itkSetMacro(Sensitivity, Precision);

  void SetScales(const std::vector<Precision> scales)
    {
    m_Scales = scales;
    }
  itkBooleanMacro(DarkObjectLightBackground);
  itkSetMacro(DarkObjectLightBackground,bool);
  itkBooleanMacro(Verbose);
  itkSetMacro(Verbose,bool);

  // some defaults for lowdose example
  // used in the paper
  void SetDefaultPars()
    {
    m_TimeStep                  = 0.001;
    m_Iterations                = 30;
    m_RecalculateVesselness     = 100;
    m_Alpha                     = 0.5;
    m_Beta                      = 0.5;
    m_Gamma                     = 5.0;
    m_Epsilon                   = 0.01;
    m_Omega                     = 25.0;
    m_Sensitivity               = 5.0;

    m_Scales.resize(5);
    m_Scales[0] = 0.300;
    m_Scales[1] = 0.482;
    m_Scales[2] = 0.775;
    m_Scales[3] = 1.245;
    m_Scales[4] = 2.000;

    m_DarkObjectLightBackground = false;
    m_Verbose                   = true;
    }

protected:
  VesselEnhancingDiffusion3DImageFilter();
  ~VesselEnhancingDiffusion3DImageFilter() {};
  void PrintSelf(std::ostream &os, Indent indent) const;
  void GenerateData();

private:

  VesselEnhancingDiffusion3DImageFilter(const Self&);
  void operator=(const Self&);

  Precision                 m_TimeStep;
  unsigned int              m_Iterations;
  unsigned int              m_RecalculateVesselness;
  Precision                 m_Alpha;
  Precision                 m_Beta;
  Precision                 m_Gamma;
  Precision                 m_Epsilon;
  Precision                 m_Omega;
  Precision                 m_Sensitivity;
  std::vector<Precision>    m_Scales;
  bool                      m_DarkObjectLightBackground;
  bool                      m_Verbose;
  unsigned int              m_CurrentIteration;

  // current hessian for which we have max vesselresponse
  typename PrecisionImageType::Pointer m_Dxx;
  typename PrecisionImageType::Pointer m_Dxy;
  typename PrecisionImageType::Pointer m_Dxz;
  typename PrecisionImageType::Pointer m_Dyy;
  typename PrecisionImageType::Pointer m_Dyz;
  typename PrecisionImageType::Pointer m_Dzz;

  void VED3DSingleIteration (typename PrecisionImageType::Pointer );

  // Calculates maxvessel response of the range
  // of scales and stores the hessian of each voxel
  // into the member images m_Dij.
  void MaxVesselResponse (const typename PrecisionImageType::Pointer);

  // calculates diffusion tensor
  // based on current values of hessian (for which we have
  // maximim vessel response).
  void DiffusionTensor();

  // Sorted magnitude increasing
  inline Precision VesselnessFunction3D ( Precision, Precision, Precision );
};


} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVesselEnhancingDiffusion3DImageFilter.hxx"
#endif

#endif