itkConnectednessFilter.h

Go to the documentation of this file.

#ifndef __itkConnectednessFilter_h
#define __itkConnectednessFilter_h

#include "itkImageRegionIterator.h"
#include "itkImageToImageFilter.h"
#include <itkDiffusionTensor3D.h>

namespace itk
{
  template <class TFeatureImage, class TSeedImage, typename TTensorImagePixelType = double>
  class ConnectednessFilter : public ImageToImageFilter<TFeatureImage, TFeatureImage>
  {
  public:
    typedef ConnectednessFilter Self;
    typedef ImageToImageFilter<TFeatureImage, TFeatureImage> Superclass;
    typedef SmartPointer<Self> Pointer;

    typedef typename itk::Image<itk::DiffusionTensor3D<TTensorImagePixelType>, 3> TTensorImage;

    typedef typename TSeedImage::PixelType SeedPixelType;
    typedef typename TFeatureImage::PixelType FeaturePixelType;
    typedef typename TTensorImage::PixelType TensorPixelType;

    typedef typename TFeatureImage::IndexType IndexType;
    typedef typename TSeedImage::IndexType IndexSeedType;
    typedef typename TTensorImage::IndexType IndexTensorType;

    typedef typename itk::ImageRegionIterator<TSeedImage> SeedIteratorType;
    typedef typename itk::ImageRegionIterator<TFeatureImage> FeatureIteratorType;

    itkNewMacro(Self)

      
      itkTypeMacro(PropagateLocalFeaturesFilter, ImageToImageFilter)

      enum DistanceMode {
        FeatureSimilarity,
        VectorAgreement,
        FeatureVectorAgreement
      };

    void SetInputImage(const TFeatureImage *image);

    void SetInputSeed(const TSeedImage *mask);

    void SetInputMask(const TSeedImage *mask);

    void SetInputVectorField(const TTensorImage *vecs);

    void SetInputVectorFieldConfidenceMap(const TFeatureImage *conf);

    void SetPropagationImage(const TFeatureImage *prop);

    typename TFeatureImage::Pointer GetDistanceImage();

    typename TFeatureImage::Pointer GetEuclideanDistanceImage();

    void SetMode(DistanceMode mode = FeatureSimilarity) { m_Mode = mode; }
    void SetApplyRankFilter(bool applyFilter) { m_ApplyRankFilter = applyFilter; }
  protected:
    ConnectednessFilter() { m_ApplyRankFilter = false; }
    ~ConnectednessFilter() {}
    virtual void GenerateData();

    virtual double GetDistanceValue(IndexType idxStart, IndexType idxEnd);

  private:
    ConnectednessFilter(const Self &); // purposely not implemented
    void operator=(const Self &);      // purposely not implemented

    typename TFeatureImage::Pointer m_InputImage;
    typename TTensorImage::Pointer m_TensorImage;
    typename TFeatureImage::Pointer m_ConfidenceImage;
    // Distance image w.r.t. to metric
    typename TFeatureImage::Pointer m_DistanceImage;
    // Euclidean distance, that keeps track of distance of shortest path
    typename TFeatureImage::Pointer m_EuclideanDistance;

    DistanceMode m_Mode;

    bool m_ApplyRankFilter;
  };
} // namespace ITK

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkConnectednessFilter.cxx"
#endif

#endif // itkConnectednessFilter_h