vtkMRMLDiffusionTensorDisplayPropertiesNode.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: ,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $
 
  =========================================================================auto=*/
 
#ifndef __vtkMRMLDiffusionTensorDisplayPropertiesNode_h
#define __vtkMRMLDiffusionTensorDisplayPropertiesNode_h
 
#include "vtkMRMLColorTableNode.h"
 
// VTK includes
class vtkPolyData;
class vtkAlgorithmOutput;

class VTK_MRML_EXPORT vtkMRMLDiffusionTensorDisplayPropertiesNode : public vtkMRMLColorTableNode
{
 public:
  static vtkMRMLDiffusionTensorDisplayPropertiesNode *New();
  vtkTypeMacro(vtkMRMLDiffusionTensorDisplayPropertiesNode,vtkMRMLColorTableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes( const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  void Copy(vtkMRMLNode *node) override;

  const char* GetNodeTagName() override {return "DiffusionTensorDisplayProperties";}
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  enum
  {
    Trace = 0,
    Determinant = 1,
    RelativeAnisotropy = 2,
    FractionalAnisotropy = 3,
    MaxEigenvalue = 4,
    MidEigenvalue = 5,
    MinEigenvalue = 6,
    LinearMeasure = 7,
    PlanarMeasure = 8,
    SphericalMeasure = 9,
    ColorOrientation = 10,
    D11 = 11,
    D22 = 12,
    D33 = 13,
    Mode = 14,
    ColorMode = 15,
    MaxEigenvalueProjX = 16,
    MaxEigenvalueProjY = 17,
    MaxEigenvalueProjZ = 18,
    MaxEigenvec_ProjX =  19,
    MaxEigenvec_ProjY =  20,
    MaxEigenvec_ProjZ =  21,
    ParallelDiffusivity =  22,
    PerpendicularDiffusivity =  23,
    ColorOrientationMiddleEigenvector = 24,
    ColorOrientationMinEigenvector = 25
  };
 
  static bool ScalarInvariantHasKnownScalarRange(int ScalarInvariant);
  static void ScalarInvariantKnownScalarRange(int ScalarInvariant, double range[2]);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(ScalarInvariant, int);

  vtkSetMacro(ScalarInvariant, int);

  void SetScalarInvariantToTrace() {
    this->SetScalarInvariant(this->Trace);
  };
  void SetScalarInvariantToTrace() {…}
 
  //Description:
  void SetScalarInvariantToRelativeAnisotropy() {
    this->SetScalarInvariant(this->RelativeAnisotropy);
  };
  void SetScalarInvariantToRelativeAnisotropy() {…}

  void SetScalarInvariantToFractionalAnisotropy() {
    this->SetScalarInvariant(this->FractionalAnisotropy);
  };
  void SetScalarInvariantToFractionalAnisotropy() {…}

  void SetScalarInvariantToLinearMeasure() {
    this->SetScalarInvariant(this->LinearMeasure);
  };
  void SetScalarInvariantToLinearMeasure() {…}

  void SetScalarInvariantToPlanarMeasure() {
    this->SetScalarInvariant(this->PlanarMeasure);
  };
  void SetScalarInvariantToPlanarMeasure() {…}

  void SetScalarInvariantToSphericalMeasure() {
    this->SetScalarInvariant(this->SphericalMeasure);
  }
  void SetScalarInvariantToSphericalMeasure() {…}


  virtual const char * GetScalarInvariantAsString();
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  enum
  {
    Lines = 0,
    Tubes = 1,
    Ellipsoids = 2,
    Superquadrics = 3
  };
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(GlyphGeometry, int);

  //vtkSetMacro(GlyphGeometry, int);
  void SetGlyphGeometry( int geometry ) {
    if ( this->GlyphGeometry != geometry )
    {
      this->GlyphGeometry = geometry;
      this->UpdateGlyphSource();
      this->Modified();
    }
  }
  void SetGlyphGeometry( int geometry ) {…}
 
  void SetGlyphGeometryToLines() {
    this->SetGlyphGeometry(this->Lines);
  };
  void SetGlyphGeometryToLines() {…}
  void SetGlyphGeometryToTubes() {
    this->SetGlyphGeometry(this->Tubes);
  };
  void SetGlyphGeometryToTubes() {…}
  void SetGlyphGeometryToEllipsoids() {
    this->SetGlyphGeometry(this->Ellipsoids);
  };
  void SetGlyphGeometryToEllipsoids() {…}
  void SetGlyphGeometryToSuperquadrics() {
    this->SetGlyphGeometry(this->Superquadrics);
  };
  void SetGlyphGeometryToSuperquadrics() {…}

  int GetFirstGlyphGeometry() {return this->Lines;};
  int GetLastGlyphGeometry() {return this->Ellipsoids;};

  virtual const char * GetGlyphGeometryAsString();
  virtual const char * GetGlyphGeometryAsString(int);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(GlyphScaleFactor, double);

  vtkSetMacro(GlyphScaleFactor, double);

  vtkGetMacro(GlyphExtractEigenvalues, int);
  vtkSetMacro(GlyphExtractEigenvalues, int);
  vtkBooleanMacro(GlyphExtractEigenvalues, int);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  enum
  {
    Major = 0,
    Middle = 1,
    Minor = 2
  };

  vtkGetMacro(GlyphEigenvector, int);

  //vtkSetMacro(GlyphEigenvector, int);
  //vtkSetMacro(GlyphGeometry, int);
  void SetGlyphEigenvector( int eigenvector ) {
    if ( this->GlyphEigenvector != eigenvector )
    {
      this->GlyphEigenvector = eigenvector;
      if ( this->GlyphGeometry == this->Lines || this->GlyphGeometry == this->Tubes)
      {
        this->UpdateGlyphSource();
      }
 
      this->Modified();
    }
  }
  void SetGlyphEigenvector( int eigenvector ) {…}

  void SetGlyphEigenvectorToMajor() {
    this->SetGlyphEigenvector(this->Major);
  };
  void SetGlyphEigenvectorToMajor() {…}

  void SetGlyphEigenvectorToMiddle() {
    this->SetGlyphEigenvector(this->Middle);
  };
  void SetGlyphEigenvectorToMiddle() {…}

  void SetGlyphEigenvectorToMinor() {
    this->SetGlyphEigenvector(this->Minor);
  };
  void SetGlyphEigenvectorToMinor() {…}

  int GetFirstGlyphEigenvector() {return this->Major;};
  int GetLastGlyphEigenvector() {return this->Minor;};

  virtual const char * GetGlyphEigenvectorAsString();
  virtual const char * GetGlyphEigenvectorAsString(int);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(LineGlyphResolution, int);
  //vtkSetMacro(LineGlyphResolution, int);
  void SetLineGlyphResolution( int resolution ) {
    if ( this->LineGlyphResolution != resolution )
    {
      this->LineGlyphResolution = resolution;
      if ( this->GlyphGeometry == this->Lines || this->GlyphGeometry == this->Tubes)
      {
        this->UpdateGlyphSource();
      }
 
      this->Modified();
    }
  }
  void SetLineGlyphResolution( int resolution ) {…}
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(TubeGlyphRadius, double);

  //vtkSetMacro(TubeGlyphRadius, double);
  void SetTubeGlyphRadius( double radius ) {
    if ( this->TubeGlyphRadius != radius )
    {
      this->TubeGlyphRadius = radius;
      if ( this->GlyphGeometry == this->Lines || this->GlyphGeometry == this->Tubes)
      {
        this->UpdateGlyphSource();
      }
 
      this->Modified();
    }
  }
  void SetTubeGlyphRadius( double radius ) {…}

  vtkGetMacro(TubeGlyphNumberOfSides, int);
  //vtkSetMacro(TubeGlyphNumberOfSides, int);
  void SetTubeGlyphNumberOfSides( int numberOfSides ) {
    if ( this->TubeGlyphNumberOfSides != numberOfSides )
    {
      this->TubeGlyphNumberOfSides = numberOfSides;
      if ( this->GlyphGeometry == this->Lines || this->GlyphGeometry == this->Tubes)
      {
        this->UpdateGlyphSource();
      }
 
      this->Modified();
    }
  }
  void SetTubeGlyphNumberOfSides( int numberOfSides ) {…}
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(EllipsoidGlyphThetaResolution, int);
  vtkSetMacro(EllipsoidGlyphThetaResolution, int);

  vtkGetMacro(EllipsoidGlyphPhiResolution, int);
  vtkSetMacro(EllipsoidGlyphPhiResolution, int);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(SuperquadricGlyphGamma, double);
  vtkSetMacro(SuperquadricGlyphGamma, double);

  vtkGetMacro(SuperquadricGlyphThetaResolution, int);
  vtkSetMacro(SuperquadricGlyphThetaResolution, int);

  vtkGetMacro(SuperquadricGlyphPhiResolution, int);
  vtkSetMacro(SuperquadricGlyphPhiResolution, int);
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetMacro(ColorGlyphBy, int);

  vtkSetMacro(ColorGlyphBy, int);

  static int GetFirstColorGlyphBy();
  static int GetLastColorGlyphBy();

  virtual const char * GetColorGlyphByAsString();

  void ColorGlyphByTrace() {
    this->SetColorGlyphBy(this->Trace);
  };
  void ColorGlyphByTrace() {…}

  void ColorGlyphByFractionalAnisotropy() {
    this->SetColorGlyphBy(this->FractionalAnisotropy);
  };
  void ColorGlyphByFractionalAnisotropy() {…}

  void ColorGlyphByLinearMeasure() {
    this->SetColorGlyphBy(this->LinearMeasure);
  };
  void ColorGlyphByLinearMeasure() {…}

 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  vtkGetObjectMacro( GlyphConnection, vtkAlgorithmOutput );
 
 //Helper function to get the string of Scalar enums
  static const char *GetScalarEnumAsString(int val);
  static int GetFirstScalarInvariant();
  static int GetLastScalarInvariant();

  vtkMRMLStorageNode* CreateDefaultStorageNode() override {
    return nullptr;
  }
  vtkMRMLStorageNode* CreateDefaultStorageNode() override  {…}
 
 protected:
  vtkMRMLDiffusionTensorDisplayPropertiesNode();
  ~vtkMRMLDiffusionTensorDisplayPropertiesNode() override;
  vtkMRMLDiffusionTensorDisplayPropertiesNode(const vtkMRMLDiffusionTensorDisplayPropertiesNode&);
  void operator=(const vtkMRMLDiffusionTensorDisplayPropertiesNode&);
 
  void UpdateGlyphSource ( );


  int ScalarInvariant;

  int GlyphGeometry;
  int ColorGlyphBy;
  double GlyphScaleFactor;
  int GlyphEigenvector;
  int GlyphExtractEigenvalues;

  int LineGlyphResolution;

  double TubeGlyphRadius;
  int TubeGlyphNumberOfSides;

  int EllipsoidGlyphThetaResolution;
  int EllipsoidGlyphPhiResolution;

  double SuperquadricGlyphGamma;
  int SuperquadricGlyphThetaResolution;
  int SuperquadricGlyphPhiResolution;


  virtual void SetGlyphConnection(vtkAlgorithmOutput* glyphPort);
  vtkAlgorithmOutput * GlyphConnection;


};
class VTK_MRML_EXPORT vtkMRMLDiffusionTensorDisplayPropertiesNode : public vtkMRMLColorTableNode {…};
 
#endif