vtkSlicerVolumeRenderingLogic.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: vtkSlicerVolumeRenderingLogic.h,v $
  Date:      $Date: 2006/01/08 04:48:05 $
  Version:   $Revision: 1.45 $
 
=========================================================================auto=*/
 
#ifndef __vtkSlicerVolumeRenderingLogic_h
#define __vtkSlicerVolumeRenderingLogic_h
 
// VolumeRendering includes
#include "vtkSlicerVolumeRenderingModuleLogicExport.h"
class vtkMRMLVolumeRenderingDisplayNode;
 
// Slicer includes
#include "vtkSlicerModuleLogic.h"
 
// MRML includes
class vtkMRMLDisplayableNode;
class vtkMRMLLabelMapVolumeDisplayNode;
class vtkMRMLNode;
class vtkMRMLScalarVolumeDisplayNode;
class vtkMRMLScalarVolumeNode;
class vtkMRMLShaderPropertyNode;
class vtkMRMLViewNode;
class vtkMRMLVolumeDisplayNode;
class vtkMRMLVolumeNode;
class vtkMRMLVolumePropertyNode;
 
// VTK includes
class vtkColorTransferFunction;
class vtkPiecewiseFunction;
class vtkScalarsToColors;
class vtkVolumeProperty;
 
// STD includes
#include <map>
#include <vector>

class VTK_SLICER_VOLUMERENDERING_MODULE_LOGIC_EXPORT vtkSlicerVolumeRenderingLogic : public vtkSlicerModuleLogic
{
public:
  static vtkSlicerVolumeRenderingLogic* New();
  vtkTypeMacro(vtkSlicerVolumeRenderingLogic, vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void RegisterRenderingMethod(const char* methodName, const char* displayNodeClassName);
  std::map<std::string, std::string> GetRenderingMethods();
  vtkSetStringMacro(DefaultRenderingMethod);
  vtkGetStringMacro(DefaultRenderingMethod);

  vtkSetMacro(UseLinearRamp, bool);
  vtkGetMacro(UseLinearRamp, bool);

  vtkMRMLVolumeRenderingDisplayNode* CreateDefaultVolumeRenderingNodes(vtkMRMLVolumeNode* volumeNode);

  vtkMRMLVolumeRenderingDisplayNode* CreateVolumeRenderingDisplayNode(const char* renderingClassName = nullptr);

  void AddVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* node);

  void RemoveVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* node);

  void AddAllVolumeRenderingDisplayNodes();

  void RemoveAllVolumeRenderingDisplayNodes();

  void ChangeVolumeRenderingMethod(const char* displayNodeClassName = nullptr);

  bool SetRecommendedVolumeRenderingProperties(vtkMRMLVolumeRenderingDisplayNode* vrDisplayNode);

  void CopyDisplayToVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* node, vtkMRMLVolumeDisplayNode* displayNode = nullptr);

  void CopyScalarDisplayToVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* volumeRenderingDisplayNode, vtkMRMLScalarVolumeDisplayNode* scalarDisplayNode = nullptr);

  void CopyLabelMapDisplayToVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* volumeRenderingDisplayNode,
                                                       vtkMRMLLabelMapVolumeDisplayNode* labelMapDisplayNode = nullptr);

  void SetThresholdToVolumeProp(double scalarRange[2], double threshold[2], vtkVolumeProperty* node, bool linearRamp = false, bool stayUpAtUpperLimit = false);

  void SetWindowLevelToVolumeProp(double scalarRange[2], double windowLevel[2], vtkScalarsToColors* lut, vtkVolumeProperty* node);

  void SetGradientOpacityToVolumeProp(double scalarRange[2], vtkVolumeProperty* node);

  void SetLabelMapToVolumeProp(vtkScalarsToColors* colors, vtkVolumeProperty* node);

  void UpdateDisplayNodeFromVolumeNode(vtkMRMLVolumeRenderingDisplayNode* displayNode,
                                       vtkMRMLVolumeNode* volumeNode,
                                       vtkMRMLVolumePropertyNode* propNode = nullptr,
                                       vtkMRMLNode* roiNode = nullptr,
                                       bool createROI = true);

  vtkMRMLDisplayableNode* CreateROINode(vtkMRMLVolumeRenderingDisplayNode* displayNode);

  void RemoveViewFromVolumeDisplayNodes(vtkMRMLVolumeNode* volumeNode, vtkMRMLViewNode* viewNode);

  vtkMRMLVolumeRenderingDisplayNode* GetVolumeRenderingDisplayNodeByID(vtkMRMLVolumeNode* volumeNode, char* displayNodeID);

  vtkMRMLVolumeRenderingDisplayNode* GetVolumeRenderingDisplayNodeForViewNode(vtkMRMLVolumeNode* volumeNode, vtkMRMLViewNode* viewNode);

  vtkMRMLVolumeRenderingDisplayNode* GetVolumeRenderingDisplayNodeForViewNode(vtkMRMLViewNode* viewNode);

  vtkMRMLVolumeRenderingDisplayNode* GetFirstVolumeRenderingDisplayNode(vtkMRMLVolumeNode* volumeNode);

  vtkMRMLVolumeRenderingDisplayNode* GetFirstVolumeRenderingDisplayNodeByROINode(vtkMRMLNode* roiNode);
 
  void UpdateTranferFunctionRangeFromImage(vtkMRMLVolumeRenderingDisplayNode* vspNode);

  void FitROIToVolume(vtkMRMLVolumeRenderingDisplayNode* vspNode);

  vtkMRMLVolumePropertyNode* AddVolumePropertyFromFile(const char* filename);

  bool AddVolumePropertiesFromFile(const char* filename, vtkCollection* loadedNodes = nullptr);

  vtkMRMLShaderPropertyNode* AddShaderPropertyFromFile(const char* filename);

  vtkMRMLScene* GetPresetsScene();

  vtkMRMLVolumePropertyNode* AddPreset(vtkMRMLVolumePropertyNode* preset, vtkImageData* icon = nullptr, bool appendToEnd = false);

  void RemovePreset(vtkMRMLVolumePropertyNode* preset);

  int LoadCustomPresetsScene(const char* sceneFilePath);

  static const char* GetIconVolumeReferenceRole() { return "IconVolume"; };

  vtkMRMLVolumePropertyNode* GetPresetByName(const char* presetName);

  bool IsDifferentFunction(vtkPiecewiseFunction* function1, vtkPiecewiseFunction* function2) const;

  bool IsDifferentFunction(vtkColorTransferFunction* function1, vtkColorTransferFunction* function2) const;
 
  vtkSetMacro(DefaultROIClassName, std::string);
  vtkGetMacro(DefaultROIClassName, std::string);
 
protected:
  vtkSlicerVolumeRenderingLogic();
  ~vtkSlicerVolumeRenderingLogic() override;
 
  void SetMRMLSceneInternal(vtkMRMLScene* scene) override;
  // Register local MRML nodes
  void RegisterNodes() override;

  void ObserveMRMLScene() override;
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;
  void OnMRMLNodeModified(vtkMRMLNode* node) override;
 
  // Update from
  void UpdateVolumeRenderingDisplayNode(vtkMRMLVolumeRenderingDisplayNode* node);
 
  std::map<std::string, std::string> RenderingMethods;
  char* DefaultRenderingMethod;
 
  bool UseLinearRamp;
 
  typedef std::vector<vtkMRMLNode*> DisplayNodesType;
  DisplayNodesType DisplayNodes;
 
  bool LoadPresets(vtkMRMLScene* scene);
  vtkMRMLScene* PresetsScene;
 
  std::string DefaultROIClassName;
 
private:
  vtkSlicerVolumeRenderingLogic(const vtkSlicerVolumeRenderingLogic&) = delete;
  void operator=(const vtkSlicerVolumeRenderingLogic&) = delete;
};
 
#endif