//-------------------------------------------------------------------------------------- // ClassifierData.h // // This file defines all the features and classifier data that are used during the // training process on the PC and the gesture detection and runtime on the Xbox 360. // // Advanced Technology Group (ATG) // Copyright (C) Microsoft Corporation. All rights reserved. //-------------------------------------------------------------------------------------- #pragma once #include #include "Common.h" #include "RingBuffer.h" #include "MuscleTracking.h" #include "VelocityGrid.h" namespace KinectGesture { //-------------------------------------------------------------------------------------- // Each feature used for training has a define so that it is easy to switch on/off // features when experimenting with different feature sets. E.g. you might be interested // only in pose detection rather than gesture detection, in which case you could simply // comment out all the time dependent features, such as velocity. //-------------------------------------------------------------------------------------- #define ADD_TYPE_DIFF_POSITION_X 1 #define ADD_TYPE_DIFF_POSITION_Y 1 #define ADD_TYPE_DIFF_POSITION_Z 1 #define ADD_TYPE_ANGLE 1 #define ADD_TYPE_TIME_SPACE_ANGLE 1 #define ADD_TYPE_POSITION_SPEED 1 #define ADD_TYPE_POSITION_VELOCITY_X 1 #define ADD_TYPE_POSITION_VELOCITY_Y 1 #define ADD_TYPE_POSITION_VELOCITY_Z 1 #define ADD_TYPE_ANGLE_VELOCITY 1 #define ADD_TYPE_ANGLE_ACCELERATION 1 #define ADD_TYPE_MUSCLE_FORCES 1 #define ADD_TYPE_MUSCLE_TORQUES 1 #define ADD_TYPE_MUSCLE_POWER 1 #define ADD_TYPE_DIFF_MUSCLE_FORCE_X 1 #define ADD_TYPE_DIFF_MUSCLE_FORCE_Y 1 #define ADD_TYPE_DIFF_MUSCLE_FORCE_Z 1 #define ADD_TYPE_POSITION_SPEED_SQ 1 #define ADD_TYPE_POSITION_VELOCITYSQ_X 1 #define ADD_TYPE_POSITION_VELOCITYSQ_Y 1 #define ADD_TYPE_POSITION_VELOCITYSQ_Z 1 #define ADD_TYPE_POSITION_ACCELERATION 1 #define ADD_TYPE_POSITION_ACCELERATION_X 1 #define ADD_TYPE_POSITION_ACCELERATION_Y 1 #define ADD_TYPE_POSITION_ACCELERATION_Z 1 #define ADD_TYPE_BONE_LENGTH_CHANGES 1 // We can add many other features, e.g. based on radial basis functions, signmoid, etc. #define ADD_TYPE_OPTICAL_FLOW 1 //-------------------------------------------------------------------------------------- // Name: ClassifierData // Desc: Base class for the classifier data //-------------------------------------------------------------------------------------- class ClassifierData { public: enum EType { #ifdef ADD_TYPE_DIFF_POSITION_X TYPE_DIFF_POSITION_X, #endif #ifdef ADD_TYPE_DIFF_POSITION_Y TYPE_DIFF_POSITION_Y, #endif #ifdef ADD_TYPE_DIFF_POSITION_Z TYPE_DIFF_POSITION_Z, #endif #ifdef ADD_TYPE_ANGLE TYPE_ANGLE, #endif #ifdef ADD_TYPE_TIME_SPACE_ANGLE TYPE_TIME_SPACE_ANGLE, #endif #ifdef ADD_TYPE_POSITION_SPEED TYPE_POSITION_SPEED, #endif #ifdef ADD_TYPE_POSITION_VELOCITY_X TYPE_POSITION_VELOCITY_X, #endif #ifdef ADD_TYPE_POSITION_VELOCITY_Y TYPE_POSITION_VELOCITY_Y, #endif #ifdef ADD_TYPE_POSITION_VELOCITY_Z TYPE_POSITION_VELOCITY_Z, #endif #ifdef ADD_TYPE_ANGLE_VELOCITY TYPE_ANGLE_VELOCITY, #endif #ifdef ADD_TYPE_ANGLE_ACCELERATION TYPE_ANGLE_ACCELERATION, #endif #ifdef ADD_TYPE_MUSCLE_FORCES TYPE_MUSCLE_FORCE_X, TYPE_MUSCLE_FORCE_Y, TYPE_MUSCLE_FORCE_Z, #endif #ifdef ADD_TYPE_MUSCLE_TORQUES TYPE_MUSCLE_TORQUE_X, TYPE_MUSCLE_TORQUE_Y, TYPE_MUSCLE_TORQUE_Z, #endif #ifdef ADD_TYPE_MUSCLE_POWER TYPE_MUSCLE_POWER, #endif #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_X TYPE_DIFF_MUSCLE_FORCE_X, #endif #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_Y TYPE_DIFF_MUSCLE_FORCE_Y, #endif #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_Z TYPE_DIFF_MUSCLE_FORCE_Z, #endif #ifdef ADD_TYPE_POSITION_VELOCITYSQ_X TYPE_POSITION_VELOCITYSQ_X, #endif #ifdef ADD_TYPE_POSITION_VELOCITYSQ_Y TYPE_POSITION_VELOCITYSQ_Y, #endif #ifdef ADD_TYPE_POSITION_VELOCITYSQ_Z TYPE_POSITION_VELOCITYSQ_Z, #endif #ifdef ADD_TYPE_POSITION_SPEED_SQ TYPE_POSITION_SPEED_SQ, #endif #ifdef ADD_TYPE_POSITION_ACCELERATION TYPE_POSITION_ACCELERATION, #endif #ifdef ADD_TYPE_POSITION_ACCELERATION_X TYPE_POSITION_ACCELERATION_X, #endif #ifdef ADD_TYPE_POSITION_ACCELERATION_Y TYPE_POSITION_ACCELERATION_Y, #endif #ifdef ADD_TYPE_POSITION_ACCELERATION_Z TYPE_POSITION_ACCELERATION_Z, #endif #ifdef ADD_TYPE_BONE_LENGTH_CHANGES TYPE_BONE_LENGTH_CHANGES, #endif #ifdef ADD_TYPE_OPTICAL_FLOW TYPE_OPTICAL_FLOW_X, TYPE_OPTICAL_FLOW_Y, TYPE_OPTICAL_FLOW_LENGTH_SQ, TYPE_OPTICAL_FLOW_TANGENT, TYPE_OPTICAL_FLOW_X_DIFF, TYPE_OPTICAL_FLOW_Y_DIFF, #endif NUM_FEATURES }; friend class DebugOutput; public: ClassifierData(); virtual VOID Update( const UINT, VOID* ) {} virtual HRESULT Read( FILE* pFile ); virtual HRESULT Read( VOID* pBuffer ); virtual HRESULT Write( FILE* pFile ); virtual HRESULT Write( VOID* pBuffer ); virtual ClassifierData* Clone() { return NULL; } VOID Copy( ClassifierData* pSource ); virtual UINT MakeUID(); inline VOID SetValue( const UINT uPlayerIdx, const FLOAT fValue ) { m_fValue[ uPlayerIdx ] = fValue; } inline FLOAT GetValue( const UINT uPlayerIdx ) const { return m_fValue[ uPlayerIdx ]; } inline VOID SetID( const UINT uID ) { m_uID = uID; } inline UINT GetID() const { return m_uID; } inline UINT GetType() const { return m_Type; } inline VOID SetRejectInfferedJoints( const BOOL bRejectInferred ) { m_bRejectInferred = bRejectInferred; } inline BOOL GetRejectInferredJoints() const { return m_bRejectInferred; } static VOID Initialize(); static ClassifierData* CreatNewInstance( FILE* pFile ); static ClassifierData* CreatNewInstance( VOID* pBuffer ); static VOID UpdateHistory( const UINT uPlayerIdx, const GESTURE_SKELETON_TYPE* pSkeletonData, const FLOAT fDeltaTimeInSeconds, BOOL* bReset, const VelocityGrid* opticalFlowGrid ); static VOID Reset( const UINT uPlayerIdx, const GESTURE_SKELETON_TYPE* pSkeletonData ); static FLOAT GetEnergyLevel( const UINT uPlayerIdx ); __forceinline static GESTURE_SKELETON_TYPE* GetCurrentSkeleton( const UINT uPlayerIdx ) { return m_SkeletonDataHistory[ uPlayerIdx ].GetCurrentSkeleton(); } protected: FLOAT m_fValue[ KINECT_GESTURE_MAX_SIMULTANEOUS_GESTURES ]; // The value updated by the data to be used in threshold comparisons in classifier EType m_Type; // The type of data UINT m_uID; // Unique ID for each so that we can link this to the classifiers BOOL m_bRejectInferred; // Reject all inferred joints or use them? static RingBuffer m_SkeletonDataHistory[ KINECT_GESTURE_MAX_SIMULTANEOUS_GESTURES ]; // Ring buffer holding sliding window of skeleton data static MUSCLE_FRAME m_Muscles[ KINECT_GESTURE_MAX_SIMULTANEOUS_GESTURES ]; static VelocityGridFromSkeleton m_OpticalFlow[ KINECT_GESTURE_MAX_SIMULTANEOUS_GESTURES ]; static ClassifierData* CreatNewInstance( const UINT uValue ); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataBaseClassForOneJoint // Desc: Base class for classifier data operating on one joint //-------------------------------------------------------------------------------------- class ClassifierDataBaseClassForOneJoint : public ClassifierData { public: ClassifierDataBaseClassForOneJoint( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT ); virtual HRESULT Read( FILE* pFile ); virtual HRESULT Read( VOID* pBuffer ); virtual HRESULT Write( FILE* pFile ); virtual HRESULT Write( VOID* pBuffer ); virtual UINT MakeUID(); protected: GESTURE_JOINT_INDEX m_jointIndex; friend class DebugOutput; }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataBaseClassForTwoJoints // Desc: Base class for classifier data operating on two joints //-------------------------------------------------------------------------------------- class ClassifierDataBaseClassForTwoJoints : public ClassifierData { public: ClassifierDataBaseClassForTwoJoints( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ); virtual HRESULT Read( FILE* pFile ); virtual HRESULT Read( VOID* pBuffer ); virtual HRESULT Write( FILE* pFile ); virtual HRESULT Write( VOID* pBuffer ); virtual UINT MakeUID(); protected: GESTURE_JOINT_INDEX m_jointIndices[ 2 ]; friend class DebugOutput; }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataBaseClassForThreeJoints // Desc: Base class for classifier data operating on three joints //-------------------------------------------------------------------------------------- class ClassifierDataBaseClassForThreeJoints : public ClassifierData { public: ClassifierDataBaseClassForThreeJoints( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex2 = GESTURE_JOINT_COUNT ); virtual HRESULT Read( FILE* pFile ); virtual HRESULT Read( VOID* pBuffer ); virtual HRESULT Write( FILE* pFile ); virtual HRESULT Write( VOID* pBuffer ); virtual UINT MakeUID(); protected: GESTURE_JOINT_INDEX m_jointIndices[ 3 ]; friend class DebugOutput; }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffPositionX // Desc: Classifier data based on differences in X between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffPositionX : public ClassifierDataBaseClassForTwoJoints { public: ClassifierDataUsingDiffPositionX( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForTwoJoints( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_POSITION_X m_Type = TYPE_DIFF_POSITION_X; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingDiffPositionX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffPositionY // Desc: Classifier data based on differences in Y between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffPositionY : public ClassifierDataUsingDiffPositionX { public: ClassifierDataUsingDiffPositionY( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataUsingDiffPositionX( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_POSITION_Y m_Type = TYPE_DIFF_POSITION_Y; #endif } virtual ClassifierDataUsingDiffPositionY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffPositionZ // Desc: Classifier data based on differences in Z between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffPositionZ : public ClassifierDataUsingDiffPositionX { public: ClassifierDataUsingDiffPositionZ( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataUsingDiffPositionX( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_POSITION_Z m_Type = TYPE_DIFF_POSITION_Z; #endif } virtual ClassifierDataUsingDiffPositionZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingAngles // Desc: Classifier data based on angle formed between three joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingAngles : public ClassifierDataBaseClassForThreeJoints { public: ClassifierDataUsingAngles( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex2 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForThreeJoints( jointIndex0, jointIndex1, jointIndex2 ) { #ifdef ADD_TYPE_ANGLE m_Type = TYPE_ANGLE; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingAngles* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingTimeSpaceAngles // Desc: Classifier data based on angle formed between the same joint at different times, // e.g. the angle form by hand at frame 0, frame 1 and frame 2 //-------------------------------------------------------------------------------------- class ClassifierDataUsingTimeSpaceAngles : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingTimeSpaceAngles( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_TIME_SPACE_ANGLE m_Type = TYPE_TIME_SPACE_ANGLE; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingTimeSpaceAngles* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionSpeed // Desc: Classifier data based on the speed of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionSpeed : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingPositionSpeed( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_POSITION_SPEED m_Type = TYPE_POSITION_SPEED; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingPositionSpeed* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionSpeedSQ // Desc: Classifier data based on the squared speed of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionSpeedSQ : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionSpeedSQ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_SPEED_SQ m_Type = TYPE_POSITION_SPEED_SQ; #endif } virtual ClassifierDataUsingPositionSpeedSQ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionAcceleration // Desc: Classifier data based on the acceleration of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionAcceleration : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingPositionAcceleration( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_POSITION_ACCELERATION m_Type = TYPE_POSITION_ACCELERATION; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingPositionAcceleration* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionAccelerationX // Desc: Classifier data based on the X acceleration of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionAccelerationX : public ClassifierDataUsingPositionAcceleration { public: ClassifierDataUsingPositionAccelerationX( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionAcceleration( jointIndex ) { #ifdef ADD_TYPE_POSITION_ACCELERATION_X m_Type = TYPE_POSITION_ACCELERATION_X; #endif } virtual ClassifierDataUsingPositionAccelerationX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionAccelerationY // Desc: Classifier data based on the Y acceleration of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionAccelerationY : public ClassifierDataUsingPositionAcceleration { public: ClassifierDataUsingPositionAccelerationY( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionAcceleration( jointIndex ) { #ifdef ADD_TYPE_POSITION_ACCELERATION_Y m_Type = TYPE_POSITION_ACCELERATION_Y; #endif } virtual ClassifierDataUsingPositionAccelerationY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionAccelerationZ // Desc: Classifier data based on the Z acceleration of a joint //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionAccelerationZ : public ClassifierDataUsingPositionAcceleration { public: ClassifierDataUsingPositionAccelerationZ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionAcceleration( jointIndex ) { #ifdef ADD_TYPE_POSITION_ACCELERATION_Z m_Type = TYPE_POSITION_ACCELERATION_Z; #endif } virtual ClassifierDataUsingPositionAccelerationZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocityX // Desc: Classifier data based on the velocity of a joint in X //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocityX : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocityX( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITY_X m_Type = TYPE_POSITION_VELOCITY_X; #endif } virtual ClassifierDataUsingPositionVelocityX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocityY // Desc: Classifier data based on the velocity of a joint in Y //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocityY : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocityY( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITY_Y m_Type = TYPE_POSITION_VELOCITY_Y; #endif } virtual ClassifierDataUsingPositionVelocityY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocityZ // Desc: Classifier data based on the velocity of a joint in Z //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocityZ : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocityZ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITY_Z m_Type = TYPE_POSITION_VELOCITY_Z; #endif } virtual ClassifierDataUsingPositionVelocityZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocitySQX // Desc: Classifier data based on the squared velocity of a joint in X //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocitySQX : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocitySQX( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITYSQ_X m_Type = TYPE_POSITION_VELOCITYSQ_X; #endif } virtual ClassifierDataUsingPositionVelocitySQX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocitySQY // Desc: Classifier data based on the squared velocity of a joint in Y //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocitySQY : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocitySQY( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITYSQ_Y m_Type = TYPE_POSITION_VELOCITYSQ_Y; #endif } virtual ClassifierDataUsingPositionVelocitySQY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingPositionVelocitySQZ // Desc: Classifier data based on the squared velocity of a joint in Z //-------------------------------------------------------------------------------------- class ClassifierDataUsingPositionVelocitySQZ : public ClassifierDataUsingPositionSpeed { public: ClassifierDataUsingPositionVelocitySQZ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingPositionSpeed( jointIndex ) { #ifdef ADD_TYPE_POSITION_VELOCITYSQ_Z m_Type = TYPE_POSITION_VELOCITYSQ_Z; #endif } virtual ClassifierDataUsingPositionVelocitySQZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingAngleVelocities // Desc: Classifier data based on the velocity of the angle between three joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingAngleVelocities : public ClassifierDataBaseClassForThreeJoints { public: ClassifierDataUsingAngleVelocities( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex2 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForThreeJoints( jointIndex0, jointIndex1, jointIndex2 ) { #ifdef ADD_TYPE_ANGLE_VELOCITY m_Type = TYPE_ANGLE_VELOCITY; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingAngleVelocities* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingAngleAcceleration // Desc: Classifier data based on the acceleration of the angle between three joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingAngleAcceleration : public ClassifierDataBaseClassForThreeJoints { public: ClassifierDataUsingAngleAcceleration( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex2 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForThreeJoints( jointIndex0, jointIndex1, jointIndex2 ) { #ifdef ADD_TYPE_ANGLE_ACCELERATION m_Type = TYPE_ANGLE_ACCELERATION; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingAngleAcceleration* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleForceX // Desc: Classifier data based on the muscle force in X //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleForceX : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingMuscleForceX( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_FORCES m_Type = TYPE_MUSCLE_FORCE_X; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingMuscleForceX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleForceY // Desc: Classifier data based on the muscle force in Y //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleForceY : public ClassifierDataUsingMuscleForceX { public: ClassifierDataUsingMuscleForceY( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingMuscleForceX( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_FORCES m_Type = TYPE_MUSCLE_FORCE_Y; #endif } virtual ClassifierDataUsingMuscleForceY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleForceZ // Desc: Classifier data based on the muscle force in Z //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleForceZ : public ClassifierDataUsingMuscleForceX { public: ClassifierDataUsingMuscleForceZ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingMuscleForceX( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_FORCES m_Type = TYPE_MUSCLE_FORCE_Z; #endif } virtual ClassifierDataUsingMuscleForceZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleTorqueX // Desc: Classifier data based on the muscle torque in X //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleTorqueX : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingMuscleTorqueX( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_TORQUES m_Type = TYPE_MUSCLE_TORQUE_X; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingMuscleTorqueX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleTorqueY // Desc: Classifier data based on the muscle torque in Y //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleTorqueY : public ClassifierDataUsingMuscleTorqueX { public: ClassifierDataUsingMuscleTorqueY( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingMuscleTorqueX( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_TORQUES m_Type = TYPE_MUSCLE_TORQUE_Y; #endif } virtual ClassifierDataUsingMuscleTorqueY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMuscleTorqueZ // Desc: Classifier data based on the muscle torque in Z //-------------------------------------------------------------------------------------- class ClassifierDataUsingMuscleTorqueZ : public ClassifierDataUsingMuscleTorqueX { public: ClassifierDataUsingMuscleTorqueZ( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataUsingMuscleTorqueX( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_TORQUES m_Type = TYPE_MUSCLE_TORQUE_Z; #endif } virtual ClassifierDataUsingMuscleTorqueZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingMusclePower // Desc: Classifier data based on the muscle power //-------------------------------------------------------------------------------------- class ClassifierDataUsingMusclePower : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingMusclePower( const GESTURE_JOINT_INDEX jointIndex = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForOneJoint( jointIndex ) { #ifdef ADD_TYPE_MUSCLE_POWER m_Type = TYPE_MUSCLE_POWER; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingMusclePower* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffMuscleForceX // Desc: Classifier data based on the differences in muscle force in X between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffMuscleForceX : public ClassifierDataBaseClassForTwoJoints { public: ClassifierDataUsingDiffMuscleForceX( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForTwoJoints( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_X m_Type = TYPE_DIFF_MUSCLE_FORCE_X; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingDiffMuscleForceX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffMuscleForceY // Desc: Classifier data based on the differences in muscle force in Y between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffMuscleForceY : public ClassifierDataUsingDiffMuscleForceX { public: ClassifierDataUsingDiffMuscleForceY( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataUsingDiffMuscleForceX( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_Y m_Type = TYPE_DIFF_MUSCLE_FORCE_Y; #endif } virtual ClassifierDataUsingDiffMuscleForceY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingDiffMuscleForceZ // Desc: Classifier data based on the differences in muscle force in Z between two joints //-------------------------------------------------------------------------------------- class ClassifierDataUsingDiffMuscleForceZ : public ClassifierDataUsingDiffMuscleForceX { public: ClassifierDataUsingDiffMuscleForceZ( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataUsingDiffMuscleForceX( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_DIFF_MUSCLE_FORCE_Z m_Type = TYPE_DIFF_MUSCLE_FORCE_Z; #endif } virtual ClassifierDataUsingDiffMuscleForceZ* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingBoneLengthChanges // Desc: Classifier data based on bone length changes over time //-------------------------------------------------------------------------------------- class ClassifierDataUsingBoneLengthChanges : public ClassifierDataBaseClassForTwoJoints { public: ClassifierDataUsingBoneLengthChanges( const GESTURE_JOINT_INDEX jointIndex0 = GESTURE_JOINT_COUNT, const GESTURE_JOINT_INDEX jointIndex1 = GESTURE_JOINT_COUNT ) : ClassifierDataBaseClassForTwoJoints( jointIndex0, jointIndex1 ) { #ifdef ADD_TYPE_BONE_LENGTH_CHANGES m_Type = TYPE_BONE_LENGTH_CHANGES; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingBoneLengthChanges* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowX // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowX : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingOpticalFlowX( const UINT ij = 0 ) : ClassifierDataBaseClassForOneJoint( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + ij) ) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_X; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowX* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowY // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowY : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingOpticalFlowY( const UINT ij = 0 ) : ClassifierDataBaseClassForOneJoint( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + ij) ) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_Y; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowY* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowLengthSq // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowLengthSq : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingOpticalFlowLengthSq( const UINT i = 3, const UINT j = 3 ) : ClassifierDataBaseClassForOneJoint( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + i+j*3) ) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_LENGTH_SQ; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowLengthSq* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowTangent // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowTangent : public ClassifierDataBaseClassForOneJoint { public: ClassifierDataUsingOpticalFlowTangent( const UINT i = 3, const UINT j = 3 ) : ClassifierDataBaseClassForOneJoint( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + i+j*3) ) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_TANGENT; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowTangent* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowX // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowXDiff : public ClassifierDataBaseClassForTwoJoints { public: ClassifierDataUsingOpticalFlowXDiff( const UINT i = 0, const UINT j = 0 ) : ClassifierDataBaseClassForTwoJoints( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + i) , (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + j)) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_X_DIFF; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowXDiff* Clone(); }; //-------------------------------------------------------------------------------------- // Name: ClassifierDataUsingOpticalFlowY // Desc: Classifier data based on optical flow //-------------------------------------------------------------------------------------- class ClassifierDataUsingOpticalFlowYDiff : public ClassifierDataBaseClassForTwoJoints { public: ClassifierDataUsingOpticalFlowYDiff( const UINT i = 0, const UINT j = 0 ) : ClassifierDataBaseClassForTwoJoints( (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + i) , (GESTURE_JOINT_INDEX)(GESTURE_JOINT_COUNT + j)) { #ifdef ADD_TYPE_OPTICAL_FLOW m_Type = TYPE_OPTICAL_FLOW_Y_DIFF; #endif } virtual VOID Update( const UINT uPlayerIdx, VOID* pData ); virtual ClassifierDataUsingOpticalFlowYDiff* Clone(); }; }