~~有興趣的小夥伴，加kinect演算法交流群：462964980。

kinect的深度資料和彩色資料的解析度以及視場大小都不一樣，不能直接對應起來，想要把深度和彩色融合起來就要費一番周折了。

看了MSDN中kinectSDK的介紹，發現了一個ICoordinateMapper的類，看介紹知道里面有一個成員函式MapDepthFrameToColorSpace可以實現深度圖和彩色圖的座標校準，於

想試試看，結果轉到定義處才發現這個成員函式是純虛擬函式！！白高興一場了，想了想也沒有找到一個合適的方法來更好的實現，於是就想手動校準好了。

接下來就是先用規則的長方體來測一下在深度圖和彩色圖中的同一邊長的比例，為了測量更加準確，就把深度圖同一時間的深度圖和彩色圖給截圖下來，然後通過matlab來實現座標顯示，來得到同一位置長方體的同一邊長，通過求幾組資料的平均得到深度圖和彩色圖的比例，這樣，在使用opencv的resize函式便將深度圖和彩色圖的比例調整為1：1了。最後通過將同一點在深度圖和彩色圖中的座標關係來將兩種圖的座標關係對應好，這樣便實現了座標的對應，通過opencv的ROI來將兩幅圖重合的部分裁剪下來，並且在同一幅畫面中顯示。

下面是一個效果圖：

1. /*****    Measurement of height by kinect            ******/
2. /*****    VisualStudio 2012 (開發工具) 
3.           OpenCV2.4.8 (顯示介面庫 vc11庫) 
4.           KinectSDK-v2.0-PublicPreview1409-Setup (Kinect SDK驅動版本) 
5.           Windows 8.1 (作業系統)                   ******/
6. /*****    shihz                                    ******/
7. /*****    2015-2-7                                ******/
8. #include"stdafx.h"
9. #include "opencv2/opencv.hpp"
10. #define Y 160
11. usingnamespace cv;  
12. // Safe release for interfaces
13. template<class Interface>  
14. inlinevoid SafeRelease(Interface *& pInterfaceToRelease)  
15. {  
16.     if (pInterfaceToRelease != NULL)  
17.     {  
18.         pInterfaceToRelease->Release();  
19.         pInterfaceToRelease = NULL;  
20.     }  
21. }  
22. //定義Kinect方法類
23. class Kinect  
24. {    
25. public:  
26.     staticconstint        cDepthWidth  = 512;   //深度圖的大小
27.     staticconstint        cDepthHeight = 424;  
28.     staticconstint        cColorWidth  = 1920;   //彩色圖的大小
29.     staticconstint        cColorHeight = 1080;  
30.     Mat showImageDepth;  
31.     HRESULT                 InitKinect();//初始化Kinect
32.     void                    UpdateDepth();//更新深度資料
33.     void                    UpdateColor();//更新深度資料
34.     void                    ProcessDepth(const UINT16* pBuffer, int nWidth, int nHeight, USHORT nMinDepth, USHORT nMaxDepth);   //處理得到的深度圖資料
35.     void                    ProcessColor(RGBQUAD* pBuffer, int nWidth, int nHeight);   //處理得到的彩色圖資料
36.     Kinect();                                     //建構函式
37.     ~Kinect();                                     //解構函式
38. private:  
39.     IKinectSensor*          m_pKinectSensor;// Current Kinect
40.     IDepthFrameReader*      m_pDepthFrameReader;// Depth reader    在需要的時候可以再新增IColorFrameReader,進行color reader
41.     RGBQUAD*                m_pDepthRGBX;          
42.     IColorFrameReader*      m_pColorFrameReader;// Color reader
43.     RGBQUAD*                m_pColorRGBX;  
44. };  
45. int main()  
46. {  
47.     Kinect kinect;  
48.     Mat showImageColor;  
49.     kinect.InitKinect();  
50.     while(1)  
51.         {  
52.            kinect.UpdateColor();                          //程式的中心內容，獲取資料並顯示
53.            kinect.UpdateDepth();  
54.            if(waitKey(1) >= 0)//按下任意鍵退出
55.               {  
56.                  break;                                  
57.                }  
58.          }  
59.     return 0;  
60. }  
61. Kinect::Kinect()  
62. {  
63.     m_pKinectSensor = NULL;  
64.     m_pColorFrameReader = NULL;  
65.     m_pDepthFrameReader = NULL;  
66.     m_pDepthRGBX = new RGBQUAD[cDepthWidth * cDepthHeight];// create heap storage for color pixel data in RGBX format  ，開闢一個動態儲存區域
67.     m_pColorRGBX = new RGBQUAD[cColorWidth * cColorHeight];// create heap storage for color pixel data in RGBX format
68. }  
69. Kinect::~Kinect()                        //定義解構函式
70. {  
71.     if (m_pDepthRGBX)  
72.     {  
73.         delete [] m_pDepthRGBX;            //刪除動態儲存區域
74.         m_pDepthRGBX = NULL;  
75.     }  
76.     SafeRelease(m_pDepthFrameReader);// done with depth frame reader
77.     if (m_pColorRGBX)  
78.     {  
79.         delete [] m_pColorRGBX;  
80.         m_pColorRGBX = NULL;  
81.     }  
82.     SafeRelease(m_pColorFrameReader);// done with color frame reader
83.     if (m_pKinectSensor)  
84.     {  
85.         m_pKinectSensor->Close();// close the Kinect Sensor
86.     }  
87.     SafeRelease(m_pKinectSensor);  
88. }  
89. HRESULT Kinect::InitKinect()            //定義初始化kinect函式
90. {  
91.     HRESULT hr;                           //typedef long HRESULT
92.     hr = GetDefaultKinectSensor(&m_pKinectSensor);      //獲取預設的kinect，一般來說只有用一個kinect，所以預設的也就是唯一的那個
93.     if (FAILED(hr))                                //Failed這個函式的引數小於0的時候返回true else 返回false
94.     {  
95.         return hr;  
96.     }  
97.     if (m_pKinectSensor)  
98.     {  
99.         // Initialize the Kinect and get the depth reader
100.         IDepthFrameSource* pDepthFrameSource = NULL;  
101.         IColorFrameSource* pColorFrameSource = NULL;  
102.         hr = m_pKinectSensor->Open();  
103.         if (SUCCEEDED(hr))  
104.         {  
105.             hr = m_pKinectSensor->get_ColorFrameSource(&pColorFrameSource);  
106.             hr = m_pKinectSensor->get_DepthFrameSource(&pDepthFrameSource);  
107.         }  
108.         if (SUCCEEDED(hr))  
109.         {  
110.             hr = pColorFrameSource->OpenReader(&m_pColorFrameReader);  
111.             hr = pDepthFrameSource->OpenReader(&m_pDepthFrameReader);      //初始化Depth reader，傳入該IDepthReader的地址，讓該指標指向深度資料流
112.         }  
113.         SafeRelease(pColorFrameSource);  
114.         SafeRelease(pDepthFrameSource);                                     
115.     }  
116.     if (!m_pKinectSensor || FAILED(hr))  
117.     {  
118.         printf("No ready Kinect found! \n");  
119.         return E_FAIL;  
120.     }  
121.     return hr;  
122. }  
123. void Kinect::UpdateDepth()  
124. {  
125.     if (!m_pDepthFrameReader)  
126.     {  
127.         return;  
128.     }  
129.     IDepthFrame* pDepthFrame = NULL;  
130.     HRESULT hr = m_pDepthFrameReader->AcquireLatestFrame(&pDepthFrame);  
131.     if (SUCCEEDED(hr))  
132.     {  
133.         IFrameDescription* pFrameDescription = NULL;  
134.         int nWidth = 0;  
135.         int nHeight = 0;  
136.         USHORT nDepthMinReliableDistance = 0;  
137.         USHORT nDepthMaxDistance = 0;  
138.         UINT nBufferSize = 0;  
139.         UINT16 *pBuffer = NULL;  
140.         if (SUCCEEDED(hr))  
141.         {  
142.             hr = pDepthFrame->get_FrameDescription(&pFrameDescription);  
143.         }  
144.         if (SUCCEEDED(hr))  
145.         {  
146.             hr = pFrameDescription->get_Width(&nWidth);  
147.         }  
148.         if (SUCCEEDED(hr))  
149.         {  
150.             hr = pFrameDescription->get_Height(&nHeight);  
151.         }  
152.         if (SUCCEEDED(hr))  
153.         {  
154.             hr = pDepthFrame->get_DepthMinReliableDistance(&nDepthMinReliableDistance);  
155.         }  
156.         if (SUCCEEDED(hr))  
157.         {  
158.             // In order to see the full range of depth (including the less reliable far field depth)
159.             // we are setting nDepthMaxDistance to the extreme potential depth threshold
160.             nDepthMaxDistance = USHRT_MAX;  
161.             // Note:  If you wish to filter by reliable depth distance, uncomment the following line.
162.             // hr = pDepthFrame->get_DepthMaxReliableDistance(&nDepthMaxDistance);
163.         }  
164.         if (SUCCEEDED(hr))  
165.         {  
166.             hr = pDepthFrame->AccessUnderlyingBuffer(&nBufferSize, &pBuffer);              
167.         }  
168.         if (SUCCEEDED(hr))  
169.         {  
170.             ProcessDepth( pBuffer, nWidth, nHeight, nDepthMinReliableDistance, nDepthMaxDistance);  
171.         }  
172.         SafeRelease(pFrameDescription);  
173.     }  
174.     SafeRelease(pDepthFrame);  
175. }  
176. void Kinect::UpdateColor()  
177. {  
178.     if (!m_pColorFrameReader)  
179.     {  
180.         return;  
181.     }  
182.     IColorFrame* pColorFrame = NULL;  
183.     HRESULT hr = m_pColorFrameReader->AcquireLatestFrame(&pColorFrame);  
184.     if (SUCCEEDED(hr))  
185.     {  
186.         IFrameDescription* pFrameDescription = NULL;  
187.         int nWidth = 0;  
188.         int nHeight = 0;  
189.         ColorImageFormat imageFormat = ColorImageFormat_None;  
190.         UINT nBufferSize = 0;  
191.         RGBQUAD *pBuffer = NULL;  
192.         if (SUCCEEDED(hr))  
193.         {  
194.             hr = pColorFrame->get_FrameDescription(&pFrameDescription);  
195.         }  
196.         if (SUCCEEDED(hr))  
197.         {  
198.             hr = pFrameDescription->get_Width(&nWidth);  
199.         }  
200.         if (SUCCEEDED(hr))  
201.         {  
202.             hr = pFrameDescription->get_Height(&nHeight);  
203.         }  
204.         if (SUCCEEDED(hr))  
205.         {  
206.             hr = pColorFrame->get_RawColorImageFormat(&imageFormat);  
207.         }  
208.         if (SUCCEEDED(hr))  
209.         {  
210.             if (imageFormat == ColorImageFormat_Bgra)  
211.             {  
212.                 hr = pColorFrame->AccessRawUnderlyingBuffer(&nBufferSize, reinterpret_cast<BYTE**>(&pBuffer));  
213.             }  
214.             elseif (m_pColorRGBX)  
215.             {  
216.                 pBuffer = m_pColorRGBX;  
217.                 nBufferSize = cColorWidth * cColorHeight * sizeof(RGBQUAD);  
218.                 hr = pColorFrame->CopyConvertedFrameDataToArray(nBufferSize, reinterpret_cast<BYTE*>(pBuffer), ColorImageFormat_Bgra);              
219.             }  
220.             else
221.             {  
222.                 hr = E_FAIL;  
223.             }  
224.         }  
225.         if (SUCCEEDED(hr))  
226.         {  
227.             ProcessColor(pBuffer, nWidth, nHeight);  
228.         }  
229.         SafeRelease(pFrameDescription);  
230.     }  
231.     SafeRelease(pColorFrame);  
232. }  
233. void Kinect::ProcessDepth(const UINT16* pBuffer, int nWidth, int nHeight, USHORT nMinDepth, USHORT nMaxDepth  )  
234. {  
235.     // Make sure we've received valid data
236.     if (m_pDepthRGBX && pBuffer && (nWidth == cDepthWidth) && (nHeight == cDepthHeight))  
237.     {  
238.         RGBQUAD* pRGBX = m_pDepthRGBX;  
239.         // end pixel is start + width*height - 1
240.         const UINT16* pBufferEnd = pBuffer + (nWidth * nHeight);  
241.         while (pBuffer < pBufferEnd)  
242.         {  
243.             USHORT depth = *pBuffer;  
244.             // To convert to a byte, we're discarding the most-significant
245.             // rather than least-significant bits.
246.             // We're preserving detail, although the intensity will "wrap."
247.             // Values outside the reliable depth range are mapped to 0 (black).
248.             // Note: Using conditionals in this loop could degrade performance.
249.             // Consider using a lookup table instead when writing production code.
250.             BYTE intensity = static_cast<BYTE>((depth >= nMinDepth) && (depth <= nMaxDepth) ? (depth % 256) : 0);     //深度資料由黑白影象顯示//，每256個單位是一個有黑到白的週期
251.             pRGBX->rgbRed   = intensity;  
252.                 pRGBX->rgbGreen = intensity;   
253.             pRGBX->rgbBlue  = intensity;  
254.             ++pRGBX;  
255.             ++pBuffer;  
256.         }  
257.         // Draw the data with OpenCV
258.         Mat DepthImage(nHeight, nWidth, CV_8UC4, m_pDepthRGBX);  
259.         Mat show = DepthImage.clone();  
260.          resize(DepthImage, show, Size(cDepthWidth*1.437 , cDepthHeight*1.437));  
261.         showImageDepth = show.clone();  
262.         imshow("DepthImage", show);  
263.     }  
264. }  
265. void Kinect::ProcessColor(RGBQUAD* pBuffer, int nWidth, int nHeight)  
266. {   
267.     // Make sure we've received valid data   
268.     if (pBuffer && (nWidth == cColorWidth) && (nHeight == cColorHeight))  
269.     {  
270.         // Draw the data with OpenCV
271.         Mat ColorImage(nHeight, nWidth, CV_8UC4, pBuffer);  
272.         Mat showImage = ColorImage.clone();  
273.         resize(ColorImage, showImage, Size(nWidth/2 , nHeight/2));  
274.         Rect rect(145,0,702,538);  
275.         int x = 33,y =-145;   
276.         //CV_8UC4 
277.         for(int i = 0;i <540;i++)  
278.             for(int j = 145;j < 960-114;j++)  
279.                 showImage.at<Vec4b>(i,j) = showImageDepth.at<Vec4b>(i+x,j+y)*0.6+showImage.at<Vec4b>(i,j)*0.4;    
280.             Mat image_roi = showImage(rect);  
281.         //imshow("ColorImage", showImage);//imshow("ColorImage", ColorImage);
282.         imshow("Image_Roi", image_roi);  
283.     }  
284. }