G:/work/subversion/scol-technologies/trunk/plugins/OpenNiSCOL/OpenNiSCOL/lib/common.h

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2010 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#ifndef __COMMON_H__
#define __COMMON_H__


//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
// Standard C++ includes
// includes
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>   
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <stdio.h>
#include <string>
#include <windows.h>
#include <exception>
#include <iostream>
#include <map>
#include <list>
#include <set>
#include <sstream>
#include <tchar.h>

// Standard C includes
#include <cassert>

// OpenNI include
#include "XnCppWrapper.h"

// NITE include
#include "XnVNite.h"

// Scol SDK include
#include <scol.h>

// Standard C++ namespace
using namespace std;


//---------------------------------------------------------------------------
// Macros
//---------------------------------------------------------------------------
// Macro to make a c++ word (a variable, a class name, etc) as string, using a preprocessor trick
#define NIDEVICE_STRINGER(MAKE_THIS_AS_STRING) #MAKE_THIS_AS_STRING

// Macro to get a class name as string
#define NIDEVICE_GET_CLASS_NAME_AS_STRING(CLASS_NAME)               \
{                                                                   \
  std::string tmpName(NIDEVICE_STRINGER(CLASS_NAME));               \
  std::string type(tmpName.substr(tmpName.find_last_of("::")+1));   \
  return type;                                                      \
}


#pragma warning (disable: 4661)


#define NIDEVICE_GET_OBJECT_TYPE_AS_STRING(CLASS_NAME)  \
std::string GetObjectTypeAsString()                     \
{                                                       \
        NIDEVICE_GET_CLASS_NAME_AS_STRING(CLASS_NAME)         \
};                                                      \


// Macro to get full error message for exception triggering
#define NIDEVICE_GET_ERROR_MESSAGE(ERROR,DESC)          \
std::string GetNiDeviceMessage()                        \
{                                                       \
  std::string msg = DESC;                               \
  msg += " - ";                                         \
  msg += xnGetStatusString(ERROR);                      \
  return msg;                                           \
};                                                      \


//---------------------------------------------------------------------------
// Class pre-declarations
//---------------------------------------------------------------------------
namespace NIDevice
{
  // Core namespace handling Exception and Singleton
  namespace Core
  {
    template <class DERIVATED_CLASS> class Singleton;
    class Exception;
    class Thread;
    template <class GENERATOR_TYPE, XnProductionNodeType OPENNI_GENERATOR_TYPE> class GenericGenerator;
    class DataSkeleton;
  }

  // Data namespace handling Image and Depth nodes
  namespace Generator
  {
    class Depth;
    class Image;
    class User;
    class Gesture;
    class Hands;
  }

  // Objects namespace handling Kinect devices and users
  namespace Objects
  {
    class KinectDevice;
    class KinectUser;
    class KinectGesture;
  }

  // Base class managing all the devices
  class DeviceManager;
}


//---------------------------------------------------------------------------
// Boost Map pre-declarations
//---------------------------------------------------------------------------
typedef std::list<NIDevice::Objects::KinectUser*> KinectUserList;
typedef std::set<unsigned int> OpenNIUserList;
typedef std::map<unsigned int, NIDevice::Objects::KinectDevice*> KinectDeviceMap;


class Quaternion
{
  public:
    Quaternion()
    {
      x = 0.0f;
      y = 0.0f;
      z = 0.0f;
      w = 1.0f;
    }
  
          float x;
    float y;
    float z;
    float w;
};

class Matrix3
{
  public:

  Matrix3 (float fEntry00, float fEntry01, float fEntry02,
                  float fEntry10, float fEntry11, float fEntry12,
                  float fEntry20, float fEntry21, float fEntry22)
  {
          m[0][0] = fEntry00;
          m[0][1] = fEntry01;
          m[0][2] = fEntry02;
          m[1][0] = fEntry10;
          m[1][1] = fEntry11;
          m[1][2] = fEntry12;
          m[2][0] = fEntry20;
          m[2][1] = fEntry21;
          m[2][2] = fEntry22;
  }


  // member access, allows use of construct mat[r][c]
  inline float* operator[] (size_t iRow) const
  {
    return (float*)m[iRow];
  }

  bool operator== (const Matrix3& rkMatrix) const;
  inline bool operator!= (const Matrix3& rkMatrix) const
        {
                return !operator==(rkMatrix);
        }

  // arithmetic operations
  Matrix3 operator+ (const Matrix3& rkMatrix) const;
  Matrix3 operator- (const Matrix3& rkMatrix) const;
  Matrix3 operator* (const Matrix3& rkMatrix) const;
  Matrix3 operator- () const;

  // matrix * vector [3x3 * 3x1 = 3x1]
  //Vector3 operator* (const Vector3& rkVector) const;

  protected:
    float m[3][3];
};

#endif