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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
PointPro.cpp
资源名称：image-retrieval.rar　[点击查看]
上传用户：xayxjz
上传日期：2022-08-07
资源大小：2188k
文件大小：37k
源码类别：

图形图象

开发平台：

Visual C++

PointPro.cpp：源码内容
  1. // PointPro.cpp: implementation of the CPointPro class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "CBIR.h"
  7. #include "PointPro.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. IMPLEMENT_DYNCREATE(CPointPro, CObject)
  17. //Diagnostics and dump member functions, overridden
  18. #ifdef _DEBUG
  22. void CPointPro::Dump(CDumpContext &dc) const
  23. {
  24. //call base class function first
  25. CObject::Dump(dc);
  26. }
  27. #endif
  29. #ifdef _DEBUG
  30. void CPointPro::AssertValid() const
  31. {
  32. //call inherited AssertValid first
  33. CObject::AssertValid();
  34. //Check CDibObject members...
  35. ASSERT(m_pDibObject != NULL); //Must exist
  36. }
  37. #endif
  39. /***********************************************************************
  40. *                                                                      *
  41. *                               点处理                                 *
  42. *                                                                      *
  43. ***********************************************************************/
  45. ////////////////////////////////////////////////////////////////////////
  46. //CPointPro()   
  47. //----------------------------------------------------------------------
  48. //基本功能：构造CPointPro类对象。由于此构造函数没有
  49. // CDibObject类，所以必须为其他所用到的CPointPro函
  50. // 数提供一个CDibObject构造器。
  51. //----------------------------------------------------------------------
  52. //参数说明：无
  53. //----------------------------------------------------------------------
  54. //返    回：无
  55. //----------------------------------------------------------------------
  56. ////////////////////////////////////////////////////////////////////////
  57. CPointPro::CPointPro()
  58. {
  60. }
  61. ////////////////////////////////////////////////////////////////////////
  62. //CPointPro(CDibObject *pDibObject)   
  63. //----------------------------------------------------------------------
  64. //基本功能：构造CPointPro类对象。由于此构造函数有一个
  65. // CDibObject类，所以无须为其他所用到的CPointPro函
  66. // 数提供一个CDibObject构造器
  67. //----------------------------------------------------------------------
  68. //参数说明：无
  69. //----------------------------------------------------------------------
  70. //返    回：无
  71. //----------------------------------------------------------------------
  72. ////////////////////////////////////////////////////////////////////////
  73. CPointPro::CPointPro( CDibObject *pDibObject )
  74. {
  76. m_pDibObject = pDibObject;
  78. }
  79. ////////////////////////////////////////////////////////////////////////
  80. //BOOL MakeGray256(BYTE mGrayType, CDibObject *pDibObject)   
  81. //----------------------------------------------------------------------
  82. //基本功能：本函数将传入的CDibObject对象中的图像从彩色转换为灰度图像。
  83. // 如果进行此调整之前没有指定一个CDibObject对象指针，则必须在
  84. // 调整时加以指定。
  85. //----------------------------------------------------------------------
  86. //参数说明：BYTE mGrayType  0：Y=0.3R+0.59G+0.11B 
  87. // 1: Y=R 
  88. // 2: Y=G
  89. // 3: Y=B
  90. // CDibObject *pDibObject, 默认为NULL。
  91. //----------------------------------------------------------------------
  92. //返    回：成功返回TRUE，失败返回FALSE。
  93. //----------------------------------------------------------------------
  94. ////////////////////////////////////////////////////////////////////////
  95. BOOL CPointPro::MakeGray256(BYTE mGrayType, 
  96. CDibObject *pDibObject )
  97. {
  98. //CDibObject对象指针
  99. if( pDibObject != NULL ) m_pDibObject = pDibObject;
  100. //若未指定 CDibObject 对象指针返回FALSE
  101. if( m_pDibObject == NULL ) return( FALSE );
  102. //低于8位的图像不进行处理
  103. if( m_pDibObject->GetNumBits() < 8 ) return( FALSE );
  106. //获取原图像字节宽度和转换后的8位256色灰度图像的字节宽度
  107. int nOldWidthBytes, nNewWidthBytes;
  108. char *pBuffer = (char *) m_pDibObject->GetDIBPointer( &nOldWidthBytes, 8, &nNewWidthBytes );
  109. if( pBuffer == NULL ) return( FALSE );
  111. //定义变量
  112. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  113. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  114. RGBQUAD *pOldRGBPalette, *pNewRGBPalette;
  115. unsigned char *pOldBits, *pNewBits, *pTemp, *pNewTemp;
  116. int nNumColors, nNumNewColors;
  118. //获取文件头指针
  119. pOldBFH = (BITMAPFILEHEADER *) pBuffer;
  120. //获取信息头指针
  121. pOldBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  122. //获取调色板指针
  123. pOldRGBPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+
  124. sizeof(BITMAPINFOHEADER)];
  125. //原图像颜色数
  126. nNumColors = m_pDibObject->GetNumColors();
  127. //新图像颜色数
  128. nNumNewColors = 256;
  129. //获取原图像数据指针
  130. pOldBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)
  131. +sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  133. //为新图像分配内存
  134. HGLOBAL hGlobal;
  135. //新图像总字节数
  136. DWORD dwSize;
  137. dwSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) +
  138. 256 * sizeof( RGBQUAD ) + 
  139. m_pDibObject->GetHeight() * nNewWidthBytes;
  140. hGlobal = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwSize );
  141. if( hGlobal == NULL )
  142. {
  143. ::GlobalUnlock( m_pDibObject->GetDib() );
  144. return( FALSE );
  145. }
  147. pBuffer = (char *) ::GlobalLock( hGlobal );
  148. if( pBuffer == NULL )
  149. {
  150. ::GlobalFree( hGlobal );
  151. ::GlobalUnlock( m_pDibObject->GetDib() );
  152. return( FALSE );
  153. }
  155. //获得新图像的文件头指针
  156. pNewBFH = (BITMAPFILEHEADER *) pBuffer;
  157. //获得新图像的信息头指针
  158. pNewBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  159. //获得新图像的调色板指针
  160. pNewRGBPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)
  161. +sizeof(BITMAPINFOHEADER)];
  162. //复制原图像文件头数据到新图像文件头
  163. *pNewBFH = *pOldBFH;
  164. //复制原图像信息头数据到新图像信息头
  165. *pNewBIH = *pOldBIH;
  167. //循环变量定义
  168. int i, j = 256, x, y;
  170. pNewBIH->biBitCount = 8;
  171. pNewBIH->biSizeImage = nNewWidthBytes * m_pDibObject->GetHeight();
  172. pNewBIH->biClrUsed = 256;
  173. pNewBFH->bfSize = sizeof( BITMAPFILEHEADER ) + 
  174. sizeof( BITMAPINFOHEADER ) + 
  175. 256 * sizeof( RGBQUAD ) + 
  176. pNewBIH->biSizeImage;
  177. pNewBFH->bfOffBits = sizeof( BITMAPFILEHEADER ) + 
  178. sizeof( BITMAPINFOHEADER ) + 
  179. nNumNewColors * sizeof( RGBQUAD );
  180. pNewBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER) +
  181. sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
  182. m_pDibObject->SetPaletteBytes( 256 * sizeof( RGBQUAD ));
  184. //创建256色灰度调色板
  185. for( i = 0; i < j; i++ )
  186. {
  187. pNewRGBPalette[i].rgbRed = i;
  188. pNewRGBPalette[i].rgbGreen = i;
  189. pNewRGBPalette[i].rgbBlue = i;
  190. }
  193. unsigned char *pLookup; //调色板查找表
  194. DWORD dwGray; //灰度级别
  196. switch( m_pDibObject->GetNumBits() )
  197. {
  198. case 8: //256色图像
  199. pLookup = new unsigned char [256];
  200. if( pLookup == NULL ) break;
  201. memset( pLookup, 0, 256 ); //调色板查找表清0（256项）
  202. switch( mGrayType)
  203. {
  204. case 0: //按亮度Y=0.3R+0.59G+0.11B将彩色图像转换为灰度图像
  205. for( i=0; i<256; i++ )
  206. {
  207. dwGray = ( (DWORD) pOldRGBPalette[i].rgbRed * 30 +
  208. (DWORD) pOldRGBPalette[i].rgbGreen * 59 +
  209. (DWORD) pOldRGBPalette[i].rgbBlue * 11 ) / 100;
  210. pLookup[i] = (unsigned char) dwGray;
  211. }
  212. break;
  213. case 1: //按亮度Y=R将彩色图像转换为灰度图像
  214. for( i=0; i<256; i++ )
  215. {
  216. dwGray =  (DWORD) pOldRGBPalette[i].rgbRed;
  217. pLookup[i] = (unsigned char) dwGray;
  218. }
  219. break;
  220. case 2: //按亮度Y=G将彩色图像转换为灰度图像
  221. for( i=0; i<256; i++ )
  222. {
  223. dwGray = (DWORD) pOldRGBPalette[i].rgbGreen;
  224. pLookup[i] = (unsigned char) dwGray;
  225. }
  226. break;
  227. case 3: //按亮度Y=B将彩色图像转换为灰度图像
  228. for( i=0; i<256; i++ )
  229. {
  230. dwGray =(DWORD) pOldRGBPalette[i].rgbBlue;
  231. pLookup[i] = (unsigned char) dwGray;
  232. }
  233. break;
  234. }
  235. for( y = 0; y < pOldBIH->biHeight; y++ )
  236. {
  237. pTemp = pOldBits; //位图数据起始指针
  238. pTemp += y * nOldWidthBytes; //位图数据下一行起始指针
  239. //转换成灰度索引
  240. for( x = 0; x < pOldBIH->biWidth; x++ ) pTemp[x] = pLookup[pTemp[x]];
  241. }
  242. delete [] pLookup; //释放pLookup查找表所占内存
  244. memcpy( pNewBits, pOldBits, nNewWidthBytes * m_pDibObject->GetHeight());
  246. break;
  247. case 16: //16位色真彩色图像
  248. unsigned char ucRed, ucGreen, ucBlue;
  249. for( y=0; y<pOldBIH->biHeight; y++ )
  250. {
  251. //位图数据起始指针
  252. pTemp = pOldBits;
  253. pNewTemp = pNewBits;
  254. //位图数据下一行起始指针
  255. pTemp += y * nOldWidthBytes;
  256. pNewTemp += y * nNewWidthBytes;
  257. switch( mGrayType )
  258. {
  259. case 0:
  260. for( x=0; x<pOldBIH->biWidth; x++ )
  261. {
  262. GETRGB555( ucRed, ucGreen, ucBlue, &pTemp[x*2] );
  263. //按亮度Y=0.3R+0.59G+0.11B将彩色图像转换为灰度图像
  264. dwGray = (ucRed * 30 + ucGreen * 59 +ucBlue * 11) / 100;
  265. //给新图像数据赋值
  266. pNewTemp[x] = (unsigned char)dwGray;
  267. }
  268. break;
  269. case 1:
  270. for( x=0; x<pOldBIH->biWidth; x++ )
  271. {
  272. GETRGB555( ucRed, ucGreen, ucBlue, &pTemp[x*2] );
  273. //按亮度Y=R将彩色图像转换为灰度图像
  274. dwGray = (ucRed * 30 + ucGreen * 59 +ucBlue * 11) / 100;
  275. //给新图像数据赋值
  276. pNewTemp[x] = (unsigned char)dwGray;
  277. }
  278. break;
  279. case 2:
  280. for( x=0; x<pOldBIH->biWidth; x++ )
  281. {
  282. GETRGB555( ucRed, ucGreen, ucBlue, &pTemp[x*2] );
  283. //按亮度Y=G将彩色图像转换为灰度图像
  284. dwGray = (ucRed * 30 + ucGreen * 59 +ucBlue * 11) / 100;
  285. //给新图像数据赋值
  286. pNewTemp[x] = (unsigned char)dwGray;
  287. }
  288. break;
  289. case 3:
  290. for( x=0; x<pOldBIH->biWidth; x++ )
  291. {
  292. GETRGB555( ucRed, ucGreen, ucBlue, &pTemp[x*2] );
  293. //按亮度Y=B将彩色图像转换为灰度图像
  294. dwGray = (ucRed * 30 + ucGreen * 59 +ucBlue * 11) / 100;
  295. //给新图像数据赋值
  296. pNewTemp[x] = (unsigned char)dwGray;
  297. }
  298. break;
  299. }
  300. }
  301. break;
  302. case 24: //24位真彩色图像
  303. for( y=0; y<pOldBIH->biHeight; y++ )
  304. {
  305. //位图数据起始指针
  306. pTemp = pOldBits;
  307. pNewTemp = pNewBits;
  308. //位图数据下一行起始指针
  309. pTemp += y * nOldWidthBytes;
  310. pNewTemp += y * nNewWidthBytes;
  311. switch( mGrayType )
  312. {
  313. case 0: //按亮度Y=0.3R+0.59G+0.11B将彩色图像转换为灰度图像
  314. for( x=0; x<pOldBIH->biWidth; x++ )
  315. {
  316. dwGray = ( (DWORD) pTemp[x*3+2] * 30 //红色
  317. +(DWORD) pTemp[x*3+1] * 59 //绿色
  318. +(DWORD) pTemp[x*3] * 11 //兰色
  319. ) / 100;
  320. //给新图像数据赋值
  321. pNewTemp[x] = (unsigned char)dwGray;
  322. }
  323. break;
  324. case 1: //按亮度Y=R将彩色图像转换为灰度图像
  325. for( x=0; x<pOldBIH->biWidth; x++ )
  326. {
  327. dwGray =  (DWORD) pTemp[x*3+2]; //红色
  328. //给新图像数据赋值
  329. pNewTemp[x] = (unsigned char)dwGray;
  330. }
  331. break;
  332. case 2: //按亮度Y=G将彩色图像转换为灰度图像
  333. for( x=0; x<pOldBIH->biWidth; x++ )
  334. {
  335. dwGray = (DWORD) pTemp[x*3+1] ; //绿色
  336. //给新图像数据赋值
  337. pNewTemp[x] = (unsigned char)dwGray;
  338. }
  339. break;
  340. case 3: //按亮度Y=B将彩色图像转换为灰度图像
  341. for( x=0; x<pOldBIH->biWidth; x++ )
  342. {
  343. dwGray =(DWORD) pTemp[x*3]; //兰色
  344. //给新图像数据赋值
  345. pNewTemp[x] = (unsigned char)dwGray;
  346. }
  347. break;
  348. }
  349. }
  350. break;
  351. case 32: //32位真彩色图像
  352. for( y=0; y<pOldBIH->biHeight; y++ )
  353. {
  354. //位图数据起始指针
  355. pTemp = pOldBits;
  356. pNewTemp = pNewBits;
  357. //位图数据下一行起始指针
  358. pTemp += y * nOldWidthBytes;
  359. pNewTemp += y * nNewWidthBytes;
  360. switch( mGrayType )
  361. {
  362. case 0:
  363. for( x=0; x<pOldBIH->biWidth; x++ )
  364. {
  365. //按亮度Y=0.3R+0.59G+0.11B将彩色图像转换为灰度图像
  366. dwGray = ( (DWORD) pTemp[x*4] * 30 //红色
  367. +(DWORD) pTemp[x*4+1] * 59 //绿色
  368. +(DWORD) pTemp[x*4+2] * 11 //兰色
  369. ) / 100;
  370. //给新图像数据赋值
  371. pNewTemp[x] = (unsigned char)dwGray;
  372. }
  373. break;
  374. case 1:
  375. for( x=0; x<pOldBIH->biWidth; x++ )
  376. {
  377. //按亮度Y=R将彩色图像转换为灰度图像
  378. dwGray =  (DWORD) pTemp[x*4];//红色
  379. //给新图像数据赋值
  380. pNewTemp[x] = (unsigned char)dwGray;
  381. }
  382. break;
  383. case 2:
  384. for( x=0; x<pOldBIH->biWidth; x++ )
  385. {
  386. //按亮度Y=G将彩色图像转换为灰度图像
  387. dwGray = (DWORD) pTemp[x*4+1] ; //绿色
  388. //给新图像数据赋值
  389. pNewTemp[x] = (unsigned char)dwGray;
  390. }
  391. break;
  392. case 3:
  393. for( x=0; x<pOldBIH->biWidth; x++ )
  394. {
  395. //按亮度Y=B将彩色图像转换为灰度图像
  396. dwGray =(DWORD) pTemp[x*4+2] ; //兰色
  397. //给新图像数据赋值
  398. pNewTemp[x] = (unsigned char)dwGray;
  399. }
  400. break;
  401. }
  402. }
  403. break;
  404. }
  406. ::GlobalUnlock( m_pDibObject->GetDib() );
  407. ::GlobalFree( m_pDibObject->GetDib() );
  408. ::GlobalUnlock( hGlobal );
  409. m_pDibObject->SetDib( hGlobal );
  411. m_pDibObject->ProcessImageHeader();
  413. m_pDibObject->m_nLastError = IMAGELIB_SUCCESS;
  415. return( TRUE );
  417. }
  419. void CPointPro::SetDibObjectClass( CDibObject *pDibObject )
  420. {
  421.    m_pDibObject = pDibObject;
  422. }
  423. ////////////////////////////////////////////////////////////////////////
  424. //int *CreateHistogram()   
  425. //----------------------------------------------------------------------
  426. //基本功能：本函数创建传入的CDibObject对象中图像的直方图。如果进行此调
  427. // 整之前没有指定一个CDibObject对象指针，则必须在调整时加以指
  428. // 定。任何未传入的坐标值或默认的-1坐标值都将被置为图像的最大值
  429. // 或最大植。变量nX1和nY1将被置为0，nX2将被置为图像宽度减1，nY2
  430. // 将被置为图像高度减1。想要在整个图像上进行操作时，最好的方法
  431. // 是不传入nX1、nY1、nX2和nY2值。这样它们会被默认为整个图像。
  432. //----------------------------------------------------------------------
  433. //参数说明：int nX1 默认为-1
  434. // int nY1 默认为-1
  435. // int nX2 默认为-1
  436. // int nY2 默认为-1
  437. // unsigned char *pData 图像位图数据指针
  438. // RGBQUAD *pPalette 图像调色板指针
  439. // int nWidthBytes 图像字节宽度
  440. // CDibObject *pDibObject 默认为NULL。
  441. //----------------------------------------------------------------------
  442. //返    回：直方图数组指针*pBuffer其中：
  443. // pBuffer[] 存储亮度直方图数据
  444. // pBuffer[256] 存储红色直方图数据
  445. // pBuffer[512] 存储绿色直方图数据
  446. // pBuffer[768] 存储蓝直方图数据
  447. //----------------------------------------------------------------------
  448. ////////////////////////////////////////////////////////////////////////
  450. int * CPointPro::CreateHistogram( int nX1, int nY1, int nX2, int nY2, 
  451.    unsigned char *pData, RGBQUAD *pPalette, 
  452.    int nWidthBytes, CDibObject *pDibObject )
  453. {
  454. //图像指针为空，无法操作返回
  455. if( pDibObject != NULL ) m_pDibObject = pDibObject;
  456. if( m_pDibObject == NULL ) return( FALSE );
  458. //分配直方图数据缓存区（数组）
  459. int *pBuffer = new int [256 * 4];
  460. //分配直方图数据缓存区失败
  461. if( pBuffer == NULL ) return( NULL );
  462. //直方图数据缓存区清零
  463. memset( pBuffer, 0, ( 256 * 4) * sizeof( int ) );
  465. //变量定义
  466. DWORD dwGray;
  467. int x, y;
  468. unsigned char *pTemp, ucRed, ucGreen, ucBlue;
  470. //图像的高度
  471. int nHeight = m_pDibObject->GetHeight();
  473. switch( m_pDibObject->GetNumBits() )
  474. {
  475. case 1: //每像素位数为1，不处理
  476. break;
  477. case 4: //每像素位数为4，不处理
  478. break;
  479. case 8: //每像素位数为8
  480. for( y = nY1; y <= nY2; y++ )
  481. {
  482. //数据指针定位到图像数据起始位置
  483. pTemp = pData;
  484. //数据指针定位到图像数据每行的起始零位置
  485. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  486. //数据指针定位到图像数据每行的起始nX1位置
  487. pTemp += nX1;
  488. for( x = nX1; x <= nX2; x++ )
  489. {
  490. //pTemp[x]为当前像素值，它为调色板项的索引值，
  491. //以此为索引，取出调色板项的相应红绿蓝分量值。
  492. ucRed   = pPalette[pTemp[x]].rgbRed;
  493. ucGreen = pPalette[pTemp[x]].rgbGreen;
  494. ucBlue  = pPalette[pTemp[x]].rgbBlue;
  496. //按关系L=0.3R+0.59G+0.11B，得到亮度值
  497. dwGray  = ( (DWORD) ucRed * 30 +
  498.         (DWORD) ucGreen * 59 +
  499.         (DWORD) ucBlue * 11 ) / 100;
  500. dwGray &= 0x000000ff;
  502. //亮度直方图数据
  503. pBuffer[dwGray]++;
  504. //红色直方图数据
  505. pBuffer[256 + ucRed]++;
  506. //绿色直方图数据
  507. pBuffer[512 + ucGreen]++;
  508. //蓝色直方图数据
  509. pBuffer[768 + ucBlue]++;
  511. }
  512. }
  513. break;
  514. case 16: //每像素位数为16
  515. for( y = nY1; y <= nY2; y++ )
  516. {
  517. //数据指针定位到图像数据起始位置
  518. pTemp = pData;
  519. //数据指针定位到图像数据每行的起始零位置
  520. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  521. //数据指针定位到图像数据每行的起始nX1位置
  522. pTemp += ( nX1 * 2 );
  523. for( x = nX1; x <= nX2; x++ )
  524. {
  525. //获取三原色分量
  526. GETRGB555( ucRed, ucGreen, ucBlue, pTemp );
  528. //按关系L=0.3R+0.59G+0.11B，得到亮度值
  529. dwGray = ( (DWORD) ucRed * 30 +
  530.        (DWORD) ucGreen * 59 +
  531.        (DWORD) ucBlue * 11 ) / 100;
  532. dwGray &= 0x000000ff;
  534. //亮度直方图数据
  535. pBuffer[dwGray]++;
  536. //红色直方图数据
  537. pBuffer[256 + ucRed]++;
  538. //绿色直方图数据
  539. pBuffer[512 + ucGreen]++;
  540. //蓝色直方图数据
  541. pBuffer[768 + ucBlue]++;
  543. //数据指针加2
  544. pTemp += 2;
  545. }
  546. }
  547. break;
  548. case 24: //每像素位数为24
  549. for( y = nY1; y < nY2; y++ )
  550. {
  551. //数据指针定位到图像数据起始位置
  552. pTemp = pData;
  553. //数据指针定位到图像数据每行的起始零位置
  554. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  555. //数据指针定位到图像数据每行的起始nX1位置
  556. pTemp += ( nX1 * 3 );
  558. for( x=nX1; x<=nX2; x++ )
  559. {
  560. //获取像素颜色的三原色。
  561. ucRed   = pTemp[x * 3 + 2];
  562. ucGreen = pTemp[x * 3 + 1];
  563. ucBlue  = pTemp[x * 3];
  565. //按关系L=0.3R+0.59G+0.11B，得到亮度值
  566. dwGray  = ( (DWORD) ucRed * 30 +
  567.         (DWORD) ucGreen * 59 +
  568.         (DWORD) ucBlue * 11 ) / 100;
  569. dwGray &= 0x000000ff;
  571. //亮度直方图数据
  572. pBuffer[dwGray]++;
  573. //红色直方图数据
  574. pBuffer[256 + ucRed]++;
  575. //绿色直方图数据
  576. pBuffer[512 + ucGreen]++;
  577. //蓝色直方图数据
  578. pBuffer[768 + ucBlue]++;
  580. //数据指针加3
  581. pTemp += 3;
  582. }
  583. }
  584. break;
  585. case 32: //每像素位数为24
  586. for( y = nY1; y <= nY2; y++ )
  587. {
  588. //数据指针定位到图像数据起始位置
  589. pTemp = pData;
  590. //数据指针定位到图像数据每行的起始零位置
  591. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  592. //数据指针定位到图像数据每行的起始nX1位置
  593. pTemp += ( nX1 * 4 );
  595. for( x = nX1; x <= nX2; x++ )
  596. {
  597. //获取像素颜色的三原色。
  598. GETRGB888( ucRed, ucGreen, ucBlue, pTemp );
  600. //按关系L=0.3R+0.59G+0.11B，得到亮度值
  601. dwGray = ( (DWORD) ucRed * 30 +
  602.        (DWORD) ucGreen * 59 +
  603.        (DWORD) ucBlue * 11 ) / 100;
  605. dwGray &= 0x000000ff;
  607. //亮度直方图数据
  608. pBuffer[dwGray]++;
  609. //红色直方图数据
  610. pBuffer[256 + ucRed]++;
  611. //绿色直方图数据
  612. pBuffer[512 + ucGreen]++;
  613. //蓝色直方图数据
  614. pBuffer[768 + ucBlue]++;
  616. pTemp += 4;
  617. }
  618. }
  619. break;
  620. }
  622. return( pBuffer );
  624. }
  628. ////////////////////////////////////////////////////////////////////////
  629. //BOOL IsGray256(CDibObject *pDibObject)
  630. //----------------------------------------------------------------------
  631. //基本功能：本函数判断传入的CDibObject对象中的图像是否为256级灰度图像。
  632. //----------------------------------------------------------------------
  633. //参数说明：CDibObject *pDibObject, 默认为NULL
  634. //----------------------------------------------------------------------
  635. //返回：BOOL：成功返回TRUE，失败返回FALSE。
  636. //----------------------------------------------------------------------
  637. ////////////////////////////////////////////////////////////////////////
  639. BOOL CPointPro::IsGray256( CDibObject *pDibObject )
  640. {
  641. //使用传入的CDibObject对象
  642. if( pDibObject != NULL ) m_pDibObject = pDibObject;
  643. //无CDibObject对象, 返回FALSE
  644. if( m_pDibObject == NULL ) return( FALSE );
  646. //不是8位图像，必不是256级灰度图像，不处理返回FALSE
  647. if( m_pDibObject->GetNumBits() != 8 ) return( FALSE );
  649. //定义变量
  650. unsigned char *pBuffer;
  651. RGBQUAD *pPalette;
  652. int nWidthBytes, i;
  654. //pBuffer: 获得位图数据指针
  655. pBuffer = (unsigned char *) m_pDibObject->GetDIBPointer( &nWidthBytes, 
  656. m_pDibObject->GetNumBits() );
  657. if( pBuffer == NULL ) return( FALSE );
  659. //pPalette：获得调色板数据地址
  660. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+
  661. sizeof(BITMAPINFOHEADER)];
  663. //检查是否为256色灰度调色板
  664. for( i=0; i<256; i++ )
  665. {
  666. if( pPalette[i].rgbRed != pPalette[i].rgbGreen 
  667. || pPalette[i].rgbRed != pPalette[i].rgbBlue
  668. || pPalette[i].rgbGreen != pPalette[i].rgbBlue )
  669. return( FALSE);
  670. }
  671. ::GlobalUnlock( m_pDibObject->GetDib() );
  673. return( TRUE );
  674. }
  675. ////////////////////////////////////////////////////////////////////////
  676. //BOOL ReplaceColorPal()
  677. //----------------------------------------------------------------------
  678. //基本功能：本函数对传入的CDibObject对象中的图像用指定的伪彩色编码表来
  679. // 替换图像的调试板。
  680. //----------------------------------------------------------------------
  681. //参数说明：CDibObject *pDibObject, 默认为NULL
  682. // BYTE * bpColorsTable - 伪彩色编码表
  683. //----------------------------------------------------------------------
  684. //返回：BOOL：成功返回TRUE，失败返回FALSE。
  685. //----------------------------------------------------------------------
  686. ////////////////////////////////////////////////////////////////////////
  688. BOOL CPointPro::ReplaceColorPal(CDibObject *pDibObject, 
  689.    BYTE *bpColorsTable)
  690. {
  691. //CDibObject对象指针
  692. if( pDibObject != NULL ) m_pDibObject = pDibObject;
  693. //若未指定 CDibObject 对象指针返回FALSE
  694. if( m_pDibObject == NULL ) return( FALSE );
  696. //定义变量
  697. unsigned char *pBuffer;
  698. BITMAPINFOHEADER *pBIH;
  699. RGBQUAD *pPalette;
  700. int nWidthBytes, nNumColors;
  702. //pBuffer: 获得位图数据指针
  703. pBuffer = (unsigned char *) m_pDibObject->GetDIBPointer( &nWidthBytes, 
  704. m_pDibObject->GetNumBits() );
  705. if( pBuffer == NULL ) return( FALSE );
  707. //pBIH：获得位图信息头地址
  708. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  709. //nNumColors：获得调色板中的颜色数。图像为16位色或更高时为0
  710. nNumColors = m_pDibObject->GetNumColors();
  711. //pPalette：获得调色板数据地址
  712. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  713. //pBits：获得位图数据地址
  715. // 读取伪彩色编码，更新DIB调色板
  716. for(int i=0; i<256; i++ )
  717. {
  718. // 更新DIB调色板红色分量
  719. pPalette[i].rgbRed = bpColorsTable[i * 4];
  720. // 更新DIB调色板绿色分量
  721. pPalette[i].rgbGreen = bpColorsTable[i * 4 + 1];
  722. // 更新DIB调色板蓝色分量
  723. pPalette[i].rgbBlue = bpColorsTable[i * 4 + 2];
  724. // 更新DIB调色板保留位
  725. pPalette[i].rgbReserved = 0;
  726. }
  727. ::GlobalUnlock( m_pDibObject->GetDib() );
  728. return(TRUE);
  729. }
  731. ////////////////////////////////////////////////////////////////////////
  732. //int *GetHistogram()   
  733. //----------------------------------------------------------------------
  734. //基本功能：本函数获得传入的CDibObject对象中图像的直方图。如果进行此调
  735. // 整之前没有指定一个CDibObject对象指针，则必须在调整时加以指
  736. // 定。任何未传入的坐标值或默认的-1坐标值都将被置为图像的最大值
  737. // 或最大植。变量nX1和nY1将被置为0，nX2将被置为图像宽度减1，nY2
  738. // 将被置为图像高度减1。想要在整个图像上进行操作时，最好的方法
  739. // 是不传入nX1、nY1、nX2和nY2值。这样它们会被默认为整个图像。
  740. //----------------------------------------------------------------------
  741. //参数说明：int nX1, 默认为-1
  742. // int nY1, 默认为-1
  743. // int nX2, 默认为-1
  744. // int nY2, 默认为-1
  745. // CDibObject *pDibObject, 默认为NULL。
  746. //----------------------------------------------------------------------
  747. //返    回：直方图数组指针*pBuffer其中：
  748. // nHistogramBuffer[] 存储亮度直方图数据
  749. // nHistogramBuffer[256] 存储红色直方图数据
  750. // nHistogramBuffer[512] 存储绿色直方图数据
  751. // nHistogramBuffer[768] 存储蓝直方图数据
  752. //----------------------------------------------------------------------
  753. ////////////////////////////////////////////////////////////////////////
  755. int * CPointPro::GetHistogram( int nX1, 
  756. int nY1,
  757. int nX2,
  758. int nY2,
  759. CDibObject *pDibObject)
  760. {
  761. //使用传入的CDibObject对象
  762. if( pDibObject != NULL ) m_pDibObject = pDibObject;
  763. //无CDibObject对象, 返回FALSE
  764. if( m_pDibObject == NULL ) return( FALSE );
  766. //坐标规整化
  767. m_pDibObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  769. //定义变量
  770. unsigned char *pBuffer, *pBits;
  771. RGBQUAD *pPalette;
  772. int nWidthBytes, nNumColors;
  774. //获得图像指针
  775. pBuffer = (unsigned char *) m_pDibObject->GetDIBPointer( &nWidthBytes, m_pDibObject->GetNumBits() );
  776. if( pBuffer == NULL ) return( NULL );
  778. //获得颜色数
  779. nNumColors = m_pDibObject->GetNumColors();
  780. //获得调色板指针
  781. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  782. //获得位图数据指针
  783. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  785. //创建直方图数据
  786. int *nHistogramBuffer = CreateHistogram( nX1, nY1, nX2, nY2, pBits, pPalette, nWidthBytes );
  788. ::GlobalUnlock( m_pDibObject->GetDib() );
  790. return( nHistogramBuffer );
  792. }
  793. ////////////////////////////////////////////////////////////////////////
  794. //BOOL SplitChannels()   
  795. //----------------------------------------------------------------------
  796. //基本功能：本函数将传入的CDibObject对象中的图像分离成由红、绿、蓝分量
  797. // 构成的256色灰度图像。
  798. //----------------------------------------------------------------------
  799. //参数说明：CDibObject *pRed 指向红色通道的图像指针
  800. // CDibObject *pGreen 指向绿色通道的图像指针
  801. // CDibObject *pBlue 指向蓝色通道的图像指针
  802. //----------------------------------------------------------------------
  803. //返    回：成功返回TRUE，失败返回FALSE。
  804. //----------------------------------------------------------------------
  805. ////////////////////////////////////////////////////////////////////////
  807. BOOL CPointPro::SplitChannels(CDibObject *pRed, 
  808.   CDibObject *pGreen, 
  809.   CDibObject *pBlue)
  810. {
  811. //没有传入相应指针无法完成操作
  812. if(m_pDibObject == NULL)
  813. {
  814. AfxMessageBox("没有传入原始图像，无法完成操作！");
  815. return FALSE;
  816. }
  818. if(pRed == NULL)
  819. {
  820. AfxMessageBox("没有传入红色通道指针，无法完成操作！");
  821. return FALSE;
  822. }
  824. if(pGreen == NULL)
  825. {
  826. AfxMessageBox("没有传入绿色通道指针，无法完成操作！");
  827. return FALSE;
  828. }
  830. if(pBlue == NULL)
  831. {
  832. AfxMessageBox("没有传入蓝色通道指针，无法完成操作！");
  833. return FALSE;
  834. }
  836. //已是256色灰度图像不用再转换
  837. if(IsGray256())
  838. {
  839. AfxMessageBox("已是256色灰度图像，不能进行通道分离！");
  840. return FALSE;
  841. }
  843. //红色通道
  844. MakeGray256(1, pRed);
  846. //绿色通道
  847. MakeGray256(2, pGreen);
  849. //蓝色通道
  850. MakeGray256(3, pBlue);
  853. return TRUE;
  854. }
  855. ////////////////////////////////////////////////////////////////////////
  856. //BOOL GetMixedChannel()   
  857. //----------------------------------------------------------------------
  858. //基本功能：本函数获得传入的CDibObject对象中的图像中的混合分量通道。
  859. //----------------------------------------------------------------------
  860. //参数说明：CDibObject *pMixed 指向混合通道的图像指针
  861. //----------------------------------------------------------------------
  862. //返    回：成功返回TRUE，失败返回FALSE。
  863. //----------------------------------------------------------------------
  864. ////////////////////////////////////////////////////////////////////////
  867. BOOL CPointPro::GetMixedChannel(CDibObject *pMixed)
  868. {
  869. //没有传入相应指针无法完成操作
  870. if(m_pDibObject == NULL)
  871. {
  872. AfxMessageBox("没有传入原始图像，无法完成操作！");
  873. return FALSE;
  874. }
  876. if(pMixed == NULL)
  877. {
  878. AfxMessageBox("没有传入通道指针，无法完成操作！");
  879. return FALSE;
  880. }
  882. //已是256色灰度图像不用再转换
  883. if(IsGray256())
  884. {
  885. AfxMessageBox("已是256色灰度图像，不能进行通道分离！");
  886. return FALSE;
  887. }
  889. MakeGray256(0, pMixed);
  891. return TRUE;
  892. }
  893. ////////////////////////////////////////////////////////////////////////
  894. //BOOL GetRedChannel()   
  895. //----------------------------------------------------------------------
  896. //基本功能：本函数获得传入的CDibObject对象中的图像中的红色分量通道。
  897. //----------------------------------------------------------------------
  898. //参数说明：CDibObject *pRed 指向红色通道的图像指针
  899. //----------------------------------------------------------------------
  900. //返    回：成功返回TRUE，失败返回FALSE。
  901. //----------------------------------------------------------------------
  902. ////////////////////////////////////////////////////////////////////////
  904. BOOL CPointPro::GetRedChannel(CDibObject *pRed)
  905. {
  906. //没有传入相应指针无法完成操作
  907. if(m_pDibObject == NULL)
  908. {
  909. AfxMessageBox("没有传入原始图像，无法完成操作！");
  910. return FALSE;
  911. }
  913. if(pRed == NULL)
  914. {
  915. AfxMessageBox("没有传入红色通道指针，无法完成操作！");
  916. return FALSE;
  917. }
  919. //已是256色灰度图像不用再转换
  920. if(IsGray256())
  921. {
  922. AfxMessageBox("已是256色灰度图像，不能进行通道分离！");
  923. return FALSE;
  924. }
  926. //红色通道
  927. MakeGray256(1, pRed);
  929. return TRUE;
  930. }
  931. ////////////////////////////////////////////////////////////////////////
  932. //BOOL GetGreenChannel()   
  933. //----------------------------------------------------------------------
  934. //基本功能：本函数获得传入的CDibObject对象中的图像中的绿色分量通道。
  935. //----------------------------------------------------------------------
  936. //参数说明：CDibObject *pGreen 指向混合通道的图像指针
  937. //----------------------------------------------------------------------
  938. //返    回：成功返回TRUE，失败返回FALSE。
  939. //----------------------------------------------------------------------
  940. ////////////////////////////////////////////////////////////////////////
  942. BOOL CPointPro::GetGreenChannel(CDibObject *pGreen)
  943. {
  944. //没有传入相应指针无法完成操作
  945. if(m_pDibObject == NULL)
  946. {
  947. AfxMessageBox("没有传入原始图像，无法完成操作！");
  948. return FALSE;
  949. }
  951. if(pGreen == NULL)
  952. {
  953. AfxMessageBox("没有传入通道指针，无法完成操作！");
  954. return FALSE;
  955. }
  957. //已是256色灰度图像不用再转换
  958. if(IsGray256())
  959. {
  960. AfxMessageBox("已是256色灰度图像，不能进行通道分离！");
  961. return FALSE;
  962. }
  964. MakeGray256(2, pGreen);
  966. return TRUE;
  967. }
  968. ////////////////////////////////////////////////////////////////////////
  969. //BOOL GetBlueChannel()   
  970. //----------------------------------------------------------------------
  971. //基本功能：本函数获得传入的CDibObject对象中的图像中的蓝色分量通道。
  972. //----------------------------------------------------------------------
  973. //参数说明：CDibObject *pBlue 指向蓝色通道的图像指针
  974. //----------------------------------------------------------------------
  975. //返    回：成功返回TRUE，失败返回FALSE。
  976. //----------------------------------------------------------------------
  977. ////////////////////////////////////////////////////////////////////////
  979. BOOL CPointPro::GetBlueChannel(CDibObject *pBlue)
  980. {
  981. //没有传入相应指针无法完成操作
  982. if(m_pDibObject == NULL)
  983. {
  984. AfxMessageBox("没有传入原始图像，无法完成操作！");
  985. return FALSE;
  986. }
  988. if(pBlue == NULL)
  989. {
  990. AfxMessageBox("没有传入通道指针，无法完成操作！");
  991. return FALSE;
  992. }
  994. //已是256色灰度图像不用再转换
  995. if(IsGray256())
  996. {
  997. AfxMessageBox("已是256色灰度图像，不能进行通道分离！");
  998. return FALSE;
  999. }
  1001. MakeGray256(3, pBlue);
  1003. return TRUE;
  1004. }
  1005. ////////////////////////////////////////////////////////////////////////
  1006. //BOOL CombineChannels()   
  1007. //----------------------------------------------------------------------
  1008. //基本功能：本函数将传入的由红、绿、蓝分量构成的256色灰度图像合成为采色图
  1009. // 像。
  1010. //----------------------------------------------------------------------
  1011. //参数说明：CDibObject *pRed 指向红色通道的图像指针
  1012. // CDibObject *pGreen 指向绿色通道的图像指针
  1013. // CDibObject *pBlue 指向蓝色通道的图像指针
  1014. //----------------------------------------------------------------------
  1015. //返    回：成功返回TRUE，失败返回FALSE。
  1016. //----------------------------------------------------------------------
  1017. ////////////////////////////////////////////////////////////////////////
  1019. BOOL CPointPro::CombineChannels(CDibObject *pRed, 
  1020. CDibObject *pGreen, 
  1021. CDibObject *pBlue)
  1022. {
  1023. //没有传入相应指针无法完成操作
  1024. if(m_pDibObject == NULL)
  1025. {
  1026. AfxMessageBox("没有传入创建新图像，无法完成操作！");
  1027. return FALSE;
  1028. }
  1030. if(pRed == NULL)
  1031. {
  1032. AfxMessageBox("没有传入红色通道指针，无法完成操作！");
  1033. return FALSE;
  1034. }
  1036. if(pGreen == NULL)
  1037. {
  1038. AfxMessageBox("没有传入绿色通道指针，无法完成操作！");
  1039. return FALSE;
  1040. }
  1042. if(pBlue == NULL)
  1043. {
  1044. AfxMessageBox("没有传入蓝色通道指针，无法完成操作！");
  1045. return FALSE;
  1046. }
  1048. //传入的图像不符合需要的格式，无法完成操作
  1049. if(pRed->GetNumBits() != 8)
  1050. {
  1051. AfxMessageBox("传入的红色通道不是8位图像，无法完成操作！");
  1052. return FALSE;
  1053. }
  1055. if(pGreen->GetNumBits() != 8)
  1056. {
  1057. AfxMessageBox("传入的绿色通道不是8位图像，无法完成操作！");
  1058. return FALSE;
  1059. }
  1061. if(pBlue->GetNumBits() != 8)
  1062. {
  1063. AfxMessageBox("传入的蓝色通道不是8位图像，无法完成操作！");
  1064. return FALSE;
  1065. }
  1067. //创建的图像不是24位图像将其转换为24位图像
  1068. if(m_pDibObject->GetNumBits() != 24)
  1069. {
  1070. m_pDibObject->ChangeFormat(24);
  1071. }
  1073. //获得各个图像的大小
  1074. int nCombineWidth, nRedWidth, nGreenWidth, nBlueWidth;
  1075. int nCombineHeight, nRedHeight, nGreenHeight, nBlueHeight;
  1077. //合并后图像的大小
  1078. nCombineWidth = m_pDibObject->GetWidth();
  1079. nCombineHeight = m_pDibObject->GetHeight();
  1081. //红色通道图像大小
  1082. nRedWidth = pRed->GetWidth();
  1083. nRedHeight = pRed->GetHeight();
  1085. //绿色通道图像大小
  1086. nGreenWidth = pGreen->GetWidth();
  1087. nGreenHeight = pGreen->GetHeight();
  1089. //蓝色通道图像大小
  1090. nBlueWidth = pBlue->GetWidth();
  1091. nBlueHeight = pBlue->GetHeight();
  1093. CRect rectCombine(0, 0, nCombineWidth, nCombineHeight);
  1094. CRect rectRed(0, 0, nRedWidth, nRedHeight);
  1095. CRect rectGreen(0, 0, nGreenWidth, nGreenHeight);
  1096. CRect rectBlue(0, 0, nBlueWidth, nBlueHeight);
  1098. //所有图像的大小应一致
  1099. if (rectCombine != rectRed 
  1100. || rectRed != rectGreen 
  1101. || rectGreen != rectBlue 
  1102. || rectBlue != rectCombine)
  1103. {
  1104. AfxMessageBox("各个通道大小不一致，无法完成操作！");
  1105. return FALSE;
  1106. }
  1108. //获取各个通道原图像字节宽度
  1109. int nCombineWidthBytes, nRedWidthBytes, nGreenWidthBytes, nBlueWidthBytes;
  1111. //合并的图像的字节宽度
  1112. char *pCombineBuffer = (char *) m_pDibObject->GetDIBPointer(&nCombineWidthBytes);
  1113. if( pCombineBuffer == NULL ) return( FALSE );
  1115. //红色通道的图像的字节宽度
  1116. char *pRedBuffer = (char *) pRed->GetDIBPointer(&nRedWidthBytes);
  1117. if( pRedBuffer == NULL ) return( FALSE );
  1119. //绿色通道的图像的字节宽度
  1120. char *pGreenBuffer = (char *) pGreen->GetDIBPointer(&nGreenWidthBytes);
  1121. if( pGreenBuffer == NULL ) return( FALSE );
  1123. //蓝色通道的图像的字节宽度
  1124. char *pBlueBuffer = (char *) pBlue->GetDIBPointer(&nBlueWidthBytes);
  1125. if( pBlueBuffer == NULL ) return( FALSE );
  1127. //定义变量
  1128. BITMAPINFOHEADER *pCombineBIH, *pRedBIH, *pGreenBIH, *pBlueBIH;
  1129. BITMAPFILEHEADER *pCombineBFH, *pRedBFH, *pGreenBFH, *pBlueBFH;
  1130. RGBQUAD *pCombineRGBPalette, *pRedRGBPalette, *pGreenRGBPalette, *pBlueRGBPalette;
  1131. unsigned char *pCombineBits, *pRedBits, *pGreenBits, *pBlueBits;
  1132. unsigned char *pCombineTemp, *pRedTemp, *pGreenTemp, *pBlueTemp;
  1133. int nCombineNumColors, nRedNumColors, nGreenNumColors, nBlueNumColors;
  1135. //合并后的图像信息
  1136. //获取文件头指针
  1137. pCombineBFH = (BITMAPFILEHEADER *) pCombineBuffer;
  1138. //获取信息头指针
  1139. pCombineBIH = (BITMAPINFOHEADER *) &pCombineBuffer[sizeof(BITMAPFILEHEADER)];
  1140. //获取调色板指针
  1141. pCombineRGBPalette = (RGBQUAD *) &pCombineBuffer[sizeof(BITMAPFILEHEADER)+
  1142. sizeof(BITMAPINFOHEADER)];
  1143. //图像颜色数
  1144. nCombineNumColors = m_pDibObject->GetNumColors();
  1145. //获取原图像数据指针
  1146. pCombineBits = (unsigned char *) &pCombineBuffer[sizeof(BITMAPFILEHEADER)
  1147. +sizeof(BITMAPINFOHEADER)+nCombineNumColors*sizeof(RGBQUAD)];
  1149. //红色通道的图像信息
  1150. //获取文件头指针
  1151. pRedBFH = (BITMAPFILEHEADER *) pRedBuffer;
  1152. //获取信息头指针
  1153. pRedBIH = (BITMAPINFOHEADER *) &pRedBuffer[sizeof(BITMAPFILEHEADER)];
  1154. //获取调色板指针
  1155. pRedRGBPalette = (RGBQUAD *) &pRedBuffer[sizeof(BITMAPFILEHEADER)+
  1156. sizeof(BITMAPINFOHEADER)];
  1157. //图像颜色数
  1158. nRedNumColors = pRed->GetNumColors();
  1159. //获取原图像数据指针
  1160. pRedBits = (unsigned char *) &pRedBuffer[sizeof(BITMAPFILEHEADER)
  1161. +sizeof(BITMAPINFOHEADER)+nRedNumColors*sizeof(RGBQUAD)];
  1163. //绿色通道的图像信息
  1164. //获取文件头指针
  1165. pGreenBFH = (BITMAPFILEHEADER *) pGreenBuffer;
  1166. //获取信息头指针
  1167. pGreenBIH = (BITMAPINFOHEADER *) &pGreenBuffer[sizeof(BITMAPFILEHEADER)];
  1168. //获取调色板指针
  1169. pGreenRGBPalette = (RGBQUAD *) &pGreenBuffer[sizeof(BITMAPFILEHEADER)+
  1170. sizeof(BITMAPINFOHEADER)];
  1171. //图像颜色数
  1172. nGreenNumColors = pGreen->GetNumColors();
  1173. //获取原图像数据指针
  1174. pGreenBits = (unsigned char *) &pGreenBuffer[sizeof(BITMAPFILEHEADER)
  1175. +sizeof(BITMAPINFOHEADER)+nGreenNumColors*sizeof(RGBQUAD)];
  1177. //蓝色通道的图像信息
  1178. //获取文件头指针
  1179. pBlueBFH = (BITMAPFILEHEADER *) pBlueBuffer;
  1180. //获取信息头指针
  1181. pBlueBIH = (BITMAPINFOHEADER *) &pBlueBuffer[sizeof(BITMAPFILEHEADER)];
  1182. //获取调色板指针
  1183. pBlueRGBPalette = (RGBQUAD *) &pBlueBuffer[sizeof(BITMAPFILEHEADER)+
  1184. sizeof(BITMAPINFOHEADER)];
  1185. //图像颜色数
  1186. nBlueNumColors = pBlue->GetNumColors();
  1187. //获取原图像数据指针
  1188. pBlueBits = (unsigned char *) &pBlueBuffer[sizeof(BITMAPFILEHEADER)
  1189. +sizeof(BITMAPINFOHEADER)+nBlueNumColors*sizeof(RGBQUAD)];
  1191. //循环变量定义
  1192. int x, y;
  1194. //行位置
  1195. for(y = 0; y < nCombineHeight; y++ )
  1196. {
  1197. //合并后的图像数据指针定位到起始位置
  1198. pCombineTemp = pCombineBits;
  1199. //合并后的图像数据指针定位到图像数据每行的起始零位置
  1200. pCombineTemp += y * nCombineWidthBytes;
  1202. //红色通道图像数据指针定位到起始位置
  1203. pRedTemp = pRedBits;
  1204. //红色通道图像数据指针定位到图像数据每行的起始零位置
  1205. pRedTemp += y * nRedWidthBytes;
  1207. //绿色通道图像数据指针定位到起始位置
  1208. pGreenTemp = pGreenBits;
  1209. //绿色通道图像数据指针定位到图像数据每行的起始零位置
  1210. pGreenTemp += y * nGreenWidthBytes;
  1212. //蓝色通道图像数据指针定位到起始位置
  1213. pBlueTemp = pBlueBits;
  1214. //蓝色通道图像数据指针定位到图像数据每行的起始零位置
  1215. pBlueTemp += y * nBlueWidthBytes;
  1217. //CString s, message = "";
  1219. //列位置
  1220. for(x = 0; x < nCombineWidth; x++)
  1221. {
  1222. //进行合并操作
  1223. pCombineTemp[2] = *pRedTemp;
  1224. pCombineTemp[1] = *pGreenTemp;
  1225. pCombineTemp[0] = *pBlueTemp;
  1227. //调整图像数据指针
  1228. pCombineTemp += 3;
  1229. pRedTemp++;
  1230. pGreenTemp++;
  1231. pBlueTemp++;
  1232. }
  1233. }
  1238. return TRUE;
  1239. }