开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
GravityCenter.cpp
资源名称：Video_detection.rar　[点击查看]
上传用户：smdfuse
上传日期：2015-11-06
资源大小：98k
文件大小：18k
源码类别：

图形图象

开发平台：

Visual C++

GravityCenter.cpp：源码内容
  1. /*******************************************************
  2. Motion target detection & tracking by gravity center
  3. Author: jianglong
  4. date: 2006.08
  5. Compiler: Microsoft Visual C++ 6.0 
  6. *******************************************************/
  7. #include "stdafx.h"
  8. #include <math.h>
  9. #include "GravityCenter.h"
  11. CGravityCenter::CGravityCenter(int nwidth,int nheight)
  12. {
  13. m_otype = TRUE;
  14. m_width = nwidth;
  15. m_height = nheight;
  16. m_imageSize = m_width*m_height;
  18. m_threshBH = S_THRESHOLD_BH;
  19. m_threshW = S_THRESHOLD_TR;
  21. permitflag1=FALSE;
  22. permitflag2=FALSE;
  23. permitflag3=FALSE;
  24. permitflag4=FALSE;
  26. captureflag1=FALSE;
  27. captureflag2=FALSE;
  28. captureflag3=FALSE;
  29. captureflag4=FALSE;
  31. m_threshBHD = THRESHOLD_BH;
  32. m_threshW1 = THRESHOLD_TR;
  33. m_threshW2 = THRESHOLD_TR;
  34. m_threshW3 = THRESHOLD_TR;
  35. m_threshW4 = THRESHOLD_TR;
  37. m_CurImage = new unsigned char[m_imageSize*3];
  38. m_CurGrayImage = new unsigned char[m_imageSize];
  39. m_TempGrayImage = new unsigned char[m_imageSize];
  40. m_PreGrayImage = new unsigned char[m_imageSize];
  42. memset(m_CurImage,0,m_imageSize*3);
  43. memset(m_CurGrayImage,0,m_imageSize);
  44. memset(m_PreGrayImage,0,m_imageSize);
  45. memset(m_TempGrayImage,0,m_imageSize);
  47. }
  48. CGravityCenter::~CGravityCenter()
  49. {
  50. delete []m_PreGrayImage;
  51. delete []m_CurGrayImage;
  52. delete []m_TempGrayImage;
  53. delete []m_CurImage;
  54. }
  56. void CGravityCenter::Initial()
  57. {
  58. m_colorType = 0;
  59. m_TargetWin.pt.x=150;
  60. m_TargetWin.pt.y=100;
  61. m_TargetWin.w = 40;
  62. m_TargetWin.h = 40;
  63. m_TargetWin.flag = FALSE;
  65. m_DrawWin.pt.x=m_width/2;
  66. m_DrawWin.pt.y=m_height/2;
  67. m_DrawWin.w = (m_width-4)/3;
  68. m_DrawWin.h = (m_height-4)/3;
  69. m_DrawWin.flag = FALSE;
  71. }
  72. void CGravityCenter::InitalObjectTracker(BOOL type, int threshold)
  73. {
  74. trackflag = FALSE;
  75. m_otype = type;
  76. m_threshold = threshold;
  77. }
  80. void CGravityCenter::GravityCenter(int index, unsigned char *nRGBbuffer)
  81. {
  82. m_frame = index;
  83. memcpy(m_CurImage,nRGBbuffer,m_width*m_height*3);
  84. RGBToGray(m_CurImage,m_CurGrayImage,m_width,m_height);
  86. if(false) //单目标
  87. {
  88. if(!trackflag)
  89. {
  90. Initial();
  91. switch(m_threshold)//捕获阈值选取
  92. {
  93. case 0:
  94. m_threshBH = S_THRESHOLD_BH;
  95. break;
  96. case 1:
  97. m_threshBH = GetBHThByHistogram(m_CurGrayImage,m_width,m_height);
  98. break;
  99. default:
  100. break;
  101. }
  102. m_TargetWin = gravity(m_CurGrayImage, m_width, m_height, m_threshBH);
  103. trackflag = m_TargetWin.flag;
  104. }
  105. else
  106. {
  107. switch(m_threshold)//跟踪窗内阈值选取
  108. {
  109. case 0:
  110. m_threshW = S_THRESHOLD_TR;
  111. break;
  112. case 1:
  113. m_threshW = GetWThByHistogram(m_CurGrayImage, m_TargetWin, m_width, m_height);
  114. break;
  115. default:
  116. break;
  117. }
  118. m_TargetWin = AdjustWindow(m_TargetWin, m_width, m_height);
  119. m_TargetWin = gvtrack(m_CurGrayImage, m_width, m_height, m_TargetWin, m_threshW);
  120. trackflag = m_TargetWin.flag;
  121. }
  123. if(trackflag)
  124. {
  125. m_DrawWin = AdjustWindow(m_TargetWin, m_width, m_height);
  126. m_result.frame = index;
  127. m_result.x = (short)m_DrawWin.pt.x;
  128. m_result.y = (short)m_DrawWin.pt.y;
  129. m_result.w = m_DrawWin.w;
  130. m_result.h = m_DrawWin.h;
  131. }
  132. DrawObjectBox(nRGBbuffer, m_DrawWin);
  133. }
  134. else  //多目标
  135. {
  136. Initial();
  137. switch(m_threshold)//捕获阈值选取
  138. {
  139. case 0:
  140. m_threshBHD = THRESHOLD_BH;
  141. break;
  142. case 1:
  143. m_threshBHD = GetBHThByHistogram(m_CurGrayImage,m_width,m_height);
  144. break;
  145. default:
  146. break;
  147. }
  149. if(permitflag1==1)
  150. {
  151. m_TargetWin1 = AdjustWindow(m_TargetWin1, m_width, m_height);
  152.   // m_threshW1 = GetWThByHistogram(m_CurGrayImage,m_TargetWin1,m_width, m_height);
  153.   //    m_threshW1 = threshold_area(m_CurGrayImage,m_TargetWin1,m_width, m_height);
  154. m_TargetWin1 = gvtrack(m_CurGrayImage, m_width, m_height, m_TargetWin1, m_threshW1);
  155. captureflag1 = m_TargetWin1.flag;
  156. if(captureflag1 == 1)
  157. {
  158. m_ObjectNum++;
  159. m_DrawWin1 = AdjustWindow(m_TargetWin1, m_width, m_height);
  160. erasure(m_CurGrayImage, m_DrawWin1, m_width, m_height);
  161. DrawObjectBox(nRGBbuffer, m_DrawWin1);
  162. }
  163. else
  164. {
  165. permitflag1 = 0;
  166. }
  167. }
  169. if(permitflag2==1)
  170. {
  171. m_TargetWin2 = AdjustWindow(m_TargetWin2, m_width, m_height);
  172.       //m_threshW2 = GetWThByHistogram(m_CurGrayImage, m_TargetWin2, m_width, m_height);
  173.   //m_threshW2 = threshold_area(m_CurGrayImage,m_TargetWin2,m_width, m_height);
  174. m_TargetWin2 = gvtrack(m_CurGrayImage, m_width, m_height, m_TargetWin2, m_threshW2);
  175. captureflag2 = m_TargetWin2.flag;
  176. if(captureflag2 == 1)
  177. {
  178. m_ObjectNum++;
  179. m_DrawWin2 = AdjustWindow(m_TargetWin2, m_width, m_height);
  180. erasure(m_CurGrayImage, m_DrawWin2, m_width, m_height);
  181. DrawObjectBox(nRGBbuffer, m_DrawWin2);
  182. }
  183. else
  184. {
  185. permitflag2 = 0;
  186. }
  187. }
  189. if(permitflag3==1)
  190. {
  191. m_TargetWin3 = AdjustWindow(m_TargetWin3, m_width, m_height);
  192. // m_threshW3 = GetWThByHistogram(m_CurGrayImage,m_TargetWin3,m_width, m_height);
  193. //  m_threshW3 = threshold_area(m_CurGrayImage,m_TargetWin3,m_width, m_height);
  194. m_TargetWin3 = gvtrack(m_CurGrayImage, m_width, m_height, m_TargetWin3, m_threshW3);
  195. captureflag3 = m_TargetWin3.flag;
  196. if(captureflag3 == 1)
  197. {
  198. m_ObjectNum++;
  199. m_DrawWin3 = AdjustWindow(m_TargetWin3, m_width, m_height);
  200. erasure(m_CurGrayImage, m_DrawWin3, m_width, m_height);
  201. DrawObjectBox(nRGBbuffer, m_DrawWin3);
  202. }
  203. else
  204. {
  205. permitflag3 = 0;
  206. }
  207. }
  209. if(permitflag4==1)
  210. {
  211. m_TargetWin4 = AdjustWindow(m_TargetWin4, m_width, m_height);
  212.       //    m_threshW4 = GetWThByHistogram(m_CurGrayImage,m_TargetWin4,m_width, m_height);
  213.   //    m_threshW4 = threshold_area(m_CurGrayImage,m_TargetWin4,m_width, m_height);
  214. m_TargetWin4 = gvtrack(m_CurGrayImage, m_width, m_height, m_TargetWin4, m_threshW4);
  215. captureflag4 = m_TargetWin4.flag;
  216. if(captureflag4 == 1)
  217. {
  218. m_ObjectNum++;
  219. m_DrawWin4 = AdjustWindow(m_TargetWin4, m_width, m_height);
  220. erasure(m_CurGrayImage, m_DrawWin4, m_width, m_height);
  221. DrawObjectBox(nRGBbuffer, m_DrawWin4);
  222. }
  223. else
  224. {
  225. permitflag4 = 0;
  226. }
  228. }
  230. //捕获过程
  231. if(permitflag1==0)
  232. {
  233. m_TargetWin1 = findEdge(m_CurGrayImage, m_width, m_height, m_threshBHD, BLOCK_NUMBER);
  234. permitflag1 = m_TargetWin1.flag;
  235. }
  236. else if(permitflag2==0)
  237. {
  238. m_TargetWin2 = findEdge(m_CurGrayImage, m_width, m_height, m_threshBHD, BLOCK_NUMBER);
  239. permitflag2 = m_TargetWin2.flag;
  240. }
  241. else if(permitflag3==0)
  242. {
  243. m_TargetWin3 = findEdge(m_CurGrayImage, m_width, m_height, m_threshBHD, BLOCK_NUMBER);
  244. permitflag3 = m_TargetWin3.flag;
  245. }
  246. else if(permitflag4==0)
  247. {
  248. m_TargetWin4 = findEdge(m_CurGrayImage, m_width, m_height, m_threshBHD, BLOCK_NUMBER);
  249. permitflag4 = m_TargetWin4.flag;
  250. }
  251. else 
  252. return;
  254. m_result.frame = index;
  255. m_result.x = 0;
  256. m_result.y = 0;
  257. m_result.w = 0;
  258. m_result.h = 0;
  260. }
  262. }
  264. //灰度化
  265. void CGravityCenter::RGBToGray(unsigned char *sRGB, unsigned char *sGray, int nWidth, int nHeight)
  266. {
  267. int i,j;
  268. for(j=0;j<nHeight;j++)
  269. {
  270. for(i=0;i<nWidth;i++)
  271. {
  272. int k = nWidth*j+i;
  273. sGray[k]=(11*sRGB[3*k]+59*sRGB[3*k+1]+30*sRGB[3*k+2])/100;
  274. }
  275. }
  276. }
  278. //二值化
  279. void CGravityCenter::Segment(unsigned char *sGray, int nWidth, int nHeight, int nThreshold)
  280. {
  281. int i,j;
  282. for(j=0;j<nHeight;j++)
  283. {
  284. for(i=0;i<nWidth;i++)
  285. {
  286. int k = nWidth*j+i;
  287. if(sGray[k]>nThreshold)
  288. sGray[k] = 1;
  289. else
  290. sGray[k] = 0;
  291. }
  292. }
  293. }
  295. //图像反色
  296. void CGravityCenter::Inverse(unsigned char *sGray, int nWidth, int nHeight)
  297. {
  298. int i,j;
  299. for(j=0;j<nHeight;j++)
  300. {
  301. for(i=0;i<nWidth;i++)
  302. {
  303. int k = nWidth*j+i;
  304. sGray[k] = unsigned char(255-sGray[k]);
  305. }
  306. }
  308. }
  311. //选取跟踪窗口颜色
  312. unsigned long CGravityCenter::GetBoxColor()
  313. {
  314. unsigned long pixelValues = 0;
  316. switch(m_colorType)
  317. {
  318. case 0:
  319. pixelValues = RGB(255,0,0);
  320. break;
  321. case 1:
  322. pixelValues = RGB(0,255,0);
  323. break;
  324. case 2:
  325. pixelValues = RGB(0,0,255);
  326. break;
  327. case 3:
  328. pixelValues = RGB(255,255,0);
  329. break;
  330. case 4:
  331. pixelValues = RGB(255,0,255);
  332. break;
  333. case 5:
  334. pixelValues = RGB(0,255,255);
  335. break;
  336. case 6:
  337. pixelValues = RGB(255,255,255);
  338. break;
  339. case 7:
  340. pixelValues = RGB(128,0,128);
  341. break;
  342. case 8:
  343. pixelValues = RGB(128,128,0);
  344. break;
  345. case 9:
  346. pixelValues = RGB(128,128,128);
  347. break;
  348. case 10:
  349. pixelValues = RGB(255,128,0);
  350. break;
  351. case 11:
  352. pixelValues = RGB(0,128,128);
  353. break;
  354. case 12:
  355. pixelValues = RGB(123,50,10);
  356. break;
  357. case 13:
  358. pixelValues = RGB(10,240,126);
  359. break;
  360. case 14:
  361. pixelValues = RGB(0,128,255);
  362. break;
  363. case 15:
  364. pixelValues = RGB(128,200,20);
  365. break;
  366. default:
  367. break;
  368. }
  370. return(pixelValues);
  372. }
  374. //改变窗口颜色
  375. void CGravityCenter::SetPixelValues(unsigned char *sRGB,unsigned long pixelValues, int x, int y)
  376. {
  377. *(sRGB+(y*m_width+x)*3+2) = unsigned char(pixelValues & 0xFF);
  378. *(sRGB+(y*m_width+x)*3+1) = unsigned char((pixelValues >> 8) & 0xFF);
  379. *(sRGB+(y*m_width+x)*3) = unsigned char((pixelValues >> 16) & 0xFF); 
  381. }
  383. //画跟踪窗口
  384. void CGravityCenter::DrawObjectBox(unsigned char *sRGB, WININFO sWin)
  385. {
  386. int i,j;
  387. unsigned long pv=0;
  388. pv = GetBoxColor();
  389. for(i=sWin.pt.x-sWin.w; i<sWin.pt.x+sWin.w; i++)
  390. {
  391. SetPixelValues(sRGB,pv,i,sWin.pt.y-sWin.h);
  392. SetPixelValues(sRGB,pv,i,sWin.pt.y+sWin.h);
  393. }
  395. for(j=sWin.pt.y-sWin.h; j<sWin.pt.y+sWin.h; j++)
  396. {
  397. SetPixelValues(sRGB,pv,sWin.pt.x-sWin.w,j);
  398. SetPixelValues(sRGB,pv,sWin.pt.x+sWin.w,j);
  399. }
  401. }
  403. //直方图法求捕获阈值
  404. int CGravityCenter::GetBHThByHistogram(unsigned char *sGray,int nWidth, int nHeight)
  405. {
  406. int threshold;
  407. int mean=0;
  408. int grayMax=0;
  409. int calHistNum=0;
  410. int whiteContrast=0;
  411. int i,j,tmp;
  412. int his[256];
  413. for(i= 0;i<256;i++)
  414. his[i] = 0;
  415. //calculate the histogram of image
  416. for(i=EDGE_SPACE;i<nHeight-EDGE_SPACE;i++)
  417. {
  418. for(j=EDGE_SPACE;j<nWidth-EDGE_SPACE;j++)
  419. {
  420. tmp = sGray[i*nWidth+j];
  421. his[tmp]++;
  422. if(tmp>grayMax)
  423. grayMax = tmp;
  424. }
  425. }
  426. //calculate the contrast of image
  427. calHistNum = (nWidth-2*EDGE_SPACE)*(nHeight-2*EDGE_SPACE);
  428. for(i= 0;i<256;i++)
  429. {
  430. mean+=his[i]*i;
  431. }
  432. mean = mean/calHistNum;
  433. whiteContrast = 100*(grayMax-mean)/grayMax;
  435. if(whiteContrast>30) threshold = grayMax-50;
  436. else if (whiteContrast>27) threshold = grayMax-30;
  437. else if (whiteContrast>24) threshold = grayMax-20;
  438. else if (whiteContrast>20) threshold = grayMax-15;
  439. else if (whiteContrast>9) threshold = grayMax-11;
  440. else if (whiteContrast>4) threshold = grayMax-6;
  441. else threshold = grayMax;
  443. return threshold;
  445. }
  447. //直方图法求窗口内阈值
  448. int CGravityCenter::GetWThByHistogram(unsigned char *sGray, WININFO sWin, int nWidth, int nHeight)
  449. {
  450. int threshold;
  451. int mean=0;
  452. int grayMax=0;
  453. int calHistNum=0;
  454. int whiteContrast=0;
  455. int i,j,tmp;
  456. int his[256];
  457. for(i= 0;i<256;i++)
  458. his[i] = 0;
  459. //calculate the histogram of image
  460. for(j=sWin.pt.y-sWin.h;j<sWin.pt.y+sWin.h;j++)
  461. {
  462. for(i=sWin.pt.x-sWin.w;i<sWin.pt.x+sWin.w;i++)
  463. {
  464. tmp = sGray[i*nWidth+j];
  465. his[tmp]++;
  466. if(tmp>grayMax)
  467. grayMax = tmp;
  468. calHistNum++;
  469. }
  470. }
  471. //calculate the contrast of image
  472. for(i= 0;i<256;i++)
  473. {
  474. mean+=his[i]*i;
  475. }
  476. mean = mean/calHistNum;
  477. whiteContrast = 100*(grayMax-mean)/grayMax;
  479. if(whiteContrast>30) threshold = grayMax-50;
  480. else if (whiteContrast>27) threshold = grayMax-30;
  481. else if (whiteContrast>24) threshold = grayMax-20;
  482. else if (whiteContrast>20) threshold = grayMax-15;
  483. else if (whiteContrast>9) threshold = grayMax-11;
  484. else if (whiteContrast>4) threshold = grayMax-6;
  485. else threshold = grayMax;
  488. return threshold;
  490. }
  492. //利用目标面积求阈值
  493. int CGravityCenter::GetWThByAera(unsigned char *sGray, WININFO sWin, int nWidth, int nHeight)
  494. {
  495. int threshold;
  496. int grayMax=0;
  497. int i,j,tmp;
  498. int his[256];
  499. for(i= 0;i<256;i++)
  500. his[i] = 0;
  501. //calculate the histogram of image
  502. for(j=sWin.pt.y-sWin.h;j<sWin.pt.y+sWin.h;j++)
  503. {
  504. for(i=sWin.pt.x-sWin.w;i<sWin.pt.x+sWin.w;i++)
  505. {
  506. tmp = sGray[i*nWidth+j];
  507. his[tmp]++;
  508. if(tmp>grayMax)
  509. grayMax = tmp;
  510. }
  511. }
  513. float rate=(sWin.w-EDGE_DRAW)*(sWin.h-EDGE_DRAW)+0.0f/(sWin.w*sWin.h);
  514.     threshold = int(grayMax-grayMax*rate);
  516. return threshold;
  518. }
  520. //调整边界窗口
  521. WININFO CGravityCenter::AdjustWindow(WININFO sWin, int sWidth, int sHeight)
  522. {
  523. WININFO win;
  524. CRect rt;
  525. rt.left = sWin.pt.x-sWin.w;
  526. rt.right = sWin.pt.x+sWin.w;
  527. rt.top = sWin.pt.y-sWin.h;
  528. rt.bottom = sWin.pt.y+sWin.h;
  530. if(rt.left<2)
  531. {
  532. rt.left = 2;
  533. rt.right = (sWin.pt.x+sWin.w)<42 ? 42:(sWin.pt.x+sWin.w);
  534. }
  535. if(rt.right>sWidth-2)
  536. {
  537. rt.right = sWidth-2;
  538. rt.left = (sWin.pt.x-sWin.w)>=(sWidth-42) ? (sWidth-42):(sWin.pt.x-sWin.w);
  539. }
  540. if(rt.top<2)
  541. {
  542. rt.top = 2;
  543. rt.bottom = (sWin.pt.y+sWin.h)<42 ? 42:(sWin.pt.y+sWin.h);
  544. }
  545. if(rt.bottom>sHeight-2)
  546. {
  547. rt.bottom = sHeight-2;
  548. rt.top = (sWin.pt.y-sWin.h)>=(sHeight-42) ? (sHeight-42):(sWin.pt.y-sWin.h);
  549. }
  551. win.w =  (rt.right-rt.left)/2;
  552. win.h =  (rt.bottom-rt.top)/2;
  553. win.pt.x = rt.left+win.w;
  554. win.pt.y = rt.top+win.h;
  555. win.flag = sWin.flag;
  557. return win;
  559. }
  561. //多目标跟踪中擦除目标
  562. void CGravityCenter::erasure(unsigned char* sGray, WININFO sWin, int sWidth, int sHeight)
  563. {
  564. int i,j;
  565. for(j=sWin.pt.y-sWin.h;j<sWin.pt.y+sWin.h;j++)
  566. {
  567. for(i=sWin.pt.x-sWin.w;i<sWin.pt.x+sWin.w;i++)
  568. {
  569. int k = sWidth*j+i;
  570. sGray[k] = (unsigned char)0;
  571. }
  572. }
  573. }
  575. //重心跟踪
  576. WININFO CGravityCenter::gvtrack(unsigned char* sGray,int sWidth, int sHeight, WININFO sWin, int sThreshold)
  577. {
  578. WININFO win;
  579. win.w = 0;
  580. win.h = 0;
  581. win.pt.x = 0;
  582. win.pt.y = 0;
  583. win.flag = FALSE;
  585. int M00bh = 0;
  586. int M01bh = 0;
  587. int M10bh = 0;
  588. int i,j,iLine;//iCol;
  589. for(j=sWin.pt.y-sWin.h;j<sWin.pt.y+sWin.h;j++)
  590. {
  591. iLine = 0;
  592. for(i=sWin.pt.x-sWin.w;i<sWin.pt.x+sWin.w;i++)
  593. {
  594. int k = sWidth*j+i;
  595. if(sGray[k]>sThreshold)
  596. {
  597. iLine++;
  598. M01bh+=i;
  599. M10bh+=j;
  600. }
  601. }
  602. M00bh+=iLine;
  603. if(win.w<iLine) win.w = iLine;
  604. if(iLine>3) win.h++;
  605. }
  607. if(M00bh>10)
  608. {
  609. win.pt.x = int(M01bh/M00bh+0.5);
  610. win.pt.y = int(M10bh/M00bh+0.5);
  611. win.w = win.w/2+EDGE_DRAW;
  612. win.h = win.h/2+EDGE_DRAW;
  613. win.flag = TRUE;
  614. }
  616. return win;
  618. }
  619. //投影找最大值法
  620. WININFO CGravityCenter::project(unsigned char* sGray, int sWidth, int sHeight, int sThreshold)
  621. {
  622. WININFO win;
  623. win.w = 0;
  624. win.h = 0;
  625. win.pt.x = 0;
  626. win.pt.y = 0;
  627. win.flag = FALSE;
  629. int X_MaxLocation=0, X_MaxLength=0;
  630. int Y_MaxLocation=0, Y_MaxLength=0;
  632. int *row, *column;
  633. row = new int[sWidth];
  634. column = new int[sHeight];
  635. memset(row,0,sWidth*sizeof(int));
  636. memset(column,0,sHeight*sizeof(int));
  638. int i,j,t;
  639. for(j=EDGE_SPACE; j<sWidth-EDGE_SPACE; j++)
  640. {
  641. for (i=EDGE_SPACE; i<sHeight-EDGE_SPACE; i++)
  642. {
  643. int k = i*sWidth+j;
  644. if(sGray[k]>sThreshold)
  645. row[j] = 1;
  646. }
  648. }
  649. for(i=EDGE_SPACE; i<sHeight-EDGE_SPACE; i++)
  650. {
  651. for (j=EDGE_SPACE; j<sWidth-EDGE_SPACE; j++)
  652. {
  653. int k = i*sWidth+j;
  654. if(sGray[k]>sThreshold)
  655. column[i] = 1;
  656. }
  658. }
  660. int location=0;
  661. int count=0;
  662. int length=0;
  663. for(t=0; t<sWidth; t++)
  664. {
  665. if(row[t] == 1)
  666. {
  667. count++;
  668. length = count;
  669. location = t-length+1;
  670. }
  671. else
  672. {
  673. count = 0;
  674. if(length>X_MaxLength)
  675. {
  676. X_MaxLocation = location;
  677. X_MaxLength = length;
  678. }
  679. }
  681. }
  683. location=0;
  684. count=0;
  685. length=0;
  686. for(t=0; t<sHeight; t++)
  687. {
  688. if(column[t] == 1)
  689. {
  690. count++;
  691. length = count;
  692. location = t-length+1;
  693. }
  694. else
  695. {
  696. count = 0;
  697. if(length>Y_MaxLength)
  698. {
  699. Y_MaxLocation = location;
  700. Y_MaxLength = length;
  701. }
  702. }
  703. }
  705. delete []row;
  706. delete []column;
  708. win.pt.x = int(X_MaxLocation+X_MaxLength/2+0.5);
  709. win.pt.y = int(Y_MaxLocation+Y_MaxLength/2+0.5);
  710. win.w = X_MaxLength/2+EDGE_DRAW;
  711. win.h = Y_MaxLength/2+EDGE_DRAW;
  712. if((X_MaxLength+Y_MaxLength)>5)
  713. win.flag = TRUE;
  715. return win;
  717. }
  719. //重心法
  720. WININFO CGravityCenter::gravity(unsigned char* sGray, int sWidth, int sHeight, int sThreshold)
  721. {
  722. WININFO win;
  723. win.w = 0;
  724. win.h = 0;
  725. win.pt.x = 0;
  726. win.pt.y = 0;
  727. win.flag = FALSE;
  729. int M00bh = 0;
  730. int M01bh = 0;
  731. int M10bh = 0;
  732. int iLine,i,j;
  733. for(j=EDGE_SPACE;j<sHeight-EDGE_SPACE;j++)
  734. {
  735. iLine = 0;
  736. for(i=EDGE_SPACE;i<sWidth-EDGE_SPACE;i++)
  737. {
  738. int k = sWidth*j+i;
  739. if(sGray[k]>sThreshold)
  740. {
  741. iLine++;
  742. M01bh+=i;
  743. M10bh+=j;
  744. }
  745. }
  746. M00bh+=iLine;
  747. if(win.w<iLine) win.w = iLine;
  748. if(iLine>0) win.h++;
  749. }
  751. if(M00bh>10)
  752. {
  753. win.pt.x = int(M01bh/M00bh+0.5);
  754. win.pt.y = int(M10bh/M00bh+0.5);
  755. win.w = win.w/2+EDGE_DRAW;
  756. win.h = win.h/2+EDGE_DRAW;
  757. win.flag = TRUE;
  758. }
  760. return win;
  762. }
  764. //找边法
  765. WININFO CGravityCenter::findEdge(unsigned char* sGray, int sWidth, int sHeight, int sThreshold, int sBlockNum)
  766. {
  767. WININFO win;
  768. win.w = 0;
  769. win.h = 0;
  770. win.pt.x = 0;
  771. win.pt.y = 0;
  772. win.flag = FALSE;
  774. int blockH = sHeight/sBlockNum;
  775. int x=0,w=0,n=0;
  776. int i,j,t=0;
  777. int tStart, tEnd;
  778. int *row = new int[sWidth];
  780. while(n<sBlockNum)
  781. {
  782. memset(row,0,sWidth*sizeof(int));
  784. for(j=EDGE_SPACE; j<sWidth-EDGE_SPACE; j++)
  785. {
  786. for (i=n*blockH; i<(n+1)*blockH; i++)
  787. {
  788. int k = i*sWidth+j;
  789. if(sGray[k]>sThreshold)
  790. row[j] = 1;
  791. }
  793. }
  795. for(t=0;t<sWidth;t++)
  796. {
  797. if(row[t]==1)
  798. {
  799. tStart=t;
  800. while(row[t]!=0) t++;
  801. tEnd = t;
  802. w = (tEnd-tStart)/2;
  803. if(w>1)
  804. {
  805. x = tStart+(tEnd-tStart)/2;
  806. break;
  807. }
  808. }
  810. }
  812. if(x>2) 
  813. {
  814. win.pt.x = x;
  815. win.pt.y = n*blockH+blockH/2;
  816. win.w = w+10;
  817. win.h = blockH/2;
  818. win.flag = TRUE;
  819. break;
  820. }
  821. else n++;
  822. }
  823. delete []row;
  824. row = NULL;
  826. return win;
  828. }