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,
    BoxLabelVisibileFlag,
    BackgroundColorFlag,
    StereoTypeFlag,
    OrientationMarkerTypeFlag,
    OrientationMarkerSizeFlag,
    RulerTypeFlag,
    RulerColorFlag,
    UseDepthPeelingFlag,
    FPSVisibleFlag,
  };
 
  vtkGetMacro (LinkedControl, int );
  vtkSetMacro (LinkedControl, int );
  vtkBooleanMacro(LinkedControl, int);
 
  void SetInteractionFlags(unsigned int);
  vtkGetMacro(InteractionFlags, unsigned int);
 
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;
 
  int LinkedControl;
  int Interacting;
  unsigned int InteractionFlags;
 
};
 
#endif