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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形/文字识别 > 查看源码
mydiblib.h
资源名称：getchar.rar　[点击查看]
上传用户：kennygump
上传日期：2022-07-22
资源大小：347k
文件大小：49k
源码类别：

图形/文字识别

开发平台：

Visual C++

mydiblib.h：源码内容
  1. #include "dibapi.h"
  2. #include <iostream>
  3. #include <deque>
  4. #include <math.h>
  5. using namespace std;
  7. typedef deque<CRect> CRectLink;
  8. typedef deque<HDIB>  HDIBLink;
  10. //声明一些必要的全局变量
  11. int w_sample=8;
  12. int h_sample=16;
  13. bool fileloaded;
  14. bool gyhinfoinput;
  15. bool gyhfinished;
  16. int digicount;
  17. int m_lianXuShu;
  18. CRectLink m_charRectCopy;
  19. CRectLink m_charRect;
  20. HDIBLink  m_dibRect;
  21. HDIBLink  m_dibRectCopy;
  22. HDIB m_hDIB;
  23. CString strPathName;
  24. CString strPathNameSave;
  26. /********************************function declaration*************************************/
  28. //清楚屏幕
  29. void ClearAll(CDC* pDC);
  30. //在屏幕上显示位图
  31. void DisplayDIB(CDC* pDC,HDIB hDIB);
  32. //对分割后的位图进行尺寸标准归一化
  33. void StdDIBbyRect(HDIB hDIB, int tarWidth, int tarHeight);
  34. //整体斜率调整
  35. void SlopeAdjust(HDIB hDIB);
  36. //去除离散噪声点
  37. void RemoveScatterNoise(HDIB hDIB);
  38. //梯度锐化
  39. void GradientSharp(HDIB hDIB);
  40. //画框
  41. void DrawFrame(CDC* pDC,HDIB hDIB, CRectLink charRect,unsigned int linewidth,COLORREF color);
  42. //将灰度图二值化
  43. void ConvertGrayToWhiteBlack(HDIB hDIB);
  44. //将256色位图转为灰度图
  45. void Convert256toGray(HDIB hDIB);
  46. //细化
  47. void Thinning(HDIB hDIB);
  48. //对位图进行分割.返回一个存储着每块分割区域的链表
  49. CRectLink CharSegment(HANDLE hDIB);
  50. //紧缩、重排调整
  51. HDIB AutoAlign(HDIB hDIB);
  52. //判断是否是离散噪声点
  53. bool DeleteScaterJudge(LPSTR lpDIBBits,WORD lLineBytes, LPBYTE lplab, int lWidth, int lHeight, int x, int y, CPoint lab[], int lianXuShu);
  54. //对图像进行模板操作
  55. HDIB Template(HDIB hDIB,double * tem ,int tem_w,int tem_h,double xishu);
  56. //对图像进行中值滤波
  57. HDIB MidFilter(HDIB hDIB,int tem_w,int tem_h);
  58. //对图像进行直方图均衡
  59. void Equalize(HDIB hDIB);
  60. /***********************************implementation*************************************/
  62. /*********************************** ************************************
  63. 函数名称：DisplayDIB
  64. 参数：
  65. CDC* pDC -指向当前设备上下文（Divice Context）的指针
  66. HDIB hDIB -要显示的位图的句柄
  67. **********************************************************************/
  69. void DisplayDIB(CDC* pDC,HDIB hDIB)
  70. {
  71. BYTE* lpDIB=(BYTE*)::GlobalLock((HGLOBAL)hDIB);
  72. // 获取DIB宽度和高度
  73. int cxDIB =  ::DIBWidth((char*) lpDIB);
  74. int cyDIB =  ::DIBHeight((char*)lpDIB);
  75. CRect rcDIB,rcDest;
  76. rcDIB.top = rcDIB.left = 0;
  77. rcDIB.right = cxDIB;
  78. rcDIB.bottom = cyDIB;
  79. //设置目标客户区输出大小尺寸
  80. rcDest = rcDIB;
  81. //CDC* pDC=GetDC();
  82. ClearAll(pDC);
  83. //在客户区显示图像
  84. //for(int ii=0;ii<10;ii++)
  85. ::PaintDIB(pDC->m_hDC,rcDest,hDIB,rcDIB,NULL);
  86. ::GlobalUnlock((HGLOBAL)hDIB);
  87. }
  89. void ClearAll(CDC *pDC)
  90. {
  91. CRect rect;
  92. //GetClientRect(&rect);
  93. rect.left =0;rect.top =0;rect.right =2000;rect.bottom =330;
  94. CPen pen;
  95. pen.CreatePen (PS_SOLID,1,RGB(255,255,255));
  96. pDC->SelectObject (&pen);
  97. pDC->Rectangle (&rect);
  98. ::DeleteObject (pen);
  99. }
  100. /*******************************************
  101. *
  102. *  函数名称：
  103. *  AutoAlign()
  104. *
  105. *  参数：
  106. *    HDIB   hDIB        －原图像的句柄
  107. *
  108. *  返回值   
  109. *    HDIB               －紧缩排列后的新图像的句柄
  110. *
  111. *  功能：
  112. *     将经过了标准化处理的字符进行规整的排列，以方便下一步的处理
  113. *
  114. *  说明：
  115. *     紧缩排列的操作必须在标准化操作之后进行
  116. *
  117. ********************************************************/
  120. HDIB AutoAlign(HDIB hDIB)
  121. {   
  123. //指向图像的指针
  124.   BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
  126. //指向象素起始位置的指针
  127. BYTE* lpDIBBits=(BYTE*)::FindDIBBits ((char*)lpDIB);
  129. //指向象素的指针
  130. BYTE* lpSrc;
  132. //获取图像的宽度
  133. LONG lWidth=::DIBWidth ((char*)lpDIB);
  135. //获取图像的高度
  136. LONG lHeight=::DIBHeight ((char*)lpDIB);
  138. //获取标准化的宽度
  139. int w=m_charRect.front ().Width() ;
  141. //获取标准化的高度
  142. int h=m_charRect.front ().Height() ;
  144. //建立一个新的图像正好能够将标准化的字符并排放置
  145. HDIB hNewDIB=::NewDIB (digicount*w,h,8);
  147. //指向新的图像的指针
  148. BYTE* lpNewDIB=(BYTE*) ::GlobalLock((HGLOBAL)hNewDIB);
  150. //指向象素起始位置的指针
  151. BYTE* lpNewDIBBits=(BYTE*)::FindDIBBits((char*)lpNewDIB);
  153. //指向象素的指针
  154. BYTE* lpDst=lpNewDIBBits;
  156. //计算原图像每行的字节数
  157. LONG lLineBytes=(lWidth+3)/4*4;
  159. //计算新图像每行的字节数
  160. LONG lLineBytesnew =(digicount*w+3)/4*4;
  162. //将新的图像初始化为白色
  163. memset(lpDst,(BYTE)255,lLineBytesnew * h);
  165. //映射操作的坐标变量
  166. int i_src,j_src;
  168. //循环变量
  169. int i,j;
  171. //统计字符个数的变量
  172. int counts=0;
  174. //存放位置信息的结构体
  175. CRect rect,rectnew;
  177. //清空一个新的链表来存放新的字符位置信息
  178. m_charRectCopy.clear ();
  180. //从头至尾逐个扫描原链表的各个结点
  181. while(!m_charRect.empty() )
  182. {   
  183. //从表头上得到一个矩形框
  184. rect=m_charRect.front ();
  186. //将这个矩形框从链表上删除
  187. m_charRect.pop_front ();
  189. //计算新的矩形框的位置信息
  191. //左边界
  192. rectnew.left =counts*w;
  194. //右边界
  195. rectnew.right =(counts+1)*w;
  197. //上边界
  198. rectnew.top =0;
  200. //下边界
  201. rectnew.bottom =h;
  203. //将获得的新的矩形框插入到新的链表中
  204. m_charRectCopy.push_back (rectnew);
  206. //将原矩形框内的象素映射到新的矩形框中
  207. for(i=0;i<h;i++)
  208. {  
  209. for(j=counts*w;j<(counts+1)*w;j++)
  210. {   
  212. //计算映射坐标
  213.            i_src=rect.top +i;
  214. j_src=rect.left +j-counts*w;
  216. //进行象素的映射
  217. lpSrc=(BYTE *)lpDIBBits + lLineBytes *  i_src + j_src;
  218. lpDst=(BYTE *)lpNewDIBBits + lLineBytesnew * i + j;
  219. *lpDst=*lpSrc;
  220. }
  221. }
  223. //字符个数加1
  224. counts++;
  226. }
  228. //将获得的新的链表复制到原链表中，以方便下一次的调用
  229. m_charRect=m_charRectCopy;
  231. //解除锁定
  232. ::GlobalUnlock (hDIB);
  235. ::GlobalUnlock (hNewDIB);
  236. return hNewDIB;
  237. }
  240. /**************************************************
  241. * 函数名称：
  242. *     ThinnerHilditch
  243. *
  244. * 参数：
  245. *   void*     image             －二值化图像矩阵前景色为1背景色为0
  246. *   unsigned  longlx             －图像的宽度
  247. *   unsigned  longly             －图像的高度
  248. *
  249. * 返回值
  250. *       无
  251. *
  252. *函数功能：
  253. *       对输入的图像进行细化，输出细化后的图像
  254. ***********************************************************/
  256. void ThinnerHilditch(void *image, unsigned long lx, unsigned long ly)
  257. {
  258.     char *f, *g;
  259.     char n[10];
  260.     unsigned int counter;
  261.     short k, shori, xx, nrn;
  262.     unsigned long i, j;
  263.     long kk, kk11, kk12, kk13, kk21, kk22, kk23, kk31, kk32, kk33, size;
  264.     size = (long)lx * (long)ly;
  265.     g = (char *)malloc(size);
  267.     if(g == NULL)
  268.     {
  269.        // printf("error in allocating memory!n");
  270.         return;
  271.     }
  273.     f = (char *)image;
  274.     for(i=0; i<lx; i++)
  275.     {
  276.         for(j=0; j<ly; j++)
  277.         {
  278.             kk=i*ly+j;
  279.             if(f[kk]!=0)
  280.             {
  281.                 f[kk]=1;
  282.                 g[kk]=f[kk];
  283.             }
  284.         }
  285.     }
  287.     counter = 1;
  289.     do
  290.     {
  291.         
  292.         counter++;
  293.         shori = 0;
  295.         for(i=0; i<lx; i++)
  296.         {
  297.             for(j=0; j<ly; j++)
  298.             {
  299.                 kk = i*ly+j;
  300.                 if(f[kk]<0)
  301.                     f[kk] = 0;
  302.                 g[kk]= f[kk];
  303.             }
  304.         }
  306.         for(i=1; i<lx-1; i++)
  307.         {
  308.             for(j=1; j<ly-1; j++)
  309.             {
  310.                 kk=i*ly+j;
  312.                 if(f[kk]!=1)
  313.                     continue;
  315.                 kk11 = (i-1)*ly+j-1;
  316.                 kk12 = kk11 + 1;
  317.                 kk13 = kk12 + 1;
  318.                 kk21 = i*ly+j-1;
  319.                 kk22 = kk21 + 1;
  320.                 kk23 = kk22 + 1;
  321.                 kk31 = (i+1)*ly+j-1;
  322.                 kk32 = kk31 + 1;
  323.                 kk33 = kk32 + 1;
  325.                 if((g[kk12]&&g[kk21]&&g[kk23]&&g[kk32])!=0)
  326.                     continue;
  328.                 nrn = g[kk11] + g[kk12] + g[kk13] + g[kk21] + g[kk23] + 
  329.                     g[kk31] + g[kk32] + g[kk33];
  331.                 if(nrn <= 1)
  332.                 {
  333.                     f[kk22] = 2;
  334.                     continue;
  335.                 }
  337.                 n[4] = f[kk11];
  338.                 n[3] = f[kk12];
  339.                 n[2] = f[kk13];
  340.                 n[5] = f[kk21];
  341.                 n[1] = f[kk23];
  342.                 n[6] = f[kk31];
  343.                 n[7] = f[kk32];
  344.                 n[8] = f[kk33];
  345.                 n[9] = n[1];
  346.                 xx = 0;
  348.                 for(k=1; k<8; k=k+2)
  349.                 {
  350.                     if((!n[k])&&(n[k+1]||n[k+2]))
  351.                         xx++;
  352.                 }
  354.                 if(xx!=1)
  355.                 {
  356.                     f[kk22] = 2;
  357.                     continue;
  358.                 }
  360.                 if(f[kk12] == -1)
  361.                 {
  362.                     f[kk12] = 0;
  363.                     n[3] = 0;
  364.                     xx = 0;
  366.                     for(k=1; k<8; k=k+2)
  367.                     {
  368.                         if((!n[k])&&(n[k+1]||n[k+2]))
  369.                             xx++;
  370.                     }
  372.                     if(xx != 1)
  373.                     {
  374.                         f[kk12] = -1;
  375.                         continue;
  376.                     }
  378.                     f[kk12] = -1;
  379.                     n[3] = -1;
  380.                 }
  382.                 if(f[kk21]!=-1)
  383.                 {
  384.                     f[kk22] = -1;
  385.                     shori = 1;
  386.                     continue;
  387.                 }
  389.                 f[kk21] = 0;
  390.                 n[5] = 0;
  391.                 xx = 0;
  393.                 for(k=1; k<8; k=k+2)
  394.                 {
  395.                     if((!n[k])&&(n[k+1]||n[k+2]))
  396.                     {
  397.                         xx++;
  398.                     }
  399.                 }
  401.                 if(xx == 1)
  402.                 {
  403.                     f[kk21] = -1;
  404.                     f[kk22] = -1;
  405.                     shori =1;
  406.                 }
  407.                 else
  408.                     f[kk21] = -1;
  409.             }
  410.         }
  411.     }while(shori);
  413.     free(g);
  414. }
  416. /**************************************************
  417. * 函数名称：
  418. *     ThinnerRosenfeld
  419. *
  420. * 参数：
  421. *   void*     image             －二值化图像矩阵前景色为1背景色为0
  422. *   unsigned  longlx             －图像的宽度
  423. *   unsigned  longly             －图像的高度
  424. *
  425. * 返回值
  426. *       无
  427. *
  428. *函数功能：
  429. *       对输入的图像进行细化，输出细化后的图像
  430. ***********************************************************/
  431. void ThinnerRosenfeld(void *image, unsigned long lx, unsigned long ly)
  432. {
  433.     char *f, *g;
  434.     char n[10];
  435.     char a[5] = {0, -1, 1, 0, 0};
  436.     char b[5] = {0, 0, 0, 1, -1};
  437.     char nrnd, cond, n48, n26, n24, n46, n68, n82, n123, n345, n567, n781;
  438.     short k, shori;
  439.     unsigned long i, j;
  440.     long ii, jj, kk, kk1, kk2, kk3, size;
  441.     size = (long)lx * (long)ly;
  443.     g = (char *)malloc(size);
  444.     if(g==NULL)
  445.     {
  446.         printf("error in alocating mmeory!n");
  447.         return;
  448.     }
  450.     f = (char *)image;
  451.     for(kk=0l; kk<size; kk++)
  452.     {
  453.         g[kk] = f[kk];
  454.     }
  456.     do
  457.     {
  458.         shori = 0;
  459.         for(k=1; k<=4; k++)
  460.         {
  461.             for(i=1; i<lx-1; i++)
  462.             {
  463.                 ii = i + a[k];
  465.                 for(j=1; j<ly-1; j++)
  466.                 {
  467.                     kk = i*ly + j;
  469.                     if(!f[kk])
  470.                         continue;
  472.                     jj = j + b[k];
  473.                     kk1 = ii*ly + jj;
  475.                     if(f[kk1])
  476.                         continue;
  478.                     kk1 = kk - ly -1;
  479.                     kk2 = kk1 + 1;
  480.                     kk3 = kk2 + 1;
  481.                     n[3] = f[kk1];
  482.                     n[2] = f[kk2];
  483.                     n[1] = f[kk3];
  484.                     kk1 = kk - 1;
  485.                     kk3 = kk + 1;
  486.                     n[4] = f[kk1];
  487.                     n[8] = f[kk3];
  488.                     kk1 = kk + ly - 1;
  489.                     kk2 = kk1 + 1;
  490.                     kk3 = kk2 + 1;
  491.                     n[5] = f[kk1];
  492.                     n[6] = f[kk2];
  493.                     n[7] = f[kk3];
  495.                     nrnd = n[1] + n[2] + n[3] + n[4]
  496.                         +n[5] + n[6] + n[7] + n[8];
  497.                     if(nrnd<=1)
  498.                         continue;
  500.                     cond = 0;
  501.                     n48 = n[4] + n[8];
  502.                     n26 = n[2] + n[6];
  503.                     n24 = n[2] + n[4];
  504.                     n46 = n[4] + n[6];
  505.                     n68 = n[6] + n[8];
  506.                     n82 = n[8] + n[2];
  507.                     n123 = n[1] + n[2] + n[3];
  508.                     n345 = n[3] + n[4] + n[5];
  509.                     n567 = n[5] + n[6] + n[7];
  510.                     n781 = n[7] + n[8] + n[1];
  512.                     if(n[2]==1 && n48==0 && n567>0)
  513.                     {
  514.                         if(!cond)
  515.                             continue;
  516.                         g[kk] = 0;
  517.                         shori = 1;
  518.                         continue;
  519.                     }
  521.                     if(n[6]==1 && n48==0 && n123>0)
  522.                     {
  523.                         if(!cond)
  524.                             continue;
  525.                         g[kk] = 0;
  526.                         shori = 1;
  527.                         continue;
  528.                     }
  530.                     if(n[8]==1 && n26==0 && n345>0)
  531.                     {
  532.                         if(!cond)
  533.                             continue;
  534.                         g[kk] = 0;
  535.                         shori = 1;
  536.                         continue;
  537.                     }
  539.                     if(n[4]==1 && n26==0 && n781>0)
  540.                     {
  541.                         if(!cond)
  542.                             continue;
  543.                         g[kk] = 0;
  544.                         shori = 1;
  545.                         continue;
  546.                     }
  548.                     if(n[5]==1 && n46==0)
  549.                     {
  550.                         if(!cond)
  551.                             continue;
  552.                         g[kk] = 0;
  553.                         shori = 1;
  554.                         continue;
  555.                     }
  557.                     if(n[7]==1 && n68==0)
  558.                     {
  559.                         if(!cond)
  560.                             continue;
  561.                         g[kk] = 0;
  562.                         shori = 1;
  563.                         continue;
  564.                     }
  566.                     if(n[1]==1 && n82==0)
  567.                     {
  568.                         if(!cond)
  569.                             continue;
  570.                         g[kk] = 0;
  571.                         shori = 1;
  572.                         continue;
  573.                     }
  575.                     if(n[3]==1 && n24==0)
  576.                     {
  577.                         if(!cond)
  578.                             continue;
  579.                         g[kk] = 0;
  580.                         shori = 1;
  581.                         continue;
  582.                     }
  584.                     cond = 1;
  585.                     if(!cond)
  586.                         continue;
  587.                     g[kk] = 0;
  588.                     shori = 1;
  589.                 }
  590.             }
  592.             for(i=0; i<lx; i++)
  593.             {
  594.                 for(j=0; j<ly; j++)
  595.                 {
  596.                     kk = i*ly + j;
  597.                     f[kk] = g[kk];
  598.                 }
  599.             }
  600.         }
  601.     }while(shori);
  603.     free(g);
  604. }              
  607. /*************************************************
  608. *
  609. * 函数名称：
  610. *       CharSegment()
  611. *
  612. *  参数：
  613. *      HDIB  hDIB      －原图像的句柄
  614. *
  615. *  返回值：
  616. *     CRectLink        －存放被分割的各个字符位置信息的链表
  617. *
  618. * 功能：
  619. *    将图像中待识别的字符逐个分离出来并返回存放各个字符的位置信息的链表
  620. *
  621. *  说明：
  622. *    此函数只能对2值化后的图像进行处理
  623. *
  624. *********************************************************/
  627. CRectLink CharSegment(HANDLE hDIB)
  628. {
  630. //清空用来保存每个字符区域的链表
  631. CRectLink charRect1,charRect2;
  632. charRect1.clear();
  633. charRect2.clear();
  635. // 指向DIB的指针
  636. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  638. // 指向DIB象素指针
  639. LPSTR    lpDIBBits;
  641. // 找到DIB图像象素起始位置
  642. lpDIBBits = ::FindDIBBits(lpDIB);
  644. //指向象素的的指针
  645. BYTE* lpSrc;
  647. //图像的长度和宽度
  648. int height,width;
  650. //获取图像的宽度
  651. width=(int)::DIBWidth(lpDIB);
  653. //获取图像的长度
  654. height=(int)::DIBHeight(lpDIB);
  656. //计算图像每行的字节数
  657. LONG lLineBytes = WIDTHBYTES(width * 8);
  659. //定义上下边界两个变量
  660. int top,bottom;
  662.     //象素的灰度值
  663.     int gray; 
  665. //设置循环变量
  666. int i,j;
  668. //用来统计图像中字符个数的计数器
  669. digicount=0;
  672. //从上往下扫描，找到上边界
  674. //行
  675. for (i=0;i<height;i++)
  676. {
  677.          //列
  678.    for (j=0;j<width;j++)
  679. {
  680.             // 指向图像第i行，第j个象素的指针
  681. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  683. //获得该点的灰度值
  684. gray = *(lpSrc);
  686. //看是否为黑点
  687. if (gray == 0)
  688. {   
  689.                //若为黑点，把此点作为字符大致的最高点
  690. top = i;
  692. //对i强行赋值以中断循环
  693. i=height;
  695. //跳出循环
  696. break;
  697. }
  699.         //如果该点不是黑点，继续循环
  700. }
  701. }
  704.     //从下往上扫描，找下边界
  706. //行
  707. for (i = height-1;i>=0;i--)
  708.     {
  710. //列
  711. for (j=0;j<width;j++)
  712. {
  713. // 指向图像第i行，第j个象素的指针
  714. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  716. //获取该点的灰度值
  717. gray = *(lpSrc);
  719. //判断是否为黑点
  720. if (gray == 0)
  721. {
  722. //若为黑点，把此点作为字符大致的最低点
  723. bottom = i;
  725. //对i强行赋值以中断循环
  726. i=-1;
  728. //跳出循环
  729. break;
  730. }
  732.           //如果该点不是黑点，继续循环
  733. }
  735. }
  737. //lab 用作是否进入一个字符分割的标志
  738. bool lab = false;
  740. //表明扫描一列中是否发现黑色点
  741. bool black = false;
  743.     //存放位置信息的结构体
  744. CRect rect;
  746. //计数器置零
  747. digicount=0;
  748.    
  749. //行
  750. for (i=0;i<width;i++)
  751. {
  752. //开始扫描一列
  753. black=false;
  755. for (j=0;j<height;j++)
  756. {
  757. // 指向图像第i行，第j个象素的指针
  758. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * j + i;
  760. //获取该点的灰度值
  761. gray = *(lpSrc);
  763.                 //判断是否为黑点
  764. if (gray == 0)
  765. {
  766. //如果发现黑点，设置标志位
  767. black=true;
  769. //如果还没有进入一个字符的分割
  770. if(lab==false)
  771. {
  772. //设置左侧边界
  773. rect.left = i;
  775. //字符分割开始
  776. lab = true;
  777. }
  779. //如果字符分割已经开始了
  780. else
  782.                       //跳出循环
  783. break;
  784. }
  785. }
  787. //如果已经扫到了最右边那列，说明整副图像扫描完毕。退出
  788.            if(i==(width-1))
  789.    
  790.  //退出整个循环    
  791.    break;
  793. //如果到此black仍为false，说明扫描了一列，都没有发现黑点。表明当前字符分割结束
  794. if(lab==true&&black==false)
  795. {   
  796.            //将位置信息存入结构体中
  798.            //设置右边界
  799. rect.right =i;
  801. //设置上边界
  802. rect.top =top;
  804. //设置下边界
  805. rect.bottom =bottom;
  807. //将框外括一个象素，以免压到字符
  808. rect.InflateRect (1,1);
  810.             //将这个结构体插入存放位置信息的链表1的后面
  811. charRect1.push_back (rect);
  813. //设置标志位，开始下一次的字符分割
  814. lab=false;
  816. //字符个数统计计数器加1
  817. digicount++;
  819. }
  821. //进入下一列的扫描
  823. }
  825.    //再将矩形轮廓矩形的top和bottom精确化
  827. //将链表1赋值给链表2
  828. charRect2=charRect1;
  830.     //将链表2的内容清空
  831.     charRect2.clear ();
  833. //建立一个新的存放位置信息的结构体
  834. CRect rectnew;
  836. //对于链表1从头至尾逐个进行扫描
  837. while(!charRect1.empty())
  838. {    
  839. //从链表1头上得到一个矩形
  840. rect= charRect1.front();
  842. //从链表1头上面删掉一个
  843. charRect1.pop_front();
  845. //计算更加精确的矩形区域
  847. //获得精确的左边界
  848. rectnew.left =rect.left-1 ;
  850. //获得精确的右边界
  851. rectnew.right =rect.right+1 ;
  853. //通过获得的精确左右边界对上下边境重新进行精确定位
  855. // 由下而上扫描计算上边界
  857. //行
  858. for(i=rect.top ;i<rect.bottom ;i++)
  859. {   
  860.           //列
  861. for(j=rect.left ;j<rect.right ;j++)
  862. {   
  863.                  // 指向图像第i行，第j个象素的指针
  864. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  866. //如果这个象素是黑点
  867. if (*lpSrc == 0)
  868. {
  869. //设置上边界
  870. rectnew.top = i-1;
  872. //对i进行强制定义以跳出循环
  873. i=rect.bottom  ;
  875. //跳出循环
  876. break;
  877. }
  878. }
  879. }
  881. //由下而上扫描计算下边界
  882.    
  883.         //行
  884. for(i=rect.bottom-1 ;i>=rect.top  ;i--)
  885. {
  886. //列
  887. for(j=rect.left ;j<rect.right ;j++)
  888. {
  889. // 指向图像第i行，第j个象素的指针
  890. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  892. //该点如果为黑点
  893. if (*lpSrc == 0)
  894. {
  895. //设置下边界
  896. rectnew.bottom = i+1;
  898.                     //对i进行强制定义以跳出循环
  899. i=-1;
  900.                     //跳出循环
  901. break;
  902. }
  903. }
  904. }
  906. //将得到的新的准确的位置信息从后面插到链表2的尾上
  907. charRect2.push_back (rectnew);
  908. }
  910. //将链表2 传递给链表1
  911. charRect1=charRect2;
  913. //解除锁定
  914. ::GlobalUnlock(hDIB);
  916. //将链表1返回
  917. return charRect1;
  918. }
  920. /****************************************************************
  921. * 函数名称：
  922. *      Convert256toGray()
  923. *
  924. * 参数：
  925. *     HDIB hDIB     －图像的句柄
  926. *
  927. *  返回值：
  928. *        无
  929. *
  930. *  功能：
  931. *     将256色位图转化为灰度图
  932. *
  933. ***************************************************************/
  935. void Convert256toGray(HDIB hDIB)
  936. {
  937. LPSTR lpDIB;
  939. // 由DIB句柄得到DIB指针并锁定DIB
  940. lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  942. // 指向DIB象素数据区的指针
  943. LPSTR   lpDIBBits;
  945. // 指向DIB象素的指针
  946. BYTE * lpSrc;
  948. // 图像宽度
  949. LONG lWidth;
  950. // 图像高度
  951. LONG   lHeight;
  953. // 图像每行的字节数
  954. LONG lLineBytes;
  956. // 指向BITMAPINFO结构的指针（Win3.0）
  957. LPBITMAPINFO lpbmi;
  959. // 指向BITMAPCOREINFO结构的指针
  960. LPBITMAPCOREINFO lpbmc;
  962. // 获取指向BITMAPINFO结构的指针（Win3.0）
  963. lpbmi = (LPBITMAPINFO)lpDIB;
  965. // 获取指向BITMAPCOREINFO结构的指针
  966. lpbmc = (LPBITMAPCOREINFO)lpDIB;
  968. // 灰度映射表
  969. BYTE bMap[256];
  971. // 计算灰度映射表（保存各个颜色的灰度值），并更新DIB调色板
  972. int i,j;
  973. for (i = 0; i < 256; i ++)
  974. {
  975. // 计算该颜色对应的灰度值
  976. bMap[i] = (BYTE)(0.299 * lpbmi->bmiColors[i].rgbRed +
  978.      0.587 * lpbmi->bmiColors[i].rgbGreen +
  980.          0.114 * lpbmi->bmiColors[i].rgbBlue + 0.5);
  981. // 更新DIB调色板红色分量
  982. lpbmi->bmiColors[i].rgbRed = i;
  984. // 更新DIB调色板绿色分量
  985. lpbmi->bmiColors[i].rgbGreen = i;
  987. // 更新DIB调色板蓝色分量
  988. lpbmi->bmiColors[i].rgbBlue = i;
  990. // 更新DIB调色板保留位
  991. lpbmi->bmiColors[i].rgbReserved = 0;
  993. }
  994. // 找到DIB图像象素起始位置
  995. lpDIBBits = ::FindDIBBits(lpDIB);
  997. // 获取图像宽度
  998. lWidth = ::DIBWidth(lpDIB);
  1000. // 获取图像高度
  1001. lHeight = ::DIBHeight(lpDIB);
  1003. // 计算图像每行的字节数
  1004. lLineBytes = WIDTHBYTES(lWidth * 8);
  1006. // 更换每个象素的颜色索引（即按照灰度映射表换成灰度值）
  1008. //逐行扫描
  1009. for(i = 0; i < lHeight; i++)
  1010. {
  1012.   //逐列扫描
  1013. for(j = 0; j < lWidth; j++)
  1014. {
  1015. // 指向DIB第i行，第j个象素的指针
  1016. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  1018. // 变换
  1019. *lpSrc = bMap[*lpSrc];
  1020. }
  1021. }
  1023. //解除锁定
  1024. ::GlobalUnlock ((HGLOBAL)hDIB);
  1025. }
  1027. /******************************************************************
  1028. *
  1029. * 函数名称ConvertGrayToWhiteBlack()
  1030. *
  1031. * 参数 ：HDIB hDIB     －原图的句柄
  1032. *
  1033. * 返回值：无
  1034. *
  1035. * 功能: ConvertGrayToWhiteBlack函数采用硬阈值的方法，实现将图像二值化的功能。
  1036. * 
  1037. * 说明：
  1038. 要求待处理的图片为256色
  1039. ************************************************************************/
  1041. void ConvertGrayToWhiteBlack(HDIB hDIB)
  1042. {
  1043. // 指向DIB的指针
  1044. LPSTR lpDIB;
  1046. // 由DIB句柄得到DIB指针并锁定DIB
  1047. lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  1049. // 指向DIB象素数据区的指针
  1050. LPSTR   lpDIBBits;
  1052. // 指向DIB象素的指针
  1053. BYTE * lpSrc;
  1055. // 图像宽度
  1056. LONG lWidth;
  1058. // 图像高度
  1059. LONG lHeight;
  1060. // 图像每行的字节数
  1061. LONG lLineBytes;
  1063. // 找到DIB图像象素起始位置
  1064. lpDIBBits = ::FindDIBBits(lpDIB);
  1066. // 获取图像宽度
  1067. lWidth = ::DIBWidth(lpDIB);
  1069. // 获取图像高度
  1070. lHeight = ::DIBHeight(lpDIB);
  1072. // 计算图像每行的字节数
  1073. lLineBytes = WIDTHBYTES(lWidth * 8);
  1075. // 更换每个象素的颜色索引（即按照灰度映射表换成灰度值）
  1076. int i,j;
  1078.     //逐行扫描
  1079. for(i = 0; i < lHeight; i++)
  1080.  {
  1082.    //逐列扫描
  1083. for(j = 0; j < lWidth; j++)
  1084. {
  1086. // 指向DIB第i行，第j个象素的指针
  1087. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  1089. // 二值化处理
  1091.    //大于220，设置为255，即白点
  1092. if(*lpSrc>220) *lpSrc=255;
  1094.   //否则设置为0，即黑点
  1095. else *lpSrc=0;
  1097. }
  1099. }
  1101.  //解除锁定
  1102. ::GlobalUnlock((HGLOBAL)hDIB);
  1103. }
  1105. /*****************************************************************
  1106. *
  1107. *  函数名称 
  1108. *       DeleteScaterJudge()
  1109. *
  1110. *  参数：
  1111. *     LPSTR   lpDIBBits      －指向象素起始位置的指针
  1112. *   WORD    lLineBytes     －图像每行的字节数
  1113. *     LPBYTE  lplab          －标志位数组
  1114. *     int     lWidth         －图像的宽度
  1115. *   int     lHeight        －图像的高度
  1116. *     int     x              －当前点的横坐标
  1117. *   int     y              －当前点的纵坐标 
  1118. *     CPoint  lab[]          －存放议考察过的连续点坐标
  1119. *     int     lianXuShu      －离散点的判定长度
  1120. *
  1121. *  返回值：
  1122. *     Bool                   －是离散点返回false 不是离散点返回true
  1123. *  
  1124. *  功能：
  1125. *     利用递归算法统计连续点的个数，通过阈值来判定是否为离散点
  1126. *
  1127. *  说明：
  1128. *     只能对2值图像进行处理
  1129. ******************************************************************/     
  1132. bool DeleteScaterJudge(LPSTR lpDIBBits, WORD lLineBytes, LPBYTE lplab, int lWidth, int lHeight, int x, int y, CPoint lab[], int lianXuShu)
  1133. {
  1135. //如果连续长度满足要求，说明不是离散点，返回
  1136. if(m_lianXuShu>=lianXuShu)
  1137. return TRUE;
  1139. //长度加一
  1140. m_lianXuShu++;
  1142. //设定访问标志
  1143. lplab[lWidth * y +x] = true;
  1145. //保存访问点坐标
  1146. lab[m_lianXuShu-1].x = x;
  1147. lab[m_lianXuShu-1].y = y;
  1149. //象素的灰度值
  1150. int gray;
  1151.   
  1152. //指向象素的指针
  1153. LPSTR lpSrc;
  1155. //长度判定
  1156.     //如果连续长度满足要求，说明不是离散点，返回
  1157. if(m_lianXuShu>=lianXuShu)
  1158. return TRUE;
  1160. //下面进入递归
  1161. else
  1162. {
  1163. //考察上下左右以及左上、右上、左下、右下八个方向
  1164. //如果是黑色点，则调用函数自身进行递归
  1166. //考察下面点
  1168. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x;
  1170. //传递灰度值
  1171. gray=*lpSrc;
  1173. //如果点在图像内、颜色为黑色并且没有被访问过
  1174. if(y-1 >=0 && gray == 0 && lplab[(y-1)*lWidth+x] == false)
  1176. //进行递归处理
  1177. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x,y-1,lab,lianXuShu);
  1179. //判断长度
  1180. //如果连续长度满足要求，说明不是离散点，返回
  1181. if(m_lianXuShu>=lianXuShu)
  1182. return TRUE;
  1184. //左下点
  1186. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x-1;
  1188.         //传递灰度值
  1189. gray=*lpSrc;
  1191.         //如果点在图像内、颜色为黑色并且没有被访问过
  1192. if(y-1 >=0 &&  x-1 >=0 && gray== 0 && lplab[(y-1)*lWidth+x-1] == false)
  1194.        //进行递归处理
  1195. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y-1,lab,lianXuShu);
  1197.         //判断长度
  1198. //如果连续长度满足要求，说明不是离散点，返回
  1199. if(m_lianXuShu>=lianXuShu)
  1200. return TRUE;
  1202. //左边
  1204. lpSrc=(char*)lpDIBBits + lLineBytes * y + x-1;
  1206. //传递灰度值
  1207. gray=*lpSrc;
  1209.         //如果点在图像内、颜色为黑色并且没有被访问过
  1210. if(x-1 >=0 &&  gray== 0 && lplab[y*lWidth+x-1] == false)
  1212.         //进行递归处理
  1213. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y,lab,lianXuShu);
  1215.         //判断长度
  1216. //如果连续长度满足要求，说明不是离散点，返回
  1217. if(m_lianXuShu>=lianXuShu)
  1218. return TRUE;
  1220. //左上
  1222. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x-1;
  1224. //传递灰度值
  1225. gray=*lpSrc;
  1227.         //如果点在图像内、颜色为黑色并且没有被访问过
  1228. if(y+1 <lHeight && x-1 >= 0 && gray == 0 && lplab[(y+1)*lWidth+x-1] == false)
  1230. //进行递归处理
  1232. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y+1,lab,lianXuShu);
  1234.         //判断长度
  1235. //如果连续长度满足要求，说明不是离散点，返回
  1236. if(m_lianXuShu>=lianXuShu)
  1237. return TRUE;
  1239. //上面
  1241. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x;
  1243.         //传递灰度值
  1244. gray=*lpSrc;
  1246.         //如果点在图像内、颜色为黑色并且没有被访问过
  1247. if(y+1 < lHeight && gray == 0 && lplab[(y+1)*lWidth+x] == false)
  1249.         //进行递归处理
  1251. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x,y+1,lab,lianXuShu);
  1253.         //判断长度
  1254. //如果连续长度满足要求，说明不是离散点，返回
  1255. if(m_lianXuShu>=lianXuShu)
  1256. return TRUE;
  1258. //右上
  1260. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x+1;
  1261.         
  1262. //传递灰度值
  1263. gray=*lpSrc;
  1265.         //如果点在图像内、颜色为黑色并且没有被访问过
  1266. if(y+1 <lHeight && x+1 <lWidth &&  gray == 0 && lplab[(y+1)*lWidth+x+1] == false)
  1268.         //进行递归处理
  1269. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y+1,lab,lianXuShu);
  1271.         //判断长度
  1272. //如果连续长度满足要求，说明不是离散点，返回
  1273. if(m_lianXuShu>=lianXuShu)
  1274. return TRUE;
  1276. //右边
  1278. lpSrc=(char*)lpDIBBits + lLineBytes * y + x+1;
  1280.         //传递灰度值
  1281. gray=*lpSrc;
  1283. //如果点在图像内、颜色为黑色并且没有被访问过
  1284. if(x+1 <lWidth && gray==0 && lplab[y*lWidth+x+1] == false)
  1286.         //进行递归处理
  1287. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y,lab,lianXuShu);
  1289.         //判断长度
  1291. //如果连续长度满足要求，说明不是离散点，返回
  1292. if(m_lianXuShu>=lianXuShu)
  1293. return TRUE;
  1295. //右下
  1297. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x+1;
  1299.         //传递灰度值
  1300. gray=*lpSrc;
  1302.         //如果点在图像内、颜色为黑色并且没有被访问过
  1303. if(y-1 >=0 && x+1 <lWidth && gray == 0 && lplab[(y-1)*lWidth+x+1] == false)
  1305.        //进行递归处理
  1306.    DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y-1,lab,lianXuShu);
  1308.         //判断长度
  1309. //如果连续长度满足要求，说明不是离散点，返回
  1310. if(m_lianXuShu>=lianXuShu)
  1311. return TRUE;
  1312. }
  1315. //如果递归结束，返回false，说明是离散点
  1316. return FALSE;
  1318. }
  1321. /*****************绘制数字字符外面的矩形框*******************/
  1322. void DrawFrame(CDC* pDC,HDIB hDIB, CRectLink charRect,unsigned int linewidth,COLORREF color)
  1323. {
  1324. CPen pen;
  1325. pen.CreatePen (PS_SOLID,linewidth,color);
  1326. pDC->SelectObject (&pen);
  1327. ::SelectObject (*pDC,GetStockObject(NULL_BRUSH));
  1328. CRect rect,rect2;
  1329. BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
  1330. while(!charRect.empty())
  1331. {
  1333. //从表头上得到一个矩形
  1334. rect2=rect= charRect.front();
  1335. //从链表头上面删掉一个
  1336. charRect.pop_front();
  1337. //注意，这里原先的rect是相对于图像原点(左下角)的，
  1338. //而在屏幕上绘图时，要转换以客户区为原点的坐标
  1339. rect.top =::DIBHeight ((char*)lpDIB)-rect2.bottom;
  1340. rect.bottom =::DIBHeight ((char*)lpDIB)-rect2.top ;
  1341. pDC->Rectangle (&rect);
  1342. }
  1343. ::GlobalUnlock ((HGLOBAL)hDIB);
  1344. }
  1345. /***********************************************
  1346. *
  1347. * 函数名称：
  1348. *   GradientSharp() 
  1349. *
  1350. *参数 ：
  1351. *  HDIB hDIB    -待处理图像的句柄
  1352. *
  1353. * 返回值：
  1354. *       无
  1355. * 
  1356. *功能：
  1357. *    现图像的梯度锐化
  1359. *说明：
  1360. *    只能对2值图像进行处理，如果图像本身边缘较细，可能造成信息的损失
  1361. **********************************************************************/
  1362. void GradientSharp(HDIB hDIB)
  1363. {
  1364. // 指向DIB的指针
  1365. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  1367. // 指向DIB象素指针
  1368. LPSTR    lpDIBBits;
  1370. // 找到DIB图像象素起始位置
  1371. lpDIBBits = ::FindDIBBits(lpDIB);
  1373.     //获取图像的宽度
  1374. LONG lWidth=::DIBWidth ((char*)lpDIB);
  1376.     //获取图像的长度
  1377. LONG lHeight=::DIBHeight ((char*)lpDIB);
  1379.     // 阈值
  1380. BYTE bThre = 2;
  1382. // 调用GradSharp()函数进行梯度板锐化
  1384. // 指向源图像的指针
  1385. unsigned char* lpSrc;
  1386. unsigned char* lpSrc1;
  1387. unsigned char* lpSrc2;
  1389. // 循环变量
  1390. LONG i;
  1391. LONG j;
  1393. // 图像每行的字节数
  1394. LONG lLineBytes;
  1396. // 中间变量
  1397. BYTE bTemp;
  1399. // 计算图像每行的字节数
  1400. lLineBytes = WIDTHBYTES(lWidth * 8);
  1402. // 每行
  1403.    for(i = 0; i < lHeight; i++)
  1404. {
  1406.      // 每列
  1407.  for(j = 0; j < lWidth; j++)
  1408. {
  1410.              // 指向DIB第i行，第j个象素的指针
  1411. lpSrc  = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  1413. // 指向DIB第i+1行，第j个象素的指针
  1414. lpSrc1 = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 2 - i) + j;
  1416.      // 指向DIB第i行，第j+1个象素的指针
  1417.      lpSrc2 = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j + 1;
  1420.               //计算梯度值
  1421.      bTemp = abs((*lpSrc)-(*lpSrc1)) + abs((*lpSrc)-(*lpSrc2));
  1423.     // 判断是否小于阈值
  1424.     if (bTemp < 255)
  1425. {  
  1427.      // 判断是否大于阈值，对于小于情况，灰度值不变。
  1428.    if (bTemp >= bThre)
  1429.    {
  1431. // 直接赋值为bTemp
  1432.  *lpSrc = bTemp;
  1434.    }
  1436. }
  1438.            else
  1439. {
  1440. // 直接赋值为255
  1441. *lpSrc = 255;
  1442. }
  1443.  }
  1444.    }
  1446. //最后还要处理一下图像中最下面那行
  1447. for(j = 0; j < lWidth; j++)
  1448. {   
  1450.  //指向最下边一行，第j个象素的指针
  1451.   lpSrc  = (unsigned char*)lpDIBBits + lLineBytes * 0 + j;
  1453.    //将此位置的象素设置为255，即白点
  1454. *lpSrc=255;
  1455. }
  1457.    //解除锁定
  1458. ::GlobalUnlock ((HGLOBAL)hDIB);
  1459. }
  1462. /************************************************************
  1463. *
  1464. *  函数名称：
  1465. *       RemoveScatterNoise()
  1466. *
  1467. *  参数：
  1468. *     HDIB    hDIB     －原图像的句柄
  1469. *
  1470. *  返回值:
  1471. *       无
  1472. *
  1473. *  功能：
  1474. *     通过对连续点长度的统计来去除离散杂点
  1475. *
  1476. *  说明：
  1477. *      只能对2值图像进行处理
  1478. ****************************************************************/
  1479. void RemoveScatterNoise(HDIB hDIB)
  1480. {
  1482. // 指向DIB的指针
  1483. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  1485. // 指向DIB象素指针
  1486. LPSTR    lpDIBBits;
  1488. // 找到DIB图像象素数据区的起始位置
  1489. lpDIBBits = ::FindDIBBits(lpDIB);
  1491. //获得图像的长度
  1492. LONG lWidth=::DIBWidth ((char*)lpDIB);
  1494. //获得图像的高度
  1495. LONG lHeight=::DIBHeight ((char*)lpDIB);
  1497. //设置判定噪声的长度阈值为15
  1498. //即如果与考察点相连接的黑点的数目小于15则认为考察点是噪声点
  1499. int length=15;
  1501. // 循环变量
  1502. m_lianXuShu=0;
  1503. LONG i;
  1504. LONG j;
  1505. LONG    k;
  1507. // 图像每行的字节数
  1508. LONG lLineBytes;
  1510. // 计算图像每行的字节数
  1511. lLineBytes = WIDTHBYTES(lWidth * 8);
  1513.     
  1514. LPSTR lpSrc;
  1516. //开辟一块用来存放标志的内存数组
  1517. LPBYTE lplab = new BYTE[lHeight * lWidth];
  1519. //开辟一块用来保存离散判定结果的内存数组
  1520. bool *lpTemp = new bool[lHeight * lWidth];
  1522.     //初始化标志数组
  1523. for (i=0;i<lHeight*lWidth;i++)
  1524.     {
  1526.     //将所有的标志位设置为非
  1527. lplab[i] = false;
  1529. }
  1531. //用来存放离散点的坐标的数组
  1532. CPoint lab[21];
  1533.    
  1534. //为循环变量赋初始值
  1535. k=0;
  1537. //扫描整个图像
  1539. //逐行扫描
  1540. for(i =0;i<lHeight;i++)
  1541. {  
  1542.        
  1543.    //逐行扫描
  1544. for(j=0;j<lWidth;j++)
  1545. {
  1546. //先把标志位置false
  1547. for(k=0;k<m_lianXuShu;k++)
  1548. lplab[lab[k].y * lWidth + lab[k].x] = false;
  1550. //连续数置0
  1551. m_lianXuShu =0;
  1553.     //进行离散性判断
  1554.     lpTemp[i*lWidth+j] = DeleteScaterJudge(lpDIBBits,(WORD)lLineBytes,lplab,lWidth,lHeight,j,i,lab,length);
  1556. }
  1557. }
  1559. //扫描整个图像，把离散点填充成白色
  1561. //逐行扫描
  1562. for(i = 0;i<lHeight;i++)
  1563. {
  1565.       //逐列扫描
  1566. for(j=0;j<lWidth;j++)
  1567. {       
  1568.     //查看标志位,如果为非则将此点设为白点
  1569. if(lpTemp[i*lWidth+j] == false)
  1570. {
  1571.                    //指向第i行第j个象素的指针
  1572. lpSrc=(char*)lpDIBBits + lLineBytes * i + j;
  1574. //将此象素设为白点
  1575. *lpSrc=BYTE(255);
  1576. }
  1577. }
  1578. }
  1580. //解除锁定
  1581. ::GlobalUnlock ((HGLOBAL)hDIB);
  1583. }
  1585. /*********************************************************
  1587. * 函数名称：
  1588. *         SlopeAdjust()
  1589. *
  1590. * 参数：
  1591. *     HDIB   hDIB       －原图像的句柄
  1592. *
  1593. * 返回值：
  1594. *         无
  1595. *
  1596. * 功能：
  1597. *     通过对图像左右半边平均高度的统计来进行倾斜的调整
  1598. *
  1599. * 说明：
  1600. *      只能对2值图像进行处理
  1601. *
  1602. ****************************************************************/
  1603. void SlopeAdjust(HDIB hDIB)
  1604. {
  1605. // 指向DIB的指针
  1606. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  1608. // 指向DIB象素指针
  1609. LPSTR    lpDIBBits;
  1611. // 找到DIB图像象素起始位置
  1612. lpDIBBits = ::FindDIBBits(lpDIB);
  1614. // 指向源图像的指针
  1615. unsigned char* lpSrc;
  1617. // 循环变量
  1618. LONG i;
  1619. LONG j;
  1621. // 图像每行的字节数
  1622. LONG lLineBytes;
  1624. //图像的长度
  1625. LONG    lWidth;
  1627. //图像的宽度
  1628. LONG lHeight;
  1630. //获取图像的长度
  1631. lWidth=::DIBWidth ((char*)lpDIB);
  1633. //获取图像的宽度
  1634. lHeight=::DIBHeight ((char*)lpDIB);
  1636. // 计算图像每行的字节数
  1637. lLineBytes = WIDTHBYTES(lWidth * 8);
  1638.     
  1639. //图像左半边的平均高度
  1640. double leftaver=0.0;
  1642.    //图像右半边的平均高度
  1643. double rightaver=0.0;
  1645. //图像的倾斜度
  1646. double slope;
  1648. //统计循环变量
  1649. LONG counts=0;
  1651. //扫描左半边的图像，求黑色象素的平均高度
  1653. //行
  1654. for (i=0;i<lHeight;i++)
  1655. {   
  1657.       //列
  1658. for (j=0;j<lWidth/2;j++)
  1659. {
  1660.  
  1661.  //指向第i行第j个象素的指针
  1662.  lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  1663.       
  1664.  //如果为黑点
  1665.  if (*lpSrc == 0)
  1666.  {
  1667.           
  1668.           //对其高度进行统计叠加
  1669.   counts +=lWidth/2 -j;
  1670.   leftaver += i*(lWidth/2 -j);
  1672.  }
  1674. }
  1675. }
  1677.     //计算平均高度
  1678. leftaver /= counts;
  1680. //将统计循环变量重新赋值
  1681. counts =0;
  1683. //扫描右半边的图像，求黑色象素的平均高度
  1685. //行
  1686. for (i =0;i<lHeight;i++)
  1687. {
  1689.        //列
  1690. for (j=lWidth/2;j<lWidth;j++)
  1691. {
  1692. //指向第i行第j个象素的指针
  1693. lpSrc=(unsigned char*)lpDIBBits + lLineBytes *  i + j;
  1695.             //如果为黑点
  1696. if (*lpSrc == 0)
  1697. {
  1699.   //进行统计叠加
  1700. counts +=lWidth -j;
  1701. rightaver += i*(lWidth -j);
  1702. }
  1703. }
  1704. }
  1706. //计算右半边的平均高度
  1707. rightaver /= counts;
  1709. //计算斜率
  1710. slope = (leftaver - rightaver) / (lWidth/2);
  1712. //指向新的图像象素起始位置的指针
  1713. LPSTR lpNewDIBBits;
  1714.    
  1715. //指向新图像的指针
  1716. LPSTR lpDst;
  1717.     
  1718. //新图像的句柄
  1719. HLOCAL nNewDIBBits=LocalAlloc(LHND,lLineBytes*lHeight);
  1720.     
  1721. //锁定内存
  1722. lpNewDIBBits=(char*)LocalLock(nNewDIBBits);
  1723.     
  1724. //指向新图像象素的指针
  1725. lpDst=(char*)lpNewDIBBits;
  1726.     
  1727. //为新图像赋初始值
  1728. memset(lpDst,(BYTE)255,lLineBytes*lHeight);
  1729.     
  1730. //象素点的灰度值
  1731. int gray;
  1732.     
  1733. //位置映射值
  1734. int i_src;
  1736. //根据斜率，把当前新图像的点映射到源图像的点
  1738. //行
  1739. for (i=0;i<lHeight;i++)
  1740. {
  1741. //列
  1742.     for (j=0;j<lWidth;j++)
  1743. {
  1744.    //计算映射位置
  1745. i_src=int(i - (j-lWidth/2)*slope);
  1747. //如果点在图像外，象素置白色
  1748. if (i_src <0 || i_src >=lHeight )
  1749. gray = 255;
  1751. else
  1752. {
  1753. //否则到源图像中找点，取得象素值
  1755. //指向第i_src行第j个象素的指针
  1756. lpSrc=(unsigned char *)lpDIBBits + lLineBytes *  i_src + j;
  1757. gray = *lpSrc;
  1758. }
  1760. //把新图像的点用得到的象素值填充
  1761.             //指向第i行第j个象素的指针
  1762. lpDst = (char *)lpNewDIBBits + lLineBytes * i + j;
  1763. *lpDst=gray;
  1764. }
  1765. }
  1767. // 将新的图像的内容拷贝到旧的图像中
  1768. memcpy(lpDIBBits,lpNewDIBBits,lLineBytes*lHeight);
  1770.    // 解除锁定
  1771. ::GlobalUnlock ((HGLOBAL)hDIB);
  1772. }
  1776. /******************************************************************
  1777. *
  1778. *  函数名称：
  1779. *      StdDIBbyRect()
  1780. *
  1781. *  参数：
  1782. *     HDIB  hDIB          －图像的句柄
  1783. *     int   tarWidth      －标准化的宽度
  1784. *     int   tarHeight     －标准化的高度
  1785. *
  1786. *  返回值：
  1787. *         无
  1788. *
  1789. *  功能：
  1790. *     将经过分割的字符，进行缩放处理使他们的宽和高一直，以方便特征的提取
  1791. *
  1792. *  说明：
  1793. *     函数中用到了，每个字符的位置信息，所以必须在执行完分割操作之后才能执行标准化操作
  1794. *
  1795. ******************************************************************/
  1796. void StdDIBbyRect(HDIB hDIB, int tarWidth, int tarHeight)
  1797. {
  1799. //指向图像的指针
  1800. BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
  1802. //指向象素起始位置的指针
  1803. BYTE* lpDIBBits=(BYTE*)::FindDIBBits ((char*)lpDIB);
  1805. //指向象素的指针
  1806. BYTE* lpSrc;
  1808. //获取图像的的宽度
  1809. LONG lWidth=::DIBWidth ((char*)lpDIB);
  1811. //获取图像的高度
  1812. LONG lHeight=::DIBHeight ((char*)lpDIB);
  1814. // 循环变量
  1815. int i;
  1816. int j;
  1818. // 图像每行的字节数
  1819. LONG lLineBytes = WIDTHBYTES(lWidth * 8);
  1821. //宽度、高度方向上的缩放因子
  1822. double wscale,hscale;
  1824. //开辟一块临时缓存区,来存放变化后的图像信息
  1825. LPSTR lpNewDIBBits;
  1826. LPSTR lpDst;
  1827.  
  1828.     //缓存区的大小和原图像的数据区大小一样
  1829. HLOCAL nNewDIBBits=LocalAlloc(LHND,lLineBytes*lHeight);
  1831. //指向缓存区开始位置的指针
  1832. lpNewDIBBits=(char*)LocalLock(nNewDIBBits);
  1834. //指向缓存内信息的指针
  1835. lpDst=(char*)lpNewDIBBits;
  1837. //将缓存区的内容赋初始值
  1838. memset(lpDst,(BYTE)255,lLineBytes*lHeight);
  1840. //进行映射操作的坐标变量
  1841. int i_src,j_src;
  1843. //存放字符位置信息的结构体
  1844. CRect rect;
  1845. CRect rectnew;
  1847. //先清空一个新的矩形区域链表以便存储标准化后的矩形区域链表
  1848. m_charRectCopy.clear ();
  1850. //从头到尾逐个扫描各个结点
  1851. while(!m_charRect.empty())
  1852. {
  1853. //从表头上得到一个矩形
  1854. rect= m_charRect.front();
  1856. //从链表头上面删掉一个
  1857. m_charRect.pop_front();
  1859. //计算缩放因子
  1861. //横坐标方向的缩放因子
  1862. wscale=(double)tarWidth/rect.Width ();
  1864. //纵坐标方向的缩放因子
  1865. hscale=(double)tarHeight/rect.Height ();
  1867. //计算标准化矩形
  1869. //上边界
  1870. rectnew.top =rect.top ;
  1872. //下边界
  1873. rectnew.bottom =rect.top +tarHeight;
  1875. //左边界
  1876. rectnew.left =rect.left ;
  1878. //右边界
  1879. rectnew.right =rectnew.left +tarWidth;
  1881. //将原矩形框内的象素映射到新的矩形框内
  1882. for(i=rectnew.top ;i<rectnew.bottom ;i++)
  1883. {
  1884. for(j=rectnew.left ;j<rectnew.right ;j++)
  1885. {   
  1887. //计算映射坐标
  1888. i_src=rectnew.top +int((i-rectnew.top )/hscale);
  1889. j_src=rectnew.left +int((j-rectnew.left )/wscale);
  1891. //将相对应的象素点进行映射操作
  1892. lpSrc=(unsigned char *)lpDIBBits + lLineBytes *  i_src + j_src;
  1893. lpDst = (char *)lpNewDIBBits + lLineBytes * i + j;
  1894. *lpDst=*lpSrc;
  1895. }
  1896. }
  1897. //将标准化后的矩形区域插入新的链表
  1898. m_charRectCopy.push_back (rectnew);
  1901. }
  1903. //存储标准化后新的rect区域
  1904.     m_charRect=m_charRectCopy;
  1906. //将缓存区的内容拷贝到图像的数据区内
  1907. memcpy(lpDIBBits,lpNewDIBBits,lLineBytes*lHeight);
  1909. //解除锁定
  1910. ::GlobalUnlock ((HGLOBAL)hDIB);
  1911. }
  1914. void Thinning(HDIB hDIB)
  1915. {
  1916. // 指向DIB的指针
  1917. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  1919. // 指向DIB象素指针
  1920. LPSTR    lpDIBBits;
  1922. // 找到DIB图像象素起始位置
  1923. lpDIBBits = ::FindDIBBits(lpDIB);
  1925. // 指向源图像的指针
  1926. LPSTR lpSrc;
  1928. //图像的高度和宽度
  1929. LONG lWidth;
  1930. LONG lHeight;
  1932. //获取图像的宽度
  1933. lWidth=::DIBWidth ((char*)lpDIB);
  1935. //获取图像的高度
  1936. lHeight=::DIBHeight ((char*)lpDIB);
  1938.     //计算每行的字节数
  1939.     LONG  lLineBytes = (lWidth+3)*4/4;
  1941. //循环变量
  1942.     int i,j;
  1944.     //建立存储区存放2值矩阵
  1945. BYTE *image = (BYTE*)malloc(lWidth*lHeight*sizeof(BYTE));
  1947. //给2值矩阵赋值
  1949. for(i=0;i<lHeight;i++)
  1950. {
  1951.     for(j=0;j<lWidth;j++)
  1952. {
  1953.       lpSrc=lpDIBBits+i*lLineBytes+j;
  1954.     
  1955.       if(*lpSrc==0)
  1956.       image[i*lWidth+j]=1;
  1958.   else
  1959.          image[i*lWidth+j]=0;
  1960. }
  1961. }
  1963.    //调用函数进行细化,两种函数可以选择
  1965.    ThinnerRosenfeld(image,lHeight,lWidth);
  1967.    //ThinnerHilditch(image,lHeight,lWidth);
  1971.    //将结果赋值到原图像中
  1973.    for(i=0;i<lHeight;i++)
  1974.    {
  1975.      for(j=0;j<lWidth;j++)
  1976.  {
  1977.    lpSrc=lpDIBBits+i*lLineBytes+j;
  1979.        if(image[i*lWidth+j]==1)
  1980.    *lpSrc=(BYTE)0;
  1982.    else
  1983.        *lpSrc=(BYTE)255;
  1984.  }
  1985.    
  1986.    }
  1989.  //清空内存
  1990.    free(image);
  1991.    ::GlobalUnlock ((HGLOBAL)hDIB);
  1993. return;
  1994. }
  1996. /*****************************************************
  1997. * 
  1998. *   函数名称：
  1999. *      Template：
  2000. *
  2001. *    参数：
  2002. *    HDIB    hDIB         －图像的句柄
  2003. *      double  *tem         －指向模板的指针
  2004. *      int  tem_w           －模板的宽度
  2005. *      int  tem_h           －模板的高度
  2006. *      double xishu         －模板的系数
  2007. *         
  2008. *    功能：
  2009. *    对图像进行模板操作
  2010. *
  2011. *    说明：
  2012. *    为处理方便起见，模板的宽度和高度都应为奇数
  2013. *******************************************************/
  2014.  HDIB Template(HDIB hDIB,double * tem ,int tem_w,int tem_h,double xishu)
  2015. {
  2017.     //统计中间值
  2018.     double sum;
  2020.     //指向图像起始位置的指针
  2021.     BYTE *lpDIB=(BYTE*)::GlobalLock((HGLOBAL) hDIB);
  2023. //指向象素起始位置的指针
  2024. BYTE *pScrBuff =(BYTE*)::FindDIBBits((char*)lpDIB);
  2025.    
  2026. //获取图像的颜色信息
  2027.     int numColors=(int) ::DIBNumColors((char *)lpDIB);
  2029.     //如果图像不是256色返回
  2030.      if (numColors!=256) 
  2031.  {   
  2032.         //解除锁定
  2033.    ::GlobalUnlock((HGLOBAL) hDIB);
  2035. //返回
  2036. return(hDIB);
  2037.  }
  2038.     
  2039.     //将指向图像象素起始位置的指针，赋值给指针变量
  2040.     BYTE* oldbuf = pScrBuff;
  2042.     //循环变量
  2043.     int i,j,m,n;
  2045. int w, h, dw;
  2047. //获取图像的宽度
  2048. w = (int) ::DIBWidth((char *)lpDIB);
  2050. //获取图像的高度
  2051. h = (int) ::DIBHeight((char *)lpDIB);
  2053. //计算图像每行的字节数
  2054. dw = (w+3)/4*4;      
  2056. //建立一个和原图像大小相同的25色灰度位图
  2057.     HDIB newhDIB=NewDIB(w,h,8);  
  2058.     
  2059. //指向新的位图的指针
  2060. BYTE *newlpDIB=(BYTE*)::GlobalLock((HGLOBAL) newhDIB);
  2062. //指向新的位图的象素起始位置的指针 
  2063.     BYTE *destBuf = (BYTE*)FindDIBBits((char *)newlpDIB);
  2064.     
  2065.    //将指向新图像象素起始位置的指针，赋值给指针变量
  2066.     BYTE *newbuf=destBuf; 
  2068. //对图像进行扫描
  2069.    
  2070. //行 
  2071.     for(i=0;i<h;i++)
  2072.     {  
  2073. //列
  2074.    for(j=0;j<w;j++)
  2075.    {   
  2077.    //为统计变量赋初始值
  2078.        sum=0;
  2080.          //对于图像的4个边框的象素保持原灰度不变
  2081.      if( j<((tem_w-1)/2) || j>(w-(tem_w+1)/2) || i<((tem_h-1)/2) || i>(h-(tem_h+1)/2) )
  2082.       *(newbuf+i*dw+j)=*(oldbuf+i*dw+j);
  2083.  
  2084.          //对于其他的象素进行模板操作
  2085.  else 
  2086.          { 
  2088.           //将点（i,j）点作为模板的中心
  2089.           for(m=i-((tem_h-1)/2);m<=i+((tem_h-1)/2);m++)
  2090.           {
  2091.      for(n=j-((tem_w-1)/2);n<=j+((tem_w-1)/2);n++)
  2092.     
  2093.              //将以点（i，j）为中心，与模板大小相同的范围内的象素与模板对用位置的系数
  2094.  //进行相乘并线形叠加
  2095.      sum+=*(oldbuf+m*dw+n)* tem[(m-i+((tem_h-1)/2))*tem_w+n-j+((tem_w-1)/2)];
  2096.   
  2097.   }
  2098.           
  2099.   //将结果乘上总的模板系数
  2100.           sum=(int)sum*xishu;
  2102.   //计算绝对值
  2103.   sum = fabs(sum);
  2105.   //如果小于0，强制赋值为0
  2106.           if(sum<0)     
  2107.           sum=0;
  2109.   //如果大于255，强制赋值为255
  2110.           if(sum>255)
  2111.   sum=255;
  2113.   //将计算的结果放到新的位图的相应位置
  2114.       *(newbuf+i*dw+j)=sum;
  2115.  }
  2116.    }
  2117. } 
  2118.    
  2119. //解除锁定
  2120. ::GlobalUnlock((HGLOBAL)hDIB);
  2121.     
  2122. //返回新的位图的句柄
  2123.     return(newhDIB);
  2124. }
  2125. /*****************************************************
  2126. * 
  2127. *   函数名称：
  2128. *      Template：
  2129. *
  2130. *    参数：
  2131. *    HDIB    hDIB         －图像的句柄
  2132. *      int  tem_w           －模板的宽度
  2133. *      int  tem_h           －模板的高度
  2134. *      
  2135. *    功能：
  2136. *    对图像进行中值
  2137. *
  2138. *    说明：
  2139. *    为处理方便起见，模板的宽度和高度都应为奇数
  2140. *******************************************************/
  2142. HDIB MidFilter(HDIB hDIB,int tem_w,int tem_h)
  2143. {
  2145.     //统计中间值
  2146.     double mid;
  2148. BYTE *temp=(BYTE*)malloc(tem_w*tem_h*sizeof(BYTE));
  2150.     //指向图像起始位置的指针
  2151.     BYTE *lpDIB=(BYTE*)::GlobalLock((HGLOBAL) hDIB);
  2153. //指向象素起始位置的指针
  2154. BYTE *pScrBuff =(BYTE*)::FindDIBBits((char*)lpDIB);
  2155.    
  2156. //获取图像的颜色信息
  2157.     int numColors=(int) ::DIBNumColors((char *)lpDIB);
  2159.     //如果图像不是256色返回
  2160.      if (numColors!=256) 
  2161.  {   
  2162.         //解除锁定
  2163.    ::GlobalUnlock((HGLOBAL) hDIB);
  2165. //返回
  2166. return(hDIB);
  2167.  }
  2168.     
  2169.     //将指向图像象素起始位置的指针，赋值给指针变量
  2170.     BYTE* oldbuf = pScrBuff;
  2172.     //循环变量
  2173.     int i,j,m,n;
  2175. int w, h, dw;
  2177. //获取图像的宽度
  2178. w = (int) ::DIBWidth((char *)lpDIB);
  2180. //获取图像的高度
  2181. h = (int) ::DIBHeight((char *)lpDIB);
  2183. //计算图像每行的字节数
  2184. dw = (w+3)/4*4;      
  2186. //建立一个和原图像大小相同的25色灰度位图
  2187.     HDIB newhDIB=NewDIB(w,h,8);  
  2188.     
  2189. //指向新的位图的指针
  2190. BYTE *newlpDIB=(BYTE*)::GlobalLock((HGLOBAL) newhDIB);
  2192. //指向新的位图的象素起始位置的指针 
  2193.     BYTE *destBuf = (BYTE*)FindDIBBits((char *)newlpDIB);
  2194.     
  2195.    //将指向新图像象素起始位置的指针，赋值给指针变量
  2196.     BYTE *newbuf=destBuf; 
  2198. //对图像进行扫描
  2199.    
  2200. //行 
  2201.     for(i=0;i<h;i++)
  2202.     {  
  2203. //列
  2204.    for(j=0;j<w;j++)
  2205.    {   
  2207.    //为统计变量赋初始值
  2208.        
  2210.          //对于图像的4个边框的象素保持原灰度不变
  2211.      if( j<((tem_w-1)/2) || j>(w-(tem_w+1)/2) || i<((tem_h-1)/2) || i>(h-(tem_h+1)/2) )
  2212.       *(newbuf+i*dw+j)=*(oldbuf+i*dw+j);
  2213.  
  2214.          //对于其他的象素进行模板操作
  2215.  else 
  2216.          { 
  2218.           //将点（i,j）点作为模板的中心
  2219.           for(m=i-((tem_h-1)/2);m<=i+((tem_h-1)/2);m++)
  2220.           {
  2221.      for(n=j-((tem_w-1)/2);n<=j+((tem_w-1)/2);n++)
  2222.     
  2223.              //将以点（i，j）为中心，与模板大小相同的范围内的象素传递到模板矩阵中
  2224.      temp[(m-i+((tem_h-1)/2))*tem_w+n-j+((tem_w-1)/2)]=*(oldbuf+m*dw+n);
  2225.   
  2226.   }
  2227.           
  2228.  //利用气泡法计算中值
  2229.            for(m=0;m<tem_w*tem_h-1;m++)
  2230.            {
  2231.    
  2232.       for(n=0;n<tem_w*tem_h-m-1;n++)
  2233.   {
  2234.     if(temp[n]>temp[n+1]) 
  2235.     mid=temp[n];
  2236.                 temp[n]=temp[n+1];
  2237.     temp[n+1]=mid;
  2238.   }
  2239.    
  2240.    } 
  2242.            //将计算的结果放到新的位图的相应位置
  2243.       *(newbuf+i*dw+j)=temp[(tem_w*tem_h-1)/2];
  2244.  }
  2245.    }
  2246. } 
  2247.    
  2248. //解除锁定
  2249. ::GlobalUnlock((HGLOBAL)hDIB);
  2250.     
  2251. //返回新的位图的句柄
  2252.     return(newhDIB);
  2253. }
  2257. /*************************************************************************
  2258.  *
  2259.  * 函数名称：
  2260.  *   Equalize()
  2261.  *
  2262.  * 参数:
  2263.  *   HDIB hDIB
  2264.  *
  2265.  *
  2266.  * 说明:
  2267.  *   该函数用来对图像进行直方图均衡。
  2268.  *
  2269.  ************************************************************************/
  2270. void Equalize(HDIB hDIB)
  2271. {
  2272. BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
  2273. BYTE* lpDIBBits=(BYTE*)::FindDIBBits((char*)lpDIB);
  2274. LONG lHeight=::DIBHeight ((char*)lpDIB);
  2275. LONG lWidth=::DIBWidth ((char*)lpDIB);
  2276. // 指向源图像的指针
  2277. unsigned char* lpSrc;
  2279. // 临时变量
  2280. LONG lTemp;
  2282. // 循环变量
  2283. LONG i;
  2284. LONG j;
  2286. // 灰度映射表
  2287. BYTE bMap[256];
  2289. // 灰度映射表
  2290. LONG lCount[256];
  2292. // 图像每行的字节数
  2293. LONG lLineBytes;
  2295. // 计算图像每行的字节数
  2296. lLineBytes = WIDTHBYTES(lWidth * 8);
  2298. // 重置计数为0
  2299. for (i = 0; i < 256; i ++)
  2300. {
  2301. // 清零
  2302. lCount[i] = 0;
  2303. }
  2305. // 计算各个灰度值的计数
  2306. for (i = 0; i < lHeight; i ++)
  2307. {
  2308. for (j = 0; j < lWidth; j ++)
  2309. {
  2310. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * i + j;
  2312. // 计数加1
  2313. lCount[*(lpSrc)]++;
  2314. }
  2315. }
  2317. // 计算灰度映射表
  2318. for (i = 0; i < 256; i++)
  2319. {
  2320. // 初始为0
  2321. lTemp = 0;
  2323. for (j = 0; j <= i ; j++)
  2324. {
  2325. lTemp += lCount[j];
  2326. }
  2328. // 计算对应的新灰度值
  2329. bMap[i] = (BYTE) (lTemp * 255 / lHeight / lWidth);
  2330. }
  2332. // 每行
  2333. for(i = 0; i < lHeight; i++)
  2334. {
  2335. // 每列
  2336. for(j = 0; j < lWidth; j++)
  2337. {
  2338. // 指向DIB第i行，第j个象素的指针
  2339. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  2341. // 计算新的灰度值
  2342. *lpSrc = bMap[*lpSrc];
  2343. }
  2344. }
  2346. ::GlobalUnlock ((HGLOBAL)hDIB);
  2347. }