www.pudn.com > Videodisplay.rar > IntWT.cpp

// IntWT.cpp: implementation of the CIntWT class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
//#include "SPIHTcoding.h" 
#include "IntWT.h" 
#include "math.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CIntWT::CIntWT() 
{ 
	width=512; 
	height=512;   //默认为512*512 
} 
 
CIntWT::~CIntWT() 
{ 
 
} 
 
void CIntWT::IDCT(int buffer[], int bufferLen) 
{ 
    int b[5]; 
	if( bufferLen != 4 ) 
	    return; 
 
	// *********************** DCT ************************************ 
	b[0] = buffer[0] + (int)( -0.5942*buffer[1] - 4.025*buffer[2] - 1.435*buffer[3] +0.5 ); 
	b[1] = buffer[1] + (int)(  0.6935*b[0]      + 3.185*buffer[2] + 1.133*buffer[3] +0.5 ); 
	b[2] = buffer[2] + (int)(  0.4413*b[0]      +0.2114*b[1]      +0.2114*buffer[3] +0.5 ); 
	b[3] = buffer[3] + (int)( -0.6935*b[0]      - 1.133*b[1]      + 3.185*b[2]      +0.5 ); 
	b[4] = b[0] +      (int)(   1.435*b[1]      - 4.025*b[2]      +0.5942*b[3]      +0.5 ); 
 
	memcpy( buffer, b+1, sizeof(int)*4 ); 
} 
 
void CIntWT::IDCT_I(int buffer[], int bufferLen) 
{ 
    int b[5]; 
	if( bufferLen != 4 ) 
	    return; 
	 
	memcpy( b+1, buffer, sizeof(int)*4 ); 
 
	// ********************** Reverse DCT ***************************** 
	b[0] =      b[4] - (int)(   1.435*b[1]      - 4.025*b[2]      +0.5942*b[3]      +0.5 ); 
	buffer[3] = b[3] - (int)( -0.6935*b[0]      - 1.133*b[1]      + 3.185*b[2]      +0.5 ); 
	buffer[2] = b[2] - (int)(  0.4413*b[0]      +0.2114*b[1]      +0.2114*buffer[3] +0.5 ); 
	buffer[1] = b[1] - (int)(  0.6935*b[0]      + 3.185*buffer[2] + 1.133*buffer[3] +0.5 ); 
    buffer[0] = b[0] - (int)( -0.5942*buffer[1] - 4.025*buffer[2] - 1.435*buffer[3] +0.5 ); 
} 
 
void CIntWT::FDCT(double buffer[], int bufferLen) 
{ 
	if( bufferLen != 4 ) 
	    return; 
	double a[4]; 
 
	memcpy( a, buffer, sizeof(double)*4 ); 
 
	buffer[0] = ( a[0] + a[1] + a[2] + a[3] )*0.5; 
	buffer[1] = 0.653281*( a[0]-a[3] ) + 0.270598*( a[1]-a[2] ); 
	buffer[2] = ( a[0] - a[1] - a[2] + a[3] )*0.5; 
	buffer[3] = 0.270598*( a[0]-a[3] ) + 0.653281*( a[1]-a[2] ); 
} 
 
void CIntWT::FDCT_I(double buffer[], int bufferLen) 
{ 
	if( bufferLen != 4 ) 
	    return; 
	double a[4]; 
 
	memcpy( a, buffer, sizeof(double)*4 ); 
 
	buffer[0] = ( a[0] + a[2] )*0.5 + 0.653281*a[1] + 0.270598*a[3]; 
	buffer[2] = ( a[0] - a[2] )*0.5 + 0.270598*a[1] - 0.653281*a[3]; 
	buffer[1] = ( a[0] - a[2] )*0.5 - 0.270598*a[1] + 0.653281*a[3];  
	buffer[3] = ( a[0] + a[2] )*0.5 - 0.653281*a[1] - 0.270598*a[3];   
} 
 
// 
// 插值(2,2)正变换    5/3 
// 
void CIntWT::Interpolate_22_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;                   // 周期延拓Buffer 
	d = dBuffer+1; 
	p = Buffer+1; 
    // 计算d  
    for( l=0; l>1 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓dBuffer  
	s = sBuffer; 
	d = dBuffer + 1; 
	p = Buffer; 
    // 计算s 
    for( l=0; l>1 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(2,2)逆变换 
// 
void CIntWT::Interpolate_22I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+1]; 
 
	memcpy( sBuffer  , buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*dBuffer = *(dBuffer+iLen);                // 周期延拓dBuffer 
	d = dBuffer+1; 
	s = sBuffer; 
	// 计算 s[2*l]  
    for( l=0; l>1 ); 
		//buffer[2*l] = *s; 
		buffer[2*l]=(*s) - ( ( (*(d-1))+(*d)+2 )>>1 ); 
		s++; 
		d++; 
	} 
 
	sBuffer[iLen] = sBuffer[0];                // 周期延拓sBuffer 
	s = sBuffer; 
	d = dBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>1 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(4,2)正变换 
// 
void CIntWT::Interpolate_42_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+5]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer+2, buffer, sizeof(int)*bufferLen ); 
    // 左右周期延拓 
	Buffer[0] = Buffer[bufferLen];   
	Buffer[1] = Buffer[bufferLen+1]; 
	Buffer[bufferLen+4] = Buffer[4]; 
	Buffer[bufferLen+3] = Buffer[3]; 
	Buffer[bufferLen+2] = Buffer[2]; 
 
	p = Buffer+3; 
	d = dBuffer+1; 
    // 计算d 
    for( l=0; l>4 ); 
		p += 2; 
		d++; 
	} 
 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓d   
    d = dBuffer+1; 
	p = Buffer+2; 
	s = sBuffer; 
	// 计算s 
    for( l=0; l>2 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(4,2)逆变换 
// 
void CIntWT::Interpolate_42I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*dBuffer = *(dBuffer+iLen);                      // 周期延拓 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	sBuffer[0] = sBuffer[iLen];                         // 周期延拓 
    *(s+1) = sBuffer[2]; 
	*s = sBuffer[1]; 
	s = sBuffer+1; 
	d = dBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>4 ); 
		d++;                    
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(2,4)正变换 
// 
void CIntWT::Interpolate_24_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;              // right周期延拓 
	p = Buffer+1; 
	d = dBuffer+2; 
    // 计算d  
    for( l=0; l>1 ); 
		d++; 
		p += 2; 
	} 
 
    // left延拓	 
	dBuffer[0] = dBuffer[iLen];  
	dBuffer[1] = dBuffer[iLen+1];   
	*d = dBuffer[2]; 
	p = Buffer; 
    d = dBuffer+2; 
	s = sBuffer; 
    // 计算s 
    for( l=0; l>6 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+2, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(2,4)逆变换 
// 
void CIntWT::Interpolate_24I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l,  
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen+1]; 
 
	memcpy( sBuffer  , buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+2, buffer+iLen, sizeof(int)*iLen ); 
	 
	dBuffer[0] = dBuffer[iLen];                        // left周期延拓 
	dBuffer[1] = dBuffer[iLen+1];   
	dBuffer[iLen+2] = dBuffer[2];                      // right 
 
    s = sBuffer; 
	d = dBuffer+2; 
	// 计算 s[2*l]  
    for( l=0; l>6 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	*s = sBuffer[0];                                   // 周期延拓 
	s = sBuffer; 
	d = dBuffer+2; 
	// 计算 s[2*l+1] 
    for( l=0; l>1 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(4,4)正变换    13/7-T 
// 
void CIntWT::Interpolate_44_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l, 
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
  	 Buffer = new int [bufferLen+5]; 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer+2, buffer, sizeof(int)*bufferLen ); 
 
    // 左右周期延拓 
	Buffer[0] = Buffer[bufferLen];          // left 
	Buffer[1] = Buffer[bufferLen+1]; 
	Buffer[bufferLen+4] = Buffer[4];        // right 
	Buffer[bufferLen+3] = Buffer[3]; 
	Buffer[bufferLen+2] = Buffer[2];  
 
	d = dBuffer+2; 
	p = Buffer+3; 
    // 计算d 
    for( l=0; l>4 ); 
		d++; 
		p += 2; 
	} 
 
	// 周期延拓	 
	dBuffer[1] = dBuffer[iLen+1]; 
	dBuffer[0] = dBuffer[iLen];    
	*d = dBuffer[2]; 
    s = sBuffer; 
	d = dBuffer+2; 
	p = Buffer+2; 
    // 计算s 
    for( l=0; l>5 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+2, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(4,4)逆变换 
// 
void CIntWT::Interpolate_44I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+2, buffer+iLen, sizeof(int)*iLen ); 
	 
	// 周期延拓 
	*(dBuffer+1) = *(dBuffer+iLen+1);      // left 
	*dBuffer = *(dBuffer+iLen);        
   	*(dBuffer+iLen+2) = *(dBuffer+2);      // right 
 
	d = dBuffer+2; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>5 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	sBuffer[0] = sBuffer[iLen];                      // 周期延拓 
	sBuffer[iLen+1] = sBuffer[1]; 
	sBuffer[iLen+2] = sBuffer[2]; 
	 
	d = dBuffer+2; 
	s = sBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(6,2)正变换 
// 
void CIntWT::Interpolate_62_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+9]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer+4, buffer, sizeof(int)*bufferLen ); 
 
	// 周期延拓 
	Buffer[0] = Buffer[bufferLen];                // left 
	Buffer[1] = Buffer[bufferLen+1]; 
	Buffer[2] = Buffer[bufferLen+2]; 
	Buffer[3] = Buffer[bufferLen+3]; 
	Buffer[bufferLen+8] = Buffer[8];              // right 
	Buffer[bufferLen+7] = Buffer[7]; 
	Buffer[bufferLen+6] = Buffer[6]; 
	Buffer[bufferLen+5] = Buffer[5]; 
	Buffer[bufferLen+4] = Buffer[4]; 
 
	p = Buffer+5; 
	d = dBuffer+1; 
    // 计算d  
    for( l=0; l>8 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓   
	d = dBuffer+1; 
	s = sBuffer; 
	p = Buffer+4; 
    // 计算s 
    for( l=0; l>2 ); 
		p += 2; 
		s++; 
		d++; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 插值(6,2)逆变换 
// 
void CIntWT::Interpolate_62I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l,  
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+5]; 
 
	memcpy( sBuffer+2, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*dBuffer = *(dBuffer+iLen);                    // 周期延拓 
	d = dBuffer+1; 
	s = sBuffer+2; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	sBuffer[0] = sBuffer[iLen];                    // 周期延拓 
	sBuffer[1] = sBuffer[iLen+1];               
	sBuffer[iLen+2] = sBuffer[2];     
	sBuffer[iLen+3] = sBuffer[3];   
	sBuffer[iLen+4] = sBuffer[4];   
 
	d = dBuffer+1; 
	s = sBuffer+2; 
	// 计算 s[2*l+1] 
    for( l=0; l>8 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// (2+2,2) transform    
// 
void CIntWT::IntWT_22_2_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;            // 周期延拓 
	p = Buffer+1; 
	d = dBuffer+1; 
    // 计算中间变量d(1) 
    for( l=0; l>1 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];               // 周期延拓d(1)   
	d = dBuffer+1; 
	s = sBuffer+1; 
    p = Buffer; 
    // 计算s 
    for( l=0; l>2 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+1] = sBuffer[1];              // 周期延拓s   
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[0] = sBuffer[iLen]; 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算d 
	for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
		                                       
	// 记录结果 
	memcpy( buffer,      sBuffer+1, sizeof(int)*iLen );           // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );           // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// (2+2,2) inverse transform 
// 
void CIntWT::IntWT_22_2I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*sBuffer = *(sBuffer+iLen);                      // 周期延拓 
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[iLen+1] = sBuffer[1]; 
	d = dBuffer+1; 
	s = sBuffer+1;  
	// 计算 d(1) 
    for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
	 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓d(1) 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l]  = *s; 
		s++; 
		d++; 
	} 
 
	*s = sBuffer[1];                                 // 周期延拓s 
	s = sBuffer+1; 
	d = dBuffer+1; 
	// 计算 s[2l+1] 
    for( l=0; l>1 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// D4 orthogonal transform 
// 
void CIntWT::IntWT_D4_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s, *p; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+1]; 
 
	p = buffer+1; 
	d = dBuffer+1; 
	// 计算中间变量d(1) 
    for( l=0; l>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+1]; 
 
	memcpy( sBuffer  , buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
                   
	sBuffer[iLen] = sBuffer[0];                      // 周期延拓  
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 d(1) 
    for( l=0; l>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+1]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;            // 周期延拓 
	d = dBuffer+1; 
	p = Buffer+1; 
    // 计算中间变量d(1) 
    for( l=0; l>1, l,  
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+1]; 
 
	memcpy( sBuffer  , buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓  
	d = dBuffer+1; 
	s = sBuffer; 
    // 计算 s(1) 
    for( l=0; l>1, l,  
		*dBuffer, *sBuffer, *p, *d, *s; 
 
	dBuffer = new int [iLen]; 
	sBuffer = new int [iLen+2]; 
 
	d = dBuffer; 
	p = buffer; 
    // 计算d(1)  
    for( l=0; l>1 ); 
		s++;		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+1] = sBuffer[1];                    // 周期延拓sBuffer 
	sBuffer[0] = sBuffer[iLen];                       
	s = sBuffer; 
	d = dBuffer; 
    // 计算d 
    for( l=0; l>2 ); 
		d++;    s++; 
	} 
 
	// 记录结果 
	memcpy( buffer,      sBuffer+1, sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer  , sizeof(int)*iLen );       // 高半带 
 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 2/6 Inverse 
// 
void CIntWT::IntWT_26I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen]; 
	sBuffer = new int [iLen+2]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer  , buffer+iLen, sizeof(int)*iLen ); 
	 
	*sBuffer = *(sBuffer+iLen);                // 周期延拓sBuffer 
	sBuffer[iLen+1] = sBuffer[1]; 
	d = dBuffer; 
	s = sBuffer; 
	// 计算 d(1)  
    for( l=0; l>2 ); 
		s++; 
		d++; 
	} 
 
	d = dBuffer; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>1 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	s = sBuffer+1; 
	d = dBuffer; 
	// 计算 s[2*l+1] 
    for( l=0; l>1, l,  
		*dBuffer, *sBuffer, *p, *d, *s; 
 
	dBuffer = new int [iLen]; 
	sBuffer = new int [iLen+4]; 
 
 
	d = dBuffer; 
	p = buffer; 
    // 计算d(1)  
    for( l=0; l>1 ); 
		s++;		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+2] = sBuffer[2];                    // 周期延拓sBuffer 
	sBuffer[iLen+3] = sBuffer[3]; 
	sBuffer[1] = sBuffer[iLen+1]; 
	sBuffer[0] = sBuffer[iLen];                       
	s = sBuffer; 
	d = dBuffer; 
    // 计算d 
    for( l=0; l>6 ); 
		d++;    s++; 
	} 
 
	// 记录结果 
	memcpy( buffer,      sBuffer+2, sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer  , sizeof(int)*iLen );       // 高半带 
 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 2/10 Inverse 
// 
void CIntWT::IntWT_210I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen]; 
	sBuffer = new int [iLen+4]; 
 
	memcpy( sBuffer+2, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer  , buffer+iLen, sizeof(int)*iLen ); 
	 
	sBuffer[iLen+2] = sBuffer[2];                    // 周期延拓sBuffer 
	sBuffer[iLen+3] = sBuffer[3]; 
	sBuffer[1] = sBuffer[iLen+1]; 
	sBuffer[0] = sBuffer[iLen];                       
	d = dBuffer; 
	s = sBuffer; 
	// 计算 d(1)  
    for( l=0; l>6 ); 
		s++; 
		d++; 
	} 
 
	d = dBuffer; 
	s = sBuffer+2; 
	// 计算 s[2*l]  
    for( l=0; l>1 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	s = sBuffer+2; 
	d = dBuffer; 
	// 计算 s[2*l+1] 
    for( l=0; l>1, l,  
		*dBuffer, *sBuffer, *p, *d, *s; 
 
	dBuffer = new int [iLen+2]; 
	sBuffer = new int [iLen+4]; 
 
	d = dBuffer+1; 
	p = buffer; 
    // 计算d(1)  
    for( l=0; l>4 ); 
		s++;		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+2] = sBuffer[2];                    // 周期延拓sBuffer 
	sBuffer[iLen+3] = sBuffer[3];  
	sBuffer[0] = sBuffer[iLen];  
	sBuffer[1] = sBuffer[iLen+1];  
	s = sBuffer; 
	d = dBuffer+1; 
    // 计算d 
    for( l=0; l>4 ); 
		d++;    s++; 
	} 
 
	// 记录结果 
	memcpy( buffer,      sBuffer+2, sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );       // 高半带 
 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 6-14 Inverse 
// 
void CIntWT::IntWT_614I_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+2]; 
	sBuffer = new int [iLen+4]; 
 
	memcpy( sBuffer+2, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	sBuffer[iLen+2] = sBuffer[2];                    // 周期延拓sBuffer 
	sBuffer[iLen+3] = sBuffer[3];  
	sBuffer[0] = sBuffer[iLen];  
	sBuffer[1] = sBuffer[iLen+1];  
	s = sBuffer; 
	d = dBuffer+1; 
	// 计算 d(1)  
    for( l=0; l>4 ); 
		s++; 
		d++; 
	} 
 
	dBuffer[0] = dBuffer[iLen];              // 周期延拓dBuffer 
	dBuffer[iLen+1] = dBuffer[1]; 
	s = sBuffer+2; 
	d = dBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>4 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	s = sBuffer+2; 
	d = dBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;            // 周期延拓 
	p = Buffer+1; 
	d = dBuffer+1; 
    // 计算中间变量d(1) 
    for( l=0; l>1 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];               // 周期延拓d(1)   
	d = dBuffer+1; 
	s = sBuffer+1; 
    p = Buffer; 
    // 计算s 
    for( l=0; l>2 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+1] = sBuffer[1];              // 周期延拓s   
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[0] = sBuffer[iLen]; 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算d 
	for( l=0; l>5 ); 
		d++; 
		s++; 
	} 
		                                       
	// 记录结果 
	memcpy( buffer,      sBuffer+1, sizeof(int)*iLen );           // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );           // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 5/11-A 
// 
void CIntWT::IntWT_511AI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*sBuffer = *(sBuffer+iLen);                      // 周期延拓 
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[iLen+1] = sBuffer[1]; 
	d = dBuffer+1; 
	s = sBuffer+1;  
	// 计算 d(1) 
    for( l=0; l>5 ); 
		d++; 
		s++; 
	} 
	 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓d(1) 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l]  = *s; 
		s++; 
		d++; 
	} 
 
	*s = sBuffer[1];                                 // 周期延拓s 
	s = sBuffer+1; 
	d = dBuffer+1; 
	// 计算 s[2l+1] 
    for( l=0; l>1 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 5/11-C 
// 
void CIntWT::IntWT_511C_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
	 Buffer = new int [bufferLen+1]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( Buffer, buffer, sizeof(int)*bufferLen ); 
 
	*(Buffer+bufferLen) = *Buffer;            // 周期延拓 
	p = Buffer+1; 
	d = dBuffer+1; 
    // 计算中间变量d(1) 
    for( l=0; l>1 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];               // 周期延拓d(1)   
	d = dBuffer+1; 
	s = sBuffer+1; 
    p = Buffer; 
    // 计算s 
    for( l=0; l>2 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+1] = sBuffer[1];              // 周期延拓s   
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[0] = sBuffer[iLen]; 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算d 
	for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
		                                       
	// 记录结果 
	memcpy( buffer,      sBuffer+1, sizeof(int)*iLen );           // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );           // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 5/11-C Inverse 
// 
void CIntWT::IntWT_511CI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
	 
	*sBuffer = *(sBuffer+iLen);                      // 周期延拓 
	sBuffer[iLen+2] = sBuffer[2]; 
	sBuffer[iLen+1] = sBuffer[1]; 
	d = dBuffer+1; 
	s = sBuffer+1;  
	// 计算 d(1) 
    for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
	 
	dBuffer[0] = dBuffer[iLen];                      // 周期延拓d(1) 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l]  = *s; 
		s++; 
		d++; 
	} 
 
	*s = sBuffer[1];                                 // 周期延拓s 
	s = sBuffer+1; 
	d = dBuffer+1; 
	// 计算 s[2l+1] 
    for( l=0; l>1 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 13/7-C 
// 
void CIntWT::IntWT_137C_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l, 
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
  	 Buffer = new int [bufferLen+5]; 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer+2, buffer, sizeof(int)*bufferLen ); 
 
    // 左右周期延拓 
	Buffer[0] = Buffer[bufferLen];          // left 
	Buffer[1] = Buffer[bufferLen+1]; 
	Buffer[bufferLen+4] = Buffer[4];        // right 
	Buffer[bufferLen+3] = Buffer[3]; 
	Buffer[bufferLen+2] = Buffer[2];  
 
	d = dBuffer+2; 
	p = Buffer+3; 
    // 计算d 
    for( l=0; l>4 ); 
		d++; 
		p += 2; 
	} 
 
	// 周期延拓	 
	dBuffer[1] = dBuffer[iLen+1]; 
	dBuffer[0] = dBuffer[iLen];    
	*d = dBuffer[2]; 
    s = sBuffer; 
	d = dBuffer+2; 
	p = Buffer+2; 
    // 计算s 
    for( l=0; l>4 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+2, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 13/7-C Inverse 
// 
void CIntWT::IntWT_137CI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+3]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+2, buffer+iLen, sizeof(int)*iLen ); 
	 
	// 周期延拓 
	*(dBuffer+1) = *(dBuffer+iLen+1);      // left 
	*dBuffer = *(dBuffer+iLen);        
   	*(dBuffer+iLen+2) = *(dBuffer+2);      // right 
 
	d = dBuffer+2; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>4 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	sBuffer[0] = sBuffer[iLen];                      // 周期延拓 
	sBuffer[iLen+1] = sBuffer[1]; 
	sBuffer[iLen+2] = sBuffer[2]; 
	 
	d = dBuffer+2; 
	s = sBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// SPB 
// 
void CIntWT::IntWT_SPB_1D(int buffer[], int bufferLen) 
{ 
	int iLen = bufferLen>>1, l,  
		*deBuffer, *sBuffer, *p, *s, *de; 
 
	deBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+2]; 
 
	de = deBuffer; 
	p = buffer; 
    // 计算d(1)  
    for( l=0; l>1 ); 
		s++;	 
		de++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+1] = sBuffer[1];                    // 周期延拓sBuffer 
	sBuffer[0] = sBuffer[iLen];        
	deBuffer[iLen] = 0;                               // 补0 
	s = sBuffer+1; 
	de = deBuffer; 
	p = buffer+iLen; 
    // 计算d 
    for( l=0; l>3 ); 
		de++;   
		p++; 
		s++; 
	} 
 
	// 记录结果 
	memcpy( buffer,      sBuffer+1, sizeof(int)*iLen );       // 低半带 
//	memcpy( buffer+iLen, dBuffer  , sizeof(int)*iLen );       // 高半带 
 
	delete []sBuffer; 
	delete []deBuffer; 
} 
 
// 
// SPB Inverse 
// 
void CIntWT::IntWT_SPBI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, *deBuffer, *dBuffer, *sBuffer, *de, *d, *s; 
 
	dBuffer  = new int [iLen]; 
	deBuffer = new int [iLen+1]; 
	sBuffer  = new int [iLen+2]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer  , buffer+iLen, sizeof(int)*iLen ); 
	 
	sBuffer[0] = sBuffer[iLen];                   // 周期延拓sBuffer 
	sBuffer[iLen+1] = sBuffer[1]; 
	deBuffer[iLen] = 0;                           // 补0 
	d = dBuffer+iLen-1; 
    de = deBuffer+iLen-1; 
	s = sBuffer+iLen; 
	// 计算 d(1)  
    for( l=0; l>3 ); 
		s--; 
		d--; 
		de--; 
	} 
 
	de = deBuffer; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>1 ); 
		buffer[2*l] = *s; 
		s++; 
		de++; 
	} 
 
	s = sBuffer+1; 
	de = deBuffer; 
	// 计算 s[2*l+1] 
    for( l=0; l>1, l,  
		*deBuffer, *sBuffer, *p, *de, *s; 
 
	deBuffer = new int [iLen+1]; 
	sBuffer  = new int [iLen+3]; 
 
	de = deBuffer; 
	p = buffer; 
    // 计算d(1)  
    for( l=0; l>1 ); 
		s++;	 
		de++; 
		p += 2; 
	} 
	 
	sBuffer[iLen+2] = sBuffer[2];                    // 周期延拓sBuffer 
	sBuffer[0] = sBuffer[iLen];       
	sBuffer[1] = sBuffer[iLen+1]; 
	deBuffer[iLen] = 0;                               // 补0 
	s = sBuffer+2; 
	de = deBuffer; 
	p = buffer+iLen; 
    // 计算d 
    for( l=0; l>4 ); 
		de++;   
		s++; 
		p++; 
	} 
 
	// 记录结果 
	memcpy( buffer,      sBuffer+2, sizeof(int)*iLen );       // 低半带 
//	memcpy( buffer+iLen, dBuffer  , sizeof(int)*iLen );       // 高半带 
 
	delete []sBuffer; 
	delete []deBuffer; 
} 
 
// 
// SPC Inverse 
// 
void CIntWT::IntWT_SPCI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*deBuffer, *dBuffer, *sBuffer, *de, *d, *s; 
 
	deBuffer = new int [iLen+1]; 
	dBuffer  = new int [iLen]; 
	sBuffer  = new int [iLen+3]; 
 
	memcpy( sBuffer+2, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer  , buffer+iLen, sizeof(int)*iLen ); 
	 
	sBuffer[0] = sBuffer[iLen];             // 周期延拓sBuffer 
	sBuffer[1] = sBuffer[iLen+1]; 
	sBuffer[iLen+2] = sBuffer[2]; 
	deBuffer[iLen] = 0;                               // 补0 
	d = dBuffer+iLen-1; 
	de = deBuffer+iLen-1; 
	s = sBuffer+iLen+1; 
	// 计算 d(1)  
    for( l=0; l>4 ); 
		s--; 
		d--; 
		de--; 
	} 
 
	de = deBuffer; 
	s = sBuffer+2; 
	// 计算 s[2*l]  
    for( l=0; l>1 ); 
		buffer[2*l] = *s; 
		s++; 
		de++; 
	} 
 
	s = sBuffer+2; 
	de = deBuffer; 
	// 计算 s[2*l+1] 
    for( l=0; l>1, l, 
		*Buffer, *dBuffer, *sBuffer, *p, *d, *s; 
 
  	 Buffer = new int [bufferLen+5]; 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen]; 
 
	memcpy( Buffer+2, buffer, sizeof(int)*bufferLen ); 
 
    // 左右周期延拓 
	Buffer[0] = Buffer[bufferLen];          // left 
	Buffer[1] = Buffer[bufferLen+1]; 
	Buffer[bufferLen+4] = Buffer[4];        // right 
	Buffer[bufferLen+3] = Buffer[3]; 
	Buffer[bufferLen+2] = Buffer[2];  
 
	d = dBuffer+1; 
	p = Buffer+3; 
    // 计算d 
    for( l=0; l>4 ); 
		d++; 
		p += 2; 
	} 
 
	dBuffer[0] = dBuffer[iLen];   	// 周期延拓	 
    s = sBuffer; 
	d = dBuffer+1; 
	p = Buffer+2; 
    // 计算s 
    for( l=0; l>2 ); 
		s++; 
		d++; 
		p += 2; 
	} 
	 
	// 记录结果 
	memcpy( buffer,      sBuffer,   sizeof(int)*iLen );       // 低半带 
	memcpy( buffer+iLen, dBuffer+1, sizeof(int)*iLen );       // 高半带 
 
	delete []Buffer; 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 9/7-M Inverse 
// 
void CIntWT::IntWT_97MI_1D(int buffer[], int bufferLen) 
{ 
    int iLen = bufferLen>>1, l, 
		*dBuffer, *sBuffer, *d, *s; 
 
	dBuffer = new int [iLen+1]; 
	sBuffer = new int [iLen+3]; 
 
	memcpy( sBuffer+1, buffer,      sizeof(int)*iLen ); 
	memcpy( dBuffer+1, buffer+iLen, sizeof(int)*iLen ); 
		 
	dBuffer[0] = dBuffer[iLen];            // 周期延拓 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l]  
    for( l=0; l>2 ); 
		buffer[2*l] = *s; 
		s++; 
		d++; 
	} 
 
	sBuffer[0] = sBuffer[iLen];                      // 周期延拓 
	sBuffer[iLen+1] = sBuffer[1]; 
	sBuffer[iLen+2] = sBuffer[2]; 
	 
	d = dBuffer+1; 
	s = sBuffer+1; 
	// 计算 s[2*l+1] 
    for( l=0; l>4 ); 
		d++; 
		s++; 
	} 
	 
	delete []sBuffer; 
	delete []dBuffer; 
} 
 
// 
// 二维整数小波变换, 直接对数组pBuffer操作，即函数结束后，pBuffer的值已变   
//     做Form型变换，分解Level次 
// 
BOOL CIntWT::IntWT_2D( int *pBuffer, int Form, int Level ) 
{ 
    if( pBuffer == NULL ) 
		return( FALSE ); 
	 
	int i, j, k = 0, Size = 512, p[512]; 
	while( k>1; 
		} 
		return( TRUE ); 
} 
 
// 
// 二维整数小波逆变换, 直接对数组pBuffer操作，即函数结束后，pBuffer的值已变   
//     做Form型变换，分解Level次 
// 
BOOL CIntWT::IntWT_2D_I( int *pBuffer, int Form, int Level ) 
{ 
    if( pBuffer == NULL ) 
		return( FALSE ); 
	 
	int i, j, k = Level, Size, p[512]; 
	 
	Size = 512>>(Level-1); 
	 
	while( k>0 ) 
	{    
		// 处理各列   
		for( j=0; j255) 
				resultData[j*width+i]=255; 
			else if(result[(height-j-1)*width+i]<0) 
				resultData[j*width+i]=0; 
			else 
				resultData[j*width+i]=(BYTE)(floor(result[(height-j-1)*width+i]+0.5)); 
		} 
	} 
	width=512; 
	height=512; 
    delete []result; 
}