vtkMRMLCameraNode.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: vtkMRMLCameraNode.h,v $
  Date:      $Date: 2006/03/19 17:12:28 $
  Version:   $Revision: 1.6 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLCameraNode_h
#define __vtkMRMLCameraNode_h
 
// MRML includes
#include "vtkMRMLTransformableNode.h"
 
// VTK includes
class vtkCamera;
class vtkMatrix4x4;
class vtkRenderer;
 
class VTK_MRML_EXPORT vtkMRMLCameraNode : public vtkMRMLTransformableNode
{
public:
  static vtkMRMLCameraNode *New();
  vtkTypeMacro(vtkMRMLCameraNode,vtkMRMLTransformableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;
 
  void ReadXMLAttributes( const char** atts) override;
 
  void WriteXML(ostream& of, int indent) override;
 
 
  void Copy(vtkMRMLNode* node) override;
 
  vtkMRMLCopyContentMacro(vtkMRMLCameraNode);
 
  const char* GetNodeTagName() override {return "Camera";};
 
  const char* GetActiveTag();
  virtual void SetActiveTag(const char *);
 
  void SetLayoutName(const char* layoutName);
  char* GetLayoutName();
 
  vtkGetObjectMacro(Camera, vtkCamera);
 
  void SetParallelProjection(int parallelProjection);
 
  int GetParallelProjection();
 
  void SetParallelScale(double scale);
 
  double GetParallelScale();
 
  void SetViewAngle(double viewAngle);
 
  double GetViewAngle();
 
  void SetPosition(double position[3]);
  inline void SetPosition(double x, double y, double z);
 
  double* GetPosition() VTK_SIZEHINT(3);
  void GetPosition(double position[3]);
 
  void SetFocalPoint(double focalPoint[3]);
  inline void SetFocalPoint(double x, double y, double z);
 
  double* GetFocalPoint() VTK_SIZEHINT(3);
  void GetFocalPoint(double focalPoint[3]);
 
  void SetViewUp(double viewUp[3]);
  inline void SetViewUp(double vx, double vy, double vz);
 
  double* GetViewUp() VTK_SIZEHINT(3);
  void GetViewUp(double viewUp[3]);
 
  void ProcessMRMLEvents ( vtkObject * /*caller*/,
                                   unsigned long /*event*/,
                                   void * /*callData*/ ) override;
 
  vtkGetObjectMacro(AppliedTransform, vtkMatrix4x4);
  virtual void SetAppliedTransform(vtkMatrix4x4* appliedTransform);
 
  enum
  {
    LayoutNameModifiedEvent = 30000,
    ActiveTagModifiedEvent = LayoutNameModifiedEvent, // deprecated, kept for backward compatibility only
    CameraInteractionEvent = 31000,
    ResetCameraClippingEvent = 32000,
  };
 
  void ResetClippingRange();
 
  enum Direction{
    Right = 0,
    Left = 1,
    Anterior = 2,
    Posterior = 3,
    Superior = 4,
    Inferior = 5
  };
 
  enum RASAxis{
    R = 0,
    A = 1,
    S = 2,
  };
 
  enum ScreenAxis{
    X = 0, // left
    Y = 1, // up
    Z = 2  // forward
  };
 
  void RotateTo(Direction position);
 
  void RotateAround(RASAxis axis, bool clockWise);
 
  void RotateAround(RASAxis axis, double angle = 15.);
 
  void TranslateAlong(ScreenAxis axis, bool positive);
 
  using vtkMRMLNode::Reset;
  void Reset(bool resetRotation,
             bool resetTranslation = true,
             bool resetDistance = true,
             vtkRenderer* renderer = nullptr);
 
  void SetInteracting(int);
  vtkGetMacro(Interacting, int);
  vtkBooleanMacro(Interacting, int);
 
  enum InteractionFlagType
  {
    None = 0,
    LookFromAxis,
    ZoomInFlag,
    ZoomOutFlag,
    CenterFlag,
    CameraInteractionFlag,
  };
 
  void SetInteractionFlags(unsigned int);
  vtkGetMacro(InteractionFlags, unsigned int);
 
protected:
  vtkMRMLCameraNode();
  ~vtkMRMLCameraNode() override;
  vtkMRMLCameraNode(const vtkMRMLCameraNode&);
  void operator=(const vtkMRMLCameraNode&);
 
 
  void SetCamera(vtkCamera* camera);
  void SetAndObserveCamera(vtkCamera* camera);
  vtkCamera* Camera{nullptr};
 
  std::string InternalActiveTag; // variable to hold returned value of GetActiveTag
 
  vtkMatrix4x4* AppliedTransform;
 
  int Interacting;
  unsigned int InteractionFlags;
};
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetPosition(double x, double y, double z)
{
  double pos[3] = {x, y, z};
  this->SetPosition(pos);
}
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetFocalPoint(double x, double y, double z)
{
  double pos[3] = {x, y, z};
  this->SetFocalPoint(pos);
}
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetViewUp(double vx, double vy, double vz)
{
  double viewUp[3] = {vx, vy, vz};
  this->SetViewUp(viewUp);
}
 
#endif