itkMeshFromFiberTractsFilter.h

Go to the documentation of this file.

#ifndef __itkMeshFromFiberTractsFilter_h
#define __itkMeshFromFiberTractsFilter_h

#include <itkLightProcessObject.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>

#include "itkFiberTracts.h"
#include "utlCoreMacro.h"

namespace itk
{

class ITK_EXPORT MeshFromFiberTractsFilter : public LightProcessObject
{
public:
  typedef MeshFromFiberTractsFilter       Self;
  typedef LightProcessObject   Superclass;
  typedef SmartPointer<Self>   Pointer;
  
  itkNewMacro(Self);

  itkTypeMacro(MeshFromFiberTractsFilter, LightProcessObject);

  typedef FiberTracts<double>                     FiberTractsType;
  typedef typename FiberTractsType::Pointer       FiberTractsPointer;
  typedef typename FiberTractsType::FiberType     FiberType;
  typedef typename FiberTractsType::FiberPointer  FiberPointer;
  typedef typename FiberType::STDVectorType       STDVectorType;
  typedef typename FiberType::VertexType          VertexType;

  typedef vtkPolyData OutputMeshPolyDataType;
  typedef vtkSmartPointer<vtkPolyData> OutputMeshPolyDataPointer;
  
  typedef enum 
  {
    GLYPH_LINE=0,      //0
    GLYPH_TUBE 
  } GlyphShapeType;
  
  typedef enum
  {
    COLOR_NONE=0, 
    COLOR_FIXED, 
    COLOR_BY_POINT_DIRECTION, 
    COLOR_BY_MEAN_DIRECTION,   
    COLOR_BY_ENDPOINTS_DIRECTION,   
    COLOR_BY_IMAGE,
    COLOR_BY_SCALARS,
    COLOR_BY_PROPERTY
  } ColorSchemeType;

  itkSetGetMacro(FiberTracts, FiberTractsPointer);
  
  itkSetGetMacro(ColorScheme, ColorSchemeType);
  itkSetGetMacro(ShapeMode, GlyphShapeType);
  
  itkSetGetMacro(TubeRadius, double);
  
  void SetColor(double r, double g, double b)
    {
    m_Color[0]=r, m_Color[1]=g, m_Color[2]=b;
    }
  const double* GetColor() const
    {
    return m_Color;
    }
  
  void SetFlip(const int flipx, const int flipy, const int flipz )
    {
    m_Flip[0]=flipx, m_Flip[1]=flipy, m_Flip[2]=flipz;
    }
  std::vector<int> GetFlip() const
    {
    return m_Flip;
    }

  virtual void Update();

  OutputMeshPolyDataPointer GetOutput() const
    {
    return this->m_Mesh;
    }

    
protected:
  MeshFromFiberTractsFilter(){}
  ~MeshFromFiberTractsFilter(){}
  
  typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;

  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE
    {
    Superclass::PrintSelf(os, indent);
    m_FiberTracts->Print(os, indent);
    utl::PrintVector(m_Flip, "m_Flip");
    PrintVar(true, os<<indent, m_TubeRadius, m_ShapeMode, m_ColorScheme);
    PrintVar(true, os<<indent, m_Color[0], m_Color[1], m_Color[2]);
    m_Mesh->Print(std::cout<<"m_Mesh=");
    }
  
  FiberTractsPointer m_FiberTracts = FiberTractsType::New();

  ColorSchemeType m_ColorScheme=COLOR_BY_POINT_DIRECTION;

  GlyphShapeType m_ShapeMode=GLYPH_LINE;
  
  OutputMeshPolyDataPointer m_Mesh = OutputMeshPolyDataType::New();
  
  double m_Color[3]={255,0,0};
  
  double m_TubeRadius=0.2;

  std::vector<int> m_Flip = std::vector<int>(3, 0);

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

};


}

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


#endif