itkStreamlineTrackingFilter.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

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

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

This file is based heavily on a corresponding ITK filter.

===================================================================*/
#ifndef __itkStreamlineTrackingFilter_h_
#define __itkStreamlineTrackingFilter_h_

#include <MitkFiberTrackingExports.h>
#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
#include <itkVectorImage.h>
#include <itkDiffusionTensor3D.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>

namespace itk{

  template< class TTensorPixelType, class TPDPixelType=double>
  class StreamlineTrackingFilter :
      public ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >,
      Image< Vector< TPDPixelType, 3 >, 3 > >
  {

  public:

    typedef StreamlineTrackingFilter Self;
    typedef SmartPointer<Self>                      Pointer;
    typedef SmartPointer<const Self>                ConstPointer;
    typedef ImageToImageFilter< Image< DiffusionTensor3D<TTensorPixelType>, 3 >, Image< Vector< TPDPixelType, 3 >, 3 > > Superclass;

    itkFactorylessNewMacro(Self)
    itkCloneMacro(Self)

    itkTypeMacro(StreamlineTrackingFilter, ImageToImageFilter)

    typedef TTensorPixelType                            TensorComponentType;
    typedef TPDPixelType                                DirectionPixelType;
    typedef typename Superclass::InputImageType         InputImageType;
    typedef typename Superclass::OutputImageType        OutputImageType;
    typedef typename Superclass::OutputImageRegionType  OutputImageRegionType;
    typedef itk::Image<unsigned char, 3>                ItkUcharImgType;
    typedef itk::Image<double, 3>                       ItkDoubleImgType;
    typedef itk::Image<float, 3>                        ItkFloatImgType;
    typedef itk::Image< vnl_vector_fixed<double,3>, 3>  ItkPDImgType;
    typedef vtkSmartPointer< vtkPolyData >              FiberPolyDataType;

    itkGetMacro( FiberPolyData, FiberPolyDataType )     
    itkSetMacro( SeedImage, ItkUcharImgType::Pointer)   
    itkSetMacro( MaskImage, ItkUcharImgType::Pointer)   
    itkSetMacro( FaImage, ItkFloatImgType::Pointer)     
    itkSetMacro( SeedsPerVoxel, int)                    
    itkSetMacro( FaThreshold, double)                    
    itkSetMacro( StepSize, double)                       
    itkSetMacro( F, double )                             
    itkSetMacro( G, double )                             
    itkSetMacro( Interpolate, bool )                    
    itkSetMacro( MinTractLength, double )                
    itkGetMacro( MinTractLength, double )
    itkSetMacro( MinCurvatureRadius, double )            
    itkGetMacro( MinCurvatureRadius, double )
    itkSetMacro( ResampleFibers, bool )                 

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

    void CalculateNewPosition(itk::ContinuousIndex<double, 3>& pos, vnl_vector_fixed<double,3>& dir, typename InputImageType::IndexType& index);    
    double FollowStreamline(itk::ContinuousIndex<double, 3> pos, int dirSign, vtkPoints* points, std::vector< vtkIdType >& ids, int imageIdx);       
    bool IsValidPosition(itk::ContinuousIndex<double, 3>& pos, typename InputImageType::IndexType& index, vnl_vector_fixed< double, 8 >& interpWeights, int imageIdx);   

    double RoundToNearest(double num);
    void BeforeThreadedGenerateData();
    void ThreadedGenerateData( const OutputImageRegionType &outputRegionForThread, ThreadIdType threadId);
    void AfterThreadedGenerateData();

    FiberPolyDataType AddPolyData(FiberPolyDataType poly1, FiberPolyDataType poly2);    

    FiberPolyDataType               m_FiberPolyData;
    vtkSmartPointer<vtkPoints>      m_Points;
    vtkSmartPointer<vtkCellArray>   m_Cells;

    std::vector< ItkDoubleImgType::Pointer >         m_EmaxImage;    
    ItkFloatImgType::Pointer                        m_FaImage;      
    std::vector< ItkPDImgType::Pointer >            m_PdImage;      
    std::vector< typename InputImageType::Pointer > m_InputImage;   

    int     m_NumberOfInputs;
    double   m_FaThreshold;
    double   m_MinCurvatureRadius;
    double   m_StepSize;
    int     m_MaxLength;
    double   m_MinTractLength;
    int     m_SeedsPerVoxel;
    double   m_F;
    double   m_G;
    bool    m_Interpolate;
    double   m_PointPistance;
    bool    m_ResampleFibers;
    std::vector< int >          m_ImageSize;
    std::vector< double >        m_ImageSpacing;
    ItkUcharImgType::Pointer    m_SeedImage;
    ItkUcharImgType::Pointer    m_MaskImage;

    itk::VectorContainer< int, FiberPolyDataType >::Pointer m_PolyDataContainer;

  private:

  };

}

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkStreamlineTrackingFilter.cpp"
#endif

#endif //__itkStreamlineTrackingFilter_h_