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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
MoveTrace.cpp
资源名称：VideoMove.rar　[点击查看]
上传用户：czshopping
上传日期：2022-05-22
资源大小：5430k
文件大小：22k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

MoveTrace.cpp：源码内容
  1. // MoveTrace.cpp: implementation of the CMoveTrace class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "VideoMove.h"
  7. #include "MoveTrace.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  19. CMoveTrace::CMoveTrace()
  20. {
  21. m_prect=NULL;
  22. m_pImageData=m_pGrey=m_pGrey1=m_pGrey2=m_pMosaic=NULL;
  23. }
  25. CMoveTrace::~CMoveTrace()
  26. {
  28. }
  30. bool CMoveTrace::Initialize(const int nImageWidth, const int nImageHeight, 
  31. const int nWidthCount, const int nHeightCount,
  32. const int nBitsCount)
  33. {
  34. m_nExtractWidth = m_nImageWidth  =  nImageWidth;
  35. m_nExtractHeight = m_nImageHeight =  nImageHeight;
  36. m_nX=m_nY=1;
  38. m_Count = 0; 
  40. m_rect.SetRectEmpty();
  42. m_nWidthCount = nWidthCount; //设置将屏幕分割的横向份数
  43. m_nHeightCount = nHeightCount; //设置将屏幕分割的纵向份数
  45. m_nDivisionWidth = m_nImageWidth/m_nWidthCount; //分割后的每一个小区域的宽度（象素）
  46. m_nDivisionHeight = m_nImageHeight/m_nHeightCount; //分割后的每一个小区域的高度（象素）
  48. m_prect = new CRect*[m_nHeightCount];
  49. for (int i=0;i<m_nHeightCount;++i)
  50. m_prect[i]=new CRect[nWidthCount];
  53. for(int y=0; y<m_nHeightCount; y++)
  54. {
  55. for(int x=0; x<m_nWidthCount; x++)
  56. {
  57. m_prect[y][x] = CRect(x*m_nDivisionWidth, y*m_nDivisionHeight,
  58. x*m_nDivisionWidth+m_nDivisionWidth,
  59. y*m_nDivisionHeight+m_nDivisionHeight);
  60. }
  61. }
  63. if (!m_pGrey)
  64. delete m_pGrey;
  65. m_pGrey = new BYTE[m_nImageHeight*m_nImageWidth]; 
  66. memset(m_pGrey,0,m_nImageHeight*m_nImageWidth);
  67. ////////////////////////////////////////////////
  68. if (!m_pGrey1)
  69. delete m_pGrey1;
  70. m_pGrey1 = new BYTE[m_nImageHeight*m_nImageWidth]; 
  71. memset(m_pGrey1,0,m_nImageHeight*m_nImageWidth);
  73. if (!m_pGrey2)
  74. delete m_pGrey2;
  75. m_pGrey2 = new BYTE[m_nImageHeight*m_nImageWidth]; 
  76. memset(m_pGrey2,0,m_nImageHeight*m_nImageWidth);
  78. if (!m_pMosaic)
  79. delete m_pMosaic;
  80. m_pMosaic = new BYTE[m_nImageHeight*m_nImageWidth];
  81. memset(m_pMosaic,0,m_nImageHeight*m_nImageWidth);
  83. return  m_pGrey && m_pGrey1 && m_pMosaic && m_pGrey2 && m_pImageData;
  84. }
  86. void CMoveTrace::Uninitialize()
  87. {
  88. if (m_pGrey)
  89. delete m_pGrey; 
  91. if (m_pGrey1)
  92. delete m_pGrey1;
  94. if (m_pGrey2)
  95. delete m_pGrey2;
  97. if(m_pMosaic)
  98. delete m_pMosaic;
  100. // m_prect = new CRect*[m_nHeightCount];
  101. for (int i=0;i<m_nHeightCount;++i)
  102. delete[] m_prect[i];
  103. delete[] m_prect;
  105. m_pImageData=m_pGrey=m_pGrey1=m_pGrey2=m_pMosaic=NULL;
  106. m_prect=NULL;
  108. }
  110. bool CMoveTrace::GetDIBBit(unsigned char * pImageData)
  111. {
  112. if(!pImageData)
  113. return false;
  114. m_pImageData   =  pImageData;
  116. return true;
  117. }
  119. bool CMoveTrace::Grey()
  120. {
  121. int nIndex=0,x1,y1;
  122. for(int y=0;y<m_nImageHeight;y+=m_nY)
  123. {
  124. y1=m_nImageHeight-y;
  125. for(int x=0;x<m_nImageWidth;x+=m_nX)
  126. {
  127. x1=m_nImageWidth-x;
  128. int nPos = (y1*m_nImageWidth+x1)*3;
  129. // int nTemp1 = m_pImageData[nPos];
  130. // int nTemp2 = m_pImageData[nPos+1];
  131. // int nTemp3 = m_pImageData[nPos+2];
  132. // m_pGrey1[x/m_nX+y*m_nExtractWidth/m_nY] = 
  133. m_pGrey1[nIndex++] = 
  134. static_cast<unsigned char>(m_pImageData[nPos+2]*0.3+m_pImageData[nPos+1]*0.59+m_pImageData[nPos]*0.11);
  135. }
  136. }
  137. return true;
  138. }
  141. void CMoveTrace::Dither(int nThreshold)
  142. {
  143. double dbTotalValue=0;
  144. int nTotal=m_nExtractHeight*m_nExtractWidth;
  145. int nIndex=0;
  146. for (int i=0;i<nTotal;++i)
  147. {
  148. (*(m_pMosaic+nIndex))=
  149. (*(m_pMosaic+nIndex))>nThreshold ? 255:0;
  150. ++nIndex;
  151. }
  152. }
  154. int CMoveTrace::Sobel()
  155. {
  156. int ImageValue,ImageValueX,ImageValueY;
  158. unsigned char *pImageDataTemp;
  159. pImageDataTemp=new unsigned char[m_nExtractWidth*m_nExtractHeight];
  160. if (pImageDataTemp==NULL)
  161. {
  162. return 0;//内存分配错误
  163. }
  165. memcpy(pImageDataTemp, m_pGrey1, m_nExtractWidth*m_nExtractHeight);
  166. int nPos=m_nExtractWidth;
  167. int i_end=m_nExtractHeight-1;
  168. int j_end=m_nExtractWidth-1;
  169. for (int i=1;i<i_end;++i)
  170. {
  171. for (int j=1;j<j_end;++j)
  172. {
  173. ImageValueX=-(*(pImageDataTemp+nPos-m_nExtractWidth+j-1)) 
  174. -2*(*(pImageDataTemp+nPos-m_nExtractWidth+j))
  175. -(*(pImageDataTemp+nPos-m_nExtractWidth+j+1))
  176. +(*(pImageDataTemp+nPos+m_nExtractWidth+j-1))
  177. +2*(*(pImageDataTemp+nPos+m_nExtractWidth+j))
  178. +(*(pImageDataTemp+nPos+m_nExtractWidth+j+1));
  180. ImageValueY=-(*(pImageDataTemp+nPos-m_nExtractWidth+j-1))
  181. +(*(pImageDataTemp+nPos-m_nExtractWidth+j))
  182. -2*(*(pImageDataTemp+nPos+j-1))
  183. +2*(*(pImageDataTemp+nPos+j+1))
  184. -(*(pImageDataTemp+nPos+m_nExtractWidth+j-1))
  185. +(*(pImageDataTemp+nPos+m_nExtractWidth+j+1));
  187. ImageValue=abs(max(ImageValueX,ImageValueY));
  188. if (ImageValue>255)
  189. {
  190. *(m_pGrey1+nPos+j)=255;
  191. }
  192. else
  193. {
  194. *(m_pGrey1+nPos+j)=static_cast<unsigned char>(ImageValue);
  195. }
  196. }
  197. nPos+=m_nExtractWidth;
  198. }
  199. delete [] pImageDataTemp;
  200. return 1;
  202. }
  204. BOOL CMoveTrace::FrameMinus()
  205. {
  206. for(int x=0; x<m_nExtractWidth*m_nExtractHeight; ++x)
  207. {
  208. m_pGrey[x]=abs(m_pGrey1[x] - m_pGrey2[x]);
  209. }
  211. return TRUE;
  212. }
  214. void CMoveTrace::Mosaic(int nMosaicWidth,const int nMosaicHeight)
  215. {
  216. m_nMosaicWidth = nMosaicWidth;
  217. m_nMosaicHeight = nMosaicHeight;
  219. int nW,nH;
  220. nW=m_nExtractWidth/nMosaicWidth;
  221. nH=m_nExtractHeight/nMosaicHeight;
  223. // nW=m_nImageWidth%nMosaicWidth==0 ? m_nImageWidth/nMosaicWidth : m_nImageWidth/nMosaicWidth;
  224. // nH=m_nImageHeight%nMosaicHeight==0?m_nImageHeight/nMosaicHeight : m_nImageHeight/nMosaicHeight;
  226. double dbTemp;
  227. int nTemp;
  228. int nArea=nMosaicWidth*nMosaicHeight;
  229. // unsigned char nImageValue;
  230. int i,j,ii,jj;
  232. int n_i_pos=0;
  233. int n_j_pos=0;
  234. int n_ii_pos=0;
  235. int n_jj_pos=0;
  236. for (i=0;i<nH;++i)
  237. {
  238. n_j_pos=0;
  239. for (j=0;j<nW;++j)
  240. {
  241. dbTemp=0;
  242. for (ii=0;ii<nMosaicHeight;++ii)
  243. {
  244. n_ii_pos=(n_i_pos+ii)*m_nExtractWidth+n_j_pos;
  245. for (jj=0;jj<nMosaicWidth;++jj)
  246. {
  247. dbTemp+=m_pGrey[n_ii_pos+jj];
  248. }
  250. }
  251. nTemp=static_cast<BYTE>(dbTemp/nArea);
  252. for (ii=0;ii<nMosaicHeight;++ii)
  253. {
  254. n_ii_pos=(n_i_pos+ii)*m_nExtractWidth+n_j_pos;
  255. for (jj=0;jj<nMosaicWidth;++jj)
  256. {
  257. m_pMosaic[n_ii_pos+jj]=nTemp;
  258. }
  259. }
  260. n_j_pos+=nMosaicWidth;
  262. }
  263. n_i_pos+=nMosaicHeight;
  264. }
  265. }
  267. void CMoveTrace::SaveFrame()
  268. {
  269. int nTotal=m_nExtractWidth*m_nExtractHeight;
  270. for(int x=0; x<nTotal; ++x)
  271. {
  272. m_pGrey2[x] = m_pGrey1[x];
  273. }
  274. }
  276. /*
  277. int CMoveTrace::Mean()
  278. {
  279. double dbTotalValue=0;
  280. for (int i=0;i<m_nImageHeight;++i)
  281. {
  282. for (int j=0;j<m_nImageWidth;++j)
  283. {
  284. dbTotalValue+=*(m_pImageData+i*m_nImageWidth+j);
  285. }
  286. }
  287. return static_cast<int>(dbTotalValue/(m_nImageHeight*m_nImageWidth));
  288. }
  289. */
  292. bool CMoveTrace::Rectangle(CRect &rect,const int nMaxWidth, const int nMinChange)
  293. {
  294. CRect tempRect;
  295. POINT centerPoint, tmpPoint;
  296. centerPoint.x = m_nExtractWidth/2;
  297. centerPoint.y = m_nExtractHeight/2;
  299. int i,j;
  300. bool bTopFind=false;
  301. bool bBottomFind=false;
  302. int nIndex=0;
  303. for (i=0;i<m_nExtractHeight;++i)
  304. {
  305. for (j=0;j<m_nExtractWidth;++j)
  306. {
  307. if (*(m_pMosaic+nIndex)!=0 && !bTopFind)
  308. tempRect.top=m_nExtractHeight-1-i, tempRect.left=j, bTopFind=true;
  309. else if (*(m_pMosaic+nIndex)!=0 && bTopFind && tempRect.left>j)
  310. tempRect.left=j;
  311. ++nIndex;
  313. }
  314. }
  316. nIndex=m_nExtractWidth*m_nExtractHeight-1;
  317. for (i=m_nExtractHeight-1;i>-1 && bTopFind ;--i)
  318. {
  319. for (j=m_nExtractWidth-1;j>-1;--j)
  320. {
  321. if (*(m_pMosaic+nIndex)!=0 && !bBottomFind)
  322. tempRect.bottom=m_nExtractHeight-1-i, tempRect.right=j, bBottomFind=true;
  323. else if (*(m_pMosaic+nIndex)!=0 && bBottomFind && tempRect.right<j)
  324. tempRect.right=j;
  325. --nIndex;
  326. }
  327. }
  329. //交换top和bottom的值
  330. int temp = tempRect.top;
  331. tempRect.top = tempRect.bottom;
  332. tempRect.bottom = temp;
  334. //如果发现的活动区域过大（大于分割的矩形区域）则忽略
  335. if(tempRect.Width()>=m_nDivisionWidth ||
  336. tempRect.Height()>=m_nDivisionHeight)
  337. return false;
  339. if(bTopFind && bBottomFind && m_Count==0)//发现有新的运动物体
  340. {
  341. m_rect = tempRect;
  343. rect.left = m_rect.left*m_nX;
  344. rect.right = m_rect.right*m_nX;
  345. rect.top = m_rect.top*m_nY;
  346. rect.bottom = m_rect.bottom*m_nY;
  348. m_Count = 1; //设置有运动物体的标志
  349. Forecast(rect); //求得运动物体在屏幕中的位置
  351. return true;
  352. }
  353. else if (!(bTopFind && bBottomFind) && m_Count == 1)//如果没有找到运动物体但是有运动物体
  354. {
  356. tmpPoint = m_rect.CenterPoint();
  358. BOOL bFlag = abs(tmpPoint.x-centerPoint.x)<nMaxWidth;
  359. //如果运动物体的中心到监视区域中心的距离时候小于预设值,
  360. //则认为物体没有消失,否则物体消失
  361. if(bFlag)
  362. {
  363. //将上次的框保留下来
  364. rect.left = m_rect.left*m_nX;
  365. rect.right = m_rect.right*m_nX;
  366. rect.top = m_rect.top*m_nY;
  367. rect.bottom = m_rect.bottom*m_nY;
  369. Forecast(rect);
  371. return true;
  372. }
  373. else
  374. {
  375. //认为没有运动物体,将变量复位
  376. m_Count = 0;
  377. m_rect.SetRectEmpty();
  379. return false;
  380. }
  381. }
  382. else if(m_Count == 1 && bTopFind && bBottomFind)//有物体并且检测到有运动(有白点产生)
  383. {
  384. int nChangePix = m_nMosaicWidth*nMinChange;
  385. int nH=tempRect.Height();
  386. int nW=tempRect.Width();
  387. //如果检测到物体的运动范围小于最小运动范围(nMinChange*m_nMosaicWidth)
  388. //将范围适当变大
  389. // if (min(abs(nH),abs(nW) )<nMinChange*m_nMosaicWidth )
  390. if (nH<nMinChange*m_nMosaicHeight || nW<nMinChange*m_nMosaicWidth )
  391. {
  392. tempRect.left-=m_nMosaicWidth*2;
  393. tempRect.left = (tempRect.left<0) ? 0: tempRect.left;
  395. tempRect.right+=m_nMosaicWidth*2;
  396. tempRect.right = (tempRect.right>m_nImageWidth)? m_nImageWidth : tempRect.right;
  398. tempRect.bottom+=m_nMosaicHeight*2;
  399. tempRect.bottom = (tempRect.bottom>m_nImageHeight) ? m_nImageHeight : tempRect.bottom;
  401. tempRect.top-=m_nMosaicHeight*2;
  402. tempRect.top = (tempRect.top<0) ? 0 : tempRect.top;
  403. }
  405. int ntempTop =  abs(tempRect.top - m_rect.top); //得到这次的纵向的运动范围和上次的纵向运动范围的
  406. int ntempBottom = abs(tempRect.bottom - m_rect.bottom); //和上次的纵向运动范围的绝对值
  408. //如果变化过大,则调整变化速度
  409. if( ntempTop>nChangePix || ntempBottom>nChangePix)
  410. {
  411. m_rect.left = tempRect.left;
  412. m_rect.right = tempRect.right;
  413. if(abs(tempRect.bottom-m_rect.bottom) > nChangePix)
  414. tempRect.bottom-m_rect.bottom > 0 ? m_rect.bottom+=nChangePix : m_rect.bottom-=nChangePix;
  415. if(abs(tempRect.top-m_rect.top) > nChangePix)
  416. tempRect.top-m_rect.top > 0 ? m_rect.top+=nChangePix : m_rect.top-=nChangePix;
  417. }
  419. m_rect=tempRect;
  421. rect.left = m_rect.left*m_nX;
  422. rect.right = m_rect.right*m_nX;
  423. rect.top = m_rect.top*m_nY;
  424. rect.bottom = m_rect.bottom*m_nY;
  426. Forecast(rect);
  428. return true;
  430. }
  432. return false;
  434. }
  437. bool CMoveTrace::Rectangle2(CRect &rect, const int nMaxWidth, const int nMinChange)
  438. {
  439. CRect tempRect;
  440. POINT centerPoint, tmpPoint;
  441. centerPoint.x = m_nExtractWidth/2;
  442. centerPoint.y = m_nExtractHeight/2;
  443. int nMosaicArea = m_nMosaicWidth*m_nMosaicHeight;
  445. long nWhiteCount = 1;
  446. long nTempX = 0;
  447. long nTempY = 0;
  448. for(int y=1; y<m_nExtractHeight-1; ++y)
  449. {
  450. for(int x=1; x<m_nExtractWidth-1; ++x)
  451. {
  452. if((255==m_pMosaic[x+y*m_nExtractWidth])
  453. && (255==m_pMosaic[x+m_nExtractWidth+y*m_nExtractWidth])
  454. //&& (255==lpVideo->m_pGrey1[x+1+y*lpVideo->m_iWidth])
  455. )
  456. {
  457. ++nWhiteCount;
  458. nTempX += x;
  459. nTempY += y;
  460. }
  461. }
  462. }
  463. nTempX = nTempX/nWhiteCount;
  464. nTempY = m_nExtractHeight-1-nTempY/nWhiteCount;
  465. // nTempY = nTempY/nWhiteCount;
  466. long nharfTempW = nWhiteCount/nMosaicArea/m_nX; //矩形框的半宽度
  467. long nharfTempH = nharfTempW*3; //矩形框的半高度
  469. // tempRect.left = abs(nTempX-nharfTempW);
  470. // tempRect.top = abs(nTempY-nharfTempH);
  471. (nTempX-nharfTempW)<0 ? tempRect.left = 0 : tempRect.left = nTempX-nharfTempW;
  472. (nTempY-nharfTempH)<0 ? tempRect.top = 0 : tempRect.top = nTempY-nharfTempH;
  473. (nTempX+nharfTempW)>m_nExtractWidth ? tempRect.right = m_nExtractWidth : tempRect.right = nTempX+nharfTempW;
  474. (nTempY+nharfTempH)>m_nExtractHeight ? tempRect.bottom = m_nExtractHeight : tempRect.bottom = nTempY+nharfTempH;
  476. if(tempRect.left==0  && tempRect.right==m_nExtractWidth && tempRect.top==0 && tempRect.bottom==m_nExtractHeight)
  477. return false;
  479. if(nWhiteCount>=nMosaicArea && m_rect.IsRectNull())//发现有新的运动物体
  480. {
  481. m_rect = tempRect;
  482. rect.left = m_rect.left*m_nX;
  483. rect.right = m_rect.right*m_nX;
  484. rect.top = m_rect.top*m_nY;
  485. rect.bottom = m_rect.bottom*m_nY;
  486. m_Count = 1;
  487. return true;
  488. }
  489. else if (m_Count == 1 && nWhiteCount<nMosaicArea)
  490. {
  491. tmpPoint = m_rect.CenterPoint();
  492. BOOL bFlag;
  493. bFlag = abs(tmpPoint.x-centerPoint.x) < nMaxWidth;
  494. if(bFlag)
  495. {
  496. rect.left = m_rect.left*m_nX;
  497. rect.right = m_rect.right*m_nX;
  498. rect.top = m_rect.top*m_nY;
  499. rect.bottom = m_rect.bottom*m_nY;
  500. return true;
  501. }
  502. else
  503. {
  504. m_Count = 0;
  505. m_rect.SetRectEmpty();
  506. rect = m_rect;
  507. return false;
  508. }
  509. }
  510. else if(m_Count == 1 && nWhiteCount>=nMosaicArea)
  511. {
  512. // int nH=tempRect.Height();
  513. int nW=tempRect.Width();
  514. int nChangePix = m_nMosaicWidth*nMinChange;
  516. if (nW<nMinChange*m_nMosaicWidth)// (min(nH,nW)<nMinChange*m_nMosaicWidth )
  517. {
  519. tempRect.left-=m_nMosaicWidth*2;
  520. if (tempRect.left < 0)
  521. tempRect.left=0;
  523. tempRect.right+=m_nMosaicWidth*2;
  524. if (tempRect.right > m_nExtractWidth)
  525. tempRect.right = m_nExtractWidth;
  527. tempRect.top-=m_nMosaicHeight*2;
  528. if (tempRect.top < 0)
  529. tempRect.top=0;
  531. tempRect.bottom+=m_nMosaicHeight*2;
  532. if (tempRect.bottom>m_nExtractHeight)
  533. tempRect.bottom = m_nExtractHeight;
  535. }
  537. int ntempTop =  abs(tempRect.top - m_rect.top);
  538. int ntempBottom = abs(tempRect.bottom - m_rect.bottom);
  539. if( ntempTop>nChangePix || ntempBottom>nChangePix)
  540. {
  541. // if(abs(tempRect.left-m_rect.left) > nChangePix)
  542. // tempRect.left-m_rect.left > 0 ? m_rect.left+=nChangePix : m_rect.left-=nChangePix;
  543. //
  544. // if(abs(tempRect.right-m_rect.right) > nChangePix)
  545. // tempRect.right-m_rect.right > 0 ? m_rect.right+=nChangePix : m_rect.right-=nChangePix;
  546. m_rect.left = tempRect.left;
  547. m_rect.right = tempRect.right;
  548. if(abs(tempRect.bottom-m_rect.bottom) > nChangePix)
  549. tempRect.bottom-m_rect.bottom > 0 ? m_rect.bottom+=nChangePix : m_rect.bottom-=nChangePix;
  550. if(abs(tempRect.top-m_rect.top) > nChangePix)
  551. tempRect.top-m_rect.top > 0 ? m_rect.top+=nChangePix : m_rect.top-=nChangePix;
  553. rect.left = m_rect.left*m_nX;
  554. rect.right = m_rect.right*m_nX;
  555. rect.top = m_rect.top*m_nY;
  556. rect.bottom = m_rect.bottom*m_nY;
  557. return true;
  558. }
  560. m_rect=tempRect;
  561. rect.left = m_rect.left*m_nX;
  562. rect.right = m_rect.right*m_nX;
  563. rect.top = m_rect.top*m_nY;
  564. rect.bottom = m_rect.bottom*m_nY;
  565. return true;
  566. }
  567. return false;
  568. }
  571. bool CMoveTrace::Extract(int nX, int nY)
  572. {
  573. if (nX && nY)
  574. {
  575. m_nExtractWidth=m_nImageWidth/nX;
  576. m_nExtractHeight=m_nImageHeight/nY;
  578. m_nX=nX,m_nY=nY;
  581. return true;
  582. }
  583. else
  584. return false;
  586. }
  588. void CMoveTrace::Forecast(CRect rect)
  589. {
  590. if(NULL==m_prect) AfxMessageBox("没有初始化!");
  592. int x,y;
  593. for(y=0;y<m_nHeightCount;y++)
  594. {
  595. for(x=0;x<m_nWidthCount;x++)
  596. {
  597. if( m_prect[y][x].PtInRect(CPoint(rect.left, rect.top))
  598. && m_prect[y][x].PtInRect(CPoint(rect.right, rect.top))
  599. && m_prect[y][x].PtInRect(rect.CenterPoint()) )
  600. {
  601. m_NextRect = m_CurrentRect;
  602. m_CurrentRect = m_prect[y][x];
  603. break;
  604. }
  605. else
  606. {
  607. //--------------
  608. }
  609. }
  610. }
  612. /* if(NULL==m_prect) AfxMessageBox("没有初始化!");
  614. int x,y;
  616. for(y=0;y<m_nHeightCount;y++)
  617. {
  618. for(x=0;x<m_nWidthCount;x++)
  619. {
  620. if(m_prect[y][x].PtInRect(rect.CenterPoint()))
  621. {
  622. m_NextRect = m_CurrentRect = m_prect[y][x];
  624. //判断下一个是否在左上的单元
  625. if(nIndex/m_nWidthCount>0 && nIndex%m_nWidthCount>0)
  626. {
  627. if(rect.left <= m_prect[nIndex-m_nWidthCount-1].right
  628. && rect.top <= m_prect[nIndex-m_nWidthCount-1].bottom)
  629. {
  630. m_NextRect = m_prect[nIndex-m_nWidthCount-1];
  631. break;
  632. }
  633. }
  635. //判断下一个是否在左边的单元
  636. //if(nIndex-1 >= 0)
  637. if(nIndex%m_nWidthCount>0)
  638. {
  639. if(rect.left <= m_prect[nIndex-1].right
  640. && rect.bottom < m_prect[nIndex-1].bottom
  641. && rect.top > m_prect[nIndex-1].top)
  642. {
  643. m_NextRect = m_prect[nIndex-1];
  644. break;
  645. }
  646. }
  648. //判断下一个是否在左下边的单元
  649. //if(nIndex+m_nWidthCount-1 < m_nWidthCount*m_nHeightCount)
  650. if( (nIndex/m_nWidthCount<m_nHeightCount-1) &&
  651. (nIndex%m_nWidthCount>0) )
  652. {
  653. if(rect.left <= m_prect[nIndex+m_nWidthCount-1].right
  654. && rect.bottom >= m_prect[nIndex+m_nWidthCount-1].top)
  655. {
  656. m_NextRect = m_prect[nIndex+m_nWidthCount-1];
  657. break;
  658. }
  659. }
  661. //判断下一个是否在右上边的单元
  662. if( nIndex/m_nWidthCount>0 
  663. && (nIndex%m_nWidthCount < m_nWidthCount-1) ) //该单元必须有上一排单元
  664. {
  665. if(rect.right >= m_prect[nIndex-m_nWidthCount+1].left
  666. && rect.top <= m_prect[nIndex-m_nWidthCount+1].bottom) 
  667. {
  668. m_NextRect = m_prect[nIndex-m_nWidthCount+1];
  669. break;
  670. }
  671. }
  673. //判断下一个是否在右边的单元
  674. if(nIndex%m_nWidthCount < m_nWidthCount-1)
  675. {
  676. if(rect.right >= m_prect[nIndex+1].left
  677. && rect.top > m_prect[nIndex+1].top
  678. && rect.bottom < m_prect[nIndex+1].bottom)
  679. {
  680. m_NextRect = m_prect[nIndex+1];
  681. break;
  682. }
  683. }
  685. //判断下一个是否在右下边的单元
  686. //if(nIndex+m_nWidthCount+1 < m_nWidthCount*m_nHeightCount)
  687. if( (nIndex%m_nWidthCount < m_nWidthCount-1) 
  688. && (nIndex/m_nWidthCount<m_nHeightCount-1) )
  689. {
  690. if(rect.right >= m_prect[nIndex+m_nWidthCount+1].left
  691. &&rect.bottom >= m_prect[nIndex+m_nWidthCount+1].top)
  692. {
  693. m_NextRect = m_prect[nIndex+m_nWidthCount+1];
  694. break;
  695. }
  696. }
  698. //判断下一个是否在上边的单元
  699. if( nIndex/m_nWidthCount>0 )
  700. {
  701. if(rect.top <= m_prect[nIndex-m_nWidthCount].bottom
  702. && rect.left > m_prect[nIndex-m_nWidthCount].left
  703. && rect.right < m_prect[nIndex-m_nWidthCount].right)
  704. {
  705. m_NextRect = m_prect[nIndex-m_nWidthCount];
  706. break;
  707. }
  708. }
  710. //判断下一个是否在下边的单元
  711. //if(nIndex+m_nWidthCount < m_nWidthCount*m_nHeightCount)
  712. if( nIndex/m_nWidthCount<m_nHeightCount-1 )
  713. {
  714. if(rect.bottom >= m_prect[nIndex+m_nWidthCount].top
  715. && rect.left > m_prect[nIndex+m_nWidthCount].left
  716. && rect.right < m_prect[nIndex+m_nWidthCount].right)
  717. {
  718. m_NextRect = m_prect[nIndex+m_nWidthCount];
  719. break;
  720. }
  721. }
  723. }//if(m_prect[nIndex].PtInRect(rect.CenterPoint()))
  724. nIndex++;
  725. }//for(x=0;x<m_nWidthCount;x++)
  727. }
  728. */
  729. }
  731. void CMoveTrace::JudgeAnalysis(int off)
  732. {
  733. /*int isize = m_nExtractWidth*m_nExtractHeight;//抽取后高度
  734. unsigned char* result = m_pGrey1+off*isize;
  735. int width=m_nExtractWidth;
  736. int height=m_nExtractHeight;
  737.     double variance[256];
  738. int i, j, threshold;
  739. int level, Th;
  740. double bmax=0.0;
  741. double mean, mean1, mean2;
  742. double counter, counter1, counter2;
  743. double sum, sum1, sum2;
  745. //get the maximum grey level of original image
  746.     level=-9999;
  747. int nIndex=0;
  748. for(i=0; i<height; i++) 
  749. { 
  750. for(j=0; j<width; j++) 
  751. {
  753. level=(level<m_pGrey1[nIndex]) ? m_pGrey1[nIndex] : level;
  754. ++nIndex;
  755. }
  756. }
  758. if(level<=1)  return ;
  759. counter=(double)isize;
  761. //get the globel mean value
  762. sum=0.0;
  763. nIndex=0;
  764. for(i=0; i<height; i++) 
  765. {
  766. for(j=0; j<width; j++) 
  767. {
  768. sum=sum+m_pGrey1[nIndex];
  769.             mean=sum/counter;
  770. ++nIndex;
  771. }
  773. }*/
  774. /********* the beginning of Th loop ********
  775. grey less than threshold Th belong to Class 1;
  776. grey more than threshold Th belong to Class 2;
  777. where Th=0, 1, 2, 3, ..., level         ************/
  778. /* for(Th=0; Th<=level; Th++)
  779. {
  780. //get the mean value of every class
  781. sum1=0.0; 
  782. sum2=0.0;
  783. counter1=0;
  784. counter2=0;
  785. for(i=0; i<height; i++) 
  786. {
  787. int line=i*width;
  788. for(j=0; j<width; j++) 
  789. {
  790. if(m_pGrey1[line+j]<Th)
  791. {
  792. counter1=counter1+1;
  793. sum1=sum1+m_pGrey1[line+j];
  794. }
  795. else
  796. {
  797. counter2=counter2+1;
  798. sum2=sum2+m_pGrey1[line+j];
  799. }
  801. }
  802. }
  803. if(counter1>0) mean1=sum1/counter1;
  804. else mean1=0;
  805.         if(counter2>0) mean2=sum2/counter2;
  806. else mean2=0;
  807. //calcuate the variance between classes
  808. variance[Th]=counter1*counter2*(mean1-mean2)*(mean1-mean2);
  809. }
  810. // get maximum variance to determine the best threshold
  811. for(Th=1; Th<=level; Th++)
  812. {
  813. if(bmax<variance[Th])
  814. {
  815. bmax=variance[Th];
  816. threshold=Th;
  817. }
  818. }
  819. ///////////////////////////////
  820. // do thresholding
  821. for(i=0; i<height-22; i++) 
  822. {
  823. int line=i*width;
  824. for(j=0; j<width; j++) 
  825. {
  826. result[line+j] = (m_pGrey1[line+j] >= threshold) ? 255: 0;
  827. }
  828. }*/
  829. ///////////////////////////
  830. }
  833. int CMoveTrace::GetThreshold(const int nMinThreshold)
  834. {
  835. //循环变量
  836. long i;
  838. //直方图数组
  839. long lHistogram[256];
  841. //阈值，最大灰度值与最小灰度值，两个区域的平均灰度值
  842. unsigned char iThreshold,iNewThreshold,iMaxGrayValue,iMinGrayValue,iMean1GrayValue,iMean2GrayValue;
  844. //用于计算区域灰度平均值的中间变量
  845. long lP1,lP2,lS1,lS2;
  847. //迭代次数
  848. int iIterationTimes;
  850. memset(lHistogram,0,sizeof(lHistogram));
  852. //获得直方图
  853. iMaxGrayValue = 0;
  854. iMinGrayValue = 255;
  855. int nIndex=0;
  856. int nTotal=m_nExtractWidth*m_nExtractHeight;
  857. for (i = 0;i < nTotal ;i++)
  858. {
  859. lHistogram[m_pGrey1[nIndex]]++;
  860. //修改最大，最小灰度值
  861. if(iMinGrayValue > m_pGrey1[nIndex])
  862. {
  863. iMinGrayValue = m_pGrey1[nIndex];
  864. }
  865. if(iMaxGrayValue < m_pGrey1[nIndex])
  866. {
  867. iMaxGrayValue = m_pGrey1[nIndex];
  868. }
  869. ++nIndex;
  870. }
  872. //迭代求最佳阈值
  873. iNewThreshold = (iMinGrayValue + iMaxGrayValue)/2;
  874. iThreshold = 0;
  876. for(iIterationTimes = 0; iThreshold != iNewThreshold && iIterationTimes < 100;iIterationTimes ++)
  877. {
  878. iThreshold = iNewThreshold;
  879. lP1 =0;
  880. lP2 =0;
  881. lS1 = 1;
  882. lS2 = 1;
  884. //求两个区域的灰度平均值
  885. for (i = iMinGrayValue;i < iThreshold;i++)
  886. {
  887. lP1 += lHistogram[i]*i;
  888. lS1 += lHistogram[i];
  889. }
  890. iMean1GrayValue = (unsigned char)(lP1 / lS1);
  892. for (i = iThreshold+1;i < iMaxGrayValue;i++)
  893. {
  894. lP2 += lHistogram[i]*i;
  895. lS2 += lHistogram[i];
  896. }
  897. iMean2GrayValue = (unsigned char)(lP2 / lS2);
  899. iNewThreshold =  (iMean1GrayValue + iMean2GrayValue)/2;
  900. }
  901. TRACE(";;;;;;;;;;;;;;;;;;;;;;;;;;;%d",iThreshold);
  902. return max(nMinThreshold, iThreshold);
  904. }