itkTractsToVectorImageFilter.h

Go to the documentation of this file.

#ifndef __itkTractsToVectorImageFilter_h__
#define __itkTractsToVectorImageFilter_h__

// MITK
#include <mitkFiberBundle.h>

// ITK
#include <itkImageSource.h>
#include <itkVectorImage.h>

// VTK
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkCellArray.h>
#include <vtkPoints.h>
#include <vtkPolyLine.h>

using namespace mitk;

namespace itk{

template< class PixelType >
class TractsToVectorImageFilter : public ImageSource< VectorImage< float, 3 > >
{

public:
    typedef TractsToVectorImageFilter Self;
    typedef ProcessObject Superclass;
    typedef SmartPointer< Self > Pointer;
    typedef SmartPointer< const Self > ConstPointer;

    typedef itk::Vector<float,3>                    OutputVectorType;
    typedef itk::Image<OutputVectorType, 3>         OutputImageType;
    typedef std::vector< OutputImageType::Pointer > OutputImageContainerType;

    typedef vnl_vector_fixed< double, 3 >                                       DirectionType;
    typedef VectorContainer< unsigned int, DirectionType >                      DirectionContainerType;
    typedef VectorContainer< unsigned int, DirectionContainerType::Pointer >    ContainerType;
    typedef Image< Vector< float, 3 >, 3>                                       ItkDirectionImageType;
    typedef VectorContainer< unsigned int, ItkDirectionImageType::Pointer >     DirectionImageContainerType;
    typedef itk::Image<unsigned char, 3>                                        ItkUcharImgType;
    typedef itk::Image<double, 3>                                               ItkDoubleImgType;

    itkFactorylessNewMacro(Self)
    itkCloneMacro(Self)
    itkTypeMacro( TractsToVectorImageFilter, ImageSource )

    itkSetMacro( SizeThreshold, float)
    itkGetMacro( SizeThreshold, float)
    itkSetMacro( AngularThreshold, float)                               
    itkGetMacro( AngularThreshold, float)                               
    itkSetMacro( NormalizeVectors, bool)                                
    itkGetMacro( NormalizeVectors, bool)                                
    itkSetMacro( UseWorkingCopy, bool)                                  
    itkGetMacro( UseWorkingCopy, bool)                                  
    itkSetMacro( MaxNumDirections, unsigned long)                       
    itkGetMacro( MaxNumDirections, unsigned long)                       
    itkSetMacro( MaskImage, ItkUcharImgType::Pointer)                   
    itkSetMacro( FiberBundle, FiberBundle::Pointer)                    
    itkGetMacro( ClusteredDirectionsContainer, ContainerType::Pointer)  
    itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)          
    itkGetMacro( OutputFiberBundle, FiberBundle::Pointer)              
    itkGetMacro( DirectionImageContainer, DirectionImageContainerType::Pointer) 
    itkSetMacro( CreateDirectionImages, bool)

    void GenerateData() override;

protected:

    DirectionContainerType::Pointer FastClustering(DirectionContainerType::Pointer inDirs, std::vector< double > lengths);  
//    std::vector< DirectionType > Clustering(std::vector< DirectionType >& inDirs);
//    DirectionContainerType::Pointer MeanShiftClustering(DirectionContainerType::Pointer dirCont);
//    vnl_vector_fixed<double, 3> ClusterStep(DirectionContainerType::Pointer dirCont, vnl_vector_fixed<double, 3> currentMean);

    vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
    itk::Point<double, 3> GetItkPoint(double point[3]);


    TractsToVectorImageFilter();
    virtual ~TractsToVectorImageFilter();

    FiberBundle::Pointer               m_FiberBundle;                      
    float                               m_AngularThreshold;                 
    float                               m_Epsilon;                          
    ItkUcharImgType::Pointer            m_MaskImage;                        
    bool                                m_NormalizeVectors;                 
    itk::Vector<float>                  m_OutImageSpacing;                  
    ContainerType::Pointer              m_DirectionsContainer;              
    bool                                m_UseWorkingCopy;                   
    unsigned long                       m_MaxNumDirections;                 
    float                               m_SizeThreshold;
    bool                                m_CreateDirectionImages;

    // output datastructures
    ContainerType::Pointer                  m_ClusteredDirectionsContainer; 
    ItkUcharImgType::Pointer                m_NumDirectionsImage;           
    DirectionImageContainerType::Pointer    m_DirectionImageContainer;      
    FiberBundle::Pointer                   m_OutputFiberBundle;            
};

}

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

#endif // __itkTractsToVectorImageFilter_h__