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);
 
  vtkMRMLShaderPropertyNode* AddShaderPropertyFromFile (const char* filename);
 
  vtkMRMLScene* GetPresetsScene();
 
  void 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