Category

Development Platform
Home > SourceCode/Document > Graph program > Special Effects > View Code
DIB.cpp
Package: dip.rar　[view]
Upload User: hongxinly
Upload Date: 2022-06-13
Package Size: 2588k
Code Size: 21k
Category:

Special Effects

Development Platform:

Visual C++

DIB.cpp：Code Content
  1. // DIB.cpp
  3. #include "ShowDIB.h"
  4. #include "ShowDIBDoc.h"
  5. #include "ShowDIBView.h"
  6. #include "stdafx.h"
  7. #include "DIB.h"
  8. #include"math.h"
  9. #include"afxwin.h"
  10. #include"stdlib.h"
  11. #define PI (double)3.14159265359
  13. CDib::CDib()
  14. {
  16. // Set the Dib pointer to
  17. // NULL so we know if it's
  18. // been loaded.
  19. m_pDib = NULL;
  20. m_pWordData = NULL;
  21. }
  23. CDib::~CDib()
  24. {
  26. // If a Dib has been loaded,
  27. // delete the memory.
  28. if( m_pDib != NULL )
  29. delete [] m_pDib;
  30. if( m_pWordData != NULL )
  31. delete [] m_pWordData;
  33. }
  35. BOOL CDib::Load( const char *pszFilename )
  36. {
  38. CFile cf;
  39. int i,j;
  41. // Attempt to open the Dib file for reading.
  42. if( !cf.Open( pszFilename, CFile::modeRead ) )
  43. return( FALSE );
  45. // Get the size of the file and store
  46. // in a local variable. Subtract the
  47. // size of the BITMAPFILEHEADER structure
  48. // since we won't keep that in memory.
  49. DWORD dwDibSize;
  50. dwDibSize =
  51. cf.GetLength() - sizeof( BITMAPFILEHEADER );
  53. // Attempt to allocate the Dib memory.
  54. unsigned char *pDib;
  55. pDib = new unsigned char [dwDibSize];
  56. if( pDib == NULL )
  57. return( FALSE );
  59. BITMAPFILEHEADER BFH;
  61. // Read in the Dib header and data.
  62. try{
  64. // Did we read in the entire BITMAPFILEHEADER?
  65. if( cf.Read( &BFH, sizeof( BITMAPFILEHEADER ) )
  66. != sizeof( BITMAPFILEHEADER ) ||
  68. // Is the type 'MB'?
  69. BFH.bfType != 'MB' ||
  71. // Did we read in the remaining data?
  72. cf.Read( pDib, dwDibSize ) != dwDibSize ){
  74. // Delete the memory if we had any
  75. // errors and return FALSE.
  76. delete [] pDib;
  77. return( FALSE );
  78. }
  79. }
  81. // If we catch an exception, delete the
  82. // exception, the temporary Dib memory,
  83. // and return FALSE.
  84. catch( CFileException *e ){
  85. e->Delete();
  86. delete [] pDib;
  87. return( FALSE );
  88. }
  90. cf.Close();
  91. // If we got to this point, the Dib has been
  92. // loaded. If a Dib was already loaded into
  93. // this class, we must now delete it.
  94. if( m_pDib != NULL )
  95. delete m_pDib;
  97. // Store the local Dib data pointer and
  98. // Dib size variables in the class member
  99. // variables.
  100. m_pDib = pDib;
  101. m_dwDibSize = dwDibSize;
  103. // Pointer our BITMAPINFOHEADER and RGBQUAD
  104. // variables to the correct place in the Dib data.
  105. m_pBIH = (BITMAPINFOHEADER *) m_pDib;
  106. m_pPalette =
  107. (RGBQUAD *) &m_pDib[sizeof(BITMAPINFOHEADER)];
  109. // Calculate the number of palette entries.
  110. m_nPaletteEntries = 1 << m_pBIH->biBitCount;
  111. if( m_pBIH->biBitCount > 8 )
  112. m_nPaletteEntries = 0;
  113. else if( m_pBIH->biClrUsed != 0 )
  114. m_nPaletteEntries = m_pBIH->biClrUsed;
  116. // Point m_pDibBits to the actual Dib bits data.
  117. m_pDibBits =
  118. &m_pDib[sizeof(BITMAPINFOHEADER)+m_nPaletteEntries*sizeof(RGBQUAD)];
  120. // If we have a valid palette, delete it.
  121. if( m_Palette.GetSafeHandle() != NULL )
  122. m_Palette.DeleteObject();
  124. // If there are palette entries, we'll need
  125. // to create a LOGPALETTE then create the
  126. // CPalette palette.
  127. if( m_nPaletteEntries != 0 ){
  129. // Allocate the LOGPALETTE structure.
  130. LOGPALETTE *pLogPal = (LOGPALETTE *) new char
  131. [sizeof(LOGPALETTE)+
  132. m_nPaletteEntries*sizeof(PALETTEENTRY)];
  134. if( pLogPal != NULL ){
  136. // Set the LOGPALETTE to version 0x300
  137. // and store the number of palette
  138. // entries.
  139. pLogPal->palVersion = 0x300;
  140. pLogPal->palNumEntries = m_nPaletteEntries;
  142. // Store the RGB values into each
  143. // PALETTEENTRY element.
  144. for( int i=0; i<m_nPaletteEntries; i++ ){
  145. pLogPal->palPalEntry[i].peRed =
  146. m_pPalette[i].rgbRed;
  147. pLogPal->palPalEntry[i].peGreen =
  148. m_pPalette[i].rgbGreen;
  149. pLogPal->palPalEntry[i].peBlue =
  150. m_pPalette[i].rgbBlue;
  151. }
  153. // Create the CPalette object and
  154. // delete the LOGPALETTE memory.
  155. m_Palette.CreatePalette( pLogPal );
  156. delete [] pLogPal;
  157. }
  158. }
  160. m_BitCount = 8;
  161. m_nWidth = m_pBIH->biWidth;
  162. m_nHeight = m_pBIH->biHeight;
  164.   m_nWidth_Step = 4*(!!(m_nWidth%4)); // if m_nWidth%4 == 0, we get 0, otherwise we get 4;
  165. m_nWidth_Step += (m_nWidth>>2)<<2;
  167. if (m_pBIH->biBitCount == 24)
  168. {
  169. MessageBox(NULL,"请自行编写转化为灰度图像的程序","说明",MB_OK);
  170. }
  172. temp =new int [m_nHeight*m_nWidth];
  173. tmp_Height = m_nHeight;
  174. tmp_Width = m_nWidth;
  176. for (i=0;i<m_nHeight;++i)
  177. {
  178. for (j=0;j<m_nWidth;++j)
  179. {
  180. temp[i*m_nWidth_Step+j] = m_pDibBits[i*m_nWidth_Step+j];
  181. }
  182. }
  183. return( TRUE );
  184. }
  186. BOOL CDib::Save( const char *pszFilename )
  187. {
  189. // If we have no data, we can't save.
  190. if( m_pDib == NULL )
  191. return( FALSE );
  193. CFile cf;
  195. // Attempt to create the file.
  196. if( !cf.Open( pszFilename,
  197. CFile::modeCreate | CFile::modeWrite ) )
  198. return( FALSE );
  200. // Write the data.
  201. try{
  203. // First, create a BITMAPFILEHEADER
  204. // with the correct data.
  205. BITMAPFILEHEADER BFH;
  206. memset( &BFH, 0, sizeof( BITMAPFILEHEADER ) );
  207. BFH.bfType = 'MB';
  208. BFH.bfSize = sizeof( BITMAPFILEHEADER ) + m_dwDibSize;
  209. BFH.bfOffBits = sizeof( BITMAPFILEHEADER ) +
  210. sizeof( BITMAPINFOHEADER ) +
  211. m_nPaletteEntries * sizeof( RGBQUAD );
  213. // Write the BITMAPFILEHEADER and the
  214. // Dib data.
  215. cf.Write( &BFH, sizeof( BITMAPFILEHEADER ) );
  216. cf.Write( m_pDib, m_dwDibSize );
  217. }
  219. // If we get an exception, delete the exception and
  220. // return FALSE.
  221. catch( CFileException *e ){
  222. e->Delete();
  223. return( FALSE );
  224. }
  226. return( TRUE );
  228. }
  230. BOOL CDib::Draw( CDC *pDC, int nX, int nY, int nWidth, int nHeight, int Style )
  231. {
  232.   long i,j;
  233.   // If we have not data we can't draw.
  234.   if( m_pDib == NULL )
  235. return( FALSE );
  236.   // if this is an 16/12 bit image, 
  237.   // we should map the 16/12 data to 8 bit
  238.   long vWidth = (4 - m_pBIH->biWidth % 4) % 4 + m_pBIH->biWidth;
  239.  
  240. if ( m_BitCount != 8)
  241. {
  242. for (i = 0; i< m_pBIH->biHeight; i++)
  243.   for (j = 0; j < m_pBIH->biWidth; j++)
  244.   {
  245.   *(m_pDibBits+i*vWidth+j) = (m_pWordData[i*m_pBIH->biWidth+j] >> (m_BitCount-8));
  246.   }
  247.   }
  250.   // Check for the default values of -1
  251. // in the width and height arguments. If
  252.   // we find -1 in either, we'll set them
  253.   // to the value that's in the BITMAPINFOHEADER.
  254.   if( nWidth == -1 )
  255.   nWidth = m_pBIH->biWidth;
  256. if( nHeight == -1 )
  257.   nHeight = m_pBIH->biHeight;
  258.  
  259. if (Style)   // non_zero: Use StretchDIBits to draw the Dib.
  260.   {
  261.   StretchDIBits( pDC->m_hDC, nX, nY,
  262.   nWidth, nHeight,
  263.   0, 0,
  264.   m_pBIH->biWidth, m_pBIH->biHeight,
  265.   m_pDibBits,
  266.   (BITMAPINFO *) m_pBIH,
  267. BI_RGB, SRCCOPY );
  268.   }
  269.   else 
  270. {
  271. SetDIBitsToDevice( pDC->m_hDC, nX, nY,
  272.   m_pBIH->biWidth, m_pBIH->biHeight,
  273. 0, 0,
  274.   0, m_pBIH->biHeight,//nHeight,
  275.   m_pDibBits,
  276.   (BITMAPINFO *) m_pBIH,
  277.   BI_RGB);
  278.   }
  280. return( TRUE );
  281. }
  283. BOOL CDib::SetPalette( CDC *pDC )
  284. {
  286. // If we have not data we
  287. // won't want to set the palette.
  288. if( m_pDib == NULL )
  289. return( FALSE );
  291. // Check to see if we have a palette
  292. // handle. For Dibs greater than 8 bits,
  293. // this will be NULL.
  294. if( m_Palette.GetSafeHandle() == NULL )
  295. return( TRUE );
  297. // Select the palette, realize the palette,
  298. // then finally restore the old palette.
  299. CPalette *pOldPalette;
  300. pOldPalette = pDC->SelectPalette( &m_Palette, FALSE );
  301. pDC->RealizePalette();
  302. pDC->SelectPalette( pOldPalette, FALSE );
  304. return( TRUE );
  306. }
  309. // 一个特别简单的二值化程序以128为界划分
  310. bool CDib::ConvertToTwoValue()
  311. {
  312. // DWORD size;
  313. unsigned char *p;
  315. p = m_pDibBits;
  317. int i,j;
  318. for (i=0;i<m_nHeight;++i)
  319. {
  320. for (j=0;j<m_nWidth;++j)
  321. {
  322. if(p[i*m_nWidth_Step+j]<128)
  323. p[i*m_nWidth_Step+j] = 0;
  324. else
  325. p[i*m_nWidth_Step+j] = 255;
  326. }
  327. }
  328. return true;
  329. }
  331. // 将彩色图像转化为灰度图像
  332. void CDib::RGB2GRAY()
  333. {
  335. }
  337. /*************************求最大值*************************
  338. ***********************************************************/
  339. int CDib::GetMax()
  340. {
  341. int Max = 0;
  342. unsigned char *p;
  343.     
  344. p = m_pDibBits;
  346. int i,j;
  347. for (i=0;i<m_nHeight;++i)
  348. {
  349. for (j=0;j<m_nWidth;++j)
  350. {
  351. if(p[i*m_nWidth_Step+j]>Max)
  352. Max = p[i*m_nWidth_Step+j];
  353. }
  354. }
  355. return Max;
  356. }
  358. /************************求最小值*************************
  359. **********************************************************/
  360. int CDib::GetMin()
  361. {
  362. int Min = 0;
  363. unsigned char *p;
  364.     
  365. p = m_pDibBits;
  367. int i,j;
  368. for (i=0;i<m_nHeight;++i)
  369. {
  370. for (j=0;j<m_nWidth;++j)
  371. {
  372. if(p[i*m_nWidth_Step+j]<Min)
  373. Min = p[i*m_nWidth_Step+j];
  374. }
  375. }
  376. return Min;
  377. }
  379. /************************求平均值************************
  380. *********************************************************/
  381. float CDib::GetAve()
  382. {
  383. float Ave = 0;
  384. long sum=0,num=0;
  385. unsigned char *p;
  386.     
  387. p = m_pDibBits;
  389. int i,j;
  390. for (i=0;i<m_nHeight;++i)
  391. {
  392. for (j=0;j<m_nWidth;++j)
  393. {
  394. sum += p[i*m_nWidth_Step+j];
  395. num ++;
  396. }
  397. }
  398. Ave =(float) sum /(float)num;
  399. return Ave;
  400. }
  402. //图象反转
  403. void CDib::Reverse()
  404. {
  405. unsigned char *p;
  407. p = m_pDibBits;
  409. int i,j;
  410. for (i=0;i<m_nHeight;++i)
  411. {
  412. for (j=0;j<m_nWidth;++j)
  413. {
  414. p[i*m_nWidth_Step+j] = 255 -p[i*m_nWidth_Step+j];
  415. }
  416. }
  417. }
  419. /*********************灰度线性变换***************************
  420. *执行的变换是分段线性变换，参数(Ax,Ay),(Bx,By)是分段点的坐标*
  421. *************************************************************/
  422. void CDib::Pointlinear()
  423. {
  424. unsigned char *p;
  425. p = m_pDibBits;
  427. float Ax=50,Ay=10,Bx=200,By=245;//参数，通过调节这四个值可以得到不同的拉伸效果
  428. int Tran[256];//变换表
  429. float i,j;
  430. for(i=0;i<256;i++)
  431. {
  432. if((0<=i)&&(i<Ax))
  433. Tran[(int)i]=(int)(i*Ay/Ax);
  434. else if((Ax<=i)&&(i<Bx))
  435. Tran[(int)i]=(int)(i*(By-Ay)/(Bx-Ax)+(Ax*By-Ay*Bx)/(Ax-Bx));
  436. else if((Bx<=i)&&(i<256))
  437. Tran[(int)i]=(int)(i*(255-By)/(255-Bx)+255*(By-Bx)/(255-Bx));
  438. }
  439. for (i=0;i<m_nHeight;++i)
  440. {
  441. for (j=0;j<m_nWidth;++j)
  442. {
  443. p[(int)i*m_nWidth_Step+(int)j] = Tran[p[(int)i*m_nWidth_Step+(int)j]];
  444. }
  445. }
  447. }
  449. /******************统计直方图************************
  450. * 统计图像的直方图,并且把它画出来 *
  451. *****************************************************/
  452. void CDib::Histogram()
  453. {
  454. unsigned char *p;
  455. float histogram[256],max;
  456. p = m_pDibBits;
  458. int i,j,rk;
  459. for(i=0;i<256;i++)
  460. histogram[i]=0;
  461. for (i=0;i<m_nHeight;++i)
  462. {
  463. for (j=0;j<m_nWidth;++j)
  464. {
  465. rk=p[i*m_nWidth_Step+j];
  466. histogram[rk] ++;//个数统计
  467. }
  468. }
  469. max=histogram[0];
  470. for(i=0;i<256;i++)
  471. if(histogram[i]>max)
  472. max=histogram[i];//统计直方图最大值
  473. for(i=0;i<256;i++)
  474. histogram[i]=(m_nHeight-1)*histogram[i]/max;//归一化处理，显示时保持最高的一列高度恒定
  475. int NOP=0;
  476. for(j=0;j<256;j++)
  477. {
  478. for(i=m_nHeight;i>0;i--)
  479. {
  480. if(i<(int)histogram[j])p[i*m_nWidth_Step+j]=0;
  481. else p[i*m_nWidth_Step+j]=255;//显示，想出这个方法的邹磊同学很ＮＢ
  482. }
  483. }
  484. }
  486. /**********************直方图均衡************************
  487. *********************************************************/
  488. void CDib::HistEqua()
  489. {
  490. unsigned char *p;
  491. float histogram[256];
  492. p = m_pDibBits;
  494. int i,j,rk;
  495. for(rk=0;rk<256;rk++)
  496. histogram[rk]=0;
  498. for (i=0;i<m_nHeight;++i)
  499. {
  500. for (j=0;j<m_nWidth;++j)
  501. {
  502. rk=p[i*m_nWidth_Step+j];
  503. histogram[rk] ++;//个数统计
  504. }
  505. }
  506. for(i=0;i<256;i++)
  507. histogram[i]=histogram[i]/(256*256);//转化为概率
  509. float Pr[256];
  510. int T[256];
  512. Pr[0]=histogram[0];
  513. T[0]=(int)(Pr[0]*256);
  514. for(i=1;i<256;i++)
  515. {
  516. Pr[i]=Pr[i-1]+histogram[i];
  517. T[i]=(int)(Pr[i]*256);
  518. }
  519. for (i=0;i<m_nHeight;++i)
  520. {
  521. for (j=0;j<m_nWidth;++j)
  522. {
  523. p[i*m_nWidth_Step+j] =T[p[i*m_nWidth_Step+j]];
  524. }
  525. }
  528. }
  530. //平移变换
  531. void CDib::GeomTrans()
  532. {
  534. }
  536. //缩放变换
  537. void CDib::GeomZoom()
  538. {
  540. }
  542. /*******************旋转变换*************************
  543. * 将图象逆时针旋转Degrees角,Degrees是可变参量 *
  544. *****************************************************/
  545. int * CDib::GeomRota()
  546. {
  547. unsigned char *p;
  548. p = m_pDibBits;
  551. double Degrees=60+0;//旋转的角度
  552. double radians = (Degrees/90.0)*(PI/2);//从度转化为弧度
  553. float cosine = (float)cos(radians);
  554. float sine = (float)sin(radians);
  556. //计算旋转后的图像的宽和长
  557. int h = (int)(m_nHeight*fabs(cosine)+m_nWidth*fabs(sine));
  558. int w = (int)(m_nHeight*fabs(sine)+m_nWidth*fabs(cosine));
  559. // if(q!=NULL)
  560. // delete[] q;////////////////////////////////////////////////为什么只要用了DELETE就不正常？
  561. q=new int [w*h+2];
  563. int y,x,sx,sy;
  564. float sourcex,sourcey,x1,y1;
  565. int NOP=0;
  566. for(y=0;y<h;y++)
  567. {
  568. for(x=0;x<w;x++)
  569. {
  570. if(0<=Degrees&&Degrees<90)
  571. {
  572. x1=x-m_nHeight*sine;
  573. y1=(float)y;
  574. }
  575. else if(90<=Degrees&&Degrees<180)
  576. {
  577. x1=(float)(x-w);
  578. y1=y+m_nWidth*cosine;
  579. }
  580. else if(180<=Degrees&&Degrees<270)
  581. {
  582. x1=x+m_nHeight*cosine;
  583. y1=(float)(y-h);
  584. }
  585. else if(180<=Degrees&&Degrees<=360)
  586. {
  587. x1=(float)x;
  588. y1=y+m_nHeight*sine;
  589. }
  590. else 
  591. MessageBox(NULL,"请输入0-360°的角度值","警告",MB_OK);
  593. /***********当使用双线性内插时***********************************************************************
  594. sourcex =x1*cosine+y1*sine;
  595. sourcey =y1*cosine-x1*sine;
  596. sx=(int)ceil(sourcex);
  597. sy=(int)ceil(sourcey);
  598. float dx=sourcex-sx;
  599. float dy=sourcey-sy;
  601. if(sx>=0&&sx<m_nWidth&&sy>=0&&sy<m_nHeight)
  602. {
  603. q[y*w+x+2]=(int)(dx*dy*p[sy*m_nWidth_Step+sx]+dx*(1-dy)*p[(sy+1)*m_nWidth_Step+sx]
  604. +(1-dx)*dy*p[sy*m_nWidth_Step+sx+1]+(1-dx)*(1-dy)*p[(sy+1)*m_nWidth_Step+sx+1]);
  605. }
  606. else q[y*w+x+2]=0;
  607. *******************************************************************************************************/
  608. /***********当不使用双线性内插时***********************************************************************/
  609. sourcex =x1*cosine+y1*sine;
  610. sourcey =y1*cosine-x1*sine;
  611. sx=(int)ceil(sourcex);
  612. sy=(int)ceil(sourcey);
  614. if(sx>=0&&sx<m_nWidth&&sy>=0&&sy<m_nHeight)
  615. {
  616. q[y*w+x+2]=p[sy*m_nWidth_Step+sx];
  617. }
  618. else q[y*w+x+2]=0;
  620. }
  621. }
  623. q[0]=w;
  624. q[1]=h;
  625. return q;
  626. }
  628. //复数
  629. typedef struct
  630. {
  631. double re;
  632. double im;
  633. }COMPLEX;
  635. //复数加法
  636. COMPLEX Add(COMPLEX c1, COMPLEX c2)
  637. {
  638. COMPLEX c;
  639. c.re=c1.re+c2.re;
  640. c.im=c1.im+c2.im;
  641. return c;
  642. }
  644. //复数减法
  645. COMPLEX Sub(COMPLEX c1, COMPLEX c2)
  646. {
  647. COMPLEX c;
  648. c.re=c1.re-c2.re;
  649. c.im=c1.im-c2.im;
  650. return c;
  651. }
  653. //复数乘法
  654. COMPLEX Mul(COMPLEX c1, COMPLEX c2)
  655. {
  656. COMPLEX c;
  657. c.re=c1.re*c2.re-c1.im*c2.im;
  658. c.im=c1.re*c2.im+c2.re*c1.im;
  659. return c;
  660. }
  662. //FFT变换
  663. void DOFFT(COMPLEX * TD, COMPLEX * FD, int power)
  664. {
  665. int count;
  666. int i,j,k,bfsize,p;
  667. double angle;
  668. COMPLEX *W,*X1,*X2,*X;
  670. /*计算傅立叶变换点数*/
  671. count=1<<power;
  673. /*分配运算所需存储器*/
  674. W=(COMPLEX *)malloc(sizeof(COMPLEX)*count/2);
  675. X1=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  676. X2=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  678. /*计算加权系数*/
  679. for(i=0;i<count/2;i++)
  680. {
  681. angle=-i*PI*2/count;
  682. W[i].re=cos(angle);
  683. W[i].im=sin(angle);
  684. }
  686. /*将时域点写入存储器*/
  687. memcpy(X1,TD,sizeof(COMPLEX)*count);
  689. /*蝶形运算*/
  690. for(k=0;k<power;k++)
  691. {
  692. for(j=0;j<1<<k;j++)
  693. {
  694. bfsize=1<<(power-k);
  695. for(i=0;i<bfsize/2;i++)
  696. {
  697. p=j*bfsize;
  698. X2[i+p]=Add(X1[i+p],X1[i+p+bfsize/2]);
  699. X2[i+p+bfsize/2]=Mul(Sub(X1[i+p],X1[i+p+bfsize/2]),W[i*(1<<k)]);
  700. }
  701. }
  702. X=X1;
  703. X1=X2;
  704. X2=X;
  705. }
  707. /*重新排序*/
  708. for(j=0;j<count;j++)
  709. {
  710. p=0;
  711. for(i=0;i<power;i++)
  712. {
  713. if (j&(1<<i)) p+=1<<(power-i-1);
  714. }
  715. FD[j]=X1[p];
  716. }
  718. /*释放存储器*/
  719. free(W);
  720. free(X1);
  721. free(X2);
  722. }
  724. /**************************FFT*************************
  725. ******************************************************/
  726. void CDib::FFT()
  727. {
  728. unsigned char *p;
  729. p = m_pDibBits;
  730. int i,j;
  731. for (i=0;i<m_nHeight;++i)
  732. {
  733. for (j=0;j<m_nWidth;++j)
  734. {
  735. p[i*m_nWidth_Step+j] =p[i*m_nWidth_Step+j];
  736. }
  737. }
  738. int w=1,h=1,wp=0,hp=0;
  739. while(w*2<=m_nWidth)
  740. {
  741. w*=2;
  742. wp++;
  743. }
  744. while(h*2<=m_nHeight)
  745. {
  746. h*=2;
  747. hp++;
  748. }
  749. COMPLEX *TD=new COMPLEX[w*h];
  750. COMPLEX *FD=new COMPLEX[w*h];
  751. int x,y;
  752. for(y=0;y<h;y++)
  753. {
  754. for(x=0;x<w;x++)
  755. {
  756. TD[x+w*y].re=p[x+w*y];
  757. TD[x+w*y].im=0;
  758. }
  759. }
  761. for(y=0;y<h;y++)
  762. {
  763. DOFFT(&TD[w*y],&FD[w*y],wp);
  764. }
  765. for(y=0;y<h;y++)
  766. {
  767. for(x=0;x<w;x++)
  768. {
  769. TD[y+h*x]=FD[x+w*y];
  770. }
  771. }
  772. for(x=0;x<w;x++)
  773. {
  774. DOFFT(&TD[x*h],&FD[x*h],hp);
  775. }
  776. for(y=0;y<h;y++)
  777. {
  778. for(x=0;x<w;x++)
  779. {
  780. p[x+w*y]=(int)sqrt(FD[x*h+y].re*FD[x*h+y].re+FD[x*h+y].im*FD[x*h+y].im)/100;
  781. if (p[x+w*y]>255) p[x+w*y]=255;
  782. }
  783. }
  784. }
  786. void DODCT(double *f, double *F, int power)
  787. {
  788. int i,count;
  789. COMPLEX *X;
  790. double s;
  792. /*计算离散余弦变换点数*/
  793. count=1<<power;
  795. /*分配运算所需存储器*/
  796. X=(COMPLEX *)malloc(sizeof(COMPLEX)*count*2);
  798. /*延拓*/
  799. memset(X,0,sizeof(COMPLEX)*count*2);
  801. /*将时域点写入存储器*/
  802. for(i=0;i<count;i++)
  803. {
  804. X[i].re=f[i];
  805. }
  807. /*调用快速傅立叶变换*/
  808. DOFFT(X,X,power+1);
  810. /*调整系数*/
  811. s=1/sqrt(count);
  812. F[0]=X[0].re*s;
  813. s*=sqrt(2);
  814. for(i=1;i<count;i++)
  815. {
  816. F[i]=(X[i].re*cos(i*PI/(count*2))+X[i].im*sin(i*PI/(count*2)))*s;
  817. }
  819. /*释放存储器*/
  820. free(X);
  821. }
  822. /****************************DCT*****************************
  823. ************************************************************/
  824. void CDib::DCT()
  825. {
  826. unsigned char *p;
  827. p = m_pDibBits;
  829. int w=1,h=1,wp=0,hp=0;
  830. while(w*2<=m_nWidth)
  831. {
  832. w*=2;
  833. wp++;
  834. }
  835. while(h*2<=m_nHeight)
  836. {
  837. h*=2;
  838. hp++;
  839. }
  840. int x,y;
  842. double *f=new double[w*h];
  843. double *W=new double[w*h];
  845. for(y=0;y<h;y++)
  846. {
  847. for(x=0;x<w;x++)
  848. {
  849. f[x+y*w]=p[x+w*y];
  850. }
  851. }
  853. for(y=0;y<h;y++)
  854. {
  855. DODCT(&f[w*y],&W[w*y],wp);
  856. }
  857. for(y=0;y<h;y++)
  858. {
  859. for(x=0;x<w;x++)
  860. {
  861. f[x*h+y]=W[x+w*y];
  862. }
  863. }
  864. for(x=0;x<w;x++)
  865. {
  866. DODCT(&f[x*h],&W[x*h],hp);
  867. }
  868. double a;
  870. for(y=0;y<h;y++)
  871. {
  872. for(x=0;x<w;x++)
  873. {
  874. p[x+w*y]=(int)fabs(W[x*h+y]);
  875. if (a>255) a=255;
  876. }
  877. }
  879. }
  881. void CDib::Walsh()
  882. {
  884. }
  886. void CDib::Wavelet()
  887. {
  889. }
  891. //均值滤波
  892. void CDib::EnhaAverF()
  893. {
  894. unsigned char *p;
  895. int ave[256*256];
  896. int some[3*3];
  897. float sum;
  898. p = m_pDibBits;
  900. int i,j,k,l;
  901. for (i=0;i<m_nHeight;++i)
  902. {
  903. for (j=0;j<m_nWidth;++j)
  904. {
  905. for(k=0;k<3;k++)
  906. for(l=0;l<3;l++)
  907. some[k*3+l]=p[(i+k-1)*m_nWidth_Step+j+l-1];
  908. sum=0;
  909. for(l=0;l<3;l++)
  910. for(k=0;k<3;k++)
  911. sum+=some[k*3+l];
  913. ave[i*m_nWidth_Step+j]=(int)(sum/9);
  914. }
  915. }
  916. for (i=0;i<m_nHeight;++i)
  917. {
  918. for (j=0;j<m_nWidth;++j)
  919. {
  920. p[i*m_nWidth_Step+j] =ave[i*m_nWidth_Step+j];
  921. }
  922. }
  925. }
  927. /****************************中值滤波***************************
  928. ***************************************************************/
  929. void CDib::EnhaMidianF()
  930. {
  931. unsigned char *p;
  932. int *mid;
  933. mid=new int [m_nHeight*m_nWidth];
  934. int some[3*3],tmp;
  935. p = m_pDibBits;
  937. int i,j,k,l;
  938. for (i=0;i<m_nHeight;++i)
  939. {
  940. for (j=0;j<m_nWidth;++j)
  941. {
  942. for(k=0;k<3;k++)
  943. for(l=0;l<3;l++)
  944. some[k*3+l]=p[(i+k-1)*m_nWidth_Step+j+l-1];
  945. for(l=0;l<9;l++)
  946. for(k=0;k<8;k++)
  947. {
  948. if(some[k]<some[k+1])
  949. {
  950. tmp=some[k];
  951. some[k]=some[k+1];
  952. some[k+1]=tmp;
  953. }
  954. }
  955. mid[i*m_nWidth_Step+j]=some[4];
  956. }
  957. }
  958. for (i=0;i<m_nHeight;++i)
  959. {
  960. for (j=0;j<m_nWidth;++j)
  961. {
  962. p[i*m_nWidth_Step+j] =mid[i*m_nWidth_Step+j];
  963. }
  964. }
  965. }
  967. /*************************Sobel**********************
  968. ****************************************************/
  969. void CDib::Sobel()
  970. {
  971. unsigned char *p;
  972. int S[256*256];
  973. p = m_pDibBits;
  975. int i,j;
  977. for (i=1;i<m_nHeight-1;++i)
  978. {
  979. for (j=1;j<m_nWidth-1;++j)
  980. {
  981. S[i*m_nWidth_Step+j]=2*p[(i+1)*m_nWidth_Step+j]-2*p[(i-1)*m_nWidth_Step+j]
  982. +p[(i+1)*m_nWidth_Step+j-1]-p[(i-1)*m_nWidth_Step+j-1]+p[(i+1)*m_nWidth_Step+j+1]-p[(i-1)*m_nWidth_Step+j+1];
  983. }
  984. }
  985. for (i=1;i<m_nHeight-1;++i)
  986. {
  987. for (j=1;j<m_nWidth-1;++j)
  988. {
  989. p[i*m_nWidth_Step+j] =S[i*m_nWidth_Step+j];
  990. if(p[i*m_nWidth_Step+j]>255)p[i*m_nWidth_Step+j]=255;
  991. if(p[i*m_nWidth_Step+j]<0)p[i*m_nWidth_Step+j]=0;
  992. }
  993. }
  994. }
  996. /***********************Laplace*************************
  997. *******************************************************/
  998. void CDib::Laplace()
  999. {
  1000. unsigned char *p;
  1001. int L[256*256];
  1002. p = m_pDibBits;
  1004. int i,j;
  1006. for (i=1;i<m_nHeight-1;++i)
  1007. {
  1008. for (j=1;j<m_nWidth-1;++j)
  1009. {
  1010. L[i*m_nWidth_Step+j]=4*p[i*m_nWidth_Step+j]-p[(i-1)*m_nWidth_Step+j]
  1011. -p[(i+1)*m_nWidth_Step+j]-p[i*m_nWidth_Step+j-1]-p[i*m_nWidth_Step+j+1];
  1012. }
  1013. }
  1014. for (i=1;i<m_nHeight-1;++i)
  1015. {
  1016. for (j=1;j<m_nWidth-1;++j)
  1017. {
  1018. p[i*m_nWidth_Step+j] =L[i*m_nWidth_Step+j];
  1019. if(p[i*m_nWidth_Step+j]>255)p[i*m_nWidth_Step+j]=255;
  1020. if(p[i*m_nWidth_Step+j]<0)p[i*m_nWidth_Step+j]=0;
  1021. }
  1022. }
  1023. }
  1025. /*********************随机噪声**********************
  1026. ***************************************************/
  1027. void CDib::RandomNoise()
  1028. {
  1029. unsigned char *p;
  1031. p = m_pDibBits;
  1033. int i,j,k,N=256*3,Noise;
  1034. for(k=0;k<N;k++)
  1035. {
  1036. i=rand()%m_nHeight;
  1037. j=rand()%m_nWidth;
  1038. Noise=rand()%512;
  1039. p[i*m_nWidth_Step+j] += Noise-256;
  1040. }
  1041. }
  1043. /*********************盐椒噪声*********************
  1044. **************************************************/
  1045. void CDib::SaltNoise()
  1046. {
  1047. unsigned char *p;
  1049. p = m_pDibBits;
  1051. int i,j,k,N=256*3,Noise;
  1052. for(k=0;k<N;k++)
  1053. {
  1054. i=rand()%m_nHeight;
  1055. j=rand()%m_nWidth;
  1056. Noise=rand()%2;
  1057. if(Noise==0)
  1058. p[i*m_nWidth_Step+j] =0;
  1059. else p[i*m_nWidth_Step+j] =255;
  1060. }
  1062. }
  1064. //逆滤波恢复
  1065. void CDib::RestoreInverse()
  1066. {
  1068. }
  1070. //维纳滤波恢复
  1071. void CDib::RestoreWiener()
  1072. {
  1074. }
  1076. /************************图像重建************************
  1077. ********************************************************/
  1078. void CDib::Reconstruction()
  1079. {
  1080. unsigned char *p;
  1081. p=m_pDibBits;
  1083. int i,j;
  1084. for (i=0;i<m_nHeight;++i)
  1085. {
  1086. for (j=0;j<m_nWidth;++j)
  1087. {
  1088. p[i*m_nWidth_Step+j] =temp[i*m_nWidth_Step+j];
  1089. }
  1090. }
  1092. }
  1094. void CDib::Huffman()
  1095. {
  1097. }
  1099. void CDib::Runlength()
  1100. {
  1102. }
  1104. void CDib::Algorithem()
  1105. {
  1107. }
  1109. void CDib::LZW()
  1110. {
  1112. }
  1114. void CDib::JPEG()
  1115. {
  1117. }