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