vtkPreciseHyperStreamline.h

Go to the documentation of this file.

/*=auto=========================================================================

  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.

  See Doc/copyright/copyright.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Program:   3D Slicer
  Module:    $RCSfile: vtkPreciseHyperStreamline.h,v $
  Date:      $Date: 2006/03/06 21:07:33 $
  Version:   $Revision: 1.6 $

=========================================================================auto=*/
//
//
//


#ifndef __vtkPreciseHyperStreamline_h
#define __vtkPreciseHyperStreamline_h

#include "vtkTeemConfigure.h"

#include "vtkDataSetToPolyDataFilter.h"
#include "vtkInitialValueProblemSolver.h" 

#define VTK_INTEGRATE_FORWARD 0
#define VTK_INTEGRATE_BACKWARD 1
#define VTK_INTEGRATE_BOTH_DIRECTIONS 2

#define VTK_INTEGRATE_MAJOR_EIGENVECTOR 0
#define VTK_INTEGRATE_MEDIUM_EIGENVECTOR 1
#define VTK_INTEGRATE_MINOR_EIGENVECTOR 2


class vtkPreciseHyperArray;

class VTK_Teem_EXPORT vtkPreciseHyperStreamline : public vtkDataSetToPolyDataFilter
{
 public:
  vtkTypeRevisionMacro(vtkPreciseHyperStreamline,vtkDataSetToPolyDataFilter);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkPreciseHyperStreamline *New();

  void SetStartLocation(vtkIdType cellId, int subId, vtkFloatingPointType pcoords[3]);

  void SetStartLocation(vtkIdType cellId, int subId, vtkFloatingPointType r, vtkFloatingPointType s,
                        vtkFloatingPointType t);

  vtkIdType GetStartLocation(int& subId, vtkFloatingPointType pcoords[3]);

  void SetStartPosition(vtkFloatingPointType x[3]);

  void SetStartPosition(vtkFloatingPointType x, vtkFloatingPointType y, vtkFloatingPointType z);

  vtkFloatingPointType *GetStartPosition();

  vtkSetClampMacro(MaximumPropagationDistance,vtkFloatingPointType,0.0,VTK_LARGE_FLOAT);
  vtkGetMacro(MaximumPropagationDistance,vtkFloatingPointType);

  vtkSetClampMacro(MinimumPropagationDistance,vtkFloatingPointType,0.0,VTK_LARGE_FLOAT);
  vtkGetMacro(MinimumPropagationDistance,vtkFloatingPointType);

  vtkSetClampMacro(IntegrationEigenvector,int,
                   VTK_INTEGRATE_MAJOR_EIGENVECTOR,
                   VTK_INTEGRATE_MINOR_EIGENVECTOR);
  vtkGetMacro(IntegrationEigenvector,int);
  void SetIntegrationEigenvectorToMajor()
    {this->SetIntegrationEigenvector(VTK_INTEGRATE_MAJOR_EIGENVECTOR);};
  void SetIntegrationEigenvectorToMedium()
    {this->SetIntegrationEigenvector(VTK_INTEGRATE_MEDIUM_EIGENVECTOR);};
  void SetIntegrationEigenvectorToMinor()
    {this->SetIntegrationEigenvector(VTK_INTEGRATE_MINOR_EIGENVECTOR);};

  void IntegrateMajorEigenvector()
    {this->SetIntegrationEigenvectorToMajor();};

  void IntegrateMediumEigenvector()
    {this->SetIntegrationEigenvectorToMedium();};

  void IntegrateMinorEigenvector()
    {this->SetIntegrationEigenvectorToMinor();};

  vtkSetClampMacro(IntegrationStepLength,vtkFloatingPointType,0.001,0.5);
  vtkGetMacro(IntegrationStepLength,vtkFloatingPointType);

  vtkSetClampMacro(StepLength,vtkFloatingPointType,0.000001,1.0);
  vtkGetMacro(StepLength,vtkFloatingPointType);



  void SetMethod(vtkInitialValueProblemSolver * meth)
    { method = meth; }

  vtkInitialValueProblemSolver * GetMethod(void) 
    { return method; }
  vtkSetClampMacro(IntegrationDirection,int,
           VTK_INTEGRATE_FORWARD,VTK_INTEGRATE_BOTH_DIRECTIONS);
  vtkGetMacro(IntegrationDirection,int);
  void SetIntegrationDirectionToForward()
    {this->SetIntegrationDirection(VTK_INTEGRATE_FORWARD);};
  void SetIntegrationDirectionToBackward()
    {this->SetIntegrationDirection(VTK_INTEGRATE_BACKWARD);};
  void SetIntegrationDirectionToIntegrateBothDirections()
    {this->SetIntegrationDirection(VTK_INTEGRATE_BOTH_DIRECTIONS);};

  vtkSetClampMacro(TerminalEigenvalue,vtkFloatingPointType,0.0,VTK_LARGE_FLOAT);
  vtkGetMacro(TerminalEigenvalue,vtkFloatingPointType);

  vtkSetClampMacro(TerminalFractionalAnisotropy,vtkFloatingPointType,0.0,1.0);
  vtkGetMacro(TerminalFractionalAnisotropy,vtkFloatingPointType);

  vtkSetClampMacro(MinStep,vtkFloatingPointType,0,VTK_LARGE_FLOAT);
  vtkGetMacro(MinStep,vtkFloatingPointType);

  vtkSetClampMacro(MaxStep,vtkFloatingPointType,0,VTK_LARGE_FLOAT);
  vtkGetMacro(MaxStep,vtkFloatingPointType);

  vtkSetClampMacro(MaxAngle,vtkFloatingPointType,0,1);
  vtkGetMacro(MaxAngle,vtkFloatingPointType);

  vtkSetClampMacro(LengthOfMaxAngle,vtkFloatingPointType,0,VTK_LARGE_FLOAT);
  vtkGetMacro(LengthOfMaxAngle,vtkFloatingPointType);

  vtkSetClampMacro(MaxError,vtkFloatingPointType,0.0000000001,VTK_LARGE_FLOAT);
  vtkGetMacro(MaxError,vtkFloatingPointType);

  vtkSetClampMacro(NumberOfSides,int,3,VTK_LARGE_INTEGER);
  vtkGetMacro(NumberOfSides,int);

  vtkSetClampMacro(Radius,vtkFloatingPointType,0.0001,VTK_LARGE_FLOAT);
  vtkGetMacro(Radius,vtkFloatingPointType);

  vtkSetMacro(LogScaling,int);
  vtkGetMacro(LogScaling,int);
  vtkBooleanMacro(LogScaling,int);
  
 protected:
  vtkPreciseHyperStreamline();
  ~vtkPreciseHyperStreamline();

  void Execute();
  void BuildTube();

  int StartFrom;

  vtkIdType StartCell;
  int StartSubId;
  vtkFloatingPointType StartPCoords[3];

  vtkFloatingPointType StartPosition[3];

  vtkInitialValueProblemSolver * method;

  vtkFloatingPointType MinStep;

  vtkFloatingPointType MaxStep;

  vtkFloatingPointType MaxError;
  
  //array of hyperstreamlines
  vtkPreciseHyperArray *Streamers;
  int NumberOfStreamers;

  vtkFloatingPointType MaximumPropagationDistance;

  vtkFloatingPointType MinimumPropagationDistance;

  int IntegrationDirection;

  vtkFloatingPointType IntegrationStepLength;

  vtkFloatingPointType StepLength;

  vtkFloatingPointType MaxAngle;

  vtkFloatingPointType LengthOfMaxAngle;

  vtkFloatingPointType TerminalEigenvalue;

  vtkFloatingPointType TerminalFractionalAnisotropy;

  vtkFloatingPointType RegularizationBias;

  int NumberOfSides;

  vtkFloatingPointType Radius;

  int LogScaling;

  int IntegrationEigenvector;
 private:
  vtkPreciseHyperStreamline(const vtkPreciseHyperStreamline&);  
  void operator=(const vtkPreciseHyperStreamline&);  
};

#endif