开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 文件操作 > 查看源码
Transfer.cpp
资源名称：SHP_to_VCT.rar　[点击查看]
上传用户：bjslfz
上传日期：2022-07-25
资源大小：4430k
文件大小：42k
源码类别：

文件操作

开发平台：

C/C++

Transfer.cpp：源码内容
  1. // Transfer.cpp: implementation of the CTransfer class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "SHP2VCT.h"
  7. #include "Transfer.h"
  8. #include "ShpFile.h"
  9. #include "MapRecordSet.h"
  10. #include "MapField.h"
  11. #include "MapFields.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[]=__FILE__;
  17. #define new DEBUG_NEW
  18. #endif
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  24. CTransfer::CTransfer(CString source,CString target)
  25. {
  26. if(source.Right(4)==".shp" && target.Right(4)==".vct")
  27. {
  28. int i;
  29. m_bShpOpen = FALSE;
  30. m_bShxOpen = FALSE;
  31. m_shpType = NULLSHP;
  33. /* -------------------------------------------------------------------- */
  34. /* Establish the byte order on this machine.                 */
  35. /* -------------------------------------------------------------------- */
  36. i = 1;
  37. if( *((uchar *) &i) == 1 )
  38. m_bBigEndian = FALSE;
  39. else
  40. m_bBigEndian = TRUE;
  42. if(!SHP2VCT(source,target))
  43. AfxMessageBox("数据转换失败",MB_OK,MB_ICONINFORMATION);
  44. else 
  45. AfxMessageBox("数据转换完成",MB_OK,MB_ICONINFORMATION);
  46. }
  47. AfxMessageBox("源文件："+ source +"n目标文件：" + target,MB_OK,MB_ICONINFORMATION);
  49. }
  50. /*************************************************
  51.   描述:         读入DBF文件格式 
  52.   输入:         文件名(全路径) 
  53.   输出：        成功返回TRUE 失败返回FALSE
  54. *************************************************/
  55. CTransfer::~CTransfer()
  56. {
  57. CMapPoint*    pPt;
  58. CMapPoints*   pPts;
  59. CMapLine*     pLine;
  60. CMapPolygon*  pPolygon;
  62. while(!m_ObList.IsEmpty())
  63. {
  64. switch ( m_shpType )
  65.         {  
  66. case POINT:
  67. pPt =(CMapPoint*)m_ObList.RemoveTail();
  68. delete pPt;
  69. break;
  70. case MULTIPOINT:
  71. pPts =(CMapPoints*)m_ObList.RemoveTail();
  72. delete pPts;
  73. break;
  75. case POLYLINE:
  76. pLine =(CMapLine*)m_ObList.RemoveTail();
  77. delete pLine;
  78. break;
  79. case POLYGON:
  80. pPolygon =(CMapPolygon*)m_ObList.RemoveTail();
  81. delete pPolygon;
  82. break;
  83. default:
  84. m_ObList.RemoveTail();
  85. break;
  87. }
  88. }    
  89. if ( m_bShpOpen )
  90. m_fShp.Close();
  91. if (m_bShxOpen)
  92. m_fShx.Close();
  93. m_pRecordSet->fDbf.Close();
  94. if ( m_pRecordSet )
  95. delete m_pRecordSet;
  96. if ( m_bVctOpen)
  97. fclose(m_pVctFile);
  99. }
  101. /*************************************************
  102.   描述:         读入DBF文件格式 
  103.   输入:         文件名(全路径) 
  104.   输出：        成功返回TRUE 失败返回FALSE
  105. *************************************************/
  106. BOOL CTransfer::ReadDBF(CString& csFileName)
  107. {
  108. CString csDbfName;
  109. BOOL bResult;
  110. //创建记录集对象
  111. m_pRecordSet = new CMapRecordSet;
  112. ASSERT ( m_pRecordSet != NULL ); 
  113. csDbfName = csFileName.Left(csFileName.GetLength() - 3);
  114. csDbfName = csDbfName + "dbf";
  115. //打开DBF文件
  116. bResult =  m_pRecordSet->openDBF(csDbfName); 
  117.     if ( !bResult )
  118. delete m_pRecordSet;
  119. return bResult;
  120. }
  121. /*************************************************
  122.   描述:         打开要操作的文件，读文件头及记录 
  123.   输入:         源文件名，目标文件名
  124.   输出：        成功返回TRUE 失败返回FALSE  
  125. *************************************************/
  126. BOOL CTransfer::SHP2VCT(CString& sourceFileName,CString& targetFileName)
  127. {
  129. int   iTemp;
  130. CString csShxName;
  131. CFileException fe;
  132.     SHPHEADER varHeader;
  134. //打开主文件
  135. if ( !m_fShp.Open(sourceFileName, CFile::modeRead|CFile::shareDenyWrite,&fe))
  136. return FALSE;
  137. m_bShpOpen = TRUE;
  138.     
  139. //打开索引文件
  140. csShxName = sourceFileName.Left(sourceFileName.GetLength() - 3);
  141. csShxName = csShxName + "shx";
  142. //AfxMessageBox(csShxName);
  143.     if ( !m_fShx.Open(csShxName, CFile::modeRead|CFile::shareDenyWrite,&fe))
  144. return FALSE;
  145. m_bShxOpen = TRUE;
  146. /////////////////////////////////////////////////////////////////////////
  147. TRY
  148.     {
  149. //读主文件头 长100字节
  150. if ( m_fShp.Read(&varHeader , sizeof(SHPHEADER))!= sizeof(SHPHEADER))
  151. return FILE_READERR;
  152.         iTemp = varHeader.iFileCode;
  153. if ( !m_bBigEndian )
  154. SwapWord(sizeof(int),&iTemp);
  155. if ( iTemp != 9994 ) //是否是shp文件
  156. return FILE_CODEERR;
  157.         if ( varHeader.iVersion != FILE_VERSION ) //文件版本是否正确
  158. return FILE_VERSIONERR;        
  159. //shp 类型  
  160. m_shpType = varHeader.iShpType;  
  161. m_shpFileLength = varHeader.iFileLength;
  162. if ( !m_bBigEndian )
  163. SwapWord(sizeof(int),&m_shpFileLength);
  164. //保存数据最大矩形范围
  165. m_Extent.SetLeft(varHeader.dbXMin);
  166. m_Extent.SetRight(varHeader.dbXMax);
  167. m_Extent.SetTop(varHeader.dbYMin);
  168. m_Extent.SetBottom(varHeader.dbYMax);
  170. //读索引文件头 长100字节
  171. if ( m_fShx.Read(&varHeader , sizeof(SHPHEADER))!= sizeof(SHPHEADER))
  172. return FILE_READERR;
  173. iTemp = varHeader.iFileCode; 
  174. if ( !m_bBigEndian )
  175. SwapWord(sizeof(int),&iTemp);
  176. if ( iTemp != 9994 ) //是否是shx文件
  177. return FILE_CODEERR;
  178.         if ( varHeader.iVersion != FILE_VERSION ) //文件版本是否正确
  179. return FILE_VERSIONERR;
  180. m_shxFileLength = varHeader.iFileLength; 
  181. if ( !m_bBigEndian )
  182. SwapWord(sizeof(int),&m_shxFileLength);
  183. //通过索引文件计算主文件记录个数 文件长度数值以16位计
  184. m_iRecordCount = ((m_shxFileLength - 50 )*2)/sizeof(SHXRECORD);
  185. if ( !ReadRecord() )
  186. return FILE_READERR;
  187. if ( !ReadDBF(sourceFileName))
  188. return FALSE;
  189. }
  190. CATCH(CFileException ,eload)
  191.     {
  192. m_fShp.Abort();
  193. return FALSE;
  194.     }
  195. END_CATCH
  197. if(!WriteVctData(targetFileName))
  198. {
  199. AfxMessageBox("无法转换!");
  200. }
  202. return TRUE;
  204. }
  205. /*************************************************
  206.   描述:         读入Shp对象坐标 
  207.   输入:         无
  208.   输出：        成功返回TRUE 失败返回FALSE  
  209. *************************************************/
  210. BOOL CTransfer::ReadRecord()
  211. {
  212. int i,j,k,m;
  213. int iDataLen,iLength,iIndex;
  214. int *pIParts;
  215. double dbTmp;
  216. char *pszBuffer,*lpVer;
  217. BOOL bEof;
  218. SHPINFO shpIn;
  219. SHPRECORDHEADER RecordHeader;
  220.     CMapRectangle objRectangle;
  221.     CMapPoint   *pPoint;
  222. CMapPoints  *pPoints;
  223. CMapParts   *pParts;
  224. CMapLine    *pLine;
  225. CMapPolygon *pPolygon;
  228. bEof = FALSE;
  229. switch ( m_shpType )
  230. {
  231. case NULLSHP:
  232. return FALSE;
  233. break;
  234. case POINT:
  235. {
  237. SHPPTCONTENT point;
  238. //读入点记录
  239. for ( i = 1 ; i <= m_iRecordCount ; i++ ) 
  240. {
  241. iLength = SetRecordPos(i);
  242. if ( iLength <= 0 )
  243. return FALSE;
  245. //获得记录头信息
  246. if (!GetRecordHeader(RecordHeader))
  247. return FALSE;
  248. //记录内容长度是否与shp实体大小一致,索引记录长度是否与记录内容长度一致
  249. if ( RecordHeader.iContentLength*2 != sizeof(point)||
  250. RecordHeader.iContentLength*2 != iLength)
  251. return FALSE;
  252. if(m_fShp.Read(&point,sizeof(point))!= sizeof(point))
  253. return FALSE;
  254. pPoint = new CMapPoint;
  255. iIndex = i - 1;
  256. pPoint->SetIndex(iIndex); 
  257. if ( pPoint == NULL )
  258. return FALSE;
  259. //类型是否匹配
  260. if ( point.iShpType != m_shpType) 
  261. return FALSE;
  262. pPoint->SetX(point.dbX );
  263. pPoint->SetY(point.dbY );
  264. m_ObList.AddTail(pPoint);  
  266. } 
  267. } 
  268. break;
  269. case POLYLINE:
  271. pszBuffer = new char [MAX_BUFFER_SIZE]; //分配缓冲区
  272. if ( pszBuffer == NULL )
  273. return FALSE;
  274. memset(pszBuffer , 0 , MAX_BUFFER_SIZE);
  276. //读入线记录
  277. for ( i = 1 ; i <= m_iRecordCount ; i++ ) //m_iRecordCount
  278. {
  280. iLength = SetRecordPos(i);
  281. if ( iLength <= 0 )
  282. return FALSE;
  284. pLine = new CMapLine();
  285. iIndex = i - 1;
  286. pLine->SetIndex(iIndex); 
  287. if ( pLine == NULL )
  288. return FALSE;
  289. //获得记录头信息
  290. if (!GetRecordHeader(RecordHeader))
  291. return FALSE;
  292. if ( !GetShpInfo(shpIn))
  293. return FALSE;
  294. if (shpIn.ishpType != POLYLINE )//类型不匹配
  295. {  
  296. delete pLine;
  297. continue;
  298. }
  299. if ( shpIn.iNumParts*sizeof(int) > MAX_BUFFER_SIZE )
  300. {
  301. //多义线段数大于最大缓冲区长度,忽略该对象
  302. delete pLine;
  303. continue;
  304. } 
  305. //计算对象内容实际长度
  306. j = sizeof(SHPINFO) + shpIn.iNumParts*sizeof(int) ;
  307. j += shpIn.iNumPoints*sizeof(SHPPOINT);  
  309. //判断实际长度是否与索引文件中记录的一致 
  310. if ( RecordHeader.iContentLength*2 != j )
  311. {
  312. delete pLine;
  313. continue;
  314. }  
  315. //设置shp矩形范围
  316. objRectangle.SetLeft(shpIn.Box[0].dbX);
  317. objRectangle.SetTop(shpIn.Box[0].dbY);
  318. objRectangle.SetRight(shpIn.Box[1].dbX);
  319. objRectangle.SetBottom(shpIn.Box[1].dbY);
  320. pLine->SetExtent(objRectangle);
  321. pIParts = new int[shpIn.iNumParts];
  322. if ( pIParts == NULL )
  323. {
  324. delete pLine;
  325. return FALSE;
  326. }
  327. //读入多义线段索引
  328. if ( m_fShp.Read(pIParts,shpIn.iNumParts*4) != (uint)(shpIn.iNumParts*4))
  329. {
  330. delete pLine;
  331. return FALSE;
  332. }
  334. //点坐标存储所占字节数
  335. iLength = shpIn.iNumPoints*sizeof(SHPPOINT);
  336. //初始化缓冲区数据
  337. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  338. if ( iDataLen < 0 )
  339. {
  340. delete pLine;
  341. delete pIParts;
  342. return FALSE;
  344. }  
  345. lpVer = pszBuffer;
  346. for ( j = 0 ;  j < shpIn.iNumParts ; j++ )
  347. {
  348. pParts  = new CMapParts();
  349. pPoints = new CMapPoints();
  350. if ( pParts == NULL || pPoints == NULL)
  351. return FALSE;
  352. if ( j == shpIn.iNumParts - 1 )
  353. {
  354. k = pIParts[j];        //本段第一个顶点索引
  355. m = shpIn.iNumPoints ; //下一个段第一个顶点索引 
  356. }
  357. else
  358. {
  359. k = pIParts[j];
  360. m = pIParts[j+1];
  361. }
  362. //处理第i段的顶点
  363. for ( ; k < m ; k++)
  364. {   
  365. pPoint = new CMapPoint();
  366. if ( pPoint == NULL )
  367. return FALSE;
  369. //需要读入数据更新缓冲区
  370. if ( lpVer == pszBuffer + iDataLen && !bEof)
  371. {
  372. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  373. if ( iDataLen < 0 )
  374. {
  375. delete pPoint;
  376. delete pPoints;
  377. delete pLine;
  378. delete pIParts;
  380. return FALSE;
  382. }  
  383. lpVer = pszBuffer;
  384. }
  385. dbTmp = *(double*)lpVer;
  386. pPoint->SetX(dbTmp);
  387. lpVer += 8;
  388. //需要读入数据更新缓冲区
  389. if ( lpVer == pszBuffer + iDataLen && !bEof)
  390. {
  391. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  392. if ( iDataLen < 0 )
  393. {
  394. delete pPoint;
  395. delete pPoints;
  396. delete pLine;
  397. delete pIParts;
  398. return FALSE;
  400. }  
  401. lpVer = pszBuffer;
  402. }
  403. dbTmp = *(double*)(lpVer);
  404. lpVer += 8;
  405. pPoint->SetY(dbTmp); 
  406. pPoints->Add(pPoint); 
  408. }  
  409. pParts->Add(pPoints);   
  410. pLine->Add(pParts); 
  412. }
  413. m_ObList.AddTail( pLine);
  414. delete []pIParts;
  416.             }
  417. delete []pszBuffer;
  419. break;
  420.         case POLYGON:
  421. pszBuffer = new char [MAX_BUFFER_SIZE]; //分配缓冲区
  422. if ( pszBuffer == NULL )
  423. return FALSE;
  424. memset(pszBuffer , 0 , MAX_BUFFER_SIZE);
  425.             
  426. //读入多边形记录
  427. for ( i = 1 ; i <= m_iRecordCount ; i++ ) //m_iRecordCount
  428. {
  429. iLength = SetRecordPos(i);
  430. if ( iLength <= 0 )
  431. return FALSE;
  433. pPolygon = new CMapPolygon();
  434. iIndex = i - 1;
  435.                 pPolygon->SetIndex(iIndex);
  436. if (pPolygon == NULL )
  437. return FALSE;
  438. //获得记录头信息
  439. if (!GetRecordHeader(RecordHeader))
  440. return FALSE;
  441. if ( !GetShpInfo(shpIn))
  442. return FALSE;
  443. if (shpIn.ishpType != POLYGON )//类型不匹配
  444. {  
  445. delete pPolygon;
  446. continue;
  447. }
  448. if ( shpIn.iNumParts*sizeof(int) > MAX_BUFFER_SIZE )
  449. {
  450. //复合多边型中的多边形个数大于最大缓冲区长度,忽略该对象
  451. delete pPolygon;
  452. continue;
  453. } 
  454. //计算对象内容实际长度
  455. j = sizeof(SHPINFO) + shpIn.iNumParts*sizeof(int) ;
  456. j += shpIn.iNumPoints*sizeof(SHPPOINT);  
  458. //判断实际长度是否与索引文件中记录的一致 
  459. if ( RecordHeader.iContentLength*2 != j )
  460. {
  461. delete pPolygon;
  462. continue;
  463. }  
  464. //设置shp矩形范围
  465. objRectangle.SetLeft(shpIn.Box[0].dbX);
  466. objRectangle.SetTop(shpIn.Box[0].dbY);
  467. objRectangle.SetRight(shpIn.Box[1].dbX);
  468. objRectangle.SetBottom(shpIn.Box[1].dbY); 
  469. pPolygon->SetExtent(objRectangle);
  470. pIParts = new int[shpIn.iNumParts];
  471. if ( pIParts == NULL )
  472. {
  473. delete pPolygon;
  474. return FALSE;
  475. }
  476. //读入复合多边型段索引
  477. if ( m_fShp.Read(pIParts,shpIn.iNumParts*4) != (uint)(shpIn.iNumParts*4))
  478. {
  479. delete pPolygon;
  480. return FALSE;
  481. }
  483. //点坐标存储所占字节数
  484. iLength = shpIn.iNumPoints*sizeof(SHPPOINT);
  485. //初始化缓冲区数据
  486. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  487. if ( iDataLen < 0 )
  488. {
  489. delete pPolygon;
  490. delete pIParts;
  491. return FALSE;
  493. }  
  494. lpVer = pszBuffer;
  495. for ( j = 0 ;  j < shpIn.iNumParts ; j++ )
  496. {
  497. pParts  = new CMapParts();
  498. pPoints = new CMapPoints();
  499. if ( pParts == NULL || pPoints == NULL)
  500. return FALSE;
  501. if ( j == shpIn.iNumParts - 1 )
  502.                     {
  503. k = pIParts[j];        //本段第一个顶点索引
  504. m = shpIn.iNumPoints ; //下一个段第一个顶点索引 
  505.                     }
  506. else
  507.                     {
  508. k = pIParts[j];
  509. m = pIParts[j+1];
  510. }
  511. //处理第i段的顶点
  512. for ( ; k < m ; k++)
  513.                     {   
  514. pPoint = new CMapPoint();
  515. if ( pPoint == NULL )
  516. return FALSE;
  518. //需要读入数据更新缓冲区
  519. if ( lpVer == pszBuffer + iDataLen && !bEof)
  520. {
  521. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  522. if ( iDataLen < 0 )
  523. {
  524. delete pPolygon;
  525. delete pIParts;
  526. return FALSE;
  528. }  
  529. lpVer = pszBuffer;
  530. }
  531. dbTmp = *(double*)lpVer;
  532. pPoint->SetX(dbTmp);
  533.                         lpVer += 8;
  534. //需要读入数据更新缓冲区
  535. if ( lpVer == pszBuffer + iDataLen && !bEof)
  536. {
  537. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  538. if ( iDataLen < 0 )
  539. {
  540. delete pPolygon;
  541. delete pIParts;
  542. return FALSE;
  544. }  
  545. lpVer = pszBuffer;
  546. }
  547. dbTmp = *(double*)(lpVer);
  548.                         pPoint->SetY(dbTmp); 
  549. pPoints->Add(pPoint); 
  550. lpVer += 8;
  552. }  
  553.                     pParts->Add(pPoints);   
  554. pPolygon->Add(pParts); 
  556. }
  557. m_ObList.AddTail( pPolygon);
  558. delete []pIParts;
  559.             }
  560. delete []pszBuffer;
  561. break;
  562. default:
  563. return FALSE;
  564. break;
  566.     }    
  567. return TRUE;   
  569. }
  570. /*************************************************
  571.   描述:         计算每条shp对象相对文件头的偏移量
  572.   输入:         记录索引值(从零开始)
  573.   输出：        该shp对象数据在文件中的位置  
  574. *************************************************/
  575. int CTransfer::SetRecordPos( int iRecord )
  576. {
  577.     unsigned int iOffset,iTmp;
  578. SHXRECORD shxRD;
  580. if ( iRecord < 0 )
  581. return 0;
  582.     //获得索引文件记录偏移量相对文件头
  583. if (iRecord == 1 )
  584. iOffset = sizeof(SHPHEADER)  ;  
  585. else
  586. iOffset = sizeof(SHPHEADER) + (iRecord-1)*sizeof(shxRecord) ;
  587. if ( iOffset > m_shxFileLength*2 - sizeof(shxRecord) )
  588. return 0;
  589. m_fShx.Seek( iOffset , CFile::begin );
  590. int m = sizeof(shxRD);
  591. m_fShx.Read( &shxRD , sizeof(shxRD));
  592. iTmp = shxRD.iOffset;
  593. SwapWord(sizeof(int),&iTmp);
  594. m_fShp.Seek(iTmp*2 ,  CFile::begin );
  595. iTmp = shxRD.iContentLength;
  596. SwapWord(sizeof(int),&iTmp);
  599. return iTmp*2;
  600. }
  601. /*************************************************
  602.   描述:         获得每条shp对象记录记录头的信息
  603.   输入:         记录头结构对象
  604.   输出：        成功返回TRUE 失败返回FALSE    
  605. *************************************************/
  606. BOOL CTransfer::GetRecordHeader(SHPRECORDHEADER& RecordHeader )
  607. {
  608. int iLength,iNum;
  610. if(m_fShp.Read(&RecordHeader,sizeof(RecordHeader))!= sizeof(RecordHeader))
  611. return FALSE;
  612. if ( !m_bBigEndian )
  613.     {  
  614. iNum    = RecordHeader.iRecordNum;
  615.         iLength = RecordHeader.iContentLength;
  616. SwapWord(sizeof(int),&iLength);
  617. SwapWord(sizeof(int),&iNum);
  618. RecordHeader.iRecordNum = iNum;
  619.         RecordHeader.iContentLength = iLength;
  620. }
  621.     return TRUE;
  623. }
  624. /*************************************************
  625.   描述:         获得每条shp对象描述信息
  626.   输入:         描述信息结构对象
  627.   输出：        成功返回TRUE 失败返回FALSE    
  628. *************************************************/
  629. BOOL CTransfer::GetShpInfo(SHPINFO& varInfo)
  630. {
  632. if(m_fShp.Read(&varInfo,sizeof(varInfo))!= sizeof(varInfo))
  633. return FALSE;
  634. return TRUE;
  635. }
  636. /*************************************************
  637.   描述:         读入点对象数据
  638.   输入:         数据缓冲区指针 缓冲区最大32K 
  639.                 如果超出需要分多次读取，要读取的长度、
  640. 是否已读取完成
  641.   输出：        读取数据的实际长度   
  642. *************************************************/
  643. int  CTransfer::ReadPoint(char* pszBuffer,int& iLength,BOOL& bEof)
  644. {
  645. if ( iLength > MAX_BUFFER_SIZE)
  646.     {
  647. iLength -= MAX_BUFFER_SIZE;
  648. if ( m_fShp.Read(pszBuffer,MAX_BUFFER_SIZE) != MAX_BUFFER_SIZE )
  649. return FILE_READERR;
  650. bEof = FALSE;
  651. return MAX_BUFFER_SIZE;
  652.     }
  653.     else
  654.     {   
  655. if ( m_fShp.Read(pszBuffer,iLength) != (uint)iLength )
  656. return FILE_READERR;
  657. bEof = TRUE;
  658. return iLength;
  659. }     
  660. }
  661. /*************************************************
  662.   描述:         向目标文件写文件头数据
  663.   输入:         目标VCT文件名
  664.   输出：        无
  665. *************************************************/
  666. void CTransfer::WriteVctFileHead(FILE* pfile)
  667. {
  668. fprintf(pfile,"%s%sn","DataMark: ",m_VctFilehead.DataMark);
  669. fprintf(pfile,"%s%2.1fn","VerSion: ",m_VctFilehead.VerSion); 
  670. fprintf(pfile,"%s%cn","Unit: ",m_VctFilehead.Unit);
  671. fprintf(pfile,"%s%dn","Dim: ",m_VctFilehead.Dim);
  672. fprintf(pfile,"%s%dn","Topo: ",m_VctFilehead.Topo);
  674. if(m_VctFilehead.MinX!=0)
  675. fprintf(pfile,"%s%9.6fn","MinX: ",m_VctFilehead.MinX);
  676. if(m_VctFilehead.MinY!=0)
  677. fprintf(pfile,"%s%9.6fn","MinY: ",m_VctFilehead.MinY);
  678. if(m_VctFilehead.MinZ!=0)
  679. fprintf(pfile,"%s%9.6fn","MinZ: ",m_VctFilehead.MinZ);
  680. if(m_VctFilehead.MaxX!=0)
  681. fprintf(pfile,"%s%9.6fn","MaxX: ",m_VctFilehead.MaxX);
  682. if(m_VctFilehead.MaxY!=0)
  683. fprintf(pfile,"%s%9.6fn","MaxY: ",m_VctFilehead.MaxY);
  684. if(m_VctFilehead.MaxZ!=0)
  685. fprintf(pfile,"%s%9.6fn","MaxZ: ",m_VctFilehead.MaxZ);
  686. if(m_VctFilehead.ScaleM!=0)
  687. fprintf(pfile,"%s%9.0fn","ScaleM: ",m_VctFilehead.ScaleM);
  688. if(m_VctFilehead.Projection!="NO")
  689. fprintf(pfile,"%s%sn","Projection: ",m_VctFilehead.Projection);
  690. if(m_VctFilehead.Spheroid!="NO")
  691. fprintf(pfile,"%s%sn","Spheroid: ",m_VctFilehead.Spheroid);
  692. if(m_VctFilehead.Parameters!="NO")
  693. fprintf(pfile,"%s%sn","Parameters: ",m_VctFilehead.Parameters);
  694. if(m_VctFilehead.Date!="NO")
  695. fprintf(pfile,"%s%sn","Date: ",m_VctFilehead.Date);
  697. fprintf(pfile,"%s%cn","Separator: ",m_VctFilehead.Separator);
  698. ///暂没有坐标系Coordinate
  699. }
  701. /*************************************************
  702.   描述:         向目标文件写要素类型参数
  703.   输入:         目标VCT文件名
  704.   输出：        无
  705. *************************************************/
  706. void CTransfer::WriteVctFeature(FILE *pfile)
  707. {
  708. if(m_pVctFeature==NULL)
  709. {
  710. AfxMessageBox("被转入的文件没有要素类型参数信息");
  711. return;
  712. }
  713. VCTFeature* pVisitFeature = m_pVctFeature;
  714. while(pVisitFeature!=NULL)
  715. {
  716. fprintf(pfile,"%s,",pVisitFeature->Code);
  717. fprintf(pfile,"%s,",pVisitFeature->Name);
  718. fprintf(pfile,"%s,",pVisitFeature->Shape);
  719. fprintf(pfile,"%d,",pVisitFeature->Color);
  720. fprintf(pfile,"%s",pVisitFeature->ListName);
  721. fputs("n",pfile);
  722. pVisitFeature=pVisitFeature->pNext;
  723. }
  724. }
  725. /*************************************************
  726.   描述:         向目标文件写属性数据结构
  727.   输入:         目标VCT文件名
  728.   输出：        无
  729. *************************************************/
  730. void CTransfer::WriteVctTableStructure(FILE *pfile)
  731. {
  732. if(m_pVctTblStruct==NULL)
  733. {
  734. AfxMessageBox("被转入的文件没有属性数据结构信息");
  735. return;
  736. }
  737. VCTTableStructure *pVisitTblStruct=m_pVctTblStruct;
  738. while(pVisitTblStruct!=NULL)
  739. {
  740. fprintf(pfile,"%s,",pVisitTblStruct->ListName);
  741. fprintf(pfile,"%dn",pVisitTblStruct->ItemNum);
  742. for(int i=0;i<pVisitTblStruct->ItemNum;i++)
  743. {
  744. fprintf(pfile,"%s,",pVisitTblStruct->pItem[i].Name);
  745. fprintf(pfile,"%s,",pVisitTblStruct->pItem[i].Type);
  746. if(pVisitTblStruct->pItem[i].Type=="Char"||pVisitTblStruct->pItem[i].Type=="Integer")
  747. fprintf(pfile,"%dn",pVisitTblStruct->pItem[i].Width);
  748. if(pVisitTblStruct->pItem[i].Type=="Float")
  749. {
  750. fprintf(pfile,"%d,",pVisitTblStruct->pItem[i].Width);
  751. fprintf(pfile,"%dn",pVisitTblStruct->pItem[i].Pric);
  752. }
  753. }
  754. pVisitTblStruct=pVisitTblStruct->pTblNext;
  755. }
  756. }
  757. /*************************************************
  758.   描述:         向目标文件写图形数据
  759.   输入:         目标VCT文件名
  760.   输出：        无
  761. *************************************************/
  762. void CTransfer::WriteVctGraphy(FILE *pfile)
  763. {
  764. fputs("PointBeginn",pfile);
  765. WriteVctPoint(pfile);
  766. fputs("PointEndn",pfile);
  767. fputs("n",pfile);
  769. fputs("LineBeginn",pfile);
  770. WriteVctLine(pfile);
  771. fputs("LineEndn",pfile); 
  772. fputs("n",pfile);
  774. fputs("PolygonBeginn",pfile);
  775. WriteVctPolygon(pfile);
  776. fputs("PolygonEndn",pfile);
  777. fputs("n",pfile);
  778. }
  779. /*************************************************
  780.   描述:         向目标文件写图形数据点数据
  781.   输入:         目标VCT文件名
  782.   输出：        无
  783. *************************************************/
  784. void CTransfer::WriteVctPoint(FILE *pfile)
  785. {
  786. if(m_pVctPointData==NULL)
  787. {
  788. //AfxMessageBox("被转入的文件没有点数据信息");
  789. return;
  790. }
  791. VCTPointData *pVisitPoint=m_pVctPointData;
  792. while(pVisitPoint!=NULL)
  793. {
  794. fprintf(pfile,"%sn",pVisitPoint->AimCode);
  795. fprintf(pfile,"%sn",pVisitPoint->FeatureCode);
  796. fprintf(pfile,"%sn",pVisitPoint->LayerName);
  797. fprintf(pfile,"%dn",pVisitPoint->PointMark);
  798. fprintf(pfile,"%f,",pVisitPoint->X);
  799. fprintf(pfile,"%fn",pVisitPoint->Y);
  800. //////////////////////////坐标Z未加
  801. if(m_VctFilehead.Topo==2 && pVisitPoint->PointMark==2)
  802. {
  803. //////////待扩充的模块
  804. }
  805. fputs("n",pfile);
  806. pVisitPoint=pVisitPoint->pNext;
  807. }
  808. }
  809. /*************************************************
  810.   描述:         向目标文件写图形数据线数据
  811.   输入:         目标VCT文件名
  812.   输出：        无
  813. *************************************************/
  814. void CTransfer::WriteVctLine(FILE *pfile)
  815. {
  816. /////写线数据
  817. if(m_pVctLineData==NULL)
  818. {
  819. //AfxMessageBox("被转入的文件没有线数据信息");
  820. return;
  821. }
  822. VCTLineData *pVisitLine=m_pVctLineData;
  823. while(pVisitLine!=NULL)
  824. {
  825. fprintf(pfile,"%sn",pVisitLine->AimCode);
  826. fprintf(pfile,"%sn",pVisitLine->FeatureCode);
  827. fprintf(pfile,"%sn",pVisitLine->LayerName);
  828. fprintf(pfile,"%dn",pVisitLine->LineMark);
  829. if(pVisitLine->LineMark!=100)
  830. {
  831. fprintf(pfile,"%dn",pVisitLine->PointNum);
  832. for(int i=0;i<pVisitLine->PointNum;i++)
  833. {  
  834. fprintf(pfile,"%f,",pVisitLine->pMemberPoint->X);
  835. fprintf(pfile,"%fn",pVisitLine->pMemberPoint->Y);
  836. ///坐标Z暂未加
  837. pVisitLine->pMemberPoint = pVisitLine->pMemberPoint->pNext;
  838. }
  839. }
  840. else
  841. {
  842. ///////写间接坐标
  843. fprintf(pfile,"%dn",pVisitLine->ChildNum);
  844. int cout=GetShang(pVisitLine->ChildNum,8);
  845. for(int i=0;i<cout+1;i++)
  846. {
  847. if(i!=cout)
  848. {
  849. for(int j=0;j<8;j++)
  850. {
  851. if(j==7)
  852. fprintf(pfile,"%d",pVisitLine->pMemberChild[i*8+j]);
  853. else
  854. fprintf(pfile,"%d,",pVisitLine->pMemberChild[i*8+j]);
  855. }
  856. }
  857. else
  858. {
  859. for(int j=0;j<pVisitLine->ChildNum%8;j++)
  860. {
  861. if(j==(pVisitLine->ChildNum%8)-1)
  862. fprintf(pfile,"%d",pVisitLine->pMemberChild[cout*8+j]);
  863. else
  864. fprintf(pfile,"%d,",pVisitLine->pMemberChild[cout*8+j]);
  865. }
  866. }
  867. fputs("n",pfile);
  868. }
  869. }
  870. fputs("n",pfile);
  871. pVisitLine=pVisitLine->pNext;
  872. }
  873. }
  874. /*************************************************
  875.   描述:         向目标文件写图形数据面数据
  876.   输入:         目标VCT文件名
  877.   输出：        无
  878.   modify by xiejing 2008-6-5
  879. *************************************************/
  880. void CTransfer::WriteVctPolygon(FILE *pfile)
  881. {
  882.    /////////写多边形
  883. if(m_pVctPolygon==NULL)
  884. {
  885. //AfxMessageBox("被转入的文件没有多边形数据信息");
  886. return;
  887. }
  888. VCTPolygonData* pVisitPolygon=m_pVctPolygon;
  890. while(pVisitPolygon!=NULL)
  891. {
  892. fprintf(pfile,"%sn",pVisitPolygon->AimCode);
  893. fprintf(pfile,"%sn",pVisitPolygon->FeatureCode);
  894. fprintf(pfile,"%sn",pVisitPolygon->LayerName);
  895. fprintf(pfile,"%f,",pVisitPolygon->labX);   
  896. fprintf(pfile,"%fn",pVisitPolygon->labY);
  897. if(m_VctFilehead.Topo==0)
  898. { ///////写直接坐标
  899. fprintf(pfile,"%dn",pVisitPolygon->PointNum);
  900. while(pVisitPolygon->pMemberPoint != NULL)
  901. {
  902. fprintf(pfile,"%f,",pVisitPolygon->pMemberPoint->X);
  903. fprintf(pfile,"%fn",pVisitPolygon->pMemberPoint->Y);
  904. pVisitPolygon->pMemberPoint = pVisitPolygon->pMemberPoint->pNext;
  905. }
  906. fprintf(pfile,"%dn",0);
  907. }
  908. else
  909. {
  910. /////////写间接坐标
  911. fprintf(pfile,"%dn",pVisitPolygon->ChildNum);
  912. int cout=GetShang(pVisitPolygon->ChildNum,8);
  913. for(int i=0;i<cout+1;i++)
  914. {
  915. if(i!=cout)
  916. {
  917. for(int j=0;j<8;j++)
  918. {
  919. if(j==7)
  920. fprintf(pfile,"%d",pVisitPolygon->pMemberChild[i*8+j]);
  921. else
  922. fprintf(pfile,"%d,",pVisitPolygon->pMemberChild[i*8+j]);
  923. }
  924. }
  925. else
  926. {
  927. for(int j=0;j<(pVisitPolygon->ChildNum%8);j++)
  928. {
  929. if(j==(pVisitPolygon->ChildNum%8)-1)
  930. fprintf(pfile,"%d",pVisitPolygon->pMemberChild[cout*8+j]);
  931. else
  932. fprintf(pfile,"%d,",pVisitPolygon->pMemberChild[cout*8+j]);
  933. }
  934. }
  935. fputs("n",pfile);
  936. }
  937. }
  938. fputs("n",pfile);
  939. pVisitPolygon=pVisitPolygon->pNext;
  940. }
  941. }
  942. /*************************************************
  943.   描述:         向目标文件写注记
  944.   输入:         目标VCT文件名
  945.   输出：        无
  946. *************************************************/
  947. void CTransfer::WriteVctAnnotation(FILE *pfile)
  948. {
  949. /////////////写注记
  950. if(m_pVctAnnotation==NULL)
  951. {
  952. //AfxMessageBox("被转入的文件没有注记信息");
  953. return;
  954. }
  955. VCTAnnotation *pVisitAnnotation=m_pVctAnnotation;
  956. while(pVisitAnnotation!=NULL)
  957. {
  958. fprintf(pfile,"%sn",pVisitAnnotation->AimCode);
  959. fprintf(pfile,"%sn",pVisitAnnotation->FeatureCode);
  960. fprintf(pfile,"%sn",pVisitAnnotation->LayerName);
  961. fprintf(pfile,"%sn",pVisitAnnotation->Font);
  962. fprintf(pfile,"%dn",pVisitAnnotation->Color);
  963. fprintf(pfile,"%d,",pVisitAnnotation->Pound);
  964. fprintf(pfile,"%d,",pVisitAnnotation->Shape);
  965. fprintf(pfile,"%cn",pVisitAnnotation->Udline);
  966. if(pVisitAnnotation->Size>0&&pVisitAnnotation->Size<100)
  967. fprintf(pfile,"%f,",pVisitAnnotation->Size);
  968. else
  969. fprintf(pfile,"%f,",pVisitAnnotation->Width);
  970. fprintf(pfile,"%fn",pVisitAnnotation->High);
  971.         fprintf(pfile,"%fn",pVisitAnnotation->Intevel);
  972. fprintf(pfile,"%sn",pVisitAnnotation->Content);
  973. fprintf(pfile,"%dn",pVisitAnnotation->AntnNum);
  974. for(int i=0;i<pVisitAnnotation->AntnNum;i++)
  975. {
  976. fprintf(pfile,"%f,",pVisitAnnotation->pMemberPoint[i].X);
  977. fprintf(pfile,"%fn",pVisitAnnotation->pMemberPoint[i].Y);
  978. //fprintf(pfile,"%dn",pVisitAnnotation->Z);
  979. }
  980. fputs("n",pfile);
  981. pVisitAnnotation=pVisitAnnotation->pNext;
  982. }
  983. }
  984. /*************************************************
  985.   描述:         向目标文件写属性数据
  986.   输入:         目标VCT文件名
  987.   输出：        无
  988. *************************************************/
  990. void CTransfer::WriteVctAttribute(FILE *pfile)
  991. {
  992. ///////写属性数据   
  993.     if(m_pVctAttribute==NULL)
  994. {
  995. AfxMessageBox("被转入的文件没有属性信息");
  996. return;
  997. }
  998. VCTAttribute *pVisitAbute=m_pVctAttribute;
  999. while( pVisitAbute != NULL)
  1000. {
  1001. fprintf(pfile,"%s,t",pVisitAbute->ListName);
  1003. for(int i=1;i<pVisitAbute->ItemNum+1;i++)
  1004. {
  1006. if(i==pVisitAbute->ItemNum)
  1007. {
  1009. fprintf(pfile,"%sn",pVisitAbute->pRecordList->Record);
  1010. }
  1011. else
  1012. {
  1013. fprintf(pfile,"%s,t",pVisitAbute->pRecordList->Record);
  1014. pVisitAbute->pRecordList = pVisitAbute->pRecordList->pNext;
  1015. }
  1016. }
  1018. pVisitAbute=pVisitAbute->pNext;
  1019. }
  1020. fputs("TableEndn",pfile);
  1021. }
  1023. int CTransfer::GetShang(int dividend, int divisor)// 求商
  1024. {
  1025. int temp,result;
  1026. temp=dividend%divisor;
  1027. result=(dividend-temp)/divisor;
  1028. return result;
  1029. }
  1030. /*************************************************
  1031.   描述:         初始化VCT格式数据
  1032.   输入:         源shp文件名
  1033.   输出：        成功返回TRUE 失败返回FALSE
  1034. *************************************************/
  1035. BOOL CTransfer::InitVctData(CString& csTargetFileName)
  1036. {
  1038. //创建并打开目标vct文件
  1039. m_pVctFile = fopen(csTargetFileName,"w");
  1040. m_bVctOpen = TRUE;
  1041. if(m_pVctFile==NULL)
  1042. {
  1043. AfxMessageBox("写入文件失败");
  1044. return FALSE;
  1045. }
  1047. m_pVctFeature = NULL;
  1048. m_pVctTblStruct = NULL;
  1049. m_pVctPointData = NULL;
  1050. m_pVctLineData = NULL;
  1051. m_pVctPolygon = NULL;
  1052. m_pVctAnnotation = NULL;
  1053. m_pVctAttribute = NULL;
  1055. //Vct文件头初始化
  1056. m_VctFilehead.DataMark = "CNSDTF-VCT";
  1057. m_VctFilehead.VerSion = (float) 1.0;
  1058. m_VctFilehead.Unit = 'D';
  1059. m_VctFilehead.Dim = 2;
  1060. m_VctFilehead.Topo = 0;
  1061. m_VctFilehead.MaxX = (float)0.0;
  1062. m_VctFilehead.MaxY = (float)0.0;
  1063. m_VctFilehead.MinX = (float)0.0;
  1064. m_VctFilehead.MinY = (float)0.0;
  1065. m_VctFilehead.MinZ = (float)0.0;
  1066. m_VctFilehead.MaxZ = (float)0.0;
  1067. m_VctFilehead.ScaleM = (float)10000.0;
  1068. m_VctFilehead.Projection = "";
  1069. m_VctFilehead.Spheroid = "";
  1070. m_VctFilehead.Parameters = "";
  1071. m_VctFilehead.Date = "NO";
  1072. m_VctFilehead.Separator = ',';
  1075. //取文件名
  1076. CString tempName= csSourseFileName; //保存源文件的文件名
  1077. tempName = tempName.Mid(tempName.ReverseFind('\')+1);
  1078. m_strFileName = tempName.Left(tempName.ReverseFind('.'));
  1080.     //Vct要素类型初始化
  1081. m_pVctFeature = new VCTFeature();
  1082. m_pVctFeature->Code = m_pVctFeature->ListName 
  1083. = m_pVctFeature->Name 
  1084. = m_pVctFeature->Shape 
  1085. = m_strFileName;
  1086. m_pVctFeature->Color = 0;
  1087. m_pVctFeature->pNext = NULL;
  1089. //Vct属性数据结构初始化
  1090. m_pVctTblStruct = new VCTTableStructure();
  1091. m_pVctTblStruct->ItemNum = 0;
  1092. m_pVctTblStruct->ListName = m_strFileName;
  1093. m_pVctTblStruct->pItem = NULL;
  1094. m_pVctTblStruct->pTblNext = NULL;
  1096. //Vct几何图形数据初始化
  1097. m_pVctLineData = NULL;
  1098. m_pVctPolygon = NULL;
  1099. m_pVctPointData = NULL;
  1101. //Vct注记初始化(未定义)
  1102. m_pVctAnnotation = NULL;
  1104. //属性数据初始化
  1105. m_pVctAttribute = NULL;
  1107. //SHP格式数据到VCT格式数据的转换
  1108. DataTransfer();
  1109. return TRUE;
  1110. }
  1111. /*************************************************
  1112.   描述:         向目标vct文件写入数据
  1113.   输入:         源shp文件名
  1114.   输出：        成功返回TRUE 失败返回FALSE
  1115. *************************************************/
  1116. BOOL CTransfer::WriteVctData(CString& csFileName) 
  1117. {
  1118. if (!InitVctData(csFileName))
  1119. {
  1120. return FALSE;
  1121. }
  1122. fputs("HeadBeginn",m_pVctFile);
  1123. WriteVctFileHead(m_pVctFile);
  1124. fputs("HeadEndn",m_pVctFile);
  1125. fputs("n",m_pVctFile);
  1127. fputs("FeatureCodeBeginn",m_pVctFile); 
  1128. WriteVctFeature(m_pVctFile);
  1129. fputs("FeatureCodeEndn",m_pVctFile);
  1130. fputs("n",m_pVctFile);
  1132. fputs("TableStructureBeginn",m_pVctFile);
  1133. WriteVctTableStructure(m_pVctFile);
  1134. fputs("TableStructureEndn",m_pVctFile);
  1135. fputs("n",m_pVctFile);
  1137. WriteVctGraphy(m_pVctFile);
  1139. fputs("AnnotationBeginn",m_pVctFile);
  1140. WriteVctAnnotation(m_pVctFile);
  1141. fputs("AnnotationEndn",m_pVctFile);
  1142. fputs("n",m_pVctFile);
  1144. fputs("AttributeBeginn",m_pVctFile);
  1145. fputs(m_strFileName + "n",m_pVctFile);
  1146. WriteVctAttribute(m_pVctFile);
  1147. fputs("AttributeEndn",m_pVctFile);
  1148. fclose(m_pVctFile);
  1150. return TRUE;
  1151. }
  1152. /*************************************************
  1153.   描述:         数据转换
  1154.   输入:         无
  1155.   输出：        无
  1156. *************************************************/
  1158. void CTransfer::DataTransfer()
  1159. {
  1160. ///////////文件头数据转换/////////////////////////////////////////////
  1161. //边界
  1162. m_VctFilehead.MaxX = (float) m_Extent.GetRight();
  1163. m_VctFilehead.MinX = (float) m_Extent.GetLeft();
  1164. m_VctFilehead.MaxY = (float) m_Extent.GetBottom();
  1165. m_VctFilehead.MinY = (float) m_Extent.GetTop();
  1166. //时间
  1167. m_VctFilehead.Date.Format("%d%d%d",(int)m_pRecordSet->m_Header.yy,(int)m_pRecordSet->m_Header.mm,(int)m_pRecordSet->m_Header.dd);
  1169. //要素类型参数转换///
  1170. //直接加到初始化里了///////////////////
  1172. //属性数据结构转换//////////////////////////////////////////
  1173. TableStructureTransfer();
  1174. //几何图形数据部分//////////////////////////////////////////
  1175. GraphyDatatransfer();
  1176. //注记转换部分（省略）//////////////////////////////////////
  1178. //属性数据转换//////////////////////////////////////////////
  1179. AttributeTransfer();
  1180. }
  1181. /*************************************************
  1182.   描述:         文件头数据转换
  1183.   部分在DataTransfer()方法中，部分在初始化方法中
  1184.   输入:         无
  1185.   输出：        无
  1186. *************************************************/
  1188. /*************************************************
  1189.   描述:         要素类型参数转换
  1190.               (直接加到初始化里了)
  1191.   输入:         无
  1192.   输出：        无
  1193. *************************************************/
  1195. /*************************************************
  1196.   描述:         属性数据结构转换
  1197.   输入:         无
  1198.   输出：        无
  1199. *************************************************/
  1200. void CTransfer::TableStructureTransfer()
  1201. {
  1203. int iSize = m_pRecordSet->m_TableDesc.m_fieldsDesc.GetSize();
  1204. FIELD_ELEMENT* pFileElement;
  1205. VCTTableStructure* pTableStructure;
  1207. m_pVctTblStruct = pTableStructure = new VCTTableStructure();
  1208. pTableStructure->pTblNext = NULL;
  1209. pTableStructure->ItemNum = iSize;
  1210. pTableStructure->ListName = m_strFileName;
  1211.     pTableStructure->pItem = new VCTItem[iSize];
  1212. for(int i=0;i<iSize;i++)
  1213. {
  1215. pFileElement = m_pRecordSet->m_TableDesc.m_fieldsDesc.GetAt(i);
  1216. pTableStructure->pItem[i].Name.Format("%s",pFileElement->szFieldName);
  1217. pTableStructure->pItem[i].Width = (int)pFileElement->ucFieldLength;
  1218. if(pFileElement->cFieldType == 'N' || pFileElement->cFieldType == 'F' )
  1219. {
  1220. if( pFileElement->ucFieldDecimal == 0 )
  1221. pTableStructure->pItem[i].Type = "Integer";
  1223. else
  1224. {
  1225. pTableStructure->pItem[i].Type = "Float";
  1226. pTableStructure->pItem[i].Pric = (int) pFileElement->ucFieldDecimal;
  1227. }
  1228. }
  1229. else if(pFileElement->cFieldType == 'C')
  1230. {
  1231. pTableStructure->pItem[i].Type = "Char";
  1232. }
  1233. else
  1234. pTableStructure->pItem[i].Type = "Invaild";
  1235. }
  1237. }
  1240. /*************************************************
  1241.   描述:     几何图形数据部分转换
  1242.   输入:            无
  1243.   输出：           无
  1244. *************************************************/
  1245. void CTransfer::GraphyDatatransfer()
  1246. {
  1248. switch ( m_shpType )
  1249. {
  1250. case POINT:
  1251. {
  1252. m_pVctFeature->Shape = "Point";
  1253. CMapPoint* pPoint;
  1254. VCTPointData* pCurPointData;
  1256. POSITION pos = m_ObList.GetHeadPosition();
  1257. int iCount = 1;
  1258. while(pos != NULL)
  1259. {
  1260. if(iCount == 1)
  1261. {
  1262. m_pVctPointData = pCurPointData = new VCTPointData();
  1263. pCurPointData->pNext = NULL;
  1264. }
  1265. else
  1266. {
  1267. pCurPointData->pNext = new VCTPointData();
  1268. pCurPointData = pCurPointData->pNext;
  1269. pCurPointData->pNext = NULL;
  1270. }
  1271. pCurPointData->pNext = NULL;
  1272. pPoint = (CMapPoint*) m_ObList.GetNext(pos);
  1273. pCurPointData->FeatureCode = m_strFileName;
  1274. pCurPointData->LayerName = m_strFileName;
  1275. pCurPointData->X = (float) pPoint->GetX();
  1276. pCurPointData->Y = (float) pPoint->GetY();
  1277. pCurPointData->PointMark = 1;
  1278. pCurPointData->AimCode.Format("%d",iCount);
  1280. iCount ++;
  1281. }
  1282. break;
  1283. }
  1284. case POLYLINE:
  1285. {
  1286. m_pVctFeature->Shape = "Line";
  1287. CMapLine* pMapLine = NULL;
  1288. CMapParts* pMapParts;
  1289. CMapPoints* pPoints;
  1290. CMapPoint* pPoint;
  1291. VCTLineData* pVctLine;
  1292. POSITION pos = m_ObList.GetHeadPosition(); 
  1293. int tempLineCount = 0;
  1294. VCTPoint* pVctHeadPoint;
  1295. while(pos != NULL)
  1296. {
  1297. if(tempLineCount == 0)
  1298. {
  1299. m_pVctLineData = pVctLine = new VCTLineData();
  1300. pVctLine->pNext = NULL;
  1301. }
  1302. else
  1303. {
  1304. pVctLine->pNext = new VCTLineData();
  1305. pVctLine = pVctLine->pNext;
  1306. pVctLine->pNext = NULL;
  1307. }
  1309. pMapLine = (CMapLine*)m_ObList.GetNext(pos);
  1310. int temPointCount = 0;
  1311. for(int i=0;i<pMapLine->m_Line.GetSize();i++)//线
  1312. {
  1313. temPointCount = 0;
  1314. pMapParts = pMapLine->m_Line[i];
  1316. for(int j=0;j<pMapParts->m_Parts.GetSize();j++)//段
  1317. {
  1319. pPoints = pMapParts->m_Parts[j];
  1320. for(int k=0;k<pPoints->m_Points.GetSize();k++)//点
  1321. {
  1322. pPoint = pPoints->m_Points[k];
  1323. if(temPointCount == 0)
  1324. {
  1325. pVctHeadPoint = pVctLine->pMemberPoint = new VCTPoint();
  1326. pVctLine->pMemberPoint->pNext = NULL;
  1327. }
  1328. else
  1329. {
  1330. pVctLine->pMemberPoint->pNext = new VCTPoint();
  1331. pVctLine->pMemberPoint = pVctLine->pMemberPoint->pNext;
  1332. pVctLine->pMemberPoint->pNext = NULL;
  1333. }
  1334. pVctLine->pMemberPoint->X = (float)pPoint->GetX();
  1335. pVctLine->pMemberPoint->Y = (float)pPoint->GetY();
  1336. temPointCount++;
  1337. }
  1338. }
  1339. }
  1340. pVctLine->AimCode.Format("%d",++tempLineCount);
  1341. pVctLine->FeatureCode = m_strFileName;
  1342. pVctLine->LayerName = m_strFileName;
  1343. pVctLine->LineMark = 1;
  1344. pVctLine->PointNum = temPointCount;
  1345. pVctLine->pMemberPoint = pVctHeadPoint;
  1347. }
  1348. break;
  1349. }
  1350. case POLYGON:
  1351. {
  1352. m_pVctFeature->Shape = "Polygon";
  1353. CMapPolygon* pMapPoiygon = NULL;
  1354. CMapParts* pMapParts;
  1355. CMapPoints* pPoints;
  1356. CMapPoint* pPoint;
  1357. VCTPolygonData* pVctPolygon;
  1358. POSITION pos = m_ObList.GetHeadPosition(); 
  1359. int tempPolygonCount = 0;
  1360. VCTPoint* pVctHeadPoint;
  1361. while(pos != NULL)
  1362. {
  1363. if(tempPolygonCount == 0)
  1364. {
  1365. m_pVctPolygon = pVctPolygon = new VCTPolygonData();
  1366. pVctPolygon->pNext = NULL;
  1367. }
  1368. else
  1369. {
  1370. pVctPolygon->pNext = new VCTPolygonData();
  1371. pVctPolygon = pVctPolygon->pNext;
  1372. pVctPolygon->pNext = NULL;
  1373. }
  1374. pMapPoiygon = (CMapPolygon*) m_ObList.GetNext(pos);
  1375. pVctPolygon->AimCode.Format("%d",++tempPolygonCount);
  1376. pVctPolygon->FeatureCode = m_strFileName;
  1377. pVctPolygon->LayerName = m_strFileName;
  1378. // pVctPolygon->labX = (float) pMapPoiygon->m_Extent.GetLeft();  //why ()
  1379. // pVctPolygon->labY = (float) pMapPoiygon->m_Extent.GetTop();
  1380. pVctPolygon->labX = (float) 0.000000;  //why ()
  1381. pVctPolygon->labY = (float) atof("7836836683315036600000000000000000000.000000");
  1383. int iPointCount = 0;
  1384. for(int i=0;i<pMapPoiygon->m_Polygon.GetSize();i++)//线
  1385. {
  1386. pMapParts = pMapPoiygon->m_Polygon[i];
  1387. for(int j=0;j<pMapParts->m_Parts.GetSize();j++)//段
  1388. {
  1390. pPoints = pMapParts->m_Parts[j];
  1391. for(int k=0;k<pPoints->m_Points.GetSize();k++)//点
  1392. {
  1393. pPoint = pPoints->m_Points[k];
  1394. if(iPointCount == 0)
  1395. {
  1396. pVctHeadPoint = pVctPolygon->pMemberPoint = new VCTPoint();
  1397. pVctPolygon->pMemberPoint->pNext = NULL;
  1398. }
  1399. else
  1400. {
  1401. pVctPolygon->pMemberPoint->pNext = new VCTPoint();
  1402. pVctPolygon->pMemberPoint = pVctPolygon->pMemberPoint->pNext;
  1403. pVctPolygon->pMemberPoint->pNext = NULL;
  1404. }
  1406. pVctPolygon->pMemberPoint->X = (float)pPoint->GetX();
  1407. pVctPolygon->pMemberPoint->Y = (float)pPoint->GetY();
  1408. iPointCount++;
  1409. }
  1410. }
  1411. }
  1412. pVctPolygon->PointNum = iPointCount;
  1413. pVctPolygon->pMemberPoint = pVctHeadPoint;
  1414. }
  1416. break;
  1417. }
  1418. default:
  1419. break;
  1420. }
  1421. }
  1424. /*************************************************
  1425.   描述:      注记转换部分（忽略）
  1426.   输入:            无
  1427.   输出：           无
  1428. *************************************************/
  1431. /*************************************************
  1432.   描述:       属性数据转换
  1433.   输入:            无
  1434.   输出：           无
  1435. *************************************************/
  1436. void CTransfer::AttributeTransfer()
  1437. {
  1439. LONG    iRecordOffset;
  1440. char   *pszBuffer;
  1441. char   szBuff[255];
  1442. double dbValue;
  1443. FIELD_ELEMENT *pField;
  1444. CMapField *pMapField;
  1445. VCTAttribute* pAttribute;
  1446. VCTRecordList* pHeadRecordList;
  1447. VARIANT varValue;
  1448. //逐条读取属性记录
  1449. for(unsigned long recs=0;recs<m_pRecordSet->m_Header.no_recs;recs++)
  1450. {
  1451. if( recs < 0 || recs >= m_pRecordSet->m_Header.no_recs)
  1452. {
  1453. AfxMessageBox("无效的索引值!");
  1454. return; //无效的索引值
  1455. }
  1456. iRecordOffset = recs*m_pRecordSet->m_Header.rec_len + m_pRecordSet->m_Header.head_len;
  1457. pszBuffer = new char[ m_pRecordSet->m_Header.rec_len];
  1458.         m_pRecordSet->fDbf.Seek(iRecordOffset , CFile::begin);   
  1459. if ( m_pRecordSet->fDbf.Read(pszBuffer,m_pRecordSet->m_Header.rec_len) 
  1460. != m_pRecordSet->m_Header.rec_len)
  1461. {     
  1462. delete []pszBuffer;
  1463. AfxMessageBox("读取属性记录错误!");
  1464. return ;
  1465. }
  1467. if( recs == 0)
  1468. {
  1469. m_pVctAttribute = pAttribute = new VCTAttribute();
  1470. pAttribute->pNext = NULL;
  1471. }
  1472. else
  1473. {
  1474. pAttribute->pNext = new VCTAttribute();
  1475. pAttribute = pAttribute->pNext;
  1476. pAttribute->pNext = NULL;
  1477. }
  1478. pAttribute->ListName.Format("%d",recs+1);
  1479. pAttribute->ItemNum =  m_pRecordSet->m_TableDesc.GetFieldCount();
  1482. for ( int j = 0 ; j < m_pRecordSet->m_TableDesc.GetFieldCount() ; j++)
  1483. {
  1484. pMapField = new CMapField();
  1485. pField = m_pRecordSet->m_TableDesc.GetDesc(j); 
  1486. pMapField->SetName( pField->szFieldName );
  1487. pMapField->SetType( pField->cFieldType );
  1488. memset(szBuff , 0 , 255);
  1489. //略过该记录是否删除标记字节pszBuffer+1
  1490. strncpy(szBuff, pszBuffer+1+pField->ulOffset , pField->ucFieldLength);
  1491. if ( pField->cFieldType == 'N' || pField->cFieldType == 'F' )
  1492. {
  1493. ::VariantInit(&varValue);
  1494. dbValue = atof(szBuff );
  1495. if ( pField->ucFieldDecimal == 0 )
  1496. {   
  1497. varValue.bVal = VT_I4;   
  1498. varValue.lVal = (int)dbValue;
  1499. pMapField->SetType(fdInteger);
  1500. }
  1501. else
  1502. {
  1503. varValue.bVal = VT_R8;
  1504. varValue.dblVal = dbValue;
  1505. pMapField->SetType(fdDouble);
  1506. }
  1507. pMapField->SetValue(varValue);
  1508. }
  1509. else if ( pField->cFieldType == 'C' )
  1510. {
  1511. pMapField->SetValueAsString(szBuff);
  1512. pMapField->SetType(fdString);
  1513. }
  1514. else
  1515. pMapField->SetType(fdInvaild);
  1516. if( j == 0)
  1517. {
  1518. pHeadRecordList = pAttribute->pRecordList = new VCTRecordList();
  1519. pAttribute->pRecordList->pNext = NULL;
  1520. }
  1521. else
  1522. {
  1523. pAttribute->pRecordList->pNext = new VCTRecordList();
  1524. pAttribute->pRecordList = pAttribute->pRecordList->pNext;
  1525. pAttribute->pRecordList->pNext = NULL;
  1526. }
  1527. pAttribute->pRecordList->Record = pMapField->GetValueAsString();
  1528. delete pMapField;
  1529. pMapField = NULL;
  1531. }
  1532. delete []pszBuffer;
  1533. pszBuffer = NULL;
  1534. pAttribute->pRecordList = pHeadRecordList;
  1535. }
  1536. }