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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > Internet/IE编程 > 查看源码
Dib.cpp
资源名称：ImageProcessIEPlus.rar　[点击查看]
上传用户：pass2008
上传日期：2021-07-05
资源大小：3299k
文件大小：18k
源码类别：

Internet/IE编程

开发平台：

Visual C++

Dib.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include "Dib.h"
  3. #include "math.h"
  5. CDib::CDib(void)
  6. {
  7. m_pDib = NULL;
  8. }
  10. CDib::~CDib(void)
  11. {
  12. // 如果位图已经被加载，释放内存
  13. if (m_pDib != NULL)
  14. {
  15. delete[] m_pDib;
  16. }
  17. }
  19. BOOL CDib::imageLoadOperation(LPCTSTR lpszPathName, UINT nOperatorSel)
  20. {
  21. CxImage xImage;
  22. int imgForm = analysisImageFormat(lpszPathName);
  23. switch (imgForm) //先进行格式统一处理，调用cxImage图像处理库
  24. {
  25. case IMG_FORMAT_BMP:
  26. xImage.Load(lpszPathName, CXIMAGE_FORMAT_BMP);
  27. break;
  28. case IMG_FORMAT_JPEG:
  29. xImage.Load(lpszPathName, CXIMAGE_FORMAT_JPG);
  30. break;
  31. case IMG_FORMAT_GIF:
  32. xImage.Load(lpszPathName, CXIMAGE_FORMAT_GIF);
  33. break;
  34. case IMG_FORMAT_PNG:
  35. xImage.Load(lpszPathName, CXIMAGE_FORMAT_PNG);
  36. break;
  37. case IMG_FORMAT_TIFF:
  38. xImage.Load(lpszPathName, CXIMAGE_FORMAT_TIF);
  39. break;
  40. default:
  41. return FALSE;
  42. }
  44. CString lpszNewPathName = alterFileExtension(lpszPathName, imgForm);
  45. xImage.Save(lpszNewPathName, CXIMAGE_FORMAT_BMP); //先保存为位图格式
  46. xImage.Load(lpszNewPathName, CXIMAGE_FORMAT_BMP);
  48. if (xImage.IsValid())
  49. {
  50. if (xImage.GetBpp()>8)
  51. {
  52. xImage.DecreaseBpp(8, true);
  53. }
  54. else if (xImage.GetBpp()<8)
  55. {
  56. xImage.IncreaseBpp(8);
  57. }
  59. xImage.GrayScale();  //转存为8位灰度位图
  60. if (!xImage.IsGrayScale()) 
  61. {
  62. return FALSE;
  63. }
  64. }
  65. else
  66. {
  67. return FALSE;
  68. }
  70. xImage.Save(lpszNewPathName, CXIMAGE_FORMAT_BMP);
  71. loadIntoMemory(lpszNewPathName); //载入内存，自己编写边缘算子函数进行处理
  72. imageEdgeOperation(nOperatorSel);
  73. saveAfterProcess(lpszNewPathName);
  74. xImage.Load(lpszNewPathName, CXIMAGE_FORMAT_BMP);
  75. switch (imgForm)
  76. {
  77. case IMG_FORMAT_BMP:
  78. break;
  79. case IMG_FORMAT_JPEG:
  80. xImage.Save(lpszPathName, CXIMAGE_FORMAT_JPG);
  81. ::DeleteFile(lpszNewPathName);
  82. break;
  83. case IMG_FORMAT_GIF:
  84. xImage.Save(lpszPathName, CXIMAGE_FORMAT_GIF);
  85. ::DeleteFile(lpszNewPathName);
  86. break;
  87. case IMG_FORMAT_PNG:
  88. xImage.Save(lpszPathName, CXIMAGE_FORMAT_PNG);
  89. ::DeleteFile(lpszNewPathName);
  90. break;
  91. case IMG_FORMAT_TIFF:
  92. xImage.Save(lpszPathName, CXIMAGE_FORMAT_TIF);
  93. ::DeleteFile(lpszNewPathName);
  94. break;
  95. }
  97. return TRUE;
  98. }
  100. CString CDib::alterFileExtension(LPCTSTR lpszPathName, int nImgFormat)
  101. {
  102. CString strImgForm(lpszPathName);
  103. int index;
  104. switch (nImgFormat)
  105. {
  106. case IMG_FORMAT_BMP:
  107. break;
  108. case IMG_FORMAT_JPEG:
  109. strImgForm.Replace(_T(".jpg"), _T(".bmp"));
  110. strImgForm.Replace(_T(".jpeg"), _T(".bmp"));
  111. strImgForm.Replace(_T(".JPG"), _T(".BMP"));
  112. strImgForm.Replace(_T(".JPEG"), _T(".BMP"));
  113. break;
  114. case IMG_FORMAT_GIF:
  115. strImgForm.Replace(_T(".gif"), _T(".bmp"));
  116. strImgForm.Replace(_T(".GIF"), _T(".BMP"));
  117. break;
  118. case IMG_FORMAT_PNG:
  119. strImgForm.Replace(_T(".png"), _T(".bmp"));
  120. strImgForm.Replace(_T(".PNG"), _T(".BMP"));
  121. break;
  122. case IMG_FORMAT_TIFF:
  123. strImgForm.Replace(_T(".tif"), _T(".bmp"));
  124. strImgForm.Replace(_T(".tiff"), _T(".bmp"));
  125. strImgForm.Replace(_T(".TIF"), _T(".BMP"));
  126. strImgForm.Replace(_T(".TIFF"), _T(".BMP"));
  127. break;
  128. }
  130. return strImgForm;
  131. }
  133. int CDib::analysisImageFormat(LPCTSTR lpszPathName)
  134. {
  135. CString strImgForm(lpszPathName);
  137. int index;
  139. index = (((strImgForm.Find(_T(".bmp"))!=-1) || (strImgForm.Find(_T(".BMP"))!=-1)) ? 0 : -1);
  140. //index = strImgForm.Find(".bmp");
  141. if (index > -1)
  142. {
  143. return IMG_FORMAT_BMP;
  144. }
  146. index = (((strImgForm.Find(_T(".gif"))!=-1) || (strImgForm.Find(_T(".GIF"))!=-1)) ? 0 : -1);
  147. //index = strImgForm.Find(".gif");
  148. if (index > -1)
  149. {
  150. return IMG_FORMAT_GIF;
  151. }
  153. index = (((strImgForm.Find(_T(".png"))!=-1) || (strImgForm.Find(_T(".PNG"))!=-1)) ? 0 : -1);
  154. //index = strImgForm.Find(".png");
  155. if (index > -1)
  156. {
  157. return IMG_FORMAT_PNG;
  158. }
  160. index = (((strImgForm.Find(_T(".jpg"))!=-1) || (strImgForm.Find(_T(".jpeg"))!=-1) || (strImgForm.Find(_T(".JPG"))!=-1) || (strImgForm.Find(_T(".JPEG"))!=-1)) ? 0 : -1);
  161. if (index > -1)
  162. {
  163. return IMG_FORMAT_JPEG;
  164. }
  166. index = (((strImgForm.Find(_T(".tif"))!=-1) || (strImgForm.Find(_T(".tiff"))!=-1) || (strImgForm.Find(_T(".TIF"))!=-1) || (strImgForm.Find(_T(".TIFF"))!=-1)) ? 0 : -1);
  167. if (index > -1)
  168. {
  169. return IMG_FORMAT_TIFF;
  170. }
  172. return IMG_FORMAT_DEFAULT;
  173. }
  175. BOOL CDib::loadIntoMemory(LPCTSTR lpszPathName)
  176. {
  177. CFile imgFile;
  179. // 打开位图文件
  180. if (!imgFile.Open(lpszPathName, CFile::modeReadWrite | CFile::shareExclusive))
  181. {
  182. return FALSE;
  183. }
  185. // 获得位图文件大小，并减去BITMAPFILEHEADER的长度
  186. DWORD dwDibSize;
  187. dwDibSize = imgFile.GetLength() - sizeof(BITMAPFILEHEADER);
  189. // 为DIB位图分配内存
  190. unsigned char* pDib;
  191. pDib = new unsigned char[dwDibSize];
  192. if (pDib == NULL)
  193. {
  194. return FALSE;
  195. }
  197. BITMAPFILEHEADER BFH;
  199. // 读取位图文件数据
  200. try
  201. {
  202. // 文件格式是否正确有效
  203. if (imgFile.Read(&BFH, sizeof(BITMAPFILEHEADER)) != sizeof(BITMAPFILEHEADER) ||
  204. BFH.bfType != 'MB' || 
  205. imgFile.Read(pDib, dwDibSize) != dwDibSize)
  206. {
  207. delete[] pDib;
  208. return FALSE;
  209. }
  210. }
  211. catch (CFileException* e)
  212. {
  213. e->Delete();
  214. delete[] pDib;
  215. return FALSE;
  216. }
  218. // delete先前加载的位图
  219. if (m_pDib != NULL)
  220. {
  221. delete m_pDib;
  222. }
  224. // 将临时Dib数据指针和Dib大小变量赋给类成员变量
  225. m_pDib = pDib;
  226. m_dwDibSize = dwDibSize;
  228. // 为相应类成员变量赋BITMAPINFOHEADER和调色板指针
  229. m_pBIH = (BITMAPINFOHEADER*)m_pDib;
  230. m_pPalette = (RGBQUAD*)&m_pDib[sizeof(BITMAPINFOHEADER)];
  231. m_Width = m_pBIH->biWidth;
  232. m_Height = m_pBIH->biHeight;
  234. // 计算调色板中实际颜色数量
  235. m_nPaletteEntries = 1 << (m_pBIH->biBitCount);
  236. if (m_pBIH->biBitCount >8)
  237. {
  238. m_nPaletteEntries = 0;
  239. }
  240. else if (m_pBIH->biClrUsed != 0)
  241. {
  242. m_nPaletteEntries = m_pBIH->biClrUsed;
  243. }
  245. // 为相应类成员变量赋image data指针
  246. m_pDibBits = &m_pDib[sizeof(BITMAPINFOHEADER) + m_nPaletteEntries * sizeof(RGBQUAD)];
  248. // delete先前的调色板
  249. if (m_Palette.GetSafeHandle() != NULL)
  250. {
  251. m_Palette.DeleteObject();
  252. }
  254. // 如果位图中存在调色板，创建LOGPALETTE 及CPalette
  255. if (m_nPaletteEntries != 0)
  256. {
  257. LOGPALETTE* pLogPal = (LOGPALETTE*)new char[sizeof(LOGPALETTE) + m_nPaletteEntries * sizeof(PALETTEENTRY)];
  259. if (pLogPal != NULL)
  260. {
  261. pLogPal->palVersion = 0x300;
  262. pLogPal->palNumEntries = m_nPaletteEntries;
  264. for (int i = 0; i < m_nPaletteEntries; i++)
  265. {
  266. pLogPal->palPalEntry[i].peRed = m_pPalette[i].rgbRed;
  267. pLogPal->palPalEntry[i].peGreen = m_pPalette[i].rgbGreen;
  268. pLogPal->palPalEntry[i].peBlue = m_pPalette[i].rgbBlue;
  269. }
  271. //创建CPalette并释放LOGPALETTE的内存
  272. m_Palette.CreatePalette(pLogPal);
  273. delete[] pLogPal;
  274. }
  275. }
  277. return TRUE;
  278. }
  280. BOOL CDib::imageEdgeOperation(UINT nOperatorSel)
  281. {
  282. switch (nOperatorSel)
  283. {
  284. case 0:
  285. LaplaceOperator();
  286. break;
  287. case 1:
  288. CannyOperator(0.1, 0.9, 0.3);
  289. break;
  290. default:
  291. break;
  292. }
  294. return TRUE;
  295. }
  297. BOOL CDib::LaplaceOperator(void)
  298. {
  299. unsigned char* lpSrc0, *lpSrc1, *lpSrc2, *lpSrc3, *lpSrc4, *lpSrc5, *lpSrc6, *lpSrc7, *lpSrc8;
  300. BYTE* p_temp = new BYTE[m_Height * m_Width];
  301. memset(p_temp, 255, m_Height * m_Width);
  302. for(int i=1; i<m_Height-1; i++)
  303. {
  304. for(int j=1; j<m_Width-1; j++)
  305. {
  306. lpSrc0 = m_pDibBits + i * m_Width + j;
  307. lpSrc1 = m_pDibBits + i * m_Width + j - 1;
  308. lpSrc2 = m_pDibBits + i * m_Width + j + 1;
  309. lpSrc3 = m_pDibBits + (i-1) * m_Width + j;
  310. lpSrc4 = m_pDibBits + (i+1) * m_Width + j;
  311. lpSrc5 = m_pDibBits + (i-1) * m_Width + j - 1;
  312. lpSrc6 = m_pDibBits + (i-1) * m_Width + j + 1;
  313. lpSrc7 = m_pDibBits + (i+1) * m_Width + j - 1;
  314. lpSrc8 = m_pDibBits + (i+1) * m_Width + j + 1;
  315. p_temp[i * m_Width + j] = abs(*lpSrc0 * 8 + *lpSrc1 * (-1) + *lpSrc2 * (-1) +
  316. *lpSrc3 * (-1) + *lpSrc4 * (-1) + *lpSrc5 * (-1) +
  317. *lpSrc6 * (-1) + *lpSrc7 * (-1) + *lpSrc8 * (-1));
  318. }
  319. }
  321. memcpy(m_pDibBits, p_temp, m_Height * m_Width);
  322. delete[] p_temp;
  323. return TRUE;
  324. }
  326. void CDib::CreatGauss(double sigma, double** pdKernel, int* pnWidowSize)
  327. {
  328. LONG i;
  329. // 数组中心点
  330. int nCenter;
  331. // 数组中一点到中心点距离
  332. double dDis;
  333. // 中间变量
  334. double dValue;
  335. double dSum;
  336. dSum = 0;
  337. // [-3*sigma,3*sigma] 以内数据，会覆盖绝大部分滤波系数
  338. *pnWidowSize = (int)(1+2*ceil(3*sigma));
  339. nCenter = (*pnWidowSize)/2;
  340. *pdKernel = new double[*pnWidowSize];
  341. //生成高斯数据
  342. for (i=0; i<(*pnWidowSize); i++)
  343. {
  344. dDis = double(i - nCenter);
  345. dValue = exp(-(1/2)*dDis*dDis/(sigma*sigma))/(sqrt(2*3.1415926)*sigma);
  346. (*pdKernel)[i] = dValue;
  347. dSum += dValue;
  348. }
  349. //归一化
  350. for (i=0; i<(*pnWidowSize); i++)
  351. {
  352. (*pdKernel)[i] /= dSum;
  353. }
  354. }
  356. void CDib::GaussianSmooth(unsigned char* pResult, double sigma)
  357. {
  358. LONG x, y;
  359. LONG i;
  361. int nWindowSize; // 高斯滤波器长度
  362. int nLen; // 窗口长度
  363. double* pdKernel; // 一维高斯滤波器
  364. double dDotMul; // 高斯系数与图像数据的点乘
  365. double dWeightSum; // 滤波系数总和
  367. double* pdTemp = new double[m_Height*m_Width];
  369. //产生一维高斯数据
  370. CreatGauss(sigma, &pdKernel, &nWindowSize);
  372. nLen = nWindowSize/2;
  373. for (y=0; y<m_Height; y++) // x方向滤波
  374. {
  375. for (x=0; x<m_Width; x++)
  376. {
  377. dDotMul = 0;
  378. dWeightSum = 0;
  379. for (i=(-nLen); i<=nLen; i++)
  380. {
  381. //判断是否在图像内部
  382. if ((i+x)>=0 && (i+x)<m_Width)
  383. {
  384. dDotMul += (double)(*(m_pDibBits+y*m_Width+(i+x))) * pdKernel[nLen+i];
  385. dWeightSum += pdKernel[nLen+i];
  386. }
  387. }
  388. pdTemp[y*m_Width+x] = dDotMul/dWeightSum;
  389. }
  390. }
  392. for (x=0; x<m_Width; x++) // y方向滤波
  393. {
  394. for (y=0; y<m_Height; y++)
  395. {
  396. dDotMul = 0;
  397. dWeightSum = 0;
  398. for (i=(-nLen); i<=nLen; i++)
  399. {
  400. if ((i+y)>=0 && (i+y)<m_Height)
  401. {
  402. dDotMul += (double)pdTemp[(y+i)*m_Width+x]*pdKernel[nLen+i];
  403. dWeightSum += pdKernel[nLen+i];
  404. }
  405. }
  406. pResult[y*m_Width+x] = (unsigned char)dDotMul/dWeightSum;
  407. }
  408. }
  410. delete[] pdKernel;
  411. pdKernel = NULL;
  413. delete[] pdTemp;
  414. pdTemp = NULL;
  415. }
  417. void CDib::Grad(unsigned char* pGray, int* pGradX, int* pGradY, int* pMag)
  418. {
  419. LONG y, x;
  421. for (y=1; y<m_Height-1; y++) // x方向的方向导数
  422. {
  423. for (x=1; x<m_Width-1; x++)
  424. {
  425. pGradX[y*m_Width + x] = (int)(pGray[y*m_Width+x+1] - pGray[y*m_Width+x-1]);
  426. }
  427. }
  429. for (x=1; x<m_Width-1; x++) // y方向方向导数
  430. {
  431. for (y=1; y<m_Height-1; y++)
  432. {
  433. pGradY[y*m_Width + x] = (int)(pGray[(y+1)*m_Width+x] - pGray[(y-1)*m_Width+x]);
  434. }
  435. }
  437. //求梯度
  438. double dSqt1, dSqt2; //中间变量
  439. for (y=0; y<m_Height; y++)
  440. {
  441. for (x=0; x<m_Width; x++)
  442. {
  443. //二阶范数求梯度
  444. dSqt1 = pGradX[y*m_Width + x]*pGradX[y*m_Width + x];
  445. dSqt2 = pGradY[y*m_Width + x]*pGradY[y*m_Width + x];
  446. pMag[y*m_Width + x] = (int)(sqrt(dSqt1+dSqt2)+0.5);
  447. }
  448. }
  449. }
  451. //非最大抑制
  452. void CDib::NonmaxSuppress(int* pMag, int* pGradX, int* pGradY, unsigned char* pNSRst)
  453. {
  454. LONG y,x;
  455. int nPos;
  457. int gx, gy; // 梯度分量
  459. //中间变量
  460. int g1, g2, g3, g4;
  461. double weight;
  462. double dTmp, dTmp1, dTmp2;
  464. //设置图像边缘为不可能的分界点
  465. for (x=0; x<m_Width; x++)
  466. {
  467. pNSRst[x] = 0;
  468. pNSRst[(m_Height-1)*m_Width+x] = 0;
  470. }
  471. for (y=0; y<m_Height; y++)
  472. {
  473. pNSRst[y*m_Width] = 0;
  474. pNSRst[y*m_Width + m_Width - 1] = 0;
  475. }
  477. for (y=1; y<m_Height-1; y++)
  478. {
  479. for (x=1; x<m_Width-1; x++)
  480. {
  481. nPos = y*m_Width + x; //当前点
  483. if (pMag[nPos] == 0) // 如果当前像素梯度幅度为0，则不是边界点
  484. {
  485. pNSRst[nPos] = 0;
  486. }
  487. else
  488. {
  489. dTmp = pMag[nPos]; // 当前点的梯度幅度
  491. //x,y方向导数
  492. gx = pGradX[nPos];
  493. gy = pGradY[nPos];
  495. if (abs(gy) > abs(gx)) //如果方向导数y分量比x分量大，说明导数方向趋向于y分量
  496. {
  497. weight = fabs((double)gx)/fabs((double)gy); // 计算插值比例
  499. g2 = pMag[nPos-m_Width];
  500. g4 = pMag[nPos+m_Width];
  502. //如果x,y两个方向导数的符号相同
  503. //C 为当前像素，与g1-g4 的位置关系为：
  504. //g1 g2
  505. //            C
  506. //             g4 g3
  507. if(gx*gy>0)
  508. {
  509. g1 = pMag[nPos-m_Width-1];
  510. g3 = pMag[nPos+m_Width+1];
  511. }
  512. //如果x,y两个方向的方向导数方向相反
  513. //C是当前像素，与g1-g4的关系为：
  514. //             g2 g1
  515. //              C
  516. //          g3 g4
  517. else
  518. {
  519. g1 = pMag[nPos-m_Width+1];
  520. g3 = pMag[nPos+m_Width-1];
  521. }
  522. }
  523. else // 如果方向导数x分量比y分量大，说明导数的方向趋向于x分量
  524. {
  525. weight = fabs((double)gy)/fabs((double)gx); // 插值比例
  527. g2 = pMag[nPos+1];
  528. g4 = pMag[nPos-1];
  530. //如果x,y两个方向的方向导数符号相同
  531. //当前像素C与 g1-g4的关系为
  532. //        g3
  533. //        g4 C g2
  534. //             g1
  535. if(gx * gy > 0)
  536. {
  537. g1 = pMag[nPos+m_Width+1];
  538. g3 = pMag[nPos-m_Width-1];
  539. }
  540. //如果x,y两个方向导数的方向相反
  541. // C与g1-g4的关系为
  542. //         g1
  543. //          g4 C g2
  544. //           g3
  545. else
  546. {
  547. g1 = pMag[nPos-m_Width+1];
  548. g3 = pMag[nPos+m_Width-1];
  549. }
  550. }
  552. //利用 g1-g4 对梯度进行插值
  553. {
  554. dTmp1 = weight*g1 + (1-weight)*g2;
  555. dTmp2 = weight*g3 + (1-weight)*g4;
  557. //当前像素的梯度是局部的最大值
  558. //该点可能是边界点
  559. if(dTmp>=dTmp1 && dTmp>=dTmp2)
  560. {
  561. pNSRst[nPos] = 128;
  562. }
  563. else
  564. {
  565. //不可能是边界点
  566. pNSRst[nPos] = 0;
  567. }
  568. }
  569. }
  570. }
  571. }
  572. }
  574. void CDib::EstimateThreshold(int* pMag, int* pThrHigh, int* pThrLow, unsigned char* pGray, double dRatHigh, double dRatLow)
  575. {
  576. LONG y, x, k;
  578. int nHist[256]; //该数组的大小和梯度值的范围有关，如果采用本程序的算法那么梯度的范围不会超过pow(2,10)
  579. int nEdgeNum; // 可能边界数
  580. int nMaxMag; // 最大梯度数
  581. int nHighCount;
  583. nMaxMag = 0;
  584. for (k=0; k<256; k++) // 初始化
  585. {
  586. nHist[k] = 0;
  587. }
  589. for (y=0; y<m_Height; y++) // 统计直方图,利用直方图计算阈值
  590. {
  591. for (x=0; x<m_Width; x++)
  592. {
  593. if (pGray[y*m_Width+x]==128)
  594. {
  595. nHist[pMag[y*m_Width+x]]++;
  596. }
  597. }
  598. }
  600. nEdgeNum = nHist[0];
  601. nMaxMag = 0;
  602. for (k=1; k<256; k++) //统计经过“非最大值抑制”后有多少像素
  603. {
  604. if (nHist[k] != 0)
  605. {
  606. nMaxMag = k;
  607. }
  608. //梯度为0的点是不可能为边界点的
  609. //经过non-maximum suppression后有多少像素
  610. nEdgeNum += nHist[k];
  611. }
  613. nHighCount = (int)(dRatHigh * nEdgeNum + 0.5); // 梯度比高阈值*pThrHigh 小的像素点总书目
  615. k=1;
  616. nEdgeNum = nHist[1];
  617. while ((k<(nMaxMag-1)) && (nEdgeNum<nHighCount)) //计算高阈值
  618. {
  619. k++;
  620. nEdgeNum += nHist[k];
  621. }
  622. *pThrHigh = k;
  624. *pThrLow = (int)((*pThrHigh) * dRatLow + 0.5); //低阈值
  625. }
  627. //利用函数寻找边界起点
  628. void CDib::Hysteresis(int* pMag, double dRatLow, double dRatHigh, unsigned char* pResult)
  629. {
  630. LONG y,x;
  631. int nThrHigh, nThrLow;
  632. int nPos;
  634. EstimateThreshold(pMag, &nThrHigh, &nThrLow, pResult, dRatHigh, dRatLow); //估计TraceEdge 函数需要的低阈值，以及Hysteresis函数使用的高阈值
  636. //寻找大于dThrHigh的点，这些点用来当作边界点，
  637. //然后用TraceEdge函数跟踪该点对应的边界
  638. for (y=0; y<m_Height; y++)
  639. {
  640. for (x=0; x<m_Width; x++)
  641. {
  642. nPos = y*m_Width + x;
  644. //如果该像素是可能的边界点，并且梯度大于高阈值，该像素作为一个边界的起点
  645. if ((pResult[nPos]==128) && (pMag[nPos]>=nThrHigh))
  646. {
  647. //设置该点为边界点
  648. pResult[nPos] = 255;
  649. TraceEdge(y, x, nThrLow, pResult, pMag);
  650. }
  652. }
  653. }
  655. //其他点已经不可能为边界点
  656. for (y=0; y<m_Height; y++)
  657. {
  658. for (x=0; x<m_Width; x++)
  659. {
  660. nPos = y*m_Width + x;
  662. if (pResult[nPos] != 255)
  663. {
  664. pResult[nPos] = 0;
  665. }
  666. }
  667. }
  668. }
  670. //根据Hysteresis 执行的结果，从一个像素点开始搜索，搜索以该像素点为边界起点的一条边界的
  671. //一条边界的所有边界点，函数采用了递归算法
  672. //             从（x,y)坐标出发，进行边界点的跟踪，跟踪只考虑pResult中没有处理并且可能是边界
  673. //        点的像素（=128），像素值为0表明该点不可能是边界点，像素值为255表明该点已经是边界点
  675. void CDib::TraceEdge(int y, int x, int nThrLow, unsigned char* pResult, int* pMag)
  676. {
  677. //对8邻域像素进行查询
  678. int xNum[8] = {1, 1, 0, -1, -1, -1, 0, 1};
  679. int yNum[8] = {0, 1, 1, 1, 0, -1, -1, -1};
  681. LONG yy, xx, k;
  683. for (k=0; k<8; k++)
  684. {
  685. yy = y+yNum[k];
  686. xx = x+xNum[k];
  688. if (pResult[yy*m_Width+xx]==128 && pMag[yy*m_Width+xx]>=nThrLow)
  689. {
  690. pResult[yy*m_Width+xx] = 255; // 该点设为边界点
  691. TraceEdge(yy, xx, nThrLow, pResult, pMag); // 以该点为中心再进行跟踪
  692. }
  693. }
  694. }
  696. // Canny算子
  697. BOOL CDib::CannyOperator(double sigma, double dRatLow, double dRatHigh)
  698. {
  699. unsigned char* pResult = new unsigned char[m_Height*m_Width];
  700. memset(pResult, 0, m_Height*m_Width);
  701. unsigned char* pGaussSmooth = new unsigned char[m_Height*m_Width]; // 经过高斯滤波后的图像
  702. memset(pGaussSmooth, 0, m_Height*m_Width);
  704. int* pGradX = new int[m_Height*m_Width]; // x方向导数的指针
  705. int* pGradY = new int[m_Height*m_Width]; // y方向
  706. int* pGradMag = new int[m_Height*m_Width]; // 梯度的幅度
  708. GaussianSmooth(pGaussSmooth, sigma); // 对原图高斯滤波
  709. Grad(pGaussSmooth, pGradX, pGradY, pGradMag); // 计算方向导数和梯度的幅度
  710. NonmaxSuppress(pGradMag, pGradX, pGradY, pResult); // 应用非最大抑制
  711. Hysteresis(pGradMag, dRatLow, dRatHigh, pResult); // 应用Hysteresis，找到所有边界
  713. delete[] pGradX;
  714. pGradX = NULL;
  715. delete[] pGradY;
  716. pGradY = NULL;
  717. delete[] pGradMag;
  718. pGradMag = NULL;
  719. delete[] pGaussSmooth;
  720. pGaussSmooth = NULL;
  722. memcpy(m_pDibBits, pResult, m_Height * m_Width);
  723. delete[] pResult;
  725. return TRUE;
  726. }
  728. BOOL CDib::saveAfterProcess(LPCTSTR lpszPathName)
  729. {
  730. if (m_pDib == NULL)
  731. {
  732. return FALSE;
  733. }
  735. CFile imgFile;
  736. if (!imgFile.Open(lpszPathName, CFile::modeCreate | CFile::modeWrite))
  737. {
  738. return FALSE;
  739. }
  741. try
  742. {
  743. BITMAPFILEHEADER BFH;
  744. memset(&BFH, 0, sizeof(BITMAPFILEHEADER));
  745. BFH.bfType = 'MB';
  746. BFH.bfSize = sizeof(BITMAPFILEHEADER) + m_dwDibSize;
  747. BFH.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + m_nPaletteEntries * sizeof(RGBQUAD);
  749. imgFile.Write(&BFH, sizeof(BITMAPFILEHEADER));
  750. imgFile.Write(m_pDib, m_dwDibSize);
  751. }
  752. catch (CFileException* e)
  753. {
  754. e->Delete();
  755. return FALSE;
  756. }
  758. return TRUE;
  759. }