使用kinect2.0做动作识别和动作计数

已于 2022-02-25 10:52:53 修改
阅读量5.9k 收藏 62
点赞数 2
分类专栏： 人工智能 运动识别 文章标签： 运动识别 动作识别 动作计数
于 2021-01-06 14:05:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Enigma_tong/article/details/112260855
版权

利用kinect2结构光相机进行运动动作识别和运动计数，不仅可以测量运动人员的卡路里，也可以测出运动速度和做功，并对于运动的动作做出科学规范的指导。

这里我们选用kinect2和windows系统作为开发工具来进行开发。如果要进行运动动作的识别，第一步需要对于采集运动的信息，比如人体的骨骼关键点信息，这里我们以手为采集对象，同时判断手是否有抓握杆的行为来进行运动的信息采集。同时我们这里以深蹲作为示范，举例如何进行运动动作的判定和计数。
人体关键点的效果如图所示
在这里插入图片描述

通过kinect2提供的接口，我们可以获取到人体各个骨骼关节点的三维信息

这里我把windows下获取人体骨骼关节点的信息的代码放在这里

//这里是.h文件
#ifndef __APP__
#define __APP__

#include <Windows.h>
#include <Kinect.h>
#include <opencv2/opencv.hpp>

#include <vector>
#include <array>

#include <wrl/client.h>
using namespace Microsoft::WRL;

class Kinect
{
private:
    // Sensor
    ComPtr<IKinectSensor> kinect;

    // Coordinate Mapper
    ComPtr<ICoordinateMapper> coordinateMapper;

    // Reader
    ComPtr<IColorFrameReader> colorFrameReader;
    ComPtr<IBodyFrameReader> bodyFrameReader;

    // Color Buffer
    std::vector<BYTE> colorBuffer;
    int colorWidth;
    int colorHeight;
    unsigned int colorBytesPerPixel;
    cv::Mat colorMat;

    // Body Buffer
    std::array<IBody*, BODY_COUNT> bodies = { nullptr };
    std::array<cv::Vec3b, BODY_COUNT> colors;

public:
    // Constructor
    Kinect();

    // Destructor
    ~Kinect();

    // Processing
    void run();

private:
    // Initialize
    void initialize();

    // Initialize Sensor
    inline void initializeSensor();

    // Initialize Color
    inline void initializeColor();

    // Initialize Body
    inline void initializeBody();

    // Finalize
    void finalize();

    // Update Data
    void update();

    // Update Color
    inline void updateColor();

    // Update Body
    inline void updateBody();

    // Draw Data
    void draw();

    // Draw Color
    inline void drawColor();

    // Draw Body
    inline void drawBody();

    // Draw Circle
    inline void drawEllipse( cv::Mat& image, const Joint& joint, const int radius, const cv::Vec3b& color, const int thickness = -1 );

    // Draw Hand State
    inline void drawHandState( cv::Mat& image, const Joint& joint, HandState handState, TrackingConfidence handConfidence );

    // Show Data
    void show();

    // Show Body
    inline void showBody();
};

#endif // __APP__

//这里是cpp文件
#include "app.h"
#include "util.h"

#include <thread>
#include <chrono>

#include <ppl.h>

// Constructor
Kinect::Kinect()
{
    // Initialize
    initialize();
}

// Destructor
Kinect::~Kinect()
{
    // Finalize
    finalize();
}

// Processing
void Kinect::run()
{
    // Main Loop
    while( true ){
        // Update Data
        update();

        // Draw Data
        draw();

        // Show Data
        show();

        // Key Check
        const int key = cv::waitKey( 10 );
        if( key == VK_ESCAPE ){
            break;
        }
    }
}

// Initialize
void Kinect::initialize()
{
    cv::setUseOptimized( true );

    // Initialize Sensor
    initializeSensor();

    // Initialize Color
    initializeColor();

    // Initialize Body
    initializeBody();

    // Wait a Few Seconds until begins to Retrieve Data from Sensor ( about 2000-[ms] )
    std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
}

// Initialize Sensor
inline void Kinect::initializeSensor()
{
    // Open Sensor
    ERROR_CHECK( GetDefaultKinectSensor( &kinect ) );

    ERROR_CHECK( kinect->Open() );

    // Check Open
    BOOLEAN isOpen = FALSE;
    ERROR_CHECK( kinect->get_IsOpen( &isOpen ) );
    if( !isOpen ){
        throw std::runtime_error( "failed IKinectSensor::get_IsOpen( &isOpen )" );
    }

    // Retrieve Coordinate Mapper
    ERROR_CHECK( kinect->get_CoordinateMapper( &coordinateMapper ) );
}

// Initialize Color
inline void Kinect::initializeColor()
{
    // Open Color Reader
    ComPtr<IColorFrameSource> colorFrameSource;
    ERROR_CHECK( kinect->get_ColorFrameSource( &colorFrameSource ) );
    ERROR_CHECK( colorFrameSource->OpenReader( &colorFrameReader ) );

    // Retrieve Color Description
    ComPtr<IFrameDescription> colorFrameDescription;
    ERROR_CHECK( colorFrameSource->CreateFrameDescription( ColorImageFormat::ColorImageFormat_Bgra, &colorFrameDescription ) );
    ERROR_CHECK( colorFrameDescription->get_Width( &colorWidth ) ); // 1920
    ERROR_CHECK( colorFrameDescription->get_Height( &colorHeight ) ); // 1080
    ERROR_CHECK( colorFrameDescription->get_BytesPerPixel( &colorBytesPerPixel ) ); // 4

    // Allocation Color Buffer
    colorBuffer.resize( colorWidth * colorHeight * colorBytesPerPixel );
}

// Initialize Body
inline void Kinect::initializeBody()
{
    // Open Body Reader
    ComPtr<IBodyFrameSource> bodyFrameSource;
    ERROR_CHECK( kinect->get_BodyFrameSource( &bodyFrameSource ) );
    ERROR_CHECK( bodyFrameSource->OpenReader( &bodyFrameReader ) );

    // Initialize Body Buffer
    Concurrency::parallel_for_each( bodies.begin(), bodies.end(), []( IBody*& body ){
        SafeRelease( body );
    } );

    // Color Table for Visualization
    colors[0] = cv::Vec3b( 255,   0,   0 ); // Blue
    colors[1] = cv::Vec3b(   0, 255,   0 ); // Green
    colors[2] = cv::Vec3b(   0,   0, 255 ); // Red
    colors[3] = cv::Vec3b( 255, 255,   0 ); // Cyan
    colors[4] = cv::Vec3b( 255,   0, 255 ); // Magenta
    colors[5] = cv::Vec3b(   0, 255, 255 ); // Yellow
}

// Finalize
void Kinect::finalize()
{
    cv::destroyAllWindows();

    // Release Body Buffer
    Concurrency::parallel_for_each( bodies.begin(), bodies.end(), []( IBody*& body ){
        SafeRelease( body );
    } );

    // Close Sensor
    if( kinect != nullptr ){
        kinect->Close();
    }
}

// Update Data
void Kinect::update()
{
    // Update Color
    updateColor();

    // Update Body
    updateBody();
}

// Update Color
inline void Kinect::updateColor()
{
    // Retrieve Color Frame
    ComPtr<IColorFrame> colorFrame;
    const HRESULT ret = colorFrameReader->AcquireLatestFrame( &colorFrame );
    if( FAILED( ret ) ){
        return;
    }

    // Convert Format ( YUY2 -> BGRA )
    ERROR_CHECK( colorFrame->CopyConvertedFrameDataToArray( static_cast<UINT>( colorBuffer.size() ), &colorBuffer[0], ColorImageFormat::ColorImageFormat_Bgra ) );
}

// Update Body
inline void Kinect::updateBody()
{
    // Retrieve Body Frame
    ComPtr<IBodyFrame> bodyFrame;
    const HRESULT ret = bodyFrameReader->AcquireLatestFrame( &bodyFrame );
    if( FAILED( ret ) ){
        return;
    }

    // Release Previous Bodies
    Concurrency::parallel_for_each( bodies.begin(), bodies.end(), []( IBody*& body ){
        SafeRelease( body );
    } );

    // Retrieve Body Data
    ERROR_CHECK( bodyFrame->GetAndRefreshBodyData( static_cast<UINT>( bodies.size() ), &bodies[0] ) );
}

// Draw Datax
void Kinect::draw()
{
    // Draw Color
    drawColor();

    // Draw Body
    drawBody();
}

// Draw Color
inline void Kinect::drawColor()
{
    // Create cv::Mat from Color Buffer
    colorMat = cv::Mat( colorHeight, colorWidth, CV_8UC4, &colorBuffer[0] );
}

// Draw Body
inline void Kinect::drawBody()
{
    // Draw Body Data to Color Data
    Concurrency::parallel_for( 0, BODY_COUNT, [&]( const int count ){
        const ComPtr<IBody> body = bodies[count];
        if( body == nullptr ){
            return;
        }

        // Check Body Tracked
        BOOLEAN tracked = FALSE;
        ERROR_CHECK( body->get_IsTracked( &tracked ) );
        if( !tracked ){
            return;
        }

        // Retrieve Joints
        std::array<Joint, JointType::JointType_Count> joints;
        ERROR_CHECK( body->GetJoints( static_cast<UINT>( joints.size() ), &joints[0] ) );

        Concurrency::parallel_for_each( joints.begin(), joints.end(), [&]( const Joint& joint ){
            // Check Joint Tracked
            if( joint.TrackingState == TrackingState::TrackingState_NotTracked ){
                return;
            }

            // Draw Joint Position
            drawEllipse( colorMat, joint, 5, colors[count] );

            // Draw Left Hand State
            if( joint.JointType == JointType::JointType_HandLeft ){
                HandState handState;
                TrackingConfidence handConfidence;
                ERROR_CHECK( body->get_HandLeftState( &handState ) );
                ERROR_CHECK( body->get_HandLeftConfidence( &handConfidence ) );

                drawHandState( colorMat, joint, handState, handConfidence );
            }

            // Draw Right Hand State
            if( joint.JointType == JointType::JointType_HandRight ){
                HandState handState;
                TrackingConfidence handConfidence;
                ERROR_CHECK( body->get_HandRightState( &handState ) );
                ERROR_CHECK( body->get_HandRightConfidence( &handConfidence ) );

                drawHandState( colorMat, joint, handState, handConfidence );
            }
        } );

        /*
        // Retrieve Joint Orientations
        std::array<JointOrientation, JointType::JointType_Count> orientations;
        ERROR_CHECK( body->GetJointOrientations( JointType::JointType_Count, &orientations[0] ) );
        */

        /*
        // Retrieve Amount of Body Lean
        PointF amount;
        ERROR_CHECK( body->get_Lean( &amount ) );
        */
    } );
}

// Draw Ellipse
inline void Kinect::drawEllipse( cv::Mat& image, const Joint& joint, const int radius, const cv::Vec3b& color, const int thickness )
{
    if( image.empty() ){
        return;
    }

    // Convert Coordinate System and Draw Joint
    ColorSpacePoint colorSpacePoint;
    ERROR_CHECK( coordinateMapper->MapCameraPointToColorSpace( joint.Position, &colorSpacePoint ) );
    const int x = static_cast<int>( colorSpacePoint.X + 0.5f );
    const int y = static_cast<int>( colorSpacePoint.Y + 0.5f );
    if( ( 0 <= x ) && ( x < image.cols ) && ( 0 <= y ) && ( y < image.rows ) ){
        cv::circle( image, cv::Point( x, y ), radius, static_cast<cv::Scalar>( color ), thickness, cv::LINE_AA );
    }
}

// Draw Hand State
inline void Kinect::drawHandState( cv::Mat& image, const Joint& joint, HandState handState, TrackingConfidence handConfidence )
{
    if( image.empty() ){
        return;
    }

    // Check Tracking Confidence
    if( handConfidence != TrackingConfidence::TrackingConfidence_High ){
        return;
    }

    // Draw Hand State 
    const int radius = 75;
    const cv::Vec3b blue = cv::Vec3b( 128, 0, 0 ), green = cv::Vec3b( 0, 128, 0 ), red = cv::Vec3b( 0, 0, 128 );
    switch( handState ){
        // Open
        case HandState::HandState_Open:
            drawEllipse( image, joint, radius, green, 5 );
            break;
        // Close
        case HandState::HandState_Closed:
            drawEllipse( image, joint, radius, red, 5 );
            break;
        // Lasso
        case HandState::HandState_Lasso:
            drawEllipse( image, joint, radius, blue, 5 );
            break;
        default:
            break;
    }
}

// Show Data
void Kinect::show()
{
    // Show Body
    showBody();
}

// Show Body
inline void Kinect::showBody()
{
    if( colorMat.empty() ){
        return;
    }

    // Resize Image
    cv::Mat resizeMat;
    const double scale = 0.5;
    cv::resize( colorMat, resizeMat, cv::Size(), scale, scale );

    // Show Image
    cv::imshow( "Body", resizeMat );
}

//main函数
#include <iostream>
#include <sstream>

#include "app.h"

int main( int argc, char* argv[] )
{
    try{
        Kinect kinect;
        kinect.run();
    } catch( std::exception& ex ){
        std::cout << ex.what() << std::endl;
    }

    return 0;
}

//util.h文件
#ifndef __UTIL__
#define __UTIL__

#include <sstream>
#include <stdexcept>

// Error Check Macro
#define ERROR_CHECK( ret )                                        \
    if( FAILED( ret ) ){                                          \
        std::stringstream ss;                                     \
        ss << "failed " #ret " " << std::hex << ret << std::endl; \
        throw std::runtime_error( ss.str().c_str() );             \
    }

// Safe Release
template<class T>
inline void SafeRelease( T*& rel )
{
    if( rel != NULL ){
        rel->Release();
        rel = NULL;
    }
}

// C++ Style Line Types For OpenCV 2.x
#if ( CV_MAJOR_VERSION < 3 )
namespace cv{
	enum LineTypes{
		FILLED  = -1,
		LINE_4  = 4,
		LINE_8  = 8,
		LINE_AA = 16
	};
}
#endif

#endif // __UTIL__

下面我们就以这两份开源代码作为基础的开发版本，演示如何开发智能运动计数和动作识别的代码
首先，我们需要训练一个极快速度的识别模型，用于识别手是否有握杆的行为，这里我们选用caffe版本的squeezeNet作为训练的模型，具体教程网上很多，我们这里就用猫狗分类的模型，具体的地址在这里
超轻量级模型地址
使用这个模型在鉴黄的图片上速度能够达到200fps以上。利用kinect2的手部信息，对于彩色图像进行一定范围的截图，自己采集一些握杆和不握杆的图片，数量大概在6000张左右，正负样本各3000张。整合完成后识别率大概是98%左右。
在这里插入图片描述
通过采集kinect2的手部骨骼关键点信息，同时利用手是否握杆来判定，就可以进行数据的处理了。
需要对于采集到数据进行深度值回归和综合滤波以后，我们把处理过的数据放在json文件中留用，再利用python代码将数据展示出来，如图所示
在这里插入图片描述
这里是我们采集到的20组深蹲的手部骨骼关键点的坐标信息
接下来就是如何计数的问题了，这里我们采用一阶导数和二阶导数相结合的方式，同时利用三次样条插值补足缺失的移动轨迹来进行计数。具体效果如图所示。
在这里插入图片描述
在这里插入图片描述
这样子我们就能对于运动动作进行捕捉了。具体效果可以参考eliteform的使用效果
视频点击
相关产品见舒华8902I速度与力量反馈系统
在这里插入图片描述

点云从入门到精通技术详解100篇-基于三维点云的水果识别与产量估计
getusushu的博客
11-02 603
我国是农业大国，随着人们生活水平的提高，对水果的需求量也越来越大，果实的种植和收获需要大量的时间和人力成本。同时大量重复性劳动对人体伤害较大，容易造成人体背部紧张等健康问题[1]。水果计数是收获过程中一个非常重要的环节，准确的水果计数可以帮助种植者更好地了解种植成果并对劳动力分配、果实存储、包装和运输做出更具成本效益的决策[2]。随着计算机技术和机器人研究的发展，机器视觉在农业方面的应用逐渐展开，包括针对育种方面的植物表型研究、针对收获工作的水果识别和果蔬。
ROS 教程4 机器人视觉识别控制 OpenCV OpenNI2 PCL 2D 3D目标检测 目标跟踪object tracking人体跟踪person followin
万有文的博客
12-08 9326
机器人视觉 一、准备工作 1、开源库： OpenCV, 二维图像处理和机器学习 OpenNI2 +OpenKinect(freenect), 深度传感器(MicrosoftKinect and Asus Xtion Pro)驱动和处理库 PCL. 点云库 处...
基于kinect的人体动作识别系统
09-30
基于kinect v2的人体动作识别，配套博客（http://blog.csdn.net/baolinq/article/），基于mfc，可以识别左移右移、上蹦下跳等，也可以自己自定义其他动作，加一些判定代码即可。使用的时候可能需要自己新建一个工程，为了上传文件小一点，我只上传了主要的代码文件~~
Kinect2.0入门教程(含unity结合)
07-24
包含Kinect2,0的SDK简介以及Kinect2.0与Unity结合简介 以及部分教程
使用两台Kinect2.0和ipi studio进行动作捕捉
k
01-29 1万+
首先需要两台电脑，装上win8以上系统和sdk2.0，因为sdk2.0目前只支持一台电脑接一台Kinect2.0所以需要两台电脑。先说一下两台Kinect的摆放，就是两台Kinect面对面放置，中间距离4-6米左右。需要校准后才能使用。校准的方法后面会说。然后打开ipi Recorder 选择Kinect2 For Windows ，点击Record Video。 先要保存一下背景，这里要求中间不
Kinect2.0 使用
会飞的小鸡的博客
03-20 3009
安装 CPU安装过程 http://www.cnblogs.com/hitcm/p/5118196.html 卸载方法 http://www.cnblogs.com/li-yao7758258/p/7445429.html GPU安装过程 https://www.cnblogs.com/kunyuanjushi/p/5204436.html https://blog.csdn.net/my...
kinect2.0sdk的安装与配置
k
07-01 1万+
在你准备做kinect开发前一定要先注意自己的配置再去购买kinect2.0 免得以后麻烦   kinect2.0 对windows要求在这 Supported Operating System Embedded 8 Standard, Windows 8, Windows 8.1 Recommended Hardware Configuration
Kinect2.0之使用KinectSDK自带的KinectStudio进行数据采集
csuzhaoqinghui的博客
11-29 9148
去年一直摆弄Kinect2.0，发现二代Kinect和一代存在差别较大，采集程序也大致不一样了。 在这里我主要是介绍两种采集方法，一种是基于KinectSDK驱动直接采集的，能够采集到深度图和彩色图。第二种是采用OPENNI2间接驱动KinectSDK进行采集，能够采集到ONI格式的视频。这篇博文我主要介绍怎么采用KinectSDK Studio分别采集RGB信息和深度信息。
Kinect SDK(1)：读取彩色、深度、骨骼信息并用OpenCV显示
热门推荐
小熊不去实验室
11-16 1万+
K4W SDK 读取彩色、深度、骨骼信息并用OpenCV显示
【Kinect for Windows SDK快速入门】：一步到位的开发环境配置
本文全面介绍Kinect for Windows SDK的应用与实践，涵盖从开发环境搭建、深度感知技术基础、传感器数据处理到应用优化与故障排除。通过详细探讨Kinect的硬件要求、SDK安装与配置，以及开发工具的集
Kinect2.0API
04-22
Kinect2.0 API文档。 在开发的时候要注意Kinect1.0和Kinect2.0的SDK是不一样的，Kinect1.0的SDK不能驱动Kinect2.0的机器，同时Kinect1.0的API和Kinect2.0的API也有较大的不同，注意区别。
kinect 2.0 for Unity开发包
02-01
Unity Asset Store上的Kinect v2.0开发包，亲测可用，里面包含三个场景，1、追踪动作，2、滑动相册，3、手势识别。
使用Kinect深度图像的静态人体动作识别
05-25
为解决传统的使用视频彩色图像序列的智能监控容易受光照、颜色等因素影响的问题,提出结合Kinect深度图像和支持向量机的人体动作识别方法.利用Kinect在监控区域获得实时深度图像,并进行背景擦除,滤波处理和提取Haar特征.通过使用支持向量机的分类算法生成分类器,并对一组特定的静态动作识别结果进行分析.研究结果表明:使用深度图像对于静态动作有较好的识别率,并且与传统的基于彩色图像的智能监控相比,该方法不仅对于光照、颜色等因素不敏感,而且在识别的准确率和效率上均有提升.
【OpenCV基础】掌握Mat数据结构和操作
!...# 1. OpenCV与Mat数据结构简介 ...Mat类使用一个通用的矩阵表示方法，无论图像的维度如何，都可以使用Mat进行表示。Mat类还提供了一套丰富的函数，用于图像的处理、分析和转换。 ## 1.1 OpenCV简介 OpenCV的
Kinect v2.0实现对采集到的图像实时解算距离和坐标信息，并分析源码及其背后的算法原理---ROS下实现的，用鼠标控制【附github链接，linuxc++源码】
qq_40464599的博客
07-24 6379
Kinect2 v2.0 是一款深度相机，笔者想用它来测量距离信息，是在ROS系统下进行的，用鼠标去点击图片就能显示该位置的物体的距离和坐标相对于相机来说。 首先要知道相机坐标系，Kinect使用以Kinect的IR传感器为中心的直角坐标系。Y轴正指向上方，Z轴正指向Kinect指向的位置，X轴正向左侧。此坐标系中的一个单位等于一米。 ， 为了实现这个功能，资料很少，并且没有给出源码链接，为了避免后面的人走弯路。所以我这里给出了github链接，直接使用就可以。 http...
Kinect for Windows v2.0安装教程
weixin_43499818的博客
12-10 3974
Kinect for Windows v2.0安装教程 根据官方教程，Kinect v2.0支持Windows 8/8.1/10，本教程讲述在Windows 10上的安装。 打开浏览器，百度搜索--Kinect for Windows v2.0，找到官方下载地址，进行下载。 注意：只需要KinectSDK-v2.0_1409-setup.exe 其他软件暂时不需要。 在安装之前，把你的Kinect 设备连到window上，你的usb接口要为usb3.0（蓝色接口或标有ss的接口），右键Win.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值