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 Direction {…};
 
  enum RASAxis{
    R = 0,
    A = 1,
    S = 2,
  };
  enum RASAxis {…};
 
  enum ScreenAxis{
    X = 0, // left
    Y = 1, // up
    Z = 2  // forward
  };
  enum ScreenAxis {…};

  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,
  };
  enum InteractionFlagType {…};

  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;
};
class VTK_MRML_EXPORT vtkMRMLCameraNode : public vtkMRMLTransformableNode {…};
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetPosition(double x, double y, double z)
{
  double pos[3] = {x, y, z};
  this->SetPosition(pos);
}
void vtkMRMLCameraNode::SetPosition(double x, double y, double z) {…}
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetFocalPoint(double x, double y, double z)
{
  double pos[3] = {x, y, z};
  this->SetFocalPoint(pos);
}
void vtkMRMLCameraNode::SetFocalPoint(double x, double y, double z) {…}
 
//---------------------------------------------------------------------------
void vtkMRMLCameraNode::SetViewUp(double vx, double vy, double vz)
{
  double viewUp[3] = {vx, vy, vz};
  this->SetViewUp(viewUp);
}
void vtkMRMLCameraNode::SetViewUp(double vx, double vy, double vz) {…}
 
#endif