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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 2D图形编程 > 查看源码
DIB.cpp
资源名称：运动检测系统(修改后).rar　[点击查看]
上传用户：seppec
上传日期：2010-02-09
资源大小：2347k
文件大小：33k
源码类别：

2D图形编程

开发平台：

Visual C++

DIB.cpp：源码内容
  1. // DIB.cpp: implementation of the DIB class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "DIB.h"
  7. #include"math.h"
  8. #define WIDTHBYTES(bits)  ((bits+31)/32*4)
  9. #define RECTWIDTH(x) (x->right-x->left)
  10. #define RECTHEIGHT(x) (x->bottom-x->top)
  11. #define THRESHOLDCONTRAST  40
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  17. #define PI 3.1415926
  18. extern int locax,locay;
  19. #define m_WIDTH 600
  20. #define m_HEIGHT 600
  22. //////////////////////////////////////////////////////////////////////
  23. // Construction/Destruction
  24. /////////////////////////////////////////////////////////////////////
  25. HDIB DIB::ReadDIBFile(HANDLE hFile)
  26. {
  27. BITMAPFILEHEADER bmfHeader;
  28. DWORD dwBitsSize;
  29. HANDLE hDIB;
  30. HANDLE hDIBtmp;
  31. LPBITMAPINFOHEADER lpbi;
  32. DWORD dwRead;
  33.     //得到文件大小
  34. dwBitsSize = GetFileSize(hFile,NULL);
  35. hDIB =  GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)));
  37. if(!hDIB)
  38. return NULL;
  40. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  41. if(!lpbi)
  42. {
  43. GlobalFree(hDIB);
  44. return NULL;
  45. }
  47. if(!ReadFile(hFile,(LPBYTE)&bmfHeader,sizeof(BITMAPFILEHEADER),&dwRead,NULL))
  48. goto ErrExit;
  49. if(sizeof(BITMAPFILEHEADER)!=dwRead)//读取文件出错
  50. goto ErrExit;
  51. if(bmfHeader.bfType != 0x4d42)//文件类型不匹配
  52. goto ErrExit;
  53. if(!ReadFile(hFile,(LPBYTE)lpbi,sizeof(BITMAPINFOHEADER),&dwRead,NULL))
  54. goto ErrExit;
  55. if(sizeof(BITMAPINFOHEADER)!= dwRead)//读取数据出错
  56. goto ErrExit;
  58. GlobalUnlock(hDIB);
  59. if(lpbi->biSizeImage==0)
  60. lpbi->biSizeImage = (this->BytePerLine(hDIB))*lpbi->biHeight;
  61. hDIBtmp = GlobalReAlloc(hDIB,lpbi->biSize+lpbi->biSizeImage,0);
  62. if(!hDIBtmp)
  63. goto ErrExitNoUnlock;
  64. else
  65. hDIB = hDIBtmp;
  66. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  67. //根据情况设定文件指针
  68. if(bmfHeader.bfOffBits != 0L)
  69. SetFilePointer(hFile,bmfHeader.bfOffBits,NULL,FILE_BEGIN);
  70.     //读取文件的象素颜色数据
  71. if(ReadFile(hFile,(LPBYTE)lpbi+lpbi->biSize,lpbi->biSizeImage,&dwRead,NULL))
  72. goto OKExit;
  74. ErrExit:
  75. GlobalUnlock(hDIB);
  77. ErrExitNoUnlock:
  78. GlobalFree(hDIB); //释放内存
  79. return NULL;
  81. OKExit:
  82. GlobalUnlock(hDIB);
  83. return hDIB;
  85. }
  87. HDIB DIB::LoadDIB(LPCTSTR lpFileName)
  88. {
  89. HANDLE hDIB;
  90. HANDLE hFile;
  91. //创建文件句柄
  92. if((hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))!= INVALID_HANDLE_VALUE)
  93. {  
  94. //读取数据
  95. hDIB = ReadDIBFile(hFile);
  96. //关闭文件句柄
  97. CloseHandle(hFile);
  98. return hDIB;
  99. }
  100. return NULL;
  101. }
  103. BOOL DIB::PaintDIBTrue(HDC hDC,LPRECT lpDCRect,HANDLE hDIB,LPRECT lpDIBRect ,DWORD dwRop)
  104. {
  105. LPBYTE lpDIBHdr;
  106. LPBYTE lpDIBBits;
  107. BOOL bSuccess = FALSE;
  109. if(!hDIB)
  110. return FALSE;
  111. lpDIBHdr = (LPBYTE)GlobalLock(hDIB);
  112. lpDIBBits = lpDIBHdr + sizeof(BITMAPINFOHEADER);
  113. bSuccess = StretchDIBits(hDC,lpDCRect->left,
  114.  lpDCRect->top,
  115.  RECTWIDTH(lpDCRect),
  116.  RECTHEIGHT(lpDCRect),
  117.  lpDIBRect->left,
  118.  ((LPBITMAPINFOHEADER)lpDIBHdr)->biHeight-lpDIBRect->top-RECTHEIGHT(lpDIBRect),
  119.  RECTWIDTH(lpDIBRect),
  120.  RECTHEIGHT(lpDIBRect),
  121.  lpDIBBits,
  122.  (LPBITMAPINFO)lpDIBHdr,
  123.  DIB_RGB_COLORS,
  124.  SRCCOPY);
  125. GlobalUnlock(hDIB);
  126. return bSuccess;
  127. }
  129. WORD DIB::BytePerLine(HANDLE hDIB)
  130. {
  131. WORD i;
  132. LPBITMAPINFOHEADER lpbi;
  133. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  134. i = WIDTHBYTES((lpbi->biWidth)*24);
  135. GlobalUnlock(hDIB);
  136. return i;
  137. }
  140. //函数实现图片从彩色到黑白的转换
  141. HDIB DIB::ToGray(HANDLE hDIB)
  142. {
  143. HDIB hNewDIB = NULL;
  144. LPBITMAPINFOHEADER lpSrc,lpDest;
  145. LPBYTE lpS,lpD;
  146. DWORD dwBytesPerLine;
  147. DWORD dwImgSize;
  148. WORD wBytesPerLine;
  149. unsigned i ,j,height,width;
  150. if(!hDIB)
  151. return NULL;
  153. lpSrc = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  155. dwBytesPerLine = WIDTHBYTES(24*(lpSrc->biWidth));
  156. dwImgSize = lpSrc->biHeight * dwBytesPerLine;
  157. //申请新的内存，大小等于原来图象的大小
  158. hNewDIB = GlobalAlloc(GHND,sizeof(BITMAPINFOHEADER)+dwImgSize);
  160. lpDest = (LPBITMAPINFOHEADER)GlobalLock(hNewDIB);
  161. //保存图片的长宽、颜色深度等信息
  162. memcpy((void*)lpDest,(void*)lpSrc,sizeof(BITMAPINFOHEADER));
  163. DWORD dwSBytesPerLine;
  164. dwSBytesPerLine = (24*(lpSrc->biWidth)+31)/32*4;
  165. height = lpDest->biHeight;
  166. width = lpDest->biWidth;
  167. lpS = (LPBYTE)lpSrc;
  168. wBytesPerLine = this->BytePerLine(hDIB);
  169. lpD = (LPBYTE)lpDest;
  170. lpS = lpS + sizeof(BITMAPINFOHEADER);
  171. lpD = lpD + sizeof(BITMAPINFOHEADER);
  172. unsigned  r , g ,b,gray ;
  173. //扫描整个图片，实现灰度化
  174. for(i = 0 ;i<height; i++)
  175. {
  176. for(j = 0 ;j<(unsigned )lpDest->biWidth;j++)
  177. {
  178.         //获得原来图片的颜色值
  179. r = *(lpS++);
  180. g = *(lpS++);
  181. b  = *(lpS++);
  182. //计算灰度值
  183. gray = (g*50+r*39+b*11)/100;
  184. //保存灰度值到目标图片
  185. *(lpD++)=gray;
  186. *(lpD++) = gray;
  187. *(lpD++) = gray;
  190. }
  191. //处理四字节对齐问题
  192. unsigned  k ;
  193. for(k=0;k<dwSBytesPerLine-lpSrc->biWidth*3;k++)
  194. {
  195. lpS++;
  196. lpD++;
  197. }
  199. }
  201. GlobalUnlock(hDIB);
  202. GlobalUnlock(hNewDIB);
  203.     return hNewDIB;
  207. }
  211. LPBYTE  DIB::FindDIBBits(HANDLE hDIB)
  212. {
  213. LPBYTE lpDIB,lpDIBtmp;
  214. LPBITMAPINFOHEADER lpbi;
  215. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  216. lpDIBtmp = (LPBYTE)lpbi;
  217. lpDIB = lpDIBtmp + sizeof(BITMAPINFOHEADER);
  218. GlobalUnlock(hDIB);
  219. return lpDIB;
  220. }
  222. long DIB::PixelOffset(int i,int j,WORD wBytePerLine)
  223. {
  224. long   Offset;
  225. Offset = i*wBytePerLine + j*3;
  226. return Offset;
  227. }
  234. //函数实现对图片的中值滤波处理
  235. void DIB::MedianFilterDIB(HANDLE hDIB)
  236. {
  238. HDIB hNewDIB;
  239. LPBYTE  lpS,lpD;
  240. LPBITMAPINFOHEADER lpbi;
  241. int r,g,b;
  242. DWORD width,height;
  243. WORD wBytesPerLine;
  244. long lOffset;
  245. if(!hDIB)
  246. return;
  247. SetCursor(LoadCursor(NULL,IDC_WAIT));
  248. wBytesPerLine = this->BytePerLine(hDIB);
  249. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  250. width = lpbi->biWidth;
  251. height = lpbi->biHeight;
  252.  //申请一块新的内存
  253. hNewDIB = GlobalAlloc(GHND,sizeof(BITMAPINFOHEADER)+lpbi->biSizeImage);
  254. lpD = (LPBYTE)GlobalLock(hNewDIB);
  255. lpS = (LPBYTE)lpbi;
  256. memcpy(lpD,lpS,sizeof(BITMAPINFOHEADER));
  257. lpS = lpS+sizeof(BITMAPINFOHEADER);
  258. lpD = lpD+sizeof(BITMAPINFOHEADER);
  259. //扫描整个图片
  260. for(WORD i=1;i<height-1;i++)
  261. for(WORD j=1;j<width-1;j++)
  262. { //中值滤波
  263. this->DoMedianFilterDIB(&r,&g,&b,i,j,wBytesPerLine,lpS);
  264. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  265. *(lpD+lOffset++) = r;
  266. *(lpD+lOffset++) = g;
  267. *(lpD+lOffset)   = b;
  269. }
  270. //把信息拷贝回原来的句柄
  271. for( i = 1;i<height-1;i++)
  272. for(WORD j = 1;j<width-1;j++)
  273. {
  274. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  275. //活得新图片的颜色
  276. int color1 = *(lpD+lOffset++);
  277. int color2 = *(lpD+lOffset++);
  278. int color3 = *(lpD+lOffset++);
  279. //拷贝到原来图片中
  280. *(lpS+lOffset++) = color1;
  281. *(lpS+lOffset++) = color2;
  282. *(lpS+lOffset++) = color3;
  283. }
  284. SetCursor(LoadCursor(NULL,IDC_ARROW));
  285. GlobalUnlock(hDIB);
  286. GlobalUnlock(hNewDIB);
  287. GlobalFree(hNewDIB);
  289. }
  293. void DIB::DoMedianFilterDIB(int *r,int *g,int*b,WORD i,WORD j,WORD wBytesPerLine,LPBYTE lpDIBBits)
  294. {
  295. long lOffset;
  296. int rgb[9][3];
  297. //把八个方位和当前位置得rgb值保存到数组rgb[9][3]中
  298. lOffset = this->PixelOffset( i-1, j-1, wBytesPerLine); 
  299. rgb[0][0] = *(lpDIBBits+lOffset++);
  300. rgb[0][1] = *(lpDIBBits+lOffset++);
  301. rgb[0][2] = *(lpDIBBits+lOffset++);
  303. lOffset = this->PixelOffset( i-1, j, wBytesPerLine);
  304. rgb[1][0] = *(lpDIBBits+lOffset++);
  305. rgb[1][1] = *(lpDIBBits+lOffset++);
  306. rgb[1][2] = *(lpDIBBits+lOffset++);
  307. lOffset = this->PixelOffset( i-1, j+1, wBytesPerLine);
  308. rgb[2][0] = *(lpDIBBits+lOffset++);
  309. rgb[2][1] = *(lpDIBBits+lOffset++);
  310. rgb[2][2] = *(lpDIBBits+lOffset++);
  311. lOffset = this->PixelOffset( i, j-1, wBytesPerLine);
  312. rgb[3][0] = *(lpDIBBits+lOffset++);
  313. rgb[3][1] = *(lpDIBBits+lOffset++);
  314. rgb[3][2] = *(lpDIBBits+lOffset++);
  315. lOffset = this->PixelOffset( i, j, wBytesPerLine);
  316. rgb[4][0] = *(lpDIBBits+lOffset++);
  317. rgb[4][1] = *(lpDIBBits+lOffset++);
  318. rgb[4][2] = *(lpDIBBits+lOffset++);
  319. lOffset = this->PixelOffset( i, j+1, wBytesPerLine);
  320. rgb[5][0] = *(lpDIBBits+lOffset++);
  321. rgb[5][1] = *(lpDIBBits+lOffset++);
  322. rgb[5][2] = *(lpDIBBits+lOffset++);
  323. lOffset = this->PixelOffset( i+1, j-1, wBytesPerLine);
  324. rgb[6][0] = *(lpDIBBits+lOffset++);
  325. rgb[6][1] = *(lpDIBBits+lOffset++);
  326. rgb[6][2] = *(lpDIBBits+lOffset++);
  327. lOffset = this->PixelOffset( i+1, j, wBytesPerLine);
  328. rgb[7][0] = *(lpDIBBits+lOffset++);
  329. rgb[7][1] = *(lpDIBBits+lOffset++);
  330. rgb[7][2] = *(lpDIBBits+lOffset++);
  331. lOffset = this->PixelOffset( i+1, j+1, wBytesPerLine);
  332. rgb[8][0] = *(lpDIBBits+lOffset++);
  333. rgb[8][1] = *(lpDIBBits+lOffset++);
  334. rgb[8][2] = *(lpDIBBits+lOffset++);
  335.  this->MedianSearch( rgb,9,b,g,r);
  338. }
  341. int DIB::MedianSearch(int a[9][3],int n,int *r,int *g,int *b)
  342. {
  343. int result,i,j,temp;
  344. //冒泡法排序，找出rgb中间值
  345. for(i=0;i<9;i++)
  346. for(j = 0 ;j<n-i-1;j++)
  347. {
  348. if(a[j][0]>a[j+1][0])
  349. {
  350. temp = a[j][0];
  351. a[j][0] = a[j+1][0];
  352. a[j+1][0]=temp;
  353. }
  354. if(a[j][1]>a[j+1][1])
  355. {
  356. temp = a[j][1];
  357. a[j][1] = a[j+1][1];
  358. a[j+1][1]=temp;
  359. }
  361. if(a[j][2]>a[j+1][2])
  362. {
  363. temp = a[j][2];
  364. a[j][2] = a[j+1][2];
  365. a[j+1][2]=temp;
  366. }
  369. }
  370. //得到rgb得中间值
  371. *b = a[5][0];
  372. *g = a[5][1];
  373. *r = a[5][2];
  374. //根据需要也可以选用灰度值
  375. result = (a[5][0]*39 +a[5][1]*50 + a[5][2]*11)/100;
  376. return result;
  377. }
  378. //实现图片的黑白二值化
  379. void DIB::WhiteBlack(HANDLE hDIB,unsigned n)
  380. {
  382. LPBITMAPINFOHEADER  lpbi;
  383. LPBYTE lpS;
  384. int width,height;
  385. long lOffset;
  386. WORD                wBytesPerLine;
  388. if(!hDIB)
  389. return ;
  390. wBytesPerLine = this->BytePerLine(hDIB);
  391. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  392.     //得到图片的长宽信息
  393. width = lpbi->biWidth;
  394. height = lpbi->biHeight;
  396. lpS = (LPBYTE)lpbi;
  397. //lps指向数据区
  398. lpS = lpS + sizeof(BITMAPINFOHEADER);
  399.    //扫描整个图片，实现二值化
  400. for(int i = 0;i<height;i++)
  401. for(int j = 0 ;j<width;j++)
  402. {   //得到象素数据在数据区中的偏移
  403. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  404. if(*(lpS+lOffset)<n)//象素值小于临界值
  405. {   //把象素填充为黑色
  406. *(lpS+lOffset++) = 0;
  407. *(lpS+lOffset++) = 0;
  408. *(lpS+lOffset)   = 0;
  409. }
  410. else //象素值大于临界值
  411. {   
  412. //把象素填充为白色
  413. *(lpS+lOffset++) = 255;
  414. *(lpS+lOffset++) = 255;
  415. *(lpS+lOffset)   = 255;
  416. }
  417. }
  419. GlobalUnlock(hDIB);
  421. }
  436. DIB::DIB()
  437. {
  440. }
  441. DIB::~DIB()
  442. {
  444. }
  446. CPoint DIB::NextBorderPoint(CPoint CurrentPoint,LPBYTE lpDIBBits,WORD wBytesPerLine)
  447. {
  448. CPoint Pointtmp;
  449. /* Pointtmp.x=-1;
  450. Pointtmp.y=-1;
  453. if(CurrentPoint.x!=this->width-1)
  454. {
  455. Pointtmp.x=CurrentPoint.x+1;
  456. Pointtmp.y=CurrentPoint.y;
  458. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  459. return Pointtmp;
  460. }
  461. if((CurrentPoint.y!=this->height-1)&&(CurrentPoint.x!=this->width-1))
  462. {
  463. Pointtmp.x=CurrentPoint.x+1;
  464. Pointtmp.y=CurrentPoint.y+1;
  466. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  467. return Pointtmp;
  468. }
  469. if(CurrentPoint.y!=this->height-1)
  470. {
  471. Pointtmp.x=CurrentPoint.x;
  472. Pointtmp.y=CurrentPoint.y+1;
  474. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  475. return Pointtmp;
  476. }
  477. if((CurrentPoint.x!=0)&&(CurrentPoint.y!=this->height-1))
  478. {
  479. Pointtmp.x=CurrentPoint.x-1;
  480. Pointtmp.y=CurrentPoint.y+1;
  482. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  483. return Pointtmp;
  484. }
  485. if(CurrentPoint.x!=0)
  486. {
  487. Pointtmp.x=CurrentPoint.x-1;
  488. Pointtmp.y=CurrentPoint.y;
  490. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  491. return Pointtmp;
  492. }
  493. if((CurrentPoint.x!=0)&&(CurrentPoint.y!=0))
  494. {
  495. Pointtmp.x=CurrentPoint.x-1;
  496. Pointtmp.y=CurrentPoint.y-1;
  498. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  499. return Pointtmp;
  500. }
  502. if(CurrentPoint.y != 0)
  503. {
  504. Pointtmp.x = CurrentPoint.x;
  505. Pointtmp.y = CurrentPoint.y-1;
  507. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  508. return Pointtmp;
  509. }
  510.     if((CurrentPoint.y!=0)&&(CurrentPoint.x!=this->width-1))
  511. {
  512. Pointtmp.y=CurrentPoint.y-1;
  513. Pointtmp.x=CurrentPoint.x+1;
  515. if(this->IsBorderPoint(Pointtmp,lpDIBBits, wBytesPerLine))
  516. return Pointtmp;
  517. }
  518. CPoint errorPoint;
  519. errorPoint.x=errorPoint.y=-2;
  520. return errorPoint;
  521. */
  522. return Pointtmp;
  523. }
  525. BOOL DIB::IsBorderPoint(CPoint CurrentPoint ,LPBYTE lpDIBBits,WORD wBytesPerLine)
  526. {
  527. long lOffset;
  528. lOffset = this->PixelOffset(CurrentPoint.y,CurrentPoint.x,wBytesPerLine);
  529. if(*(lpDIBBits+lOffset)!=0)
  530. return false;
  532. if(CurrentPoint.y!=0)
  533. {
  534. lOffset = this->PixelOffset(CurrentPoint.y-1,CurrentPoint.x,wBytesPerLine);
  535. if(*(lpDIBBits+lOffset)==255)
  536. return true;
  537. }
  539. if(CurrentPoint.x!=this->width-1)
  540. {
  541. lOffset = this->PixelOffset(CurrentPoint.y,CurrentPoint.x+1,wBytesPerLine);
  542. if(*(lpDIBBits+lOffset)==255)
  543. return true;
  544. }
  546. if(CurrentPoint.y!=this->height-1)
  547. {
  548. lOffset = this->PixelOffset(CurrentPoint.y+1,CurrentPoint.x,wBytesPerLine);
  549. if(*(lpDIBBits+lOffset)==255)
  550. return true;
  551. }
  554. if(CurrentPoint.x!=0)
  555. {
  556. lOffset = this->PixelOffset(CurrentPoint.y,CurrentPoint.x-1,wBytesPerLine);
  557. if(*(lpDIBBits+lOffset)==255)
  558. return true;
  559. }
  561. return false;
  562. }
  566. CPoint DIB::SearchInteriorPoint(CPoint Point,LPBYTE lpDIBBits,WORD wBytesPerLine)
  567. {
  568. long lOffset;
  569. CPoint Pointtmp;
  570. Pointtmp.x=Pointtmp.y=-1;
  571. if((Point.x!=0)&&(Point.y!=this->height-1))
  572. {
  573. lOffset = this->PixelOffset(Point.y+1,Point.x-1,wBytesPerLine);
  574. if(*(lpDIBBits+lOffset)==0)
  575. {
  576. Pointtmp.x=Point.x-1;
  577. Pointtmp.y=Point.y+1;
  578. return Pointtmp;
  579. }
  580. }
  582. if(Point.y!=this->height-1)
  583. {
  584. lOffset = this->PixelOffset(Point.y+1,Point.x,wBytesPerLine);
  585. if(*(lpDIBBits+lOffset)==0)
  586. {
  587. Pointtmp.x=Point.x;
  588. Pointtmp.y=Point.y+1;
  589. return Pointtmp;
  590. }
  591. }
  593. if((Point.x!=this->width-1)&&(Point.y!=this->height-1))
  594. {
  595. lOffset = this->PixelOffset(Point.y+1,Point.x+1,wBytesPerLine);
  596. if(*(lpDIBBits+lOffset)==0)
  597. {
  598. Pointtmp.x=Point.x+1;
  599. Pointtmp.y=Point.y+1;
  600. return Pointtmp;
  601. }
  602. }
  604. if(Point.x!=this->width-1)
  605. {
  606. lOffset=this->PixelOffset(Point.y,Point.x+1,wBytesPerLine);
  607. if(*(lpDIBBits+lOffset)==0)
  608. {
  609. Pointtmp.x=Point.x+1;
  610. Pointtmp.y=Point.y;
  611. return Pointtmp;
  612. }
  613. }
  614. return Pointtmp;
  615. }
  619. BOOL DIB:: SaveDIB(HANDLE hDib, CFile& file)
  620. {
  621. // Bitmap文件头
  622. BITMAPFILEHEADER bmfHdr;
  624. // 指向BITMAPINFOHEADER的指针
  625. LPBITMAPINFOHEADER lpBI;
  627. // DIB大小
  628. DWORD dwDIBSize =0;
  630. if (hDib == NULL)
  631. {
  632. // 如果DIB为空，返回FALSE
  633. return FALSE;
  634. }
  636. // 读取BITMAPINFO结构，并锁定
  637. lpBI = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);
  639. if (lpBI == NULL)
  640. {
  641. // 为空，返回FALSE
  642. return FALSE;
  643. }
  645. // 判断是否是WIN3.0 DIB
  646. // if (!IS_WIN30_DIB(lpBI))
  647. // {
  648. // 不支持其它类型的DIB保存
  650. // 解除锁定
  651. // ::GlobalUnlock((HGLOBAL) hDib);
  653. // 返回FALSE
  654. // return FALSE;
  655. // }
  657. // 填充文件头
  659. // 文件类型"BM"
  660. bmfHdr.bfType =  0x4d42; //DIB_HEADER_MARKER;
  662. // 计算DIB大小时，最简单的方法是调用GlobalSize()函数。但是全局内存大小并
  663. // 不是DIB真正的大小，它总是多几个字节。这样就需要计算一下DIB的真实大小。
  665. // 文件头大小＋颜色表大小
  666. // （BITMAPINFOHEADER和BITMAPCOREHEADER结构的第一个DWORD都是该结构的大小）
  667. // dwDIBSize = *(LPDWORD)lpBI; //+ ::PaletteSize((LPSTR)lpBI);
  668. dwDIBSize = sizeof(BITMAPINFOHEADER);//+lpBI->biSizeImage;
  669. // 计算图像大小
  670. if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
  671. {
  672. // 对于RLE位图，没法计算大小，只能信任biSizeImage内的值
  673. dwDIBSize += lpBI->biSizeImage;
  674. }
  675. else
  676. {
  677. // 象素的大小
  678. DWORD dwBmBitsSize;
  680. // 大小为Width * Height
  681. dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*24) * lpBI->biHeight;
  683. // 计算出DIB真正的大小
  684. dwDIBSize += dwBmBitsSize;
  686. // 更新biSizeImage（很多BMP文件头中biSizeImage的值是错误的）
  687. lpBI->biSizeImage = dwBmBitsSize;
  688. }
  691. // 计算文件大小：DIB大小＋BITMAPFILEHEADER结构大小
  692. bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
  694. // 两个保留字
  695. bmfHdr.bfReserved1 = 0;
  696. bmfHdr.bfReserved2 = 0;
  698. // 计算偏移量bfOffBits，它的大小为Bitmap文件头大小＋DIB头大小＋颜色表大小
  699. bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize;
  700.  // + PaletteSize((LPSTR)lpBI);
  701. // 尝试写文件
  702. // TRY
  703. {
  704. // 写文件头
  705. file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
  707. // 写DIB头和象素
  708. file.WriteHuge(lpBI, dwDIBSize);
  709. }
  710. // CATCH (CFileException, e)
  711. // {
  712. // 解除锁定
  713. // ::GlobalUnlock((HGLOBAL) hDib);
  715. // 抛出异常
  716. /// THROW_LAST();
  717. // }
  718. // END_CATCH
  720. // 解除锁定
  721. ::GlobalUnlock((HGLOBAL) hDib);
  723. // 返回TRUE
  724. return TRUE;
  725. }
  730. HANDLE DIB::ScaleDIB(HANDLE hDIB, float scal_x, float scal_y)
  731. {
  732. if(scal_x<0 || scal_y <0)
  733. return NULL;
  735. LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
  736. int w = lpbi->biWidth;
  737. int h = lpbi->biHeight;
  738. BYTE  tempmess[40];
  739. LPBYTE Src = this->FindDIBBits(hDIB);
  740. memcpy(tempmess,(LPBYTE)lpbi,40);
  741. int wid = ((int)(w*scal_x+0.5f)*24+31)/32*4;
  742. int imgsize =(int) (wid*(int)(h*scal_y+0.5f));
  744. HDIB hDIB2 = GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)+imgsize));
  745. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB2);
  746. memcpy((LPBYTE)lpbi,tempmess,40);
  747. lpbi->biWidth =(int)(w*scal_x+0.5f);
  748. lpbi->biHeight = (int)(h*scal_y+0.5f);
  749. lpbi->biSizeImage = imgsize;
  750. LPBYTE lpData = this->FindDIBBits(hDIB2);
  751. int srcWidth = w;
  752. int srcHeight = h;
  753. int dstWidth = (int)(w*scal_x+0.5f);
  754. int dstHeight = (int)(h*scal_y+0.5f);
  756. for(int i=0; i<dstHeight;i++)
  757. {
  758. float y_inverse_map = (float)i/scal_y;
  759. int y_lt = (int)y_inverse_map;
  760. float v=y_inverse_map - y_lt;
  761. int indexBase = i *wid;
  762. for(int j=0;j<dstWidth;j++)
  763. {
  764. float x_inverse_map = (float)j/scal_x;
  765. int x_lt = (int) x_inverse_map;
  766. float u=x_inverse_map - x_lt;
  767. int index = indexBase + j*3;
  768. *(lpData+index) = Src[y_lt*((w*24+31)/32*4)+x_lt*3];
  769. *(lpData+index+1) = Src[y_lt*((w*24+31)/32*4)+x_lt*3+1];
  770. *(lpData+index+2) = Src[y_lt*((w*24+31)/32*4)+x_lt*3+2];
  771. // int r,g,b;
  772. //((interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b))) ;
  773. // *(lpData+temp)   = b;
  774. //*(lpData+index++)   = (BYTE)((interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight)>>16)) & 0x000000ff;
  775. // (interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b));
  776. // *(lpData+temp+1)   = g;
  777.   //  (interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b));
  778. //  *(lpData+temp+2)   =r;
  780. }
  781. }
  782. GlobalUnlock(hDIB);
  783. GlobalUnlock(hDIB2);
  784. return hDIB2;
  786. }
  788. //cwh 01.6.20
  789. /*****************************************
  790. 卷积核心算法
  791. *****************************************/
  792. void DIB::interPolate(LPBYTE Src,int x,int y, float u,float v, int scanw, int scanh,int *r,int *g,int *b)
  793. {
  794. // UINT r11,g11,b11;
  795. //r=g=b=0;
  796. int red1[2][2];
  797. int green1[2][2];
  798. int blue1[2][2];
  799. int xx1[2];
  800. int yy1[2];
  801. xx1[0]=x*3;xx1[1]=x*3+3;
  802. yy1[0]=y;yy1[1]=y+1;
  803. if(xx1[1]>scanw-1)
  804. xx1[1] = scanw-1;
  805. if(yy1[1]>scanh-1)
  806. yy1[1] = scanh-1;
  808. for(int i=0;i<2;i++)
  809. {
  810. int indexBase1 = yy1[i]*((scanw*24+31)/32*4);
  811. for(int j=0;j<2;j++)
  812. {
  813. int index1 = indexBase1 + xx1[j];
  814. blue1[j][i] = (*(Src+index1));
  815.     green1[j][i] = (*(Src+index1+1));
  816.     red1[j][i] =  (*(Src+index1+2));
  818. }
  819. }
  821. //r11 = ((1-u)*(1-v)*red1[0][0]+(1-u)*v*red1[0][1]+u*(1-v)*red1[1][0]+u*v*red1[1][1]);
  822. // g11 = ((1-u)*(1-v)*green1[0][0]+(1-u)*v*green1[0][1]+u*(1-v)*green1[1][0]+u*v*green1[1][1]);
  823. //b11 = ((1-u)*(1-v)*blue1[0][0]+(1-u)*v*blue1[0][1]+u*(1-v)*blue1[1][0]+u*v*blue1[1][1]);
  824.   
  825. // *r=r11;
  826. //*g=g11;
  827. // *b=b11;
  828. // return (0x00ffffff&((b<<16)|(g<<8)|r));
  829. }
  831. HANDLE DIB::CopyHandle( HANDLE hSrc)
  832. {
  833. HANDLE hDst;
  834. LPBITMAPINFOHEADER lpbi;
  835. int width,height;
  836. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hSrc);
  837. width = lpbi->biWidth;
  838. height = lpbi->biHeight;
  839. hDst = GlobalAlloc(GMEM_MOVEABLE,lpbi->biSize+lpbi->biSizeImage);
  840. if(!hDst)
  841. return NULL;
  842. LPBYTE lpDest;
  843. lpDest = (LPBYTE)GlobalLock(hDst);
  844. memcpy(lpDest,(LPBYTE)lpbi,lpbi->biSize+lpbi->biSizeImage);
  845. GlobalUnlock(hSrc);
  846. GlobalUnlock(hDst);
  847. return hDst;
  849. }
  850. HANDLE  DIB::  Gradient(HANDLE hDIB)
  851. {
  852. LPBITMAPINFOHEADER lpbi;
  853. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  854. int width = lpbi->biWidth;
  855. int height = lpbi->biHeight;
  856. long lOffset;
  857. LPBYTE lpS,lpD;
  858. WORD wBytesPerLine = this->BytePerLine(hDIB);
  859. HANDLE hNewDIB;
  860. hNewDIB = GlobalAlloc(GMEM_MOVEABLE,(DWORD)(lpbi->biSize+lpbi->biSizeImage));
  861. if(!hNewDIB)
  862. {
  863. AfxMessageBox("分配内存失败");
  864. return NULL;
  865. }
  866. lpS = (LPBYTE)lpbi;
  867. lpD =(LPBYTE) GlobalLock(hNewDIB);
  868. memcpy(lpD,lpS,sizeof(BITMAPINFOHEADER));
  869. lpS = this->FindDIBBits(hDIB);
  870. lpD = this->FindDIBBits(hNewDIB);
  871. int color1,color2;
  872. for(int i=1;i<height-1;i++)
  873. for(int j=1;j<width-1;j++)
  874. {
  875. lOffset = this->PixelOffset(i+1,j+1,wBytesPerLine);
  876. color1 = *(lpS+lOffset);
  877. lOffset = this->PixelOffset(i-1,j-1,wBytesPerLine);
  878. color2 = *(lpS+lOffset);
  879. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  880. *(lpD+lOffset++) = abs(color2-color1)*3;
  881. *(lpD+lOffset++) = abs(color2-color1)*3;
  882. *(lpD+lOffset++) = abs(color2-color1)*3;
  884. }
  885. for(i =0;i<height;i++)
  886. {
  887. lOffset = this->PixelOffset(i,0,wBytesPerLine);
  888. *(lpD+lOffset++) =0;
  889. *(lpD+lOffset++) =0;
  890. *(lpD+lOffset++) =0;
  891. }
  893. for(i =0;i<height;i++)
  894. {
  895. lOffset = this->PixelOffset(i,width-1,wBytesPerLine);
  896. *(lpD+lOffset++) =0;
  897. *(lpD+lOffset++) =0;
  898. *(lpD+lOffset++) =0;
  899. }
  900. for(i =0;i<width;i++)
  901. {
  902. lOffset = this->PixelOffset(height-1,i,wBytesPerLine);
  903. *(lpD+lOffset++) =0;
  904. *(lpD+lOffset++) =0;
  905. *(lpD+lOffset++) =0;
  906. }
  907. for(i =0;i<width;i++)
  908. {
  909. lOffset = this->PixelOffset(0,i,wBytesPerLine);
  910. *(lpD+lOffset++) =0;
  911. *(lpD+lOffset++) =0;
  912. *(lpD+lOffset++) =0;
  913. }
  915. GlobalUnlock(hNewDIB);
  916. GlobalUnlock(hDIB);
  917. return hNewDIB;
  918. }
  920. //函数寻找图片中的特征区域的中心点
  921. void DIB::LocateImporntPoint(HANDLE hDIB, int Radius, CPoint *pPoint)
  922. {
  923. LPBITMAPINFOHEADER lpbi;
  924. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  925. int width ,height;
  926. width = lpbi->biWidth;
  927. height = lpbi->biHeight;
  928. WORD wBytesPerLine;
  929. wBytesPerLine = this->BytePerLine(hDIB);
  930. LPBYTE lpData;
  931. lpData = this->FindDIBBits(hDIB);
  932. int tempsum=0,sum=0;//定义两个变量用来记数
  933. long lOffset;
  934. //扫描整个图片（边缘点除外）寻找特征区域
  935. for(int i=Radius;i<height-Radius;i++)
  936. for(int j= Radius;j<width-Radius;j++)
  937. { tempsum =0;
  938. //扫描以Radius×2＋1为边长的正方形区域
  939. for(int k1=-Radius;k1<=Radius;k1++)
  940. for(int k2 =-Radius;k2<=Radius;k2++)
  941. {
  942. lOffset = this->PixelOffset(i+k1,j+k2,wBytesPerLine);
  943. int color = *(lpData+lOffset);
  944. tempsum +=color;//累加象素值
  945. }
  946. if(tempsum>sum)//如果得到的累计象素值大于已经得到的最大值
  947. {
  948. //更改累计象素值大小
  949. sum = tempsum;
  950. //更改特征区域中心点
  951. (pPoint->x) = j;
  952. (pPoint->y) = i;
  953.    
  955. }
  956. }
  957. //下面的代码把特征区域的边框设置成白色
  958. for( i = -Radius;i<=Radius;i++)
  959. {
  960. lOffset = this->PixelOffset(pPoint->y-Radius,pPoint->x +i,wBytesPerLine);
  961. *(lpData+lOffset++) = 255;
  962. *(lpData+lOffset++) = 255;
  963. *(lpData+lOffset++) = 255;
  964. }
  965. for( i = -Radius;i<=Radius;i++)
  966. {
  967. lOffset = this->PixelOffset(pPoint->y+Radius,pPoint->x +i,wBytesPerLine);
  968. *(lpData+lOffset++) = 255;
  969. *(lpData+lOffset++) = 255;
  970. *(lpData+lOffset++) = 255;
  971. }
  972. for( i = -Radius;i<=Radius;i++)
  973. {
  974. lOffset = this->PixelOffset(pPoint->y+i,pPoint->x-Radius ,wBytesPerLine);
  975. *(lpData+lOffset++) = 255;
  976. *(lpData+lOffset++) = 255;
  977. *(lpData+lOffset++) = 255;
  978. }
  979. for( i = -Radius;i<=Radius;i++)
  980. {
  981. lOffset = this->PixelOffset(pPoint->y+i,pPoint->x+Radius,wBytesPerLine);
  982. *(lpData+lOffset++) = 255;
  983. *(lpData+lOffset++) = 255;
  984. *(lpData+lOffset++) = 255;
  985. }
  986. lOffset = this->PixelOffset(pPoint->y,pPoint->x ,wBytesPerLine);
  987. *(lpData+lOffset++) = 0;
  988. *(lpData+lOffset++) = 255;
  989. *(lpData+lOffset++) = 0;
  991. GlobalUnlock(hDIB);
  992. }
  995. #define THRESHOLD (RADIUS*2+1)*(RADIUS*2+1)*15
  996. //函数在一幅图片中寻找匹配的中心点
  997. BOOL DIB::MatchImportantPoint(HANDLE hDIB,int CharaterInfo[RADIUS*2+1][RADIUS*2+1][3],CPoint *ImPoint)
  998. {
  999. LPBITMAPINFOHEADER lpbi;
  1000. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1001. int width = lpbi->biWidth;
  1002. int height = lpbi->biHeight;
  1003. LPBYTE lpData = this->FindDIBBits(hDIB);
  1004.     WORD wBytesPerLine = this->BytePerLine(hDIB);
  1005. long lOffset;
  1006. long sum =100000,tempsum;
  1007. //扫描整个图片（边缘点）除外
  1008. for(int i=RADIUS ;i<height-RADIUS;i++)
  1009. for(int j=RADIUS;j<width-RADIUS;j++)
  1010. {
  1011. tempsum =0;
  1012. //扫描以RADIUS*2+1为边长的正方形区域
  1013. for(int k=-RADIUS;k<=RADIUS;k++)
  1014. for(int kk=-RADIUS;kk<=RADIUS;kk++)
  1015. {
  1016. //计算当前正方形和已知特征区域的颜色差值
  1018. lOffset = this->PixelOffset(i+k,j+kk,wBytesPerLine);
  1019. int colorblue = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][0]);
  1020. int colorgreen = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][1]);
  1021. int colorred = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][2]);
  1022. tempsum +=colorgreen+colorblue+colorred;
  1023. }
  1024. if(tempsum<sum)
  1025. {  //更新差值
  1026. sum = tempsum;
  1027. //更改特征坐标点
  1028. ImPoint->x = j;
  1029. ImPoint->y = i;
  1030. }
  1031. }
  1033. if(sum <THRESHOLD){//找到满足条件的区域
  1034. //下面的代码把找到的区域的边框设置成为白色
  1035. for(i =-RADIUS;i<=RADIUS;i++)
  1036. {
  1037. lOffset = this->PixelOffset(ImPoint->y-RADIUS,ImPoint->x+i,wBytesPerLine);
  1038. *(lpData+lOffset++) = 255;
  1039. *(lpData+lOffset++) = 255;
  1040. *(lpData+lOffset++) = 255;
  1042. }
  1044. for(i =-RADIUS;i<=RADIUS;i++)
  1045. {
  1046. lOffset = this->PixelOffset(ImPoint->y+RADIUS,ImPoint->x+i,wBytesPerLine);
  1047. *(lpData+lOffset++) = 255;
  1048. *(lpData+lOffset++) = 255;
  1049. *(lpData+lOffset++) = 255;
  1051. }
  1052. for(i =-RADIUS;i<=RADIUS;i++)
  1053. {
  1054. lOffset = this->PixelOffset(ImPoint->y+i,ImPoint->x+RADIUS,wBytesPerLine);
  1055. *(lpData+lOffset++) = 255;
  1056. *(lpData+lOffset++) = 255;
  1057. *(lpData+lOffset++) = 255;
  1059. }
  1060. for(i =-RADIUS;i<=RADIUS;i++)
  1061. {
  1062. lOffset = this->PixelOffset(ImPoint->y+i,ImPoint->x-RADIUS,wBytesPerLine);
  1063. *(lpData+lOffset++) = 255;
  1064. *(lpData+lOffset++) = 255;
  1065. *(lpData+lOffset++) = 255;
  1067. }
  1068. GlobalUnlock(hDIB);
  1069. return true;
  1070. }
  1071. else AfxMessageBox("Can't find the corresponding point!");
  1072. GlobalUnlock(hDIB);
  1073. return false;
  1074. }
  1075. //比较两张图片的相似度
  1076. BOOL DIB::ComPareImg(HANDLE hDIB1, HANDLE hDIB2 ,CPoint pt1,CPoint pt2)
  1077. {
  1078. if(abs(pt1.x-pt2.x)>3 || abs(pt1.y -pt2.y)>3)//图象偏差过大
  1079. {
  1080. AfxMessageBox("Imgs Offset are too big");
  1081. return false;
  1082. }
  1083. LPBITMAPINFOHEADER lpbi1,lpbi2;
  1084. lpbi1 = (LPBITMAPINFOHEADER)GlobalLock(hDIB1);
  1085. int width1 = lpbi1->biWidth;
  1086. int height1 = lpbi1->biHeight;
  1087. lpbi2 = (LPBITMAPINFOHEADER)GlobalLock(hDIB2);
  1088. int width2 = lpbi2->biWidth;
  1089. int height2 = lpbi2->biHeight;
  1090. if(width1 != width2 || height1 != height2)//图象长宽尺寸不同
  1091. {
  1092. GlobalUnlock(hDIB1);
  1093. GlobalUnlock(hDIB2);
  1094. AfxMessageBox("Img is not same size");
  1095. return false;
  1096. }
  1097. LPBYTE lpData1,lpData2;
  1098. lpData1 = this->FindDIBBits(hDIB1);
  1099. lpData2 = this->FindDIBBits(hDIB2);
  1100. WORD wBytesPerLine = this->BytePerLine(hDIB1);
  1101. int xleft,xright,ytop,ybottom;
  1102. //下面的一段代码实现图象对齐
  1103. if(pt1.x>=pt2.x)//第一幅图得特征中心点比第二幅图偏右
  1104. {
  1106. xleft = pt2.x;//要处理得左边得象素点个数
  1107. xright =width-pt1.x-1;//要处理得右边得象素点个数
  1108. }
  1110. else//第一幅图得特征中心点比第二幅图偏左
  1111. {
  1113. xleft = pt1.x;
  1114. xright = width1-pt2.x-1;
  1115. }
  1117. if(pt1.y >=pt2.y)//第一幅图得特征中心点得位置偏上
  1118. {
  1120. ytop = pt2.y;//要处理得中心点上面得象素个数
  1121. ybottom = height1-pt1.y-1;//要处理得中心点下面得象素个数
  1123. }
  1125. else//第一幅图得特征中心点得位置偏下
  1126. {
  1128. ytop = pt1.y;
  1129. ybottom = height1-pt2.y-1;
  1130. }
  1131. long sum=0;
  1132. long lOffset;
  1133. //计算两幅图片交叉区域得象素差值
  1134. for(int i=-ytop;i<=ybottom;i++)
  1135. for(int j=-xleft;j<=xright;j++)
  1136. {
  1137. //第一幅图
  1138. lOffset = this->PixelOffset(i+pt1.y,j+pt1.x,wBytesPerLine);
  1139. int c11 = *(lpData1+lOffset++);
  1140. int c12 = *(lpData1+lOffset++);
  1141. int c13 = *(lpData1+lOffset++);
  1142. //第二幅图
  1143. lOffset = this->PixelOffset(i+pt2.y,j+pt2.x,wBytesPerLine);
  1144. int c21 = *(lpData2+lOffset++);
  1145. int c22 = *(lpData2+lOffset++);
  1146. int c23 = *(lpData2+lOffset++);
  1147. //计算差值
  1148. sum += abs(c11-c21)+abs(c12-c22)+abs(c13-c23);
  1149. }
  1150. GlobalUnlock(hDIB1);
  1151. GlobalUnlock(hDIB2);
  1152. if(sum>width1*height1*3*2)//判断是否相似
  1153. return false;
  1154. else 
  1155. return true;
  1157. }
  1159. BOOL DIB::  CompareImg2(HANDLE hDIBBK,HANDLE hDIBCurrent,CPoint pt1,CPoint pt2)
  1160. {
  1161. if(abs(pt1.x-pt2.x)>3 || abs(pt1.y -pt2.y)>3)
  1162. {
  1163. AfxMessageBox("Imgs Offset are too big");
  1164. return false;
  1165. }
  1166. LPBITMAPINFOHEADER lpbi1,lpbi2;
  1167. lpbi1 = (LPBITMAPINFOHEADER)GlobalLock(hDIBBK);
  1168. int width1 = lpbi1->biWidth;
  1169. int height1 = lpbi1->biHeight;
  1170. lpbi2 = (LPBITMAPINFOHEADER)GlobalLock(hDIBCurrent);
  1171. int width2 = lpbi2->biWidth;
  1172. int height2 = lpbi2->biHeight;
  1173. if(width1 != width2 || height1 != height2)
  1174. {
  1175. GlobalUnlock(hDIBBK);
  1176. GlobalUnlock(hDIBCurrent);
  1177. AfxMessageBox("Img is not same size");
  1178. return false;
  1179. }
  1180. LPBYTE lpData1,lpData2;
  1181. lpData1 = this->FindDIBBits(hDIBBK);
  1182. lpData2 = this->FindDIBBits(hDIBCurrent);
  1183. WORD wBytesPerLine = this->BytePerLine(hDIBBK);
  1184. int xleft,xright,ytop,ybottom;
  1186. if(pt1.x>=pt2.x)
  1187. {
  1189. xleft = pt2.x;
  1190. xright =width1-pt1.x-1;
  1191. }
  1193. else
  1194. {
  1196. xleft = pt1.x;
  1197. xright = width1-pt2.x-1;
  1198. }
  1200. if(pt1.y >=pt2.y)
  1201. {
  1203. ytop = pt2.y;
  1204. ybottom = height1-pt1.y-1;
  1206. }
  1208. else
  1209. {
  1211. ytop = pt1.y;
  1212. ybottom = height1-pt2.y-1;
  1213. }
  1214. long sum=0;
  1215. long lOffset;
  1219. for(int i=-ytop;i<=ybottom;i++)
  1220. for(int j=-xleft;j<=xright;j++)
  1221. {
  1223. lOffset = this->PixelOffset(i+pt1.y,j+pt1.x,wBytesPerLine);
  1224. int c11 = *(lpData1+lOffset++);
  1225. int c12 = *(lpData1+lOffset++);
  1226. int c13 = *(lpData1+lOffset++);
  1227. lOffset = this->PixelOffset(i+pt2.y,j+pt2.x,wBytesPerLine);
  1228. int c21 = *(lpData2+lOffset++);
  1229. int c22 = *(lpData2+lOffset++);
  1230. int c23 = *(lpData2+lOffset++);
  1231. lOffset = this->PixelOffset(i+pt2.y,j+pt2.x,wBytesPerLine);
  1232. *(lpData2+lOffset++) = abs(c11-c21);
  1233. *(lpData2+lOffset++) = abs(c12-c22);
  1234. *(lpData2+lOffset++) = abs(c13-c23);
  1235. }
  1236. for(i =0;i<height1;i++)
  1237. for(int j=0;j<width1;j++)
  1238. {
  1239. if(i<pt2.y-ytop || i>pt2.y+ybottom||j<pt2.x-xleft || j >pt2.x+xright)
  1240. {
  1241. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  1242. *(lpData2+lOffset++) = 0;
  1243. *(lpData2+lOffset++) = 0;
  1244. *(lpData2+lOffset++) = 0;
  1245. }
  1246. }
  1248. GlobalUnlock(hDIBBK);
  1249. GlobalUnlock(hDIBCurrent);
  1250. return true;
  1252. }
  1256. BOOL DIB::IsScaterPoint(int x, int y, int width, int height, LPBYTE lpData,WORD wBytesPerLine,  int threshold,bool lab[m_HEIGHT][m_WIDTH])
  1257. {
  1258. long lOffset;
  1259. lOffset = this->PixelOffset(y,x,wBytesPerLine);
  1260. if(*(lpData+lOffset) == 255 && lab[y][x] == false)
  1261. {
  1262. this->lenth++;
  1263. lab[y][x] = true;
  1264. if(this->lenth >= threshold)
  1265. return true;
  1266. if(x+1<width && lab[y][x+1] == false)
  1267. { IsScaterPoint(x+1,y,width,height,lpData,wBytesPerLine,threshold,lab);
  1268. if(this->lenth>=threshold)
  1269. return true;
  1271. }
  1272. if(x-1>=0 && lab[y][x-1] == false)
  1273. {
  1274. (IsScaterPoint(x-1,y,width,height,lpData,wBytesPerLine,threshold,lab));
  1275. if(this->lenth>=threshold)
  1276. return true;
  1278. }
  1280. if(y-1>=0 && lab[y-1][x]==false)
  1281. {
  1282. (IsScaterPoint(x,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  1283. if(this->lenth>=threshold)
  1284. return true;
  1286. }
  1287. if(y+1<height && lab[y+1][x]==false)
  1288. { (IsScaterPoint(x,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  1289. if(this->lenth>=threshold)
  1290. return true;
  1292. }
  1293. if(y+1<height  && x+1 <width && lab[y+1][x+1]==false)
  1294. { (IsScaterPoint(x+1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  1295. if(this->lenth>=threshold)
  1296. return true;
  1298. }
  1299. if(y+1<height && x-1 >=0 && lab[y+1][x-1]==false)
  1300. { (IsScaterPoint(x-1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  1301. if(this->lenth>=threshold)
  1302. return true;
  1304. }
  1305. if(y-1>=0 && x-1 >=0 &&lab[y-1][x-1]==false)
  1306. { (IsScaterPoint(x-1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  1307. if(this->lenth>=threshold)
  1308. return true;
  1310. }
  1311. if(y-1<height && x+1<width && lab[y+1][x]==false)
  1312. { (IsScaterPoint(x+1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  1313. if(this->lenth>=threshold)
  1314. return true;
  1316. }
  1317. }
  1318. return false;
  1319. }
  1320. //函数得到边界得中心点
  1321. CPoint DIB:: GetEdgeCenter(HANDLE hDIB)
  1322. {
  1323. LPBITMAPINFOHEADER lpbi;
  1324. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1325. int width = lpbi->biWidth;
  1326. int height = lpbi->biHeight;
  1327. WORD wBytesPerLine = this->BytePerLine(hDIB);
  1328. LPBYTE lpData = this->FindDIBBits(hDIB);
  1329. long lOffset;
  1330. int x =0,y =0,num =0;
  1331. //对整幅图片进行扫描
  1332. for(int i=0;i<height;i++)
  1333. for(int j=0;j<width;j++)
  1334. {
  1335. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  1336. if(*(lpData+lOffset) ==255)//如果是白色象素
  1337. {
  1338. x +=j;//中心点得横坐标和纵坐标加上当前得横坐标和纵坐标
  1339. y +=i;
  1340. num++;
  1341. }
  1342. }
  1343. //得到结果坐标点
  1344. CPoint result;
  1345. result.x = x/num;
  1346. result.y = y/num;
  1347. //把中心点设置为绿色
  1348. lOffset = this->PixelOffset(result.y,result.x,wBytesPerLine);
  1349. *(lpData+lOffset++) = 0;
  1350. *(lpData+lOffset++) = 255;
  1351. *(lpData+lOffset++) = 0;
  1352. return result;
  1353. }