lsdoc.cpp

数据结构链表的演示程序

	ZeroMemory(retarray,sizeof(long)*line*slipnum);

	for(long index=0;index<m_BlockNum;index++)
	{
		long compare;
		switch(type)
		{
		case 1:
			compare=m_LittleBlocks[index].AREA;
			break;
		case 2:
			compare=m_LittleBlocks[index].LENG;
			break;
		}

		BYTE typeindex=(m_LittleBlocks[index].TYPEINDEX+1)*2;

		UINT i;
		for(i=0;i<slipnum;i++)
		{
			if(compare<=slips[i])
			{
				retarray[i]++;			// 该段的总体的块数加一
				retarray[slipnum+i]+=compare;	// 该段的总体的面积或周长增加
				retarray[typeindex*slipnum+i]++;
				retarray[(typeindex+1)*slipnum+i]+=compare;
				break;
			}
			else
				continue;
		}

	}
	return retarray;
}


void CLSDoc::CalcInfoIndex(Line line,CArray<float,float>& Result)
{
	BYTE typenum=m_BlockTypes.GetSize();

	UINT x1=line.x1+0.5;
	UINT x2=line.x2+0.5;
	UINT y1=line.y1+0.5;
	UINT y2=line.y2+0.5;

	if(x1>=m_nWidth)
		x1=m_nWidth-1;
	if(y1>=m_nHeight)
		y1=m_nHeight-1;
	if(x2>=m_nWidth)
		x2=m_nWidth-1;
	if(y2>=m_nHeight)
		y2=m_nHeight-1;

	UINT segnum;
	UINT leng=sqrt((x2-x1+1)*(x2-x1+1)+(y2-y1+1)*(y2-y1+1))+0.5;
	segnum=double(leng)/double(m_nInfoLeng)+0.5;

	if(x1==x2)
	{
		if(y1>y2)
		{
			UINT tmpy=y2;
			y2=y1;
			y1=tmpy;
		}

		UINT px=x1;
		UINT py;
		BYTE val;
		BYTE nameindex;
		int segindex=-1;
		BOOL * LittleInfo=(BOOL *)malloc(sizeof(BOOL)*typenum*segnum);
		ZeroMemory(LittleInfo,sizeof(BOOL)*typenum*segnum);

		for(py=y1;;py++)
		{
			if((py-y1)%m_nInfoLeng==0)
				segindex++;
			if(segindex==segnum)
				break;
			val=GetValue(px,py);
			nameindex=GetNameIndex(val);
			LittleInfo[nameindex+typenum*segindex]=TRUE;
		}

		int tmpsegnum=segnum;
		while(tmpsegnum>=2)
		{
			float * resultinfo=(float *)malloc(sizeof(float)*typenum);
			ZeroMemory(resultinfo,sizeof(float)*typenum);

			for(segindex=0;segindex<tmpsegnum-1;segindex++)
			{
				for(BYTE k=0;k<typenum;k++)
				{
					if(LittleInfo[k+segindex*typenum]!=LittleInfo[k+(segindex+1)*typenum])
					{
						resultinfo[k]++;
					}
						
					if(segindex*2+1<tmpsegnum)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum]||LittleInfo[k+(segindex*2+1)*typenum];
					else if(segindex*2==tmpsegnum-1)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum];
				}
			}
			
			Result.Add(tmpsegnum);
			for(BYTE m=0;m<typenum;m++)
			{
				Result.Add(resultinfo[m]/(tmpsegnum-1));
			}

			if(tmpsegnum%2==0)
			{
				tmpsegnum=tmpsegnum/2;
			}
			else
			{
				tmpsegnum=(tmpsegnum+1)/2;
			}
		}
		return;
	}

	if(y1==y2)
	{
		if(x1>x2)
		{
			UINT tmpx=x2;
			x2=x1;
			x1=tmpx;
		}

		UINT py=y1;
		UINT px;
		BYTE val;
		BYTE nameindex;
		int segindex=-1;
		BOOL * LittleInfo=(BOOL *)malloc(sizeof(BOOL)*typenum*segnum);
		ZeroMemory(LittleInfo,sizeof(BOOL)*typenum*segnum);

		for(px=x1;;px++)
		{
			if((px-x1)%m_nInfoLeng==0)
				segindex++;
			if(segindex==segnum)
				break;
			val=GetValue(px,py);
			nameindex=GetNameIndex(val);
			LittleInfo[nameindex+typenum*segindex]=TRUE;
		}

		int tmpsegnum=segnum;
		while(tmpsegnum>=2)
		{
			float * resultinfo=(float *)malloc(sizeof(float)*typenum);
			ZeroMemory(resultinfo,sizeof(float)*typenum);

			for(segindex=0;segindex<tmpsegnum-1;segindex++)
			{
				for(BYTE k=0;k<typenum;k++)
				{
					if(LittleInfo[k+segindex*typenum]!=LittleInfo[k+(segindex+1)*typenum])
					{
						resultinfo[k]++;
					}

					if(segindex*2+1<tmpsegnum)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum]||LittleInfo[k+(segindex*2+1)*typenum];
					else if(segindex*2==tmpsegnum-1)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum];
				}
			}

			Result.Add(tmpsegnum);
			for(BYTE m=0;m<typenum;m++)
			{
				Result.Add(resultinfo[m]/(tmpsegnum-1));
			}

			if(tmpsegnum%2==0)
			{
				tmpsegnum=tmpsegnum/2;
			}
			else
			{
				tmpsegnum=(tmpsegnum+1)/2;
			}
		}
		return;
	}

	double k=(double(y2)-double(y1))/(double(x2)-double(x1));

	if(abs(x1-x2)>=abs(y1-y2))
	{
		if(x1>x2)
		{
			UINT tmpx=x2;
			UINT tmpy=y2;
			y2=y1;
			x2=x1;
			x1=tmpx;
			y1=tmpy;
		}

		UINT px;
		BYTE val;
		BYTE nameindex;
		int segindex=-1;
		BOOL * LittleInfo=(BOOL *)malloc(sizeof(BOOL)*typenum*segnum);
		ZeroMemory(LittleInfo,sizeof(BOOL)*typenum*segnum);

		UINT segx=m_nInfoLeng/sqrt(1+k*k)+0.5;
		for(px=x1;;px++)
		{
			if((px-x1)%segx==0)
				segindex++;
			if(segindex==segnum)
				break;
			val=GetValue(px,y1+(px-x1)*k+0.5);
			nameindex=GetNameIndex(val);
			LittleInfo[nameindex+typenum*segindex]=TRUE;
		}

		int tmpsegnum=segnum;
		while(tmpsegnum>=2)
		{
			float * resultinfo=(float *)malloc(sizeof(float)*typenum);
			ZeroMemory(resultinfo,sizeof(float)*typenum);

			for(segindex=0;segindex<tmpsegnum-1;segindex++)
			{
				for(BYTE k=0;k<typenum;k++)
				{
					if(LittleInfo[k+segindex*typenum]!=LittleInfo[k+(segindex+1)*typenum])
					{
						resultinfo[k]++;
					}

					if(segindex*2+1<tmpsegnum)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum]||LittleInfo[k+(segindex*2+1)*typenum];
					else if(segindex*2==tmpsegnum-1)
						LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum];
				}
			}

			Result.Add(tmpsegnum);
			for(BYTE m=0;m<typenum;m++)
			{
				Result.Add(resultinfo[m]/(tmpsegnum-1));
			}

			if(tmpsegnum%2==0)
			{
				tmpsegnum=tmpsegnum/2;
			}
			else
			{
				tmpsegnum=(tmpsegnum+1)/2;
			}
		}
		return;
	}

	if(y1>y2)
	{
		UINT tmpx=x2;
		UINT tmpy=y2;
		y2=y1;
		x2=x1;
		x1=tmpx;
		y1=tmpy;
	}

	UINT py;
	BYTE val;
	BYTE nameindex;
	int segindex=-1;
	BOOL * LittleInfo=(BOOL *)malloc(sizeof(BOOL)*typenum*segnum);
	ZeroMemory(LittleInfo,sizeof(BOOL)*typenum*segnum);

	UINT segy=fabs(k)*m_nInfoLeng/sqrt(1+k*k)+0.5;
	for(py=y1;;py++)
	{
		if((py-y1)%segy==0)
			segindex++;
		if(segindex==segnum)
			break;
		val=GetValue((py-y1)/k+x1+0.5,py);
		nameindex=GetNameIndex(val);
		LittleInfo[nameindex+typenum*segindex]=TRUE;
	}

	int tmpsegnum=segnum;
	while(tmpsegnum>=2)
	{
		float * resultinfo=(float *)malloc(sizeof(float)*typenum);
		ZeroMemory(resultinfo,sizeof(float)*typenum);

		for(segindex=0;segindex<tmpsegnum-1;segindex++)
		{
			for(BYTE k=0;k<typenum;k++)
			{
				if(LittleInfo[k+segindex*typenum]!=LittleInfo[k+(segindex+1)*typenum])
				{
					resultinfo[k]++;
				}

				if(segindex*2+1<tmpsegnum)
					LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum]||LittleInfo[k+(segindex*2+1)*typenum];
				else if(segindex*2==tmpsegnum-1)
					LittleInfo[k+segindex*typenum]=LittleInfo[k+segindex*2*typenum];
			}
		}

		Result.Add(tmpsegnum);
		for(BYTE m=0;m<typenum;m++)
		{
			Result.Add(resultinfo[m]/(tmpsegnum-1));
		}

		if(tmpsegnum%2==0)
		{
			tmpsegnum=tmpsegnum/2;
		}
		else
		{
			tmpsegnum=(tmpsegnum+1)/2;
		}
	}

	return;
}


double * CLSDoc::CalcSpace(UINT boxnum,CArray<UINT,UINT> & lengs)
{
	BYTE typenum=m_BlockTypes.GetSize();

	double * retarray=(double *)malloc(sizeof(double)*boxnum*typenum);
	ZeroMemory(retarray,sizeof(double)*boxnum*typenum);

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

	waitdlg.m_ProgWait.SetRange(0,boxnum);
	waitdlg.m_ProgWait.SetStep(1);

	for(int i=0;i<boxnum;i++)
	{
		waitdlg.m_ProgWait.StepIt();

		UINT leng=lengs[i];

		if(leng==1)
		{
			for(BYTE tt=0;tt<typenum;tt++)
			{	
				retarray[i*typenum+tt]=m_BaseSpace[tt];
			}

			continue;
		}

		ULONG arraywidth=leng*leng;

		ULONG Nr=(m_nWidth-leng+1)*(m_nHeight-leng+1);
		
		ULONG * Nsr=(ULONG *)malloc(sizeof(ULONG)*typenum*(arraywidth));
		ZeroMemory(Nsr,sizeof(ULONG)*typenum*(arraywidth));

		ULONG * typeSY=(ULONG *)malloc(sizeof(ULONG)*typenum);
		ZeroMemory(typeSY,sizeof(ULONG)*typenum);

		for(UINT a=0;a<leng;a++)
		{
			for(UINT b=0;b<leng;b++)
			{
				BYTE val=GetValue(a,b);
				BYTE typeindex=GetNameIndex(val);
				typeSY[typeindex]++;
			}
		}

		for(UINT starty=0;starty<=m_nHeight-leng;starty++)
		{
			ULONG * typeS=(ULONG *)malloc(sizeof(ULONG)*typenum);		
							// 滑箱中各类景观的像素数
			
			ZeroMemory(typeS,sizeof(ULONG)*typenum);

			if(starty>0)
			{
				for(UINT xx=0;xx<leng;xx++)
				{
					BYTE val=GetValue(xx,starty-1);
					BYTE typeindex=GetNameIndex(val);
					typeSY[typeindex]--;

					val=GetValue(xx,starty+leng-1);
					typeindex=GetNameIndex(val);
					typeSY[typeindex]++;
				}
			}


			for(BYTE ttt=0;ttt<typenum;ttt++)
			{
				typeS[ttt]=typeSY[ttt];
			}


			for(BYTE t=0;t<typenum;t++)
			{
				if(typeS[t]!=0)
				{
					Nsr[t*arraywidth+typeS[t]-1]++;
				}
			}

			
			for(UINT startx=1;startx<=m_nWidth-leng;startx++)
			{
				for(UINT movey=0;movey<leng;movey++)
				{
					BYTE val=GetValue(startx-1,starty+movey);
					BYTE typeindex=GetNameIndex(val);
					typeS[typeindex]--;

					val=GetValue(startx+leng-1,starty+movey);
					typeindex=GetNameIndex(val);
					typeS[typeindex]++;
				}

				for(BYTE t=0;t<typenum;t++)
				{
					if(typeS[t]!=0)
					{
						Nsr[t*arraywidth+typeS[t]-1]++;
					}
				}
			}
		}


		for(BYTE tt=0;tt<typenum;tt++)
		{
			LONGLONG ESNsr=0;
			LONGLONG ESSNsr=0;

			for(ULONG ll=1;ll<=arraywidth;ll++)
			{
				LONGLONG nsr=Nsr[tt*(arraywidth)+ll-1];
				LONGLONG snsr=ll*nsr;
				LONGLONG ssnsr=ll*snsr;
				ESNsr+=snsr;
				ESSNsr+=ssnsr;
			}

			double tmpspaceindex=double(ESSNsr)/double(ESNsr)/double(ESNsr)*double(Nr);

			retarray[i*typenum+tt]=tmpspaceindex;
		}
	}

	waitdlg.DestroyWindow();
	return retarray;

}


BOOL CLSDoc::Write(const char *pzFileName,int x1,int y1,int x2,int y2)
{
	int width=x2-x1+1;
	int datawidth;

	if(width%4!=0)
	{
		datawidth=width/4+1;
		datawidth=datawidth*4;
	}
	else
		datawidth=width;

	int height=y2-y1+1;

	BITMAPINFOHEADER bminfohd;
	BITMAPFILEHEADER bmfhd;

	int nHeaderSize=sizeof(BITMAPFILEHEADER);
	int nInfoSize=sizeof(BITMAPINFOHEADER);
	int nQuadSize=sizeof(RGBQUAD)*m_dib.m_Colors;
	long nDataSize=datawidth*height;
	
	bminfohd.biSize=nInfoSize;
	bminfohd.biWidth=width;
	bminfohd.biHeight=height;
	bminfohd.biPlanes=1;
	bminfohd.biBitCount=8;
	bminfohd.biCompression=0;
	bminfohd.biSizeImage=nDataSize;
	bminfohd.biClrUsed=m_dib.m_Colors;
	bminfohd.biClrImportant=0;
	
	RGBQUAD * rgbquad=(RGBQUAD *)malloc(nQuadSize);

	for(int i=0;i<m_dib.m_Colors;i++)
	{
		rgbquad[i]=m_dib.m_Quads[i];