igtlTrajectoryMessage.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   The OpenIGTLink Library
  Language:  C++
  Web page:  http://openigtlink.org/
 
  Copyright (c) Insight Software Consortium. All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
 
=========================================================================*/
 
#ifndef __igtlTrajectoryMessage_h
#define __igtlTrajectoryMessage_h
 
#include <vector>
#include <string>
 
#include "igtlObject.h"
#include "igtlMath.h"
#include "igtlMessageBase.h"
#include "igtlTypes.h"
 
#include "igtlImageMessage.h"
 
namespace igtl
{
 
class IGTLCommon_EXPORT TrajectoryElement: public Object
{
public:
  typedef TrajectoryElement              Self;
  typedef Object                         Superclass;
  typedef SmartPointer<Self>             Pointer;
  typedef SmartPointer<const Self>       ConstPointer;
 
  igtlTypeMacro(igtl::TrajectoryElement, igtl::Object);
  igtlNewMacro(igtl::TrajectoryElement);
 
  enum {
    TYPE_ENTRY_ONLY   = 1, /* Trajectory with only entry point */
    TYPE_TARGET_ONLY  = 2, /* Trajectory with only target point */
    TYPE_ENTRY_TARGET = 3, /* Trajectory with entry and target point */
  };
 
public:
 
  int           SetName(const char* name);
 
  const char*   GetName()                            { return this->m_Name.c_str(); };
 
  int           SetGroupName(const char* grpname);
 
  const char*   GetGroupName()                       { return this->m_GroupName.c_str(); };
 
  int           SetType(igtlUint8 type);
  igtlUint8     GetType()                            { return this->m_Type; };
 
  void          SetRGBA(igtlUint8 rgba[4]);
 
  void          SetRGBA(igtlUint8 r, igtlUint8 g, igtlUint8 b, igtlUint8 a);
 
  void          GetRGBA(igtlUint8* rgba);
 
  void          GetRGBA(igtlUint8& r, igtlUint8& g, igtlUint8& b, igtlUint8& a);
 
  void          SetEntryPosition(igtlFloat32 position[3]);
 
  void          SetEntryPosition(igtlFloat32 x, igtlFloat32 y, igtlFloat32 z);
 
  void          GetEntryPosition(igtlFloat32* position);
 
  void          GetEntryPosition(igtlFloat32& x, igtlFloat32& y, igtlFloat32& z);
 
  void          SetTargetPosition(igtlFloat32 position[3]);
 
  void          SetTargetPosition(igtlFloat32 x, igtlFloat32 y, igtlFloat32 z);
 
  void          GetTargetPosition(igtlFloat32* position);
 
  void          GetTargetPosition(igtlFloat32& x, igtlFloat32& y, igtlFloat32& z);
 
  void          SetRadius(igtlFloat32 radius)        { this->m_Radius = radius; };
 
  igtlFloat32   GetRadius()                          { return this->m_Radius; };
 
  int           SetOwner(const char* owner);
 
  const char*   GetOwner()                           { return this->m_Owner.c_str(); };
 
protected:
  TrajectoryElement();
  ~TrajectoryElement();
 
protected:
 
  std::string   m_Name;
 
  std::string   m_GroupName;
 
  igtlUint8     m_Type;
 
  igtlUint8     m_RGBA[4];
 
  igtlFloat32   m_EntryPosition[3];
 
  igtlFloat32   m_TargetPosition[3];
 
  igtlFloat32   m_Radius;
 
  std::string   m_Owner;
};
 
 
class IGTLCommon_EXPORT GetTrajectoryMessage: public MessageBase
{
public:
  typedef GetTrajectoryMessage            Self;
  typedef MessageBase                     Superclass;
  typedef SmartPointer<Self>              Pointer;
  typedef SmartPointer<const Self>        ConstPointer;
 
  igtlTypeMacro(igtl::GetTrajectoryMessage, igtl::MessageBase);
  igtlNewMacro(igtl::GetTrajectoryMessage);
 
protected:
  GetTrajectoryMessage() : MessageBase() { this->m_SendMessageType  = "GET_TRAJ"; };
  ~GetTrajectoryMessage() {};
protected:
  virtual int  CalculateContentBufferSize() { return 0; };
  virtual int  PackContent()        { AllocateBuffer(); return 1; };
  virtual int  UnpackContent()      { return 1; };
};
 
 
class IGTLCommon_EXPORT TrajectoryMessage: public MessageBase
{
public:
  typedef TrajectoryMessage               Self;
  typedef MessageBase                     Superclass;
  typedef SmartPointer<Self>              Pointer;
  typedef SmartPointer<const Self>        ConstPointer;
 
  igtlTypeMacro(igtl::TrajectoryMessage, igtl::MessageBase);
  igtlNewMacro(igtl::TrajectoryMessage);
 
public:
 
  int  AddTrajectoryElement(TrajectoryElement::Pointer& elem);
  
  igtlLegacyMacro(
  void ClearTrajectoryElement(TrajectoryElement::Pointer& elem));
  
  void ClearAllTrajectoryElements();
 
  int  GetNumberOfTrajectoryElement();
 
  void GetTrajectoryElement(int index, TrajectoryElement::Pointer& elem);
 
 
protected:
  TrajectoryMessage();
  ~TrajectoryMessage();
  
protected:
 
  virtual int  CalculateContentBufferSize();
  virtual int  PackContent();
  virtual int  UnpackContent();
  
  std::vector<TrajectoryElement::Pointer> m_TrajectoryList;
  
};
 
} // namespace igtl
 
#endif // _igtlTrajectoryMessage_h