图像处理中的频域的图像增强——VC关键代码实现

最新推荐文章于 2023-01-27 19:12:51 发布
最新推荐文章于 2023-01-27 19:12:51 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： 数字图像处理 文章标签： 图像处理 delete fft null 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunny3106/article/details/1767600
版权

                     理想，高斯，巴特沃思高通/低通滤波函数代码 


/*************************************************************************
* /函数名称：
 *   LowPassFilter()
* /输入参数:
 *   LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth      - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius      - 理想低通滤波的滤波半径
 * /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
 * /说明:
 *  lpDIBBits 是指向需要滤波的图像像素指针。
 *  经过低通滤波的数据仍然存储在lpDIBBits 当中。
**************************************************************************/
BOOL LowPassFilter(LPSTR lpDIBBits, LONG nWidth, LONG nHeight,int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针
 
 // 计算进行傅立叶变换的点数－横向 （2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo;

 double dReal;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部
 // 低通滤波的半径不能超过频域的最大半径
 if(nRadius> (nTransWidth/2) || nRadius> (nTransHeight/2) )
 {
  return (false);        // 返回FALSE
 } 
 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0);  // 补零
  }
 }
 //把图像数据传给pCTData
 for(y=0; y<nHeight; y++)
 {
  for(x=0; x<nWidth; x++)
  {
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 }
 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;    // 傅立叶正变换


   for(x=0;x<nTransWidth;x++)        //开始实施理想的低通滤波
 {
  for(y=nRadius;y<nTransHeight-nRadius;y++)
  {
   // 把纵向所有大于nRadius2的高频分量设置为0
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
 }
 for(x=nRadius;x<nTransWidth-nRadius;x++)
 {
  for(y=0;y<nTransHeight;y++)
  {
   // 把横向所有大于nRadius1的高频分量设置为0
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
 }

 IFFT_2D(pCFData, pCTData,nHeight, nWidth);     // 经过低通滤波的图象进行反变换

 
 for(y=0; y<nHeight; y++)        // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   //需要考虑信号的正负问题以及实际所用的图象数据是灰度值还是原始数据
   dReal = pCTData[y*nTransWidth + x].real() ;   // 实部
   dImag = pCTData[y*nTransWidth + x].imag() ;  // 虚部
   unchValue =dReal;
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 } 
 delete pCTData;          // 释放内存
 delete pCFData;          // 释放内存
 pCTData = NULL;
 pCFData = NULL; 
 return (true);          //返回结果
}


/*************************************************************************
* /函数名称：
 *   ButterWorthLowPass()
* /输入参数:
 *  LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth      - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius      - ButterWorth低通滤波的"半功率"点
* /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
* /说明:
 *  pDIBBits 是指向需要滤波的图像像素指针。
 *  经过ButterWorth低通滤波的数据仍然存储在lpDIBBits 当中。
 **************************************************************************/
BOOL ButterWorthLowPass(LPSTR lpDIBBits, LONG nWidth, LONG nHeight, int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 double H ;          // ButterWorth 滤波系数
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double dReal ;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针
 // 计算进行傅立叶变换的点数－横向 （2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo;
 
 // 低通滤波的半径不能超过频域的最大半径
 if(nRadius> (nTransWidth/2) || nRadius> (nTransHeight/2) )
 {
  return (false);        // 返回FALSE
 } 

 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存

 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0); // 补零
  }
 }
 for(y=0; y<nHeight; y++)       // 把图像数据传给pCTData
 {
  for(x=0; x<nWidth; x++)
  {
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 } 
 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;   // 傅立叶正变换
 for(y=0; y<nTransHeight; y++)      // 开始实施ButterWorth低通滤波
 {
  for(x=0; x<nTransWidth; x++)
  {
   H = (double)(y*y+x*x) ;
   H = H / (nRadius * nRadius);
   H = 1/(1+H)  ;       // 求H值
   pCFData[y*nTransWidth + x]=complex<double>(pCFData[y*nTransWidth + x].real()*H,
   pCFData[y*nTransWidth + x].imag()*H);
  }
 }
 // 经过ButterWorth低通滤波的图象进行反变换
 IFFT_2D(pCFData, pCTData, nWidth, nHeight);
 for(y=0; y<nHeight; y++)       // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   dReal = pCTData[y*nTransWidth + x].real() ;
   dImag = pCTData[y*nTransWidth + x].imag() ;
   unchValue = max(0,min(255,sqrt(dReal*dReal+dImag*dImag) ));
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 }
 delete pCTData;         // 释放内存
 delete pCFData;         // 释放内存
 pCTData = NULL;
 pCFData = NULL;
 return (true);         //返回结果 
}


/*************************************************************************
* /函数名称：
 *   GaussLowPass()
* /输入参数:
 *  LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth      - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius      - Gauss低通滤波的"半功率"点
* /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
* /说明:
 *  pDIBBits 是指向需要滤波的图像像素指针。
 *  经过Gauss低通滤波的数据仍然存储在lpDIBBits 当中。
 **************************************************************************/
BOOL GaussLowPass(LPSTR lpDIBBits, LONG nWidth, LONG nHeight, int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 double H ;          // ButterWorth 滤波系数
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double dReal ;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针
 // 计算进行傅立叶变换的点数－横向 （2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo;
 
 // 低通滤波的半径不能超过频域的最大半径
 if(nRadius> (nTransWidth/2) || nRadius> (nTransHeight/2) )
 {
  return (false);        // 返回FALSE
 } 

 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存

 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0); // 补零
  }
 }
 for(y=0; y<nHeight; y++)       // 把图像数据传给pCTData
 {
  for(x=0; x<nWidth; x++)
  {
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 } 
 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;   // 傅立叶正变换

 for(y=0; y<nTransHeight; y++)      // 开始实施Gauss低通滤波
 {
  for(x=0; x<nTransWidth; x++)
  {
   H = (double)(y*y+x*x) ;
   H = H / (2 * nRadius * nRadius);
   H = exp (-H)  ;       // 求H值
   pCFData[y*nTransWidth + x]=complex<double>(pCFData[y*nTransWidth + x].real()*H,
   pCFData[y*nTransWidth + x].imag()*H);
  }
 }
 // 经过Gauss低通滤波的图象进行反变换
 IFFT_2D(pCFData, pCTData, nWidth, nHeight);
 for(y=0; y<nHeight; y++)       // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   dReal = pCTData[y*nTransWidth + x].real() ;
   dImag = pCTData[y*nTransWidth + x].imag() ;
   unchValue = max(0,min(255,sqrt(dReal*dReal+dImag*dImag) ));
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 }
 delete pCTData;         // 释放内存
 delete pCFData;         // 释放内存
 pCTData = NULL;
 pCFData = NULL;
 return (true);         //返回结果 
}


/*************************************************************************
* /函数名称：
 *   HighPassFilter()
* /输入参数:
 *   LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth      - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius      - 理想高通滤波的滤波半径
 * /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
 * /说明:
 *  lpDIBBits 是指向需要滤波的图像像素指针。
 *  经过高通滤波的数据仍然存储在lpDIBBits 当中。
**************************************************************************/
BOOL HighPassFilter(LPSTR lpDIBBits, LONG nWidth, LONG nHeight,int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针

 // 计算进行傅立叶变换的点数－横向 （2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo;

 double dReal;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部

 // 滤波的半径不能超过频域的最大半径
 if(nRadius>nTransWidth-1 || nRadius>nTransHeight-1)
 {
  return (false);        // 返回false
 }

 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0); // 补零
  }
 }
 for(y=0; y<nHeight; y++)        // 把图像数据传给pCTData
 {
  for(x=0; x<nWidth; x++)
  {
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 } 

 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;    // 傅立叶正变换
 for(x=0;x<nTransWidth;x++)       // 开始实施理想的高通滤波
 {
  for(y=0;y<nRadius;y++)
  {
   //把纵向所有小于nRadius的低频分量设置为0
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
   
  for(y=nTransHeight-1-nRadius;y<nTransHeight;y++)
  {
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
 }

 for(x=0;x<nRadius;x++)
 {
  //把横向所有小于nRadius的低频分量设置为0
  for(y=0;y<nTransHeight;y++)
  {
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
 }

 for(x=nTransWidth-nRadius;x<nTransWidth;x++)
 {
  for(y=0;y<nTransHeight;y++)
  {
   pCFData[x*nTransHeight + y]=complex<double>(0,0);
  }
 }
 
 IFFT_2D(pCFData, pCTData,nHeight, nWidth);   // 经过高通滤波的图象进行反变换
 for(y=0; y<nHeight; y++)       // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   //需要考虑信号的正负问题以及实际所用的图象数据是灰度值还是原始数据
   dReal = pCTData[y*nTransWidth + x].real() ;
   dImag = pCTData[y*nTransWidth + x].imag() ;
   unchValue =dReal;
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 }
 delete pCTData;          // 释放内存
 delete pCFData;          // 释放内存
 pCTData = NULL;
 pCFData = NULL; 
 return (true);          // 返回结果
}

/*************************************************************************
 * /函数名称：
 *   ButterWorthHighPass()
 * /输入参数:
 *  LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth       - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius            - ButterWorth高通滤波的"半功率"点
* /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
* /说明:
 *  pDIBBits 是指向需要滤波的图像像素指针。
 *  经过ButterWorth低通滤波的数据仍然存储在lpDIBBits 当中。
 **************************************************************************/
BOOL ButterWorthHighPass(LPSTR lpDIBBits, LONG nWidth, LONG nHeight, int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 double H ;          // ButterWorth 滤波系数
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double dReal ;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针
 // 计算进行傅立叶变换的点数－横向（2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne);
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo; 
 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0); // 补零
  }
 }
 for(y=0; y<nHeight; y++)      // 把图像数据传给pCTData
 {
  for(x=0; x<nWidth; x++)
  {
  // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 }
 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;  // 傅立叶正变换
 for(y=0; y<nTransHeight; y++)     // 下面开始实施ButterWorth高通滤波
 {
  for(x=0; x<nTransWidth; x++)
  {
   H = (double)(y*y+x*x) ;
   H = (nRadius * nRadius) / H ;
   H = 1/(1+H);      // 求H值
   pCFData[y*nTransWidth + x]=complex<double>(H*(pCFData[y*nTransWidth + x].real()),
      H*(pCFData[y*nTransWidth + x].imag())  );
  }
 }
 // 经过ButterWorth高通滤波的图象进行反变换
 IFFT_2D(pCFData, pCTData, nWidth, nHeight);
 for(y=0; y<nHeight; y++)      // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   dReal = pCTData[y*nTransWidth + x].real() ;
   dImag = pCTData[y*nTransWidth + x].imag() ;
   unchValue = max(0,min(255,sqrt(dReal*dReal+dImag*dImag)+100 ));
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 } 
 delete pCTData;         // 释放内存
 delete pCFData;         // 释放内存
 pCTData = NULL;
 pCFData = NULL;
 return (true);         // 返回结果
}


/*************************************************************************
* /函数名称：
 *   GaussHighPass()
* /输入参数:
 *  LPSTR lpDIBBits     - 指向需要滤波的图像像素指针
 *   int nWidth          - 数据宽度
 *   int nHeight      - 数据高度
 *   int nRadius      - Gauss高通滤波的"半功率"点
* /返回值:
 *    BOOL        // 成功返回TRUE，否则返回FALSE。
* /说明:
 *  pDIBBits 是指向需要滤波的图像像素指针。
 *  经过Gauss高通滤波的数据仍然存储在lpDIBBits 当中。
 **************************************************************************/
BOOL GaussHighPass(LPSTR lpDIBBits, LONG nWidth, LONG nHeight, int nRadius)
{
 unsigned char* lpSrc;       // 指向源图像的指针
 int y ;          // 循环控制变量
 int x ;          // 循环控制变量
 double dTmpOne ;        //存放临时变量
 double dTmpTwo ;        //存放临时变量
 double H ;          // ButterWorth 滤波系数
 int nTransWidth ;        // 傅立叶变换的宽度（2的整数次幂）
 int nTransHeight;        // 傅立叶变换的高度（2的整数次幂）
 double dReal ;         // 傅立叶变换的实部
 double dImag;         // 傅立叶变换的虚部
 double unchValue;        // 存贮图像各像素灰度的临时变量
 complex<double> * pCTData ;      // 指向时域数据的指针
 complex<double> * pCFData ;      // 指向频域数据的指针
 // 计算进行傅立叶变换的点数－横向 （2的整数次幂）
 dTmpOne = log(nWidth)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransWidth = (int) dTmpTwo; 
 // 计算进行傅立叶变换的点数－纵向 （2的整数次幂）
 dTmpOne = log(nHeight)/log(2);
 dTmpTwo = ceil(dTmpOne) ;
 dTmpTwo = pow(2,dTmpTwo);
 nTransHeight = (int) dTmpTwo;
 
 // 高通滤波的半径不能超过频域的最大半径
 if(nRadius> (nTransWidth/2) || nRadius> (nTransHeight/2) )
 {
  return (false);        // 返回FALSE
 } 

 pCTData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存
 pCFData=new complex<double>[nTransWidth * nTransHeight]; // 分配内存

 // 图像数据的宽和高不一定是2的整数次幂，所以pCTData有一部分数据需要补0
 for(y=0; y<nTransHeight; y++)
 {
  for(x=0; x<nTransWidth; x++)
  {
   pCTData[y*nTransWidth + x]=complex<double>(0,0); // 补零
  }
 }
 for(y=0; y<nHeight; y++)       // 把图像数据传给pCTData
 {
  for(x=0; x<nWidth; x++)
  {
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   unchValue = *lpSrc;
   pCTData[y*nTransWidth + x]=complex<double>(unchValue,0);
  }
 } 
 FFT_2D(pCTData, nWidth, nHeight, pCFData) ;   // 傅立叶正变换

 for(y=0; y<nTransHeight; y++)      // 开始实施Gauss高通滤波
 {
  for(x=0; x<nTransWidth; x++)
  {
   H = (double)(y*y+x*x) ;
   H = H / (2 * nRadius * nRadius);
   H = 1 - exp (-H)  ;       // 求H值
   pCFData[y*nTransWidth + x]=complex<double>(pCFData[y*nTransWidth + x].real()*H,
   pCFData[y*nTransWidth + x].imag()*H);
  }
 }
 // 经过Gauss高通滤波的图象进行反变换
 IFFT_2D(pCFData, pCTData, nWidth, nHeight);
 for(y=0; y<nHeight; y++)       // 反变换的数据传给lpDIBBits
 {
  for(x=0; x<nWidth; x++)
  {
   dReal = pCTData[y*nTransWidth + x].real() ;
   dImag = pCTData[y*nTransWidth + x].imag() ;
   unchValue = max(0,min(255,sqrt(dReal*dReal+dImag*dImag) ));
   // 指向DIB第y行，第x个象素的指针
   lpSrc = (unsigned char*)lpDIBBits + nWidth * (nHeight - 1 - y) + x;
   *lpSrc =unchValue ;
  }
 }
 delete pCTData;         // 释放内存
 delete pCFData;         // 释放内存
 pCTData = NULL;
 pCFData = NULL;
 return (true);         //返回结果 
}

sunny3106
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Matlab之图像增强的频域增强
new_EAGLE的博客
07-16 2372
matlab的图像增强（频域增强）
频域图像增强技术
05-29
频域图像增强技术，采用傅里叶变换，使用零填充的方法的滤波效果和不使用零填充的滤波的效果。
图像增强实战:空域滤波、频域滤波和退化恢复滤波器（附全部代码）
最新发布
m0_63859672的博客
01-27 2016
本文主要针对图片拍摄场景有雾气导致图片不清晰的情况，分别使用了三种方法：空域滤波、频域滤波和退化恢复滤波器对同一幅图片进行了增强处理，对三种方法的实验结果进行了对比，得出了一些结论。
基于图像增强技术的频域滤波算法
06-03
本文档是基于图像增强技术的频域滤波算法研究,主要是关于图像增强的频域滤波算法。
图像增强—频域增强技术
白水的博客
08-11 7613
在频域中，变换系数反映了某些图像的特征。如频谱的直流分量比例于图像的平均亮度、噪音对应于频率较高的区域、图像实体对应于频率较低的区域频域增强原理在频谱中，图像中心处对应了图像中变化较平缓的区域，四周对应了图像边缘、噪音或者变化陡峭的部分。因此我们可以将代表了图像边缘、噪音或者变化陡峭的高频率成分滤除掉，只留下变化平缓的低频率成分，再由频域变换回时域，这就相当于对图像进行了平滑处理；相反，若滤去...
图像傅里叶变换vc代码
02-20
图像傅里叶变换是数字图像处理中的一个核心概念，它在信号分析、图像增强和滤波等领域有着广泛的应用。在VC++环境下实现图像傅里叶变换，我们可以利用OpenCV库等工具，它提供了丰富的函数来方便地进行图像处理操作。...
数字图像处理学：Visual C++实现电子书
12-26
针对“VC”，“matlab”，“matlab编程”以及“数字图像处理”这些标签，我们可以深入探讨以下几个关键知识点： 1. **数字图像处理基础**：图像由像素组成，数字图像处理涉及像素的操作，如图像增强、降噪、分割、...
灰度与彩色图像处理VC程序代码
03-24
在图像处理领域，灰度和彩色图像处理是两个重要的概念，尤其在计算机视觉、数字图像分析和图像增强等应用中占据着核心地位。本资源提供的是一个基于VC++（Visual C++）编程环境的图像处理程序代码，它包含了对灰度...
数字图像处理系统VC源码
11-13
VC6下数字图像处理系统-DIP_system，包含以下功能函数： ============================================================================== 第3章 ==============================================================...
VC图像处理系列之三——图像增强篇
10-31
### 图像增强与VC编程实现 #### 图像增强概述 图像增强是图像处理领域的一个重要分支，其核心目的是改善图像的视觉效果，使之更符合人类的观察习惯和分析需求。图像在采集和传输过程中，往往会受到各种因素的影响...
频率域图像增强及MATLAB实现
gogo小Sa的专栏
10-14 1万+
二.MATLAB实现 2.1 二维快速傅里叶变换fft2  %% imgFft2 %{ 函数： Y=fft2(X,m,n) 函数说明：计算二维快速傅里叶变换 参数说明： X:输入图像 m,n:为将X的第一和第二维规整到指定的长度，当m和n均为2的整数次幂时算法的执行速度要比m和n均为素数要快 返回值：Y是计算得到的傅里叶频谱，是一个复数矩阵 备注： abs(Y)可得
3.2 Python图像的频域图像增强-高通和低通滤波器
集电极
07-12 9298
3.2 Python图像的频域图像增强-高通和低通滤波器 文章目录3.2 Python图像的频域图像增强-高通和低通滤波器1 算法原理1.1理想滤波器1.2巴特沃斯滤波器1.3指数滤波器2 代码3 效果 1 算法原理 高通和低通滤波器（分别考虑:理想滤波器、巴特沃斯滤波器，指数滤波器） 1.1理想滤波器 顾名思义，高通滤波器为：让高频信息通过，过滤低频信息；低通滤波相反。低频滤波器，顾名思义，就是过滤掉或者大幅度衰减图像的高频成分，让图像的低频成分通过。低频滤波器可以平滑图像，虑去图像的噪声。而与此相反的高
图像处理学习三（频域图像增强）
Strive_0902的博客
11-21 3788
频域图像增强 图像变换技术：将原定义在图像空间的图像以某种形式转换到另外一些空间，并利用在这些空间的特有性质方便地进行一定的加工，最后再转换回图像空间以得到所需的效果。 变换是双向的，或者说需要双向的变换。在图像处理中，一般将从图像空间向其他空间的变换称为正变换，而将从其他空间向图像空间的变换称为反变换或逆变换 。
数字图像处理》第6讲——频域图像增强
T的博客
12-06 4536
虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ 目录 ①频域是什么？ ②为什么要在频率域研究图像增强？ ③傅里叶变换的频率分量与图像空间特征之间的联系 ④频域的滤波步骤 ⑤一些基本的滤波器 1、陷波滤波器 2、低通滤波器 ...
数字图像处理—彩色增强—伪彩色增强(亮度切割）（从灰度到彩色的变换）（频域滤波）
见证自己的成长之路~
02-24 1万+
一、伪彩色增强（从无彩色到有彩色）： 一种常用的彩色增强方法是对原来灰度图中不同灰度值的区域赋予不同的颜色以更明显地区分它们。 二、主要有三种根据图像灰度的特点而赋予伪彩色的方法： 1、亮度切割：将图像灰度分级，然后对每个灰度值区间内的像素赋一种颜色。 2、从灰度到彩色的变换（黑白电视到彩色电视、和真的彩色电视有区别）（经过红、绿、蓝变换，合成）：使用光滑的、非线性的变换函数，更加灵活。实
数字图像处理--图像增强MATLAB程序
热门推荐
iefenghao的博客
08-20 3万+
图像增强是增强图像中的有用信息，它可以是一个失真的过程，其目的是要改善图像的视觉效果，针对给定图像的应用场合。有目的地强调图像的整体或局部特性，将原来不清晰的图像变得清晰或强调某些感兴趣的特征，扩大图像中不同物体特征之间的差别，抑制不感兴趣的特征，使之改善图像质量、丰富信息量，加强图像判读和识别效果，满足某些特殊分析的需要。 1 图像增强--灰度 //灰度 P=imread('66.jpg'...
图像增强之频域增强
wxplol的博客
05-25 6186
一、傅里叶变换 关于傅里叶变换等基础知识这里就不一一解释，网上有好多，自己可以百度。 二、图像处理中的二维离散傅里叶变换 我们知道二维图像的傅里叶变换可以用以下数学公式： 表示变换后的结果需要用实数图和虚数图表示（或幅值图和相位图）。 三、频域滤波基础 在频域中高频代表了图像的边缘或者纹理细节，而低频代表了图像的轮廓信息，所以，和空间域滤波类似，低通滤波可 以看做对图像的模糊
频域图像增强算法
FPGA/MATLAB学习教程/源码/项目合作开发
10-29 1万+
人类传递信息的主要媒介是语言和图像。据统计在人类接受的各种信息中视觉信息占80%，所以图像信息是十分重要的信息传递媒体和方式。图像传递系统包括图像采集、图像压缩、图像编码、图像存储、图像通信、图像显示这六个部分。在实际应用中每个部分都有可能导致图像品质变差，使图像传递的信息无法被正常读取和识别。例如，在采集图像过程中由于光照环境或物体表面反光等原因造成图像整体光照不均，或是图像采集系统在采集过程中由于机械设备的缘故无法避免的加入采集噪声，或是图像显示设备的局限性造成图像显示层次感降低或颜色减少等等。...
数字图像处理实验四图像频域增强
weixin_39569242的博客
07-23 9222
一、实验目的 （1）了解图像增强的目的及意义，加深对图像增强的感性认识，巩固所学的图像增强的理论知识和相关算法。 （2）熟练掌握低通、高通、带通、同态滤波器的使用方法，明确不同性质的滤波器对图像的影响和作用。 二、实验内容 （1）选择合适的灰度图像，添加随机噪声 （2）对图像进行低通滤波，观察滤波效果 （3）选择一灰度图像，进行高通滤波，观察滤波效果 （4）选择合适的灰度图像，进行带...
MATLAB图像处理：频域增强与滤波器应用
本文主要介绍了图像处理中的频域增强技术，特别是通过高低通滤波器对图像进行增强处理。文章探讨了不同类型的滤波器在MATLAB环境下的实现，包括巴特沃斯高通滤波器、指数滤波器、梯形滤波器以及理想滤波器，并对比了...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值