vtkMRMLScalarVolumeDisplayNode.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: vtkMRMLScalarVolumeDisplayNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $

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

#ifndef __vtkMRMLScalarVolumeDisplayNode_h
#define __vtkMRMLScalarVolumeDisplayNode_h

// MRML includes
#include "vtkMRMLVolumeDisplayNode.h"

// VTK includes
class vtkImageAlgorithm;
class vtkImageAccumulate;
class vtkImageAppendComponents;
class vtkImageBimodalAnalysis;
class vtkImageCast;
class vtkImageLogic;
class vtkImageMapToColors;
class vtkImageMapToWindowLevelColors;
class vtkImageStencil;
class vtkImageThreshold;
class vtkImageExtractComponents;
class vtkImageMathematics;

// STD includes
#include <vector>

class VTK_MRML_EXPORT vtkMRMLScalarVolumeDisplayNode : public vtkMRMLVolumeDisplayNode
{
  public:
  static vtkMRMLScalarVolumeDisplayNode *New();
  vtkTypeMacro(vtkMRMLScalarVolumeDisplayNode,vtkMRMLVolumeDisplayNode);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;

  virtual void ReadXMLAttributes( const char** atts) VTK_OVERRIDE;

  virtual void WriteXML(ostream& of, int indent) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  virtual const char* GetNodeTagName() VTK_OVERRIDE {return "VolumeDisplay";}


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

  vtkGetMacro(WindowLevelLocked, bool);
  vtkSetMacro(WindowLevelLocked, bool);

  vtkBooleanMacro(AutoWindowLevel, int);
  vtkGetMacro(AutoWindowLevel, int);
  vtkSetMacro(AutoWindowLevel, int);

  double GetWindow();
  virtual void SetWindow(double);

  double GetLevel();
  virtual void SetLevel(double);

  virtual void SetWindowLevel(double window, double level);
  void SetWindowLevelMinMax(double min, double max);

  double GetWindowLevelMin();
  double GetWindowLevelMax();

  vtkBooleanMacro(ApplyThreshold, int);
  vtkGetMacro(ApplyThreshold, int);
  virtual void SetApplyThreshold(int);

  vtkBooleanMacro(AutoThreshold, int);
  vtkGetMacro(AutoThreshold, int);
  vtkSetMacro(AutoThreshold, int);

  virtual double GetLowerThreshold();
  virtual void SetLowerThreshold(double lower);

  virtual double GetUpperThreshold();
  virtual void SetUpperThreshold(double upper);

  virtual void SetThreshold(double lower, double upper);

  vtkGetMacro(Interpolate, int);
  vtkSetMacro(Interpolate, int);
  vtkBooleanMacro(Interpolate, int);

  virtual void SetDefaultColorMap() VTK_OVERRIDE;

  virtual void ProcessMRMLEvents ( vtkObject * /*caller*/,
                                   unsigned long /*event*/,
                                   void * /*callData*/ ) VTK_OVERRIDE;

  virtual void SetInputImageDataConnection(vtkAlgorithmOutput *imageDataConnection) VTK_OVERRIDE;

  virtual vtkAlgorithmOutput* GetInputImageDataConnection() VTK_OVERRIDE;

  virtual vtkAlgorithmOutput* GetOutputImageDataConnection() VTK_OVERRIDE;

  virtual void SetBackgroundImageStencilDataConnection(vtkAlgorithmOutput *imageDataConnection) VTK_OVERRIDE;
  virtual vtkAlgorithmOutput* GetBackgroundImageStencilDataConnection() VTK_OVERRIDE;

  void AddWindowLevelPresetFromString(const char *preset);
  void AddWindowLevelPreset(double window, double level);

  void ResetWindowLevelPresets();

  void SetWindowLevelFromPreset(int p);

  int GetNumberOfWindowLevelPresets();

  double GetWindowPreset(int p);
  double GetLevelPreset(int p);

  virtual void GetDisplayScalarRange(double range[2]);

protected:
  vtkMRMLScalarVolumeDisplayNode();
  virtual ~vtkMRMLScalarVolumeDisplayNode();
  vtkMRMLScalarVolumeDisplayNode(const vtkMRMLScalarVolumeDisplayNode&);
  void operator=(const vtkMRMLScalarVolumeDisplayNode&);

  virtual void SetColorNodeInternal(vtkMRMLColorNode* newColorNode) VTK_OVERRIDE;
  void UpdateLookupTable(vtkMRMLColorNode* newColorNode);
  void CalculateAutoLevels();

  vtkImageData* GetScalarImageData();
  virtual vtkAlgorithmOutput* GetScalarImageDataConnection();

  virtual void SetInputToImageDataPipeline(vtkAlgorithmOutput *imageDataConnection) VTK_OVERRIDE;

  class WindowLevelPreset
  {
  public:
    double Window;
    double Level;
    WindowLevelPreset() { this->Window = 0.0; this->Level = 0.0; };
  };
  //double Window;
  //double Level;
  //double UpperThreshold;
  //double LowerThreshold;


  int Interpolate;
  bool WindowLevelLocked;
  int AutoWindowLevel;
  int ApplyThreshold;
  int AutoThreshold;

  vtkImageLogic *AlphaLogic;
  vtkImageMapToColors *MapToColors;
  vtkImageThreshold *Threshold;
  vtkImageAppendComponents *AppendComponents;
  vtkImageMapToWindowLevelColors *MapToWindowLevelColors;
  vtkImageExtractComponents *ExtractRGB;
  vtkImageExtractComponents *ExtractAlpha;
  vtkImageStencil *MultiplyAlpha;

  std::vector<WindowLevelPreset> WindowLevelPresets;

  vtkImageAccumulate *Accumulate;
  vtkImageBimodalAnalysis *Bimodal;
  bool IsInCalculateAutoLevels;
};

#endif