vtkMRMLViewNode.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: vtkMRMLViewNode.h,v $
  Date:      $Date: 2006/03/19 17:12:28 $
  Version:   $Revision: 1.6 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLViewNode_h
#define __vtkMRMLViewNode_h
 
// VTK includes
#include "vtkMRMLAbstractViewNode.h"

class VTK_MRML_EXPORT vtkMRMLViewNode : public vtkMRMLAbstractViewNode
{
public:
  static vtkMRMLViewNode* New();
  vtkTypeMacro(vtkMRMLViewNode, vtkMRMLAbstractViewNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLViewNode);

  const char* GetNodeTagName() override;

  static double* defaultBackgroundColor();
  static double* defaultBackgroundColor2();

  static void GetDefaultBoxColor(double color[3]);

  vtkGetMacro(BoxVisible, int);
  vtkSetMacro(BoxVisible, int);

  vtkSetVector3Macro(BoxColor, double);
  vtkGetVector3Macro(BoxColor, double);

  vtkGetMacro(AxisLabelsVisible, int);
  vtkSetMacro(AxisLabelsVisible, int);

  vtkGetMacro(AxisLabelsCameraDependent, int);
  vtkSetMacro(AxisLabelsCameraDependent, int);

  vtkGetMacro(FiducialsVisible, int);
  vtkSetMacro(FiducialsVisible, int);
 
  vtkGetMacro(FiducialLabelsVisible, int);
  vtkSetMacro(FiducialLabelsVisible, int);

  vtkGetMacro(FieldOfView, double);
  vtkSetMacro(FieldOfView, double);

  vtkGetMacro(LetterSize, double);
  vtkSetMacro(LetterSize, double);

  vtkGetMacro(AnimationMode, int);
  vtkSetMacro(AnimationMode, int);
  static const char* GetAnimationModeAsString(int id);
  static int GetAnimationModeFromString(const char* name);
 
  vtkGetMacro(ViewAxisMode, int);
  vtkSetMacro(ViewAxisMode, int);
  static const char* GetViewAxisModeAsString(int id);
  static int GetViewAxisModeFromString(const char* name);

  vtkGetMacro(SpinDirection, int);
  vtkSetMacro(SpinDirection, int);
  static const char* GetSpinDirectionAsString(int id);
  static int GetSpinDirectionFromString(const char* name);

  vtkGetMacro(SpinDegrees, double);
  vtkSetMacro(SpinDegrees, double);
 
  vtkGetMacro(RotateDegrees, double);
  vtkSetMacro(RotateDegrees, double);

  vtkGetMacro(AnimationMs, int);
  vtkSetMacro(AnimationMs, int);

  vtkGetMacro(RockLength, int);
  vtkSetMacro(RockLength, int);

  vtkGetMacro(RockCount, int);
  vtkSetMacro(RockCount, int);

  vtkGetMacro(StereoType, int);
  vtkSetMacro(StereoType, int);
  static const char* GetStereoTypeAsString(int id);
  static int GetStereoTypeFromString(const char* name);

  vtkGetMacro(RenderMode, int);
  vtkSetMacro(RenderMode, int);
  static const char* GetRenderModeAsString(int id);
  static int GetRenderModeFromString(const char* name);

  vtkGetMacro(UseDepthPeeling, int);
  vtkSetMacro(UseDepthPeeling, int);

  vtkGetMacro(FPSVisible, int);
  vtkSetMacro(FPSVisible, int);

  vtkGetMacro(GPUMemorySize, int);
  vtkSetMacro(GPUMemorySize, int);

  vtkSetMacro(AutoReleaseGraphicsResources, bool);
  vtkGetMacro(AutoReleaseGraphicsResources, bool);
  vtkBooleanMacro(AutoReleaseGraphicsResources, bool);

  vtkSetMacro(ExpectedFPS, double);
  vtkGetMacro(ExpectedFPS, double);
 
  vtkSetMacro(VolumeRenderingQuality, int);
  vtkGetMacro(VolumeRenderingQuality, int);
  static const char* GetVolumeRenderingQualityAsString(int id);
  static int GetVolumeRenderingQualityFromString(const char* name);

  vtkGetMacro(RaycastTechnique, int);
  vtkSetMacro(RaycastTechnique, int);
  static const char* GetRaycastTechniqueAsString(int id);
  static int GetRaycastTechniqueFromString(const char* name);

  vtkGetMacro(VolumeRenderingSurfaceSmoothing, bool);
  vtkSetMacro(VolumeRenderingSurfaceSmoothing, bool);

  vtkSetMacro(VolumeRenderingOversamplingFactor, double);
  vtkGetMacro(VolumeRenderingOversamplingFactor, double);

  enum
  {
    RotateAround = 0,
    LookFrom,
    ViewAxisMode_Last
  };

  enum
  {
    PitchUp = 0,
    PitchDown,
    RollLeft,
    RollRight,
    YawLeft,
    YawRight,
    SpinDirection_Last
  };

  enum
  {
    NoStereo = 0,
    RedBlue,
    Anaglyph,
    QuadBuffer,
    Interlaced,
    UserDefined_1,
    UserDefined_2,
    UserDefined_3,
    StereoType_Last
  };

  enum
  {
    Perspective = 0,
    Orthographic,
    RenderMode_Last
  };

  enum
  {
    Off = 0,
    Spin,
    Rock,
    AnimationMode_Last
  };

  enum
  {
    Adaptive = 0, 
    Normal,       
    Maximum,      
    VolumeRenderingQuality_Last
  };

  enum
  {
    Composite = 0,         // Composite with directional lighting (default)
    CompositeEdgeColoring, // Composite with fake lighting (edge coloring, faster) - Not used
    MaximumIntensityProjection,
    MinimumIntensityProjection,
    GradiantMagnitudeOpacityModulation,       // Not used
    IllustrativeContextPreservingExploration, // Not used
    RaycastTechnique_Last
  };

  enum
  {
    GraphicalResourcesCreatedEvent = 19001,
    ResetFocalPointRequestedEvent,
  };

  void SetInteracting(int);
  vtkGetMacro(Interacting, int);
  vtkBooleanMacro(Interacting, int);

  enum InteractionFlagType
  {
    None = 0,
    AnimationModeFlag,
    RenderModeFlag,
    BoxVisibleFlag,
    BoxColorFlag,
    BoxLabelVisibleFlag,
    BoxLabelVisibileFlag = BoxLabelVisibleFlag, 
    BackgroundColorFlag,
    StereoTypeFlag,
    OrientationMarkerTypeFlag,
    OrientationMarkerSizeFlag,
    RulerTypeFlag,
    RulerColorFlag,
    UseDepthPeelingFlag,
    FPSVisibleFlag,
    ShadowsVisibilityFlag,
    AmbientShadowsSizeScaleFlag,
    AmbientShadowsVolumeOpacityThresholdFlag,
    AmbientShadowsIntensityScaleFlag,
    AmbientShadowsIntensityShiftFlag,
  };

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

  void SetInteractionFlags(unsigned int);
  vtkGetMacro(InteractionFlags, unsigned int);


  vtkGetMacro(ShadowsVisibility, bool);
  vtkSetMacro(ShadowsVisibility, bool);
  vtkBooleanMacro(ShadowsVisibility, bool);


  vtkGetMacro(AmbientShadowsSizeScale, double);
  vtkSetMacro(AmbientShadowsSizeScale, double);


  vtkGetMacro(AmbientShadowsVolumeOpacityThreshold, double);
  vtkSetMacro(AmbientShadowsVolumeOpacityThreshold, double);


  vtkGetMacro(AmbientShadowsIntensityScale, double);
  vtkSetMacro(AmbientShadowsIntensityScale, double);


  vtkGetMacro(AmbientShadowsIntensityShift, double);
  vtkSetMacro(AmbientShadowsIntensityShift, double);
 
protected:
  vtkMRMLViewNode();
  ~vtkMRMLViewNode() override;
  vtkMRMLViewNode(const vtkMRMLViewNode&);
  void operator=(const vtkMRMLViewNode&);
 
  int FiducialsVisible;
  int FiducialLabelsVisible;
  int BoxVisible;
  double BoxColor[3];
  int AxisLabelsVisible;
  int AxisLabelsCameraDependent;
  double FieldOfView;
  double LetterSize;

  int AnimationMode;
  int SpinDirection;
  double SpinDegrees;
  int AnimationMs;

  int RockLength;
  int RockCount;

  double RotateDegrees;

  int StereoType;

  int RenderMode;

  int ViewAxisMode;

  int UseDepthPeeling;

  int FPSVisible;

  int GPUMemorySize;

  bool AutoReleaseGraphicsResources;

  double ExpectedFPS;

  int VolumeRenderingQuality;

  int RaycastTechnique;

  bool VolumeRenderingSurfaceSmoothing;

  double VolumeRenderingOversamplingFactor;
 
  bool ShadowsVisibility{ false };
  double AmbientShadowsSizeScale{ 0.3 };
  double AmbientShadowsVolumeOpacityThreshold{ 0.25 };
  double AmbientShadowsIntensityScale{ 1.0 };
  double AmbientShadowsIntensityShift{ 0.0 };
 
  int LinkedControl;
  int Interacting;
  unsigned int InteractionFlags;
};
 
#endif