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

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

图形图象

开发平台：

Visual C++

StaticDetect.cpp：源码内容
  1. /*******************************************************************
  2. Motion target detection methods in video
  3. Author: jianglong
  4. date: 2006.06
  5. Compiler: Microsoft Visual C++ 6.0 
  6. ********************************************************************/
  7. #include "stdafx.h"
  8. //#include "Motiontrack.h"
  9. #include "StaticDetect.h"
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. //////////////////////////////////////////////////////////////////////
  18. // Construction/Destruction
  19. //////////////////////////////////////////////////////////////////////
  21. CStatsticDetect::CStatsticDetect(int nwidth, int nheight)
  22. {
  23. m_nFrame = 0;
  24. count = 0;
  25. WIDTH = nwidth;
  26. HEIGHT = nheight;
  27. IMAGESIZE = WIDTH*HEIGHT;
  29. m_pCurImage = new BYTE[IMAGESIZE*3];
  30. memset(m_pCurImage,0,IMAGESIZE*3);
  31. m_pGrayImage = new BYTE[IMAGESIZE];
  32. memset(m_pGrayImage,0,IMAGESIZE);
  33. m_pBackground = new BYTE[IMAGESIZE];
  34. memset(m_pBackground,0,IMAGESIZE);
  35. m_pBgImage = new BYTE[IMAGESIZE*3];
  36. memset(m_pBgImage,0,IMAGESIZE*3);
  37.     m_pDiffImage = new BYTE[IMAGESIZE]; 
  38. memset(m_pDiffImage,0,IMAGESIZE);
  39. m_pDetectImage = new BYTE[IMAGESIZE*3];
  40. memset(m_pDetectImage,0,IMAGESIZE*3);
  41. m_pBackHistgram = new short int[IMAGESIZE*256];
  42. memset(m_pBackHistgram,0,IMAGESIZE*256*sizeof(short int));
  43. m_pTemplate = new UINT[IMAGESIZE];
  44. memset(m_pTemplate,0,IMAGESIZE*sizeof(UINT));
  45. m_pPreGrayImage = new BYTE[IMAGESIZE];
  46. memset(m_pPreGrayImage,0,IMAGESIZE);
  47. image1 = new BYTE[IMAGESIZE];
  48. memset(image1,0,IMAGESIZE);
  49. image2 = new BYTE[IMAGESIZE];
  50. memset(image2,0,IMAGESIZE);
  51. image3 = new BYTE[IMAGESIZE];
  52. memset(image3,0,IMAGESIZE);
  53. image4 = new BYTE[IMAGESIZE];
  54. memset(image4,0,IMAGESIZE);
  55. }
  57. CStatsticDetect::~CStatsticDetect()
  58. {
  59. delete []m_pBackHistgram;
  60. delete []m_pDiffImage;
  61. delete []m_pBgImage;
  62. delete []m_pGrayImage;
  63. delete []m_pBackground;
  64. delete []m_pDetectImage;
  65. delete []m_pCurImage;
  66. delete []m_pTemplate;
  67. delete []image1;
  68. delete []image2;
  69. delete []image3;
  70. delete []image4;
  72. }
  73. void CStatsticDetect::ReceiveFrame(int index,BYTE* sBuf, DETECT_METHOD sMethod)
  74. {
  75. m_nFrame = index;
  76. memcpy(m_pCurImage,sBuf,WIDTH*HEIGHT*3);
  77. RGBToYUV(m_pCurImage,m_pGrayImage,WIDTH,HEIGHT);
  78. // if(index==1256)
  79. // SaveBmp(m_pGrayImage,WIDTH,HEIGHT,8,index);
  81. switch(sMethod)
  82. {
  83. case D_MULDIFFER:
  84. // ImageCopy(m_pGrayImage, m_nFrame);
  85. // if(m_nFrame>2)
  86. // {
  87. // MDiffImage(m_pDiffImage,WIDTH,HEIGHT,15);
  88. // DeNoise(m_pDiffImage,WIDTH,HEIGHT);
  89. //// SaveBmp(m_pDiffImage,WIDTH,HEIGHT,8,index);
  90. // }
  92. if(m_nFrame>0)
  93. {
  94. DiffImage(m_pGrayImage,m_pPreGrayImage,WIDTH,HEIGHT,20);
  95. DeNoise(m_pDiffImage,WIDTH,HEIGHT);
  96. }
  97. memcpy(m_pPreGrayImage,m_pGrayImage,IMAGESIZE);
  98. break;
  99. case D_MULMEAN:
  100. GetMultiData(m_pGrayImage,WIDTH,HEIGHT);
  102. if(m_nFrame>BACK_ALL_NUM)
  103. {
  104. if(m_nFrame==(BACK_ALL_NUM+1))
  105. {
  106. GetBgImage();
  107. memset(m_pTemplate,0,IMAGESIZE*sizeof(UINT));
  108. count = 0;
  109. SaveBmp(m_pBackground,WIDTH,HEIGHT,8,index);
  111. }
  112. else if(m_nFrame%(2*BACK_ALL_NUM)==1) //更新背景图像
  113. {
  114. GetBgImage();
  115. memset(m_pTemplate,0,IMAGESIZE*sizeof(UINT));
  116. count = 0;
  117. SaveBmp(m_pBackground,WIDTH,HEIGHT,8,index);
  119. }
  121. DiffImage(m_pGrayImage,m_pBackground,WIDTH,HEIGHT,THRESHOLD);
  122. DeNoise(m_pDiffImage,WIDTH,HEIGHT);
  123. }
  125. break;
  126. case D_STATISTIC:
  127. if(m_nFrame%BACK_SEQ_NUM==1)
  128. SetBgHistgram(m_pBackHistgram,m_pGrayImage,WIDTH,HEIGHT);
  130. if(m_nFrame>BACK_ALL_NUM)
  131. {
  132. if(m_nFrame==(BACK_ALL_NUM+1))
  133. {
  134. GetBgByHistgram(m_pBackHistgram,m_pBackground,WIDTH,HEIGHT);
  135. memset(m_pBackHistgram,0,WIDTH*HEIGHT*256*sizeof(short int));
  136. // SaveBmp(m_pBackground,WIDTH,HEIGHT,8,index);
  138. }
  139. else if(m_nFrame%(3*BACK_ALL_NUM)==1) //更新背景图像
  140. {
  141. GetBgByHistgram(m_pBackHistgram,m_pBackground,WIDTH,HEIGHT);
  142. memset(m_pBackHistgram,0,WIDTH*HEIGHT*256*sizeof(short int));
  143. // SaveBmp(m_pBackground,WIDTH,HEIGHT,8,index);
  145. }
  146. DiffImage(m_pGrayImage,m_pBackground,WIDTH,HEIGHT,THRESHOLD);
  147. DeNoise(m_pDiffImage,WIDTH,HEIGHT);
  148. if(index==1257)
  149. SaveBmp(m_pDiffImage,WIDTH,HEIGHT,8,index);
  151. }
  152. break;
  153. default:
  154. break;
  155. }
  157. }
  159. void CStatsticDetect::RGBToYUV(BYTE *sRGB,BYTE *sGray,int nWidth, int nHeight)
  160. {
  161. int i,j;
  162. for(j=0;j<nHeight;j++)
  163. {
  164. for(i=0;i<nWidth;i++)
  165. {
  166. sGray[nWidth*j+i]=(11*sRGB[3*(nWidth*j+i)]+59*sRGB[3*(nWidth*j+i)+1]+30*sRGB[3*(nWidth*j+i)+2])/100;
  167. }
  168. }
  170. }
  172. void CStatsticDetect::SetBgHistgram(short int *pHistgram, BYTE *sGray,int nWidth, int nHeight)
  173. {
  174. for(int j=0;j<nHeight;j++)
  175. {
  176. for(int i=0;i<nWidth;i++)
  177. {
  178. int p=*(sGray+j*nWidth+i)+256*(j*nWidth+i);
  179. *(pHistgram+p)=*(pHistgram+p)+1;
  180. }
  181. }
  183. }
  185. BOOL CStatsticDetect::GetBgByHistgram(short int *pHistgram,BYTE *sBg,int nWidth,int nHeight)
  186. {
  187. int j,i,k;
  188. for(j=0;j<nHeight;j++)
  189. {
  190. for(i=0;i<nWidth;i++)
  191. {
  192. int c=0; 
  193. int color=0;
  194. for(k=0;k<256;k++)
  195. {
  196. if(*(pHistgram+256*(j*nWidth+i)+k)>c)
  197. {
  198. c=*(pHistgram+256*(j*nWidth+i)+k);
  199. color=k;
  200. }
  201. }
  203. *(sBg+j*nWidth+i)=color;
  205. }
  206. }
  208. for(j=0;j<nHeight;j++)
  209. {
  210. for( i=0;i<nWidth;i++)
  211. {
  212. memset(m_pBgImage+(nWidth*j+i)*3,*(sBg+j*nWidth+i),3);
  213. }
  214. }
  216. return TRUE;
  217. }
  219. void CStatsticDetect::DiffImage(BYTE *sGray,BYTE *pGray,int nWidth, int nHeight,int nThreshold)
  220. {
  221. int i,j;
  222. for(j=0;j<nHeight;j++)
  223. {
  224. for(i=0;i<nWidth;i++)
  225. {
  226. int diff=sGray[j*nWidth+i]-pGray[nWidth*j+i];
  227. // m_pDiffImage[j*nWidth+i] = BYTE(abs(diff));
  229. if(diff>nThreshold||diff<-nThreshold)
  230. {
  231. m_pDiffImage[j*nWidth+i]=255;
  232. }
  233. else
  234. {
  235. m_pDiffImage[j*nWidth+i]=0;
  236. }
  237. }
  238. }
  239. }
  240. void CStatsticDetect::DeNoise(BYTE *sGray,int nWidth, int nHeight)
  241. {
  242. int mode[3][3] = {-1,0,-1,-1,0,-1,-1,0,-1};
  243. Erosion(sGray,nWidth,nHeight,mode);
  244. // Dilation(sGray,nWidth,nHeight,mode);
  245. Medianfilter_3x3(sGray,nWidth,nHeight);
  246. for(int j=0;j<nHeight;j++)
  247. {
  248. for(int i=0;i<nWidth;i++)
  249. {
  250. memset(m_pDetectImage+(nWidth*j+i)*3, *(m_pDiffImage+j*nWidth+i), 3);
  251. }
  252. }
  254. }
  256. void CStatsticDetect::Medianfilter_3x3(BYTE *sGray, int nWidth, int nHeight)
  257. {
  258. int i,j,k,l,count;
  259. int ii,mid;
  260. BYTE mean[9];
  261. int ImageWidth, ImageHeight;
  262. ImageWidth = nWidth;
  263. ImageHeight = nHeight;
  265. BYTE* pBuf=new BYTE[ImageWidth*ImageHeight]; 
  266. for(i=1;i<ImageHeight-1;i++)
  267. {
  268. for(j=1;j<ImageWidth-1;j++)
  269. {
  270. count = 0;
  271. for(k=-1;k<=1;k++)
  272. {
  273. for(l=-1;l<=1;l++)
  274. {
  275. mean[count]=sGray[(k+i)*ImageWidth+l+j];
  276. count++;
  277. }
  278. }
  279. for(k=0;k<9;k++)
  280. {
  281. mid=mean[k];
  282. ii=k;
  283. for(l=k+1;l<9;l++)
  284. {
  285. if(mid>mean[l])
  286. {
  287. mid=mean[l];
  288. ii=l;
  289. }
  290. }
  291. mean[ii]=mean[k];
  292. mean[k]=mid;
  293. }
  294. pBuf[i*ImageWidth+j]= mean[4];
  295. }
  296. }
  297. memcpy(sGray,pBuf,sizeof(BYTE)*ImageWidth*ImageHeight);
  298. delete []pBuf;
  299. }
  301. void CStatsticDetect::Dilation(BYTE *sGray,int nWidth, int nHeight,int structure[3][3])
  302. {
  303. BYTE* t_gray = new BYTE[nWidth*nHeight];
  304. BYTE pixel;
  305. int i,j,m,n;
  306. for(j=1;j<nHeight-1;j++)
  307. {
  308. for(i=1;i<nWidth-1;i++)
  309. {
  310. t_gray[j*nWidth+i] = (BYTE)0;
  311. for (m = 0;m < 3;m++ )
  312. {
  313. for (n = 0;n < 3;n++)
  314. {
  315. if( structure[m][n] == -1)
  316. continue;
  317. pixel = sGray[(j+(m-2)+1)*nWidth + i + (n-1)];
  318. if (pixel == 255 )
  319. {
  320. t_gray[j*nWidth+i] = (BYTE)255;
  321. break;
  322. }
  323. }
  324. }
  326. }
  327. }
  328. memcpy(sGray,t_gray,nWidth*nHeight);
  329. delete []t_gray;
  330. }
  332. void CStatsticDetect::Erosion(BYTE *sGray,int nWidth, int nHeight,int structure[3][3])
  333. {
  334. BYTE* t_gray = new BYTE[nWidth*nHeight];
  335. BYTE pixel;
  336. int i,j,m,n;
  337. for(j=1;j<nHeight-1;j++)
  338. {
  339. for(i=1;i<nWidth-1;i++)
  340. {
  341. t_gray[j*nWidth+i] = (BYTE)255;
  342. for (m = 0;m < 3;m++ )
  343. {
  344. for (n = 0;n < 3;n++)
  345. {
  346. if( structure[m][n] == -1)
  347. continue;
  348. pixel = sGray[(j+(m-2)+1)*nWidth + i + (n-1)];
  349. if (pixel == 0 )
  350. {
  351. t_gray[j*nWidth+i] = (BYTE)0;
  352. break;
  353. }
  354. }
  355. }
  357. }
  358. }
  359. memcpy(sGray,t_gray,nWidth*nHeight);
  360. delete []t_gray;
  361. }
  363. void CStatsticDetect::GetMultiData(BYTE *sGray,int nWidth, int nHeight)
  364. {
  365.     count++;
  366. for(int j=0;j<nHeight;j++)
  367. for(int i=0;i<nWidth;i++)
  368. m_pTemplate[j*nWidth+i]+=sGray[j*nWidth+i];
  369. }
  371. void CStatsticDetect::GetBgImage()
  372. {
  373. int i,j,t,pixel;
  374. for(j=0;j<HEIGHT;j++)
  375. {
  376. for(i=0;i<WIDTH;i++)
  377. {
  378. t = j*WIDTH+i;
  379. pixel = UINT(m_pTemplate[t]/count+0.5);
  380. if(pixel>255)
  381. m_pBackground[t] = BYTE(255);
  382. else if(pixel<0)
  383. m_pBackground[t] = BYTE(0);
  384. else
  385. m_pBackground[t] = BYTE(pixel);
  386. }
  387. }
  388. }
  390. void CStatsticDetect::SaveBmp(BYTE* buffer,int nwidth, int nheight, int bit, int index) 
  391. {
  392. //write bmp
  393. BITMAPFILEHEADER bfh; 
  394. bfh.bfType=0X4D42;
  395. bfh.bfSize=(DWORD)(sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256 + nheight*nwidth);
  396. bfh.bfReserved1=0;
  397. bfh.bfReserved2=0;
  398. bfh.bfOffBits=(DWORD)(sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256);
  400. BITMAPINFOHEADER bih;
  401. bih.biSize=sizeof(BITMAPINFOHEADER);
  402. bih.biWidth=nwidth;
  403. bih.biHeight=nheight;
  404. bih.biPlanes=1;
  405. bih.biBitCount=bit;
  406. bih.biCompression=BI_RGB;
  407. bih.biSizeImage=nheight*nwidth;
  408. bih.biXPelsPerMeter = 0;
  409. bih.biYPelsPerMeter = 0;
  410. bih.biClrUsed = 0;
  411. bih.biClrImportant = 0;
  413. RGBQUAD palate[256];
  414. for(int t=0;t<256;t++)
  415. {
  416. palate[t].rgbBlue=(BYTE)t;
  417. palate[t].rgbGreen=(BYTE)t;
  418. palate[t].rgbRed=(BYTE)t;
  419. palate[t].rgbReserved=0;
  420. }
  421. int bpl = (nwidth*8+31)/32*4;
  422. int imageSize = nheight*bpl;
  423. BYTE* imgData = NULL;
  424. if(bit == 8)
  425. {
  426. imgData = new BYTE[imageSize];
  427. memcpy(imgData, buffer, imageSize);
  428. }
  430. if(bit == 24)
  431. {
  432. imgData = new BYTE[imageSize*3];
  433. memcpy(imgData, buffer, imageSize*3);
  434. }
  436. CFile fp;
  437. CString path ;
  438. path.Format("Frame%03d.bmp",index);
  440. TRY
  441. {
  442. fp.Open("F:\"+path,CFile::modeCreate | CFile::modeWrite);
  443. fp.Write((LPSTR)&bfh,sizeof(BITMAPFILEHEADER)); //写文件头
  444. fp.Write((LPSTR)&bih,sizeof(BITMAPINFOHEADER)); //写信息头
  445. if(bit==8)
  446. fp.Write((LPSTR)palate,sizeof(RGBQUAD)*256); //写调色板
  447. fp.Write(imgData,nheight*nwidth);//写数据
  448. }
  449. CATCH(CFileException,e)
  450. {
  451. THROW_LAST();
  452. }
  453. END_CATCH
  455. delete []imgData;
  456. imgData = NULL;
  458. fp.Close();
  459. }
  462. void CStatsticDetect::ImageCopy(BYTE *sGray, int m_num)
  463. {
  464. if(m_num==0) 
  465. {
  466. memcpy(image1,sGray,IMAGESIZE);
  467. }
  468. else if(m_num==1)
  469. {
  470. memcpy(image2,sGray,IMAGESIZE);
  471. }
  472. else if(m_num==2)
  473. {
  474. memcpy(image3,sGray,IMAGESIZE);
  475. }
  476. else if(m_num==4)
  477. {
  478. memcpy(image4,sGray,IMAGESIZE);
  479. }
  480. else
  481. {
  482. memcpy(image1,image2,IMAGESIZE);
  483. memcpy(image2,image3,IMAGESIZE);
  484. memcpy(image3,image4,IMAGESIZE);
  485. memcpy(image4,sGray,IMAGESIZE);
  486. }
  487. }
  489. void CStatsticDetect::Subtract(BYTE *nImage, BYTE *nImage1, BYTE *nImage2, int nWidth, int nHeight, int nThresh)
  490. {
  491. int i,j;
  492. for(j=0;j<nHeight;j++)
  493. {
  494. for(i=0;i<nWidth;i++)
  495. {
  496. int t = j*nWidth+i;
  497. nImage[t] = nImage1[t]-nImage2[t];
  499. if(abs(nImage[t])>nThresh) 
  500. nImage[t] = 1;
  501. else
  502. nImage[t] = 0;
  503. }
  504. }
  505. }
  507. void CStatsticDetect::MDiffImage(BYTE *sGray,int nWidth, int nHeight, int nthresh)
  508. {
  509. BYTE *temp1 = new BYTE[nWidth*nHeight];
  510. BYTE *temp2 = new BYTE[nWidth*nHeight];
  511. Subtract(temp1, image1, image3, nWidth, nHeight, nthresh);
  512. Subtract(temp2, image2, image4, nWidth, nHeight, nthresh);
  514. int i,j;
  515. // for(j=0;j<nHeight;j++)
  516. // {
  517. // for(i=0;i<nWidth;i++)
  518. // {
  519. // int t=j*nWidth+i;
  520. // if(temp1[t]==1)
  521. // temp1[t] = 255;
  522. // else
  523. // temp1[t] = 0;
  524. //
  525. // if(temp2[t]==1)
  526. // temp2[t] = 255;
  527. // else
  528. // temp2[t] = 0;
  529. //
  530. // }
  531. // }
  532. //
  533. //    DeNoise(temp1,WIDTH,HEIGHT);
  534. // SaveBmp(temp1,WIDTH,HEIGHT,8,7000);
  535. //    DeNoise(temp2,WIDTH,HEIGHT);
  536. // SaveBmp(temp2,WIDTH,HEIGHT,8,7001);
  539.     bool p;
  540. for(j=0;j<nHeight;j++)
  541. {
  542. for(i=0;i<nWidth;i++)
  543. {
  544. int t=j*nWidth+i;
  545. p = temp1[t] && temp2[t];
  546. if(p)
  547. sGray[t] = 255;
  548. else
  549. sGray[t] = 0;
  550. }
  551. }
  553. delete []temp1;
  554. delete []temp2;
  555. }