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"
#include "vtkImageMapToWindowLevelAddon.h"
 
// VTK includes
class vtkImageAlgorithm;
class vtkImageAppendComponents;
class vtkImageHistogramStatistics;
class vtkImageCast;
class vtkImageLogic;
class vtkImageMapToColors;
class vtkImageStencil;
class vtkImageThreshold;
class vtkImageExtractComponents;
class vtkImageMathematics;
class vtkScalarsToColors;
 
// 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;
  };

  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)");
  };

  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);

  vtkGetMacro(InvertDisplayScalarRange, int);
  virtual void SetInvertDisplayScalarRange(int invert);
  vtkBooleanMacro(InvertDisplayScalarRange, int);

  vtkGetMacro(WindowMappingMethod, int);
  virtual void SetWindowMappingMethod(int method);

  static int GetWindowMappingMethodFromString(const char* name);
  static const char* GetWindowMappingMethodAsString(int type);
  static vtkImageMapToWindowLevelAddon::WindowMappingMode GetWindowMappingMethodFromIndex(int idx);
 
  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;

  static bool GetWindowLevelFromPresetString(const char* preset, double& window, double& level);
  static std::string GetWindowLevelAsPresetString(double window, double level);
  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]);

  virtual vtkScalarsToColors* GetLookupTable();
 
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(double window, double level)
      : Window(window)
      , Level(level)
    {
    }
  };
  // double Window;
  // double Level;
  // double UpperThreshold;
  // double LowerThreshold;

  void SetWindowLevelPresets(const std::vector<WindowLevelPreset>& windowLevelPresets);

  int Interpolate;
  int AutoWindowLevel;
  int ApplyThreshold;
  int AutoThreshold;
  int InvertDisplayScalarRange;
  int WindowMappingMethod;
 
  vtkImageLogic* AlphaLogic;
  vtkImageMapToColors* MapToColors;
  vtkImageThreshold* Threshold;
  vtkImageAppendComponents* AppendComponents;
  vtkImageMapToWindowLevelAddon* MapToWindowLevelColors;
  vtkImageExtractComponents* ExtractRGB;
  vtkImageExtractComponents* ExtractAlpha;
  vtkImageStencil* MultiplyAlpha;

  std::vector<WindowLevelPreset> WindowLevelPresets;

  vtkImageHistogramStatistics* HistogramStatistics;
  bool IsInCalculateAutoLevels;
};
 
#endif