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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PlateLocateMethod.cpp
资源名称：车牌识别.rar　[点击查看]
上传用户：sgmlaoniu
上传日期：2013-03-16
资源大小：403k
文件大小：27k
源码类别：

Windows编程

开发平台：

Visual C++

PlateLocateMethod.cpp：源码内容
  1. /**************************************************************************
  2. *  文件名：PlateLocateMethod.cpp
  3. *
  4. *  车牌定位函数库：
  5. *  
  6. *  ConvertToGrayScale();   - 24位真彩色图转换成灰度图
  7. *************************************************************************/
  9. #include "stdafx.h"
  10. #include "PlateLocateMethod.h"
  11. #include "math.h"
  13. /*************************************************************************
  14. *
  15. * 函数名称：
  16. *   ConvertToGrayScale()
  17. *
  18. * 参数:
  19. *   LPSTR lpDIB - 指向源DIB图像指针
  20. *   
  21. * 返回值:
  22. *   BOOL - 成功返回TRUE，否则返回FALSE。
  23. *
  24. * 说明:
  25. *   该函数将24位真彩色图转换成256级灰度图
  26. *
  27. ************************************************************************/
  28. BOOL WINAPI ConvertToGrayScale(LPSTR lpDIB)   
  29. {
  31. LPSTR lpDIBBits;                //指向DIB的象素的指针
  32. LPSTR lpNewDIBBits;             //指向DIB灰度图图像(新图像)开始处象素的指针
  33.     LONG lLineBytes;
  34. unsigned char * lpSrc;          //指向原图像象素点的指针
  35. unsigned char * lpdest;         //指向目标图像象素点的指针
  37.     unsigned  char *ired,*igreen,*iblue;
  39.     long lWidth;                    //图像宽度和高度
  40. long lHeight;
  42. long i,j;           //循环变量
  44. lWidth = ::DIBWidth(lpDIB);   //DIB 宽度
  45. lHeight = ::DIBHeight(lpDIB); //DIB 高度
  46. RGBQUAD  *lpRGBquad;
  47. lpRGBquad = (RGBQUAD *)&lpDIB[sizeof(BITMAPINFOHEADER)]; //INFOHEADER后为调色板
  48.     if(::DIBNumColors(lpDIB) == 256)  //256色位图不作任何处理
  49. {
  50. return TRUE;
  51.     }
  53. if(::DIBNumColors(lpDIB) != 256)  //非256色位图将它灰度化
  54. {
  55. lLineBytes = WIDTHBYTES(lWidth*8*3);//真彩色一个象素为3个字节
  56. lpdest=  new  BYTE[lHeight*lWidth];
  57. lpDIBBits = (LPSTR)lpDIB + sizeof(BITMAPINFOHEADER);//指向DIB象素
  58. for(i = 0;i < lHeight; i++)
  59. for(j = 0;j < lWidth*3; j+=3)//每个象素3个字节
  60. {
  61. ired   =  (unsigned  char*)lpDIBBits + lLineBytes * i + j + 2;
  62. igreen =  (unsigned  char*)lpDIBBits + lLineBytes * i + j + 1;
  63. iblue  =  (unsigned  char*)lpDIBBits + lLineBytes * i + j ;
  64. lpdest[i*lWidth + j/3]  = (unsigned  char)((*ired)*0.299 + (*igreen)*0.588 + (*iblue)*0.114);
  65. }
  67. //需要做三件事情：1、修改INFOHEADER 2、增加调色板 3、修改原图像灰度值
  68. LPBITMAPINFOHEADER  lpBI;
  69. lpBI  =  (LPBITMAPINFOHEADER)lpDIB;
  70. lpBI->biBitCount = 8;
  72. //设置灰度调色板
  73. for(i = 0;i < 256;i++)
  74. {
  75. lpRGBquad[i].rgbRed   = (unsigned char)i;
  76. lpRGBquad[i].rgbGreen = (unsigned char)i;
  77. lpRGBquad[i].rgbBlue  = (unsigned char)i;
  78. lpRGBquad[i].rgbReserved = 0;
  79. }
  81. lpNewDIBBits= ::FindDIBBits(lpDIB);  //找到DIB图像象素起始位置
  82. lLineBytes=WIDTHBYTES(lWidth  *  8);
  83. //修改灰度值
  84. for(i = 0;i < lHeight; i++)
  85. for(j = 0;j < lWidth; j++)
  86. {
  87. lpSrc = (unsigned  char*)lpNewDIBBits + lLineBytes * i+ j ;
  88. *lpSrc=lpdest[i*lWidth+j];
  89. }
  90. delete  lpdest;
  91. }
  92. return true;
  93. }
  94. /*************************************************************************
  95.  *
  96.  * 函数名称：
  97.  *   InteEqualize()
  98.  *
  99.  * 参数:
  100.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  101.  *   LONG  lWidth       - 源图像宽度（象素数）
  102.  *   LONG  lHeight      - 源图像高度（象素数）
  103.  *
  104.  * 返回值:
  105.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  106.  *
  107.  * 说明:
  108.  *   该函数用来对图像进行直方图均衡。
  109.  *
  110.  ************************************************************************/
  111. BOOL WINAPI InteEqualize(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  112. {
  114. // 指向源图像的指针
  115. unsigned char* lpSrc;
  117. // 临时变量
  118. LONG lTemp;
  120. // 循环变量
  121. LONG i;
  122. LONG j;
  124. // 灰度映射表
  125. BYTE bMap[256];
  127. // 灰度映射表
  128. LONG lCount[256];
  130. // 图像每行的字节数
  131. LONG lLineBytes;
  133. // 计算图像每行的字节数
  134. lLineBytes = WIDTHBYTES(lWidth * 8);
  136. // 重置计数为0
  137. for (i = 0; i < 256; i ++)
  138. {
  139. // 清零
  140. lCount[i] = 0;
  141. }
  143. // 计算各个灰度值的计数
  144. for (i = 0; i < lHeight; i ++)
  145. {
  146. for (j = 0; j < lWidth; j ++)
  147. {
  148. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * i + j;
  150. // 计数加1
  151. lCount[*(lpSrc)]++;
  152. }
  153. }
  155. // 计算灰度映射表
  156. for (i = 0; i < 256; i++)
  157. {
  158. // 初始为0
  159. lTemp = 0;
  161. for (j = 0; j <= i ; j++)
  162. {
  163. lTemp += lCount[j];
  164. }
  166. // 计算对应的新灰度值
  167. bMap[i] = (BYTE) (lTemp * 255 / (lHeight * lWidth));
  168. }
  170. // 每行
  171. for(i = 0; i < lHeight; i++)
  172. {
  173. // 每列
  174. for(j = 0; j < lWidth; j++)
  175. {
  176. // 指向DIB第i行，第j个象素的指针
  177. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  179. // 计算新的灰度值
  180. *lpSrc = bMap[*lpSrc];
  181. }
  182. }
  184. // 返回
  185. return TRUE;
  186. }
  187. /*************************************************************************
  188.  *
  189.  * 函数名称：
  190.  *   RobertDIB()
  191.  *
  192.  * 参数:
  193.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  194.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  195.  *   LONG  lHeight      - 源图像高度（象素数）
  196.  * 返回值:
  197.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  198.  *
  199.  * 说明:
  200.  * 该函数用Robert边缘检测算子对图像进行边缘检测运算。
  201.  * 
  202.  * 要求目标图像为灰度图像。
  203.  ************************************************************************/
  205. BOOL WINAPI RobertDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  206. {
  208. // 指向源图像的指针
  209. LPSTR lpSrc;
  211. // 指向缓存图像的指针
  212. LPSTR lpDst;
  214. // 指向缓存DIB图像的指针
  215. LPSTR lpNewDIBBits;
  216. HLOCAL hNewDIBBits;
  218. //循环变量
  219. long i;
  220. long j;
  222. //像素值
  223. double result;
  224. unsigned char pixel[4];
  226. // 暂时分配内存，以保存新图像
  227. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  229. if (hNewDIBBits == NULL)
  230. {
  231. // 分配内存失败
  232. return FALSE;
  233. }
  235. // 锁定内存
  236. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  238. // 初始化新分配的内存，设定初始值为255
  239. lpDst = (char *)lpNewDIBBits;
  240. memset(lpDst, (BYTE)255, lWidth * lHeight);
  243. //使用水平方向的结构元素进行腐蚀
  244. for(j = lHeight-1; j > 0; j--)
  245. {
  246. for(i = 0;i <lWidth-1; i++)
  247. {
  248. //由于使用2×2的模板，为防止越界，所以不处理最下边和最右边的两列像素
  250. // 指向源图像第j行，第i个象素的指针
  251. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  253. // 指向目标图像第j行，第i个象素的指针
  254. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  256. //取得当前指针处2*2区域的像素值，注意要转换为unsigned char型
  257. pixel[0] = (unsigned char)*lpSrc;
  258. pixel[1] = (unsigned char)*(lpSrc + 1);
  259. pixel[2] = (unsigned char)*(lpSrc - lWidth);
  260. pixel[3] = (unsigned char)*(lpSrc - lWidth + 1);
  262. //计算目标图像中的当前点
  263.  result = sqrt(( pixel[0] - pixel[3] )*( pixel[0] - pixel[3] ) + 
  264.   ( pixel[1] - pixel[2] )*( pixel[1] - pixel[2] ));
  265. *lpDst = (unsigned char)result;
  267. }
  268. }
  270. // 复制腐蚀后的图像
  271. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  273. // 释放内存
  274. LocalUnlock(hNewDIBBits);
  275. LocalFree(hNewDIBBits);
  277. // 返回
  278. return TRUE;
  279. }
  280. /*************************************************************************
  281. *
  282. * 函数名称：
  283. *   ThresholdTrans()
  284. *
  285. * 参数:
  286. *   LPSTR lpDIBBits    - 指向源DIB图像指针
  287. *   LONG  lWidth       - 源图像宽度（象素数）
  288. *   LONG  lHeight      - 源图像高度（象素数）
  289. *   BYTE  bThre     - 阈值
  290. *
  291. * 返回值:
  292. *   BOOL               - 成功返回TRUE，否则返回FALSE。
  293. *
  294. * 说明:
  295. *   该函数用来对图像进行阈值变换。对于灰度值小于阈值的象素直接设置
  296. * 灰度值为0；灰度值大于阈值的象素直接设置为255。
  297. *
  298. ************************************************************************/
  299. BOOL WINAPI ThresholdTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, BYTE bThre)
  300. {
  302. // 指向源图像的指针
  303. unsigned char* lpSrc;
  305. // 循环变量
  306. LONG i;
  307. LONG j;
  309. // 图像每行的字节数
  310. LONG lLineBytes;
  312. // 计算图像每行的字节数
  313. lLineBytes = WIDTHBYTES(lWidth * 8);
  315. // 每行
  316. for(i = 0; i < lHeight; i++)
  317. {
  318. // 每列
  319. for(j = 0; j < lWidth; j++)
  320. {
  321. // 指向DIB第i行，第j个象素的指针
  322. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  324. // 判断是否小于阈值
  325. if ((*lpSrc) < bThre)
  326. {
  327. // 直接赋值为0
  328. *lpSrc = 0;
  329. }
  330. else
  331. {
  332. // 直接赋值为255
  333. *lpSrc = 255;
  334. }
  335. }
  336. }
  338. // 返回
  339. return TRUE;
  340. }
  342. /*************************************************************************
  343. *
  344. * 函数名称：
  345. *   myHprojectDIB()
  346. *
  347. * 参数:
  348. *   LPSTR lpDIBBits    - 指向源DIB图像指针
  349. *   LONG  lWidth       - 源图像宽度（象素数）
  350. *   LONG  lHeight      - 源图像高度（象素数）
  351. *   INT*  iTop         - 车牌上边缘
  352. *   INT*  iBottom      - 车牌下边缘
  353. * 返回值:
  354. *   BOOL               - 成功返回TRUE，否则返回FALSE。
  355. *
  356. * 说明:
  357. *   该函数用于对含车牌图像进行水平投影运算，求取车牌子图像的上下边缘位置
  358. *
  359. ************************************************************************/
  360. BOOL WINAPI myHprojectDIB(LPSTR lpDIB, LONG lWidth, LONG lHeight, 
  361.   int* iTop, int* iBottom) 
  362. {
  363. LPSTR lpDIBBits;                   //指向DIB的象素的指针
  365.     LONG lLineBytes;                   // 图像每行的字节数
  366. unsigned char * lpSrc;             //指向原图像象素点的指针
  368. unsigned char pixel; //像素值
  370. int i,j;
  372. // 计算结果
  373. INT* iResult;
  375. INT pzBottom,pzTop;
  377. bool findPZ=false;
  379. // 找到DIB图像象素起始位置
  380. lpDIBBits = ::FindDIBBits(lpDIB);
  382. // 计算图像每行的字节数
  383. lLineBytes = WIDTHBYTES(lWidth * 8);
  385. iResult=new INT[lHeight];
  387. for(i=0;i<lHeight;i++)
  388. iResult[i]=0;
  390. for(j=lHeight/7;j<lHeight*0.8;j++)
  391. {
  392. iResult[j]=0;
  393. for(i=0;i<lWidth;i++)
  394. {
  395. lpSrc=(unsigned char*)lpDIBBits+lLineBytes*j+i;
  396. pixel=(unsigned char)(*lpSrc);
  397. if(pixel==255)
  398. {
  399. iResult[j]++;
  400. }
  401. }
  402. if((!findPZ)&&iResult[j]>12)
  403. {
  404. pzBottom=j;
  405. findPZ=true;
  406. continue;
  407. }
  408. if(findPZ&&iResult[j]<12)
  409. {
  410. pzTop=j;
  411. break;
  412. }
  414. }
  415. if(pzTop - pzBottom < 40)
  416. {
  417. pzTop=pzTop+55;
  418. pzBottom=pzBottom-20;   //微量调整
  419. }
  420. *iBottom=lHeight-pzBottom;
  421. //*iBottom=pzBottom;
  422. *iTop=lHeight-pzTop;
  423. //*iTop=pzTop;
  424. return true;
  425. }
  427. /*************************************************************************
  428. *
  429. * 函数名称：
  430. *   myVprojectDIB()
  431. *
  432. * 参数:
  433. *   LPSTR lpDIBBits    - 指向源DIB图像指针
  434. *   LONG  lWidth       - 源图像宽度（象素数）
  435. *   LONG  lHeight      - 源图像高度（象素数）
  436. *   INT*  iLeft        - 车牌左边缘
  437. *   INT*  iRight       - 车牌右边缘
  438. * 返回值:
  439. *   BOOL               - 成功返回TRUE，否则返回FALSE。
  440. *
  441. * 说明:
  442. *   该函数用于对含车牌图像进行垂直投影运算，求取车牌子图像的左右边缘位置
  443. *
  444. ************************************************************************/
  445. BOOL WINAPI myVprojectDIB(LPSTR lpDIB, LONG lWidth, LONG lHeight, 
  446.   int* iLeft, int* iRight) 
  447. {
  448. LPSTR lpDIBBits;                   //指向DIB的象素的指针
  450.     LONG lLineBytes;                   // 图像每行的字节数
  451. unsigned char * lpSrc;             //指向原图像象素点的指针
  453. unsigned char pixel; //像素值
  455. int i,j;
  457. // 计算结果
  458. INT* iResult;
  460. INT pzLeft,pzRight;
  462. bool findPZ=false;
  464. // 找到DIB图像象素起始位置
  465. lpDIBBits = ::FindDIBBits(lpDIB);
  467. // 计算图像每行的字节数
  468. lLineBytes = WIDTHBYTES(lWidth * 8);
  470. iResult=new INT[lWidth];
  472. for(i=0;i<lWidth;i++)
  473. iResult[i]=0;
  475. for(i=lWidth/7;i<lWidth*0.8;i++)
  476. {
  477. iResult[i]=0;
  478. for(j=0;j<lHeight;j++)
  479. {
  480. lpSrc=(unsigned char*)lpDIBBits+lLineBytes*j+i;
  481. pixel=(unsigned char)(*lpSrc);
  482. if(pixel==255)
  483. {
  484. iResult[i]++;
  485. }
  486. }
  487. if((!findPZ)&&iResult[i]>12)
  488. {
  489. pzLeft=i;
  490. findPZ=true;
  491. continue;
  492. }
  494. pzRight=pzLeft+150;
  495. }
  497. *iLeft=pzLeft-10;
  498. *iRight=pzRight+10;
  499. return true;
  500. }
  502. /*************************************************************************
  503. *
  504. * 函数名称：
  505. *   Template()
  506. *
  507. * 参数:
  508. *   LPSTR lpDIBBits    - 指向源DIB图像指针
  509. *   LONG  lWidth       - 源图像宽度（象素数）
  510. *   LONG  lHeight      - 源图像高度（象素数）
  511. *   int   iTempH - 模板的高度
  512. *   int   iTempW - 模板的宽度
  513. *   int   iTempMX - 模板的中心元素X坐标 ( < iTempW - 1)
  514. *   int   iTempMY - 模板的中心元素Y坐标 ( < iTempH - 1)
  515. *  FLOAT * fpArray - 指向模板数组的指针
  516. *  FLOAT fCoef - 模板系数
  517. *
  518. * 返回值:
  519. *   BOOL               - 成功返回TRUE，否则返回FALSE。
  520. *
  521. * 说明:
  522. *   该函数用指定的模板（任意大小）来对图像进行操作，参数iTempH指定模板
  523. * 的高度，参数iTempW指定模板的宽度，参数iTempMX和iTempMY指定模板的中心
  524. * 元素坐标，参数fpArray指定模板元素，fCoef指定系数。
  525. *
  526. ************************************************************************/
  528. BOOL WINAPI myTemplate(LPSTR lpDIB)
  529. {
  530. // 指向复制图像的指针
  531. LPSTR lpNewDIBBits;
  532. HLOCAL hNewDIBBits;
  534. // 指向要复制区域的指针
  535. unsigned char* lpDst;
  537. LPSTR lpDIBBits;                   //指向DIB的象素的指针
  539.     LONG lLineBytes;                   // 图像每行的字节数
  540. unsigned char * lpSrc;             //指向原图像象素点的指针
  542.     long lWidth;                       //图像宽度和高度
  543. long lHeight;
  545. // 计算结果
  546. INT fResult1;
  547. INT fResult2;
  548. INT fResult;
  550. // 找到DIB图像象素起始位置
  551. lpDIBBits = ::FindDIBBits(lpDIB);
  552. lWidth = ::DIBWidth(lpDIB);   //DIB 宽度
  553. lHeight = ::DIBHeight(lpDIB); //DIB 高度
  555. // 计算图像每行的字节数
  556. lLineBytes = WIDTHBYTES(lWidth * 8);
  558. // 暂时分配内存，以保存新图像
  559. hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
  561. // 判断是否内存分配失败
  562. if (hNewDIBBits == NULL)
  563. {
  564. // 分配内存失败
  565. return false;
  566. }
  568. // 锁定内存
  569. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  571. // 初始化图像为原始图像
  572. memcpy(lpNewDIBBits, lpDIBBits, lLineBytes * lHeight);
  575. long i,j;           //循环变量
  577. //
  578. //不对边缘进行处理
  579. for(i = 0; i < lHeight; i++)
  580. {
  581. // 每列
  582. for(j = 0; j < lWidth; j++)
  583. {
  584. // 指向新DIB第i行，第j个象素的指针
  585. lpDst = (unsigned char*)lpNewDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  587. // 指向DIB第i行，第j个象素的指针
  588. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  590. fResult1=abs((*lpSrc)-(*(lpSrc+1)));
  591. fResult2=abs((*lpSrc)-(*(lpSrc+lWidth)));
  593. if(fResult1 < fResult2)
  594. fResult = fResult2;
  595. else fResult = fResult1;
  597. // 取绝对值
  598. if(fResult<0) fResult=-fResult;
  600. // 判断是否超过255
  601. if(fResult > 255)
  602. {
  603. // 直接赋值为255
  604. * lpDst = 255;
  605. }
  606. else
  607. {
  608. // 赋值
  609. * lpDst = (unsigned char) (fResult + 0.5);
  610. }
  612. }
  613. }
  615. // 复制变换后的图像
  616. memcpy(lpDIBBits, lpNewDIBBits, lLineBytes * lHeight);
  618. // 释放内存
  619. LocalUnlock(hNewDIBBits);
  620. LocalFree(hNewDIBBits);
  622. // 返回
  623. return TRUE;
  624. }
  625. /*************************************************************************
  626. *
  627. * 函数名称：
  628. *   myCropDIB()
  629. *
  630. * 参数:
  631. *   HDIB hDIB          - 指向源DIB图像句柄
  632. *   LPRECT lpRect      - 指向要剪裁的矩形区域
  633. *
  634. * 返回值:
  635. *   HDIB               - 返回裁剪后的矩形区域图像句柄。
  636. *
  637. * 说明:
  638. * 该函数用于对指定图像进行指定区域裁剪操作。
  639. * 
  640. * 要求目标图像为255个灰度值的灰度图像。
  641. ************************************************************************/
  643. HDIB WINAPI myCropDIB(HDIB hDIB, LPRECT lpRect)
  644. {
  646. LPBITMAPINFO lpbmi = NULL; 
  647.     LPBYTE       lpSourceBits, lpTargetBits, lpResult; 
  648.     HDC  hDC = NULL, hSourceDC, hTargetDC; 
  649.     HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap; 
  650.     DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize; 
  651. int  nWidth, nHeight;
  652. HDIB  hNewDIB;
  653. DWORD  dwSize;
  655. // Get DIB pointer
  656. if (! hDIB)
  657. {
  658. return NULL;
  659. }
  660. LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB);
  661. if (! lpSrcDIB)
  662. {
  663. return NULL;
  664. }
  666.     // Allocate and fill out a BITMAPINFO struct for the new DIB 
  667.     dwTargetHeaderSize = sizeof( BITMAPINFOHEADER ) + PaletteSize((LPSTR)lpSrcDIB); 
  668.     lpbmi = (LPBITMAPINFO)malloc( dwTargetHeaderSize ); 
  669. memcpy(lpbmi, lpSrcDIB, dwTargetHeaderSize);
  670. nWidth = RECTWIDTH(lpRect);
  671. nHeight = RECTHEIGHT(lpRect);
  672.     lpbmi->bmiHeader.biWidth = nWidth; 
  673.     lpbmi->bmiHeader.biHeight = nHeight; 
  675.     // Gonna use DIBSections and BitBlt() to do the conversion, so make 'em 
  676. hDC = ::GetDC( NULL ); 
  677.     hTargetBitmap = CreateDIBSection( hDC, lpbmi, DIB_RGB_COLORS, (VOID **)&lpTargetBits, NULL, 0 ); 
  678.     hSourceBitmap = CreateDIBSection( hDC, lpSrcDIB, DIB_RGB_COLORS, (VOID **)&lpSourceBits, NULL, 0 ); 
  679.     hSourceDC = CreateCompatibleDC( hDC ); 
  680.     hTargetDC = CreateCompatibleDC( hDC ); 
  682.     // Flip the bits on the source DIBSection to match the source DIB 
  683.     dwSourceBitsSize = lpSrcDIB->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader)); 
  684.     dwTargetBitsSize = lpbmi->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpbmi->bmiHeader)); 
  685.     memcpy( lpSourceBits, FindDIBBits((LPSTR)lpSrcDIB), dwSourceBitsSize ); 
  686.     lpbmi->bmiHeader.biSizeImage = dwTargetBitsSize; 
  688.     // Select DIBSections into DCs 
  689.     hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap ); 
  690.     hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap ); 
  692. // put old bitmap in new bitmap 
  693.     BitBlt(hTargetDC, 0, 0, nWidth, nHeight, hSourceDC, lpRect->left, lpRect->top, SRCCOPY); 
  695.     // Clean up and delete the DCs 
  696.     SelectObject( hSourceDC, hOldSourceBitmap ); 
  697.     SelectObject( hTargetDC, hOldTargetBitmap ); 
  698.     DeleteDC( hSourceDC ); 
  699.     DeleteDC( hTargetDC ); 
  700.     ::ReleaseDC( NULL, hDC ); 
  702.     // Flush the GDI batch, so we can play with the bits 
  703.     GdiFlush(); 
  705.     // Allocate enough memory for the new CF_DIB, and copy bits 
  706. dwSize = dwTargetHeaderSize + dwTargetBitsSize;
  707. hNewDIB =(HDIB)GlobalAlloc(GHND, dwSize);
  708.     lpResult = (LPBYTE)GlobalLock(hNewDIB);//malloc( dwTargetHeaderSize + dwTargetBitsSize ); 
  709.     memcpy( lpResult, lpbmi, dwTargetHeaderSize ); 
  710.     memcpy( FindDIBBits( (LPSTR)lpResult ), lpTargetBits, dwTargetBitsSize ); 
  712.     // final cleanup 
  713.     DeleteObject( hTargetBitmap ); 
  714.     DeleteObject( hSourceBitmap ); 
  715.     free( lpbmi ); 
  716. GlobalUnlock(hDIB);
  717. GlobalUnlock(hNewDIB);
  719.     return hNewDIB;
  720. }
  722. /*************************************************************************
  723. *
  724. * 函数名称：
  725. *   MedianFilter()
  726. *
  727. * 参数:
  728. *   LPSTR lpDIBBits - 指向源DIB图像指针
  729. *   LONG  lWidth - 源图像宽度（象素数）
  730. *   LONG  lHeight - 源图像高度（象素数）
  731. *   int   iFilterH - 滤波器的高度
  732. *   int   iFilterW - 滤波器的宽度
  733. *   int   iFilterMX - 滤波器的中心元素X坐标
  734. *   int   iFilterMY - 滤波器的中心元素Y坐标
  735. *
  736. * 返回值:
  737. *   BOOL - 成功返回TRUE，否则返回FALSE。
  738. *
  739. * 说明:
  740. *   该函数对DIB图像进行中值滤波。
  741. *
  742. ************************************************************************/
  744. BOOL WINAPI myMedianFilter(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, 
  745.    int iFilterH, int iFilterW, 
  746.    int iFilterMX, int iFilterMY)
  747. {
  749. // 指向源图像的指针
  750. unsigned char* lpSrc;
  752. // 指向要复制区域的指针
  753. unsigned char* lpDst;
  755. // 指向复制图像的指针
  756. LPSTR lpNewDIBBits;
  757. HLOCAL hNewDIBBits;
  759. // 指向滤波器数组的指针
  760. unsigned char * aValue;
  761. HLOCAL hArray;
  763. // 循环变量
  764. LONG i;
  765. LONG j;
  766. LONG k;
  767. LONG l;
  769. // 图像每行的字节数
  770. LONG lLineBytes;
  772. // 计算图像每行的字节数
  773. lLineBytes = WIDTHBYTES(lWidth * 8);
  775. // 暂时分配内存，以保存新图像
  776. hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
  778. // 判断是否内存分配失败
  779. if (hNewDIBBits == NULL)
  780. {
  781. // 分配内存失败
  782. return FALSE;
  783. }
  785. // 锁定内存
  786. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  788. // 初始化图像为原始图像
  789. memcpy(lpNewDIBBits, lpDIBBits, lLineBytes * lHeight);
  791. // 暂时分配内存，以保存滤波器数组
  792. hArray = LocalAlloc(LHND, iFilterH * iFilterW);
  794. // 判断是否内存分配失败
  795. if (hArray == NULL)
  796. {
  797. // 释放内存
  798. LocalUnlock(hNewDIBBits);
  799. LocalFree(hNewDIBBits);
  801. // 分配内存失败
  802. return FALSE;
  803. }
  805. // 锁定内存
  806. aValue = (unsigned char * )LocalLock(hArray);
  808. // 开始中值滤波
  809. // 行(除去边缘几行)
  810. for(i = iFilterMY; i < lHeight - iFilterH + iFilterMY + 1; i++)
  811. {
  812. // 列(除去边缘几列)
  813. for(j = iFilterMX; j < lWidth - iFilterW + iFilterMX + 1; j++)
  814. {
  815. // 指向新DIB第i行，第j个象素的指针
  816. lpDst = (unsigned char*)lpNewDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  818. // 读取滤波器数组
  819. for (k = 0; k < iFilterH; k++)
  820. {
  821. for (l = 0; l < iFilterW; l++)
  822. {
  823. // 指向DIB第i - iFilterMY + k行，第j - iFilterMX + l个象素的指针
  824. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i + iFilterMY - k) + j - iFilterMX + l;
  826. // 保存象素值
  827. aValue[k * iFilterW + l] = *lpSrc;
  828. }
  829. }
  831. // 获取中值
  832. * lpDst = myGetMedianNum(aValue, iFilterH * iFilterW);
  833. }
  834. }
  836. // 复制变换后的图像
  837. memcpy(lpDIBBits, lpNewDIBBits, lLineBytes * lHeight);
  839. // 释放内存
  840. LocalUnlock(hNewDIBBits);
  841. LocalFree(hNewDIBBits);
  842. LocalUnlock(hArray);
  843. LocalFree(hArray);
  845. // 返回
  846. return TRUE;
  847. }
  849. /*************************************************************************
  850. *
  851. * 函数名称：
  852. *   GetMedianNum()
  853. *
  854. * 参数:
  855. *   unsigned char * bpArray - 指向要获取中值的数组指针
  856. *   int   iFilterLen - 数组长度
  857. *
  858. * 返回值:
  859. *   unsigned char      - 返回指定数组的中值。
  860. *
  861. * 说明:
  862. *   该函数用冒泡法对一维数组进行排序，并返回数组元素的中值。
  863. *
  864. ************************************************************************/
  866. unsigned char WINAPI myGetMedianNum(unsigned char * bArray, int iFilterLen)
  867. {
  868. // 循环变量
  869. int i;
  870. int j;
  872. // 中间变量
  873. unsigned char bTemp;
  875. // 用冒泡法对数组进行排序
  876. for (j = 0; j < iFilterLen - 1; j ++)
  877. {
  878. for (i = 0; i < iFilterLen - j - 1; i ++)
  879. {
  880. if (bArray[i] > bArray[i + 1])
  881. {
  882. // 互换
  883. bTemp = bArray[i];
  884. bArray[i] = bArray[i + 1];
  885. bArray[i + 1] = bTemp;
  886. }
  887. }
  888. }
  890. // 计算中值
  891. if ((iFilterLen & 1) > 0)
  892. {
  893. // 数组有奇数个元素，返回中间一个元素
  894. bTemp = bArray[(iFilterLen + 1) / 2];
  895. }
  896. else
  897. {
  898. // 数组有偶数个元素，返回中间两个元素平均值
  899. bTemp = (bArray[iFilterLen / 2] + bArray[iFilterLen / 2 + 1]) / 2;
  900. }
  902. // 返回中值
  903. return bTemp;
  904. }
  905. /***************************************************************************
  906. ***************************************************************************/
  907. BOOL WINAPI myFindRightAngle(CDC* pDC,LPSTR lpDIB,int* iLeft,int* iTop,int* iRight,int* iBottom)
  908. {
  909. LPSTR lpDIBBits;                   //指向DIB的象素的指针
  911.     LONG lLineBytes;                   // 图像每行的字节数
  912. unsigned char * lpSrc;             //指向原图像象素点的指针
  914. unsigned char pixel = 0; //像素值
  916. long lWidth;                       //图像宽度和高度
  917. long lHeight;
  919. int i = 0,j = 0;
  920. int lineRequired = 12;//确定一条直线至少要18个象素
  921. int lineLimited  = 20;//为确定一条直线应该扫描25个象素
  922. int linePixelCount = 0;//已扫描到的灰度值为255的象素点
  923. int pixelCount = 0;//扫描象素时的循环变量
  925. CPen newRedPen(PS_SOLID,2,RGB(255,0,0));
  926. pDC->SelectObject(newRedPen);
  927. HGDIOBJ brush=GetStockObject(NULL_BRUSH);
  928. pDC->SelectObject((HBRUSH)GetStockObject(NULL_BRUSH));
  930.     //INT pzBottom,pzTop,pzLeft,pzRight;
  931. struct topLeftCorner {
  932. int pzTop;
  933. int pzLeft;
  934. }topLeft[1000];
  936. struct bottomRightCorner {
  937. int pzBottom;
  938. int pzRight;
  939. }bottomRight[1000];
  941. int  tlCount = 0;//左上角数组的索引
  942. int  brCount = 0;//右下角数组的索引
  943. bool findTL=false;                  //是否找到左上角
  944. bool findBR=false;                  //是否找到右下角
  945. // 找到DIB图像象素起始位置
  946. lpDIBBits = ::FindDIBBits(lpDIB);
  947. lWidth = ::DIBWidth(lpDIB);   //DIB 宽度
  948. lHeight = ::DIBHeight(lpDIB); //DIB 高度
  949. // 计算图像每行的字节数
  950. lLineBytes = WIDTHBYTES(lWidth * 8);
  952. for(i = 0;i < 100;i++)
  953. {
  954. topLeft[i].pzTop = 0;
  955. topLeft[i].pzLeft = 0;
  956. }
  958. for(i = 0;i < 100;i++)
  959. {
  960. bottomRight[i].pzBottom = 0;
  961. bottomRight[i].pzRight = 0;
  962. }
  964.     //计算左上角的位置，可能有多个，保存在topLeft数组中
  965. for(i = 30;i < lHeight - 30;i++)//考虑到车牌的大小，在边缘一定范围内可以不考虑
  966. {
  967. linePixelCount = 0;
  968. for(j = 30;j < lWidth - 30 ;j++)
  969. {
  970. linePixelCount = 0;
  972. for(pixelCount = j;pixelCount < (j + lineLimited);pixelCount++)//计算直线
  973. {
  974. lpSrc=(unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + pixelCount;
  975.     pixel=(unsigned char)(*lpSrc);
  976.     if(pixel == 255)
  977. {
  978.     linePixelCount++;
  979. //pDC->MoveTo(j,i);
  980.     //pDC->LineTo(j,i);
  981. }
  982. }
  983. /*if(linePixelCount >= lineRequired)
  984. {
  985. pDC->MoveTo(j,i);
  986. pDC->LineTo(j,i);
  987. }*/
  988. if(linePixelCount >= lineRequired)
  989. {
  990. linePixelCount = 0;
  991. for(pixelCount = i;pixelCount < (i + lineLimited);pixelCount++)
  992. {
  993. lpSrc=(unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - pixelCount) + j;
  994.         pixel=(unsigned char)(*lpSrc);
  995.         if(pixel == 255)
  996. {
  997.         linePixelCount++;
  998. //pDC->MoveTo(j,i);
  999.         //pDC->LineTo(j,i);
  1000. }
  1001. }
  1002. }
  1003. if(linePixelCount >= lineRequired)
  1004. {
  1005. findTL = true;
  1006. }
  1007. if(findTL)
  1008. {
  1009. findTL = false;
  1010. linePixelCount = 0;
  1011. topLeft[tlCount].pzTop = i;
  1012. topLeft[tlCount].pzLeft = j;
  1013. pDC->MoveTo(j,i);
  1014. pDC->LineTo(j,i);
  1015. tlCount++;
  1016. }
  1017. }
  1018. }
  1020.     CPen newGreenPen(PS_SOLID,2,RGB(0,255,0));
  1021. pDC->SelectObject(newGreenPen);
  1022. //计算右下角的位置，可能有多个，保存在bottomRight数组中
  1023. linePixelCount = 0;//重新初始化计数器
  1024. for(i = 10;i < lHeight - 10;i++)//考虑到车牌的大小，在边缘一定范围内可以不考虑
  1025. {
  1026. linePixelCount = 0;
  1027. for(j = 20;j < lWidth - 20;j++)
  1028. {
  1029. linePixelCount = 0;
  1030. for(pixelCount = j;pixelCount < (j + lineLimited);pixelCount++)//计算直线
  1031. {
  1032. lpSrc=(unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + pixelCount;
  1033.     pixel=(unsigned char)(*lpSrc);
  1034.     if(pixel == 255)
  1035. {
  1036.     linePixelCount++;
  1037. }
  1038. }
  1039. if(linePixelCount >= lineRequired)
  1040. {
  1041. linePixelCount = 0;
  1042. for(pixelCount = i;pixelCount > (i - lineLimited);pixelCount--)
  1043. {
  1044. lpSrc=(unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - pixelCount) + lineRequired + j;
  1045.         pixel=(unsigned char)(*lpSrc);
  1046.         if(pixel == 255)
  1047. {
  1048.         linePixelCount++;
  1049. }
  1050. }
  1051. if(linePixelCount >= lineRequired)
  1052. {
  1053. findBR = true;
  1054. }
  1055. }
  1056. if(findBR)
  1057. {
  1058. findBR = false;
  1059. linePixelCount = 0;
  1060. bottomRight[brCount].pzBottom = i;
  1061. bottomRight[brCount].pzRight = j + lineRequired;
  1062. pDC->MoveTo(j + lineRequired,i);
  1063. pDC->LineTo(j + lineRequired,i);
  1064. brCount++;
  1065. }
  1066. }
  1067. }
  1068.     
  1069.     //计算车牌的位置
  1070. int plateUpHeight = 50;
  1071. int plateDownHeight = 30;
  1072. int plateUpWidth = 100;
  1073. int plateDownWidth = 80;
  1074. bool plateFind = false;
  1075. for(i = 0;i < tlCount;i++)
  1076. {
  1077. for(j = brCount - 1 ;j >= 0;j--)
  1078. {
  1079. if((bottomRight[j].pzBottom - topLeft[i].pzTop > plateDownHeight) &&
  1080. (bottomRight[j].pzBottom - topLeft[i].pzTop < plateUpHeight) && 
  1081. (bottomRight[j].pzRight - topLeft[i].pzLeft > plateDownWidth) && 
  1082. (bottomRight[j].pzRight - topLeft[i].pzLeft < plateUpWidth) &&
  1083. (double(bottomRight[j].pzRight - topLeft[i].pzLeft) / (bottomRight[j].pzBottom - topLeft[i].pzTop)) > 2)
  1084. {
  1085. *iTop = topLeft[i].pzTop;
  1086. *iLeft = topLeft[i].pzLeft;
  1087. *iBottom = bottomRight[j].pzBottom + 10;
  1088. *iRight = bottomRight[j].pzRight + 15;
  1089. plateFind = true;
  1090. break;
  1091. }
  1092. else
  1093. {
  1094. //i++;
  1095. //j--;
  1096. }
  1097. }
  1098. if(plateFind) break;
  1099. }
  1101. /**iTop = topLeft[0].pzTop;
  1102. *iLeft = topLeft[0].pzLeft;
  1103. *iBottom = bottomRight[0].pzBottom;
  1104. *iRight = bottomRight[0].pzRight;*/
  1105. return true;
  1106. }
  1107. /*************************************************************************
  1108. *在图像上画一个矩形
  1109. *
  1110. *
  1111. *
  1112. *************************************************************************/
  1113. BOOL WINAPI DrawRectangle(CDC* pDC,int iLeft,int iTop,int iRight,int iBottom)
  1114. {
  1115. CPen newPen(PS_SOLID,2,RGB(255,0,0));
  1116. pDC->SelectObject(newPen);
  1117. HGDIOBJ brush=GetStockObject(NULL_BRUSH);
  1118. pDC->SelectObject((HBRUSH)GetStockObject(NULL_BRUSH));
  1120. pDC->Rectangle(iLeft,iTop,iRight,iBottom);
  1121. return true;
  1122. }