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 vtkImageAppendComponents;
class vtkImageHistogramStatistics;
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) override;
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes( const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLScalarVolumeDisplayNode);

  const char* GetNodeTagName() override {return "VolumeDisplay";}
 
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  bool GetWindowLevelLocked()
  {
    vtkWarningMacro("vtkMRMLScalarVolumeDisplayNode::GetWindowLevelLocked method is deprecated. To check if the mouse mode cannot change window/level, get info from the interaction node. "
                    "e.g. slicer.app.applicationLogic().GetInteractionNode().GetCurrentInteractionMode() == slicer.vtkMRMLInteractionNode.AdjustWindowLevel");
    return false;
  };
  bool GetWindowLevelLocked() {…}

  virtual void SetWindowLevelLocked(bool)
  {
    vtkWarningMacro("vtkMRMLScalarVolumeDisplayNode::SetWindowLevelLocked method is deprecated. To prevent the mouse from changing window/level, set the interaction node to something other than AdjustWindowLevel. "
                    "e.g. slicer.app.applicationLogic().GetInteractionNode().SetCurrentInteractionMode(slicer.vtkMRMLInteractionNode.ViewTransform)");
  };
  virtual void SetWindowLevelLocked(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);
 
  void SetDefaultColorMap() override;

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

  void SetInputImageDataConnection(vtkAlgorithmOutput *imageDataConnection) override;

  vtkAlgorithmOutput* GetInputImageDataConnection() override;

  vtkAlgorithmOutput* GetOutputImageDataConnection() override;

  void SetBackgroundImageStencilDataConnection(vtkAlgorithmOutput *imageDataConnection) override;
  vtkAlgorithmOutput* GetBackgroundImageStencilDataConnection() 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();
  ~vtkMRMLScalarVolumeDisplayNode() override;
  vtkMRMLScalarVolumeDisplayNode(const vtkMRMLScalarVolumeDisplayNode&);
  void operator=(const vtkMRMLScalarVolumeDisplayNode&);
 
  void SetColorNodeInternal(vtkMRMLColorNode* newColorNode) override;
  void UpdateLookupTable(vtkMRMLColorNode* newColorNode);
  void CalculateAutoLevels();

  vtkImageData* GetScalarImageData();
  virtual vtkAlgorithmOutput* GetScalarImageDataConnection();
 
  void SetInputToImageDataPipeline(vtkAlgorithmOutput *imageDataConnection) override;

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

  int Interpolate;
  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;

  vtkImageHistogramStatistics *HistogramStatistics;
  bool IsInCalculateAutoLevels;
};
class VTK_MRML_EXPORT vtkMRMLScalarVolumeDisplayNode : public vtkMRMLVolumeDisplayNode {…};
 
#endif