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

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

图片显示

开发平台：

Visual C++

Imagepointprocesses.cpp：源码内容
  1. // ImagePointProcesses.cpp
  3. #include "stdafx.h"
  4. #include "ImagePointProcesses.h"
  5. #include "fft.cpp"
  6. #include "winbase.h"
  7. #include "edgecontour.h"
  9. /**************************************************************************
  10. *                                                                         *
  11. *                               Point Processes                           *
  12. *                                                                         *
  13. **************************************************************************/
  15. CImagePointProcesses::CImagePointProcesses()
  16. {
  17. EdgeDetectType = SOBEL;
  18. Embossed = FALSE;
  19. }
  21. CImagePointProcesses::CImagePointProcesses( CImageObject *pImageObject )
  22. {
  24. m_pImageObject = pImageObject;
  25. EdgeDetectType = SOBEL;
  26. Embossed = FALSE;
  27. }
  29. BOOL CImagePointProcesses::ChangeBrightness( int nBrightness, int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  30. {
  32. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  33. if( m_pImageObject == NULL ) return( FALSE );
  35. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  36. if( nBrightness == 100 ) return( TRUE );
  38. BOOL bLessThanHalf, bCompleteImage;
  39. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2, &bCompleteImage, &bLessThanHalf );
  41. unsigned char *pBuffer, *pBits, *pTemp;
  42. BITMAPINFOHEADER *pBIH;
  43. RGBQUAD *pPalette;
  44. int nWidthBytes, nNumColors, x, y, i;
  46. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  47. if( pBuffer == NULL ) return( FALSE );
  49. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  50. nNumColors = m_pImageObject->GetNumColors();
  51. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  52. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  54. if( nBrightness < 0 ) nBrightness = 0;
  55. else if( nBrightness > 200 ) nBrightness = 200;
  57. LOGPALETTE *pLogPal;
  58. CPalette *_pPalette = m_pImageObject->GetPalette();
  59. if( m_pImageObject->GetNumBits() > 8 && ( pLogPal = m_pImageObject->GetLogPal() ) != NULL && ( bCompleteImage || !bLessThanHalf ) ){
  60. _pPalette->DeleteObject();
  61. for( i=0; i<nNumColors; i++ )
  62. BrightnessValues( nBrightness,
  63. pLogPal->palPalEntry[i].peRed,
  64. pLogPal->palPalEntry[i].peGreen,
  65. pLogPal->palPalEntry[i].peBlue,
  66. &pLogPal->palPalEntry[i].peRed,
  67. &pLogPal->palPalEntry[i].peGreen,
  68. &pLogPal->palPalEntry[i].peBlue );
  69. _pPalette->CreatePalette( pLogPal );
  70. }
  72. switch( m_pImageObject->GetNumBits() ){
  73. case 4:
  74. if( bCompleteImage ){
  75. _pPalette->DeleteObject();
  76. for( i=0; i<nNumColors; i++ ) BrightnessValues( nBrightness, pPalette[i].rgbRed, pPalette[i].rgbGreen, pPalette[i].rgbBlue, &pPalette[i].rgbRed, &pPalette[i].rgbGreen, &pPalette[i].rgbBlue );
  77. {
  78. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  79. if( pLogPal != NULL ){
  80. _pPalette->CreatePalette( pLogPal );
  81. delete [] pLogPal;
  82. }
  83. }
  84. }
  85. else{
  86. unsigned char ucRed, ucGreen, ucBlue, Data;
  87. for( y=nY1; y<=nY2; y++ ){
  88. pTemp = pBits;
  89. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 / 2 ) );
  90. for( x=nX1; x<=nX2; x++ ){
  91. Data = *pTemp;
  92. if( !( x & 1 ) ) Data >>= 4;
  93. else Data &= 0x0f;
  94. ucRed = pPalette[Data].rgbRed;
  95. ucGreen = pPalette[Data].rgbGreen;
  96. ucBlue = pPalette[Data].rgbBlue;
  97. BrightnessValues( nBrightness, ucRed, ucGreen, ucBlue, &ucRed, &ucGreen, &ucBlue );
  98. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  99. if( !( x & 1 ) ){
  100. Data <<= 4;
  101. (*pTemp) &= 0x0f;
  102. (*pTemp) |= Data;
  103. }
  104. else{
  105. (*pTemp) &= 0xf0;
  106. (*pTemp) |= Data;
  107. pTemp++;
  108. }
  109. }
  110. }
  111. }
  112. break;
  113. case 8:
  114. if( bCompleteImage ){
  115. _pPalette->DeleteObject();
  116. for( i=0; i<nNumColors; i++ ) BrightnessValues( nBrightness, pPalette[i].rgbRed, pPalette[i].rgbGreen, pPalette[i].rgbBlue, &pPalette[i].rgbRed, &pPalette[i].rgbGreen, &pPalette[i].rgbBlue );
  117. {
  118. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  119. if( pLogPal != NULL ){
  120. _pPalette->CreatePalette( pLogPal );
  121. delete [] pLogPal;
  122. }
  123. }
  124. }
  125. else{
  126. unsigned char ucRed, ucGreen, ucBlue, Data;
  127. for( y=nY1; y<=nY2; y++ ){
  128. pTemp = pBits;
  129. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + nX1 );
  130. for( x=nX1; x<=nX2; x++ ){
  131. Data = *pTemp;
  132. ucRed = pPalette[Data].rgbRed;
  133. ucGreen = pPalette[Data].rgbGreen;
  134. ucBlue = pPalette[Data].rgbBlue;
  135. BrightnessValues( nBrightness, ucRed, ucGreen, ucBlue, &ucRed, &ucGreen, &ucBlue );
  136. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  137. *pTemp++ = Data;
  138. }
  139. }
  140. }
  141. break;
  142. case 16:
  143. for( y=nY1; y<=nY2; y++ ){
  144. pTemp = pBits;
  145. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 2 ) );
  146. for( x=nX1; x<=nX2; x++ ){
  147. }
  148. }
  149. break;
  150. case 24:
  151. for( y=nY1; y<=nY2; y++ ){
  152. pTemp = pBits;
  153. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 3 ) );
  154. for( x=nX1; x<=nX2; x++ ){
  155. BrightnessValues( nBrightness, pTemp[0], pTemp[1], pTemp[2], &pTemp[0], &pTemp[1], &pTemp[2] );
  156. pTemp += 3;
  157. }
  158. }
  159. break;
  160. case 32:
  161. for( y=nY1; y<=nY2; y++ ){
  162. unsigned char ucRed, ucGreen, ucBlue;
  163. pTemp = pBits;
  164. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 4 ) );
  165. for( x=nX1; x<=nX2; x++ ){
  166. ucRed = pTemp[0];
  167. ucGreen = pTemp[1];
  168. ucBlue = pTemp[2];
  171. *pTemp++ = ucRed;
  172. *pTemp++ = ucGreen;
  173. *pTemp++ = ucBlue;
  174. pTemp++;
  175. }
  176. }
  177. break;
  178. }
  180. ::GlobalUnlock( m_pImageObject->GetDib() );
  182. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  184. return( TRUE );
  186. }
  188. void CImagePointProcesses::BrightnessValues( int nBrightness, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue, unsigned char *pucNewRed, unsigned char *pucNewGreen, unsigned char *pucNewBlue )
  189. {
  191. if( m_pImageObject == NULL ) return;
  193. DWORD Red, Green, Blue;
  195. Red = (DWORD) ( ( (DWORD) ucRed * (DWORD) nBrightness ) / (DWORD) 100 );
  196. if( Red > 255 ) Red = 255;
  197. else if( Red == 0 && nBrightness > 100 ) Red = (DWORD) ( ( nBrightness * 255 ) / 100 );
  198. ucRed = (unsigned char) Red;
  199. Green = (DWORD) ( ( (DWORD) ucGreen * (DWORD) nBrightness ) / (DWORD) 100 );
  200. if( Green > 255 ) Green = 255;
  201. else if( Green == 0 && nBrightness > 100 ) Green = (DWORD) ( ( nBrightness * 255 ) / 100 );
  202. ucGreen = (unsigned char) Green;
  203. Blue = (DWORD) ( ( (DWORD) ucBlue * (DWORD) nBrightness ) / (DWORD) 100 );
  204. if( Blue > 255 ) Blue = 255;
  205. else if( Blue == 0 && nBrightness > 100 ) Blue = (DWORD) ( ( nBrightness * 255 ) / 100 );
  206. ucBlue = (unsigned char) Blue;
  208. *pucNewRed = ucRed;
  209. *pucNewGreen = ucGreen;
  210. *pucNewBlue = ucBlue;
  212. }
  214. BOOL CImagePointProcesses::ReverseColors( int nX1, int nY1, int nX2, int nY2, CImageObject *pImageObject )
  215. {
  217. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  218. if( m_pImageObject == NULL ) return( FALSE );
  220. BOOL bLessThanHalf, bCompleteImage;
  221. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2, &bCompleteImage, &bLessThanHalf );
  223. unsigned char *pBuffer, *pBits, *pTemp;
  224. BITMAPINFOHEADER *pBIH;
  225. RGBQUAD *pPalette;
  226. int nWidthBytes, nNumColors, x, y, i;
  228. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  229. if( pBuffer == NULL ) return( FALSE );
  231. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  232. nNumColors = m_pImageObject->GetNumColors();
  233. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  234. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  236. LOGPALETTE *pLogPal = m_pImageObject->GetLogPal();
  237. CPalette *_pPalette = m_pImageObject->GetPalette();
  238. if( m_pImageObject->GetNumBits() > 8 && pLogPal != NULL && ( bCompleteImage || !bLessThanHalf ) ){
  239. _pPalette->DeleteObject();
  240. for( i=0; i<nNumColors; i++ ){
  241. pLogPal->palPalEntry[i].peRed = 255 - pLogPal->palPalEntry[i].peRed;
  242. pLogPal->palPalEntry[i].peGreen = 255 - pLogPal->palPalEntry[i].peGreen;
  243. pLogPal->palPalEntry[i].peBlue = 255 - pLogPal->palPalEntry[i].peBlue;
  244. }
  245. _pPalette->CreatePalette( pLogPal );
  246. }
  248. switch( m_pImageObject->GetNumBits() ){
  249. case 1:
  250. for( y=nY1; y<=nY2; y++ ){
  251. unsigned char Mask;
  252. pTemp = pBits;
  253. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 / 8 ) );
  254. for( x=nX1; x<=nX2; x++ ){
  255. Mask = 0x80 >> ( x & 7 );
  256. if( pTemp[0] & Mask ) pTemp[0] &= ( Mask ^ 0xff );
  257. else pTemp[0] |= Mask;
  258. if( ( x & 7 ) == 7 ) pTemp++;
  259. }
  260. }
  261. break;
  262. case 4:
  263.   if( bCompleteImage ){
  264. _pPalette->DeleteObject();
  265. for( i=0; i<nNumColors; i++ ){
  266. pPalette[i].rgbRed = 255 - pPalette[i].rgbRed;
  267. pPalette[i].rgbGreen = 255 - pPalette[i].rgbGreen;
  268. pPalette[i].rgbBlue = 255 - pPalette[i].rgbBlue;
  269. }
  270. {
  271. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  272. if( pLogPal != NULL ){
  273. _pPalette->CreatePalette( pLogPal );
  274. delete [] pLogPal;
  275. }
  276. }
  277. }
  278. else{
  279. unsigned char ucRed, ucGreen, ucBlue, Data;
  280. for( y=nY1; y<=nY2; y++ ){
  281. pTemp = pBits;
  282. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 / 2 ) );
  283. for( x=nX1; x<=nX2; x++ ){
  284. Data = *pTemp;
  285. if( !( x & 1 ) ) Data >>= 4;
  286. else Data &= 0x0f;
  287. ucRed = pPalette[Data].rgbRed;
  288. ucGreen = pPalette[Data].rgbGreen;
  289. ucBlue = pPalette[Data].rgbBlue;
  290. ucRed = 255 - ucRed;
  291. ucGreen = 255 - ucGreen;
  292. ucBlue = 255 - ucBlue;
  293. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  294. if( !( x & 1 ) ){
  295. Data <<= 4;
  296. (*pTemp) &= 0x0f;
  297. (*pTemp) |= Data;
  298. }
  299. else{
  300. (*pTemp) &= 0xf0;
  301. (*pTemp) |= Data;
  302. pTemp++;
  303. }
  304. }
  305. }
  306. }
  307. break;
  308. case 8:
  309. if( bCompleteImage ){
  310. _pPalette->DeleteObject();
  311. for( i=0; i<nNumColors; i++ ){
  312. pPalette[i].rgbRed = 255 - pPalette[i].rgbRed;
  313. pPalette[i].rgbGreen = 255 - pPalette[i].rgbGreen;
  314. pPalette[i].rgbBlue = 255 - pPalette[i].rgbBlue;
  315. }
  316. {
  317. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  318. if( pLogPal != NULL ){
  319. _pPalette->CreatePalette( pLogPal );
  320. delete [] pLogPal;
  321. }
  322. }
  323. }
  324. else{
  325. unsigned char ucRed, ucGreen, ucBlue, Data;
  326. for( y=nY1; y<=nY2; y++ ){
  327. pTemp = pBits;
  328. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + nX1 );
  329. for( x=nX1; x<=nX2; x++ ){
  330. Data = *pTemp;
  331. ucRed = pPalette[Data].rgbRed;
  332. ucGreen = pPalette[Data].rgbGreen;
  333. ucBlue = pPalette[Data].rgbBlue;
  334. ucRed = 255 - ucRed;
  335. ucGreen = 255 - ucGreen;
  336. ucBlue = 255 - ucBlue;
  337. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  338. *pTemp++ = Data;
  339. }
  340. }
  341. }
  342. break;
  343. case 16:
  344. for( y=nY1; y<=nY2; y++ ){
  345. pTemp = pBits;
  346. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 2 ) );
  347. for( x=nX1; x<=nX2; x++ ){
  348. }
  349. }
  350. break;
  351. case 24:
  352. for( y=nY1; y<=nY2; y++ ){
  353. pTemp = pBits;
  354. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 3 ) );
  355. for( x=nX1; x<=nX2; x++ ){
  356. pTemp[0] = 255 - pTemp[0];
  357. pTemp[1] = 255 - pTemp[1];
  358. pTemp[2] = 255 - pTemp[2];
  359. pTemp += 3;
  360. }
  361. }
  362. break;
  363. case 32:
  364. for( y=nY1; y<=nY2; y++ ){
  365. pTemp = pBits;
  366. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 4 ) );
  367. for( x=nX1; x<=nX2; x++ ){
  368. pTemp[0] = 255 - pTemp[0];
  369. pTemp[1] = 255 - pTemp[1];
  370. pTemp[2] = 255 - pTemp[2];
  371. pTemp[3] = 255 - pTemp[3];
  372. pTemp += 4;
  373. }
  374. }
  375. break;
  376. }
  378. ::GlobalUnlock( m_pImageObject->GetDib() );
  380. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  382. return( TRUE );
  384. }
  386. BOOL CImagePointProcesses::MakeGray( BOOL bSetPalette, CImageObject *pImageObject )
  387. {
  389. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  390. if( m_pImageObject == NULL ) return( FALSE );
  392. unsigned char *pBuffer, *pBits, *pTemp;
  393. BITMAPINFOHEADER *pBIH;
  394. RGBQUAD *pPalette;
  395. int nWidthBytes, nNumColors, x, y, i;
  396. WORD wColorBits, *pColorBits;
  398. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  399. if( pBuffer == NULL ) return( FALSE );
  401. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  402. nNumColors = m_pImageObject->GetNumColors();
  403. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  404. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  406. unsigned char *pLookup;
  407. DWORD dwGray;
  409. switch( m_pImageObject->GetNumBits() ){
  410. case 1:
  411. break;
  412. case 4:
  413. pLookup = new unsigned char [16];
  414. if( pLookup == NULL ) break;
  415. memset( pLookup, 0, 16 );
  416. for( i=0; i<16; i++ ){
  417. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  418. (DWORD) pPalette[i].rgbGreen * 59 +
  419. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  420. pLookup[i] = (unsigned char) dwGray;
  421. }
  422. for( i=0; i<16; i++ ){
  423. pPalette[i].rgbRed = pLookup[i];
  424. pPalette[i].rgbGreen = pLookup[i];
  425. pPalette[i].rgbBlue = pLookup[i];
  426. }
  427. delete [] pLookup;
  428. m_pImageObject->ProcessPalette();
  429. if( bSetPalette && m_pImageObject->m_nPaletteBytes > 0 ){
  430. CWindowDC WindowDC( NULL );
  431. m_pImageObject->SetPalette( &WindowDC );
  432. }
  433. break;
  434. case 8:
  435. pLookup = new unsigned char [256];
  436. if( pLookup == NULL ) break;
  437. memset( pLookup, 0, 256 );
  438. for( i=0; i<256; i++ ){
  439. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  440. (DWORD) pPalette[i].rgbGreen * 59 +
  441. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  442. pLookup[i] = (unsigned char) dwGray;
  443. }
  444. for( y=0; y<pBIH->biHeight; y++ ){
  445. pTemp = pBits;
  446. pTemp += y * nWidthBytes;
  447. for( x=0; x<pBIH->biWidth; x++ ) pTemp[x] = pLookup[pTemp[x]];
  448. }
  449. delete [] pLookup;
  450. for( i=0; i<256; i++ ){
  451. pPalette[i].rgbRed = i;
  452. pPalette[i].rgbGreen = i;
  453. pPalette[i].rgbBlue = i;
  454. }
  455. m_pImageObject->ProcessPalette();
  456. if( bSetPalette && m_pImageObject->m_nPaletteBytes > 0 ){
  457. CWindowDC WindowDC( NULL );
  458. m_pImageObject->SetPalette( &WindowDC );
  459. }
  460. break;
  461. case 16:
  462. for( y=0; y<pBIH->biHeight; y++ ){
  463. pTemp = pBits;
  464. pTemp += y * nWidthBytes;
  465. for( x=0; x<pBIH->biWidth; x++ ){
  466. pColorBits = (WORD *) pTemp[x*2];
  467. wColorBits = *pColorBits;
  468. dwGray = ( (DWORD) ( ( wColorBits & 0x7c00 ) >> 10 ) * 30 +
  469. (DWORD) ( ( wColorBits & 0x03e0 ) >> 5 ) * 59 +
  470. (DWORD) ( wColorBits & 0x001f ) * 11 ) / 100;
  471. *pColorBits = ( ( (WORD) dwGray << 10 ) | ( (WORD) dwGray << 5 ) | (WORD) dwGray);
  472. }
  473. }
  474. m_pImageObject->ProcessPalette();
  475. if( bSetPalette && m_pImageObject->m_nPaletteBytes > 0 ){
  476. CWindowDC WindowDC( NULL );
  477. m_pImageObject->SetPalette( &WindowDC );
  478. }
  479. break;
  480. case 24:
  481. for( y=0; y<pBIH->biHeight; y++ ){
  482. pTemp = pBits;
  483. pTemp += y * nWidthBytes;
  484. for( x=0; x<pBIH->biWidth; x++ ){
  485. dwGray = ( (DWORD) pTemp[x*3+2] * 30 +
  486. (DWORD) pTemp[x*3+1] * 59 +
  487. (DWORD) pTemp[x*3] * 11 ) / 100;
  488. pTemp[x*3] = (unsigned char) dwGray;
  489. pTemp[x*3+1] = (unsigned char) dwGray;
  490. pTemp[x*3+2] = (unsigned char) dwGray;
  491. }
  492. }
  493. m_pImageObject->ProcessPalette();
  494. if( bSetPalette && m_pImageObject->m_nPaletteBytes > 0 ){
  495. CWindowDC WindowDC( NULL );
  496. m_pImageObject->SetPalette( &WindowDC );
  497. }
  498. break;
  499. case 32:
  500. for( y=0; y<pBIH->biHeight; y++ ){
  501. pTemp = pBits;
  502. pTemp += y * nWidthBytes;
  503. for( x=0; x<pBIH->biWidth; x++ ){
  504. dwGray = ( (DWORD) pTemp[x*4] * 30 +
  505. (DWORD) pTemp[x*4+1] * 59 +
  506. (DWORD) pTemp[x*4+2] * 11 ) / 100;
  507. pTemp[x*4] = (unsigned char) dwGray;
  508. pTemp[x*4+1] = (unsigned char) dwGray;
  509. pTemp[x*4+2] = (unsigned char) dwGray;
  510. }
  511. }
  512. m_pImageObject->ProcessPalette();
  513. if( bSetPalette && m_pImageObject->m_nPaletteBytes > 0 ){
  514. CWindowDC WindowDC( NULL );
  515. m_pImageObject->SetPalette( &WindowDC );
  516. }
  517. break;
  518. }
  520. ::GlobalUnlock( m_pImageObject->GetDib() );
  522. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  524. return( TRUE );
  526. }
  528. BOOL CImagePointProcesses::Colorize( int nX1, int nY1, int nX2, int nY2, COLORREF Color, CImageObject *pImageObject )
  529. {
  531. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  532. if( m_pImageObject == NULL ) return( FALSE );
  534. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  536. BOOL bLessThanHalf, bCompleteImage;
  537. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2, &bCompleteImage, &bLessThanHalf );
  539. unsigned char *pBuffer, *pBits, *pTemp;
  540. BITMAPINFOHEADER *pBIH;
  541. RGBQUAD *pPalette;
  542. int nWidthBytes, nNumColors, x, y, i;
  544. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  545. if( pBuffer == NULL ) return( FALSE );
  547. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  548. nNumColors = m_pImageObject->GetNumColors();
  549. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  550. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  552. DWORD dwRed, dwGreen, dwBlue, dwGray;
  553. dwBlue = Color >> 16;
  554. dwGreen = ( Color >> 8 ) & 0x000000ff;
  555. dwRed = Color & 0x000000ff;
  557. LOGPALETTE *pLogPal = m_pImageObject->GetLogPal();
  558. CPalette *_pPalette = m_pImageObject->GetPalette();
  559. if( m_pImageObject->GetNumBits() > 8 && pLogPal != NULL && ( bCompleteImage || !bLessThanHalf ) ){
  560. _pPalette->DeleteObject();
  561. for( i=0; i<nNumColors; i++ ){
  562. dwGray = ( (DWORD) pLogPal->palPalEntry[i].peRed * 30 +
  563. (DWORD) pLogPal->palPalEntry[i].peGreen * 59 +
  564. (DWORD) pLogPal->palPalEntry[i].peBlue * 11 ) / 100;
  565. pLogPal->palPalEntry[i].peRed = (unsigned char) ( ( dwRed * dwGray ) / (DWORD) 255 );
  566. pLogPal->palPalEntry[i].peGreen = (unsigned char) ( ( dwGreen * dwGray ) / (DWORD) 255 );
  567. pLogPal->palPalEntry[i].peBlue = (unsigned char) ( ( dwBlue * dwGray ) / (DWORD) 255 );
  568. }
  569. _pPalette->CreatePalette( pLogPal );
  570. }
  572. switch( m_pImageObject->GetNumBits() ){
  573. case 4:
  574.   if( bCompleteImage ){
  575. _pPalette->DeleteObject();
  576. for( i=0; i<nNumColors; i++ ){
  577. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  578. (DWORD) pPalette[i].rgbGreen * 59 +
  579. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  580. pPalette[i].rgbRed = (unsigned char) ( ( dwRed * dwGray ) / (DWORD) 255 );
  581. pPalette[i].rgbGreen = (unsigned char) ( ( dwGreen * dwGray ) / (DWORD) 255 );
  582. pPalette[i].rgbBlue = (unsigned char) ( ( dwBlue * dwGray ) / (DWORD) 255 );
  583. }
  584. {
  585. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  586. if( pLogPal != NULL ){
  587. _pPalette->CreatePalette( pLogPal );
  588. delete [] pLogPal;
  589. }
  590. }
  591. }
  592. else{
  593. unsigned char ucRed, ucGreen, ucBlue, Data;
  594. for( y=nY1; y<=nY2; y++ ){
  595. pTemp = pBits;
  596. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 / 2 ) );
  597. for( x=nX1; x<=nX2; x++ ){
  598. Data = *pTemp;
  599. if( !( x & 1 ) ) Data >>= 4;
  600. else Data &= 0x0f;
  601. ucRed = pPalette[Data].rgbRed;
  602. ucGreen = pPalette[Data].rgbGreen;
  603. ucBlue = pPalette[Data].rgbBlue;
  604. ucRed = 255 - ucRed;
  605. ucGreen = 255 - ucGreen;
  606. ucBlue = 255 - ucBlue;
  607. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  608. if( !( x & 1 ) ){
  609. Data <<= 4;
  610. (*pTemp) &= 0x0f;
  611. (*pTemp) |= Data;
  612. }
  613. else{
  614. (*pTemp) &= 0xf0;
  615. (*pTemp) |= Data;
  616. pTemp++;
  617. }
  618. }
  619. }
  620. }
  621. break;
  622. case 8:
  623. if( bCompleteImage ){
  624. _pPalette->DeleteObject();
  625. for( i=0; i<nNumColors; i++ ){
  626. dwGray = ( (DWORD) pPalette[i].rgbRed * 30 +
  627. (DWORD) pPalette[i].rgbGreen * 59 +
  628. (DWORD) pPalette[i].rgbBlue * 11 ) / 100;
  629. pPalette[i].rgbRed = (unsigned char) ( ( dwRed * dwGray ) / (DWORD) 255 );
  630. pPalette[i].rgbGreen = (unsigned char) ( ( dwGreen * dwGray ) / (DWORD) 255 );
  631. pPalette[i].rgbBlue = (unsigned char) ( ( dwBlue * dwGray ) / (DWORD) 255 );
  632. }
  633. {
  634. LOGPALETTE *pLogPal = m_pImageObject->CreateLogPalette( pPalette, nNumColors );
  635. if( pLogPal != NULL ){
  636. _pPalette->CreatePalette( pLogPal );
  637. delete [] pLogPal;
  638. }
  639. }
  640. }
  641. else{
  642. unsigned char ucRed, ucGreen, ucBlue, Data;
  643. for( y=nY1; y<=nY2; y++ ){
  644. pTemp = pBits;
  645. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + nX1 );
  646. for( x=nX1; x<=nX2; x++ ){
  647. Data = *pTemp;
  648. dwGray = ( (DWORD) pPalette[Data].rgbRed * 30 +
  649. (DWORD) pPalette[Data].rgbGreen * 59 +
  650. (DWORD) pPalette[Data].rgbBlue * 11 ) / 100;
  651. ucRed = (unsigned char) ( ( dwRed * dwGray ) / (DWORD) 255 );
  652. ucGreen = (unsigned char) ( ( dwGreen * dwGray ) / (DWORD) 255 );
  653. ucBlue = (unsigned char) ( ( dwBlue * dwGray ) / (DWORD) 255 );
  654. Data = (unsigned char) m_pImageObject->GetNearestIndex( ucRed, ucGreen, ucBlue, pPalette, nNumColors );
  655. *pTemp++ = Data;
  656. }
  657. }
  658. }
  659. break;
  660. case 16:
  661. for( y=nY1; y<=nY2; y++ ){
  662. pTemp = pBits;
  663. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 2 ) );
  664. for( x=nX1; x<=nX2; x++ ){
  665. }
  666. }
  667. break;
  668. case 24:
  669. for( y=nY1; y<=nY2; y++ ){
  670. pTemp = pBits;
  671. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 3 ) );
  672. for( x=nX1; x<=nX2; x++ ){
  673. dwGray = ( (DWORD) pTemp[2] * 30 +
  674. (DWORD) pTemp[1] * 59 +
  675. (DWORD) pTemp[0] * 11 ) / 100;
  676. pTemp[2] = (unsigned char) ( ( dwRed * dwGray ) / (DWORD) 255 );
  677. pTemp[1] = (unsigned char) ( ( dwGreen * dwGray ) / (DWORD) 255 );
  678. pTemp[0] = (unsigned char) ( ( dwBlue * dwGray ) / (DWORD) 255 );
  679. pTemp += 3;
  680. }
  681. }
  682. break;
  683. case 32:
  684. for( y=nY1; y<=nY2; y++ ){
  685. pTemp = pBits;
  686. pTemp += ( ( ( m_pImageObject->GetHeight() - 1 - y ) * nWidthBytes ) + ( nX1 * 4 ) );
  687. for( x=nX1; x<=nX2; x++ ){
  688. pTemp[0] = 255 - pTemp[0];
  689. pTemp[1] = 255 - pTemp[1];
  690. pTemp[2] = 255 - pTemp[2];
  691. pTemp[3] = 255 - pTemp[3];
  692. pTemp += 4;
  693. }
  694. }
  695. break;
  696. }
  698. ::GlobalUnlock( m_pImageObject->GetDib() );
  700. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  702. return( TRUE );
  704. }
  706. void CImagePointProcesses::SetImageObjectClass( CImageObject *pImageObject )
  707. {
  709. m_pImageObject = pImageObject;
  711. }
  713. int *CImagePointProcesses::CreateHistogram( int nX1, int nY1, int nX2, int nY2, unsigned char *pData, RGBQUAD *pPalette, int nWidthBytes, CImageObject *pImageObject )
  714. {
  716. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  717. if( m_pImageObject == NULL ) return( FALSE );
  719. m_pImageObject->NormalizeCoordinates( &nX1, &nY1, &nX2, &nY2 );
  721. int *pBuffer = new int [256*4+4];
  722. if( pBuffer == NULL ) return( NULL );
  723. memset( pBuffer, 0, ( 256 * 4 + 4 ) * sizeof( int ) );
  725. DWORD dwGray;
  726. int x, y;
  727. unsigned char *pTemp, ucRed, ucGreen, ucBlue;
  728. int Pixels = 0;
  729. int nHeight = m_pImageObject->GetHeight();
  731. switch( m_pImageObject->GetNumBits() ){
  732. case 1:
  733. break;
  734. case 4:
  735. break;
  736. case 8:
  738. for( y=0; y<nHeight; y++ ){
  739. pTemp = pData;
  740. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  741. pTemp += nX1;
  742. for( x=nX1; x<=nX2; x++ ){
  743. ucRed = pPalette[pTemp[x]].rgbRed;
  744. ucGreen = pPalette[pTemp[x]].rgbGreen;
  745. ucBlue = pPalette[pTemp[x]].rgbBlue;
  746. dwGray = ( (DWORD) ucRed * 30 +
  747. (DWORD) ucGreen * 59 +
  748. (DWORD) ucBlue * 11 ) / 100;
  749. dwGray &= 0x000000ff;
  750. pBuffer[dwGray]++;
  751. pBuffer[256+ucRed]++;
  752. pBuffer[512+ucBlue]++;
  753. pBuffer[768+ucGreen]++;
  754. Pixels++;
  755. }
  756. }
  757. break;
  758. case 16:
  759. for( y=0; y<nHeight; y++ ){
  760. pTemp = pData;
  761. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  762. pTemp += ( nX1 * 2 );
  763. for( x=nX1; x<=nX2; x++ ){
  764. GETRGB555( ucRed, ucGreen, ucBlue, pTemp );
  765. dwGray = ( (DWORD) ucRed * 30 +
  766. (DWORD) ucGreen * 59 +
  767. (DWORD) ucBlue * 11 ) / 100;
  768. dwGray &= 0x000000ff;
  769. pBuffer[dwGray]++;
  770. pBuffer[256+pTemp[x*3]]++;
  771. pBuffer[512+pTemp[x*3+1]]++;
  772. pBuffer[768+pTemp[x*3+2]]++;
  773. Pixels++;
  774. pTemp += 2;
  775. }
  776. }
  777. break;
  778. case 24:
  779. for( y=0; y<nHeight; y++ ){
  780. pTemp = pData;
  781. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  782. pTemp += ( nX1 * 3 );
  783. for( x=nX1; x<=nX2; x++ ){
  784. dwGray = ( (DWORD) pTemp[x*3+2] * 30 +
  785. (DWORD) pTemp[x*3+1] * 59 +
  786. (DWORD) pTemp[x*3] * 11 ) / 100;
  787. dwGray &= 0x000000ff;
  788. pBuffer[dwGray]++;
  789. pBuffer[256+pTemp[x*3]]++;
  790. pBuffer[512+pTemp[x*3+1]]++;
  791. pBuffer[768+pTemp[x*3+2]]++;
  792. Pixels++;
  793. }
  794. }
  795. break;
  796. case 32:
  797. for( y=0; y<nHeight; y++ ){
  798. pTemp = pData;
  799. pTemp += ( ( nHeight - 1 - y ) * nWidthBytes );
  800. pTemp += ( nX1 * 4 );
  801. for( x=nX1; x<=nX2; x++ ){
  802. GETRGB888( ucRed, ucGreen, ucBlue, pTemp );
  803. dwGray = ( (DWORD) ucRed * 30 +
  804. (DWORD) ucGreen * 59 +
  805. (DWORD) ucBlue * 11 ) / 100;
  806. dwGray &= 0x000000ff;
  807. pBuffer[dwGray]++;
  808. pBuffer[256+pTemp[x*3]]++;
  809. pBuffer[512+pTemp[x*3+1]]++;
  810. pBuffer[768+pTemp[x*3+2]]++;
  811. Pixels++;
  812. pTemp += 4;
  813. }
  814. }
  815. break;
  816. }
  818. pBuffer[0] = pBuffer[256] = pBuffer[512] = pBuffer[768] = 0;
  819. int Highest = 0, i, j;
  820. for( i=0; i<256*4; i++ ){
  821. if( pBuffer[i] > Highest ) Highest = pBuffer[i];
  822. }
  823. for( j=0; j<4; j++ ){
  824. for( i=0; i<256; i++ ) pBuffer[j*256+i] = ( pBuffer[j*256+i] * 255 ) / Highest;
  825. }
  826. Highest = 0;
  827. for( i=0; i<256*4; i++ ){
  828. if( pBuffer[i] > Highest ) Highest = pBuffer[i];
  829. }
  830. pBuffer[256*4] = Highest;
  831. pBuffer[256*4+1] = Highest / 25;
  833. for( i=0; i<256; i++ ){
  834. if( pBuffer[i] >= pBuffer[256*4+1] ) break;
  835. }
  836. pBuffer[256*4+2] = i;
  837. for( i=255; i>=0; i-- ){
  838. if( pBuffer[i] >= pBuffer[256*4+1] ) break;
  839. }
  840. pBuffer[256*4+3] = i;
  841. if( pBuffer[256*4+2] > 255 ) pBuffer[256*4+2] = 255;
  842. if( pBuffer[256*4+3] < 0 ) pBuffer[256*4+3] = 0;
  844. return( pBuffer );
  846. }
  849. BOOL CImagePointProcesses::FFTTrans(CImageObject *pImageObject)
  850. {
  851. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  852. if( m_pImageObject == NULL ) return( FALSE );
  854. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  856. unsigned char *pBuffer, *pBits, *pTemp;
  857. BITMAPINFOHEADER *pBIH;
  858. RGBQUAD *pPalette;
  859. int nWidthBytes, nNumColors;
  861. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  862. if( pBuffer == NULL ) return( FALSE );
  864. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  865. nNumColors = m_pImageObject->GetNumColors();
  866. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  867. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  869.     int nTotalPixel = pBIH->biWidth * pBIH->biHeight;
  870. int nWidth = pBIH->biWidth;
  871. int nHeight = pBIH->biHeight;
  872. double (* fftBuffer)[2] = new double[nTotalPixel][2];
  873. long x, y;
  874. unsigned char ucRed, ucGreen, ucBlue;
  875. DWORD dwGray;
  877. switch( m_pImageObject->GetNumBits() )
  878. {
  879. case 1:
  880. break;
  881. case 4:
  882. break;
  883. case 8:
  884. for( y=0; y<nHeight; y++ ){
  885. pTemp = pBits;
  886. pTemp += y * nWidthBytes;
  887. for( x=0; x<nWidth; x++ ){
  888. ucRed = pPalette[pTemp[x]].rgbRed;
  889. ucGreen = pPalette[pTemp[x]].rgbGreen;
  890. ucBlue = pPalette[pTemp[x]].rgbBlue;
  891. dwGray = ( (DWORD) ucRed * 30 +
  892. (DWORD) ucGreen * 59 +
  893. (DWORD) ucBlue * 11 ) / 100;
  894. dwGray &= 0x000000ff;
  895. fftBuffer[y*nWidth+x][0] = (double) dwGray;
  896. fftBuffer[y*nWidth+x][1] = 0.0;
  897. }
  898. }
  899. break;
  900. }
  902. double * pCos =  new double[nHeight/2];
  903. double * pSin =  new double[nHeight/2];
  904. int * l = new int[nHeight];
  905. calW(pCos, pSin, l, nHeight);
  906. // char strTime[35];
  907. // LARGE_INTEGER Frequency;
  908. // LARGE_INTEGER PerformanceCount1, PerformanceCount2;
  909. // QueryPerformanceFrequency(&Frequency);
  910. // QueryPerformanceCounter(&PerformanceCount1);
  911. for(y=0; y<nHeight; y++){
  912. fft(fftBuffer+nWidth*y, pCos, pSin, l, nWidth);
  913. }
  914. imposition(fftBuffer, nWidth);
  915. for(x=0; x<nWidth; x++){
  916. fft(fftBuffer+nHeight*x, pCos, pSin, l, nHeight);
  917. }
  918. imposition(fftBuffer, nHeight);
  919. // QueryPerformanceCounter(&PerformanceCount2);
  920. // sprintf(strTime, "共耗时：%ld", PerformanceCount2.QuadPart-PerformanceCount1.QuadPart);
  921. // AfxMessageBox(strTime);
  923. double max = 0.0;
  924. for(y=0; y<nHeight; y++){
  925. for(x=0; x<nWidth; x++){
  926. double real = fftBuffer[y*nWidth+x][0];
  927. double img = fftBuffer[y*nWidth+x][1];
  928. double amp;
  929. amp = fftBuffer[y*nWidth+x][0] = log(sqrt(real*real + img*img)+1.0);
  930. max = ((amp>max) ? amp : max);
  931. }
  932. }
  933. for(y=0; y<nHeight; y++){
  934. for(x=0; x<nWidth; x++){
  935. long newx = (x>127)?(x-128):(x+128);
  936. long newy = (y>127)?(y-128):(y+128);
  937. pBits[newy*nWidthBytes+newx] = (unsigned char)(fftBuffer[y*nWidth+x][0]/max * 255.0);
  938. }
  939. }
  941. ::GlobalUnlock( m_pImageObject->GetDib() );
  942. delete[] fftBuffer;
  943. delete[] pCos;
  944. delete[] pSin;
  945. delete[] l;
  947. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  949. return( TRUE );
  950. }
  952. BOOL CImagePointProcesses::DCTTrans(CImageObject * pImageObject)
  953. {
  954. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  955. if( m_pImageObject == NULL ) return( FALSE );
  957. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  959. unsigned char *pBuffer, *pBits, *pTemp;
  960. BITMAPINFOHEADER *pBIH;
  961. RGBQUAD *pPalette;
  962. int nWidthBytes, nNumColors;
  964. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  965. if( pBuffer == NULL ) return( FALSE );
  967. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  968. nNumColors = m_pImageObject->GetNumColors();
  969. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  970. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  972.     int nTotalPixel = pBIH->biWidth * pBIH->biHeight;
  973. int nWidth = pBIH->biWidth;
  974. int nHeight = pBIH->biHeight;
  975. double (* dctBuffer) = new double[nTotalPixel];
  976. long x, y;
  977. unsigned char ucRed, ucGreen, ucBlue;
  978. DWORD dwGray;
  980. switch( m_pImageObject->GetNumBits() )
  981. {
  982. case 1:
  983. break;
  984. case 4:
  985. break;
  986. case 8:
  987. for( y=0; y<nHeight; y++ ){
  988. pTemp = pBits;
  989. pTemp += y * nWidthBytes;
  990. for( x=0; x<nWidth; x++ ){
  991. ucRed = pPalette[pTemp[x]].rgbRed;
  992. ucGreen = pPalette[pTemp[x]].rgbGreen;
  993. ucBlue = pPalette[pTemp[x]].rgbBlue;
  994. dwGray = ( (DWORD) ucRed * 30 +
  995. (DWORD) ucGreen * 59 +
  996. (DWORD) ucBlue * 11 ) / 100;
  997. dwGray &= 0x000000ff;
  998. dctBuffer[y*nWidth+x] = (double) dwGray;
  999. }
  1000. }
  1001. break;
  1002. }
  1004. double * pCos =  new double[nHeight/2];
  1005. double * pSin =  new double[nHeight/2];
  1006. int * l = new int[nHeight];
  1007. calW(pCos, pSin, l, nHeight);
  1009. for(y=0; y<nHeight; y++){
  1010. dct(dctBuffer+nWidth*y, pCos, pSin, l, nWidth);
  1011. }
  1012. imposition(dctBuffer, nWidth);
  1013. for(x=0; x<nWidth; x++){
  1014. dct(dctBuffer+nHeight*x, pCos, pSin, l, nHeight);
  1015. }
  1016. imposition(dctBuffer, nHeight);
  1018. double max = 0.0;
  1019. for(y=0; y<nHeight; y++){
  1020. for(x=0; x<nWidth; x++){
  1021. double result;
  1022. result = dctBuffer[y*nWidth+x] = log10(fabs(dctBuffer[y*nWidth+x])+1.0);
  1023. max = ((result>max) ? result : max);
  1024. }
  1025. }
  1026. for(y=0; y<nHeight; y++){
  1027. for(x=0; x<nWidth; x++){
  1028. pBits[y*nWidth+x] = (unsigned char)(dctBuffer[(nHeight-1-y)*nWidth+x]/max*255.0);
  1029. }
  1030. }
  1032. delete[] dctBuffer;
  1033. delete[] pCos;
  1034. delete[] pSin;
  1035. delete[] l;
  1036. ::GlobalUnlock( m_pImageObject->GetDib() );
  1038. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  1040. return( TRUE );
  1042. }
  1044. BOOL CImagePointProcesses::EdgeDetect(CImageObject *pImageObject)
  1045. {
  1046. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  1047. if( m_pImageObject == NULL ) return( FALSE );
  1049. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  1051. unsigned char *pBuffer, *pBits, *pTemp;
  1052. BITMAPINFOHEADER *pBIH;
  1053. RGBQUAD *pPalette;
  1054. int nWidthBytes, nNumColors;
  1056. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  1057. if( pBuffer == NULL ) return( FALSE );
  1059. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1060. nNumColors = m_pImageObject->GetNumColors();
  1061. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1062. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1064.     int nTotalPixel = pBIH->biWidth * pBIH->biHeight;
  1065. int nWidth = pBIH->biWidth;
  1066. int nHeight = pBIH->biHeight;
  1067. double * Buffer = new double[nTotalPixel];
  1068. double * Bridge = new double[nTotalPixel];
  1069. long x, y;
  1070. unsigned char ucRed, ucGreen, ucBlue;
  1071. DWORD dwGray;
  1073. switch( m_pImageObject->GetNumBits() )
  1074. {
  1075. case 1:
  1076. break;
  1077. case 4:
  1078. break;
  1079. case 8:
  1080. for( y=0; y<nHeight; y++ ){
  1081. pTemp = pBits;
  1082. pTemp += y * nWidthBytes;
  1083. for( x=0; x<nWidth; x++ ){
  1084. ucRed = pPalette[pTemp[x]].rgbRed;
  1085. ucGreen = pPalette[pTemp[x]].rgbGreen;
  1086. ucBlue = pPalette[pTemp[x]].rgbBlue;
  1087. dwGray = ( (DWORD) ucRed * 30 +
  1088. (DWORD) ucGreen * 59 +
  1089. (DWORD) ucBlue * 11 ) / 100;
  1090. dwGray &= 0x000000ff;
  1091. Buffer[y*nWidth+x] = Bridge[y*nWidth+x] = (double) dwGray;
  1092. }
  1093. }
  1094. break;
  1095. }
  1097. double temp1, temp2;
  1098. for(y=1; y<nHeight-1; y++)
  1099. {
  1100. for(x=1; x<nWidth-1; x++)
  1101. {
  1102. switch(EdgeDetectType)
  1103. {
  1104. case LAPLACE:
  1105.    temp1 = -Bridge[(x-1)+y*nWidth]
  1106.    -Bridge[(x+1)+y*nWidth]
  1107.    -Bridge[x+(y-1)*nWidth]
  1108.    -Bridge[x+(y+1)*nWidth]
  1109.    +Bridge[x+y*nWidth]*4;
  1110.    temp2 = -Bridge[(x-1)+(y-1)*nWidth]
  1111.    -Bridge[x+(y-1)*nWidth]
  1112.    -Bridge[(x+1)+(y-1)*nWidth]
  1113.    -Bridge[(x-1)+y*nWidth]
  1114.    +Bridge[x+y*nWidth]*8
  1115.    -Bridge[(x+1)+y*nWidth]
  1116.    -Bridge[(x-1)+(y+1)*nWidth]
  1117.    -Bridge[x+(y+1)*nWidth]
  1118.    -Bridge[(x+1)+(y+1)*nWidth];
  1119.    Buffer[x+y*nWidth]=temp1+temp2;
  1120.    break;
  1121. case SOBEL:
  1122.    temp1 = -Bridge[(x-1)+(y-1)*nWidth]
  1123.    +Bridge[(x+1)+(y-1)*nWidth]
  1124.    -Bridge[(x-1)+y*nWidth]*2
  1125.    +Bridge[(x+1)+y*nWidth]*2
  1126.    -Bridge[(x-1)+(y+1)*nWidth]
  1127.    +Bridge[(x+1)+(y+1)*nWidth];
  1128.    temp2 = Bridge[(x-1)+(y-1)*nWidth]
  1129.    +Bridge[x+(y-1)*nWidth]*2
  1130.    +Bridge[(x+1)+(y-1)*nWidth]
  1131.    -Bridge[(x-1)+(y+1)*nWidth]
  1132.    -Bridge[x+(y+1)*nWidth]*2
  1133.    -Bridge[(x+1)+(y+1)*nWidth];
  1134.    Buffer[x+y*nWidth]=temp1+temp2;
  1135.    break;
  1136. case PREWITT:
  1137.    temp1 = -Bridge[(x-1)+(y-1)*nWidth]
  1138.    +Bridge[(x+1)+(y-1)*nWidth]
  1139.    -Bridge[(x-1)+y*nWidth]
  1140.    +Bridge[(x+1)+y*nWidth]
  1141.    -Bridge[(x-1)+(y+1)*nWidth]
  1142.    +Bridge[(x+1)+(y+1)*nWidth];
  1143.    temp2 = Bridge[(x-1)+(y-1)*nWidth]
  1144.    +Bridge[x+(y-1)*nWidth]
  1145.    +Bridge[(x+1)+(y-1)*nWidth]
  1146.    -Bridge[(x-1)+(y+1)*nWidth]
  1147.    -Bridge[x+(y+1)*nWidth]
  1148.    -Bridge[(x+1)+(y+1)*nWidth];
  1149.    Buffer[x+y*nWidth]=temp1+temp2;
  1150.    break;
  1151. }
  1152. }
  1153. }
  1155. double max = 0.0;
  1156. double min = 0.0;
  1157. for(y=0; y<nHeight; y++){
  1158. for(x=0; x<nWidth; x++){
  1159. double amp = Buffer[y*nWidth+x];
  1160. max = ((amp>max) ? amp : max);
  1161. min = ((amp<min) ? amp : min);
  1162. }
  1163. }
  1164. for(y=0; y<nHeight; y++){
  1165. for(x=0; x<nWidth; x++){
  1166. if(Embossed)
  1167. pBits[y*nWidthBytes+x] = (unsigned char)((Buffer[y*nWidth+x]-min)/(max-min)*255.0);
  1168. else
  1169. {
  1170. if(Buffer[y*nWidth+x]>255.0) Buffer[y*nWidth+x]=255.0;
  1171. else if(Buffer[y*nWidth+x]<0.0) Buffer[y*nWidth+x] = 0.0;
  1172. pBits[y*nWidthBytes+x] = (unsigned char)Buffer[y*nWidth+x];
  1173. }
  1174. }
  1175. }
  1177. ::GlobalUnlock( m_pImageObject->GetDib() );
  1178. if(Buffer) delete[] Buffer;
  1179. if(Bridge) delete[] Bridge;
  1181. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  1183. return( TRUE );
  1185. }
  1187. BOOL CImagePointProcesses::AddNoise(CImageObject * pImageObject, int nRatio)
  1188. {
  1189. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  1190. if( m_pImageObject == NULL ) return( FALSE );
  1192. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  1194. unsigned char *pBuffer, *pBits;
  1195. BITMAPINFOHEADER *pBIH;
  1196. RGBQUAD *pPalette;
  1197. int nWidthBytes, nNumColors;
  1199. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  1200. if( pBuffer == NULL ) return( FALSE );
  1202. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1203. nNumColors = m_pImageObject->GetNumColors();
  1204. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1205. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1207.     int nTotalPixel = pBIH->biWidth * pBIH->biHeight;
  1208. int nWidth = pBIH->biWidth;
  1209. int nHeight = pBIH->biHeight;
  1210. long x, y;
  1212. int temp;
  1213. srand( (unsigned)time(NULL) );
  1214. for(y=0; y<nHeight; y++){
  1215. for(x=0; x<nWidth; x++)
  1216. {
  1217. temp = rand();
  1218. if(temp < RAND_MAX*nRatio/100) pBits[y*nWidthBytes+x] = (unsigned char)255.0;
  1219. }
  1220. }
  1222. ::GlobalUnlock( m_pImageObject->GetDib() );
  1224. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  1226. return( TRUE );
  1228. }
  1231. BOOL CImagePointProcesses::ExtractRiver(CPoint *pStartPoint, CImageObject *pImageObject)
  1232. {
  1233. CPoint presetPoint(42, 6);
  1234. if( pImageObject != NULL ) m_pImageObject = pImageObject;
  1235. if( m_pImageObject == NULL ) return( FALSE );
  1236. if(pStartPoint == NULL)
  1237. {
  1238. pStartPoint = &presetPoint;
  1239. }
  1241. EdgeDetectType = LAPLACE;
  1243. if( m_pImageObject->GetNumBits() == 1 ) return( FALSE );
  1245. unsigned char *pBuffer, *pBits, *pTemp;
  1246. BITMAPINFOHEADER *pBIH;
  1247. RGBQUAD *pPalette;
  1248. int nWidthBytes, nNumColors;
  1250. pBuffer = (unsigned char *) m_pImageObject->GetDIBPointer( &nWidthBytes, m_pImageObject->GetNumBits() );
  1251. if( pBuffer == NULL ) return( FALSE );
  1253. pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
  1254. nNumColors = m_pImageObject->GetNumColors();
  1255. pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
  1256. pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
  1258.     int nTotalPixel = pBIH->biWidth * pBIH->biHeight;
  1259. int nWidth = pBIH->biWidth;
  1260. int nHeight = pBIH->biHeight;
  1261. double * Buffer = new double[nTotalPixel];
  1262. double * Bridge = new double[nTotalPixel];
  1263. long x, y;
  1264. unsigned char ucRed, ucGreen, ucBlue;
  1265. DWORD dwGray;
  1267. switch( m_pImageObject->GetNumBits() )
  1268. {
  1269. case 1:
  1270. break;
  1271. case 4:
  1272. break;
  1273. case 8:
  1274. for( y=0; y<nHeight; y++ ){
  1275. pTemp = pBits;
  1276. pTemp += y * nWidthBytes;
  1277. for( x=0; x<nWidth; x++ ){
  1278. ucRed = pPalette[pTemp[x]].rgbRed;
  1279. ucGreen = pPalette[pTemp[x]].rgbGreen;
  1280. ucBlue = pPalette[pTemp[x]].rgbBlue;
  1281. dwGray = ( (DWORD) ucRed * 30 +
  1282. (DWORD) ucGreen * 59 +
  1283. (DWORD) ucBlue * 11 ) / 100;
  1284. dwGray &= 0x000000ff;
  1285. Buffer[y*nWidth+x] = Bridge[y*nWidth+x] = (double) dwGray;
  1286. }
  1287. }
  1288. break;
  1289. }
  1291. /* double temp1, temp2;
  1292. for(y=1; y<nHeight-1; y++)
  1293. {
  1294. for(x=1; x<nWidth-1; x++)
  1295. {
  1296. switch(EdgeDetectType)
  1297. {
  1298. case LAPLACE:
  1299.    temp1 = -Bridge[(x-1)+y*nWidth]
  1300.    -Bridge[(x+1)+y*nWidth]
  1301.    -Bridge[x+(y-1)*nWidth]
  1302.    -Bridge[x+(y+1)*nWidth]
  1303.    +Bridge[x+y*nWidth]*4;
  1304.    temp2 = -Bridge[(x-1)+(y-1)*nWidth]
  1305.    -Bridge[x+(y-1)*nWidth]
  1306.    -Bridge[(x+1)+(y-1)*nWidth]
  1307.    -Bridge[(x-1)+y*nWidth]
  1308.    +Bridge[x+y*nWidth]*8
  1309.    -Bridge[(x+1)+y*nWidth]
  1310.    -Bridge[(x-1)+(y+1)*nWidth]
  1311.    -Bridge[x+(y+1)*nWidth]
  1312.    -Bridge[(x+1)+(y+1)*nWidth];
  1313.    Buffer[x+y*nWidth]=temp1+temp2;
  1314.    break;
  1315. case SOBEL:
  1316.    temp1 = -Bridge[(x-1)+(y-1)*nWidth]
  1317.    +Bridge[(x+1)+(y-1)*nWidth]
  1318.    -Bridge[(x-1)+y*nWidth]*2
  1319.    +Bridge[(x+1)+y*nWidth]*2
  1320.    -Bridge[(x-1)+(y+1)*nWidth]
  1321.    +Bridge[(x+1)+(y+1)*nWidth];
  1322.    temp2 = Bridge[(x-1)+(y-1)*nWidth]
  1323.    +Bridge[x+(y-1)*nWidth]*2
  1324.    +Bridge[(x+1)+(y-1)*nWidth]
  1325.    -Bridge[(x-1)+(y+1)*nWidth]
  1326.    -Bridge[x+(y+1)*nWidth]*2
  1327.    -Bridge[(x+1)+(y+1)*nWidth];
  1328.    Buffer[x+y*nWidth]=temp1+temp2;
  1329.    break;
  1330. case PREWITT:
  1331.    temp1 = -Bridge[(x-1)+(y-1)*nWidth]
  1332.    +Bridge[(x+1)+(y-1)*nWidth]
  1333.    -Bridge[(x-1)+y*nWidth]
  1334.    +Bridge[(x+1)+y*nWidth]
  1335.    -Bridge[(x-1)+(y+1)*nWidth]
  1336.    +Bridge[(x+1)+(y+1)*nWidth];
  1337.    temp2 = Bridge[(x-1)+(y-1)*nWidth]
  1338.    +Bridge[x+(y-1)*nWidth]
  1339.    +Bridge[(x+1)+(y-1)*nWidth]
  1340.    -Bridge[(x-1)+(y+1)*nWidth]
  1341.    -Bridge[x+(y+1)*nWidth]
  1342.    -Bridge[(x+1)+(y+1)*nWidth];
  1343.    Buffer[x+y*nWidth]=temp1+temp2;
  1344.    break;
  1345. }
  1346. }
  1347. }
  1349. double max = 0.0;
  1350. double min = 0.0;
  1351. for(y=0; y<nHeight; y++){
  1352. for(x=0; x<nWidth; x++){
  1353. double amp = Buffer[y*nWidth+x];
  1354. max = ((amp>max) ? amp : max);
  1355. min = ((amp<min) ? amp : min);
  1356. }
  1357. }
  1358. for(y=0; y<nHeight; y++){
  1359. for(x=0; x<nWidth; x++){
  1360. if(Embossed)
  1361. pBits[y*nWidthBytes+x] = (unsigned char)((Buffer[y*nWidth+x]-min)/(max-min)*255.0);
  1362. else
  1363. {
  1364. // if(Buffer[y*nWidth+x]>255.0) Buffer[y*nWidth+x]=255.0;
  1365. // else if(Buffer[y*nWidth+x]<0.0) Buffer[y*nWidth+x] = 0.0;
  1366. #define SIDE 1
  1367. if(y > SIDE && y < 255-SIDE && x > SIDE && x < 255-SIDE)
  1368. {
  1369. if(Buffer[y*nWidth+x]>150.0)
  1370. Buffer[y*nWidth+x]=0.0;
  1371. else if(Buffer[y*nWidth+x]<=150.0)
  1372. Buffer[y*nWidth+x] = 255.0;
  1373. }
  1374. else
  1375. Buffer[y*nWidth+x] = 255.0;
  1376. pBits[y*nWidthBytes+x] = (unsigned char)Buffer[y*nWidth+x];
  1377. }
  1378. }
  1379. }
  1380. */
  1381. for(y=0; y<nHeight; y++){
  1382. for(x=0; x<nWidth; x++){
  1383. if(Buffer[y*nWidth+x]>150.0)
  1384. Buffer[y*nWidth+x]=255.0;
  1385. else if(Buffer[y*nWidth+x]<=150.0)
  1386. Buffer[y*nWidth+x] = 0.0;
  1387. pBits[y*nWidthBytes+x] = (unsigned char)Buffer[y*nWidth+x];
  1388. }
  1389. }
  1390. //提取河流
  1391. TraceDIB((char *)pBits, nWidth, nHeight);
  1392. /*
  1393. #define NEAR_POINT 4
  1394. double CurPointColor = Buffer[pStartPoint->x + nWidth*pStartPoint->y];
  1395. int curX = pStartPoint->x;
  1396. int count = 0;
  1397. double dist = 0.0;
  1398. int threshold = 1;
  1399. int upper_thres = 250;
  1400. int low_thres = 250;
  1401. int j;
  1403. RiverTrack[0].x = 44;//pStartPoint->x;
  1404. RiverTrack[0].y = 4;pStartPoint->y;
  1405. // for(x = RiverTrack[0].x; x < nWidth; x ++)
  1406. // {
  1407. // for(y = 0; y < 256; y ++)
  1408. for(y = RiverTrack[0].y; y < nHeight; y ++)
  1409. {
  1410. for(x = 0; x < 256; x ++)
  1411. {
  1412. if(Buffer[y*nWidth + x] >= upper_thres)
  1413. {
  1414. count ++;
  1415. RiverTrack[count].x = x;
  1416. RiverTrack[count].y = y;
  1417. }
  1418. else if(Buffer[y*nWidth + x] >= low_thres)
  1419. {
  1420. dist = (x-RiverTrack[count].x)*(x-RiverTrack[count].x)
  1421. + (y-RiverTrack[count].y)*(y-RiverTrack[count].y);
  1422. if(dist < threshold * threshold)
  1423. {
  1424. count ++;
  1425. RiverTrack[count].x = x;
  1426. RiverTrack[count].y = y;
  1427. }
  1428. }
  1429. }
  1430. }
  1431. //画出来
  1432. for(y = 0; y < nHeight; y ++)
  1433. for(x = 0; x < nWidth; x ++)
  1434. pBits[y*nWidthBytes + x] = 0;
  1435. for(j=0; j<count; j++)
  1436. {
  1437. pBits[RiverTrack[j].y*nWidthBytes + RiverTrack[j].x] = 255;
  1438. }
  1439. */
  1440. ::GlobalUnlock( m_pImageObject->GetDib() );
  1441. if(Buffer) delete[] Buffer;
  1442. if(Bridge) delete[] Bridge;
  1444. m_pImageObject->m_nLastError = IMAGELIB_SUCCESS;
  1446. return( TRUE );
  1447. }