intdwt53.cpp

该程序实现各种小波提升分解

// LiftDwt.cpp: implementation of the CLiftDwt class.

//  使用5-3小波进行的整数小波变换，5-3小波使用的是jpeg2000无损压缩推荐的小波。
//  延拓方式采用对称延拓，程序中涉及到了浮点运算，但是输入和输出的数据均为整数。
//
//  程序包括以下部分:
//  Dwt1D(int *buffer, int buflen) 一维整数小波变换，buffer进行变换的数据，buflen数据的长度
//  IDwt1D(int *buffer, int buflen) 一维整数小波反变换
//  
//  Dwt2D(int buffer[], int height, int width, int lv) 二维整数小波变换,buffer进行变换的数据,height,//width数据的尺寸,lv小波分解层数
//  IDwt2D(int buffer[], int height, int width, int lv) 二维整数小波反变换.
//
//  shift 数据延拓时候，左右延拓的长度，为滤波器长度的一半左右  
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "IntDwt53.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//#define MAX(x,y) (x>y?x:y)
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CIntDwt53::CIntDwt53()
{
   shift = 2;
}

CIntDwt53::~CIntDwt53()
{

}

void CIntDwt53::Dwt2D(int *buffer, int height, int width, int lv)
{
	int i,j,k;
 	int nheight,nwidth;
	int *pbuffer1,*pbuffer2;
 
	for ( k=0; k<lv; k++)
	{
       nheight=height>>k;
	   nwidth=width>>k;

	   pbuffer1 = new int [nheight];	 
	   pbuffer2 = new int [nwidth];
       //行变换
	   for (i=0; i<nheight; i++)
		{
			for(j=0; j<nwidth; j++)
				*(pbuffer1+j) = *(buffer+i*width+j);
			
			Dwt1D(pbuffer1,nwidth);
			
			for(j=0; j<nwidth; j++)
				 *(buffer+i*width+j) = *(pbuffer1+j);
		}
		delete []pbuffer1;
       
		//列变换
		for(j=0; j<nwidth; j++)
		{
			for (i=0; i<nheight; i++)
				*(pbuffer2+i)= *(buffer+i*width+j);

			Dwt1D(pbuffer2,nheight);
			
			for(i=0; i<nwidth; i++)
				 *(buffer+i*width+j) = *(pbuffer2+i);
		}
		delete []pbuffer2;
	}

}


void CIntDwt53::IDwt2D(int *buffer, int height, int width, int lv)
{

    int i,j,k;
 	int nheight,nwidth;
	int *pbuffer1,*pbuffer2;
	  
	for (k=0; k<lv; k++)
	{
		nheight=height>>(lv-k-1);
 		nwidth=width>>(lv-k-1);
	    
		pbuffer1 = new int [nheight];	 
	    pbuffer2 = new int [nwidth];
        
		//列反变换
		for(j=0; j<nwidth; j++)
		{
 			for (i=0; i<nheight; i++)
 				*(pbuffer1+i) =  *(buffer+i*width+j);
 		
			IDwt1D(pbuffer1,nheight);
 			
			for(i=0; i<nwidth; i++)
 				 *(buffer+i*width+j) = *(pbuffer1+i);
 		}
 		delete []pbuffer1;
 
        //行反变换
	
 		for (i=0; i<nheight; i++)
		{
 			for(j=0; j<nwidth; j++)
 				*(pbuffer2+j)=*(buffer+i*width+j);
 			IDwt1D(pbuffer2,nwidth);
 			for(j=0; j<nwidth; j++)
 				 *(buffer+i*width+j) = *(pbuffer2+j);
 		}
		delete []pbuffer2;
 	}
}

void CIntDwt53::Dwt1D(int *buffer, int buflen)
{
	int i;
	int itemp;


	int *d, *p;
	p = new int [buflen+2*shift];
	d = new int [(buflen>>1)+shift];	
	/*  对称延拓 */
	for (i=0; i<shift; i++)
	{
		*(p+i) = *(buffer+shift-i);
		*(p+buflen+shift+i) = *(buffer+buflen-i-2);
	}
	for (i=0; i<buflen; i++) *(p+i+shift) = *(buffer+i);
    /* 数据延拓结束  计算p1 = d1          p2 = s1 */
    
	for (i=0; i<(buflen>>1)+shift; i++)
	{
		itemp = i-(shift>>1);
		*(d+i) = *(p+shift+2*itemp+1) - int(floor( *(p+shift+2*itemp+2)/2. +*(p+shift+2*itemp)/2. + 0.5 ));
	}
	for (i=0; i<(buflen>>1); i++)
	{
		*(buffer+(buflen>>1)+i) = *(d+i+(shift>>1));
		*(buffer+i) = *(p+shift+2*i) + int (floor (*(d+i+(shift>>1))/4. +*(d+i-1+(shift>>1))/4. +1 ) );
	}

    delete []p;
	delete []d;
    
}

void CIntDwt53::IDwt1D(int *buffer, int buflen)
{
	int i;
    int *p1, *p2, *s;
	p1 = new int [(buflen>>1)+shift];
	p2 = new int [(buflen>>1)+shift];
	s  = new int [(buflen>>1)+shift];
	
   	/*  对称延拓	*/
   	for (i=0; i<(shift>>1); i++)
	{
		p1[i] = buffer[(shift>>1)-i];
		p1[i+(shift>>1)+(buflen>>1)] = buffer[(buflen>>1)-i-1];
		p2[i] = buffer[(buflen>>1)+(shift>>1)-i-1];
		p2[i+(shift>>1)+(buflen>>1)] = buffer[buflen-i-2];
	}
	for (i=0; i<(buflen>>1); i++)
	{
		p1[i+(shift>>1)] = buffer[i];
		p2[i+(shift>>1)] = buffer[i+(buflen>>1)];
	}
/*   对称延拓结束  */

	for (i=1; i<(buflen>>1)+shift; i++)
		*(s+i) = *(p1+i) - int (floor (*(p2+i)/4.+*(p2+i-1)/4.+1) );
	for (i=0; i<(buflen>>1); i++)
	{
		*(buffer+2*i) = *(s+i+(shift>>1));
		*(buffer+2*i+1) = *(p2+i+(shift>>1)) + int (floor( *(s+i+1+(shift>>1))/2. +*(s+i+(shift>>1))/2. +0.5 ));
	}



	delete []p1;
	delete []p2;
	delete []s;
}