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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
QQBitmap.cpp
资源名称：CQQFind.rar　[点击查看]
上传用户：cxh888fhc
上传日期：2017-07-08
资源大小：240k
文件大小：18k
源码类别：

钩子与API截获

开发平台：

Visual C++

QQBitmap.cpp：源码内容
  1. // QQBitmap.cpp: implementation of the CQQBitmap class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "CQQFind.h"
  7. #include "QQBitmap.h"
  8. #include <math.h>
  9. #include <winable.h>
  10. #include <winuser.h>
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  18. //////////////////////////////////////////////////////////////////////
  19. // Construction/Destruction
  20. //////////////////////////////////////////////////////////////////////
  22. CQQBitmap::CQQBitmap()
  23. {
  24. m_hWnd=(HWND)-1;
  25. }
  28. CQQBitmap::CQQBitmap(CString strFilePath)
  29. {
  30. //以一个数据文件作为初始化,供测试用
  31. #ifdef _DEBUG
  32. CFile file;
  33. if(GetFileAttributes(strFilePath)==-1)
  34. {
  35. return ;
  36. }
  37. if(!file.Open(strFilePath,CFile::modeRead))
  38. return ;
  40. BITMAPFILEHEADER bmfih;
  41. DWORD nFileLen;
  42. nFileLen=file.GetLength();
  44. if(file.Read((LPSTR)&bmfih,sizeof(bmfih))!=sizeof(bmfih))
  45. {
  46. file.Close();
  47. return;
  48. }
  49. if(bmfih.bfType!=((WORD)('M'<<8)|'B'))
  50. { 
  51. MessageBox(NULL,"不是bmp文件!","错误",MB_ICONWARNING);
  52. file.Close();
  53. return ;
  54. }
  56. HGLOBAL hDIB=::GlobalAlloc(GMEM_FIXED,nFileLen);
  57. if(hDIB==NULL)
  58. {
  59. file.Close();
  60. return ;
  61. }
  63. if(file.ReadHuge((LPSTR)hDIB,nFileLen-sizeof(BITMAPFILEHEADER))!=
  64. nFileLen-sizeof(BITMAPFILEHEADER))
  65. {
  66. ::GlobalFree(hDIB);
  67. file.Close();
  68. return ;
  69. }
  71. BITMAPINFO &bmInfo=*(LPBITMAPINFO)::GlobalLock(hDIB); 
  72. BYTE *pBmpPixelBuffer=(BYTE *)&bmInfo+bmfih.bfOffBits-
  73. sizeof(BITMAPFILEHEADER);                                                                                       
  75. CClientDC dc(NULL); 
  76. HBITMAP hBitmap;
  77. hBitmap=CreateDIBitmap(dc.m_hDC,(BITMAPINFOHEADER *)&bmInfo,
  78. CBM_INIT,(VOID *)pBmpPixelBuffer,&bmInfo,DIB_RGB_COLORS);
  79. ::GlobalUnlock(hDIB); 
  80. ::GlobalFree(hDIB);
  82. file.Close();
  84. m_bpAllPicture.Attach(hBitmap);
  85. CheckStyle();
  87. DividPicture();
  88. FindDifferent();
  89. #endif
  90. }
  93. CQQBitmap::~CQQBitmap()
  94. {
  95. m_hWnd=(HWND)-1;
  96. }
  98. CQQBitmap::CQQBitmap(HWND hWnd)
  99. {
  100. m_hWnd=hWnd;
  102. ::BringWindowToTop(hWnd);
  103. CClientDC dc(CWnd::FromHandle(hWnd));
  104. int BitPerPixel=dc.GetDeviceCaps(BITSPIXEL);
  105. CRect rcTemp;
  106. ::GetClientRect(hWnd,rcTemp);
  107. int Width=rcTemp.right;
  108. int Height=rcTemp.bottom;
  110. CDC memDC;
  111. memDC.CreateCompatibleDC(&dc);
  112. CBitmap *pOldmemBitmap;
  114. m_bpAllPicture.CreateCompatibleBitmap(&dc,Width,Height);
  115. pOldmemBitmap=memDC.SelectObject(&m_bpAllPicture);
  117. memDC.BitBlt(0,0,Width,Height,&dc,0,0,SRCCOPY);
  118. memDC.SelectObject(pOldmemBitmap);
  119. CheckStyle();
  121. DividPicture();
  122. FindDifferent();
  123. }
  125. BOOL CQQBitmap::SetCurrenthWnd(HWND hWnd)
  126. {
  127. if(hWnd!=(HWND)-1)
  128. {
  129. m_hWnd=hWnd;
  130. if(hWnd==NULL)
  131. {
  132. MessageBox(NULL,"没有开启QQ游戏!","错误",MB_ICONWARNING);
  133. return FALSE;
  134. }
  135. ::BringWindowToTop(hWnd);
  136. CClientDC dc(CWnd::FromHandle(hWnd));
  137. int BitPerPixel=dc.GetDeviceCaps(BITSPIXEL);
  138. CRect rcTemp;
  139. ::GetClientRect(hWnd,rcTemp);
  140. int Width=rcTemp.right;
  141. int Height=rcTemp.bottom;
  143. CDC memDC;
  144. memDC.CreateCompatibleDC(&dc);
  145. CBitmap *pOldmemBitmap;
  147. m_bpAllPicture.CreateCompatibleBitmap(&dc,Width,Height);
  148. pOldmemBitmap=memDC.SelectObject(&m_bpAllPicture);
  150. memDC.BitBlt(0,0,Width,Height,&dc,0,0,SRCCOPY);
  151. memDC.SelectObject(pOldmemBitmap);
  153. DividPicture();
  154. FindDifferent();
  155. return TRUE;
  156. }
  157. return FALSE;
  158. }
  160. BOOL CQQBitmap::DividPicture()
  161. {
  162. /////////////////////////////////////////////////
  163. DividPictureV();
  164. DividPictureH();
  165. //图片划分完毕.可以开始找数据了
  166. return TRUE;
  167. }
  170. void CQQBitmap::PrintBitmapToFile(CString strFilePath,BOOL bBitmapFormat)
  171. {
  172. #ifdef _DEBUG
  173. if(m_bpAllPicture.m_hObject==NULL)
  174. {
  175. return ;
  176. }
  177. BITMAP bmp;
  178. CClientDC dc(NULL);
  179. m_bpAllPicture.GetBitmap(&bmp);
  180. strFilePath.Insert(strFilePath.GetLength()-4,"All");
  181. CFile file(strFilePath,CFile::modeWrite|CFile::modeCreate);
  182. strFilePath.Delete(strFilePath.GetLength()-7,3);
  183. BITMAPINFOHEADER bih={0};
  184. bih.biBitCount=bmp.bmBitsPixel;
  185. bih.biCompression=BI_RGB;
  186. bih.biHeight=bmp.bmHeight;
  187. bih.biPlanes=1;
  188. bih.biSize=sizeof(BITMAPINFOHEADER);
  189. bih.biSizeImage=bmp.bmWidthBytes*bmp.bmHeight;
  190. bih.biWidth=bmp.bmWidth;
  191. BITMAPFILEHEADER bfh={0};
  192. bfh.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
  193. bfh.bfSize=bfh.bfOffBits+bmp.bmWidthBytes*bmp.bmHeight;
  194. bfh.bfType=(WORD)(_T('M')<<8|_T('B'));
  195. file.Write(&bfh,sizeof(BITMAPFILEHEADER));
  196. file.Write(&bih,sizeof(BITMAPINFOHEADER));
  198. BYTE *p=new BYTE[bmp.bmWidthBytes * bmp.bmHeight];
  199. if(bBitmapFormat==TRUE)
  200. {
  201. GetDIBits( dc.m_hDC,(HBITMAP)m_bpAllPicture,0,bmp.bmHeight,p,
  202. (LPBITMAPINFO)&bih,DIB_RGB_COLORS);
  203. }
  204. else
  205. {
  206. m_bpAllPicture.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)p);
  207. }
  209. file.WriteHuge(p,bmp.bmWidthBytes * bmp.bmHeight);
  210. delete[] p;
  211. file.Close();
  214. if(m_bpPicture1.m_hObject==NULL)
  215. {
  216. return;
  217. }
  218. m_bpPicture1.GetBitmap(&bmp);
  219. strFilePath.Insert(strFilePath.GetLength()-4,"Prt1");
  220. CFile file1(strFilePath,CFile::modeWrite|CFile::modeCreate);
  221. strFilePath.Delete(strFilePath.GetLength()-8,4);
  222. memset(&bih,0,sizeof(BITMAPINFOHEADER));
  223. bih.biBitCount=bmp.bmBitsPixel;
  224. bih.biCompression=BI_RGB;
  225. bih.biHeight=bmp.bmHeight;
  226. bih.biPlanes=1;
  227. bih.biSize=sizeof(BITMAPINFOHEADER);
  228. bih.biSizeImage=bmp.bmWidthBytes*bmp.bmHeight;
  229. bih.biWidth=bmp.bmWidth;
  230. memset(&bfh,0,sizeof(BITMAPFILEHEADER));
  231. bfh.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
  232. bfh.bfSize=bfh.bfOffBits+bmp.bmWidthBytes*bmp.bmHeight;
  233. bfh.bfType=(WORD)(_T('M')<<8|_T('B'));
  234. file1.Write(&bfh,sizeof(BITMAPFILEHEADER));
  235. file1.Write(&bih,sizeof(BITMAPINFOHEADER));
  237. BYTE *p1=new BYTE[bmp.bmWidthBytes * bmp.bmHeight];
  238. if(bBitmapFormat==TRUE)
  239. {
  240. GetDIBits( dc.m_hDC,(HBITMAP)m_bpPicture1,0,bmp.bmHeight,p1,
  241. (LPBITMAPINFO)&bih,DIB_RGB_COLORS);
  242. }
  243. else
  244. {
  245. m_bpPicture1.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)p1);
  246. }
  248. file1.WriteHuge(p1,bmp.bmWidthBytes * bmp.bmHeight);
  249. file1.Close();
  250. delete[] p1;
  252. if(m_bpPicture2.m_hObject==NULL)
  253. {
  254. return;
  255. }
  256. m_bpPicture2.GetBitmap(&bmp);
  257. strFilePath.Insert(strFilePath.GetLength()-4,"Prt2");
  258. CFile file2(strFilePath,CFile::modeWrite|CFile::modeCreate);
  259. strFilePath.Delete(strFilePath.GetLength()-8,4);
  260. memset(&bih,0,sizeof(BITMAPINFOHEADER));
  261. bih.biBitCount=bmp.bmBitsPixel;
  262. bih.biCompression=BI_RGB;
  263. bih.biHeight=bmp.bmHeight;
  264. bih.biPlanes=1;
  265. bih.biSize=sizeof(BITMAPINFOHEADER);
  266. bih.biSizeImage=bmp.bmWidthBytes*bmp.bmHeight;
  267. bih.biWidth=bmp.bmWidth;
  268. memset(&bfh,0,sizeof(BITMAPFILEHEADER));
  269. bfh.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
  270. bfh.bfSize=bfh.bfOffBits+bmp.bmWidthBytes*bmp.bmHeight;
  271. bfh.bfType=(WORD)(_T('M')<<8|_T('B'));
  272. file2.Write(&bfh,sizeof(BITMAPFILEHEADER));
  273. file2.Write(&bih,sizeof(BITMAPINFOHEADER));
  275. BYTE *p2=new BYTE[bmp.bmWidthBytes * bmp.bmHeight];
  276. if(bBitmapFormat==TRUE)
  277. {
  278. GetDIBits( dc.m_hDC,(HBITMAP)m_bpPicture2,0,bmp.bmHeight,p2,
  279. (LPBITMAPINFO)&bih,DIB_RGB_COLORS);
  280. }
  281. else
  282. {
  283. m_bpPicture2.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)p2);
  284. }
  286. file2.WriteHuge(p2,bmp.bmWidthBytes * bmp.bmHeight);
  287. file2.Close();
  288. delete []p2;
  289. #endif
  290. }
  294. BOOL CQQBitmap::DividPictureV()
  295. {
  296. //垂直分割图片,以m_bpAllPicture为蓝本,结果保存到m_bpPicture1中
  297. BITMAP bmp;
  298. m_bpAllPicture.GetBitmap(&bmp);
  299. int nPosX=bmp.bmWidthBytes;
  300. int nPosY=bmp.bmHeight;
  301. BYTE *pData1=new BYTE[nPosX*nPosY];
  302. m_bpAllPicture.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)pData1);
  304. LONG *pData=(LONG*)pData1;
  305. ASSERT(nPosX%4==0);
  306. nPosX/=4;
  307. // int x,y;
  308. //
  309. // int nSameColorLineX=0;
  310. // BOOL bNewBegin=TRUE;
  311. // int nTop=-1,nBottom=-1;
  312. // //此标志为真,预示着当前正在经历非线条
  313. //
  314. // for(y=0;y<nPosY;y++)
  315. // {
  316. // LONG tempPre;
  317. //
  318. // int nDiff=0;
  319. // for(x=0;x<nPosX;x++)
  320. // {
  321. // LONG temp=pData[y*nPosX+x];
  322. // if(x==0)
  323. // {
  324. // tempPre=temp;
  325. // continue;
  326. // }
  327. //
  328. // BYTE /*t4,*/t3,t2,t1;
  329. //// t4=HIBYTE(HIWORD(temp)); //保留
  330. // t3=LOBYTE(HIWORD(temp)); //红色
  331. // t2=HIBYTE(LOWORD(temp)); //绿色
  332. // t1=LOBYTE(LOWORD(temp)); //蓝色
  333. // BYTE p1,p2,p3/*,p4*/;
  334. //// p4=HIBYTE(HIWORD(tempPre)); //保留
  335. // p3=LOBYTE(HIWORD(tempPre)); //红色
  336. // p2=HIBYTE(LOWORD(tempPre)); //绿色
  337. // p1=LOBYTE(LOWORD(tempPre)); //蓝色
  338. //
  339. // if(abs((UINT)t1-(UINT)p1)<=20&&abs((UINT)t2-(UINT)p2)<=20&&
  340. // abs((UINT)t3-(UINT)p3)<=20)
  341. // {
  342. // //do nothing;
  343. // }
  344. // else
  345. // {
  346. // //出现一行的颜色变化幅度非常大,则认为此行为非分割线条
  347. // nDiff++;
  348. // if(nDiff>=10)
  349. // {
  350. // if(nSameColorLineX==3&&nTop==-1)
  351. // {
  352. // //处于top位置
  353. // nTop=y;
  354. // }
  355. // bNewBegin=TRUE;
  356. // break;
  357. // //此行无需再比较,直接跳出;
  358. // }
  359. // }
  360. // tempPre=temp;
  361. // }
  362. //
  363. // if(x>=nPosX)
  364. // {
  365. // //刚刚经历了分割线条
  366. // if(bNewBegin==TRUE)
  367. // {
  368. // nSameColorLineX++;
  369. // if(nSameColorLineX==4&&nBottom==-1)
  370. // {
  371. // //记录下下限位置
  372. // nBottom=y-1;
  373. // }
  374. // bNewBegin=FALSE;
  375. // }
  376. // }
  377. // }
  378. //
  380. int nTop,nBottom;
  381. //卡通场的数据;
  382. if(m_bSmall==TRUE)
  383. {
  384. nTop=186;
  385. nBottom=471;
  386. }
  387. else
  388. {
  389. nTop=192;
  390. nBottom=639;
  391. }
  393. LONG *pData2=new LONG[nPosX*(nBottom-nTop+1)];
  394. memcpy(pData2,&pData[nTop*nPosX],nPosX*4*(nBottom-nTop+1));
  395. delete []pData1;
  396. m_nTop=nTop;
  397. m_nBottom=nBottom;
  399. BITMAPINFO bih={0};
  400. bih.bmiHeader.biBitCount=bmp.bmBitsPixel;
  401. bih.bmiHeader.biCompression=BI_RGB;
  402. bih.bmiHeader.biHeight=-nBottom+nTop-1;
  403. bih.bmiHeader.biPlanes=1;
  404. bih.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
  405. bih.bmiHeader.biWidth=nPosX;
  406. bih.bmiHeader.biSizeImage=bih.bmiHeader.biWidth*bih.bmiHeader.biHeight*4;
  408. CClientDC dc(NULL); 
  409. HBITMAP hBitmap;
  410. hBitmap=CreateDIBitmap(dc.m_hDC,(BITMAPINFOHEADER *)&bih,
  411. CBM_INIT,(VOID *)pData2,&bih,DIB_RGB_COLORS);
  413. m_bpPicture1.Attach(hBitmap);
  415. delete []pData2;
  416. return TRUE;
  417. }
  419. BOOL CQQBitmap::DividPictureH()
  420. {
  421. //垂直分割图片,以m_bpPicture1为蓝本,结果保存到m_bpPicture1,2中
  422. int p1Left,p1Right,p2Left,p2Right;
  424. if(m_bSmall==FALSE)
  425. {
  426. p1Left=8;
  427. p1Right=504;
  428. p2Left=517;
  429. p2Right=1013;
  430. }
  431. else
  432. {
  433. p1Left=10;
  434. p1Right=390;
  435. p2Left=403;
  436. p2Right=783;
  437. }
  439. m_nP1Right=p1Right;
  440. m_nP1Left=p1Left;
  441. m_nP2Left=p2Left;
  443. BITMAP bmp;
  444. m_bpPicture1.GetBitmap(&bmp);
  445. int nPosX=bmp.bmWidthBytes;
  446. int nPosY=bmp.bmHeight;
  447. BYTE *pData1=new BYTE[nPosX*nPosY];
  448. m_bpPicture1.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)pData1);
  450. LONG *pData=(LONG*)pData1;
  451. ASSERT(nPosX%4==0);
  452. nPosX/=4;
  454. LONG *pTempData=new LONG[bmp.bmHeight*(p1Right-p1Left+1)];
  456. for(int j=0;j<bmp.bmHeight;j++)
  457. {
  458. for(int i=p1Left;i<=p1Right;i++)
  459. {
  460. pTempData[j*(p1Right-p1Left+1)+i-p1Left]=pData[j*nPosX+i];
  461. }
  462. }
  464. BITMAPINFO bih={0};
  465. bih.bmiHeader.biBitCount=bmp.bmBitsPixel;
  466. bih.bmiHeader.biCompression=BI_RGB;
  467. bih.bmiHeader.biHeight=-bmp.bmHeight;
  468. bih.bmiHeader.biPlanes=1;
  469. bih.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
  470. bih.bmiHeader.biWidth=p1Right-p1Left+1;
  471. bih.bmiHeader.biSizeImage=bih.bmiHeader.biWidth*bih.bmiHeader.biHeight*4;
  473. CClientDC dc(NULL); 
  474. HBITMAP hBitmap;
  475. hBitmap=CreateDIBitmap(dc.m_hDC,(BITMAPINFOHEADER *)&bih,
  476. CBM_INIT,(VOID *)pTempData,&bih,DIB_RGB_COLORS);
  478. m_bpPicture1.Detach();
  479. m_bpPicture1.Attach(hBitmap);
  481. for(j=0;j<bmp.bmHeight;j++)
  482. {
  483. for(int i=p2Left;i<=p2Right;i++)
  484. {
  485. pTempData[j*(p2Right-p2Left+1)+i-p2Left]=pData[j*nPosX+i];
  486. }
  487. }
  489. bih.bmiHeader.biWidth=p2Right-p2Left+1;
  490. bih.bmiHeader.biSizeImage=bih.bmiHeader.biWidth*bih.bmiHeader.biHeight*4;
  492. hBitmap=CreateDIBitmap(dc.m_hDC,(BITMAPINFOHEADER *)&bih,
  493. CBM_INIT,(VOID *)pTempData,&bih,DIB_RGB_COLORS);
  495. m_bpPicture2.Attach(hBitmap);
  497. delete []pTempData;
  498. delete []pData1;
  500. return TRUE;
  501. }
  503. //void CQQBitmap::GetHLine(int &p1Left,int &p1Right,int &p2Left,int &p2Right)
  504. //{
  505. // BITMAP bmp;
  506. // m_bpPicture1.GetBitmap(&bmp);
  507. // int nPosX=bmp.bmWidthBytes;
  508. // int nPosY=bmp.bmHeight;
  509. // BYTE *pData1=new BYTE[nPosX*nPosY];
  510. // m_bpPicture1.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)pData1);
  511. //
  512. // LONG *pData=(LONG*)pData1;
  513. // ASSERT(nPosX%4==0);
  514. // nPosX/=4;
  515. //
  516. // for(int i=0;i<nPosY;i++)
  517. // {
  518. // for(int j=0;j<nPosX;j++)
  519. // {
  520. // LONG temp=pData[i*nPosX+j];
  521. // BYTE t4,t3,t2,t1;
  522. // t4=HIBYTE(HIWORD(temp)); //保留
  523. // t3=LOBYTE(HIWORD(temp)); //红色
  524. // t2=HIBYTE(LOWORD(temp)); //绿色
  525. // t1=LOBYTE(LOWORD(temp)); //蓝色
  526. //
  527. // if(t1>=110&&t2>=110&&t3>=110)
  528. // {
  529. // pData[i*nPosX+j]=255|255<<8|255<<16|255<<24;
  530. // }
  531. // else
  532. // {
  533. // pData[i*nPosX+j]=0|0<<8|0<<16|0<<24;
  534. // }
  535. // }
  536. // }
  537. //
  538. // m_bpPicture1.SetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,pData1);
  539. // PrintBitmapToFile("测试1.bmp",TRUE);
  540. //
  541. // int x,y;
  542. // int nGet=1;
  543. // BOOL bInGet=FALSE;
  544. // for(x=0;x<nPosX;x++)
  545. // {
  546. // int nBlack=0;
  547. // for(y=0;y<nPosY;y++)
  548. // {
  549. // LONG temp1=pData[y*nPosX+x];
  550. // if(temp1==(0|0<<8|0<<16|0<<24))
  551. // {
  552. // //出现黑色点超过十个,认为不是垂直线条区域,直接跳出
  553. // if(++nBlack>=10)
  554. // {
  555. // if(bInGet==TRUE)
  556. // {
  557. // bInGet=FALSE;
  558. // nGet++;
  559. // }
  560. // break;
  561. // }
  562. // }
  563. // }
  564. //
  565. // if(y>=nPosY)
  566. // {
  567. // //出现了第一条线全都是白色的列线条
  568. // if(nGet==1)
  569. // {
  570. // bInGet=TRUE;
  571. // p1Left=x;
  572. // }
  573. // else if(nGet==2)
  574. // {
  575. // //出现第二条白线
  576. // p1Right=x;
  577. // nGet++;
  578. // }
  579. // else if(nGet==3)
  580. // {
  581. // p2Left=x;
  582. // bInGet=TRUE;
  583. // }
  584. // else if(nGet==4)
  585. // {
  586. // p2Right=x;
  587. // break;
  588. // }
  589. // }
  590. // }
  591. //
  592. // delete []pData1;
  593. // p1Left++;
  594. // p1Right--;
  595. // p2Left++;
  596. // p2Right--;
  597. // ASSERT(p1Right-p1Left==p2Right-p2Left);
  598. //}
  600. void CQQBitmap::FindDifferent()
  601. {
  602. BITMAP bmp;
  603. m_bpPicture1.GetBitmap(&bmp);
  604. int nPosX=bmp.bmWidthBytes;
  605. int nPosY=bmp.bmHeight;
  606. BYTE *pDataX=new BYTE[nPosX*nPosY];
  607. m_bpPicture1.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)pDataX);
  608. LONG *pData1=(LONG*)pDataX;
  610. BYTE *pDataY=new BYTE[nPosX*nPosY];
  611. m_bpPicture2.GetBitmap(&bmp);
  612. ASSERT((nPosX==bmp.bmWidthBytes)&&(nPosY==bmp.bmHeight));
  613. m_bpPicture2.GetBitmapBits(bmp.bmWidthBytes * bmp.bmHeight,(LPVOID)pDataY);
  614. LONG *pData2=(LONG*)pDataY;
  616. ASSERT(nPosX%4==0);
  617. nPosX/=4;
  619. int x,y;
  621. for(y=0;y<nPosY;y++)
  622. {
  623. for(x=0;x<nPosX;x++)
  624. {
  625. int n=m_arrayDifRect.GetSize();
  626. POINT ptTemp;
  627. ptTemp.x=x;
  628. ptTemp.y=y;
  630. while(n)
  631. {
  632. n--;
  633. RECT rcTemp=m_arrayDifRect.GetAt(n);
  634. rcTemp.left=rcTemp.left-6>0?rcTemp.left-6:0;
  635. rcTemp.right+=6;
  636. rcTemp.top=rcTemp.top-6>0?rcTemp.top-6:0;;
  637. rcTemp.bottom+=6;
  638. if(PtInRect(&rcTemp,ptTemp)==TRUE)
  639. {
  640. break;
  641. }
  642. }
  644. if(n>0)
  645. {
  646. continue;
  647. }
  649. if(pData2[y*nPosX+x]!=pData1[y*nPosX+x])
  650. {
  651. //向右寻找,直到连续五个像素都相同,则认为为右边界
  652. int nRight,nBottom,nFlag=0;
  653. for(nRight=x+1;nRight<nPosX;nRight++)
  654. {
  655. if(pData2[y*nPosX+nRight]==pData1[y*nPosX+nRight])
  656. {
  657. nFlag++;
  658. if(nFlag>=5)
  659. {
  660. break;
  661. }
  662. }
  663. else
  664. {
  665. nFlag=0;
  666. }
  667. }
  669. if(nFlag<5)
  670. {
  671. //nRight到达右极限
  672. nRight=nPosX-1-nFlag;
  673. }
  674. else
  675. {
  676. //达到五个像素连续相同的条件
  677. nRight=nRight-5;
  678. }
  680. //向下寻找,知道连续个像素都相同,则认为为下边界
  681. nFlag=0;
  682. for(nBottom=y+1;nBottom<nPosY;nBottom++)
  683. {
  684. if(pData2[nBottom*nPosX+x]==pData1[nBottom*nPosX+x])
  685. {
  686. nFlag++;
  687. if(nFlag>=5)
  688. {
  689. break;
  690. }
  691. }
  692. else
  693. {
  694. nFlag=0;
  695. }
  696. }
  698. if(nFlag<5)
  699. {
  700. //nRight到达右极限
  701. nBottom=nPosY-1-nFlag;
  702. }
  703. else
  704. {
  705. //达到五个像素连续相同的条件
  706. nBottom=nBottom-5;
  707. }
  709. RECT rcTemp;
  710. rcTemp.left=x;
  711. rcTemp.top=y;
  712. rcTemp.right=nRight;
  713. rcTemp.bottom=nBottom;
  714. m_arrayDifRect.Add(rcTemp);
  715. x=nRight;
  716. }
  717. }
  718. }
  720. int nCount=m_arrayDifRect.GetSize();
  721. int i=0;
  723. //#ifdef _DEBUG
  724. // while(i<nCount)
  725. // {
  726. // //调整坐标位置为相对于窗体的位置
  727. // RECT rcTemp=m_arrayDifRect.GetAt(i);
  728. // rcTemp.left+=m_nP1Left;
  729. // rcTemp.right+=m_nP1Left;
  730. // rcTemp.top+=m_nTop;
  731. // rcTemp.bottom+=m_nTop;
  732. // m_arrayDifRect.RemoveAt(i);
  733. // m_arrayDifRect.InsertAt(i,rcTemp);
  734. // i++;
  735. // }
  736. //#endif
  738. while(i<nCount)
  739. {
  740. RECT rcTemp=m_arrayDifRect.GetAt(i);
  741. m_arrayDifRect.RemoveAt(i);
  742. if(rcTemp.right-rcTemp.left<=6||rcTemp.bottom-rcTemp.top<=6)
  743. {
  744. nCount--;
  745. }
  746. else
  747. {
  748. m_arrayDifRect.InsertAt(i,rcTemp);
  749. i++;
  750. }
  751. }
  753. HDC hdcMem;
  754. CDC MemDC;
  756. CClientDC dc(NULL);
  757. hdcMem=CreateCompatibleDC(dc.m_hDC); //?????hdc?????dc
  758. MemDC.Attach(hdcMem);//?hdcMem?pMemDC????
  760. m_bpAllPicture.GetBitmap(&bmp);
  761. nPosX=bmp.bmWidthBytes;
  762. nPosY=bmp.bmHeight;
  764. CBitmap *pOldBitmap=MemDC.SelectObject(&m_bpAllPicture); //?????hdcMem,???hdcMem???????????dc?.
  765. CBrush *pOldBrush=(CBrush *)MemDC.SelectStockObject(NULL_BRUSH);
  766. CPen pen;
  767. pen.CreatePen(PS_SOLID,3,RGB(255,0,0));
  768. CPen *pOldPen=(CPen *)MemDC.SelectObject(&pen);
  769. nCount=m_arrayDifRect.GetSize();
  771. i=0;
  772. while(i<nCount)
  773. {
  774. RECT rcTemp;
  775. rcTemp=m_arrayDifRect.GetAt(i);
  776. MemDC.Ellipse(&rcTemp);
  777. i++;
  778. }
  779. MemDC.SelectObject(pOldPen);
  780. MemDC.SelectObject(pOldBrush);
  781. MemDC.SelectObject(pOldBitmap);
  783. PrintBitmapToFile("QQ游戏.bmp",TRUE);
  785. delete []pDataX;
  786. delete []pDataY;
  787. }
  789. void CQQBitmap::CheckStyle()
  790. {
  791. BITMAP bmp;
  792. m_bpAllPicture.GetBitmap(&bmp);
  794. if(bmp.bmHeight>=700&&bmp.bmWidth>=1000)
  795. {
  796. //美女场
  797. m_bSmall=FALSE;
  798. }
  799. else
  800. {
  801. //卡通场
  802. m_bSmall=TRUE;
  803. }
  804. }
  806. void CQQBitmap::GetDiffRects(CArray<RECT,RECT> &array)
  807. {
  808. int nCount=m_arrayDifRect.GetSize();
  809. int i=0;
  810. for(i=0;i<nCount;i++)
  811. {
  812. RECT rcTemp;
  813. rcTemp=m_arrayDifRect.GetAt(i);
  814. array.Add(rcTemp);
  815. }
  816. }
  818. void CQQBitmap::GetPicture1Rect(RECT &rcP1)
  819. {
  820. rcP1.left=m_nP1Left;
  821. rcP1.right=m_nP1Right;
  822. rcP1.top=m_nTop;
  823. rcP1.bottom=m_nBottom;
  824. }