igtlImageMessage2.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 __igtlImageMessage2_h
#define __igtlImageMessage2_h
 
#include "igtlObject.h"
//#include "igtlMacros.h"
#include "igtlMacro.h"
#include "igtlMath.h"
#include "igtlMessageBase.h"
 
 
#define  FRAGMENTED_PACK 
 
 
namespace igtl
{
 
 
class IGTLCommon_EXPORT GetImageMessage2: public MessageBase
{
public:
  typedef GetImageMessage2                Self;
  typedef MessageBase                    Superclass;
  typedef SmartPointer<Self>             Pointer;
  typedef SmartPointer<const Self>       ConstPointer;
 
  igtlTypeMacro(igtl::GetImageMessage2, igtl::MessageBase);
  igtlNewMacro(igtl::GetImageMessage2);
 
protected:
  GetImageMessage2() : MessageBase() { this->m_SendMessageType  = "GET_IMAGE"; };
  ~GetImageMessage2() {};
protected:
  virtual int  CalculateContentBufferSize() { return 0; };
  virtual int  PackContent()        { AllocateBuffer(); return 1; };
  virtual int  UnpackContent()      { return 1; };
};
 
 
class IGTLCommon_EXPORT ImageMessage2: public MessageBase
{
public:
  typedef ImageMessage2              Self;
  typedef MessageBase               Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
 
  igtlTypeMacro(igtl::ImageMessage2, igtl::MessageBase)
  igtlNewMacro(igtl::ImageMessage2);
 
public:
 
  enum {
    COORDINATE_RAS=1,
    COORDINATE_LPS=2
  };
 
  enum {
    ENDIAN_BIG=1,
    ENDIAN_LITTLE=2
  };
 
  enum {
    DTYPE_SCALAR = 1,
    DTYPE_VECTOR = 3
  };
 
  enum {
    TYPE_INT8    = 2,
    TYPE_UINT8   = 3,
    TYPE_INT16   = 4,
    TYPE_UINT16  = 5,
    TYPE_INT32   = 6,
    TYPE_UINT32  = 7,
    TYPE_FLOAT32 = 10,
    TYPE_FLOAT64 = 11
  };
 
 
public:
 
  void SetDimensions(int s[3]);
 
  void SetDimensions(int i, int j, int k);
 
  void GetDimensions(int s[3]);
 
  void GetDimensions(int &i, int &j, int &k);
 
  int  SetSubVolume(int dim[3], int off[3]);
 
  int  SetSubVolume(int dimi, int dimj, int dimk, int offi, int offj, int offk);
 
  void GetSubVolume(int dim[3], int off[3]);
 
  void GetSubVolume(int &dimi, int &dimj, int &dimk, int &offi, int &offj, int &offk);
 
  void SetSpacing(float s[3]);
 
  void SetSpacing(float si, float sj, float sk);
 
  void GetSpacing(float s[3]);
 
  void GetSpacing(float &si, float &sj, float &sk);
 
  void SetOrigin(float p[3]);
 
  void SetOrigin(float px, float py, float pz);
 
  void GetOrigin(float p[3]);
 
  void GetOrigin(float &px, float &py, float &pz);
 
  void SetNormals(float o[3][3]);
 
  void SetNormals(float t[3], float s[3], float n[3]);
 
  void GetNormals(float o[3][3]);
 
  void GetNormals(float t[3], float s[3], float n[3]);
 
  void SetNumComponents(int num);
 
  int  GetNumComponents();
 
  void SetMatrix(Matrix4x4& mat);
 
  void GetMatrix(Matrix4x4& mat);
 
  void SetScalarType(int t)    { scalarType = t; };
 
  void SetScalarTypeToInt8()   { scalarType = TYPE_INT8; };
 
  void SetScalarTypeToUint8()  { scalarType = TYPE_UINT8; };
 
  void SetScalarTypeToInt16()  { scalarType = TYPE_INT16; };
 
  void SetScalarTypeToUint16() { scalarType = TYPE_UINT16; };
 
  void SetScalarTypeToInt32()  { scalarType = TYPE_INT32; };
 
  void SetScalarTypeToUint32() { scalarType = TYPE_UINT32; };
 
  int  GetScalarType()         { return scalarType; };
 
  int  GetScalarSize()         { return ScalarSizeTable[scalarType]; };
 
  int  GetScalarSize(int type) { return ScalarSizeTable[type]; };
 
  void SetEndian(int e)        { endian = e; };
 
  int  GetEndian()             { return endian; };
 
  // TODO: Should returned value be 64-bit integer?
  int  GetImageSize()
  {
    return dimensions[0]*dimensions[1]*dimensions[2]*GetScalarSize()*numComponents;
  };
 
  int GetCoordinateSystem() { return coordinate;};
 
  void SetCoordinateSystem(int c) {coordinate = c;};
 
  int  GetSubVolumeImageSize()
  {
    return subDimensions[0]*subDimensions[1]*subDimensions[2]*GetScalarSize()*numComponents;
  };
 
 
  virtual void  AllocateScalars();
 
  virtual void* GetScalarPointer();
 
#ifdef  FRAGMENTED_PACK 
  virtual void  SetScalarPointer(void * p);
 
  void* GetBufferPointer();
 
  int   GetNumberOfPackFragments() { return 3;  /* header, image header and image body */ }
 
  void* GetPackFragmentPointer(int id);
 
  int   GetPackFragmentSize(int id);
#endif // FRAGMENTED_PACK 
 
 
protected:
  ImageMessage2();
  ~ImageMessage2();
  
protected:
 
  virtual int  CalculateContentBufferSize();
 
#ifdef FRAGMENTED_PACK  
public:  
  virtual int   Pack();
public:
#endif //FRAGMENTED_PACK  
 
  virtual int  PackContent();
  virtual int  UnpackContent();
 
#ifdef FRAGMENTED_PACK  
  virtual void AllocateBuffer(int contentSize);
#endif //FRAGMENTED_PACK  
 
  int    dimensions[3];
 
  float  spacing[3];
 
  int    subDimensions[3];
 
  int    subOffset[3];
 
  Matrix4x4 matrix;
 
  int    endian;
 
  int    numComponents;
 
  int    scalarType;
 
  int    coordinate;
 
  unsigned char*  m_ImageHeader;
 
  unsigned char*  m_Image;
 
#ifdef  FRAGMENTED_PACK 
  unsigned char*  m_SinglePack;
 
  int             m_SinglePackSize; 
  int             m_ImageSize;
 
  int             m_SelfAllocatedImage;
 
  int             m_SelfAllocatedImageHeader;
 
#endif 
 
  int ScalarSizeTable[12];
};
 
 
} // namespace igtl
 
#endif // _igtlImageMessage2_h