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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
IMAGEAREAPROCESSES.CPP
资源名称：vc图像处理比较全面的程序.rar　[点击查看]
上传用户：alisonmail
上传日期：2013-02-28
资源大小：500k
文件大小：56k
源码类别：

图片显示

开发平台：

Visual C++

IMAGEAREAPROCESSES.CPP：源码内容
  1. // ImageAreaProcesses.cpp
  3. #include "stdafx.h"
  4. #include "ImageAreaProcesses.h"
  6. #define MAX( a, b ) ( a > b ? a : b )
  8. /**************************************************************************
  9. *                                                                         *
  10. *                                Area Processes                           *
  11. *                                                                         *
  12. **************************************************************************/
  14. CImageAreaProcesses::CImageAreaProcesses()
  15. {
  16. }
  18. CImageAreaProcesses::CImageAreaProcesses( CImageObject *pImageObject )
  19. {
  21. m_pImageObject = pImageObject;
  23. }
  25. BOOL CImageAreaProcesses::MedianFilter( int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  26. {
  28. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  29. if( m_pImageObject == NULL ) return( FALSE );
  31. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  33. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  35. int nWidth = m_pImageObject->GetWidth();
  36. int nHeight = m_pImageObject->GetHeight();
  37. if( nX1 < 2 ) nX1 = 2;
  38. if( nY1 < 2 ) nY1 = 2;
  39. if( nX2 >= nWidth - 2 ) nX2 = nWidth - 2;
  40. if( nY2 >= nHeight - 2 ) nY2 = nHeight - 2;
  42. DWORD dwMedianList[9];
  43. int nLoc[9];
  44. unsigned char Data;
  46. unsigned char *pOldBuffer, *pNewBuffer, *pOldBits, *pNewBits, *pOldTemp, *pNewTemp;
  47. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  48. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  49. RGBQUAD *pOldPalette, *pNewPalette;
  50. int nWidthBytes, nNumColors, x, y, i, j, k, l;
  52. pOldBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  53. if( pOldBuffer == NULL ) return( FALSE );
  55. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  56. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  57. nNumColors = m_pImageObject->GetNumColors();
  58. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  59. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  61. DWORD dwNewSize;
  62. HGLOBAL hNewDib;
  64. dwNewSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumColors * sizeof( RGBQUAD ) + nWidthBytes * m_pImageObject->GetHeight();
  65. hNewDib = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewSize );
  66. if( hNewDib == NULL ){
  67. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  68. ::GlobalUnlock( m_pImageObject->GetDib() );
  69. return( FALSE );
  70. }
  72. pNewBuffer = (unsigned char *) ::GlobalLock( hNewDib );
  73. if( pNewBuffer == NULL ){
  74. ::GlobalFree( hNewDib );
  75. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  76. ::GlobalUnlock( m_pImageObject->GetDib() );
  77. return( FALSE );
  78. }
  80. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  81. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  82. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  83. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  85. *pNewBFH = *pOldBFH;
  86. *pNewBIH = *pOldBIH;
  87. for( i=0; i<nNumColors; i++ ) pNewPalette[i] = pOldPalette[i];
  89. memcpy( pNewBits, pOldBits, nWidthBytes * nHeight );
  91. unsigned char ucRed, ucGreen, ucBlue;
  93. switch( m_pImageObject->GetNumBits() ){
  94. case 8:
  95. for( y=nY1; y<=nY2; y++ ){
  96. pOldTemp = pOldBits;
  97. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  98. pOldTemp += ( nX1 - 1 );
  99. pNewTemp = pNewBits;
  100. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  101. pNewTemp += nX1;
  102. l = 0;
  103. for( x=nX1; x<=nX2; x++ ){
  105. // List all pixel gray values in the 3x3 area
  106. for( i=0; i<3; i++ ){
  107. Data = pOldTemp[i+l];
  108. dwMedianList[i] = ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  109. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  110. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100;
  111. nLoc[i] = ( i + l );
  112. }
  113. for( i=0; i<3; i++ ){
  114. Data = pOldTemp[i+l+nWidthBytes];
  115. dwMedianList[i+3] = ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  116. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  117. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100;
  118. nLoc[i+3] = ( i + l ) + nWidthBytes;
  119. }
  120. for( i=0; i<3; i++ ){
  121. Data = pOldTemp[i+l+nWidthBytes*2];
  122. dwMedianList[i+6] = ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  123. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  124. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100;
  125. nLoc[i+6] = ( i + l ) + nWidthBytes * 2;
  126. }
  128. // Sort the list;
  129. for( i=1; i<9; i++ ){
  130. for( j=0; j<i; j++ ){
  131. if( dwMedianList[i] < dwMedianList[j] ){
  132. DWORD dwTmp;
  133. int nTmp;
  134. dwTmp = dwMedianList[i];
  135. nTmp = nLoc[i];
  136. for( k=i; k>j; k-- ){
  137. dwMedianList[k] = dwMedianList[k-1];
  138. nLoc[k] = nLoc[k-1];
  139. }
  140. dwMedianList[j] = dwTmp;
  141. nLoc[j] = nTmp;
  142. break;
  143. }
  144. }
  145. }
  147. // Get the median RGB values and store them
  148. Data = pOldTemp[nLoc[4]];
  149. *pNewTemp++ = (unsigned char) m_pImageObject->GetNearestIndex( pNewPalette[Data].rgbRed, pNewPalette[Data].rgbGreen, pNewPalette[Data].rgbBlue, pNewPalette, nNumColors );
  151. l++;
  152. }
  153. }
  154. break;
  155. case 16:
  156. for( y=nY1; y<=nY2; y++ ){
  157. pOldTemp = pOldBits;
  158. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  159. pOldTemp += ( ( nX1 - 1 ) * 2 );
  160. pNewTemp = pNewBits;
  161. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  162. pNewTemp += ( nX1 * 2 );
  163. l = 0;
  164. for( x=nX1; x<=nX2; x++ ){
  166. // List all pixel gray values in the 3x3 area
  167. for( i=0; i<3; i++ ){
  168. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*2] ); 
  169. dwMedianList[i] = ( (DWORD) ucRed * 30 +
  170. (DWORD) ucGreen * 59 +
  171. (DWORD) ucBlue * 11 ) / 100;
  172. nLoc[i] = ( i + l ) * 2;
  173. }
  174. for( i=0; i<3; i++ ){
  175. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*2] );
  176. dwMedianList[i+3] = ( (DWORD) ucRed * 30 +
  177. (DWORD) ucGreen * 59 +
  178. (DWORD) ucBlue * 11 ) / 100;
  179. nLoc[i+3] = ( i + l ) * 2 + nWidthBytes;
  180. }
  181. for( i=0; i<3; i++ ){
  182. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*2] );
  183. dwMedianList[i+6] = ( (DWORD) ucRed * 30 +
  184. (DWORD) ucGreen * 59 +
  185. (DWORD) ucBlue * 11 ) / 100;
  186. nLoc[i+6] = ( i + l ) * 2 + nWidthBytes * 2;
  187. }
  189. // Sort the list;
  190. for( i=1; i<9; i++ ){
  191. for( j=0; j<i; j++ ){
  192. if( dwMedianList[i] < dwMedianList[j] ){
  193. DWORD dwTmp;
  194. int nTmp;
  195. dwTmp = dwMedianList[i];
  196. nTmp = nLoc[i];
  197. for( k=i; k>j; k-- ){
  198. dwMedianList[k] = dwMedianList[k-1];
  199. nLoc[k] = nLoc[k-1];
  200. }
  201. dwMedianList[j] = dwTmp;
  202. nLoc[j] = nTmp;
  203. break;
  204. }
  205. }
  206. }
  208. // Get the median RGB values and store them
  209. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nLoc[4]] );
  210. PUTRGB555( ucRed, ucGreen, ucBlue, pNewTemp );
  211. pNewTemp += 2;
  213. l++;
  214. }
  215. }
  216. break;
  217. case 24:
  218. for( y=nY1; y<=nY2; y++ ){
  219. pOldTemp = pOldBits;
  220. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  221. pOldTemp += ( ( nX1 - 1 ) * 3 );
  222. pNewTemp = pNewBits;
  223. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  224. pNewTemp += ( nX1 * 3 );
  225. l = 0;
  226. for( x=nX1; x<=nX2; x++ ){
  228. // List all pixel gray values in the 3x3 area
  229. for( i=0; i<3; i++ ){
  230. dwMedianList[i] = ( (DWORD) pOldTemp[(i+l)*3+2] * 30 +
  231. (DWORD) pOldTemp[(i+l)*3+1] * 59 +
  232. (DWORD) pOldTemp[(i+l)*3] * 11 ) / 100;
  233. nLoc[i] = ( i + l ) * 3;
  234. }
  235. for( i=0; i<3; i++ ){
  236. dwMedianList[i+3] = ( (DWORD) pOldTemp[nWidthBytes+(i+l)*3+2] * 30 +
  237. (DWORD) pOldTemp[nWidthBytes+(i+l)*3+1] * 59 +
  238. (DWORD) pOldTemp[nWidthBytes+(i+l)*3] * 11 ) / 100;
  239. nLoc[i+3] = ( i + l ) * 3 + nWidthBytes;
  240. }
  241. for( i=0; i<3; i++ ){
  242. dwMedianList[i+6] = ( (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+2] * 30 +
  243. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+1] * 59 +
  244. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3] * 11 ) / 100;
  245. nLoc[i+6] = ( i + l ) * 3 + nWidthBytes * 2;
  246. }
  248. // Sort the list;
  249. for( i=1; i<9; i++ ){
  250. for( j=0; j<i; j++ ){
  251. if( dwMedianList[i] < dwMedianList[j] ){
  252. DWORD dwTmp;
  253. int nTmp;
  254. dwTmp = dwMedianList[i];
  255. nTmp = nLoc[i];
  256. for( k=i; k>j; k-- ){
  257. dwMedianList[k] = dwMedianList[k-1];
  258. nLoc[k] = nLoc[k-1];
  259. }
  260. dwMedianList[j] = dwTmp;
  261. nLoc[j] = nTmp;
  262. break;
  263. }
  264. }
  265. }
  267. // Get the median RGB values and store them
  268. *pNewTemp++ = pOldTemp[nLoc[4]];
  269. *pNewTemp++ = pOldTemp[nLoc[4]+1];
  270. *pNewTemp++ = pOldTemp[nLoc[4]+2];
  272. l++;
  273. }
  274. }
  275. break;
  276. case 32:
  277. for( y=nY1; y<=nY2; y++ ){
  278. pOldTemp = pOldBits;
  279. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  280. pOldTemp += ( ( nX1 - 1 ) * 4 );
  281. pNewTemp = pNewBits;
  282. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  283. pNewTemp += ( nX1 * 4 );
  284. l = 0;
  285. for( x=nX1; x<=nX2; x++ ){
  287. // List all pixel gray values in the 3x3 area
  288. for( i=0; i<3; i++ ){
  289. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*4] ); 
  290. dwMedianList[i] = ( (DWORD) ucRed * 30 +
  291. (DWORD) ucGreen * 59 +
  292. (DWORD) ucBlue * 11 ) / 100;
  293. nLoc[i] = ( i + l ) * 4;
  294. }
  295. for( i=0; i<3; i++ ){
  296. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*4] ); 
  297. dwMedianList[i+3] = ( (DWORD) ucRed * 30 +
  298. (DWORD) ucGreen * 59 +
  299. (DWORD) ucBlue * 11 ) / 100;
  300. nLoc[i+3] = ( i + l ) * 4 + nWidthBytes;
  301. }
  302. for( i=0; i<3; i++ ){
  303. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*4] ); 
  304. dwMedianList[i+6] = ( (DWORD) ucRed * 30 +
  305. (DWORD) ucGreen * 59 +
  306. (DWORD) ucBlue * 11 ) / 100;
  307. nLoc[i+6] = ( i + l ) * 4 + nWidthBytes * 2;
  308. }
  310. // Sort the list;
  311. for( i=1; i<9; i++ ){
  312. for( j=0; j<i; j++ ){
  313. if( dwMedianList[i] < dwMedianList[j] ){
  314. DWORD dwTmp;
  315. int nTmp;
  316. dwTmp = dwMedianList[i];
  317. nTmp = nLoc[i];
  318. for( k=i; k>j; k-- ){
  319. dwMedianList[k] = dwMedianList[k-1];
  320. nLoc[k] = nLoc[k-1];
  321. }
  322. dwMedianList[j] = dwTmp;
  323. nLoc[j] = nTmp;
  324. break;
  325. }
  326. }
  327. }
  329. // Get the median RGB values and store them
  330. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nLoc[4]] );
  331. PUTRGB888( ucRed, ucGreen, ucBlue, pNewTemp );
  332. pNewTemp += 4;
  334. l++;
  335. }
  336. }
  337. break;
  339. }
  341. ::GlobalUnlock( m_pImageObject->GetDib() );
  342. ::GlobalFree( m_pImageObject->GetDib() );
  343. ::GlobalUnlock( hNewDib );
  344. m_pImageObject->SetDib( hNewDib );
  346. return( TRUE );
  348. }
  350. BOOL CImageAreaProcesses::ChangeContrast( int nContrast, int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  351. {
  353. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  354. if( m_pImageObject == NULL ) return( FALSE );
  356. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  358. if( nContrast == 100 ) return( TRUE );
  360. return( EqualizeContrast( nX1, nY1, nX2, nY2, nContrast ) );
  362. }
  364. BOOL CImageAreaProcesses::EqualizeContrast( int nX1, int nY1, int nX2, int nY2, int nThresholdFactor, CImageObject *pImageObject )
  365. {
  367. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  368. if( m_pImageObject == NULL ) return( FALSE );
  370. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  372. int nDestMin = 0;
  373. int nDestMax = 255;
  375. BOOL bLessThanHalf, bCompleteImage;
  376. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2, &bCompleteImage, &bLessThanHalf );
  378. unsigned char *pBuffer, *pBits, *pTemp;
  379. RGBQUAD *pPalette;
  380. int nWidthBytes, nNumColors;
  382. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  383. if( pBuffer == NULL ) return( FALSE );
  385. nNumColors = m_pImageObject->GetNumColors();
  386. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  387. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  389. int *pnHistogramBuffer;
  390. pnHistogramBuffer = CreateHistogram( nX1, nY1, nX2, nY2, pBits, pPalette, nWidthBytes );
  391. if( pnHistogramBuffer == NULL ){
  392. ::GlobalUnlock( m_pImageObject->GetDib() );
  393. return( FALSE );
  394. }
  396. int x, y, nTemp, i;
  397. int nMinIndex = pnHistogramBuffer[256*4+2];
  398. int nMaxIndex = pnHistogramBuffer[256*4+3];
  399. int nNumSteps;
  400. int nThreshold = pnHistogramBuffer[256*4+1];
  401. if( nMinIndex >= 253 && nMaxIndex <= 2 ){
  402. ::GlobalUnlock( m_pImageObject->GetDib() );
  403. return( FALSE );
  404. }
  406. nNumSteps = nMaxIndex - nMinIndex + 1;
  408. if( nThresholdFactor != -1 ){
  409. nDestMin = ( nMinIndex * ( 200 - nThresholdFactor ) ) / 100;
  410. if( nDestMin > 255 ) nDestMin = 255;
  411. nDestMax = 255 - ( ( ( 255 - nMaxIndex ) * ( 200 - nThresholdFactor ) ) / 100 );
  412. if( nDestMax < 0 ) nDestMax = 0;
  413. while( nDestMin > nDestMax ) nDestMin--, nDestMax++;
  414. if( nDestMin > 255 ) nDestMin = 255;
  415. if( nDestMax < 0 ) nDestMax = 0;
  416. }
  418. double dStep = 256.0 / (double) nNumSteps;
  419. double dDestStep = (double) ( nDestMax - nDestMin + 1 ) / 256.0;
  420. double result;
  421. unsigned char ucRed, ucGreen, ucBlue, ucData;
  423. DWORD dwGray, dwNewGray;
  425. CPalette *_pPalette = m_pImageObject->GetPalette();
  427. RGBQUAD OldPalette[256];
  428. for( i=0; i<256; i++ ) memset( &OldPalette[i], 0, sizeof( RGBQUAD ) );
  429. for( i=0; i<nNumColors; i++ ) OldPalette[i] = pPalette[i];
  430. if( m_pImageObject->GetNumBits() <= 8 && ( bCompleteImage || !bLessThanHalf ) ){
  431. for( i=0; i<nNumColors; i++ ){
  432. OldPalette[i] = pPalette[i];
  433. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  434. (DWORD) pPalette[i].rgbGreen * 59 +
  435. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  436. if( dwGray <= (DWORD) nThreshold ) pPalette[i].rgbRed = pPalette[i].rgbGreen = pPalette[i].rgbBlue = 0;
  437. else{
  438. nTemp = (int) dwGray - nMinIndex;
  439. if( nTemp < 0 ) nTemp = 0;
  440. result = (double) nTemp;
  441. result *= dStep;
  442. result += (double) nDestMin;
  443. result *= dDestStep;
  444. dwNewGray = (DWORD) result;
  445. if( dwNewGray > 255 ) dwNewGray = 255;
  446. if( dwNewGray > dwGray ){
  447. do{
  448. if( pPalette[i].rgbRed < 255 ) pPalette[i].rgbRed++;
  449. if( pPalette[i].rgbGreen < 255 ) pPalette[i].rgbGreen++;
  450. if( pPalette[i].rgbBlue < 255 ) pPalette[i].rgbBlue++;
  451. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  452. (DWORD) pPalette[i].rgbGreen * 59 +
  453. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  454. } while( dwGray < dwNewGray );
  455. }
  456. else if( dwNewGray < dwGray ){
  457. do{
  458. if( pPalette[i].rgbRed > 0 ) pPalette[i].rgbRed--;
  459. if( pPalette[i].rgbGreen > 0 ) pPalette[i].rgbGreen--;
  460. if( pPalette[i].rgbBlue > 0 ) pPalette[i].rgbBlue--;
  461. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  462. (DWORD) pPalette[i].rgbGreen * 59 +
  463. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  464. } while( dwGray > dwNewGray );
  465. }
  466. }
  467. }
  468. _pPalette->DeleteObject();
  469. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  470. if( pLogPal != NULL ){
  471. _pPalette->CreatePalette( pLogPal );
  472. delete [] pLogPal;
  473. }
  474. }
  476. int nWidth = m_pImageObject->GetWidth();
  477. int nHeight = m_pImageObject->GetHeight();
  479. switch( m_pImageObject->GetNumBits() ){
  480. case 4:
  481. if( !bCompleteImage ){
  482. if( !bLessThanHalf ){
  483. for( y=0; y<nHeight; y++ ){
  484. pTemp = pBits;
  485. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  486. for( x=0; x<nWidth; x++ ){
  487. if( !( x >= nX1 && y >= nY1 && x <= nX2 && y <= nY2 ) ){
  488. ucData = pTemp[0];
  489. ucRed = OldPalette[ucData].rgbRed;
  490. ucGreen = OldPalette[ucData].rgbGreen;
  491. ucBlue = OldPalette[ucData].rgbBlue;
  492. ucData = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  493. pTemp[0] = ucData;
  494. }
  495. pTemp++;
  496. }
  497. }
  498. }
  499. for( y=nY1; y<=nY2; y++ ){
  500. pTemp = pBits;
  501. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  502. pTemp += ( nX1 / 2 );
  503. for( x=nX1; x<=nX2; x++ ){
  504. ucData = pTemp[0];
  505. if( !( x & 1 ) ) ucData >>= 4;
  506. ucData &= 0x0f;
  507. ucRed = OldPalette[ucData].rgbRed;
  508. ucGreen = OldPalette[ucData].rgbGreen;
  509. ucBlue = OldPalette[ucData].rgbBlue;
  510. dwGray = ( (DWORD) ucRed * 30 +
  511. (DWORD) ucGreen * 59 +
  512. (DWORD) ucBlue * 11 ) / 100;
  513. nTemp = (int) dwGray - nMinIndex;
  514. if( nTemp < 0 ) nTemp = 0;
  515. result = (double) nTemp;
  516. result *= dStep;
  517. result += (double) nDestMin;
  518. result *= dDestStep;
  519. dwNewGray = (DWORD) result;
  520. if( dwNewGray > 255 ) dwNewGray = 255;
  521. if( dwNewGray > dwGray ){
  522. do{
  523. if( ucRed < 255 ) ucRed++;
  524. if( ucGreen < 255 ) ucGreen++;
  525. if( ucBlue < 255 ) ucBlue++;
  526. dwGray = ( (DWORD) ucRed * 30 +
  527. (DWORD) ucGreen * 59 +
  528. (DWORD) ucBlue * 11 ) / 100;
  529. } while( dwGray < dwNewGray );
  530. }
  531. else if( dwNewGray < dwGray ){
  532. do{
  533. if( ucRed > 0 ) ucRed--;
  534. if( ucGreen > 0 ) ucGreen--;
  535. if( ucBlue > 0 ) ucBlue--;
  536. dwGray = ( (DWORD) ucRed * 30 +
  537. (DWORD) ucGreen * 59 +
  538. (DWORD) ucBlue * 11 ) / 100;
  539. } while( dwGray > dwNewGray );
  540. }
  541. ucData = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  542. if( !( x & 1 ) ) pTemp[0] = ( ucData << 4 );
  543. else pTemp[0] |= ucData;
  544. }
  545. if( ( x & 1 ) ) pTemp++;
  546. }
  547. }
  548. break;
  549. case 8:
  550. if( !bCompleteImage ){
  551. if( !bLessThanHalf ){
  552. for( y=0; y<nHeight; y++ ){
  553. pTemp = pBits;
  554. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  555. for( x=0; x<nWidth; x++ ){
  556. if( !( x >= nX1 && y >= nY1 && x <= nX2 && y <= nY2 ) ){
  557. ucData = pTemp[0];
  558. ucRed = OldPalette[ucData].rgbRed;
  559. ucGreen = OldPalette[ucData].rgbGreen;
  560. ucBlue = OldPalette[ucData].rgbBlue;
  561. ucData = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  562. pTemp[0] = ucData;
  563. }
  564. pTemp++;
  565. }
  566. }
  567. }
  568. for( y=nY1; y<=nY2; y++ ){
  569. pTemp = pBits;
  570. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  571. pTemp += nX1;
  572. for( x=nX1; x<=nX2; x++ ){
  573. ucData = pTemp[0];
  574. ucRed = OldPalette[ucData].rgbRed;
  575. ucGreen = OldPalette[ucData].rgbGreen;
  576. ucBlue = OldPalette[ucData].rgbBlue;
  577. dwGray = ( (DWORD) ucRed * 30 +
  578. (DWORD) ucGreen * 59 +
  579. (DWORD) ucBlue * 11 ) / 100;
  580. nTemp = (int) dwGray - nMinIndex;
  581. if( nTemp < 0 ) nTemp = 0;
  582. result = (double) nTemp;
  583. result *= dStep;
  584. result += (double) nDestMin;
  585. result *= dDestStep;
  586. dwNewGray = (DWORD) result;
  587. if( dwNewGray > 255 ) dwNewGray = 255;
  588. if( dwNewGray > dwGray ){
  589. do{
  590. if( ucRed < 255 ) ucRed++;
  591. if( ucGreen < 255 ) ucGreen++;
  592. if( ucBlue < 255 ) ucBlue++;
  593. dwGray = ( (DWORD) ucRed * 30 +
  594. (DWORD) ucGreen * 59 +
  595. (DWORD) ucBlue * 11 ) / 100;
  596. } while( dwGray < dwNewGray );
  597. }
  598. else if( dwNewGray < dwGray ){
  599. do{
  600. if( ucRed > 0 ) ucRed--;
  601. if( ucGreen > 0 ) ucGreen--;
  602. if( ucBlue > 0 ) ucBlue--;
  603. dwGray = ( (DWORD) ucRed * 30 +
  604. (DWORD) ucGreen * 59 +
  605. (DWORD) ucBlue * 11 ) / 100;
  606. } while( dwGray > dwNewGray );
  607. }
  608. ucData = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  609. *pTemp++ = ucData;
  610. }
  611. }
  612. }
  613. break;
  614. case 16:
  615. for( y=nY1; y<=nY2; y++ ){
  616. pTemp = pBits;
  617. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  618. pTemp += ( nX1 * 2 );
  619. for( x=nX1; x<=nX2; x++ ){
  620. GETRGB555( ucRed, ucGreen, ucBlue, pTemp );
  621. dwGray = ( (DWORD) ucRed * 30 +
  622. (DWORD) ucGreen * 59 +
  623. (DWORD) ucBlue * 11 ) / 100;
  624. nTemp = (int) dwGray - nMinIndex;
  625. if( nTemp < 0 ) nTemp = 0;
  626. result = (double) nTemp;
  627. result *= dStep;
  628. result += (double) nDestMin;
  629. result *= dDestStep;
  630. dwNewGray = (DWORD) result;
  631. if( dwNewGray > 255 ) dwNewGray = 255;
  632. if( dwNewGray > dwGray ){
  633. do{
  634. if( ucRed < 255 ) ucRed++;
  635. if( ucGreen < 255 ) ucGreen++;
  636. if( ucBlue < 255 ) ucBlue++;
  637. dwGray = ( (DWORD) ucRed * 30 +
  638. (DWORD) ucGreen * 59 +
  639. (DWORD) ucBlue * 11 ) / 100;
  640. } while( dwGray < dwNewGray );
  641. }
  642. else if( dwNewGray < dwGray ){
  643. do{
  644. if( ucRed > 0 ) ucRed--;
  645. if( ucGreen > 0 ) ucGreen--;
  646. if(ucBlue > 0 ) ucBlue--;
  647. dwGray = ( (DWORD) ucRed * 30 +
  648. (DWORD) ucGreen * 59 +
  649. (DWORD) ucBlue * 11 ) / 100;
  650. } while( dwGray > dwNewGray );
  651. }
  652. PUTRGB555( ucRed, ucGreen, ucBlue, pTemp );
  653. pTemp += 2;
  654. }
  655. }
  656. break;
  657. case 24:
  658. for( y=nY1; y<=nY2; y++ ){
  659. pTemp = pBits;
  660. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  661. pTemp += ( nX1 * 3 );
  662. for( x=nX1; x<=nX2; x++ ){
  663. dwGray = ( (DWORD) pTemp[2] * 30 +
  664. (DWORD) pTemp[1] * 59 +
  665. (DWORD) pTemp[0] * 11 ) / 100;
  666. nTemp = (int) dwGray - nMinIndex;
  667. if( nTemp < 0 ) nTemp = 0;
  668. result = (double) nTemp;
  669. result *= dStep;
  670. result += (double) nDestMin;
  671. result *= dDestStep;
  672. dwNewGray = (DWORD) result;
  673. if( dwNewGray > 255 ) dwNewGray = 255;
  674. if( dwNewGray > dwGray ){
  675. do{
  676. if( pTemp[0] < 255 ) pTemp[0]++;
  677. if( pTemp[1] < 255 ) pTemp[1]++;
  678. if( pTemp[2] < 255 ) pTemp[2]++;
  679. dwGray = ( (DWORD) pTemp[2] * 30 +
  680. (DWORD) pTemp[1] * 59 +
  681. (DWORD) pTemp[0] * 11 ) / 100;
  682. } while( dwGray < dwNewGray );
  683. }
  684. else if( dwNewGray < dwGray ){
  685. do{
  686. if( pTemp[0] > 0 ) pTemp[0]--;
  687. if( pTemp[1] > 0 ) pTemp[1]--;
  688. if( pTemp[2] > 0 ) pTemp[2]--;
  689. dwGray = ( (DWORD) pTemp[2] * 30 +
  690. (DWORD) pTemp[1] * 59 +
  691. (DWORD) pTemp[0] * 11 ) / 100;
  692. } while( dwGray > dwNewGray );
  693. }
  694. pTemp += 3;
  695. }
  696. }
  697. break;
  698. case 32:
  699. for( y=nY1; y<=nY2; y++ ){
  700. pTemp = pBits;
  701. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  702. pTemp += ( nX1 * 4 );
  703. for( x=nX1; x<=nX2; x++ ){
  704. GETRGB555( ucRed, ucGreen, ucBlue, pTemp );
  705. dwGray = ( (DWORD) ucRed * 30 +
  706. (DWORD) ucGreen * 59 +
  707. (DWORD) ucBlue * 11 ) / 100;
  708. nTemp = (int) dwGray - nMinIndex;
  709. if( nTemp < 0 ) nTemp = 0;
  710. result = (double) nTemp;
  711. result *= dStep;
  712. result += (double) nDestMin;
  713. result *= dDestStep;
  714. dwNewGray = (DWORD) result;
  715. if( dwNewGray > 255 ) dwNewGray = 255;
  716. if( dwNewGray > dwGray ){
  717. do{
  718. if( ucRed < 255 ) ucRed++;
  719. if( ucGreen < 255 ) ucGreen++;
  720. if( ucBlue < 255 ) ucBlue++;
  721. dwGray = ( (DWORD) ucRed * 30 +
  722. (DWORD) ucGreen * 59 +
  723. (DWORD) ucBlue * 11 ) / 100;
  724. } while( dwGray < dwNewGray );
  725. }
  726. else if( dwNewGray < dwGray ){
  727. do{
  728. if( ucRed > 0 ) ucRed--;
  729. if( ucGreen > 0 ) ucGreen--;
  730. if(ucBlue > 0 ) ucBlue--;
  731. dwGray = ( (DWORD) ucRed * 30 +
  732. (DWORD) ucGreen * 59 +
  733. (DWORD) ucBlue * 11 ) / 100;
  734. } while( dwGray > dwNewGray );
  735. }
  736. PUTRGB888( ucRed, ucGreen, ucBlue, pTemp );
  737. pTemp += 4;
  738. }
  739. }
  740. break;
  742. }
  744. ::GlobalUnlock( m_pImageObject->GetDib() );
  746. return( TRUE );
  748. }
  750. BOOL CImageAreaProcesses::HighpassFilter( int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  751. {
  753. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  754. if( m_pImageObject == NULL ) return( FALSE );
  756. static DWORD dwFact2[] = { 1, 1, 1, 1, 16, 1, 1, 1, 1 };
  758. LowpassFilter( nX1, nY1, nX2, nY2, dwFact2 );
  760. return( TRUE );
  762. }
  764. BOOL CImageAreaProcesses::LowpassFilter( int nX1, int nY1, int nX2, int nY2, DWORD *dwFact, CImageObject *pImageObject )
  765. {
  767. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  768. if( m_pImageObject == NULL ) return( FALSE );
  770. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  772. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  774. int nWidth = m_pImageObject->GetWidth();
  775. int nHeight = m_pImageObject->GetHeight();
  777. if( nX1 < 2 ) nX1 = 2;
  778. if( nY1 < 2 ) nY1 = 2;
  779. if( nX2 >= nWidth - 2 ) nX2 = nWidth - 2;
  780. if( nY2 >= nHeight - 2 ) nY2 = nHeight - 2;
  782. DWORD dwGrayTotal, dwDivisor = 0;
  783. unsigned char Data;
  784. DWORD *dwFactor;
  785. static DWORD dwFact1[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
  786. if( dwFact == NULL ) dwFactor = dwFact1;
  787. else dwFactor = dwFact;
  788. int i;
  789. for( i=0; i<9; i++ ) dwDivisor += dwFactor[i];
  791. unsigned char *pOldBuffer, *pNewBuffer, *pOldBits, *pNewBits, *pOldTemp, *pNewTemp;
  792. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  793. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  794. RGBQUAD *pOldPalette, *pNewPalette;
  795. int nWidthBytes, nNumColors, x, y, j, l;
  797. pOldBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  798. if( pOldBuffer == NULL ) return( FALSE );
  800. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  801. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  802. nNumColors = m_pImageObject->GetNumColors();
  803. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  804. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  806. DWORD dwNewSize, dwGray, dwTemp;
  807. HGLOBAL hNewDib;
  809. dwNewSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumColors * sizeof( RGBQUAD ) + nWidthBytes * nHeight;
  810. hNewDib = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewSize );
  811. if( hNewDib == NULL ){
  812. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  813. ::GlobalUnlock( m_pImageObject->GetDib() );
  814. return( FALSE );
  815. }
  817. pNewBuffer = (unsigned char *) ::GlobalLock( hNewDib );
  818. if( pNewBuffer == NULL ){
  819. ::GlobalFree( hNewDib );
  820. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  821. ::GlobalUnlock( m_pImageObject->GetDib() );
  822. return( FALSE );
  823. }
  825. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  826. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  827. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  828. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  830. *pNewBFH = *pOldBFH;
  831. *pNewBIH = *pOldBIH;
  832. for( i=0; i<nNumColors; i++ ) pNewPalette[i] = pOldPalette[i];
  834. memcpy( pNewBits, pOldBits, nWidthBytes * nHeight );
  836. unsigned char ucRed, ucGreen, ucBlue;
  838. switch( m_pImageObject->GetNumBits() ){
  839. case 8:
  840. for( y=nY1; y<=nY2; y++ ){
  841. pOldTemp = pOldBits;
  842. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  843. pOldTemp += ( nX1 - 1 );
  844. pNewTemp = pNewBits;
  845. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  846. pNewTemp += nX1;
  847. l = 0;
  848. for( x=nX1; x<=nX2; x++ ){
  850. // List all pixel gray values in the 3x3 area
  851. j = 0;
  852. for( i=0; i<3; i++ ){
  853. Data = pOldTemp[i+l];
  854. dwGrayTotal += ( ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  855. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  856. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 ) * dwFactor[j++] );
  857. }
  858. for( i=0; i<3; i++ ){
  859. Data = pOldTemp[i+l+nWidthBytes];
  860. dwGrayTotal += ( ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  861. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  862. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 ) * dwFactor[j++] );
  863. }
  864. for( i=0; i<3; i++ ){
  865. Data = pOldTemp[i+l+nWidthBytes*2];
  866. dwGrayTotal += ( ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  867. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  868. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 ) * dwFactor[j++] );
  869. }
  871. dwGrayTotal /= dwDivisor;
  872. Data = pOldTemp[1+nWidthBytes];
  873. ucRed = pOldPalette[Data].rgbRed;
  874. ucGreen = pOldPalette[Data].rgbGreen;
  875. ucBlue = pOldPalette[Data].rgbBlue;
  876. dwGray = ( ( (DWORD) ucRed * 30 +
  877. (DWORD) ucGreen * 59 +
  878. (DWORD) ucBlue * 11 ) / 100 );
  879. if( dwGray != 0 ) ucRed = (unsigned char) ( ( (DWORD) pOldPalette[Data].rgbRed * dwGrayTotal ) / dwGray );
  880. else ucRed = (unsigned char) ( ( dwGray + dwGrayTotal ) / 2 );
  881. if( dwGray != 0 ) ucGreen = (unsigned char) ( ( (DWORD) pOldPalette[Data].rgbGreen * dwGrayTotal ) / dwGray );
  882. else ucGreen = (unsigned char) ( ( dwGray + dwGrayTotal ) / 2 );
  883. if( dwGray != 0 ) ucBlue = (unsigned char) ( ( (DWORD) pOldPalette[Data].rgbBlue * dwGrayTotal ) / dwGray );
  884. else ucBlue = (unsigned char) ( ( dwGray + dwGrayTotal ) / 2 );
  885. *pNewTemp++ = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pNewPalette, nNumColors );
  887. l++;
  888. }
  889. }
  890. break;
  891. case 16:
  892. for( y=nY1; y<=nY2; y++ ){
  893. pOldTemp = pOldBits;
  894. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  895. pOldTemp += ( ( nX1 - 1 ) * 2 );
  896. pNewTemp = pNewBits;
  897. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  898. pNewTemp += ( nX1 * 2 );
  899. l = 0;
  900. for( x=nX1; x<=nX2; x++ ){
  902. dwGrayTotal = 0;
  903. j = 0;
  904. // List all pixel gray values in the 3x3 area
  905. for( i=0; i<3; i++ ){
  906. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*2] );
  907. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  908. (DWORD) ucGreen * 59 +
  909. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  910. }
  911. for( i=0; i<3; i++ ){
  912. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*2] );
  913. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  914. (DWORD) ucGreen * 59 +
  915. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  916. }
  917. for( i=0; i<3; i++ ){
  918. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*2] );
  919. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  920. (DWORD) ucGreen * 59 +
  921. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  922. }
  924. dwGrayTotal /= dwDivisor;
  926. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(1+l)*2] );
  927. dwGray = ( ( (DWORD) ucRed * 30 +
  928. (DWORD) ucGreen * 59 +
  929. (DWORD) ucBlue * 11 ) / 100 );
  931. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(1+l)*2] );
  932. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucRed * dwGrayTotal ) / dwGray );
  933. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  934. if( dwTemp > 255 ) dwTemp = 255;
  935. ucRed = (unsigned char) dwTemp;
  936. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucGreen * dwGrayTotal ) / dwGray );
  937. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  938. if( dwTemp > 255 ) dwTemp = 255;
  939. ucGreen = (unsigned char) dwTemp;
  940. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucBlue * dwGrayTotal ) / dwGray );
  941. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  942. if( dwTemp > 255 ) dwTemp = 255;
  943. ucBlue = (unsigned char) dwTemp;
  944. PUTRGB555( ucRed, ucGreen, ucBlue, pNewTemp );
  946. pNewTemp += 2;
  948. l++;
  949. }
  950. }
  951. break;
  952. case 24:
  953. for( y=nY1; y<=nY2; y++ ){
  954. pOldTemp = pOldBits;
  955. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  956. pOldTemp += ( ( nX1 - 1 ) * 3 );
  957. pNewTemp = pNewBits;
  958. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  959. pNewTemp += ( nX1 * 3 );
  960. l = 0;
  961. for( x=nX1; x<=nX2; x++ ){
  963. dwGrayTotal = 0;
  964. j = 0;
  965. // List all pixel gray values in the 3x3 area
  966. for( i=0; i<3; i++ ){
  967. dwGrayTotal += ( ( ( (DWORD) pOldTemp[(i+l)*3+2] * 30 +
  968. (DWORD) pOldTemp[(i+l)*3+1] * 59 +
  969. (DWORD) pOldTemp[(i+l)*3] * 11 ) / 100 ) * dwFactor[j++] );
  970. }
  971. for( i=0; i<3; i++ ){
  972. dwGrayTotal += ( ( ( (DWORD) pOldTemp[nWidthBytes+(i+l)*3+2] * 30 +
  973. (DWORD) pOldTemp[nWidthBytes+(i+l)*3+1] * 59 +
  974. (DWORD) pOldTemp[nWidthBytes+(i+l)*3] * 11 ) / 100 ) * dwFactor[j++] );
  975. }
  976. for( i=0; i<3; i++ ){
  977. dwGrayTotal += ( ( ( (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+2] * 30 +
  978. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+1] * 59 +
  979. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3] * 11 ) / 100 ) * dwFactor[j++] );
  980. }
  982. dwGrayTotal /= dwDivisor;
  984. dwGray = ( ( (DWORD) pOldTemp[nWidthBytes+(1+l)*3+2] * 30 +
  985. (DWORD) pOldTemp[nWidthBytes+(1+l)*3+1] * 59 +
  986. (DWORD) pOldTemp[nWidthBytes+(1+l)*3] * 11 ) / 100 );
  988. if( dwGray != 0 ) dwTemp = ( ( (DWORD) pOldTemp[(l+1)*3+nWidthBytes+2] * dwGrayTotal ) / dwGray );
  989. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  990. if( dwTemp > 255 ) dwTemp = 255;
  991. pNewTemp[2] = (unsigned char) dwTemp;
  992. if( dwGray != 0 ) dwTemp = ( ( (DWORD) pOldTemp[(l+1)*3+nWidthBytes+1] * dwGrayTotal ) / dwGray );
  993. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  994. if( dwTemp > 255 ) dwTemp = 255;
  995. pNewTemp[1] = (unsigned char) dwTemp;
  996. if( dwGray != 0 ) dwTemp = ( ( (DWORD) pOldTemp[(l+1)*3+nWidthBytes] * dwGrayTotal ) / dwGray );
  997. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  998. if( dwTemp > 255 ) dwTemp = 255;
  999. pNewTemp[0] = (unsigned char) dwTemp;
  1001. pNewTemp += 3;
  1003. l++;
  1004. }
  1005. }
  1006. break;
  1007. case 32:
  1008. for( y=nY1; y<=nY2; y++ ){
  1009. pOldTemp = pOldBits;
  1010. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  1011. pOldTemp += ( ( nX1 - 1 ) * 4 );
  1012. pNewTemp = pNewBits;
  1013. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1014. pNewTemp += ( nX1 * 4 );
  1015. l = 0;
  1016. for( x=nX1; x<=nX2; x++ ){
  1018. dwGrayTotal = 0;
  1019. j = 0;
  1020. // List all pixel gray values in the 3x3 area
  1021. for( i=0; i<3; i++ ){
  1022. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*4] );
  1023. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  1024. (DWORD) ucGreen * 59 +
  1025. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  1026. }
  1027. for( i=0; i<3; i++ ){
  1028. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*4] );
  1029. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  1030. (DWORD) ucGreen * 59 +
  1031. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  1032. }
  1033. for( i=0; i<3; i++ ){
  1034. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*4] );
  1035. dwGrayTotal += ( ( ( (DWORD) ucRed * 30 +
  1036. (DWORD) ucGreen * 59 +
  1037. (DWORD) ucBlue * 11 ) / 100 ) * dwFactor[j++] );
  1038. }
  1040. dwGrayTotal /= dwDivisor;
  1042. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(1+l)*4] );
  1043. dwGray = ( ( (DWORD) ucRed * 30 +
  1044. (DWORD) ucGreen * 59 +
  1045. (DWORD) ucBlue * 11 ) / 100 );
  1047. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(1+l)*4] );
  1048. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucRed * dwGrayTotal ) / dwGray );
  1049. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  1050. if( dwTemp > 255 ) dwTemp = 255;
  1051. ucRed = (unsigned char) dwTemp;
  1052. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucGreen * dwGrayTotal ) / dwGray );
  1053. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  1054. if( dwTemp > 255 ) dwTemp = 255;
  1055. ucGreen = (unsigned char) dwTemp;
  1056. if( dwGray != 0 ) dwTemp = ( ( (DWORD) ucBlue * dwGrayTotal ) / dwGray );
  1057. else dwTemp = ( dwGrayTotal + dwGray ) / 2;
  1058. if( dwTemp > 255 ) dwTemp = 255;
  1059. ucBlue = (unsigned char) dwTemp;
  1060. PUTRGB888( ucRed, ucGreen, ucBlue, pNewTemp );
  1062. pNewTemp += 4;
  1064. l++;
  1065. }
  1066. }
  1067. break;
  1068. }
  1070. ::GlobalUnlock( m_pImageObject->GetDib() );
  1071. ::GlobalFree( m_pImageObject->GetDib() );
  1072. ::GlobalUnlock( hNewDib );
  1073. m_pImageObject->SetDib( hNewDib );
  1075. return( TRUE );
  1077. }
  1079. BOOL CImageAreaProcesses::EdgeEnhance( int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  1080. {
  1082. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  1083. if( m_pImageObject == NULL ) return( FALSE );
  1085. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  1087. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  1088. int nWidth = m_pImageObject->GetWidth();
  1089. int nHeight = m_pImageObject->GetHeight();
  1091. if( nX1 < 2 ) nX1 = 2;
  1092. if( nY1 < 2 ) nY1 = 2;
  1093. if( nX2 >= nWidth - 2 ) nX2 = nWidth - 2;
  1094. if( nY2 >= nHeight - 2 ) nY2 = nHeight - 2;
  1096. DWORD dwGrayTotal;
  1097. unsigned char Data;
  1099. unsigned char *pOldBuffer, *pNewBuffer, *pOldBits, *pNewBits, *pOldTemp, *pNewTemp;
  1100. BITMAPFILEHEADER *pOldBFH, *pNewBFH;
  1101. BITMAPINFOHEADER *pOldBIH, *pNewBIH;
  1102. RGBQUAD *pOldPalette, *pNewPalette;
  1103. int nWidthBytes, nNumColors, x, y, j, l;
  1105. pOldBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  1106. if( pOldBuffer == NULL ) return( FALSE );
  1108. pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
  1109. pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
  1110. nNumColors = m_pImageObject->GetNumColors();
  1111. pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1112. pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1114. DWORD dwNewSize, dwTemp, dwGrayList[9];
  1115. HGLOBAL hNewDib;
  1117. dwNewSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNumColors * sizeof( RGBQUAD ) + nWidthBytes * nHeight;
  1118. hNewDib = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewSize );
  1119. if( hNewDib == NULL ){
  1120. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
  1121. ::GlobalUnlock( m_pImageObject->GetDib() );
  1122. return( FALSE );
  1123. }
  1125. pNewBuffer = (unsigned char *) ::GlobalLock( hNewDib );
  1126. if( pNewBuffer == NULL ){
  1127. ::GlobalFree( hNewDib );
  1128. m_pImageObject->m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
  1129. ::GlobalUnlock( m_pImageObject->GetDib() );
  1130. return( FALSE );
  1131. }
  1133. pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
  1134. pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
  1135. pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1136. pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1138. *pNewBFH = *pOldBFH;
  1139. *pNewBIH = *pOldBIH;
  1140. int i;
  1141. for( i=0; i<nNumColors; i++ ) pNewPalette[i] = pOldPalette[i];
  1143. memcpy( pNewBits, pOldBits, nWidthBytes * nHeight );
  1145. unsigned char ucRed, ucGreen, ucBlue;
  1147. DWORD dwLineAEIAveBelow, dwLineAEIAveAbove, dwLineAEIMaxDif;
  1148. DWORD dwLineBEHAveBelow, dwLineBEHAveAbove, dwLineBEHMaxDif;
  1149. DWORD dwLineCEGAveBelow, dwLineCEGAveAbove, dwLineCEGMaxDif;
  1150. DWORD dwLineDEFAveBelow, dwLineDEFAveAbove, dwLineDEFMaxDif;
  1151. DWORD dwMaxDif;
  1153. switch( m_pImageObject->GetNumBits() ){
  1154. case 8:
  1155. for( y=nY1; y<=nY2; y++ ){
  1156. pOldTemp = pOldBits;
  1157. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  1158. pOldTemp += ( nX1 - 1 );
  1159. pNewTemp = pNewBits;
  1160. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1161. pNewTemp += nX1;
  1162. l = 0;
  1163. for( x=nX1; x<=nX2; x++ ){
  1165. // List all pixel gray values in the 3x3 area
  1166. j = 0;
  1167. for( i=0; i<3; i++ ){
  1168. Data = pOldTemp[i+l];
  1169. dwGrayList[j++] = ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  1170. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  1171. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 );
  1172. }
  1173. for( i=0; i<3; i++ ){
  1174. Data = pOldTemp[i+l+nWidthBytes];
  1175. dwGrayList[j++] = ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  1176. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  1177. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 );
  1178. }
  1179. for( i=0; i<3; i++ ){
  1180. Data = pOldTemp[i+l+nWidthBytes*2];
  1181. dwGrayList[j++] = ( ( (DWORD) pOldPalette[Data].rgbRed * 30 +
  1182. (DWORD) pOldPalette[Data].rgbGreen * 59 +
  1183. (DWORD) pOldPalette[Data].rgbBlue * 11 ) / 100 );
  1184. }
  1186. dwLineAEIAveBelow = ( dwGrayList[3] + dwGrayList[6] + dwGrayList[7] ) / 3;
  1187. dwLineAEIAveAbove = ( dwGrayList[1] + dwGrayList[2] + dwGrayList[5] ) / 3;
  1188. if( dwLineAEIAveBelow > dwLineAEIAveAbove ) dwLineAEIMaxDif = dwLineAEIAveBelow - dwLineAEIAveAbove;
  1189. else dwLineAEIMaxDif = dwLineAEIAveAbove - dwLineAEIAveBelow;
  1191. dwLineBEHAveBelow = ( dwGrayList[0] + dwGrayList[3] + dwGrayList[6] ) / 3;
  1192. dwLineBEHAveAbove = ( dwGrayList[2] + dwGrayList[4] + dwGrayList[8] ) / 3;
  1193. if( dwLineBEHAveBelow > dwLineBEHAveAbove ) dwLineBEHMaxDif = dwLineBEHAveBelow - dwLineBEHAveAbove;
  1194. else dwLineBEHMaxDif = dwLineBEHAveAbove - dwLineBEHAveBelow;
  1196. dwLineCEGAveBelow = ( dwGrayList[5] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1197. dwLineCEGAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[3] ) / 3;
  1198. if( dwLineCEGAveBelow > dwLineCEGAveAbove ) dwLineCEGMaxDif = dwLineCEGAveBelow - dwLineCEGAveAbove;
  1199. else dwLineCEGMaxDif = dwLineCEGAveAbove - dwLineCEGAveBelow;
  1201. dwLineDEFAveBelow = ( dwGrayList[6] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1202. dwLineDEFAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[2] ) / 3;
  1203. if( dwLineDEFAveBelow > dwLineDEFAveAbove ) dwLineDEFMaxDif = dwLineDEFAveBelow - dwLineDEFAveAbove;
  1204. else dwLineDEFMaxDif = dwLineDEFAveAbove - dwLineDEFAveBelow;
  1206. dwMaxDif = MAX( dwLineAEIMaxDif, dwLineBEHMaxDif );
  1207. dwMaxDif = MAX( dwLineCEGMaxDif, dwMaxDif );
  1208. dwMaxDif = MAX( dwLineDEFMaxDif, dwMaxDif );
  1210. Data = pOldTemp[1+l+nWidthBytes];
  1211. if( dwMaxDif > 20 ){
  1212. ucRed = pOldPalette[Data].rgbRed;
  1213. ucGreen = pOldPalette[Data].rgbGreen;
  1214. ucBlue = pOldPalette[Data].rgbBlue;
  1215. dwTemp = ( ( (DWORD) ucRed * 12 ) / 10 );
  1216. if( dwTemp > 255 ) dwTemp = 255;
  1217. ucRed = (unsigned char) dwTemp;
  1218. dwTemp = ( ( (DWORD) ucGreen * 12 ) / 10 );
  1219. if( dwTemp > 255 ) dwTemp = 255;
  1220. ucGreen = (unsigned char) dwTemp;
  1221. dwTemp = ( ( (DWORD) ucBlue * 12 ) / 10 );
  1222. if( dwTemp > 255 ) dwTemp = 255;
  1223. ucBlue = (unsigned char) dwTemp;
  1224. Data = m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pNewPalette, nNumColors );
  1225. }
  1227. *pNewTemp++ = Data;
  1229. l++;
  1230. }
  1231. }
  1232. break;
  1233. case 16:
  1234. for( y=nY1; y<=nY2; y++ ){
  1235. pOldTemp = pOldBits;
  1236. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  1237. pOldTemp += ( ( nX1 - 1 ) * 2 );
  1238. pNewTemp = pNewBits;
  1239. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1240. pNewTemp += ( nX1 * 2 );
  1241. l = 0;
  1242. for( x=nX1; x<=nX2; x++ ){
  1244. dwGrayTotal = 0;
  1245. j = 0;
  1246. // List all pixel gray values in the 3x3 area
  1247. for( i=0; i<3; i++ ){
  1248. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*2] );
  1249. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1250. (DWORD) ucGreen * 59 +
  1251. (DWORD) ucBlue * 11 ) / 100 );
  1252. }
  1253. for( i=0; i<3; i++ ){
  1254. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*2] );
  1255. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1256. (DWORD) ucGreen * 59 +
  1257. (DWORD) ucBlue * 11 ) / 100 );
  1258. }
  1259. for( i=0; i<3; i++ ){
  1260. GETRGB555( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*2] );
  1261. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1262. (DWORD) ucGreen * 59 +
  1263. (DWORD) ucBlue * 11 ) / 100 );
  1264. }
  1266. dwLineAEIAveBelow = ( dwGrayList[3] + dwGrayList[6] + dwGrayList[7] ) / 3;
  1267. dwLineAEIAveAbove = ( dwGrayList[1] + dwGrayList[2] + dwGrayList[5] ) / 3;
  1268. if( dwLineAEIAveBelow > dwLineAEIAveAbove ) dwLineAEIMaxDif = dwLineAEIAveBelow - dwLineAEIAveAbove;
  1269. else dwLineAEIMaxDif = dwLineAEIAveAbove - dwLineAEIAveBelow;
  1271. dwLineBEHAveBelow = ( dwGrayList[0] + dwGrayList[3] + dwGrayList[6] ) / 3;
  1272. dwLineBEHAveAbove = ( dwGrayList[2] + dwGrayList[4] + dwGrayList[8] ) / 3;
  1273. if( dwLineBEHAveBelow > dwLineBEHAveAbove ) dwLineBEHMaxDif = dwLineBEHAveBelow - dwLineBEHAveAbove;
  1274. else dwLineBEHMaxDif = dwLineBEHAveAbove - dwLineBEHAveBelow;
  1276. dwLineCEGAveBelow = ( dwGrayList[5] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1277. dwLineCEGAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[3] ) / 3;
  1278. if( dwLineCEGAveBelow > dwLineCEGAveAbove ) dwLineCEGMaxDif = dwLineCEGAveBelow - dwLineCEGAveAbove;
  1279. else dwLineCEGMaxDif = dwLineCEGAveAbove - dwLineCEGAveBelow;
  1281. dwLineDEFAveBelow = ( dwGrayList[6] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1282. dwLineDEFAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[2] ) / 3;
  1283. if( dwLineDEFAveBelow > dwLineDEFAveAbove ) dwLineDEFMaxDif = dwLineDEFAveBelow - dwLineDEFAveAbove;
  1284. else dwLineDEFMaxDif = dwLineDEFAveAbove - dwLineDEFAveBelow;
  1286. dwMaxDif = MAX( dwLineAEIMaxDif, dwLineBEHMaxDif );
  1287. dwMaxDif = MAX( dwLineCEGMaxDif, dwMaxDif );
  1288. dwMaxDif = MAX( dwLineDEFMaxDif, dwMaxDif );
  1290. if( dwMaxDif > 20 ){
  1291. GETRGB555( ucRed, ucGreen, ucBlue, pOldTemp[(1+l)*2+nWidthBytes] );
  1292. dwTemp = ( ( (DWORD) ucRed * 12 ) / 10 );
  1293. if( dwTemp > 255 ) dwTemp = 255;
  1294. ucRed = (unsigned char) dwTemp;
  1295. dwTemp = ( ( (DWORD) ucGreen * 12 ) / 10 );
  1296. if( dwTemp > 255 ) dwTemp = 255;
  1297. ucGreen = (unsigned char) dwTemp;
  1298. dwTemp = ( ( (DWORD) ucBlue * 12 ) / 10 );
  1299. if( dwTemp > 255 ) dwTemp = 255;
  1300. ucBlue = (unsigned char) dwTemp;
  1301. PUTRGB555( ucRed, ucGreen, ucBlue, pNewTemp );
  1302. }
  1303. else{
  1304. GETRGB555( ucRed, ucGreen, ucBlue, pOldTemp[(1+l)*2+nWidthBytes] );
  1305. PUTRGB555( ucRed, ucGreen, ucBlue, pNewTemp );
  1306. }
  1308. pNewTemp += 2;
  1310. l++;
  1311. }
  1312. }
  1313. break;
  1314. case 24:
  1315. for( y=nY1; y<=nY2; y++ ){
  1316. pOldTemp = pOldBits;
  1317. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  1318. pOldTemp += ( ( nX1 - 1 ) * 3 );
  1319. pNewTemp = pNewBits;
  1320. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1321. pNewTemp += ( nX1 * 3 );
  1322. l = 0;
  1323. for( x=nX1; x<=nX2; x++ ){
  1325. dwGrayTotal = 0;
  1326. j = 0;
  1327. // List all pixel gray values in the 3x3 area
  1328. for( i=0; i<3; i++ ){
  1329. dwGrayList[j++] = ( ( (DWORD) pOldTemp[(i+l)*3+2] * 30 +
  1330. (DWORD) pOldTemp[(i+l)*3+1] * 59 +
  1331. (DWORD) pOldTemp[(i+l)*3] * 11 ) / 100 );
  1332. }
  1333. for( i=0; i<3; i++ ){
  1334. dwGrayList[j++] = ( ( (DWORD) pOldTemp[nWidthBytes+(i+l)*3+2] * 30 +
  1335. (DWORD) pOldTemp[nWidthBytes+(i+l)*3+1] * 59 +
  1336. (DWORD) pOldTemp[nWidthBytes+(i+l)*3] * 11 ) / 100 );
  1337. }
  1338. for( i=0; i<3; i++ ){
  1339. dwGrayList[j++] = ( ( (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+2] * 30 +
  1340. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3+1] * 59 +
  1341. (DWORD) pOldTemp[nWidthBytes*2+(i+l)*3] * 11 ) / 100 );
  1342. }
  1344. dwLineAEIAveBelow = ( dwGrayList[3] + dwGrayList[6] + dwGrayList[7] ) / 3;
  1345. dwLineAEIAveAbove = ( dwGrayList[1] + dwGrayList[2] + dwGrayList[5] ) / 3;
  1346. if( dwLineAEIAveBelow > dwLineAEIAveAbove ) dwLineAEIMaxDif = dwLineAEIAveBelow - dwLineAEIAveAbove;
  1347. else dwLineAEIMaxDif = dwLineAEIAveAbove - dwLineAEIAveBelow;
  1349. dwLineBEHAveBelow = ( dwGrayList[0] + dwGrayList[3] + dwGrayList[6] ) / 3;
  1350. dwLineBEHAveAbove = ( dwGrayList[2] + dwGrayList[4] + dwGrayList[8] ) / 3;
  1351. if( dwLineBEHAveBelow > dwLineBEHAveAbove ) dwLineBEHMaxDif = dwLineBEHAveBelow - dwLineBEHAveAbove;
  1352. else dwLineBEHMaxDif = dwLineBEHAveAbove - dwLineBEHAveBelow;
  1354. dwLineCEGAveBelow = ( dwGrayList[5] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1355. dwLineCEGAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[3] ) / 3;
  1356. if( dwLineCEGAveBelow > dwLineCEGAveAbove ) dwLineCEGMaxDif = dwLineCEGAveBelow - dwLineCEGAveAbove;
  1357. else dwLineCEGMaxDif = dwLineCEGAveAbove - dwLineCEGAveBelow;
  1359. dwLineDEFAveBelow = ( dwGrayList[6] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1360. dwLineDEFAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[2] ) / 3;
  1361. if( dwLineDEFAveBelow > dwLineDEFAveAbove ) dwLineDEFMaxDif = dwLineDEFAveBelow - dwLineDEFAveAbove;
  1362. else dwLineDEFMaxDif = dwLineDEFAveAbove - dwLineDEFAveBelow;
  1364. dwMaxDif = MAX( dwLineAEIMaxDif, dwLineBEHMaxDif );
  1365. dwMaxDif = MAX( dwLineCEGMaxDif, dwMaxDif );
  1366. dwMaxDif = MAX( dwLineDEFMaxDif, dwMaxDif );
  1368. if( dwMaxDif > 20 ){
  1369. dwTemp = ( ( (DWORD) pOldTemp[(1+l)*3+nWidthBytes] * 12 ) / 10 );
  1370. if( dwTemp > 255 ) dwTemp = 255;
  1371. pNewTemp[0] = (unsigned char) dwTemp;
  1372. dwTemp = ( ( (DWORD) pOldTemp[(1+l)*3+nWidthBytes+1] * 12 ) / 10 );
  1373. if( dwTemp > 255 ) dwTemp = 255;
  1374. pNewTemp[1] = (unsigned char) dwTemp;
  1375. dwTemp = ( ( (DWORD) pOldTemp[(1+l)*3+nWidthBytes+2] * 12 ) / 10 );
  1376. if( dwTemp > 255 ) dwTemp = 255;
  1377. pNewTemp[2] = (unsigned char) dwTemp;
  1378. }
  1379. else{
  1380. pNewTemp[0] = pOldTemp[(1+l)*3+nWidthBytes];
  1381. pNewTemp[1] = pOldTemp[(1+l)*3+nWidthBytes+1];
  1382. pNewTemp[2] = pOldTemp[(1+l)*3+nWidthBytes+2];
  1383. }
  1385. pNewTemp += 3;
  1387. l++;
  1388. }
  1389. }
  1390. break;
  1391. case 32:
  1392. for( y=nY1; y<=nY2; y++ ){
  1393. pOldTemp = pOldBits;
  1394. pOldTemp += ( ( nHeight - 1 - y - 1 ) * nWidthBytes );
  1395. pOldTemp += ( ( nX1 - 1 ) * 4 );
  1396. pNewTemp = pNewBits;
  1397. pNewTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1398. pNewTemp += ( nX1 * 4 );
  1399. l = 0;
  1400. for( x=nX1; x<=nX2; x++ ){
  1402. dwGrayTotal = 0;
  1403. j = 0;
  1404. // List all pixel gray values in the 3x3 area
  1405. for( i=0; i<3; i++ ){
  1406. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[(i+l)*4] );
  1407. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1408. (DWORD) ucGreen * 59 +
  1409. (DWORD) ucBlue * 11 ) / 100 );
  1410. }
  1411. for( i=0; i<3; i++ ){
  1412. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes+(i+l)*4] );
  1413. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1414. (DWORD) ucGreen * 59 +
  1415. (DWORD) ucBlue * 11 ) / 100 );
  1416. }
  1417. for( i=0; i<3; i++ ){
  1418. GETRGB888( ucRed, ucGreen, ucBlue, &pOldTemp[nWidthBytes*2+(i+l)*4] );
  1419. dwGrayList[j++] = ( ( (DWORD) ucRed * 30 +
  1420. (DWORD) ucGreen * 59 +
  1421. (DWORD) ucBlue * 11 ) / 100 );
  1422. }
  1424. dwLineAEIAveBelow = ( dwGrayList[3] + dwGrayList[6] + dwGrayList[7] ) / 3;
  1425. dwLineAEIAveAbove = ( dwGrayList[1] + dwGrayList[2] + dwGrayList[5] ) / 3;
  1426. if( dwLineAEIAveBelow > dwLineAEIAveAbove ) dwLineAEIMaxDif = dwLineAEIAveBelow - dwLineAEIAveAbove;
  1427. else dwLineAEIMaxDif = dwLineAEIAveAbove - dwLineAEIAveBelow;
  1429. dwLineBEHAveBelow = ( dwGrayList[0] + dwGrayList[3] + dwGrayList[6] ) / 3;
  1430. dwLineBEHAveAbove = ( dwGrayList[2] + dwGrayList[4] + dwGrayList[8] ) / 3;
  1431. if( dwLineBEHAveBelow > dwLineBEHAveAbove ) dwLineBEHMaxDif = dwLineBEHAveBelow - dwLineBEHAveAbove;
  1432. else dwLineBEHMaxDif = dwLineBEHAveAbove - dwLineBEHAveBelow;
  1434. dwLineCEGAveBelow = ( dwGrayList[5] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1435. dwLineCEGAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[3] ) / 3;
  1436. if( dwLineCEGAveBelow > dwLineCEGAveAbove ) dwLineCEGMaxDif = dwLineCEGAveBelow - dwLineCEGAveAbove;
  1437. else dwLineCEGMaxDif = dwLineCEGAveAbove - dwLineCEGAveBelow;
  1439. dwLineDEFAveBelow = ( dwGrayList[6] + dwGrayList[7] + dwGrayList[8] ) / 3;
  1440. dwLineDEFAveAbove = ( dwGrayList[0] + dwGrayList[1] + dwGrayList[2] ) / 3;
  1441. if( dwLineDEFAveBelow > dwLineDEFAveAbove ) dwLineDEFMaxDif = dwLineDEFAveBelow - dwLineDEFAveAbove;
  1442. else dwLineDEFMaxDif = dwLineDEFAveAbove - dwLineDEFAveBelow;
  1444. dwMaxDif = MAX( dwLineAEIMaxDif, dwLineBEHMaxDif );
  1445. dwMaxDif = MAX( dwLineCEGMaxDif, dwMaxDif );
  1446. dwMaxDif = MAX( dwLineDEFMaxDif, dwMaxDif );
  1448. if( dwMaxDif > 20 ){
  1449. GETRGB888( ucRed, ucGreen, ucBlue, pOldTemp[(1+l)*4+nWidthBytes] );
  1450. dwTemp = ( ( (DWORD) ucRed * 12 ) / 10 );
  1451. if( dwTemp > 255 ) dwTemp = 255;
  1452. ucRed = (unsigned char) dwTemp;
  1453. dwTemp = ( ( (DWORD) ucGreen * 12 ) / 10 );
  1454. if( dwTemp > 255 ) dwTemp = 255;
  1455. ucGreen = (unsigned char) dwTemp;
  1456. dwTemp = ( ( (DWORD) ucBlue * 12 ) / 10 );
  1457. if( dwTemp > 255 ) dwTemp = 255;
  1458. ucBlue = (unsigned char) dwTemp;
  1459. PUTRGB888( ucRed, ucGreen, ucBlue, pNewTemp );
  1460. }
  1461. else{
  1462. GETRGB888( ucRed, ucGreen, ucBlue, pOldTemp[(1+l)*4+nWidthBytes] );
  1463. PUTRGB888( ucRed, ucGreen, ucBlue, pNewTemp );
  1464. }
  1466. pNewTemp += 4;
  1468. l++;
  1469. }
  1470. }
  1471. break;
  1472. }
  1474. ::GlobalUnlock( m_pImageObject->GetDib() );
  1475. ::GlobalFree( m_pImageObject->GetDib() );
  1476. ::GlobalUnlock( hNewDib );
  1477. m_pImageObject->SetDib( hNewDib );
  1479. return( TRUE );
  1481. }
  1483. int *CImageAreaProcesses::GetHistogram( int nX1, int nY1, int nX2, int nY2 )
  1484. {
  1486. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  1488. unsigned char *pBuffer, *pBits;
  1489. RGBQUAD *pPalette;
  1490. int nWidthBytes, nNumColors;
  1492. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  1493. if( pBuffer == NULL ) return( NULL );
  1495. nNumColors = m_pImageObject->GetNumColors();
  1496. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1497. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1499. int *nHistogramBuffer = CreateHistogram( nX1, nY1, nX2, nY2, pBits, pPalette, nWidthBytes );
  1501. ::GlobalUnlock( m_pImageObject->GetDib() );
  1503. return( nHistogramBuffer );
  1505. }
  1507. int *CImageAreaProcesses::CreateHistogram( int nX1, int nY1, int nX2, int nY2, unsigned char *pData, RGBQUAD *pPalette, int nWidthBytes )
  1508. {
  1510. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  1512. int *pBuffer = new int [256*4+4];
  1513. if( pBuffer == NULL ) return( NULL );
  1514. memset( pBuffer, 0, ( 256 * 4 + 4 ) * sizeof( int ) );
  1516. DWORD dwGray;
  1517. int x, y;
  1518. unsigned char *pTemp, ucRed, ucGreen, ucBlue;
  1519. int Pixels = 0;
  1521. int nWidth = m_pImageObject->GetWidth();
  1522. int nHeight = m_pImageObject->GetHeight();
  1524. switch( m_pImageObject->GetNumBits() ){
  1525. case 1:
  1526. break;
  1527. case 4:
  1528. break;
  1529. case 8:
  1530. for( y=0; y<nHeight; y++ ){
  1531. pTemp = pData;
  1532. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1533. pTemp += nX1;
  1534. for( x=nX1; x<=nX2; x++ ){
  1535. ucRed = pPalette[pTemp[x]].rgbRed;
  1536. ucGreen = pPalette[pTemp[x]].rgbGreen;
  1537. ucBlue = pPalette[pTemp[x]].rgbBlue;
  1538. dwGray = ( (DWORD) ucRed * 30 +
  1539. (DWORD) ucGreen * 59 +
  1540. (DWORD) ucBlue * 11 ) / 100;
  1541. dwGray &= 0x000000ff;
  1542. pBuffer[dwGray]++;
  1543. pBuffer[256+ucRed]++;
  1544. pBuffer[512+ucBlue]++;
  1545. pBuffer[768+ucGreen]++;
  1546. Pixels++;
  1547. }
  1548. }
  1549. break;
  1550. case 16:
  1551. for( y=0; y<nHeight; y++ ){
  1552. pTemp = pData;
  1553. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1554. pTemp += ( nX1 * 2 );
  1555. for( x=nX1; x<=nX2; x++ ){
  1556. GETRGB555( ucRed, ucGreen, ucBlue, pTemp );
  1557. dwGray = ( (DWORD) ucRed * 30 +
  1558. (DWORD) ucGreen * 59 +
  1559. (DWORD) ucBlue * 11 ) / 100;
  1560. dwGray &= 0x000000ff;
  1561. pBuffer[dwGray]++;
  1562. pBuffer[256+pTemp[x*3]]++;
  1563. pBuffer[512+pTemp[x*3+1]]++;
  1564. pBuffer[768+pTemp[x*3+2]]++;
  1565. Pixels++;
  1566. pTemp += 2;
  1567. }
  1568. }
  1569. break;
  1570. case 24:
  1571. for( y=0; y<nHeight; y++ ){
  1572. pTemp = pData;
  1573. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1574. pTemp += ( nX1 * 3 );
  1575. for( x=nX1; x<=nX2; x++ ){
  1576. dwGray = ( (DWORD) pTemp[x*3+2] * 30 +
  1577. (DWORD) pTemp[x*3+1] * 59 +
  1578. (DWORD) pTemp[x*3] * 11 ) / 100;
  1579. dwGray &= 0x000000ff;
  1580. pBuffer[dwGray]++;
  1581. pBuffer[256+pTemp[x*3]]++;
  1582. pBuffer[512+pTemp[x*3+1]]++;
  1583. pBuffer[768+pTemp[x*3+2]]++;
  1584. Pixels++;
  1585. }
  1586. }
  1587. break;
  1588. case 32:
  1589. for( y=0; y<m_pImageObject->GetHeight(); y++ ){
  1590. pTemp = pData;
  1591. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  1592. pTemp += ( nX1 * 4 );
  1593. for( x=nX1; x<=nX2; x++ ){
  1594. GETRGB888( ucRed, ucGreen, ucBlue, pTemp );
  1595. dwGray = ( (DWORD) ucRed * 30 +
  1596. (DWORD) ucGreen * 59 +
  1597. (DWORD) ucBlue * 11 ) / 100;
  1598. dwGray &= 0x000000ff;
  1599. pBuffer[dwGray]++;
  1600. pBuffer[256+pTemp[x*3]]++;
  1601. pBuffer[512+pTemp[x*3+1]]++;
  1602. pBuffer[768+pTemp[x*3+2]]++;
  1603. Pixels++;
  1604. pTemp += 4;
  1605. }
  1606. }
  1607. break;
  1608. }
  1610. pBuffer[0] = pBuffer[256] = pBuffer[512] = pBuffer[768] = 0;
  1611. int Highest = 0, i, j;
  1612. for( i=0; i<256*4; i++ ){
  1613. if( pBuffer[i] > Highest ) Highest = pBuffer[i];
  1614. }
  1615. for( j=0; j<4; j++ ){
  1616. for( i=0; i<256; i++ ) pBuffer[j*256+i] = ( pBuffer[j*256+i] * 255 ) / Highest;
  1617. }
  1618. Highest = 0;
  1619. for( i=0; i<256*4; i++ ){
  1620. if( pBuffer[i] > Highest ) Highest = pBuffer[i];
  1621. }
  1622. pBuffer[256*4] = Highest;
  1623. pBuffer[256*4+1] = Highest / 25;
  1625. for( i=0; i<256; i++ ){
  1626. if( pBuffer[i] >= pBuffer[256*4+1] ) break;
  1627. }
  1628. pBuffer[256*4+2] = i;
  1629. for( i=255; i>=0; i-- ){
  1630. if( pBuffer[i] >= pBuffer[256*4+1] ) break;
  1631. }
  1632. pBuffer[256*4+3] = i;
  1633. if( pBuffer[256*4+2] > 255 ) pBuffer[256*4+2] = 255;
  1634. if( pBuffer[256*4+3] < 0 ) pBuffer[256*4+3] = 0;
  1636. return( pBuffer );
  1638. }