小波变换 opencv

最新推荐文章于 2023-08-14 09:02:13 发布
最新推荐文章于 2023-08-14 09:02:13 发布
阅读量2.4k 收藏 9
点赞数
分类专栏： c++ 
<pre name="code" class="cpp">///  小波变换
Mat WDT( const Mat &_src, const string _wname, const int _level )const
{    
	int reValue = THID_ERR_NONE;  
	Mat src = Mat_<float>(_src);   
	Mat dst = Mat::zeros( src.rows, src.cols, src.type() );   
	int N = src.rows;  
	int D = src.cols;   
	/// 高通低通滤波器  
	Mat lowFilter;    
	Mat highFilter;   
	wavelet( _wname, lowFilter, highFilter );   
	/// 小波变换   
	int t=1;   
	int row = N;   
	int col = D;     
	while( t<=_level ) 
	{    
		///先进行行小波变换      
		for( int i=0; i<row; i++ )      
		{          
			/// 取出src中要处理的数据的一行   
			Mat oneRow = Mat::zeros( 1,col, src.type() );      
			for ( int j=0; j<col; j++ )      
			{            
				oneRow.at<float>(0,j) = src.at<float>(i,j);        
			}         
			oneRow = waveletDecompose( oneRow, lowFilter, highFilter );        
			/// 将src这一行置为oneRow中的数据       
			for ( int j=0; j<col; j++ )     
			{             
				dst.at<float>(i,j) = oneRow.at<float>(0,j);    
			}      
		}
#if 0     
		//normalize( dst, dst, 0, 255, NORM_MINMAX );     
		IplImage dstImg1 = IplImage(dst);      
		cvSaveImage( "dst.jpg", &dstImg1 );
#endif    
			/// 小波列变换      
			for ( int j=0; j<col; j++ )   
			{          
				/// 取出src数据的一行输入     
				Mat oneCol = Mat::zeros( row, 1, src.type() );   
				for ( int i=0; i<row; i++ )        
				{             
					oneCol.at<float>(i,0) = dst.at<float>(i,j);   
				}          
				oneCol = ( waveletDecompose( oneCol.t(), lowFilter, highFilter ) ).t();         
				for ( int i=0; i<row; i++ )        
				{               
					dst.at<float>(i,j) = oneCol.at<float>(i,0);     
				}      
			} 
#if 0       
			//normalize( dst, dst, 0, 255, NORM_MINMAX );     
			IplImage dstImg2 = IplImage(dst);      
			cvSaveImage( "dst.jpg", &dstImg2 );
#endif       
			/// 更新    
			row /= 2;     
			col /=2;      
			t++;       
			src = dst;  
	}   
	return dst;
} 
///  小波逆变换
Mat IWDT( const Mat &_src, const string _wname, const int _level )const
{    
	int reValue = THID_ERR_NONE; 
	Mat src = Mat_<float>(_src);  
	Mat dst = Mat::zeros( src.rows, src.cols, src.type() );  
	int N = src.rows;    int D = src.cols;   
	/// 高通低通滤波器 
	Mat lowFilter;    
	Mat highFilter;   
	wavelet( _wname, lowFilter, highFilter );  
	/// 小波变换
	int t=1;   
	int row = N/std::pow( 2., _level-1);
	int col = D/std::pow(2., _level-1); 
	while ( row<=N && col<=D )   
	{       
		/// 小波列逆变换    
		for ( int j=0; j<col; j++ )    
		{         
			/// 取出src数据的一行输入       
			Mat oneCol = Mat::zeros( row, 1, src.type() );    
			for ( int i=0; i<row; i++ )      
			{           
				oneCol.at<float>(i,0) = src.at<float>(i,j);    
			}         
			oneCol = ( waveletReconstruct( oneCol.t(), lowFilter, highFilter ) ).t();      
			for ( int i=0; i<row; i++ )        
			{            
				dst.at<float>(i,j) = oneCol.at<float>(i,0);          
			}      
		} 
#if 0       
		//normalize( dst, dst, 0, 255, NORM_MINMAX );   
		IplImage dstImg2 = IplImage(dst);    
		cvSaveImage( "dst.jpg", &dstImg2 );
#endif      
		///行小波逆变换      
		for( int i=0; i<row; i++ )    
		{          
			/// 取出src中要处理的数据的一行  
			Mat oneRow = Mat::zeros( 1,col, src.type() );            
			for ( int j=0; j<col; j++ )         
			{              
				oneRow.at<float>(0,j) = dst.at<float>(i,j);     
			}         
			oneRow = waveletReconstruct( oneRow, lowFilter, highFilter );        
			/// 将src这一行置为oneRow中的数据          
			for ( int j=0; j<col; j++ )         
			{              
				dst.at<float>(i,j) = oneRow.at<float>(0,j);     
			}      
		}
#if 0      
		//normalize( dst, dst, 0, 255, NORM_MINMAX );  
		IplImage dstImg1 = IplImage(dst);    
		cvSaveImage( "dst.jpg", &dstImg1 );
#endif      
			row *= 2;    
			col *= 2;      
			src = dst;   
	}    
	return dst;
}  
 
/// 调用函数
/// 生成不同类型的小波，现在只有haar，sym2
void wavelet( const string _wname, Mat &_lowFilter, Mat &_highFilter )const
{   
	if ( _wname=="haar" || _wname=="db1" )  
	{       
		int N = 2;    
		_lowFilter = Mat::zeros( 1, N, CV_32F );    

		_highFilter = Mat::zeros( 1, N, CV_32F );             
		_lowFilter.at<float>(0, 0) = 1/sqrtf(N);    
		_lowFilter.at<float>(0, 1) = 1/sqrtf(N);        
		_highFilter.at<float>(0, 0) = -1/sqrtf(N);        
		_highFilter.at<float>(0, 1) = 1/sqrtf(N);   
	}   
	if ( _wname =="sym2" )  
	{       
		int N = 4;     
		float h[] = {-0.483, 0.836, -0.224, -0.129 };  
		float l[] = {-0.129, 0.224,    0.837, 0.483 };  
		_lowFilter = Mat::zeros( 1, N, CV_32F );     
		_highFilter = Mat::zeros( 1, N, CV_32F );    
		for ( int i=0; i<N; i++ )      
		{         
			_lowFilter.at<float>(0, i) = l[i];     
			_highFilter.at<float>(0, i) = h[i];   
		}    
	}
} 
/// 小波分解
Mat waveletDecompose( const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter )const
{   
	assert( _src.rows==1 && _lowFilter.rows==1 && _highFilter.rows==1 );    
	assert( _src.cols>=_lowFilter.cols && _src.cols>=_highFilter.cols );  
	Mat &src = Mat_<float>(_src);   
	int D = src.cols;   
	Mat &lowFilter = Mat_<float>(_lowFilter); 
	Mat &highFilter = Mat_<float>(_highFilter);   
	/// 频域滤波，或时域卷积；ifft( fft(x) * fft(filter)) = cov(x,filter)    
	Mat dst1 = Mat::zeros( 1, D, src.type() );  
	Mat dst2 = Mat::zeros( 1, D, src.type()  );  
	filter2D( src, dst1, -1, lowFilter ); 
	filter2D( src, dst2, -1, highFilter );     
	/// 下采样    
	Mat downDst1 = Mat::zeros( 1, D/2, src.type() ); 
	Mat downDst2 = Mat::zeros( 1, D/2, src.type() );   
	resize( dst1, downDst1, downDst1.size() );  
	resize( dst2, downDst2, downDst2.size() );     
	/// 数据拼接   
	for ( int i=0; i<D/2; i++ )  
	{     
		src.at<float>(0, i) = downDst1.at<float>( 0, i );    
		src.at<float>(0, i+D/2) = downDst2.at<float>( 0, i );   
	}    
	return src;
}
/// 小波重建
Mat waveletReconstruct( const Mat &_src, const Mat &_lowFilter, const Mat &_highFilter )const
{    
	assert( _src.rows==1 && _lowFilter.rows==1 && _highFilter.rows==1 );  
	assert( _src.cols>=_lowFilter.cols && _src.cols>=_highFilter.cols ); 
	Mat &src = Mat_<float>(_src);   
	int D = src.cols;  
	Mat &lowFilter = Mat_<float>(_lowFilter); 
	Mat &highFilter = Mat_<float>(_highFilter);    
	/// 插值;  
	Mat Up1 = Mat::zeros( 1, D, src.type() );  
	Mat Up2 = Mat::zeros( 1, D, src.type() );  
	/// 插值为0 
	//for ( int i=0, cnt=1; i<D/2; i++,cnt+=2 ) 
	//{ 
	//    Up1.at<float>( 0, cnt ) = src.at<float>( 0, i );   ///< 前一半   
	//    Up2.at<float>( 0, cnt ) = src.at<float>( 0, i+D/2 ); ///< 后一半  
	//}   
	/// 线性插值 
	Mat roi1( src, Rect(0, 0, D/2, 1) );   
	Mat roi2( src, Rect(D/2, 0, D/2, 1) );   
	resize( roi1, Up1, Up1.size(), 0, 0, INTER_CUBIC ); 
	resize( roi2, Up2, Up2.size(), 0, 0, INTER_CUBIC ); 
	/// 前一半低通，后一半高通  
	Mat dst1 = Mat::zeros( 1, D, src.type() );   
	Mat dst2= Mat::zeros( 1, D, src.type() );   
	filter2D( Up1, dst1, -1, lowFilter );
	filter2D( Up2, dst2, -1, highFilter );    
	/// 结果相加   
	dst1 = dst1 + dst2;   
	return dst1; 
} 


 

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
  
 
#include <opencv2\highgui\highgui.hpp>
#include <math.h>

#include <iostream>
using namespace std;
//二维离散变换小波源代码
void DWT(IplImage *pImage, int nLayer)
{
   // 执行条件
   if (pImage)
   {
      if (pImage->nChannels == 1 &&
         pImage->depth == IPL_DEPTH_32F &&
         ((pImage->width >> nLayer) << nLayer) == pImage->width &&
         ((pImage->height >> nLayer) << nLayer) == pImage->height)
      {
         int     i, x, y, n;
         float   fValue   = 0;
         float   fRadius  = sqrt(2.0f);
         int     nWidth   = pImage->width;
         int     nHeight  = pImage->height;
         int     nHalfW   = nWidth / 2;
         int     nHalfH   = nHeight / 2;
         float **pData    = new float*[pImage->height];
         float  *pRow     = new float[pImage->width];
         float  *pColumn  = new float[pImage->height];
         for (i = 0; i < pImage->height; i++)   pData[i] = (float*) (pImage->imageData + pImage->widthStep * i);
         // 多层小波变换
         for (n = 0; n < nLayer; n++, nWidth /= 2, nHeight /= 2, nHalfW /= 2, nHalfH /= 2)
         {
            // 水平变换
            for (y = 0; y < nHeight; y++)
            {
               // 奇偶分离
               memcpy(pRow, pData[y], sizeof(float) * nWidth);
               for (i = 0; i < nHalfW; i++)
               {
                  x = i * 2;
                  pData[y][i] = pRow[x];
                  pData[y][nHalfW + i] = pRow[x + 1];
               }
               // 提升小波变换
               for (i = 0; i < nHalfW - 1; i++)
               {
                  fValue = (pData[y][i] + pData[y][i + 1]) / 2;
                  pData[y][nHalfW + i] -= fValue;
               }
               fValue = (pData[y][nHalfW - 1] + pData[y][nHalfW - 2]) / 2;
               pData[y][nWidth - 1] -= fValue;
               fValue = (pData[y][nHalfW] + pData[y][nHalfW + 1]) / 4;
               pData[y][0] += fValue;
               for (i = 1; i < nHalfW; i++)
               {
                  fValue = (pData[y][nHalfW + i] + pData[y][nHalfW + i - 1]) / 4;
                  pData[y][i] += fValue;
               }
               // 频带系数
               for (i = 0; i < nHalfW; i++)
               {
                  pData[y][i] *= fRadius;
                  pData[y][nHalfW + i] /= fRadius;
               }
            }
            // 垂直变换
            for (x = 0; x < nWidth; x++)
            {
               // 奇偶分离
               for (i = 0; i < nHalfH; i++)
               {
                  y = i * 2;
                  pColumn[i] = pData[y][x];
                  pColumn[nHalfH + i] = pData[y + 1][x];
               }
               for (i = 0; i < nHeight; i++)
               {
                  pData[i][x] = pColumn[i];
               }
               // 提升小波变换
               for (i = 0; i < nHalfH - 1; i++)
               {
                  fValue = (pData[i][x] + pData[i + 1][x]) / 2;
                  pData[nHalfH + i][x] -= fValue;
               }
               fValue = (pData[nHalfH - 1][x] + pData[nHalfH - 2][x]) / 2;
               pData[nHeight - 1][x] -= fValue;
               fValue = (pData[nHalfH][x] + pData[nHalfH + 1][x]) / 4;
               pData[0][x] += fValue;
               for (i = 1; i < nHalfH; i++)
               {
                  fValue = (pData[nHalfH + i][x] + pData[nHalfH + i - 1][x]) / 4;
                  pData[i][x] += fValue;
               }
               // 频带系数
               for (i = 0; i < nHalfH; i++)
               {
                  pData[i][x] *= fRadius;
                  pData[nHalfH + i][x] /= fRadius;
               }
            }
         }
         delete[] pData;
         delete[] pRow;
         delete[] pColumn;
      }
   }
}

// 二维离散小波恢复（单通道浮点图像）
void IDWT(IplImage *pImage, int nLayer)
{
   // 执行条件
   if (pImage)
   {
      if (pImage->nChannels == 1 &&
         pImage->depth == IPL_DEPTH_32F &&
         ((pImage->width >> nLayer) << nLayer) == pImage->width &&
         ((pImage->height >> nLayer) << nLayer) == pImage->height)
      {
         int     i, x, y, n;
         float   fValue   = 0;
         float   fRadius  = sqrt(2.0f);
         int     nWidth   = pImage->width >> (nLayer - 1);
         int     nHeight  = pImage->height >> (nLayer - 1);
         int     nHalfW   = nWidth / 2;
         int     nHalfH   = nHeight / 2;
         float **pData    = new float*[pImage->height];
         float  *pRow     = new float[pImage->width];
         float  *pColumn  = new float[pImage->height];
         for (i = 0; i < pImage->height; i++)
         {
            pData[i] = (float*) (pImage->imageData + pImage->widthStep * i);
         }
         // 多层小波恢复
         for (n = 0; n < nLayer; n++, nWidth *= 2, nHeight *= 2, nHalfW *= 2, nHalfH *= 2)
         {
            // 垂直恢复
            for (x = 0; x < nWidth; x++)
            {
               // 频带系数
               for (i = 0; i < nHalfH; i++)
               {
                  pData[i][x] /= fRadius;
                  pData[nHalfH + i][x] *= fRadius;
               }
               // 提升小波恢复
               fValue = (pData[nHalfH][x] + pData[nHalfH + 1][x]) / 4;
               pData[0][x] -= fValue;
               for (i = 1; i < nHalfH; i++)
               {
                  fValue = (pData[nHalfH + i][x] + pData[nHalfH + i - 1][x]) / 4;
                  pData[i][x] -= fValue;
               }
               for (i = 0; i < nHalfH - 1; i++)
               {
                  fValue = (pData[i][x] + pData[i + 1][x]) / 2;
                  pData[nHalfH + i][x] += fValue;
               }
               fValue = (pData[nHalfH - 1][x] + pData[nHalfH - 2][x]) / 2;
               pData[nHeight - 1][x] += fValue;
               // 奇偶合并
               for (i = 0; i < nHalfH; i++)
               {
                  y = i * 2;
                  pColumn[y] = pData[i][x];
                  pColumn[y + 1] = pData[nHalfH + i][x];
               }
               for (i = 0; i < nHeight; i++)   pData[i][x] = pColumn[i];
            }
            // 水平恢复
            for (y = 0; y < nHeight; y++)
            {
               // 频带系数
               for (i = 0; i < nHalfW; i++)
               {
                  pData[y][i] /= fRadius;
                  pData[y][nHalfW + i] *= fRadius;
               }
               // 提升小波恢复
               fValue = (pData[y][nHalfW] + pData[y][nHalfW + 1]) / 4;
               pData[y][0] -= fValue;
               for (i = 1; i < nHalfW; i++)
               {
                  fValue = (pData[y][nHalfW + i] + pData[y][nHalfW + i - 1]) / 4;
                  pData[y][i] -= fValue;
               }
               for (i = 0; i < nHalfW - 1; i++)
               {
                  fValue = (pData[y][i] + pData[y][i + 1]) / 2;
                  pData[y][nHalfW + i] += fValue;
               }
               fValue = (pData[y][nHalfW - 1] + pData[y][nHalfW - 2]) / 2;
               pData[y][nWidth - 1] += fValue;
               // 奇偶合并
               for (i = 0; i < nHalfW; i++)
               {
                  x = i * 2;
                  pRow[x] = pData[y][i];
                  pRow[x + 1] = pData[y][nHalfW + i];
               }
               memcpy(pData[y], pRow, sizeof(float) * nWidth);
            }
         }
         delete[] pData;
         delete[] pRow;
         delete[] pColumn;
      }
   }
} 


int main()
{
	// 小波变换层数
	int nLayer = 2;
	// 输入彩色图像
	IplImage *pSrc = cvLoadImage("lena.jpg", CV_LOAD_IMAGE_COLOR);
	// 计算小波图象大小
	CvSize size = cvGetSize(pSrc);
	if ((pSrc->width >> nLayer) << nLayer != pSrc->width)	size.width = ((pSrc->width >> nLayer) + 1) << nLayer;
	if ((pSrc->height >> nLayer) << nLayer != pSrc->height)  size.height = ((pSrc->height >> nLayer) + 1) << nLayer;
	// 创建小波图象
	IplImage *pWavelet = cvCreateImage(size, IPL_DEPTH_32F, pSrc->nChannels);
	if (pWavelet) {
		// 小波图象赋值
		cvSetImageROI(pWavelet, cvRect(0, 0, pSrc->width, pSrc->height));
		cvConvertScale(pSrc, pWavelet, 1, -128);
		cvResetImageROI(pWavelet);
		// 彩色图像小波变换
		IplImage *pImage = cvCreateImage(cvGetSize(pWavelet), IPL_DEPTH_32F, 1);
		if (pImage) {
			for (int i = 1; i <= pWavelet->nChannels; i++)   {
				cvSetImageCOI(pWavelet, i);
				cvCopy(pWavelet, pImage, NULL);
				// 二维离散小波变换
				DWT(pImage, nLayer);
				// 二维离散小波恢复
				// IDWT(pImage, nLayer);
				cvCopy(pImage, pWavelet, NULL);
			}
			cvSetImageCOI(pWavelet, 0);
			cvReleaseImage(&pImage);
		}
		// 小波变换图象
		cvSetImageROI(pWavelet, cvRect(0, 0, pSrc->width, pSrc->height));
		cvConvertScale(pWavelet, pSrc, 1, 128);
		cvResetImageROI(pWavelet);
		cvReleaseImage(&pWavelet);
	}
	// 显示图像pSrc
	cv::namedWindow("result");
	cvShowImage("result",pSrc);
	cv::waitKey(0);
	cvReleaseImage(&pSrc); 
}
 
 
 
 
 


                

        

        

    




    

      

        

            

              
                
                  雪山飞狐
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    9
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
OpenCV Haar小波变换

				
			

			

				

					dayuhaitang1的博客
				

				

					05-27
					
					424
					
				

			

		

		

			
				
OpenCV Haar小波变换

			
		

	



                

              
                



	

		

			

				
					
harr整数小波变换opencv实现.rar

				
			

			

				

					12-30
				

			

		

		

			
				
在这个“harr整数小波变换opencv实现.rar”压缩包中，包含了使用C++编程语言和OpenCV库来实现Harr小波变换的相关代码和可能的示例。OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供...

			
		

	



                


  
              

                


	

		

			

				
					
平稳小波变换实现声呐图像超分辨率

					
最新发布

				
			

			

				

					nsjdjdn的博客
				

				

					08-14
					
					211
					
				

			

		

		

			
				
小波超分辨率计算就是最早的基于小波变换的方法，高分辨率图像经过小波分解得到 4 个子带图像 LL，LH，HL 和 HH，平稳小波算法（SWT）是从不使用下采样图像的离散小波算法(DWT)开发而来，它仍然处理离散信号。因此输入图像和子带图像大小相同。SWT将图像分成不同的子带图像，高频子带包含图像的高频分量。SWT中保持高频分量。SWT解决了DWT的缺点，SWT用于确定原始图像的冗余度，用于曲线估计和回归。对非平稳时间序列的探索和频谱分析。

			
		

	





	

		

			

				
					
python的opencv操作记录(八)——小波变换

				
			

			

				

					新兴IT民工的专栏
				

				

					11-09
					
					3107
					
				

			

		

		

			
				
小波变换的概念，一般逻辑和例子

			
		

	



		

			
		



	

		

			

				
					
转：基于opencv的小波变换

				
			

			

				

					weixin_34218890的博客
				

				

					08-08
					
					604
					
				

			

		

		

			
				
转自http://www.cnblogs.com/zhangzhi/archive/2009/09/19/1569888.html
提供函数DWT()和IDWT()，前者完成任意层次的小波变换，后者完成任意层次的小波逆变换。输入图像要求必须是单通道浮点图像，对图像大小也有要求（1层变换：w,h必须是2的倍数；2层变换：w,h必须是4的倍数；3层变换：w,h必须是8的倍数......），变换后的结...

			
		

	





	

		

			

				
					
用Java实现小波变换 Wavelets in Java

				
			

			

				

					GarfieldEr007的专栏
				

				

					12-30
					
					7044
					
				

			

		

		

			
				
Wavelets in Java

This web page publishes the Java source code and Javadoc generated documentation for wavelets. Wavelets are a technique, like Fourier analysis, for analyzing signals. They are also

			
		

	





	

		

			

				
					
opencv+小波变换

					
热门推荐

				
			

			

				

					qq_37333087的博客
				

				

					07-18
					
					1万+
					
				

			

		

		

			
				
什么是小波变换

  小波变换，作为图像处理中的一个重要分支，在图像压缩，医疗图像处理中有着比较好的应用，在一定程度上甚至可以取代傅里叶变换。与傅里叶变换不同，由于小波变换是建立在多尺度上的，因而可以有着更高的灵活度。这里为了让各位更好地理解小波，先打个比方。存在一家做产品的公司，该公司等级制度明确，其中有一个负责产品方向的CEO，以及一个负责技术的CTO。此时CEO决定做产品A，跟同为大佬的CT...

			
		

	





	

		

			

				
					
基于opencv的小波变换

				
			

			

				

					ghjdst的博客
				

				

					10-18
					
					1739
					
				

			

		

		

			
				
本文是通过滤波器组实现的harr小波变换（还没写反变换）

			
		

	





	

		

			

				
					
快速小波变换 基于opencv带注释

				
			

			

				

					07-19
				

			

		

		

			
				
在OpenCV库中，它提供了实现快速小波变换的接口，使得开发者能够轻松地将小波分析应用于实际项目。在这个基于OpenCV的案例中，源码带有注释，有助于理解算法的工作原理。  小波变换是信号分析的一种工具，它能够同时...

			
		

	





	

		

			

				
					
opencv实现小波变换

				
			

			

				

					04-25
				

			

		

		

			
				
### opencv实现小波变换：深入解析与代码详解  #### 小波变换简介 小波变换是一种时频分析工具，广泛应用于信号处理、图像压缩、边缘检测等领域。它能够提供时间分辨率和频率分辨率的平衡，使得在不同尺度上对信号...

			
		

	





	

		

			

				
					
Opencv实现Gabor小波变换

				
			

			

				

					06-08
				

			

		

		

			
				
基于opencv实现了对给定图像Gabor小波变换；尺度、方向、高斯窗口等参数可调

			
		

	





	

		

			

				
					
图像小波变换和逆变换_openCV

				
			

			

				

					11-26
				

			

		

		

			
				
基于openCV实现的图像小波变换和逆变换功能函数源代码，可以在你的工程项目中直接调用，适用于图像融合分析分类识别等计算机视觉领域。

			
		

	





	

		

			

				
					
Opencv + c++实现简单的小波变换

				
			

			

				

					10-06
				

			

		

		

			
				
简单的实现二维图像的小波变换，实现简答，也便于后期的小波拓展。

			
		

	





	

		

			

				
					
OpenCV3 小波变换

				
			

			

				

					06-20
				

			

		

		

			
				
借鉴网上前辈代码，用OpenCV3写的小波变换，如有错误，请各位大神批评指正。

			
		

	





	

		

			

				
					
c#小波变换算法c#小波变换算法

				
			

			

				

					12-15
				

			

		

		

			
				
 - **Emgu CV**：基于OpenCV的.NET库，也提供了小波变换的功能。  - **自定义实现**：可以使用C#编写自己的小波变换算法，例如基于滤波器组的离散小波变换算法。  4. **`Filter.cs`文件可能包含的内容**：  - **...

			
		

	





	

		

			

				
					
在OpenCV里实现小波变换

				
			

			

				

					大坡3D软件开发
				

				

					11-23
					
					3549
					
				

			

		

		

			
				
小波变换（wavelet transform，WT）是一种新的变换分析方法，它继承和发展了短时傅立叶变换局部化的思想，同时又克服了窗口大小不随频率变化等缺点，能够提供一个随频率改变的“时间-频率”窗口，是进行信号时频分析和处理的理想工具。它的主要特点是通过变换能够充分突出问题某些方面的特征，能对时间（空间）频率的局部化分析，通过伸缩平移运算对信号（函数)逐步进行多尺度细化，最终达到高频处时间细分，...

			
		

	





	

		

			

				
					
哈尔(Haar)小波变换的原理及opencv源代码

				
			

			

				

					生命在于折腾！
				

				

					12-27
					
					1万+
					
				

			

		

		

			
				
# include
# include


  using namespace std;
  using namespace cv;


  int main()
{
    Mat img = imread("lenna.bmp",0);
    int width = img.cols;
    int height = img.ro

			
		

	





	

		

			

				
					
opencv小波变换代码

				
			

			

				

					天边那颗星
				

				

					01-02
					
					1281
					
				

			

		

		

			
				
// DWT.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"
#include "cv.h"
#include "highgui.h"


// 二维离散小波变换（单通道浮点图像）
void DWT(IplImage *pImage, int nLayer)
{
 // 执行条件
 if (pImage)
 {
  if (pImage

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值