Kinect SDK 1.5 Face Tracking ---> 使用opencv显示后的超级简化版本

最新推荐文章于 2017-07-20 17:13:09 发布
最新推荐文章于 2017-07-20 17:13:09 发布
阅读量6.6k 收藏 8
点赞数
分类专栏： Kinect 文章标签： null image winapi vector float
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoming0000/article/details/7607473
版权

    [2012-10-10]此文章使用的多线程效果很不好，请大家使用微软例子中的waitForMultiObjects方法的内核事件方法。

这二天阅读新的SDK1.5的代码，由于要结合它弄人脸识别问题，所以必须把它的人脸追踪代码研读一下，虽然几经挫折，最终连蒙带猜还是弄出来了。至于怎么用，以及更细节的问题，大家需要自己阅读微软相关文章了。给一个微软相关网站地址点击打开链接。

下面是代码

VS2010+opencv2.3.1+Kinect SDK1.5

驱动什么的，大家自己安装，木有基础的同学先学好基础先。代码是基于我之前更新的SDK1.5基础之上的，如果不太懂，先看之前的文章~

// win32_KinectFaceTracking.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
//----------------------------------------------------
#define  _WINDOWS
#include <FaceTrackLib.h>

HRESULT VisualizeFaceModel(IFTImage* pColorImg, IFTModel* pModel, FT_CAMERA_CONFIG const* pCameraConfig, FLOAT const* pSUCoef, 
	FLOAT zoomFactor, POINT viewOffset, IFTResult* pAAMRlt, UINT32 color);
//----------------------------------------------------
#include <vector>
#include <deque>
#include <iomanip>
#include <stdexcept>
#include <string>
#include <iostream>
#include "opencv2\opencv.hpp"

using namespace std;
using namespace cv;
#include <windows.h>
#include <mmsystem.h>
#include <assert.h>
#include <strsafe.h>
#include "NuiApi.h"
#define COLOR_WIDTH		640
#define COLOR_HIGHT		480
#define DEPTH_WIDTH		320
#define DEPTH_HIGHT		240
#define SKELETON_WIDTH 640
#define SKELETON_HIGHT 480
#define CHANNEL			3
BYTE buf[DEPTH_WIDTH*DEPTH_HIGHT*CHANNEL];
int drawColor(HANDLE h);
int drawDepth(HANDLE h);
int drawSkeleton();
//---face tracking------------------------------------------
BYTE *colorBuffer,*depthBuffer;
IFTImage* pColorFrame;
IFTImage* pDepthFrame;
FT_VECTOR3D m_hint3D[2];
//-----------------------------------------------------------------------------------
HANDLE h1;
HANDLE h3;
HANDLE h5;
HANDLE h2;
HANDLE h4;
DWORD WINAPI VideoFunc(LPVOID pParam)
{
//	cout<<"video start!"<<endl;
	while(TRUE)
	{
		if(WaitForSingleObject(h1,INFINITE)==WAIT_OBJECT_0)
		{
			drawColor(h2);

		}
		//	Sleep(10);
//		cout<<"video"<<endl;
	}

}
DWORD WINAPI DepthFunc(LPVOID pParam)
{

//	cout<<"depth start!"<<endl;
	while(TRUE)
	{
		if(WaitForSingleObject(h3,INFINITE)==WAIT_OBJECT_0)
		{
			drawDepth(h4);	

		}
		//	Sleep(10);
//		cout<<"depth"<<endl;
	}
}
DWORD WINAPI SkeletonFunc(LPVOID pParam)
{
	//	HANDLE h = (HANDLE)pParam;
//	cout<<"skeleton start!"<<endl;
	while(TRUE)
	{
		if(WaitForSingleObject(h3,INFINITE)==WAIT_OBJECT_0)
			drawSkeleton();

		//	Sleep(10);
//		cout<<"skeleton"<<endl;
	}
}
DWORD WINAPI TrackFace(LPVOID pParam)
{
	cout<<"track face start !"<<endl;
	while(TRUE)
	{
		//do something

		Sleep(16);
		cout<<"track face"<<endl;
	}

}
//-----------------------------------------------------------------------------------
int drawColor(HANDLE h)
{
	const NUI_IMAGE_FRAME * pImageFrame = NULL;
	HRESULT hr = NuiImageStreamGetNextFrame( h, 0, &pImageFrame );
	if( FAILED( hr ) )
	{
		cout<<"Get Color Image Frame Failed"<<endl;
		return -1;
	}
	INuiFrameTexture * pTexture = pImageFrame->pFrameTexture;
	NUI_LOCKED_RECT LockedRect;
	pTexture->LockRect( 0, &LockedRect, NULL, 0 );
	if( LockedRect.Pitch != 0 )
	{
		BYTE * pBuffer = (BYTE*) LockedRect.pBits;
		colorBuffer	=	pBuffer;
		memcpy(pColorFrame->GetBuffer(), PBYTE(LockedRect.pBits), min(pColorFrame->GetBufferSize(), UINT(pTexture->BufferLen())));

		Mat temp(COLOR_HIGHT,COLOR_WIDTH,CV_8UC4,pBuffer);
		imshow("b",temp);
		waitKey(1);
	}
	NuiImageStreamReleaseFrame( h, pImageFrame );
	return 0;
}

int drawDepth(HANDLE h)
{
	const NUI_IMAGE_FRAME * pImageFrame = NULL;
	HRESULT hr = NuiImageStreamGetNextFrame( h, 0, &pImageFrame );
	if( FAILED( hr ) )
	{
		cout<<"Get Depth Image Frame Failed"<<endl;
		return -1;
	}
	INuiFrameTexture * pTexture = pImageFrame->pFrameTexture;
	NUI_LOCKED_RECT LockedRect;
	pTexture->LockRect( 0, &LockedRect, NULL, 0 );
	if( LockedRect.Pitch != 0 )
	{
		USHORT * pBuff = (USHORT*) LockedRect.pBits;
//		depthBuffer = pBuff;
		memcpy(pDepthFrame->GetBuffer(), PBYTE(LockedRect.pBits), min(pDepthFrame->GetBufferSize(), UINT(pTexture->BufferLen())));

		for(int i=0;i<DEPTH_WIDTH*DEPTH_HIGHT;i++)
		{
			BYTE index = pBuff[i]&0x07;
			USHORT realDepth = (pBuff[i]&0xFFF8)>>3;
			BYTE scale = 255 - (BYTE)(256*realDepth/0x0fff);
			buf[CHANNEL*i] = buf[CHANNEL*i+1] = buf[CHANNEL*i+2] = 0;
			switch( index )
			{
			case 0:
				buf[CHANNEL*i]=scale/2;
				buf[CHANNEL*i+1]=scale/2;
				buf[CHANNEL*i+2]=scale/2;
				break;
			case 1:
				buf[CHANNEL*i]=scale;
				break;
			case 2:
				buf[CHANNEL*i+1]=scale;
				break;
			case 3:
				buf[CHANNEL*i+2]=scale;
				break;
			case 4:
				buf[CHANNEL*i]=scale;
				buf[CHANNEL*i+1]=scale;
				break;
			case 5:
				buf[CHANNEL*i]=scale;
				buf[CHANNEL*i+2]=scale;
				break;
			case 6:
				buf[CHANNEL*i+1]=scale;
				buf[CHANNEL*i+2]=scale;
				break;
			case 7:
				buf[CHANNEL*i]=255-scale/2;
				buf[CHANNEL*i+1]=255-scale/2;
				buf[CHANNEL*i+2]=255-scale/2;
				break;
			}
		}
		Mat b(DEPTH_HIGHT,DEPTH_WIDTH,CV_8UC3,buf);
		imshow("depth",b);
		waitKey(1);
	}
	NuiImageStreamReleaseFrame( h, pImageFrame );
	return 0;
}

int drawSkeleton()
{
	NUI_SKELETON_FRAME SkeletonFrame;
	cv::Point pt[20];
	Mat skeletonMat=Mat(SKELETON_HIGHT,SKELETON_WIDTH,CV_8UC3,Scalar(0,0,0));
	HRESULT hr = NuiSkeletonGetNextFrame( 0, &SkeletonFrame );
	if( FAILED( hr ) )
	{
		cout<<"Get Skeleton Image Frame Failed"<<endl;
		return -1;
	}
	bool bFoundSkeleton = false;
	for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
	{
		if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
		{
			bFoundSkeleton = true;
		}
	}
	// Has skeletons!
	if( bFoundSkeleton )
	{
		NuiTransformSmooth(&SkeletonFrame,NULL);
		for( int i = 0 ; i < NUI_SKELETON_COUNT ; i++ )
		{
			if( SkeletonFrame.SkeletonData[i].eTrackingState == NUI_SKELETON_TRACKED )
			{
				for (int j = 0; j < NUI_SKELETON_POSITION_COUNT; j++)
				{
					float fx,fy;
					NuiTransformSkeletonToDepthImage( SkeletonFrame.SkeletonData[i].SkeletonPositions[j], &fx, &fy );
					pt[j].x = (int) ( fx * SKELETON_WIDTH )/320;
					pt[j].y = (int) ( fy * SKELETON_HIGHT )/240;
					circle(skeletonMat,pt[j],5,CV_RGB(255,0,0));
				}
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HEAD],pt[NUI_SKELETON_POSITION_SHOULDER_CENTER],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_SHOULDER_CENTER],pt[NUI_SKELETON_POSITION_SPINE],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_SPINE],pt[NUI_SKELETON_POSITION_HIP_CENTER],CV_RGB(0,255,0));

				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HAND_RIGHT],pt[NUI_SKELETON_POSITION_WRIST_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_WRIST_RIGHT],pt[NUI_SKELETON_POSITION_ELBOW_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_ELBOW_RIGHT],pt[NUI_SKELETON_POSITION_SHOULDER_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_SHOULDER_RIGHT],pt[NUI_SKELETON_POSITION_SHOULDER_CENTER],CV_RGB(0,255,0));

				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_SHOULDER_CENTER],pt[NUI_SKELETON_POSITION_SHOULDER_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_SHOULDER_LEFT],pt[NUI_SKELETON_POSITION_ELBOW_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_ELBOW_LEFT],pt[NUI_SKELETON_POSITION_WRIST_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_WRIST_LEFT],pt[NUI_SKELETON_POSITION_HAND_LEFT],CV_RGB(0,255,0));

				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HIP_CENTER],pt[NUI_SKELETON_POSITION_HIP_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HIP_RIGHT],pt[NUI_SKELETON_POSITION_KNEE_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_KNEE_RIGHT],pt[NUI_SKELETON_POSITION_ANKLE_RIGHT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_ANKLE_RIGHT],pt[NUI_SKELETON_POSITION_FOOT_RIGHT],CV_RGB(0,255,0));

				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HIP_CENTER],pt[NUI_SKELETON_POSITION_HIP_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_HIP_LEFT],pt[NUI_SKELETON_POSITION_KNEE_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_KNEE_LEFT],pt[NUI_SKELETON_POSITION_ANKLE_LEFT],CV_RGB(0,255,0));
				cv::line(skeletonMat,pt[NUI_SKELETON_POSITION_ANKLE_LEFT],pt[NUI_SKELETON_POSITION_FOOT_LEFT],CV_RGB(0,255,0));
				m_hint3D[0].x=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].x;
				m_hint3D[0].y=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].y;
				m_hint3D[0].z=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_SHOULDER_CENTER].z;
				m_hint3D[1].x=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].x;
				m_hint3D[1].y=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].y;
				m_hint3D[1].z=SkeletonFrame.SkeletonData[i].SkeletonPositions[NUI_SKELETON_POSITION_HEAD].z;
			}
		}
	}
	imshow("skeleton",skeletonMat);
	waitKey(1);
	return 0;
}

int main(int argc,char * argv[])
{

	//初始化NUI
	HRESULT hr = NuiInitialize(NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX|NUI_INITIALIZE_FLAG_USES_COLOR|NUI_INITIALIZE_FLAG_USES_SKELETON);
	if( hr != S_OK )
	{
		cout<<"NuiInitialize failed"<<endl;
		return hr;
	}
	//打开KINECT设备的彩色图信息通道
	h1 = CreateEvent( NULL, TRUE, FALSE, NULL );
	h2 = NULL;
	hr = NuiImageStreamOpen(NUI_IMAGE_TYPE_COLOR,NUI_IMAGE_RESOLUTION_640x480, 0, 2, h1, &h2);
	if( FAILED( hr ) )
	{
		cout<<"Could not open image stream video"<<endl;
		return hr;
	}
	h3 = CreateEvent( NULL, TRUE, FALSE, NULL );
	h4 = NULL;
	hr = NuiImageStreamOpen( NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX, NUI_IMAGE_RESOLUTION_320x240, 0, 2, h3, &h4);
	if( FAILED( hr ) )
	{
		cout<<"Could not open depth stream video"<<endl;
		return hr;
	}
	h5 = CreateEvent( NULL, TRUE, FALSE, NULL );
	hr = NuiSkeletonTrackingEnable( h5, 0 );
	if( FAILED( hr ) )
	{
		cout<<"Could not open skeleton stream video"<<endl;
		return hr;
	}
	HANDLE hThread1,hThread2,hThread3;
	hThread1 = CreateThread(NULL,0,VideoFunc,h2,0,NULL);
	hThread2 = CreateThread(NULL,0,DepthFunc,h4,0,NULL);
	hThread3 = CreateThread(NULL,0,SkeletonFunc,NULL,0,NULL);


	m_hint3D[0] = FT_VECTOR3D(0, 0, 0);
	m_hint3D[1] = FT_VECTOR3D(0, 0, 0);

	pColorFrame = FTCreateImage();
	pDepthFrame = FTCreateImage();
	
	IFTFaceTracker* pFT = FTCreateFaceTracker();
	if(!pFT)
	{
		return -1;// Handle errors
	}

	FT_CAMERA_CONFIG myCameraConfig = {640, 480, NUI_CAMERA_COLOR_NOMINAL_FOCAL_LENGTH_IN_PIXELS}; // width, height, focal length
	FT_CAMERA_CONFIG depthConfig;
	depthConfig.FocalLength = NUI_CAMERA_DEPTH_NOMINAL_FOCAL_LENGTH_IN_PIXELS;
	depthConfig.Width = 320;
	depthConfig.Height = 240;//貌似这里一定要填，而且要填对才行！！

	hr = pFT->Initialize(&myCameraConfig, &depthConfig, NULL, NULL);
	if( FAILED(hr) )
	{
		return -2;// Handle errors
	}
	// Create IFTResult to hold a face tracking result
	IFTResult* pFTResult = NULL;
	hr = pFT->CreateFTResult(&pFTResult);
	if(FAILED(hr))
	{
		return -11;
	}
	// prepare Image and SensorData for 640x480 RGB images

	if(!pColorFrame)
	{
		return -12;// Handle errors
	}
	// Attach assumes that the camera code provided by the application
	// is filling the buffer cameraFrameBuffer
//	pColorFrame->Attach(640, 480, colorBuffer, FTIMAGEFORMAT_UINT8_B8G8R8X8, 640*3);

	hr = pColorFrame->Allocate(640, 480, FTIMAGEFORMAT_UINT8_B8G8R8X8);
	if (FAILED(hr))
	{
		return hr;
	}
	hr = pDepthFrame->Allocate(320, 240, FTIMAGEFORMAT_UINT16_D13P3);
	if (FAILED(hr))
	{
		return hr;
	}
	FT_SENSOR_DATA sensorData;
	sensorData.pVideoFrame = pColorFrame;
	sensorData.pDepthFrame = pDepthFrame;
	sensorData.ZoomFactor = 1.0f;
	POINT point;point.x=0;point.y=0;
	sensorData.ViewOffset = point;

	bool isTracked = false;
	int iFaceTrackTimeCount=0;
	// Track a face
	while ( true )
	{
		// Call your camera method to process IO and fill the camera buffer
	//	cameraObj.ProcessIO(cameraFrameBuffer); // replace with your method
		if(!isTracked)
		{
			hr = pFT->StartTracking(&sensorData, NULL, m_hint3D, pFTResult);
			if(SUCCEEDED(hr) && SUCCEEDED(pFTResult->GetStatus()))
			{
				isTracked = true;
			}
			else
			{
				// Handle errors
				isTracked = false;
			}
		}
		else
		{
			// Continue tracking. It uses a previously known face position,
			// so it is an inexpensive call.
			hr = pFT->ContinueTracking(&sensorData, m_hint3D, pFTResult);
			if(FAILED(hr) || FAILED (pFTResult->GetStatus()))
			{
				// Handle errors
				isTracked = false;
			}
		}
		if(isTracked)
			{printf("被跟踪了！!!!!!!!!!!!!!!\n");
		IFTModel* ftModel;
		HRESULT hr = pFT->GetFaceModel(&ftModel);
		FLOAT* pSU = NULL;
		UINT numSU;
		BOOL suConverged;
		pFT->GetShapeUnits(NULL, &pSU, &numSU, &suConverged);
		 POINT viewOffset = {0, 0};
		hr = VisualizeFaceModel(pColorFrame, ftModel, &myCameraConfig, pSU, 1.0, viewOffset, pFTResult, 0x00FFFF00);
		if(FAILED(hr))
			printf("显示失败！！\n");
		Mat tempMat(COLOR_HIGHT,COLOR_WIDTH,CV_8UC4,pColorFrame->GetBuffer());
		imshow("faceTracking",tempMat);
		waitKey(1);

		}
		 //printf("%d\n",pFTResult->GetStatus());
		// Do something with pFTResult.
		Sleep(16);
		iFaceTrackTimeCount++;
		if(iFaceTrackTimeCount>16*1000)
			break;
		// Terminate on some criteria.
	}
	// Clean up.
	pFTResult->Release();
	pColorFrame->Release();
	pFT->Release();

	CloseHandle(hThread1);
	CloseHandle(hThread2);
	CloseHandle(hThread3);
	Sleep(60000);
	NuiShutdown();
	return 0;
}

HRESULT VisualizeFaceModel(IFTImage* pColorImg, IFTModel* pModel, FT_CAMERA_CONFIG const* pCameraConfig, FLOAT const* pSUCoef, 
	FLOAT zoomFactor, POINT viewOffset, IFTResult* pAAMRlt, UINT32 color)
{
	if (!pColorImg || !pModel || !pCameraConfig || !pSUCoef || !pAAMRlt)
	{
		return E_POINTER;
	}

	HRESULT hr = S_OK;
	UINT vertexCount = pModel->GetVertexCount();
	FT_VECTOR2D* pPts2D = reinterpret_cast<FT_VECTOR2D*>(_malloca(sizeof(FT_VECTOR2D) * vertexCount));
	if (pPts2D)
	{
		FLOAT *pAUs;
		UINT auCount;
		hr = pAAMRlt->GetAUCoefficients(&pAUs, &auCount);
		if (SUCCEEDED(hr))
		{
			FLOAT scale, rotationXYZ[3], translationXYZ[3];
			hr = pAAMRlt->Get3DPose(&scale, rotationXYZ, translationXYZ);
			if (SUCCEEDED(hr))
			{
				hr = pModel->GetProjectedShape(pCameraConfig, zoomFactor, viewOffset, pSUCoef, pModel->GetSUCount(), pAUs, auCount, 
					scale, rotationXYZ, translationXYZ, pPts2D, vertexCount);
				if (SUCCEEDED(hr))
				{
					POINT* p3DMdl   = reinterpret_cast<POINT*>(_malloca(sizeof(POINT) * vertexCount));
					if (p3DMdl)
					{
						for (UINT i = 0; i < vertexCount; ++i)
						{
							p3DMdl[i].x = LONG(pPts2D[i].x + 0.5f);
							p3DMdl[i].y = LONG(pPts2D[i].y + 0.5f);
						}

						FT_TRIANGLE* pTriangles;
						UINT triangleCount;
						hr = pModel->GetTriangles(&pTriangles, &triangleCount);
						if (SUCCEEDED(hr))
						{
							struct EdgeHashTable
							{
								UINT32* pEdges;
								UINT edgesAlloc;

								void Insert(int a, int b) 
								{
									UINT32 v = (min(a, b) << 16) | max(a, b);
									UINT32 index = (v + (v << 8)) * 49157, i;
									for (i = 0; i < edgesAlloc - 1 && pEdges[(index + i) & (edgesAlloc - 1)] && v != pEdges[(index + i) & (edgesAlloc - 1)]; ++i)
									{
									}
									pEdges[(index + i) & (edgesAlloc - 1)] = v;
								}
							} eht;

							eht.edgesAlloc = 1 << UINT(log(2.f * (1 + vertexCount + triangleCount)) / log(2.f));
							eht.pEdges = reinterpret_cast<UINT32*>(_malloca(sizeof(UINT32) * eht.edgesAlloc));
							if (eht.pEdges)
							{
								ZeroMemory(eht.pEdges, sizeof(UINT32) * eht.edgesAlloc);
								for (UINT i = 0; i < triangleCount; ++i)
								{ 
									eht.Insert(pTriangles[i].i, pTriangles[i].j);
									eht.Insert(pTriangles[i].j, pTriangles[i].k);
									eht.Insert(pTriangles[i].k, pTriangles[i].i);
								}
								for (UINT i = 0; i < eht.edgesAlloc; ++i)
								{
									if(eht.pEdges[i] != 0)
									{
										pColorImg->DrawLine(p3DMdl[eht.pEdges[i] >> 16], p3DMdl[eht.pEdges[i] & 0xFFFF], color, 1);
									}
								}
								_freea(eht.pEdges);
							}

							// Render the face rect in magenta
							RECT rectFace;
							hr = pAAMRlt->GetFaceRect(&rectFace);
							if (SUCCEEDED(hr))
							{
								POINT leftTop = {rectFace.left, rectFace.top};
								POINT rightTop = {rectFace.right - 1, rectFace.top};
								POINT leftBottom = {rectFace.left, rectFace.bottom - 1};
								POINT rightBottom = {rectFace.right - 1, rectFace.bottom - 1};
								UINT32 nColor = 0xff00ff;
								SUCCEEDED(hr = pColorImg->DrawLine(leftTop, rightTop, nColor, 1)) &&
									SUCCEEDED(hr = pColorImg->DrawLine(rightTop, rightBottom, nColor, 1)) &&
									SUCCEEDED(hr = pColorImg->DrawLine(rightBottom, leftBottom, nColor, 1)) &&
									SUCCEEDED(hr = pColorImg->DrawLine(leftBottom, leftTop, nColor, 1));
							}
						}

						_freea(p3DMdl); 
					}
					else
					{
						hr = E_OUTOFMEMORY;
					}
				}
			}
		}
		_freea(pPts2D);
	}
	else
	{
		hr = E_OUTOFMEMORY;
	}
	return hr;
}

最后给个图片

免积分下载VS2010项目源码地址~

延陵小明
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
KinectV2 Face Basic
ah,fresh meat
09-08 1676
KinectV2 Face BasicKinectV2 将有关Face的内容分为了两部分：Face Basic & HD face。 这里首先记录Face Basic有关的内容。KinectV2 Face Basic FaceFrameResult face points face bounding box face orientation face properties 代码样例 编码提示Fac
使用OpenCV显示KinectV2数据
延陵小明
06-06 9365
若有问题请去原文链接留言，csdn已经很少上了：http://guoming.me/use-opencv-display-kinectv2-data 这次给大家分享下我自己写的KinectV2的OpenCV项目，可以用于研究KinectV2图像算法的人。项目地址在我的Github页面。另外还有更复杂的OpenCV显示KinectV2人脸追踪的项目，适用于研究人脸追踪Face
OpenCV简化版Mat实现
沧海一帆的专栏
11-24 1575
未来理解OpenCV中的Mat结构，自己写了一个简化版本的Mat。 Mat是个结构体，通常用来保存图片信息，比较难理解的一点是图片信息通常是一个矩阵，以数组形式保存，而这个矩阵和Mat的关系是什么呢？ 经过深入研究发现，Mat结构体中的data就是指向数组的指针。#include<stdio.h> #include<stdlib.h> #include<assert.h> #define uch
OpenCV 使用FaceRecognizer类来进行人脸识别
k
09-19 2万+
还是需要这么做来声明这个变量Ptr<FaceRecognizer> fc 有三种方法可以使用： createEigenFaceRecognizer、createFisherFaceRecognizer、createLBPHFaceRecognizer。训练和识别所需要的均为灰度图，而且图片大小必须完全一样。 也可以用save 和load对已经训练好的数据进行储存和读取。#define _CRT_
[坠露木兰]Kinect Face Tracking SDK[Kinect人脸跟踪]2013-4-10更新
延陵小明
03-11 1万+
Kinect人脸跟踪Kinect Face Tracking SDK 本文持续维护地址：http://52coding.com/kinect-face-tracking 箫鸣琴奏_CPP程序侠 相关资料免费积分下载链接 更新： [2013-4-10]编译程序时遇到xcopy问题（error MSB3073），猪猪猪小航给出了他的解决办法（第4节）。 [2013-3-25]程序源
Kinect SDK1.6+OpenCV2.4.3+VS2010相关配置及代码运行
c20081052的专栏
11-26 1484
初次在VS2010控制台程序下进行工程的kinect配置，运行网上的相关程序实例，获取人脸跟踪深度图，骨架提取
Kinect人脸跟踪Kinect Face Tracking SDK
merryken的专栏
08-12 4850
文章目录 [隐藏] 11.前言 22.人脸跟踪概念 2.1(1)软件硬件配置 2.2(2)face tracking参数 2.3(3)具体技术 2.4(4)函数和结构 2.5(5)人脸跟踪简易流程 33.更多人脸跟踪细节介绍 3.1(1)线程问题 3.2(2)人脸特征点 3.3(3)人脸旋转 44.程序配置与说明 4.1[20
faceTracking 的一些资源
poinsettia的专栏
07-15 2116
1.http://www.cvchina.info/2012/05/25/kinect-face-tracking/：提供了 AAM revisited，AAM based face tracking with temporal matching and face segmentation和ICP的链接 After a long journey, my team at Microsoft
AI-图书馆（一）
ailib的博客
07-20 2652
AI、计算机视觉、深度学习知识整理库
Kinect SDK1.5-Face Tracking OpenCV简化版
05-27
使用OpenCV简化人脸跟踪后的显示，大大简化了KinectSDK1.5例子，需要人脸检测和人脸识别的可以看看。 更多可以参考博客http://blog.csdn.net/guoming0000/article/details/7607473
Kinect Face Tracking SDK[Kinect人脸跟踪]
03-11
Kinect Face Tracking SDK[Kinect人脸跟踪],Kinect SDK1.6,OpenCV 显示。相关文章http://blog.csdn.net/guoming0000/article/details/8658580
kinect_face_tracking
02-08
标题“kinect_face_tracking”指的是基于微软Kinect设备的一个演示项目，主要功能是实现人脸识别与追踪。这个项目可能由初学者开发，目的是学习和实践如何使用Kinect进行面部识别技术。 Kinect是一款由微软推出的...
emgucv+kinect2.0sdk+vs2015人脸跟踪c#程序
09-09
标题中的“emgucv+kinect2.0sdk+vs2015人脸跟踪c#程序”揭示了这个项目的核心技术栈，涉及到的主要知识点包括： 1. **EmguCV**：Emgu CV是开源计算机视觉库OpenCV的.NET封装，它提供了C#、VB.NET、IronPython等多种...
Kinect For Windows SDK 2.0的解读之《KinectV2开发手册》
热门推荐
延陵小明
12-09 2万+
转载自 自己的博客，由于百度迟迟没有收录，在这里转发。 Kinect For Windows SDK 2.0的解读之一《开发手册》 这二天在外面出差，回来才发现26号早晨微软已经通知我可以下载最新的SDK了！今天，11-27终于回到上海，趁着夜色，我将这次SDK中描述的主要内容翻译一下给大家看看。截止目前为止，还未看到互联网上有人分享相关内容文章。那就由我先给大家抛砖引玉吧
Kinect V2深度数据用OpenCV显示
延陵小明
10-20 9706
持续维护地址：http://guoming.me/kinect2-depth-opencv 这次带来深度数据的显示，
Kinect人脸识别系统—开发历程
延陵小明
06-25 7909
除非比较重要的文章，其他小文章都放在52coding.com上了。此文属于，吐槽文章。 持续维护地址： http://52coding.com/kinect-face-recognition-development 本篇文章主要讲的是开发者的切身经历，如果你正在弄Kinect或者做系统，又或者曾经做过一段时间，或许会有所共鸣。如果要了解系统中使用的一些算法，我已经做了多篇博客，你可以很
初次使用Kinect体感，并用OpenCV显示彩色景深骨骼图
延陵小明
12-01 6539
1.     安装Kinect驱动 安装驱动前，看下右侧的Installation instructions，这里简单翻译下： 体感不要连在电脑上 如果以前装了Kinect SDK要卸载它 关闭Visual Studio2010 http://www.kinectforwindows.org/download/ 根据硬件平台选择要装的驱动(64bit安装64bit驱动,32bit安装3
kinect v2 examples with ms-sdk
最新发布
06-06
在使用Kinect v2和MS-SDK进行开发时，可以参考一些示例代码，这些示例代码可以帮助开发者更好地理解Kinect v2的工作原理，以及如何使用MS-SDK进行开发。例如，可以参考Kinect v2官方提供的示例代码，其中包括了基本...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值