XnTypes.h

Go to the documentation of this file.

/*****************************************************************************
*                                                                            *
*  OpenNI 1.0 Alpha                                                          *
*  Copyright (C) 2010 PrimeSense Ltd.                                        *
*                                                                            *
*  This file is part of OpenNI.                                              *
*                                                                            *
*  OpenNI 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 3 of the License, or      *
*  (at your option) any later version.                                       *
*                                                                            *
*  OpenNI 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 OpenNI. If not, see <http://www.gnu.org/licenses/>.            *
*                                                                            *
*****************************************************************************/



#ifndef __XN_TYPES_H__
#define __XN_TYPES_H__

//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
#include <XnStatus.h>
#include <XnOS.h>

//---------------------------------------------------------------------------
// Defines
//---------------------------------------------------------------------------
#define XN_MAX_NAME_LENGTH                                      80

#define XN_MAX_CREATION_INFO_LENGTH                     255

#define XN_MAX_LICENSE_LENGTH                           255

#define XN_NODE_WAIT_FOR_DATA_TIMEOUT           2000

#define XN_VENDOR_OPEN_NI       "OpenNI"

#define XN_FORMAT_NAME_ONI      "oni"

//---------------------------------------------------------------------------
// Forward Declarations
//---------------------------------------------------------------------------
struct XnInternalNodeData;

//---------------------------------------------------------------------------
// Types
//---------------------------------------------------------------------------

#pragma pack (push, 1)

typedef struct XnContext XnContext;

typedef struct XnInternalNodeData* XnNodeHandle;

typedef XnUInt32 XnLockHandle;

typedef enum XnProductionNodeType
{
        XN_NODE_TYPE_DEVICE = 1,
        
        XN_NODE_TYPE_DEPTH = 2,
        
        XN_NODE_TYPE_IMAGE = 3,

        XN_NODE_TYPE_AUDIO = 4,
        
        XN_NODE_TYPE_IR = 5,

        XN_NODE_TYPE_USER = 6,
        
        XN_NODE_TYPE_RECORDER = 7,
        
        XN_NODE_TYPE_PLAYER = 8,
        
        XN_NODE_TYPE_GESTURE = 9,
        
        XN_NODE_TYPE_SCENE = 10,
        
        XN_NODE_TYPE_HANDS = 11,

        XN_NODE_TYPE_CODEC = 12,
} XnProductionNodeType;

typedef struct XnVersion
{
        XnUInt8 nMajor;
        XnUInt8 nMinor;
        XnUInt16 nMaintenance;
        XnUInt32 nBuild;
} XnVersion;

typedef struct XnProductionNodeDescription
{
        XnProductionNodeType Type;
        XnChar strVendor[XN_MAX_NAME_LENGTH];
        XnChar strName[XN_MAX_NAME_LENGTH];
        XnVersion Version;
} XnProductionNodeDescription;

typedef struct XnNodeInfo XnNodeInfo;

typedef struct XnNodeInfoListNode XnNodeInfoListNode;

typedef struct XnNodeInfoList XnNodeInfoList;

typedef struct XnNodeInfoListIterator
{
        XnNodeInfoListNode* pCurrent;
} XnNodeInfoListIterator;

typedef struct XnNodeQuery XnNodeQuery;

typedef struct XnLicense
{
        XnChar strVendor[XN_MAX_NAME_LENGTH];
        XnChar strKey[XN_MAX_LICENSE_LENGTH];
} XnLicense;

typedef struct XnEnumerationErrors XnEnumerationErrors;

typedef void* XnModuleNodeHandle;

typedef void (XN_CALLBACK_TYPE* XnStateChangedHandler)(XnNodeHandle hNode, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnErrorStateChangedHandler)(XnStatus errorState, void* pCookie);

typedef void* XnCallbackHandle;

typedef struct XnModuleExportedProductionNodeInterface XnModuleExportedProductionNodeInterface; // Forward Declaration


//---------------------------------------------------------------------------
// 3D Vision Types
//---------------------------------------------------------------------------
typedef XnUInt16 XnDepthPixel;

#define XN_DEPTH_NO_SAMPLE_VALUE        ((XnDepthPixel)0)

typedef struct XnRGB24Pixel
{
        XnUInt8 nRed;
        XnUInt8 nGreen;
        XnUInt8 nBlue;
} XnRGB24Pixel;

typedef struct XnYUV422DoublePixel
{
        XnUInt8 nU;
        XnUInt8 nY1;
        XnUInt8 nV;
        XnUInt8 nY2;
} XnYUV422DoublePixel;

typedef XnUInt8 XnGrayscale8Pixel;

typedef XnUInt16 XnGrayscale16Pixel;

typedef XnGrayscale16Pixel XnIRPixel;

typedef XnUInt16 XnLabel;

//---------------------------------------------------------------------------
// Generators Capabilities
//---------------------------------------------------------------------------
#define XN_CAPABILITY_EXTENDED_SERIALIZATION    "ExtendedSerialization"
#define XN_CAPABILITY_MIRROR                                    "Mirror"
#define XN_CAPABILITY_ALTERNATIVE_VIEW_POINT    "AlternativeViewPoint"
#define XN_CAPABILITY_CROPPING                                  "Cropping"
#define XN_CAPABILITY_USER_POSITION                             "UserPosition"
#define XN_CAPABILITY_SKELETON                                  "User::Skeleton"
#define XN_CAPABILITY_POSE_DETECTION                    "User::PoseDetection"
#define XN_CAPABILITY_LOCK_AWARE                                "LockAware"
#define XN_CAPABILITY_ERROR_STATE                               "ErrorState"
#define XN_CAPABILITY_FRAME_SYNC                                "FrameSync"

//---------------------------------------------------------------------------
// Generators API Structs
//---------------------------------------------------------------------------

#define XN_QQVGA_X_RES  160
#define XN_QQVGA_Y_RES  120

#define XN_CGA_X_RES    320
#define XN_CGA_Y_RES    200

#define XN_QVGA_X_RES   320
#define XN_QVGA_Y_RES   240

#define XN_VGA_X_RES    640
#define XN_VGA_Y_RES    480

#define XN_SVGA_X_RES   800
#define XN_SVGA_Y_RES   600

#define XN_XGA_X_RES    1024
#define XN_XGA_Y_RES    768

#define XN_720P_X_RES   1280
#define XN_720P_Y_RES   720

#define XN_SXGA_X_RES   1280
#define XN_SXGA_Y_RES   1024

#define XN_UXGA_X_RES   1600
#define XN_UXGA_Y_RES   1200

#define XN_1080P_X_RES  1920
#define XN_1080P_Y_RES  1080

typedef enum XnResolution
{
        XN_RES_CUSTOM = 0,
        XN_RES_QQVGA = 1,
        XN_RES_CGA = 2,
        XN_RES_QVGA = 3,
        XN_RES_VGA = 4,
        XN_RES_SVGA = 5,
        XN_RES_XGA = 6,
        XN_RES_720P = 7,
        XN_RES_SXGA = 8,
        XN_RES_UXGA = 9,
        XN_RES_1080P = 10,
} XnResolution;

typedef struct XnMapOutputMode
{
        XnUInt32 nXRes;
        XnUInt32 nYRes;
        XnUInt32 nFPS;
} XnMapOutputMode;

typedef enum XnSampleRate
{
        XN_SAMPLE_RATE_8K = 8000,
        XN_SAMPLE_RATE_11K = 11025,
        XN_SAMPLE_RATE_12K = 12000,
        XN_SAMPLE_RATE_16K = 16000,
        XN_SAMPLE_RATE_22K = 22050,
        XN_SAMPLE_RATE_24K = 24000,
        XN_SAMPLE_RATE_32K = 32000,
        XN_SAMPLE_RATE_44K = 44100,
        XN_SAMPLE_RATE_48K = 48000,
} XnSampleRate;

typedef struct XnWaveOutputMode
{
        XnUInt32 nSampleRate;
        XnUInt16 nBitsPerSample;
        XnUInt8 nChannels;
} XnWaveOutputMode;

typedef struct XnVector3D
{
        XnFloat X;
        XnFloat Y;
        XnFloat Z;
} XnVector3D;

typedef XnVector3D XnPoint3D;

typedef struct XnBoundingBox3D
{
        XnPoint3D LeftBottomNear;
        XnPoint3D RightTopFar;
} XnBoundingBox3D;

typedef struct XnCropping
{
        XnBool bEnabled;
        XnUInt16 nXOffset;
        XnUInt16 nYOffset;
        XnUInt16 nXSize;
        XnUInt16 nYSize;
} XnCropping;

typedef struct XnFieldOfView
{
        XnDouble fHFOV;
        XnDouble fVFOV;
} XnFieldOfView;

typedef enum XnPixelFormat
{
        XN_PIXEL_FORMAT_RGB24 = 1,
        XN_PIXEL_FORMAT_YUV422 = 2,
        XN_PIXEL_FORMAT_GRAYSCALE_8_BIT = 3,
        XN_PIXEL_FORMAT_GRAYSCALE_16_BIT = 4,
} XnPixelFormat;

typedef struct XnSupportedPixelFormats
{
        XnBool m_bRGB24 : 1;
        XnBool m_bYUV422 : 1;
        XnBool m_bGrayscale8Bit : 1;
        XnBool m_bGrayscale16Bit : 1;
        XnUInt m_nPadding : 4;
        XnUInt m_nReserved : 24;
} XnSupportedPixelFormats;

typedef enum XnPlayerSeekOrigin
{
        XN_PLAYER_SEEK_SET = 0,
        XN_PLAYER_SEEK_CUR = 1,
        XN_PLAYER_SEEK_END = 2,
} XnPlayerSeekOrigin;

// User
typedef XnUInt32 XnUserID;
typedef XnFloat  XnConfidence;

typedef struct XnMatrix3X3
{
        XnFloat elements[9];
} XnMatrix3X3;

typedef struct XnPlane3D
{
        XnVector3D vNormal;

        XnPoint3D ptPoint;
} XnPlane3D;

typedef struct XnSkeletonJointPosition
{
        XnVector3D              position;

        XnConfidence    fConfidence;
} XnSkeletonJointPosition;

typedef struct XnSkeletonJointOrientation
{
        XnMatrix3X3             orientation;
        XnConfidence    fConfidence;
} XnSkeletonJointOrientation;

typedef struct XnSkeletonJointTransformation
{
        XnSkeletonJointPosition         position;
        XnSkeletonJointOrientation      orientation;
} XnSkeletonJointTransformation;

typedef enum XnSkeletonJoint
{
        XN_SKEL_HEAD                    = 1,
        XN_SKEL_NECK                    = 2,
        XN_SKEL_TORSO                   = 3,
        XN_SKEL_WAIST                   = 4,

        XN_SKEL_LEFT_COLLAR             = 5,
        XN_SKEL_LEFT_SHOULDER   = 6,
        XN_SKEL_LEFT_ELBOW              = 7,
        XN_SKEL_LEFT_WRIST              = 8,
        XN_SKEL_LEFT_HAND               = 9,
        XN_SKEL_LEFT_FINGERTIP  =10,

        XN_SKEL_RIGHT_COLLAR    =11,
        XN_SKEL_RIGHT_SHOULDER  =12,
        XN_SKEL_RIGHT_ELBOW             =13,
        XN_SKEL_RIGHT_WRIST             =14,
        XN_SKEL_RIGHT_HAND              =15,
        XN_SKEL_RIGHT_FINGERTIP =16,

        XN_SKEL_LEFT_HIP                =17,
        XN_SKEL_LEFT_KNEE               =18,
        XN_SKEL_LEFT_ANKLE              =19,
        XN_SKEL_LEFT_FOOT               =20,

        XN_SKEL_RIGHT_HIP               =21,
        XN_SKEL_RIGHT_KNEE              =22,
        XN_SKEL_RIGHT_ANKLE             =23,
        XN_SKEL_RIGHT_FOOT              =24     
} XnSkeletonJoint;

typedef enum XnSkeletonProfile
{
        XN_SKEL_PROFILE_NONE            = 1,

        XN_SKEL_PROFILE_ALL                     = 2,
        
        XN_SKEL_PROFILE_UPPER           = 3,
        
        XN_SKEL_PROFILE_LOWER           = 4,
        
        XN_SKEL_PROFILE_HEAD_HANDS      = 5,
} XnSkeletonProfile;

// User
typedef void (XN_CALLBACK_TYPE* XnUserHandler)(XnNodeHandle hNode, XnUserID user, void* pCookie);

// Hands
typedef void (XN_CALLBACK_TYPE* XnHandCreate)(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnHandUpdate)(XnNodeHandle hNode, XnUserID user, const XnPoint3D* pPosition, XnFloat fTime, void* pCookie);

typedef void (XN_CALLBACK_TYPE* XnHandDestroy)(XnNodeHandle hNode, XnUserID user, XnFloat fTime, void* pCookie);

// Gesture Module
typedef void (XN_CALLBACK_TYPE* XnGestureRecognized)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pIDPosition, const XnPoint3D* pEndPosition, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnGestureProgress)(XnNodeHandle hNode, const XnChar* strGesture, const XnPoint3D* pPosition, XnFloat fProgress, void* pCookie);

// Skeleton
typedef void (XN_CALLBACK_TYPE* XnCalibrationStart)(XnNodeHandle hNode, XnUserID user, void* pCookie);
typedef void (XN_CALLBACK_TYPE* XnCalibrationEnd)(XnNodeHandle hNode, XnUserID user, XnBool bSuccess, void* pCookie);

// Pose Detection
typedef void (XN_CALLBACK_TYPE* XnPoseDetectionCallback)(XnNodeHandle hNode, const XnChar* strPose, XnUserID user, void* pCookie);

//---------------------------------------------------------------------------
// Recorder Types
//---------------------------------------------------------------------------

typedef enum XnRecordMedium
{
        XN_RECORD_MEDIUM_FILE = 0,
} XnRecordMedium;

typedef XnUInt32 XnCodecID;

#define XN_CODEC_ID(c1, c2, c3, c4) (XnCodecID)((c4 << 24) | (c3 << 16) | (c2 << 8) | c1)

typedef struct XnRecorderOutputStreamInterface
{
        XnStatus (XN_CALLBACK_TYPE* Open)(void* pCookie);

        XnStatus (XN_CALLBACK_TYPE* Write)(void* pCookie, const XnChar* strNodeName, 
                const void* pData, XnUInt32 nSize);

        XnStatus (XN_CALLBACK_TYPE* Seek)(void* pCookie, XnOSSeekType seekType, const XnUInt32 nOffset);

        XnUInt32 (XN_CALLBACK_TYPE* Tell)(void* pCookie);

        void (XN_CALLBACK_TYPE* Close)(void* pCookie);
} XnRecorderOutputStreamInterface;

typedef struct XnPlayerInputStreamInterface
{
        XnStatus (XN_CALLBACK_TYPE* Open)(void* pCookie);

        XnStatus (XN_CALLBACK_TYPE* Read)(void* pCookie, void* pBuffer, XnUInt32 nSize, XnUInt32* pnBytesRead);

        XnStatus (XN_CALLBACK_TYPE* Seek)(void* pCookie, XnOSSeekType seekType, const XnInt32 nOffset);
        
        XnUInt32 (XN_CALLBACK_TYPE* Tell)(void* pCookie);

        void (XN_CALLBACK_TYPE* Close)(void* pCookie);
} XnPlayerInputStreamInterface;

typedef struct XnNodeNotifications
{
        XnStatus (XN_CALLBACK_TYPE* OnNodeAdded)
                (void* pCookie, const XnChar* strNodeName, XnProductionNodeType type,
                XnCodecID compression);

        XnStatus (XN_CALLBACK_TYPE* OnNodeRemoved)
                (void* pCookie, const XnChar* strNodeName);

        XnStatus (XN_CALLBACK_TYPE* OnNodeIntPropChanged)
                (void* pCookie, const XnChar* strNodeName, 
                const XnChar* strPropName, XnUInt64 nValue);

        XnStatus (XN_CALLBACK_TYPE* OnNodeRealPropChanged)
                (void* pCookie, const XnChar* strNodeName, 
                const XnChar* strPropName, XnDouble dValue);

        XnStatus (XN_CALLBACK_TYPE* OnNodeStringPropChanged)
                (void* pCookie, const XnChar* strNodeName, 
                const XnChar* strPropName, const XnChar* strValue);

        XnStatus (XN_CALLBACK_TYPE* OnNodeGeneralPropChanged)
                (void* pCookie, const XnChar* strNodeName, 
                const XnChar* strPropName, XnUInt32 nBufferSize, const void* pBuffer);

        XnStatus (XN_CALLBACK_TYPE* OnNodeStateReady)
                (void* pCookie, const XnChar* strNodeName);

        XnStatus (XN_CALLBACK_TYPE* OnNodeNewData)
                (void* pCookie, const XnChar* strNodeName,
                XnUInt64 nTimeStamp, XnUInt32 nFrame, const void* pData, XnUInt32 nSize);

} XnNodeNotifications;

typedef struct XnUInt32XYPair
{
        XnUInt32 X;
        XnUInt32 Y;
} XnUInt32XYPair;

typedef struct XnOutputMetaData
{
        XnUInt64 nTimestamp;

        XnUInt32 nFrameID;
        
        XnUInt32 nDataSize;

        XnBool bIsNew;

} XnOutputMetaData;

typedef struct XnMapMetaData
{
        XnOutputMetaData* pOutput;

        XnUInt32XYPair Res;
        
        XnUInt32XYPair Offset;
        
        XnUInt32XYPair FullRes;
        
        XnPixelFormat PixelFormat;
        
        XnUInt32 nFPS;
} XnMapMetaData;

typedef struct XnDepthMetaData
{
        XnMapMetaData* pMap;
        
        const XnDepthPixel* pData;
        
        XnDepthPixel nZRes;
} XnDepthMetaData;

typedef struct XnImageMetaData
{
        XnMapMetaData* pMap;
        
        const XnUInt8* pData;
} XnImageMetaData;

typedef struct XnIRMetaData
{
        XnMapMetaData* pMap;
        
        const XnIRPixel* pData;
} XnIRMetaData;

typedef struct XnAudioMetaData
{
        XnOutputMetaData* pOutput;

        XnWaveOutputMode Wave;
        
        const XnUInt8* pData;
} XnAudioMetaData;

typedef struct XnSceneMetaData
{
        XnMapMetaData* pMap;

        const XnLabel* pData;
} XnSceneMetaData;

#pragma pack (pop)

#endif //__XN_TYPES_H__