cnsdftctl.cpp

这个不用多说了

		AfxMessageBox("写入文件失败");
		return;
	}
	fputs("HeadBegin\n",pfile);
	WriteVctFileHead(pfile);
	fputs("HeadEnd\n",pfile);
	fputs("\n",pfile);
	
	fputs("FeatureCodeBegin\n",pfile); 
	WriteVctFeature(pfile);
	fputs("FeatureCodeEnd\n",pfile);
	fputs("\n",pfile);

	fputs("TableStructureBegin\n",pfile);
	WriteVctTableStructure(pfile);
	fputs("TableStructureEnd\n",pfile);
	fputs("\n",pfile);

	WriteVctGraphy();

	fputs("AnnotationBegin\n",pfile);	
	WriteVctAnnotation(pfile);
	fputs("AnnotationEnd\n",pfile);
	fputs("\n",pfile);

	fputs("AttributeBegin\n",pfile);
	WriteVctAttribute(pfile);
	fputs("AttributeEnd\n",pfile);
	
	fclose(pfile);
	
	MessageBox("数据转换完成",MB_OK,MB_ICONINFORMATION);
}

void CCNSDFTCtrl::ReadVctFileHead(FILE *file)
{
	char buffer[200];
	do
	{
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
		strtok(buffer,":");
		char* tmp=strtok(NULL,":");
		if(0==strnicmp("DataMark",buffer,8))
		{
			if(tmp)
				m_filehead.DataMark=tmp;
			else
				m_filehead.DataMark="";

			 m_filehead.DataMark.TrimLeft();
			 m_filehead.DataMark.TrimRight();
		
		}
		if(0==strnicmp("VerSion",buffer,7))
		{
	        if(tmp)
				sscanf(tmp,"%f",&m_filehead.VerSion);
			else
				m_filehead.VerSion=0;
		}
		if(0==strnicmp("Unit",buffer,4))
		{
           if(tmp)
			    sscanf(tmp,"%s",&m_filehead.Unit);//problem
		   else
				m_filehead.Unit=' ';
		}
		if(0==strnicmp("Dim",buffer,3))
		{
			if(tmp)
				sscanf(tmp,"%d",&m_filehead.Dim);
		//	else
        }
		if(0==strnicmp("Topo",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%d",&m_filehead.Topo);
			//else
		}
		if(0==strnicmp("MinX",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MinX);//问题m_filehead.MinX
			//else
			//	m_filehead.MinX=0;
		}
		if(0==strnicmp("MinY",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MinY);
		//	else
		//		m_filehead.MinY=0;
		}
			if(0==strnicmp("MinZ",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MinZ);
			//else
			//	m_filehead.MinZ=0;
		}
		if(0==strnicmp("MaxX",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MaxX);
		//	else
		//		m_filehead.MaxX=0;
		}
		if(0==strnicmp("MaxY",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MaxY);
			//else
			//	m_filehead.MaxY=0;
		}
        if(0==strnicmp("MaxZ",buffer,4))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.MaxZ);
			//else
			//	m_filehead.MaxZ=0;
		}
        if(0==strnicmp("ScaleM",buffer,6))
		{
			if(tmp)
				sscanf(tmp,"%f",&m_filehead.ScaleM);
			//else
			//	m_filehead.ScaleM=0;
		}
		if(0==strnicmp("Projection",buffer,10))
		{
			if(tmp)
				m_filehead.Projection=tmp;
			//else
			//	m_filehead.Projection="";
		}
		if(0==strnicmp("Spheroid",buffer,8))
		{
			if(tmp)
				m_filehead.Spheroid=tmp;
			//else
			//	m_filehead.Spheroid="";
		}
        if(0==strnicmp("Parameters",buffer,10))
		{
			if(tmp)
				m_filehead.Parameters=tmp;
			else
			  m_filehead.Parameters="";
		}
		if(0==strnicmp("Date",buffer,4))
		{
			if(tmp)
				m_filehead.Date=tmp;
			//else
			//	m_filehead.Date="";
		}
		if(0==strnicmp("Separator",buffer,9))
		{
			if(tmp)
				sscanf(tmp,"%s",&m_filehead.Separator);//NOproblem
			else
				m_filehead.Separator=',';
		}
        if(0==strnicmp("Coordinate",buffer,10))
		{
			if(tmp)
				sscanf(tmp,"%c",&m_filehead.Coordinate);
			else
                m_filehead.Coordinate='M';
		}

	}while(strnicmp("HeadEnd",buffer,7)!=0);
}

void CCNSDFTCtrl::ReadVctFeature(FILE *pfile)
{
	///////////读取要素类型参数
	pHeadFeature=NULL;
	char buffer[200];
	Feature  *pCurFeature,	*pPrevFeature;
    fgetNoEmpty(buffer,sizeof(buffer),pfile);
	int TmpFlg=1;
	while(strnicmp("FeatureCodeEnd",buffer,14)!=0)
	{
		strtok(buffer,",");
		char* nam=strtok(NULL,",");
		char* shap=strtok(NULL,",");
		char* colr=strtok(NULL,",");
		char* lstnam=strtok(NULL,",");
		pCurFeature=new Feature[sizeof(Feature)];
		pCurFeature->Code=buffer;
		pCurFeature->Name=nam;
        pCurFeature->Shape=shap;
		sscanf(colr,"%d",&pCurFeature->Color);
		pCurFeature->ListName=lstnam;
        pCurFeature->pNext=NULL;
		if(TmpFlg==1)
              pHeadFeature=pCurFeature;
		else
			  pPrevFeature->pNext=pCurFeature;
		  pPrevFeature=pCurFeature;
		  TmpFlg=0;
          fgetNoEmpty(buffer,sizeof(buffer),pfile);
	}
}

void CCNSDFTCtrl::ReadVctTableStruct(FILE *pfile)
{
	//////读属性数据结构
	pHeadTblStruct=NULL;
	char buffer[200];
	TableStructure  *pCurTblStruct,*pPrevTblStruct;
	int temp=1;
	fgetNoEmpty(buffer,sizeof(buffer),pfile);
	while(strnicmp("TableStructureEnd",buffer,17)!=0)
	{
		strtok(buffer,",");
		char* itemNum=strtok(NULL,",");
		pCurTblStruct=new TableStructure[sizeof(TableStructure)];
		pCurTblStruct->ListName=buffer;
		sscanf(itemNum,"%d",&pCurTblStruct->ItemNum);
		pCurTblStruct->pTblNext=NULL;
        Item* item=new Item[pCurTblStruct->ItemNum];
		pCurTblStruct->pItem=item;
		for(int i=0;i<pCurTblStruct->ItemNum;i++)
		{
			fgetNoEmpty(buffer,sizeof(buffer),pfile);
			strtok(buffer,",");
			char* type=strtok(NULL,",");
			item[i].Name=buffer;
            item[i].Type=type;
			if(item[i].Type=="Char"||item[i].Type=="Integer")
			{ 
				char* width=strtok(NULL,",");
				sscanf(width,"%d",&item[i].Width);
			}
			if(item[i].Type=="Float")
			{
				char* width=strtok(NULL,",");
				char* pric=strtok(NULL,",");
				sscanf(width,"%d",&item[i].Width);
				sscanf(pric,"%d",&item[i].Pric);
			}
		}
		if(temp==1)
			pHeadTblStruct=pCurTblStruct;
	    else
			pPrevTblStruct->pTblNext=pCurTblStruct;
		pPrevTblStruct=pCurTblStruct;
	    temp=0;
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
	}
}

void CCNSDFTCtrl::ReadVctGraphy()
{
	///读几何图形数据
	char buffer[200];
	fgetNoEmpty(buffer,sizeof(buffer),pfile);
	if(strnicmp("PointBegin",buffer,10)!=0)
	{
        fclose(pfile);
		AfxMessageBox("文件没有点数据信息");
		return;
	}
	ReadVctPoint(pfile);
	
	 fgetNoEmpty(buffer,sizeof(buffer),pfile);
	 if(strnicmp("LineBegin",buffer,9)!=0)
	 {
		 fclose(pfile);
		 AfxMessageBox("文件没有线数据信息");
		 return;			
	 }
	ReadVctLine(pfile);
	
	fgetNoEmpty(buffer,sizeof(buffer),pfile);
   if(strnicmp("PolygonBegin",buffer,12)!=0)
   {
	   fclose(pfile);
	   AfxMessageBox("文件没有多边形信息");
	   return;	
   }
	ReadVctPolygon(pfile);
}

void CCNSDFTCtrl::ReadVctPoint(FILE *pfile)
{
	/////////////读点数据
	pHeadPointData=NULL;
	char buffer[200];
    PointData *pCurPointData,*pPrevPointData;
	int tmflag=1;
	fgetNoEmpty(buffer,sizeof(buffer),pfile);
	while(strnicmp("PointEnd",buffer,8)!=0)
	{
		pCurPointData=new PointData[sizeof(PointData)];
		pCurPointData->AimCode=buffer;
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
        pCurPointData->FeatureCode=buffer;
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
		pCurPointData->LayerName=buffer;
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
		sscanf(buffer,"%d",&pCurPointData->PointMark);
        fgetNoEmpty(buffer,sizeof(buffer),pfile);
        strtok(buffer,",");
		char* temp=strtok(NULL,","); 
		sscanf(buffer,"%f",&pCurPointData->X);
        sscanf(temp,"%f",&pCurPointData->Y);
		 //////////////////////////坐标Z未加
		if(m_filehead.Topo==2&&pCurPointData->PointMark==2)
		{
			 //////////待扩充的模块
		}
		 //pPrevPointData=pCurPointData;
         pCurPointData->pNext=NULL;
		 if(tmflag==1)
			pHeadPointData=pCurPointData;
		 else
			pPrevPointData->pNext=pCurPointData;
         pPrevPointData=pCurPointData;
		 tmflag=0;
		 fgetNoEmpty(buffer,sizeof(buffer),pfile);
	}
}

void CCNSDFTCtrl::ReadVctLine(FILE *pfile)
{
	////////读线数据
	pHeadLineData=NULL;
	char buffer[200];
	 fgetNoEmpty(buffer,sizeof(buffer),pfile);
	 LineData *pCurLineData,*pPrevLineData;
	 int tpflag=1;
     while(strnicmp("LineEnd",buffer,7)!=0)
	 {
       pCurLineData=new LineData[sizeof(LineData)];
	   pCurLineData->AimCode=buffer;
	   fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   pCurLineData->FeatureCode=buffer;
	   fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   pCurLineData->LayerName=buffer;
       fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   sscanf(buffer,"%d",&pCurLineData->LineMark);
	   ///////读直接坐标
	   if(pCurLineData->LineMark!=100)
       {
	      fgetNoEmpty(buffer,sizeof(buffer),pfile);
          sscanf(buffer,"%d",&pCurLineData->PointNum);
	      Point *LnPnt;
	      LnPnt=new Point[pCurLineData->PointNum];
		  pCurLineData->pMemberPoint=LnPnt;
	      for(int i=0;i<pCurLineData->PointNum;i++)
		  {
             fgetNoEmpty(buffer,sizeof(buffer),pfile);
             strtok(buffer,",");
		     char* tmp=strtok(NULL,",");
		     sscanf(buffer,"%f",&LnPnt[i].X);
             sscanf(tmp,"%f",&LnPnt[i].Y);
			 /////坐标Z未加
		  }
	   }
	   else
	   {
		   //读间接坐标
  		  fgetNoEmpty(buffer,sizeof(buffer),pfile);
		  sscanf(buffer,"%d",&pCurLineData->ChildNum);
		  int* LnChild;
		  LnChild=new int[pCurLineData->ChildNum];
		  pCurLineData->pMemberChild=LnChild;
	      int cout=GetShang(pCurLineData->ChildNum,8);
		  for(int i=0;i<cout+1;i++)
		  {
			  if(i!=cout)
			  {
				fgetNoEmpty(buffer,sizeof(buffer),pfile);
				strtok(buffer,",");
				sscanf(buffer,"%d",&LnChild[i*8]);
				for(int j=1;j<=7;j++)
				{
					char* swap=strtok(NULL,",");
					sscanf(swap,"%d",&LnChild[i*8+j]);
				}
			  }
			  else
			  {
				fgetNoEmpty(buffer,sizeof(buffer),pfile);
				strtok(buffer,",");
				sscanf(buffer,"%d",&LnChild[cout*8]);
				for(int k=1;k<pCurLineData->ChildNum%8;k++)
				{
					char* swap=strtok(NULL,",");
					sscanf(swap,"%d",&LnChild[cout*8+k]);
				}
			  }
		  }
	   }	
		pCurLineData->pNext=NULL;
       if(tpflag==1)
			pHeadLineData=pCurLineData;
	   else
           pPrevLineData->pNext=pCurLineData;
		pPrevLineData=pCurLineData; 
        tpflag=0;
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
	}
}

void CCNSDFTCtrl::ReadVctPolygon(FILE *pfile)
{
	///////读多边形
	pHeadPolygon=NULL;
	char buffer[200];
   fgetNoEmpty(buffer,sizeof(buffer),pfile);
   int flag=1;
   PolygonData *pPrevPolygon,*pCurPolygon;
   while(strnicmp("PolygonEnd",buffer,10)!=0)
   {
	   pCurPolygon=new PolygonData[sizeof(PolygonData)];
       pCurPolygon->AimCode=buffer;
	   fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   pCurPolygon->FeatureCode=buffer;
	   fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   pCurPolygon->LayerName=buffer;
       fgetNoEmpty(buffer,sizeof(buffer),pfile);
	   strtok(buffer,",");
	   char* tmp=strtok(NULL,",");
	   sscanf(buffer,"%f",&pCurPolygon->labX);
       sscanf(tmp,"%f",&pCurPolygon->labY);

	   if(m_filehead.Topo==0)
	   {
          fgetNoEmpty(buffer,sizeof(buffer),pfile);
		  sscanf(buffer,"%d",&pCurPolygon->PointNum);//problem
          int TmpSwap=pCurPolygon->PointNum;	
		  while(pCurPolygon->PointNum!=0)
		  {
			 Point *PlyPnt;
			 PlyPnt=new Point[pCurPolygon->PointNum];
			 pCurPolygon->pMemberPoint=PlyPnt;
             for(int i=0;i<pCurPolygon->PointNum;i++)
			 {
				fgetNoEmpty(buffer,sizeof(buffer),pfile);
	            strtok(buffer,",");
	            char* tmp=strtok(NULL,",");
	            sscanf(buffer,"%f",&PlyPnt[i].X);
                sscanf(tmp,"%f",&PlyPnt[i].Y);
				/////坐标Z暂未加
			 }
			 fgetNoEmpty(buffer,sizeof(buffer),pfile);
			 sscanf(buffer,"%d",&pCurPolygon->PointNum);//problem
		  }
        pCurPolygon->PointNum=TmpSwap;
	   }
	   else
	   {
      //////读间接坐标
		fgetNoEmpty(buffer,sizeof(buffer),pfile);
		sscanf(buffer,"%d",&pCurPolygon->ChildNum);
		int* PlyChild;
		PlyChild=new int[pCurPolygon->ChildNum];
		pCurPolygon->pMemberChild=PlyChild;
		int cout=GetShang(pCurPolygon->ChildNum,8);
		for(int i=0;i<cout+1;i++)
		{
			if(i!=cout)
			{
				fgetNoEmpty(buffer,sizeof(buffer),pfile);
				strtok(buffer,",");
				sscanf(buffer,"%d",&PlyChild[i*8]);