lsdoc.cpp

数据结构链表的演示程序

	}

	bmfhd.bfType=* ( (WORD *) "BM");
	bmfhd.bfOffBits=nHeaderSize+nInfoSize+nQuadSize;
	bmfhd.bfReserved1=bmfhd.bfReserved2=0;
	bmfhd.bfSize=bmfhd.bfOffBits+nDataSize;

	BYTE * imagedata=(BYTE *)malloc(nDataSize);
	
	long index=0;
	for(int b=y2;b>=y1;b--)
	{
		for(int a=x1;a<=x2;a++)
		{
			imagedata[index]=GetValue(a,b);
			index++;
		}
		for(int c=x2-x1+1;c<datawidth;c++)
		{
			imagedata[index]=0;
			index++;
		}
	}

	CFile file;

	try
	{
		file.Open(pzFileName,CFile::modeCreate | CFile::modeWrite | CFile:: typeBinary);
		file.Write((LPSTR)&bmfhd, nHeaderSize);
		file.Write((LPSTR)&bminfohd,nInfoSize);
		file.Write((LPSTR)rgbquad,nQuadSize);
		file.WriteHuge((LPSTR)imagedata,nDataSize);
	}
	catch (CFileException* e)   
	{      
		THROW(e);
	}

	return TRUE;
}


TypeIndex * CLSDoc::CalcRegionAllIndex(int x1,int y1,int x2,int y2,
									   AllIndex& AllIndexReturn)
{
	BYTE typenum=m_BlockTypes.GetSize();

	TypeIndex * TypeIndexReturn=(TypeIndex *)malloc(sizeof(TypeIndex)*typenum);

	ZeroMemory(TypeIndexReturn,sizeof(TypeIndex)*typenum);

	double AllArea=(x2-x1+1)*(y2-y1+1);

	CArray <RegionBlockProperty,RegionBlockProperty> Blocks;
	RegionBlockProperty tmpBlock;

	for(int starty=y1;starty<=y2;starty++)
	{
		for(int startx=x1;startx<=x2;startx++)
		{
			long id=m_BlockID[startx+starty*m_nWidth].ID;

			for(int index=0;index<Blocks.GetSize();index++)
			{
				if(Blocks[index].BlockID==id)	//判断是否为新斑块
				{					// 否则面积加一
					Blocks[index].area++;
					break;
				}
			}

			if(index==Blocks.GetSize())		// 是新斑块则加入斑块数组
			{ 
				tmpBlock.BlockID=id;
				tmpBlock.area=1;
				tmpBlock.typeindex=m_LittleBlocks[id-1].TYPEINDEX;
				Blocks.Add( tmpBlock );
			} 		
		}
	}
	
	int BlockNum=Blocks.GetSize();

	AllIndexReturn.AverArea=AllArea/BlockNum;
	AllIndexReturn.BlockNum=BlockNum;
	AllIndexReturn.Chip=(BlockNum-1)/AllIndexReturn.AverArea;

	AllIndexReturn.City=0;
	AllIndexReturn.Jamming=0;
	AllIndexReturn.Plant=0;
	AllIndexReturn.Risk=0;

	// 以下初始化类型数组
	RegionTypeProperty * RegionTypes=(RegionTypeProperty *)malloc(
		sizeof(RegionTypeProperty)*typenum);

	ZeroMemory(RegionTypes,sizeof(RegionTypeProperty)*typenum);


	// 以下填充类型数组
	for(int blockindex=0;blockindex<BlockNum;blockindex++)
	{
		BYTE typeindex=Blocks[blockindex].typeindex;
		RegionTypes[typeindex].area+=Blocks[blockindex].area;
		RegionTypes[typeindex].blocknum++;
	}

	double Pk,EPk=0;	// 多样性指数
	double Hmax;	// 最大多样性指数
	BYTE trueTypeNum=0;
 
	for(BYTE j=0;j<typenum;j++)
	{
		if(RegionTypes[j].blocknum>0)
		{
			double blocknum=RegionTypes[j].blocknum;
			
			Pk=RegionTypes[j].area/AllArea;
			EPk+=Pk*log(Pk);
			trueTypeNum++;

			// 以下计算各类型的指数值
	
			TypeIndexReturn[j].IsData=TRUE;
			TypeIndexReturn[j].AverArea=RegionTypes[j].area/blocknum;
			TypeIndexReturn[j].BlockNum=RegionTypes[j].blocknum;
			TypeIndexReturn[j].Chip=(blocknum-1)/TypeIndexReturn[j].AverArea;
			
			AllIndexReturn.City+=RegionTypes[j].area*m_Coefficient[j*4];
			AllIndexReturn.Jamming+=RegionTypes[j].area*m_Coefficient[j*4+1];
			AllIndexReturn.Plant+=RegionTypes[j].area*m_Coefficient[j*4+2];
			AllIndexReturn.Risk+=RegionTypes[j].area*m_Coefficient[j*4+3];
		}
	}

	AllIndexReturn.City/=AllArea;
	AllIndexReturn.Jamming/=AllArea;
	AllIndexReturn.Plant/=AllArea;
	AllIndexReturn.Risk/=AllArea;

	EPk=-EPk;
	Hmax=log(trueTypeNum);

	AllIndexReturn.Diversity=EPk;
	if(Hmax!=0)
	{
		AllIndexReturn.Blance=EPk/Hmax;
	}
	else
	{
		AllIndexReturn.Blance=0;
	}

	AllIndexReturn.Vantage=Hmax-EPk;

	return TypeIndexReturn;
}


void CLSDoc::AllVarySpace()
{
	if(m_bRandom)
	{
		RanAllVarySpace();
	}
	else
	{
		SysAllVarySpace();
	}
}


void CLSDoc::SysAllVarySpace()		// 系统采样变量空间化
{	
	// 公有变量
	long boxnum=m_nYBox*m_nXBox;
	BYTE typenum=m_BlockTypes.GetSize();
	UINT nBoxWidth=m_nWidth/m_nXBox;
	UINT nBoxHeight=m_nHeight/m_nYBox;



	// 结果变量初始化
	m_aBoxCoords.RemoveAll();
	m_aBoxCoords.SetSize(m_nAllBoxNum);

	m_AllVarySpace.RemoveAll();
	m_AllVarySpace.SetSize(boxnum);

	m_TypeVarySpace.RemoveAll();
	m_TypeVarySpace.SetSize(boxnum*typenum);

	m_AverAllIndex.Z_AverArea=0;
	m_AverAllIndex.Z_Blance=0;
	m_AverAllIndex.Z_BlockNum=0;
	m_AverAllIndex.Z_Chip=0;
	m_AverAllIndex.Z_City=0;
	m_AverAllIndex.Z_Diversity=0;
	m_AverAllIndex.Z_Jamming=0;
	m_AverAllIndex.Z_Plant=0;
	m_AverAllIndex.Z_Risk=0;
	m_AverAllIndex.Z_Vantage=0;

	m_AllC0.Z_AverArea=0;
	m_AllC0.Z_Blance=0;
	m_AllC0.Z_BlockNum=0;
	m_AllC0.Z_Chip=0;
	m_AllC0.Z_City=0;
	m_AllC0.Z_Diversity=0;
	m_AllC0.Z_Jamming=0;
	m_AllC0.Z_Plant=0;
	m_AllC0.Z_Risk=0;
	m_AllC0.Z_Vantage=0;

	m_AverTypeIndex.RemoveAll();
	m_AverTypeIndex.SetSize(typenum);

	m_TypeC0.RemoveAll();
	m_TypeC0.SetSize(typenum);

	for(int kj=0;kj<typenum;kj++)
	{
		m_AverTypeIndex[kj].Chip=0;
		m_AverTypeIndex[kj].AverArea=0;
		m_AverTypeIndex[kj].BlockNum=0;

		m_TypeC0[kj].Chip=0;
		m_TypeC0[kj].AverArea=0;
		m_TypeC0[kj].BlockNum=0;
	}



	//临时变量
	int boxindex=-1;
	int startx=0;
	int starty=0;
	TypeIndex * tmpTypeIndex=(TypeIndex *)malloc(sizeof(TypeIndex)*typenum);
	

	CWaitDlg waitdlg;
	waitdlg.Create(IDD_WAIT,NULL);

	waitdlg.m_ProgWait.SetRange(0,m_nYBox+2);
	waitdlg.m_ProgWait.SetStep(1);


	
	// 从左到右,从上到下计算值
	for(int ynum=0;ynum<m_nYBox;ynum++)
	{
		for(int xnum=0;xnum<m_nXBox;xnum++)
		{
			boxindex++;

			m_aBoxCoords[boxindex].x=startx;
			m_aBoxCoords[boxindex].y=starty;

			// 计算子单元的值
			tmpTypeIndex=CalcRegionAllIndex(startx,starty,
				startx+nBoxWidth-1-m_nHorizDist,starty+nBoxHeight-1-m_nVertiDist,
				m_AllVarySpace[boxindex]);

			// 填充类型变量的值
			for(int ttt=0;ttt<typenum;ttt++)
			{
				m_TypeVarySpace[boxindex*typenum+ttt]=tmpTypeIndex[ttt];

				// 计算类型平均值
				if(tmpTypeIndex[ttt].IsData)
				{
					m_AverTypeIndex[ttt].AverArea+=tmpTypeIndex[ttt].AverArea;
					m_AverTypeIndex[ttt].BlockNum+=tmpTypeIndex[ttt].BlockNum;
					m_AverTypeIndex[ttt].Chip+=tmpTypeIndex[ttt].Chip;

					m_TypeC0[ttt].AverArea+=tmpTypeIndex[ttt].AverArea*
						tmpTypeIndex[ttt].AverArea;
					m_TypeC0[ttt].BlockNum+=tmpTypeIndex[ttt].BlockNum*
						tmpTypeIndex[ttt].BlockNum;
					m_TypeC0[ttt].Chip+=tmpTypeIndex[ttt].Chip*
						tmpTypeIndex[ttt].Chip;
				}
			}

			// 计算整体平均值
			m_AverAllIndex.Z_AverArea+=m_AllVarySpace[boxindex].AverArea;
			m_AverAllIndex.Z_Blance+=m_AllVarySpace[boxindex].Blance;
			m_AverAllIndex.Z_BlockNum+=m_AllVarySpace[boxindex].BlockNum;
			m_AverAllIndex.Z_Chip+=m_AllVarySpace[boxindex].Chip;
			m_AverAllIndex.Z_City+=m_AllVarySpace[boxindex].City;
			m_AverAllIndex.Z_Diversity+=m_AllVarySpace[boxindex].Diversity;
			m_AverAllIndex.Z_Jamming+=m_AllVarySpace[boxindex].Jamming;
			m_AverAllIndex.Z_Plant+=m_AllVarySpace[boxindex].Plant;
			m_AverAllIndex.Z_Risk+=m_AllVarySpace[boxindex].Risk;
			m_AverAllIndex.Z_Vantage+=m_AllVarySpace[boxindex].Vantage;

			m_AllC0.Z_AverArea+=m_AllVarySpace[boxindex].AverArea*
				m_AllVarySpace[boxindex].AverArea;
			m_AllC0.Z_Blance+=m_AllVarySpace[boxindex].Blance*
				m_AllVarySpace[boxindex].Blance;
			m_AllC0.Z_BlockNum+=m_AllVarySpace[boxindex].BlockNum*
				m_AllVarySpace[boxindex].BlockNum;
			m_AllC0.Z_Chip+=m_AllVarySpace[boxindex].Chip*
				m_AllVarySpace[boxindex].Chip;
			m_AllC0.Z_City+=m_AllVarySpace[boxindex].City*
				m_AllVarySpace[boxindex].City;
			m_AllC0.Z_Diversity+=m_AllVarySpace[boxindex].Diversity*
				m_AllVarySpace[boxindex].Diversity;
			m_AllC0.Z_Jamming+=m_AllVarySpace[boxindex].Jamming*
				m_AllVarySpace[boxindex].Jamming;
			m_AllC0.Z_Plant+=m_AllVarySpace[boxindex].Plant*
				m_AllVarySpace[boxindex].Plant;
			m_AllC0.Z_Risk+=m_AllVarySpace[boxindex].Risk*
				m_AllVarySpace[boxindex].Risk;
			m_AllC0.Z_Vantage+=m_AllVarySpace[boxindex].Vantage*
				m_AllVarySpace[boxindex].Vantage;

			startx+=nBoxWidth;
		}

		startx=0;
		starty+=nBoxHeight;

		waitdlg.m_ProgWait.StepIt();
	}

	
	// 求平均
	m_AverAllIndex.Z_AverArea/=boxnum;
	m_AverAllIndex.Z_Blance/=boxnum;
	m_AverAllIndex.Z_BlockNum/=boxnum;
	m_AverAllIndex.Z_Chip/=boxnum;
	m_AverAllIndex.Z_City/=boxnum;
	m_AverAllIndex.Z_Diversity/=boxnum;
	m_AverAllIndex.Z_Jamming/=boxnum;
	m_AverAllIndex.Z_Plant/=boxnum;
	m_AverAllIndex.Z_Risk/=boxnum;
	m_AverAllIndex.Z_Vantage/=boxnum;

	m_AllC0.Z_AverArea=m_AllC0.Z_AverArea/boxnum-
		m_AverAllIndex.Z_AverArea*m_AverAllIndex.Z_AverArea;
	m_AllC0.Z_Blance=m_AllC0.Z_Blance/boxnum-
		m_AverAllIndex.Z_Blance*m_AverAllIndex.Z_Blance;
	m_AllC0.Z_BlockNum=m_AllC0.Z_BlockNum/boxnum-
		m_AverAllIndex.Z_BlockNum*m_AverAllIndex.Z_BlockNum;
	m_AllC0.Z_Chip=m_AllC0.Z_Chip/boxnum-
		m_AverAllIndex.Z_Chip*m_AverAllIndex.Z_Chip;
	m_AllC0.Z_City=m_AllC0.Z_City/boxnum-
		m_AverAllIndex.Z_City*m_AverAllIndex.Z_City;
	m_AllC0.Z_Diversity=m_AllC0.Z_Diversity/boxnum-
		m_AverAllIndex.Z_Diversity*m_AverAllIndex.Z_Diversity;
	m_AllC0.Z_Jamming=m_AllC0.Z_Jamming/boxnum-
		m_AverAllIndex.Z_Jamming*m_AverAllIndex.Z_Jamming;
	m_AllC0.Z_Plant=m_AllC0.Z_Plant/boxnum-
		m_AverAllIndex.Z_Plant*m_AverAllIndex.Z_Plant;
	m_AllC0.Z_Risk=m_AllC0.Z_Risk/boxnum-
		m_AverAllIndex.Z_Risk*m_AverAllIndex.Z_Risk;
	m_AllC0.Z_Vantage=m_AllC0.Z_Vantage/boxnum-
		m_AverAllIndex.Z_Vantage*m_AverAllIndex.Z_Vantage;


	for(int mls=0;mls<typenum;mls++)
	{
		m_AverTypeIndex[mls].AverArea/=boxnum;
		m_AverTypeIndex[mls].BlockNum/=boxnum;
		m_AverTypeIndex[mls].Chip/=boxnum;

		m_TypeC0[mls].AverArea=m_TypeC0[mls].AverArea/boxnum-
			m_AverTypeIndex[mls].AverArea*m_AverTypeIndex[mls].AverArea;

		m_TypeC0[mls].BlockNum=m_TypeC0[mls].BlockNum/boxnum-
			m_AverTypeIndex[mls].BlockNum*m_AverTypeIndex[mls].BlockNum;

		m_TypeC0[mls].Chip=m_TypeC0[mls].Chip/boxnum-
			m_AverTypeIndex[mls].Chip*m_AverTypeIndex[mls].Chip;
	}


	waitdlg.m_ProgWait.StepIt();

	// 求EI0
	CalcEI0();

	waitdlg.m_ProgWait.StepIt();

	waitdlg.DestroyWindow();

	m_bEverAllSpace=TRUE;
}


void CLSDoc::RanAllVarySpace()		// 随机采样变量空间化
{	
	// 公有变量
	long boxnum=m_nAllBoxNum;
	BYTE typenum=m_BlockTypes.GetSize();
	UINT nBoxWidth=m_nRanBoxWidth;
	UINT nBoxHeight=m_nRanBoxHeight;



	// 结果变量初始化
	if(!m_bPointFromFile)
	{
		m_aBoxCoords.RemoveAll();
		m_aBoxCoords.SetSize(boxnum);
	}

	m_AllVarySpace.RemoveAll();
	m_AllVarySpace.SetSize(boxnum);

	m_TypeVarySpace.RemoveAll();
	m_TypeVarySpace.SetSize(boxnum*typenum);

	m_AverAllIndex.Z_AverArea=0;
	m_AverAllIndex.Z_Blance=0;
	m_AverAllIndex.Z_BlockNum=0;
	m_AverAllIndex.Z_Chip=0;
	m_AverAllIndex.Z_City=0;
	m_AverAllIndex.Z_Diversity=0;
	m_AverAllIndex.Z_Jamming=0;
	m_AverAllIndex.Z_Plant=0;
	m_AverAllIndex.Z_Risk=0;
	m_AverAllIndex.Z_Vantage=0;

	m_AllC0.Z_AverArea=0;
	m_AllC0.Z_Blance=0;
	m_AllC0.Z_BlockNum=0;
	m_AllC0.Z_Chip=0;
	m_AllC0.Z_City=0;
	m_AllC0.Z_Diversity=0;
	m_AllC0.Z_Jamming=0;
	m_AllC0.Z_Plant=0;
	m_AllC0.Z_Risk=0;
	m_AllC0.Z_Vantage=0;

	m_AverTypeIndex.RemoveAll();
	m_AverTypeIndex.SetSize(typenum);

	m_TypeC0.RemoveAll();
	m_TypeC0.SetSize(typenum);

	for(int kj=0;kj<typenum;kj++)
	{
		m_AverTypeIndex[kj].Chip=0;
		m_AverTypeIndex[kj].AverArea=0;
		m_AverTypeIndex[kj].BlockNum=0;

		m_TypeC0[kj].Chip=0;
		m_TypeC0[kj].AverArea=0;
		m_TypeC0[kj].BlockNum=0;
	}


	int startx=0;
	int starty=0;
	TypeIndex * tmpTypeIndex=(TypeIndex *)malloc(sizeof(TypeIndex)*typenum);
	

	CWaitDlg waitdlg;
	waitdlg.Create(IDD_WAIT,NULL);

	waitdlg.m_ProgWait.SetRange(0,m_nAllBoxNum+2);
	waitdlg.m_ProgWait.SetStep(1);


	srand( (unsigned)time( NULL ) );
	UINT maxrandx=m_nWidth-nBoxWidth;
	UINT maxrandy=m_nHeight-nBoxHeight;

	for(UINT boxindex=0;boxindex<boxnum;boxindex++)
	{
		if(!m_bPointFromFile)
		{
			BOOL bLoop;
			do
			{
				bLoop=FALSE;
				startx=rand()%maxrandx;
				starty=rand()%maxrandy;

				for(UINT coordindex=0;coordindex<boxindex;coordindex++)
				{
					if((startx==m_aBoxCoords[coordindex].x)&&(starty==m_aBoxCoords[coordindex].y))
					{
						bLoop=TRUE;
						break;
					}
				}
			}while(bLoop);

			m_aBoxCoords[boxindex].x=startx;
			m_aBoxCoords[boxindex].y=starty;
		}

		else
		{
			startx=m_aBoxCoords[boxindex].x;
			starty=m_aBoxCoords[boxindex].y;
		}

		// 计算子单元的值
		tmpTypeIndex=CalcRegionAllIndex(startx,starty,
			startx+nBoxWidth-1,starty+nBoxHeight-1,
			m_AllVarySpace[boxindex]);

		// 填充类型变量的值
		for(int ttt=0;ttt<typenum;ttt++)
		{
			m_TypeVarySpace[boxindex*typenum+ttt]=tmpTypeIndex[ttt];

			// 计算类型平均值