itkIntegrateStreamlinesFilter.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). 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 in the top level directory for details.

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

#ifndef itkIntegrateStreamlinesFilter_h
#define itkIntegrateStreamlinesFilter_h

#include <itkImage.h>
#include <itkVector.h>
#include "itkBaseCTEStreamlinesFilter.h"
#include <itkLinearInterpolateImageFunction.h>
#include <itkVectorLinearInterpolateImageFunction.h>

namespace itk {
template < class TImageType, typename TScalarType=double, unsigned int NDimensions=3 > 
class ITK_EXPORT IntegrateStreamlinesFilter :
  public BaseCTEStreamlinesFilter<TImageType, TScalarType, NDimensions>
{
public:

  typedef IntegrateStreamlinesFilter                                     Self;
  typedef BaseCTEStreamlinesFilter<TImageType, TScalarType, NDimensions> Superclass;
  typedef SmartPointer<Self>                                             Pointer;
  typedef SmartPointer<const Self>                                       ConstPointer;
  
  itkNewMacro(Self);

  itkTypeMacro(IntegrateStreamlinesFilter, BaseCTEStreamlinesFilter);

  itkStaticConstMacro(Dimension, unsigned int, NDimensions);

  typedef Vector< TScalarType, NDimensions >                     InputVectorImagePixelType;
  typedef Image< InputVectorImagePixelType, NDimensions >        InputVectorImageType;
  typedef typename InputVectorImageType::Pointer                 InputVectorImagePointer;
  typedef typename InputVectorImageType::ConstPointer            InputVectorImageConstPointer; 
  typedef TScalarType                                            InputScalarImagePixelType;
  typedef Image< InputScalarImagePixelType, NDimensions >        InputScalarImageType;
  typedef typename InputScalarImageType::PointType               InputScalarImagePointType;
  typedef typename InputScalarImageType::Pointer                 InputScalarImagePointer;
  typedef typename InputScalarImageType::IndexType               InputScalarImageIndexType;
  typedef typename InputScalarImageType::ConstPointer            InputScalarImageConstPointer;
  typedef typename InputScalarImageType::RegionType              InputScalarImageRegionType;
  typedef InputScalarImageType                                   OutputImageType;
  typedef typename OutputImageType::PixelType                    OutputImagePixelType;
  typedef typename OutputImageType::Pointer                      OutputImagePointer;
  typedef typename OutputImageType::ConstPointer                 OutputImageConstPointer;
  typedef VectorLinearInterpolateImageFunction<
                                          InputVectorImageType
                                         ,TScalarType
                                              >                  VectorInterpolatorType;
  typedef typename VectorInterpolatorType::Pointer               VectorInterpolatorPointer;
  typedef typename VectorInterpolatorType::PointType             VectorInterpolatorPointType;
  typedef LinearInterpolateImageFunction< 
                                     InputScalarImageType
                                    ,TScalarType 
                                        >                        ScalarInterpolatorType;
  typedef typename ScalarInterpolatorType::Pointer               ScalarInterpolatorPointer;
  typedef typename ScalarInterpolatorType::PointType             ScalarInterpolatorPointType;

  void SetScalarImage(const InputScalarImageType *image) {this->SetNthInput(0, const_cast<InputScalarImageType *>(image)); }

  void SetVectorImage(const InputVectorImageType* image) { this->SetNthInput(1, const_cast<InputVectorImageType *>(image)); }
                                        
  itkSetMacro(MinIterationVoltage, InputScalarImagePixelType);
  itkGetMacro(MinIterationVoltage, InputScalarImagePixelType);

  itkSetMacro(MaxIterationVoltage, InputScalarImagePixelType);
  itkGetMacro(MaxIterationVoltage, InputScalarImagePixelType);

  itkSetMacro(StepSize, TScalarType);
  itkGetMacro(StepSize, TScalarType);

  itkSetMacro(MaxIterationLength, TScalarType);
  itkGetMacro(MaxIterationLength, TScalarType);

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

  // The main method to implement in derived classes, note, its threaded.
  virtual void ThreadedGenerateData( const InputScalarImageRegionType &outputRegionForThread, ThreadIdType threadId);

private:
  
  IntegrateStreamlinesFilter(const Self&); 
  void operator=(const Self&); 

  InputScalarImagePixelType m_MinIterationVoltage;
  
  InputScalarImagePixelType m_MaxIterationVoltage;
  
  TScalarType m_StepSize;

  TScalarType m_MaxIterationLength;

  double GetLengthToThreshold(
                              const InputScalarImagePointType &startingPoint,
                              const InputScalarImagePixelType &initialValue,
                              const InputScalarImagePixelType &threshold,
                              const InputVectorImagePointer   &vectorImage,
                              const InputScalarImagePointer   &scalarImage,
                              const VectorInterpolatorPointer &vectorInterpolator,
                              const ScalarInterpolatorPointer &scalarInterpolator,
                              const double &multiplier, // 1 or -1
                              const bool &debug,
                              bool &maxLengthExceeded
                             );
                              
  
};

} // end namespace

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

#endif