spiht.h

根据paper思想

#if !defined(AFX_SPIHT_H__0A51CBC1_3065_4B53_AD33_0DDE8F286B18__INCLUDED_)
#define AFX_SPIHT_H__0A51CBC1_3065_4B53_AD33_0DDE8F286B18__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#include "resource.h"
#include <math.h>
#include <memory.h>
#include <assert.h>


#endif // !defined(AFX_SPIHT_H__0A51CBC1_3065_4B53_AD33_0DDE8F286B18__INCLUDED_)

#define TYPE_A   0 /* binary 0 */
#define TYPE_B   1 /* binary 1 */

#define TO_MEMORY 0/* Write compressed file to memory */
#define TO_DISK   1/* Write compressed file to disk */

#define FROM_MEMORY 0/* Write compressed file to memory */
#define FROM_DISK   1/* Write compressed file to disk */


//////////////////////////////////////////////////////////////////////////
//CMatrix2D
//////////////////////////////////////////////////////////////////////////
typedef int ElementType;

template <class T>
class CMatrix2D  
{
public:
	void LoadData(T *example, int r,int c,int pr,int pc);
	void Destroy();
	void Clear();
	void Create(int r, int c);
	T MaxMagnitude();
	T **m; 
	int row;
	int col;
	CMatrix2D();
	virtual ~CMatrix2D();
private:
	T* buffer;
};

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
template <class T>
CMatrix2D<T>::CMatrix2D():col(0),row(0),m(NULL),buffer(NULL)
{
}

template <class T>
CMatrix2D<T>::~CMatrix2D()
{
}

template <class T>
void CMatrix2D<T>::Create(int r, int c)
{
    row = r;
    col = c;
	buffer = new T[row*col];
	assert(buffer);
	m = new T*[r];
	assert(m);
    for (int i=0; i<r; i++)
		m[i] = buffer+col*i; 
}

template <class T>
void CMatrix2D<T>::Clear()
{
    memset(buffer,0,col*row*sizeof(T));
}

/*
* Returns max(abs(matrix)), the absolute maximum value of a matrix.
*/ 

template <class T>
T CMatrix2D<T>::MaxMagnitude()
{
	T max = 0;
	for(int i=0;i<col*row;i++)
		if(buffer[i]>max || buffer[i]<-max)
			max = buffer[i]>=0?buffer[i]:-buffer[i];
		return max;
}

template <class T>
void CMatrix2D<T>::Destroy()
{
	
	delete []buffer;
	delete []m;
	buffer = NULL;
	m = NULL;
}

template <class T>
void CMatrix2D<T>::LoadData(T *example, int r, int c, int pr,int pc)
{
//	memcpy(buffer,example,r*c*sizeof(T));

	int i,j;

	for(i = 0; i < r; i++)
	{
		for(j = 0; j < c; j++)
		{
			m[i][j] = example[i*c+j];
		}
	}
	
	/*扩展图像部分，填充像素*/
	for (j = c - 1; j < pc - 1; j++) 
	{
		m[0][j+1] = (m[0][j] + m[1][j]) / 2;
		m[r-1][j+1] = (m[r-1][j] + m[r-2][j]) / 2;
		for (i = r - 2; i > 0; i--)
			m[i][j+1] = (m[i-1][j] + m[i][j] + m[i+1][j]) / 3; 
	}
	for (i = r - 1; i < pr - 1; i++) 
	{
		m[i+1][0] = (m[i][0] + m[i][1]) / 2;
		m[i+1][pc-1] = (m[i][pc-1] + m[i][pc-2]) / 2;
		for (j = pc - 2; j > 0; j--)
			m[i+1][j] = (m[i][j-1] + m[i][j] + m[i][j+1]) / 3; 
	}

}
#pragma optimize("", on)

//////////////////////////////////////////////////////////////////////////
//CLinkList
//////////////////////////////////////////////////////////////////////////
class CLinkList  
{
public:
	struct ListType {
		int x;
		int y;
		unsigned char type;
	} ;
	
	/* element of the list */
	struct ListElement {
	public:
		ListType data;
		ListElement *next;
		ListElement *previous;
	};
	
	void RemoveCurrentElement();
	ListType GetCurrentElement(char *found);
	void Reset();
	void Destroy();
	void Append(ListType d);
	void Create();
	int length;
	ListElement* head;
	ListElement* current;
	ListElement* end;
	CLinkList();
	virtual ~CLinkList();
	
};

//////////////////////////////////////////////////////////////////////////
//CSPIHT
//////////////////////////////////////////////////////////////////////////
class CSPIHT  
{
public:
	struct SPIHTFileHeader  
	{
		int height;
		int width;
		char level;
		float BitRate;
		int threshold;
		float fWaveParam;
		UINT selection;
	};
	
	struct CSPIHTFileInfo
	{
		SPIHTFileHeader header;
		LONG lCounts;   
		BYTE *pFirstByte;//The first of bytes which record real compressed file;
	};
	
	float m_fDecomBitRate;
	UINT selection;
	SPIHTFileHeader header;
	void SetImageSize(int x,int y);
	void SetLevel(char l);
	float BitRate;
	void SetBitRate(float b);
	BOOL stop;
	CMatrix2D<ElementType> *MR;
	void RefinementPass2(CMatrix2D<ElementType> *m,int threshold);
	void SortingPass2(CMatrix2D<ElementType> *m, int threshold);
	unsigned long  BitCount;
	unsigned char inputbyte;
	char GetBit();
	void Decode( );
	char * strFileNameOut;
	char * strFileNameIn;
	void Encode(ElementType *example);
	void RefinementPass1(CMatrix2D<ElementType> *m,int threshold);
	void SortingPass1(CMatrix2D<ElementType> *m, int threshold);
	BOOL TestSubset(CMatrix2D<ElementType> *m, int x, int y, int threshold, unsigned char type,int band);
	BOOL ZeroTree(CMatrix2D<ElementType> *m,int threshold,int band,int min_x,int max_x,int min_y,int max_y);
	void Initialization();
	void DumpBuffer();
	void PutBit(char bit);
	CLinkList * LIP;
	CLinkList *LIS;
	CLinkList *LSP;
	CSPIHTFileInfo CompressedFileInfo;
	unsigned int zeroes, ones;
	unsigned char outputbyte, mask;
	FILE * SPIHTFile;
	CMatrix2D<ElementType>* M;
	/*计算各自带大小*/
	int *subbandxsize;
	int *subbandysize;
	void SetSubbandSize(int x,int y);
	int FindSubband(int x,int y);
	void DestroySubsize();
	int nXDim;
	int nYDim;
	/*用于扩展图像大小*/
	int pXDim;
	int pYDim;
	char cAction;
	CSPIHT();
	virtual ~CSPIHT();
	private:
		unsigned char * pByte;
		char level;
		int subbands;
	protected:
		LPVOID lpMeta;
		CLinkList::ListElement* pNewlyAppended;
		
};
#pragma optimize("", on)