目标跟踪之Lukas-Kanade光流法（转）

光流是图像亮度的运动信息描述。光流法计算最初是由Horn和Schunck于1981年提出的，创造性地将二维速度场与灰度相联系，引入光流约束方程，得到光流计算的基本算法．光流计算基于物体移动的光学特性提出了2个假设：

①运动物体的灰度在很短的间隔时间内保持不变；
②给定邻域内的速度向量场变化是缓慢的。

算法原理

假设图像上一个像素点(x,y)，在t时刻的亮度为E(x+Δx,y+Δy,t+Δt)，同时用u(x,y0和v(x,y)来表示该点光流在水平和垂直方向上的移动分量：

u=dx/dt

v=dy/dt

在经过一段时间间隔Δt后该点对应点亮度为E(x+Δx,y+Δy,t+Δt),当Δt很小趋近于0时，我们可以认为该点亮度不变，所以可以有：
E(x,y,t)=E(x+Δx,y+Δy,t+Δt)
当该点的亮度有变化时，将移动后点的亮度由Taylor公式展幵，可得：

忽略其二阶无穷小，由于Δt趋近于0时，有：

式中w=(u,v)，所以上式就是基本的光流约束方程。
其中令表示图像中像素点灰度沿x，y，t方向的梯度，可将上式改写成：

Lucas-Kanade是一种广泛使用的光流估计的差分方法，这个方法是由Bruce D. Lucas和Takeo Kanade发明的。它假设光流在像素点的邻域是一个常数，然后使用最小二乘法对邻域中的所有像素点求解基本的光流方程。
通过结合几个邻近像素点的信息，卢卡斯-金出方法(简称为L-K方法)通常能够消除光流方程里的多义性。而且，与逐点计算的方法相比，L-K方法对图像噪声不敏感。不过，由于这是一种局部方法，所以在图像的均匀区域内部，L-K方法无法提供光流信息。

Lucas-Kanade改进算法

Jean-Yves Bouguet提出一种基于金字塔分层，针对仿射变换的改进Lucas-Kanade算法。

 

为什么要用金字塔？因为lk算法的约束条件即：小速度，亮度不变以及区域一致性都是较强的假设，并不很容易得到满足。如当物体运动速度较快时，假设不成立，那么后续的假设就会有较大的偏差，使得最终求出的光流值有较大的误差。

考虑物体的运动速度较大时，算法会出现较大的误差。那么就希望能减少图像中物体的运动速度。一个直观的方法就是，缩小图像的尺寸。假设当图像为400×400时，物体速度为[16 16],那么图像缩小为200×200时，速度变为[8,8]。缩小为100*100时，速度减少到[4,4]。所以在源图像缩放了很多以后，原算法又变得适用了。所以光流可以通过生成 原图像的金字塔图像，逐层求解，不断精确来求得。简单来说上层金字塔（低分辨率）中的一个像素可以代表下层的两个。

 

假设I和J是两幅2D的灰度图像，对于图像上每个像素点的灰度值定义为：

I(x)=I(x,y)   和  J(x)=j(x,y)

其中x=(x,y)是图像上像素点的图像坐标。
在实际场景中图像I和图像J可以代表前后两帧图像。对于图像特征点金字塔跟踪来说的目的是：对于前一帧的图像I上一点u(ux,uy)，要在后一帧图像J上找到一点v(ux+dx,uy+dy)与之相匹配，即灰度值最接近。那么向量d=[dx,dy]就是图像在点u处的运动速度，也就是所说像素点u的光流。为了进一步说明向量d的含义。我们假设前一帧图像经历了仿射变换到后一帧图像，定义变换矩阵为

其中四个参数dxx，dyy，dxy，dyx表征着图像中的仿射变形。所以光流计算的目的转变成找到向量d和变换矩阵A使得图像上一块区域内灰度差最小。
定义误差

其中两个整数wx和wy设定了图像上矩形窗口的大小(2*wx+1)和(2*wy+1)。
典型的wx和wy取值为1，2，3，4，5，6，7个像素，相似度的函数被在(2ωx+1, 2ωy+1)的区域内定义。注意在金字塔各层窗口的大小是保持恒定的尺寸

对于Lucas-Kanade改进算法来说，主要的步骤有三步：建立金字塔，基于金字塔跟踪，迭代过程。

 

金字塔的建立

令I0 = I 是第 0 层的图像，它是金字塔图像中分辨率最高的图像，图像的宽度和高度分别定义为nx0 = nx 和 ny0 = ny 。以一种递归的方式建立金字塔：从I0中计算I1，从I1中计算I2 ，···。令L =1, 2,...代表金字塔的层数，L通常取2,3,4。IL−1 是第L−1层的图像，nxL−1 和 nyL−1分别是图像IL−1 的宽度和高度。图像IL可按如下方式由IL−1 求得：

即用一个[0.25 0.5 0.25]的低通滤波器对IL-1进行卷积。

金字塔跟踪

总体来讲，金字塔特征跟踪算法描述如下：首先，光流和仿射变换矩阵在最高一层的图像上计算出；将上一层的计算结果作为初始值传递给下一层图像，这一层的图像在这个初始值的基础上，计算这一层的光流和仿射变化矩阵；再将这一层的光流和仿射矩阵作为初始值传递给下一层图像，直到传递给最后一层，即原始图像层，这一层计算出来的光流和仿射变换矩阵作为最后的光流和仿射变换矩阵的结果。

对于L=0,1,2,…L，定义是图像中像素点u在第L层对应点的坐标。根据上一步中图像金字塔的定义，可以计算出

我们用数学的思想重新描述在L层和L+1层迭代运算，假定在第L层有对被跟踪目标的位置有个大致估计，而从第L+1层传递到L层的运动矢量，即光流计算初值为（后面会对gL做一个解释）并且对于最上层的变换矩阵猜测

为了在L层上计算光流和仿射变换矩阵，需要重新定义在L层上的匹配误差ξL：

其中图像和是原始图像在L层上采样出来的图像，基于这层中的光流和仿射矩阵初值gL和GL可以计算出两个对应图像和：

这里用L+1层得到的最初估计gL对L层作预平移，L层在gL的基础上求该层的光流dL，这样求得的残余光流向量dL= [dLx, dLy]T就足够小，因此能够通过标准的光流法来求出这个运动矢量。然后得到的dL结合gL又可以对L-1层的gL-1做估计。最终的光流和就是在所有层的分段光流d的叠加。使用金字塔图像计算光流的一个明显的好处是，对于一个有着较大的像素偏移的矢量d，可以通过计算几个比较小的残余光流来得到。这里就是金字塔跟踪算法的核心。

接下来就是计算该层上的光流dL和变换矩阵AL，我们将在下一步中谈论。现在，假设在这一层上的光流和变换矩阵己经计算出来。接着将结果传递给下一层，计算出下一层的假设初值：

将gL-1和GL-1作为初值，重新循环上面的步骤，直到最上一层，计算出光流d和仿射变换矩阵A。

由于金字塔的缩放减小了光流值，最高层的光流估计值可以设为0，设顶层时的初始为：

这种算法最明显的优势在于对于每一层的光流都会保持很小，但是最终计算来的光流可以进行累积，便于有效地跟踪特征点。

迭代过程

这一步是算法的核心步骤。在金字塔的每一层，目标是计算出光流dL和仿射变换矩阵AL从而使误差ξL最小。由于每一层的迭代过程是相同的，所以我们就描述从一层到下一层的迭代过程。首先将上一层的光流u和A传给这一层，计算这一帧图像中像素点的光照，同时计算出图像在该点x方向和y方向上的偏导

Ix=[I(x+1,y)-I(x-1,y)]/2

Iy=[I(x,y+1)-I(x,y-1)]/2

在此基础上，计算出空间梯度矩阵：

更新光流v=2*v

迭代过程：计算后一帧图像中对应像素点的灰度，计算两
帧图像间相同位置点的灰度值之差，在计算图像之间的误差
向量：

最后计算针对仿射光流

，
更新跟踪结果

直到某个阈值，结束在这一层的迭代过程。

特征点选择

因此，可按照以下的步骤选择特征点：
1、计算图像 I 中每一个像素的矩阵G和最小特征值λm。
2、寻找整副图像中最小特征值 λm 中的最大特征值λmax。
3、保留最小特征值 λm 大于给定阈值的像素点。阈值通常取5% λmax ~10% λmax 。
4、保留 λm 局部最大值的像素：像素特征值 λm 大于其3*3 邻域中其他像素的特征值 λm 。
5、剔除像素密集区域中的一些像素，确保图像中相邻像素的距离都大于给定的阈值（常取5~10 pixels）。
上述操作完成后，图像 I 中剩下的像素即为选择的特征点，并作为跟踪特征点。特征点选择算法的步骤5 确保了特征点间的最小距离。

没有必要取一个大的综合窗口选择特征点（或计算矩阵G）。大量实验证明，wx = wy =1的 3*3 大小的综合窗口能够取得满意的效果。

金字塔高度的选择

在大多数的情况下，超过4的金字塔图像层次没有太大的意义。

有时为了简化可以将仿射变换矩阵G简化为单位矩阵。

算法流程

下面是我的实现。

1. #ifndef _LKOF_
2. #define _LKOF_
3. /***********Lucas-Kanade optical flow track**********/
4. /*****************author Marshall********************/
5. /**********************2015.10.14********************/
6. /******************version 1.0***********************/
7. class LucasKanadeTracker
8. {
9. struct DBPoint
10. {
11. double x;
12. double y;
13. DBPoint(const double X, const double Y):x(X),y(Y){
14. }
15. DBPoint(){}
16. };
17. int*height;
18. int*width;
19. private:
20. unsigned int max_pyramid_layer;
21. unsigned int original_imgH;
22. unsigned int original_imgW;
23. unsigned int window_radius;
24. BYTE**pre_pyr;//the pyramid of previous frame image,img1_pyr[0] is of max size
25. BYTE**next_pyr;//the frame after img1_pyr
26. bool isusepyramid;
27. DBPoint*target,*endin;
28. int numofpoint;
29. private:
30. void build_pyramid(BYTE**&original_gray);
31. void lucaskanade(BYTE**&frame_pre, BYTE**&frame_cur, DBPoint*& start,
32. DBPoint*& finish, unsigned int point_nums, char*state);
33. void get_max_pyramid_layer();
34. void pyramid_down(BYTE*&src_gray_data, const int src_h,
35. const int src_w, BYTE*& dst, int&dst_h, int&dst_w);
36. void lowpass_filter(BYTE*&src, const int H, const int W, BYTE*&smoothed);
37. double get_subpixel(BYTE*&src, int h, int w, const DBPoint& point);
38. // caculate the inverse mareix of pMatrix，the result is put into _pMatrix
39. void ContraryMatrix(double *pMatrix, double * _pMatrix, int dim);
40. bool matrixMul(double *src1, int height1, int width1, double *src2, int height2, int width2, double *dst);
41. public:
42. LucasKanadeTracker(const int windowRadius, bool usePyr);
43. ~LucasKanadeTracker();
44. void get_pre_frame(BYTE*&gray);//use only at the beginning
45. void discard_pre_frame();
46. //set the next frame as pre_frame,must dicard pre_pyr in advance
47. void get_pre_frame();
48. //use every time,must after using get_pre_frame(BYTE**pyr)
49. void get_next_frame(BYTE*&gray);
50. void get_info(const int nh, const int nw);
51. void get_target(POINT*target, int n);
52. void run_single_frame();
53. POINT get_result();
54. BYTE*&get_pyramid(int th);
55. int get_pyrH(int th){ return height[th]; }
56. int get_pyrW(int th){ return width[th]; }
57. };
58. #endif

1. #include "stdafx.h"
2. #include "LucasKanadeTracker.h"
3. using namespace std;
4. LucasKanadeTracker::LucasKanadeTracker(const int windowRadius, bool usePyr)
5. :window_radius(windowRadius), isusepyramid(usePyr)
6. {
7. }
8. LucasKanadeTracker::~LucasKanadeTracker()
9. {
10. for (int i = 0; i < max_pyramid_layer; i++)
11. {
12. if (pre_pyr[i])
13. delete[]pre_pyr[i];
14. if (next_pyr[i])
15. delete[]next_pyr[i];
16. }
17. delete[]pre_pyr;
18. delete[]next_pyr;
19. if (height)
20. delete[]height;
21. if (width)
22. delete[]width;
23. }
24. void LucasKanadeTracker::lowpass_filter(BYTE*&src, const int H, const int W, BYTE*&smoothed)
25. {
26. //tackle with border
27. for (int i = 0; i < H; i++)
28. {
29. smoothed[i*W] = src[i*W];
30. smoothed[i*W + W - 1] = src[i*W + W - 1];
31. }
32. for (int i = 0; i < W; i++)
33. {
34. smoothed[i] = src[i];
35. smoothed[(H - 1)*W + i] = src[(H - 1)*W + i];
36. }
37. for (int i = 1; i < H - 1; i++)
38. for (int j = 1; j < W - 1; j++)
39. {
40. double re = 0;
41. re += src[i*W + j] * 0.25;
42. re += src[(i - 1)*W + j] * 0.125;
43. re += src[i*W + j + 1] * 0.125;
44. re += src[i*W + j - 1] * 0.125;
45. re += src[(i + 1)*W + j] * 0.125;
46. re += src[(i - 1)*W + j - 1] * 0.0625;
47. re += src[(i + 1)*W + j - 1] * 0.0625;
48. re += src[(i - 1)*W + j + 1] * 0.0625;
49. re += src[(i + 1)*W + j + 1] * 0.0625;
50. smoothed[i*W + j] = BYTE(re);
51. }
52. delete[]src;
53. src = smoothed;
54. }
55. void LucasKanadeTracker::get_info(const int nh, const int nw)
56. {
57. original_imgH = nh;
58. original_imgW = nw;
59. if (isusepyramid)
60. get_max_pyramid_layer();
61. else
62. max_pyramid_layer = 1;
63. pre_pyr = new BYTE*[max_pyramid_layer];
64. next_pyr = new BYTE*[max_pyramid_layer];
65. height = new int[max_pyramid_layer];
66. width = new int[max_pyramid_layer];
67. height[0] = nh;
68. width[0] = nw;
69. }
70. void LucasKanadeTracker::get_target(POINT*target, int n)
71. {
72. this->target = new DBPoint[n];
73. endin = new DBPoint[n];
74. for (int i = 0; i < n; i++)
75. {
76. this->target[i].x = target[i].x;
77. this->target[i].y = target[i].y;
78. }
79. numofpoint = n;
80. }
81. BYTE*&LucasKanadeTracker::get_pyramid(int th)
82. {
83. return pre_pyr[th];
84. }
85. POINT LucasKanadeTracker::get_result()
86. {
87. POINT pp;
88. pp.x = target[0].x;
89. pp.y = target[0].y;
90. return pp;
91. }
92. void LucasKanadeTracker::get_pre_frame(BYTE*&gray)//use only at the beginning
93. {
94. pre_pyr[0] = gray;
95. build_pyramid(pre_pyr);
96. //save_gray("1.bmp", pre_pyr[1], height[1], width[1]);
97. }
98. void  LucasKanadeTracker::discard_pre_frame()
99. {
100. //we don't new memory for original data,so we don't delete it here
101. for (int i = 0; i < max_pyramid_layer; i++)
102. delete[]pre_pyr[i];
103. }
104. //set the next frame as pre_frame,must dicard pre_pyr in advance
105. void  LucasKanadeTracker::get_pre_frame()
106. {
107. for (int i = 0; i < max_pyramid_layer; i++)
108. pre_pyr[i] = next_pyr[i];
109. }
110. //use every time,must after using get_pre_frame(BYTE**pyr)
111. void  LucasKanadeTracker::get_next_frame(BYTE*&gray)
112. {
113. next_pyr[0] = gray;
114. build_pyramid(next_pyr);
115. //save_gray("1.bmp", next_pyr[1], height[1], width[1]);
116. }
117. void LucasKanadeTracker::pyramid_down(BYTE*&src_gray_data,
118. const int src_h, const int src_w, BYTE*& dst, int&dst_h, int&dst_w)
119. {
120. dst_h = src_h / 2;
121. dst_w = src_w / 2;
122. int ii = height[1];
123. int hh = width[1];
124. assert(dst_w > 3 && dst_h > 3);
125. //BYTE*smoothed = new BYTE[src_h*src_w];
126. dst = new BYTE[dst_h*dst_w];
127. //lowpass_filter(src_gray_data, src_h, src_w,smoothed);
128. for (int i = 0; i < dst_h - 1; i++)
129. for (int j = 0; j < dst_w - 1; j++)
130. {
131. int srcY = 2 * i + 1;
132. int srcX = 2 * j + 1;
133. double re = src_gray_data[srcY*src_w + srcX] * 0.25;
134. re += src_gray_data[(srcY - 1)*src_w + srcX] * 0.125;
135. re += src_gray_data[(srcY + 1)*src_w + srcX] * 0.125;
136. re += src_gray_data[srcY*src_w + srcX - 1] * 0.125;
137. re += src_gray_data[srcY*src_w + srcX + 1] * 0.125;
138. re += src_gray_data[(srcY - 1)*src_w + srcX + 1] * 0.0625;
139. re += src_gray_data[(srcY - 1)*src_w + srcX - 1] * 0.0625;
140. re += src_gray_data[(srcY + 1)*src_w + srcX - 1] * 0.0625;
141. re += src_gray_data[(srcY + 1)*src_w + srcX + 1] * 0.0625;
142. dst[i*dst_w + j] = re;
143. }
144. for (int i = 0; i < dst_h; i++)
145. dst[i*dst_w + dst_w - 1] = dst[i*dst_w + dst_w - 2];
146. for (int i = 0; i < dst_w; i++)
147. dst[(dst_h - 1)*dst_w + i] = dst[(dst_h - 2)*dst_w + i];
148. }
149. //bilinear interplotation
150. double LucasKanadeTracker::get_subpixel(BYTE*&src, int h, int w, const DBPoint& point)
151. {
152. int floorX = floor(point.x);
153. int floorY = floor(point.y);
154. double fractX = point.x - floorX;
155. double fractY = point.y - floorY;
156. return ((1.0 - fractX) * (1.0 - fractY) * src[floorX + w* floorY])
157. + (fractX * (1.0 - fractY) * src[floorX + 1 + floorY*w])
158. + ((1.0 - fractX) * fractY * src[floorX + (floorY + 1)*w])
159. + (fractX * fractY * src[floorX + 1 + (floorY + 1)*w]);
160. }
161. void LucasKanadeTracker::get_max_pyramid_layer()
162. {
163. int layer = 0;
164. int windowsize = 2 * window_radius + 1;
165. int temp = original_imgH > original_imgW ?
166. original_imgW : original_imgH;
167. if (temp > ((1 << 4) * 2 * windowsize))
168. {
169. max_pyramid_layer = 5;
170. return;
171. }
172. temp = double(temp) / 2;
173. while (temp > 2 * windowsize)
174. {
175. layer++;
176. temp = double(temp) / 2;
177. }
178. max_pyramid_layer = layer;
179. }
180. void LucasKanadeTracker::build_pyramid(BYTE**&pyramid)
181. {
182. for (int i = 1; i < max_pyramid_layer; i++)
183. {
184. pyramid_down(pyramid[i - 1], height[i - 1],
185. width[i - 1], pyramid[i], height[i], width[i]);
186. }
187. }
188. void LucasKanadeTracker::run_single_frame()
189. {
190. char*state = NULL;
191. lucaskanade(pre_pyr, next_pyr, target, endin, numofpoint, state);
192. for (int i = 0; i < numofpoint; i++)
193. {
194. target[i].x = endin[i].x;
195. target[i].y = endin[i].y;
196. }
197. }
198. void LucasKanadeTracker::lucaskanade(BYTE**&frame_pre, BYTE**&frame_cur,
199. DBPoint*& start, DBPoint*& finish, unsigned int point_nums, char*state)
200. {
201. double*derivativeXs = new double
202. [(2 * window_radius + 1)*(2 * window_radius + 1)];
203. double*derivativeYs = new double
204. [(2 * window_radius + 1)*(2 * window_radius + 1)];
205. for (int i = 0; i < point_nums; i++)
206. {
207. double g[2] = { 0 };
208. double finalopticalflow[2] = { 0 };
209. memset(derivativeXs, 0, sizeof(double)*
210. (2 * window_radius + 1)*(2 * window_radius + 1));
211. memset(derivativeYs, 0, sizeof(double)*
212. (2 * window_radius + 1)*(2 * window_radius + 1));
213. for (int j = max_pyramid_layer - 1; j >= 0; j--)
214. {
215. DBPoint curpoint;
216. curpoint.x = start[i].x / pow(2.0, j);
217. curpoint.y = start[i].y / pow(2.0, j);
218. double Xleft = curpoint.x - window_radius;
219. double Xright = curpoint.x + window_radius;
220. double Yleft = curpoint.y - window_radius;
221. double Yright = curpoint.y + window_radius;
222. double gradient[4] = { 0 };
223. int cnt = 0;
224. for (double xx = Xleft; xx < Xright + 0.01; xx += 1.0)
225. for (double yy = Yleft; yy < Yright + 0.01; yy += 1.0)
226. {
227. assert(xx < 1000 && yy < 1000 && xx >= 0 && yy >= 0);
228. double derivativeX = get_subpixel(frame_pre[j],
229. height[j], width[j], DBPoint(xx + 1.0, yy)) -
230. get_subpixel(frame_pre[j], height[j],
231. width[j], DBPoint(xx - 1.0, yy));
232. derivativeX /= 2.0;
233. double t1 = get_subpixel
234. (frame_pre[j], height[j], width[j], DBPoint(xx, yy + 1.0));
235. double t2 = get_subpixel(frame_pre[j], height[j],
236. width[j], DBPoint(xx, yy - 1.0));
237. double derivativeY = (t1 - t2) / 2.0;
238. derivativeXs[cnt] = derivativeX;
239. derivativeYs[cnt++] = derivativeY;
240. gradient[0] += derivativeX * derivativeX;
241. gradient[1] += derivativeX * derivativeY;
242. gradient[2] += derivativeX * derivativeY;
243. gradient[3] += derivativeY * derivativeY;
244. }
245. double gradient_inv[4] = { 0 };
246. ContraryMatrix(gradient, gradient_inv, 2);
247. double opticalflow[2] = { 0 };
248. int max_iter = 50;
249. double opticalflow_residual = 1;
250. int iteration = 0;
251. while (iteration<max_iter&&opticalflow_residual>0.00001)
252. {
253. iteration++;
254. double mismatch[2] = { 0 };
255. cnt = 0;
256. for (double xx = Xleft; xx < Xright + 0.001; xx += 1.0)
257. for (double yy = Yleft; yy < Yright + 0.001; yy += 1.0)
258. {
259. assert(xx < 1000 && yy < 1000 && xx >= 0 && yy >= 0);
260. double nextX = xx + g[0] + opticalflow[0];
261. double nextY = yy + g[1] + opticalflow[1];
262. assert(nextX < 1000 && nextY < 1000 && nextX >= 0 && nextY >= 0);
263. double pixelDifference = (get_subpixel(frame_pre[j],
264. height[j], width[j], DBPoint(xx, yy))
265. - get_subpixel(frame_cur[j], height[j],
266. width[j], DBPoint(nextX, nextY)));
267. mismatch[0] += pixelDifference*derivativeXs[cnt];
268. mismatch[1] += pixelDifference*derivativeYs[cnt++];
269. }
270. double temp_of[2];
271. matrixMul(gradient_inv, 2, 2, mismatch, 2, 1, temp_of);
272. opticalflow[0] += temp_of[0];
273. opticalflow[1] += temp_of[1];
274. opticalflow_residual = abs(temp_of[0]) + abs(temp_of[1]);
275. }
276. if (j == 0)
277. {
278. finalopticalflow[0] = opticalflow[0];
279. finalopticalflow[1] = opticalflow[1];
280. }
281. else
282. {
283. g[0] = 2 * (g[0] + opticalflow[0]);
284. g[1] = 2 * (g[1] + opticalflow[1]);
285. }
286. }
287. finalopticalflow[0] += g[0];
288. finalopticalflow[1] += g[1];
289. finish[i].x = start[i].x + finalopticalflow[0];
290. finish[i].y = start[i].y + finalopticalflow[1];
291. }
292. delete[]derivativeXs, derivativeYs;
293. }
294. //matrix inverse
295. void LucasKanadeTracker::ContraryMatrix(double *pMatrix, double * _pMatrix, int dim)
296. {
297. double *tMatrix = new double[2 * dim*dim];
298. for (int i = 0; i < dim; i++){
299. for (int j = 0; j < dim; j++)
300. tMatrix[i*dim * 2 + j] = pMatrix[i*dim + j];
301. }
302. for (int i = 0; i < dim; i++){
303. for (int j = dim; j < dim * 2; j++)
304. tMatrix[i*dim * 2 + j] = 0.0;
305. tMatrix[i*dim * 2 + dim + i] = 1.0;
306. }
307. //Initialization over!
308. for (int i = 0; i < dim; i++)//Process Cols
309. {
310. double base = tMatrix[i*dim * 2 + i];
311. if (fabs(base) < 1E-300){
312. // AfxMessageBox("求逆矩阵过程中被零除，无法求解!" );
313. _ASSERTE(-1);//throw exception
314. exit(0);
315. }
316. for (int j = 0; j < dim; j++)//row
317. {
318. if (j == i) continue;
319. double times = tMatrix[j*dim * 2 + i] / base;
320. for (int k = 0; k < dim * 2; k++)//col
321. {
322. tMatrix[j*dim * 2 + k] = tMatrix[j*dim * 2 + k] - times*tMatrix[i*dim * 2 + k];
323. }
324. }
325. for (int k = 0; k < dim * 2; k++){
326. tMatrix[i*dim * 2 + k] /= base;
327. }
328. }
329. for (int i = 0; i < dim; i++)
330. {
331. for (int j = 0; j < dim; j++)
332. _pMatrix[i*dim + j] = tMatrix[i*dim * 2 + j + dim];
333. }
334. delete[] tMatrix;
335. }
336. bool LucasKanadeTracker::matrixMul(double *src1, int height1, int width1, double *src2, int height2, int width2, double *dst)
337. {
338. int i, j, k;
339. double sum = 0;
340. double *first = src1;
341. double *second = src2;
342. double *dest = dst;
343. int Step1 = width1;
344. int Step2 = width2;
345. if (src1 == NULL || src2 == NULL || dest == NULL || height2 != width1)
346. return false;
347. for (j = 0; j < height1; j++)
348. {
349. for (i = 0; i < width2; i++)
350. {
351. sum = 0;
352. second = src2 + i;
353. for (k = 0; k < width1; k++)
354. {
355. sum += first[k] * (*second);
356. second += Step2;
357. }
358. dest[i] = sum;
359. }
360. first += Step1;
361. dest += Step2;
362. }
363. return true;
364. }

下面是两帧图像间特征点的跟踪

      

参考文献：Pyramidal Implementation of the AÆne Lucas Kanade Feature Tracker Description of the algorithm

An Iterative Image Registration Technique with an Application to Stereo Vision

Detection and Tracking of Point Features

Good Features to Track

Derivation of Kanade-Lucas-Tomasi Tracking Equation

Lucas–Kanade光流算法

Kanade-Lucas-Tomasi(KLT)目标跟踪

光流法与KLT

跟踪算法合集

Opencv学习笔记（九）光流法

OpenCV光流跟踪程序学习