classifyinfofile.cpp

基于小波的SAR斑点处理

#include "stdafx.h"
#include "RSIPStruct.h"

#include "ClassifyInfoFile.h"

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

///////////////////////////////////////////////////////
//CRSClassInfo

CRSClassInfo::CRSClassInfo()
{
	m_nRegionNumber = 0;
	m_aTrainingRegion.RemoveAll();
	m_aTrainPolyLine.RemoveAll();
}

CRSClassInfo::~CRSClassInfo()
{
	CTrainRegion *pRegion = NULL;
	for(int i=0; i<m_nRegionNumber; i++)
	{
		pRegion = (CTrainRegion *)m_aTrainingRegion.GetAt(i);
		ASSERT(pRegion != NULL);
		delete pRegion;
	}
	m_aTrainingRegion.RemoveAll();

	CTrainPolygon * pPolygon = NULL;
	for(i=0; i<m_nRegionNumber; i++)
	{
		pPolygon = (CTrainPolygon *)m_aTrainPolyLine.GetAt(i);
		ASSERT(pPolygon != NULL);
		delete pPolygon;
	}
	m_aTrainPolyLine.RemoveAll();
}
///////////////////////////////////////////////////////
//CRSClassifyInfoFile

CRSClassifyInfoFile::CRSClassifyInfoFile()
{
	m_nImageCount = 0;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_aImageNameArray.RemoveAll();	//It's size is <m_nImageHeight>

	m_nClassCount = 0;
	m_aClassInfoArray.RemoveAll();		//It's size is <m_nClassCount>
}

CRSClassifyInfoFile::~CRSClassifyInfoFile()
{
	Reset();
}

void CRSClassifyInfoFile::Reset()
{
	CString *pszTemp;
	for(int i=0; i<m_aImageNameArray.GetSize(); i++)
	{
		pszTemp = (CString *)(m_aImageNameArray[i]);
		delete pszTemp;
	}
	m_aImageNameArray.RemoveAll();

	CRSClassInfo *pInfo;
	for(int j=0; j<m_aClassInfoArray.GetSize(); j++)
	{
		pInfo = (CRSClassInfo *)(m_aClassInfoArray[j]);
		delete pInfo;
	}
	m_aClassInfoArray.RemoveAll();

	m_nImageCount = 0;
	m_nClassCount = 0;
}

void CRSClassifyInfoFile::Calculate()
{
	CFile File;

	BYTE *pGray;
	CRSClassInfo *pInfo;
	CTrainRegion * pRegion;
	POINT * pPoint;

	// 分类计算中心向量和协方差矩阵
	for(int i=0; i<m_nClassCount; i++)
	{
		pInfo = (CRSClassInfo *)(m_aClassInfoArray[i]);

		// 求出每类有多少个训练区点，并申请临时内存
		DWORD pointSum = 0;
		for(int j=0; j<pInfo->m_nRegionNumber; j++)
		{
			pRegion = (CTrainRegion *)(pInfo->m_aTrainingRegion.GetAt(j));
			pointSum += pRegion->m_nPntNum;
		}
		pGray = new BYTE[pointSum*m_nImageCount];

		// 取出每幅图象中的训练区中的象素
		// 存储方式为：
		//
		//		[ 图象1	  [ 训练区1		
		//		|		  |
		//		/ 图象2	--/ 训练区2
		//		\		  \
		//		|		  [ 训练区3
		//		[ 图象3   
		for(j=0; j<m_nImageCount; j++)
		{
			CString *pszFileName = (CString *)(m_aImageNameArray[j]);
			File.Open(*pszFileName, CFile::modeRead);

			int pointCount = 0;
			for(int k=0; k<pInfo->m_nRegionNumber; k++)
			{
				pRegion = (CTrainRegion *)(pInfo->m_aTrainingRegion.GetAt(k));
				for(int l=0; l<pRegion->m_nPntNum; l++)
				{
					pPoint = (POINT *)(pRegion->m_aPntsInRegion[l]);
					File.Seek(m_nImageWidth*pPoint->y+pPoint->x,CFile::begin);
					File.Read(&pGray[j*pointSum+pointCount+l],sizeof(BYTE));
				}
				pointCount += pRegion->m_nPntNum;
			}
			File.Close();
		}

		// 清除原有值，释放内存
		if(pInfo->m_pdCenter!=NULL)
			delete []pInfo->m_pdCenter;
		if(pInfo->m_pdCovariance!=NULL)
			delete []pInfo->m_pdCovariance;

		// 申请内存
		pInfo->m_pdCenter = new double[m_nImageCount];
		pInfo->m_pdCovariance = new double[m_nImageCount*m_nImageCount];

		// 计算中心向量
		for(j=0; j<m_nImageCount; j++)
		{
			pInfo->m_pdCenter[j] = 0.0;
			for(int k=0; k<pointSum; k++)
				pInfo->m_pdCenter[j] += (double)pGray[j*pointSum+k];
			pInfo->m_pdCenter[j] /= pointSum;
		}

		// 计算协方差矩阵(其中每个元素都是协方差的pointSum倍)
		for(j=0; j<m_nImageCount; j++)
			for(int k=0; k<m_nImageCount; k++)
			{
				pInfo->m_pdCovariance[j*m_nImageCount+k]=0.0;
				for(int l=0; l<pointSum; l++)
					pInfo->m_pdCovariance[j*m_nImageCount+k] +=
							((double)pGray[j*pointSum+l]-pInfo->m_pdCenter[j])*
							((double)pGray[k*pointSum+l]-pInfo->m_pdCenter[k]);
				pInfo->m_pdCovariance[j*m_nImageCount+k] /= pointSum;
			}

		// 释放临时内存
		delete []pGray;
	}
}

int CRSClassifyInfoFile::AddTrainingRegion(POINT *pPoint,int nPointCount,int index)
{
	ASSERT(index>=0 && index<m_aClassInfoArray.GetSize());

	CRSClassInfo *pInfo;
	CTrainRegion * pRegion = new CTrainRegion();
	POINT *pThePoint;
	
	pInfo = (CRSClassInfo *)m_aClassInfoArray.GetAt(index);
	pInfo->m_nRegionNumber += 1;
		
	pRegion->m_nPntNum = nPointCount;
	for(int i=0; i<nPointCount; i++)
	{
		pThePoint = new POINT[1];
		pThePoint->x = pPoint[i].x;
		pThePoint->y = pPoint[i].y;
		pRegion->m_aPntsInRegion.Add(pThePoint);
	}
	pInfo->m_aTrainingRegion.Add(pRegion);
	
	return index;
}

int CRSClassifyInfoFile::AddTrainingPolygon(POINT *pPoint,int nPointCount,int index)
{
	ASSERT(index>=0 && index<m_aClassInfoArray.GetSize());

	CRSClassInfo *pInfo;
	CTrainPolygon * pPolygon = new CTrainPolygon();
	POINT *pThePoint;
	
	pInfo = (CRSClassInfo *)m_aClassInfoArray.GetAt(index);
	//pInfo->m_nRegionNumber += 1;	//已经加1了
		
	pPolygon->m_nPointNum = nPointCount;
	for(int i=0; i<nPointCount; i++)
	{
		pThePoint = new POINT[1];
		pThePoint->x = pPoint[i].x;
		pThePoint->y = pPoint[i].y;
		pPolygon->m_aPolyLine.Add(pThePoint);
	}
	pInfo->m_aTrainPolyLine.Add(pPolygon);
	
	return index;
}

bool CRSClassifyInfoFile::ReadFromFile(CFile &file)
{
	char flag[3];
	file.Read(flag,3);
	if(flag[0]!='C' || flag[1]!='L' || flag[2]!='S')
	{
		AfxMessageBox("非法的影象分类信息文件!");
		return FALSE;
	}

	char szName[256];
	TRY
	{
		// 读参与分类的影象的数目、宽高和名字
		file.Read(&m_nImageCount,sizeof(int));
		file.Read(&m_nImageWidth,sizeof(int));
		file.Read(&m_nImageHeight,sizeof(int));
		for(int i=0; i<m_nImageCount; i++)
		{
			file.Read(szName,256);
			CString * pszFileName = new CString(szName);
			m_aImageNameArray.Add(pszFileName);
		}

		// 读影象的分类信息
		file.Read(&m_nClassCount,sizeof(int));

		CRSClassInfo *pInfo;
		for(i=0; i<m_nClassCount; i++)
		{
			pInfo = new CRSClassInfo();

			// 类的名字、ID号和颜色
			char szClassName[256];
			file.Read(szClassName,256);
			pInfo->m_szClassName = szClassName;
			file.Read(&pInfo->m_nValue,sizeof(int));
			file.Read(&pInfo->m_clrColor,sizeof(COLORREF));

			// 中心向量
			double dTemp;
			pInfo->m_pdCenter = (double *)new double[m_nImageCount];
			for(int j=0; j<m_nImageCount; j++)
			{
				file.Read(&dTemp,sizeof(double));
				pInfo->m_pdCenter[j] = dTemp;
			}

			// 协方差矩阵
			pInfo->m_pdCovariance = (double *)new double[m_nImageCount*m_nImageCount];
			for(j=0; j<m_nImageCount; j++)
				for(int k=0; k<m_nImageCount; k++)
				{
					file.Read(&dTemp,sizeof(double));
					pInfo->m_pdCovariance[j*m_nImageCount+k] = dTemp;
				}

			m_aClassInfoArray.Add(pInfo);
		}
	}
	CATCH( CFileException, e )
	{
		return FALSE; 
	}
	CATCH( CMemoryException, e )
	{
		return FALSE; 
	}
	END_CATCH

	return TRUE;
}

bool CRSClassifyInfoFile::SaveAsFile(CFile &file)
{
	TRY
	{
		// 写文件标志
		CString flag = "CLS";
		file.Write(flag,3);

		// 写参与分类的影象的数目、宽高和名字
		file.Write(&m_nImageCount,sizeof(int));
		file.Write(&m_nImageWidth,sizeof(int));
		file.Write(&m_nImageHeight,sizeof(int));
		for(int i=0; i<m_nImageCount; i++)
		{
			CString *pszFileName = (CString *)(m_aImageNameArray[i]);
			file.Write(*pszFileName,256);
		}

		// 写图象的分类信息
		file.Write(&m_nClassCount,sizeof(int));
		CRSClassInfo *pInfo;
		for(i=0; i<m_nClassCount; i++)
		{
			pInfo = (CRSClassInfo *)(m_aClassInfoArray[i]);
			
			// 类的名字、ID号和颜色
			file.Write(pInfo->m_szClassName,256);
			file.Write(&pInfo->m_nValue,sizeof(int));
			file.Write(&pInfo->m_clrColor,sizeof(COLORREF));
			
			// 中心向量
			double dTemp;
			for(int j=0; j<m_nImageCount; j++)
			{
				dTemp = pInfo->m_pdCenter[j];
				file.Write(&dTemp,sizeof(double));
			}

			// 协方差矩阵
			for(j=0; j<m_nImageCount; j++)
				for(int k=0; k<m_nImageCount; k++)
				{
					dTemp = pInfo->m_pdCovariance[j*m_nImageCount+k];
					file.Write(&dTemp,sizeof(double));
				}
		}
	}
	CATCH( CFileException, e )
	{
		return FALSE; 
	}
	END_CATCH
	
	return TRUE;
}