vtkDiffusionTensorMathematics.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkDiffusionTensorMathematics.h,v $
  Date:      $Date: 2006/12/19 17:14:44 $
  Version:   $Revision: 1.20 $
 
=========================================================================auto=*/
//
//
 
 
#ifndef __vtkDiffusionTensorMathematics_h
#define __vtkDiffusionTensorMathematics_h
 
// vtkTeem includes
#include "vtkTeemConfigure.h"
 
// VTK includes
#include <vtkThreadedImageAlgorithm.h>
 
class vtkMatrix4x4;
class vtkImageData;
class VTK_Teem_EXPORT vtkDiffusionTensorMathematics : public vtkThreadedImageAlgorithm
{
public:
  static vtkDiffusionTensorMathematics *New();
  vtkTypeMacro(vtkDiffusionTensorMathematics,vtkThreadedImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum
  {
    VTK_TENS_TRACE = 0,
    VTK_TENS_DETERMINANT = 1,
    VTK_TENS_RELATIVE_ANISOTROPY = 2,
    VTK_TENS_FRACTIONAL_ANISOTROPY = 3,
    VTK_TENS_MAX_EIGENVALUE = 4,
    VTK_TENS_MID_EIGENVALUE = 5,
    VTK_TENS_MIN_EIGENVALUE = 6,
    VTK_TENS_LINEAR_MEASURE = 7,
    VTK_TENS_PLANAR_MEASURE = 8,
    VTK_TENS_SPHERICAL_MEASURE = 9,
    VTK_TENS_COLOR_ORIENTATION = 10,
    VTK_TENS_D11 = 11,
    VTK_TENS_D22 = 12,
    VTK_TENS_D33 = 13,
    VTK_TENS_MODE = 14,
    VTK_TENS_COLOR_MODE =15,
    VTK_TENS_MAX_EIGENVALUE_PROJX = 16,
    VTK_TENS_MAX_EIGENVALUE_PROJY = 17,
    VTK_TENS_MAX_EIGENVALUE_PROJZ = 18,
    VTK_TENS_RAI_MAX_EIGENVEC_PROJX = 19,
    VTK_TENS_RAI_MAX_EIGENVEC_PROJY = 20,
    VTK_TENS_RAI_MAX_EIGENVEC_PROJZ = 21,
    VTK_TENS_MAX_EIGENVEC_PROJX = 22,
    VTK_TENS_MAX_EIGENVEC_PROJY = 23,
    VTK_TENS_MAX_EIGENVEC_PROJZ = 24,
    VTK_TENS_PARALLEL_DIFFUSIVITY = 25,
    VTK_TENS_PERPENDICULAR_DIFFUSIVITY = 26,
    VTK_TENS_COLOR_ORIENTATION_MIDDLE_EIGENVECTOR = 27,
    VTK_TENS_COLOR_ORIENTATION_MIN_EIGENVECTOR = 28,
    VTK_TENS_MEAN_DIFFUSIVITY = 29
  };
  vtkGetMacro(Operation,int);
  vtkSetClampMacro(Operation,int, VTK_TENS_TRACE, VTK_TENS_MEAN_DIFFUSIVITY);
 
  void SetOperationToTrace()
    {this->SetOperation(VTK_TENS_TRACE);};
 
  void SetOperationToDeterminant()
    {this->SetOperation(VTK_TENS_DETERMINANT);};
 
  void SetOperationToRelativeAnisotropy()
    {this->SetOperation(VTK_TENS_RELATIVE_ANISOTROPY);};
  void SetOperationToFractionalAnisotropy()
    {this->SetOperation(VTK_TENS_FRACTIONAL_ANISOTROPY);};
  void SetOperationToLinearMeasure()
    {this->SetOperation(VTK_TENS_LINEAR_MEASURE);};
  void SetOperationToPlanarMeasure()
    {this->SetOperation(VTK_TENS_PLANAR_MEASURE);};
  void SetOperationToSphericalMeasure()
    {this->SetOperation(VTK_TENS_SPHERICAL_MEASURE);};
  void SetOperationToMode()
    {this->SetOperation(VTK_TENS_MODE);};
  void SetOperationToParallelDiffusivity()
    {this->SetOperation(VTK_TENS_PARALLEL_DIFFUSIVITY);};
  void SetOperationToPerpendicularDiffusivity()
    {this->SetOperation(VTK_TENS_PERPENDICULAR_DIFFUSIVITY);};
  void SetOperationToMeanDiffusivity()
    {this->SetOperation(VTK_TENS_MEAN_DIFFUSIVITY);};
 
  void SetOperationToMaxEigenvalue()
    {this->SetOperation(VTK_TENS_MAX_EIGENVALUE);};
  void SetOperationToMiddleEigenvalue()
    {this->SetOperation(VTK_TENS_MID_EIGENVALUE);};
  void SetOperationToMinEigenvalue()
    {this->SetOperation(VTK_TENS_MIN_EIGENVALUE);};
 
  void SetOperationToMaxEigenvalueProjectionX()
  {this->SetOperation(VTK_TENS_MAX_EIGENVALUE_PROJX);};
  void SetOperationToMaxEigenvalueProjectionY()
  {this->SetOperation(VTK_TENS_MAX_EIGENVALUE_PROJY);};
  void SetOperationToMaxEigenvalueProjectionZ()
  {this->SetOperation(VTK_TENS_MAX_EIGENVALUE_PROJZ);};
 
  void SetOperationToRAIMaxEigenvecX()
  {this->SetOperation(VTK_TENS_RAI_MAX_EIGENVEC_PROJX);}
  void SetOperationToRAIMaxEigenvecY()
  {this->SetOperation(VTK_TENS_RAI_MAX_EIGENVEC_PROJY);}
  void SetOperationToRAIMaxEigenvecZ()
  {this->SetOperation(VTK_TENS_RAI_MAX_EIGENVEC_PROJZ);}
 
  void SetOperationToMaxEigenvecX()
  {this->SetOperation(VTK_TENS_MAX_EIGENVEC_PROJX);}
  void SetOperationToMaxEigenvecY()
  {this->SetOperation(VTK_TENS_MAX_EIGENVEC_PROJY);}
  void SetOperationToMaxEigenvecZ()
  {this->SetOperation(VTK_TENS_MAX_EIGENVEC_PROJZ);}
 
 
  void SetOperationToD11()
    {this->SetOperation(VTK_TENS_D11);};
  void SetOperationToD22()
    {this->SetOperation(VTK_TENS_D22);};
  void SetOperationToD33()
    {this->SetOperation(VTK_TENS_D33);};
 
  void SetOperationToColorByOrientation()
    {this->SetOperation(VTK_TENS_COLOR_ORIENTATION);};
 
  void SetOperationToColorByMode()
    {this->SetOperation(VTK_TENS_COLOR_MODE);};
 
  vtkSetMacro(ScaleFactor,double);
  vtkGetMacro(ScaleFactor,double);
 
  vtkSetMacro(ExtractEigenvalues,int);
  vtkBooleanMacro(ExtractEigenvalues,int);
  vtkGetMacro(ExtractEigenvalues,int);
 
  //
  //
  //
  virtual void SetTensorRotationMatrix(vtkMatrix4x4*);
  vtkGetObjectMacro(TensorRotationMatrix, vtkMatrix4x4);
 
  vtkBooleanMacro(MaskWithScalars, int);
  vtkSetMacro(MaskWithScalars, int);
  vtkGetMacro(MaskWithScalars, int);
 
  vtkBooleanMacro(FixNegativeEigenvalues, int);
  vtkSetMacro(FixNegativeEigenvalues, int);
  vtkGetMacro(FixNegativeEigenvalues, int);
 
  virtual void SetScalarMask(vtkImageData*);
  vtkGetObjectMacro(ScalarMask, vtkImageData);
 
  vtkSetMacro(MaskLabelValue, int);
  vtkGetMacro(MaskLabelValue, int);
 
  static void ModeToRGB(double Mode, double FA,
                 double &R, double &G, double &B);
 
  static void RGBToIndex(double R, double G,
                  double B, double &index);
 
  static int FixNegativeEigenvaluesMethod(double w[3]);
  static double Determinant(double D[3][3]);
  static double Trace(double D[3][3]);
  static double Trace(double w[3]);
  static double RelativeAnisotropy(double w[3]);
  static double FractionalAnisotropy(double w[3]);
  static double LinearMeasure(double w[3]);
  static double PlanarMeasure(double w[3]);
  static double SphericalMeasure(double w[3]);
  static double MaxEigenvalue(double w[3]);
  static double MiddleEigenvalue(double w[3]);
  static double ParallelDiffusivity(double w[3]);
  static double PerpendicularDiffusivity(double w[3]);
  static double MeanDiffusivity(double w[3]);
  static double MinEigenvalue(double w[3]);
  static double RAIMaxEigenvecX(double **v, double w[3]);
  static double RAIMaxEigenvecY(double **v, double w[3]);
  static double RAIMaxEigenvecZ(double **v, double w[3]);
  static double MaxEigenvecX(double **v, double w[3]);
  static double MaxEigenvecY(double **v, double w[3]);
  static double MaxEigenvecZ(double **v, double w[3]);
  static double MaxEigenvalueProjectionX(double **v, double w[3]);
  static double MaxEigenvalueProjectionY(double **v, double w[3]);
  static double MaxEigenvalueProjectionZ(double **v, double w[3]);
  static double Mode(double w[3]);
  static void ColorByMode(double w[3], double &R,double &G, double &B);
 
  //Description
  //Wrap function to teem eigen solver
  static int TeemEigenSolver(double **m, double *w, double **v);
  void ComputeTensorIncrements(vtkImageData *imageData, vtkIdType incr[3]);
 
protected:
  vtkDiffusionTensorMathematics();
  ~vtkDiffusionTensorMathematics() override;
 
  int Operation; 
  double ScaleFactor; 
  int ExtractEigenvalues; 
 
  int MaskWithScalars;
  vtkImageData *ScalarMask;
  int MaskLabelValue;
 
  vtkMatrix4x4 *TensorRotationMatrix;
  int FixNegativeEigenvalues;
 
  int RequestInformation (vtkInformation*,
                                  vtkInformationVector**,
                                  vtkInformationVector*) override;
 
  void ThreadedRequestData(vtkInformation *request,
                                   vtkInformationVector **inputVector,
                                   vtkInformationVector *outputVector,
                                   vtkImageData ***inData,
                                   vtkImageData **outData,
                                   int extent[6], int threadId) override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  // Reimplemented to delete the tensor array of the output.
  int RequestData(vtkInformation* request,
                          vtkInformationVector** inputVector,
                          vtkInformationVector* outputVector) override;
private:
  vtkDiffusionTensorMathematics(const vtkDiffusionTensorMathematics&) = delete;
  void operator=(const vtkDiffusionTensorMathematics&) = delete;
};
 
#endif