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

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

文件操作

开发平台：

C/C++

shpFile.cpp：源码内容
  1. #include "stdafx.h"
  2. #include <d3dtypes.h>
  3. #include "shpFile.h"
  4. #include "MapPoint.h"
  5. #include "MapPoints.h"
  6. #include "MapLine.h"
  7. #include "MapPolygon.h"
  8. #include "MapFields.h"
  11. CShpFile::CShpFile() 
  12. {
  13. int i;
  14. bShpOpen = FALSE;
  15. bShxOpen = FALSE;
  16. m_shpType = NULLSHP;
  18. /* -------------------------------------------------------------------- */
  19.             /* Establish the byte order on this machine. */
  20.     /* -------------------------------------------------------------------- */
  21.     i = 1;
  22.     if( *((uchar *) &i) == 1 )
  23. m_bBigEndian = FALSE;
  24. else
  25. m_bBigEndian = TRUE;
  26. }
  28. CShpFile::~CShpFile()
  29. {
  31.  CMapPoint*    pPt;
  32.  CMapPoints*   pPts;
  33.  CMapLine*     pLine;
  34.  CMapPolygon*  pPolygon;
  36.  while(!m_ObList.IsEmpty())
  37.  {
  38. switch ( m_shpType )
  39.         {  
  40. case POINT:
  41. pPt =(CMapPoint*)m_ObList.RemoveTail();
  42. delete pPt;
  43. break;
  44.             case MULTIPOINT:
  45. pPts =(CMapPoints*)m_ObList.RemoveTail();
  46. delete pPts;
  47. break;
  49. case POLYLINE:
  50.                 pLine =(CMapLine*)m_ObList.RemoveTail();
  51. delete pLine;
  52. break;
  53. case POLYGON:
  54.                 pPolygon =(CMapPolygon*)m_ObList.RemoveTail();
  55. delete pPolygon;
  56. break;
  57.             default:
  58. m_ObList.RemoveTail();
  59. break;
  60.  
  61. }
  62.      }    
  63.  if ( bShpOpen )
  64. fShp.Close();
  65.  if (bShxOpen)
  66. fShx.Close();
  67.  if ( pRecordSet )
  68.  delete pRecordSet;
  69.  
  70. }
  72. /*************************************************
  73.   描述:         读入Shp、shx文件 格式 参阅ESRI技术白皮书
  74.   输入:         文件名(全路径) 
  75.   输出：        成功返回TRUE 失败返回FALSE
  76. *************************************************/
  79. BOOL CShpFile::ReadShp(CString& csFileName)
  80. {
  81. int   iTemp;
  82. CString csShxName;
  83. CFileException fe;
  84.     SHPHEADER varHeader;
  86. //打开主文件
  87. if ( !fShp.Open(csFileName, CFile::modeRead|CFile::shareDenyWrite,&fe))
  88. return FALSE;
  89. bShpOpen = TRUE;
  90.     
  91. //打开索引文件
  92. csShxName = csFileName.Left(csFileName.GetLength() - 3);
  94. csShxName = csShxName + "shx";
  95.     if ( !fShx.Open(csShxName, CFile::modeRead|CFile::shareDenyWrite,&fe))
  96. return FALSE;
  97. bShxOpen = TRUE;
  98.        
  100. TRY
  101.     {
  102.     //读主文件头 长100字节
  103. if ( fShp.Read(&varHeader , sizeof(SHPHEADER))!= sizeof(SHPHEADER))
  104. return FILE_READERR;
  106.         iTemp = varHeader.iFileCode; 
  107. if ( !m_bBigEndian )
  108. SwapWord(sizeof(int),&iTemp);
  109. if ( iTemp != 9994 ) //是否是shp文件
  110. return FILE_CODEERR;
  111.         if ( varHeader.iVersion != FILE_VERSION ) //文件版本是否正确
  112. return FILE_VERSIONERR;
  113.         
  114. //shp 类型  
  115. m_shpType = varHeader.iShpType;  
  116. m_shpFileLength = varHeader.iFileLength;
  117.     if ( !m_bBigEndian )
  118. SwapWord(sizeof(int),&m_shpFileLength);
  120. //保存数据最大矩形范围
  121. m_Extent.SetLeft(varHeader.dbXMin);
  122. m_Extent.SetRight(varHeader.dbXMax);
  123. m_Extent.SetTop(varHeader.dbYMin);
  124. m_Extent.SetBottom(varHeader.dbYMax);
  125.         
  126. //读索引文件头 长100字节
  127. if ( fShx.Read(&varHeader , sizeof(SHPHEADER))!= sizeof(SHPHEADER))
  128. return FILE_READERR;
  129. iTemp = varHeader.iFileCode; 
  130. if ( !m_bBigEndian )
  131. SwapWord(sizeof(int),&iTemp);
  132. if ( iTemp != 9994 ) //是否是shx文件
  133. return FILE_CODEERR;
  134.         if ( varHeader.iVersion != FILE_VERSION ) //文件版本是否正确
  135. return FILE_VERSIONERR;
  136. m_shxFileLength = varHeader.iFileLength; 
  137. if ( !m_bBigEndian )
  138. SwapWord(sizeof(int),&m_shxFileLength);
  139. //通过索引文件计算主文件记录个数 文件长度数值以16位计
  140. m_iRecordCount = ((m_shxFileLength - 50 )*2)/sizeof(SHXRECORD);
  142. if ( !ReadRecord() )
  143. return FILE_READERR;
  144.          if ( !ReadDBF(csFileName))
  145.  return FALSE;
  146. }
  147. CATCH(CFileException ,eload)
  148.     {
  149. fShp.Abort();
  150. return FALSE;
  151.     }
  152. END_CATCH
  155. return TRUE;
  157. }
  158. /*************************************************
  159.   描述:         读入DBF文件格式 
  160.   输入:         文件名(全路径) 
  161.   输出：        成功返回TRUE 失败返回FALSE
  162. *************************************************/
  163. BOOL CShpFile::ReadDBF(CString& csFileName)
  164. {
  165. CString csDbfName;
  166. BOOL bResult;
  167. //创建记录集对象
  168. pRecordSet = new CMapRecordSet;
  169. ASSERT ( pRecordSet != NULL ); 
  170. csDbfName = csFileName.Left(csFileName.GetLength() - 3);
  171. csDbfName = csDbfName + "dbf";
  172. //打开DBF文件
  173. bResult =  pRecordSet->openDBF(csDbfName); 
  174.     if ( !bResult )
  175. delete pRecordSet;
  176. return bResult;
  177. }
  179. /*************************************************
  180.   描述:         获得当前地图文件最大矩形范围 
  181.   输入:         无
  182.   输出：        地图矩形范围   
  183. *************************************************/
  185. CMapRectangle CShpFile::GetExtent()
  186. {
  187. return m_Extent;
  188. }
  190. /*************************************************
  191.   描述:         设置地图文件最大矩形范围 
  192.   输入:         地图矩形范围
  193.   输出：        无   
  194. *************************************************/
  195. void CShpFile::SetExtent(CMapRectangle& extent )
  196. {
  197. m_Extent.SetLeft(extent.GetLeft());  
  198.     m_Extent.SetRight(extent.GetRight());
  199. m_Extent.SetTop(extent.GetTop()); 
  200.     m_Extent.SetBottom(extent.GetBottom());
  201. }
  203. /*************************************************
  204.   描述:         设置Shp对象类型 
  205.   输入:         shp 类型
  206.   输出：        无   
  207. *************************************************/
  208. void CShpFile::SetShpType(int& iShpType)
  209. {
  210. m_shpType = iShpType;
  211. }
  213. /*************************************************
  214.   描述:         读入Shp对象坐标 
  215.   输入:         无
  216.   输出：        成功返回TRUE 失败返回FALSE  
  217. *************************************************/
  219. BOOL CShpFile::ReadRecord()
  220. {
  221. int i,j,k,m;
  222. int iDataLen,iLength,iIndex;
  223. int *pIParts;
  224. double dbTmp;
  225. char *pszBuffer,*lpVer;
  226. BOOL bEof;
  227. SHPINFO shpIn;
  228. SHPRECORDHEADER RecordHeader;
  229.     CMapRectangle objRectangle;
  230.     CMapPoint   *pPoint;
  231. CMapPoints  *pPoints;
  232. CMapParts   *pParts;
  233. CMapLine    *pLine;
  234. CMapPolygon *pPolygon;
  236. bEof = FALSE;
  237. switch ( m_shpType )
  238. {
  239. case NULLSHP:
  240. return FALSE;
  241. break;
  242.         case POINT:
  243. {
  245. SHPPTCONTENT point;
  246. //读入点记录
  247. for ( i = 1 ; i <= m_iRecordCount ; i++ ) 
  248. {
  249. iLength = SetRecordPos(i);
  250. if ( iLength <= 0 )
  251. return FALSE;
  253. //获得记录头信息
  254. if (!GetRecordHeader(RecordHeader))
  255. return FALSE;
  256. //记录内容长度是否与shp实体大小一致,索引记录长度是否与记录内容长度一致
  257. if ( RecordHeader.iContentLength*2 != sizeof(point)||
  258. RecordHeader.iContentLength*2 != iLength)
  259. return FALSE;
  260. if(fShp.Read(&point,sizeof(point))!= sizeof(point))
  261. return FALSE;
  262. pPoint = new CMapPoint;
  263. iIndex = i - 1;
  264.     pPoint->SetIndex(iIndex); 
  265. if ( pPoint == NULL )
  266. return FALSE;
  267. //类型是否匹配
  268. if ( point.iShpType != m_shpType) 
  269. return FALSE;
  270.                     pPoint->SetX(point.dbX );
  271. pPoint->SetY(point.dbY );
  272. m_ObList.AddTail(pPoint);  
  273.     
  274.  } 
  275. } 
  276. break;
  277.         case POLYLINE:
  278.     
  279. pszBuffer = new char [MAX_BUFFER_SIZE]; //分配缓冲区
  280. if ( pszBuffer == NULL )
  281. return FALSE;
  282. memset(pszBuffer , 0 , MAX_BUFFER_SIZE);
  283.             
  284. //读入线记录
  285. for ( i = 1 ; i <= m_iRecordCount ; i++ ) //m_iRecordCount
  286. {
  288. iLength = SetRecordPos(i);
  289. if ( iLength <= 0 )
  290. return FALSE;
  292. pLine = new CMapLine();
  293. iIndex = i - 1;
  294. pLine->SetIndex(iIndex); 
  295. if ( pLine == NULL )
  296. return FALSE;
  297. //获得记录头信息
  298. if (!GetRecordHeader(RecordHeader))
  299. return FALSE;
  300. if ( !GetShpInfo(shpIn))
  301. return FALSE;
  302.  if (shpIn.ishpType != POLYLINE )//类型不匹配
  303.                  {  
  304.                       delete pLine;
  305.   continue;
  306.  }
  307.  if ( shpIn.iNumParts*sizeof(int) > MAX_BUFFER_SIZE )
  308.                  {
  309.  //多义线段数大于最大缓冲区长度,忽略该对象
  310.  delete pLine;
  311.  continue;
  312.                  } 
  313.  //计算对象内容实际长度
  314.  j = sizeof(SHPINFO) + shpIn.iNumParts*sizeof(int) ;
  315.  j += shpIn.iNumPoints*sizeof(SHPPOINT);  
  316.                  
  317.  //判断实际长度是否与索引文件中记录的一致 
  318.  if ( RecordHeader.iContentLength*2 != j )
  319.                  {
  320.      delete pLine;
  321.  continue;
  322.  }  
  323.  //设置shp矩形范围
  324.  objRectangle.SetLeft(shpIn.Box[0].dbX);
  325.  objRectangle.SetTop(shpIn.Box[0].dbY);
  326.  objRectangle.SetRight(shpIn.Box[1].dbX);
  327.  objRectangle.SetBottom(shpIn.Box[1].dbY);
  328.  pLine->SetExtent(objRectangle);
  329.  pIParts = new int[shpIn.iNumParts];
  330.  if ( pIParts == NULL )
  331.                  {
  332. delete pLine;
  333. return FALSE;
  334.  }
  335.  //读入多义线段索引
  336.  if ( fShp.Read(pIParts,shpIn.iNumParts*4) != (uint)(shpIn.iNumParts*4))
  337.  {
  338. delete pLine;
  339. return FALSE;
  340.  }
  342.  //点坐标存储所占字节数
  343.  iLength = shpIn.iNumPoints*sizeof(SHPPOINT);
  344.  //初始化缓冲区数据
  345.  iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  346.  if ( iDataLen < 0 )
  347.                  {
  348.   delete pLine;
  349.   delete pIParts;
  350.   return FALSE;
  351.  
  352.  }  
  353.  lpVer = pszBuffer;
  354.  for ( j = 0 ;  j < shpIn.iNumParts ; j++ )
  355.  {
  356. pParts  = new CMapParts();
  357. pPoints = new CMapPoints();
  358.   if ( pParts == NULL || pPoints == NULL)
  359. return FALSE;
  360. if ( j == shpIn.iNumParts - 1 )
  361.                     {
  362.     k = pIParts[j];        //本段第一个顶点索引
  363.     m = shpIn.iNumPoints ; //下一个段第一个顶点索引 
  364.                     }
  365.                    else
  366.                     {
  367. k = pIParts[j];
  368. m = pIParts[j+1];
  369. }
  370. //处理第i段的顶点
  371.     for ( ; k < m ; k++)
  372.                     {   
  373. pPoint = new CMapPoint();
  374. if ( pPoint == NULL )
  375. return FALSE;
  377. //需要读入数据更新缓冲区
  378. if ( lpVer == pszBuffer + iDataLen && !bEof)
  379. {
  380. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  381. if ( iDataLen < 0 )
  382. {
  383. delete pPoint;
  384. delete pPoints;
  385. delete pLine;
  386. delete pIParts;
  388. return FALSE;
  389.  
  390. }  
  391. lpVer = pszBuffer;
  392. }
  393. dbTmp = *(double*)lpVer;
  394.     pPoint->SetX(dbTmp);
  395.                         lpVer += 8;
  396. //需要读入数据更新缓冲区
  397. if ( lpVer == pszBuffer + iDataLen && !bEof)
  398. {
  399. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  400. if ( iDataLen < 0 )
  401. {
  402. delete pPoint;
  403. delete pPoints;
  404. delete pLine;
  405. delete pIParts;
  406. return FALSE;
  407.  
  408. }  
  409. lpVer = pszBuffer;
  410. }
  411. dbTmp = *(double*)(lpVer);
  412. lpVer += 8;
  413.                         pPoint->SetY(dbTmp); 
  414. pPoints->Add(pPoint); 
  416. }  
  417.                     pParts->Add(pPoints);   
  418.     pLine->Add(pParts); 
  420.  }
  421.  m_ObList.AddTail( pLine);
  422.  delete []pIParts;
  424.             }
  425. delete []pszBuffer;
  427. break;
  428.         case POLYGON:
  429. pszBuffer = new char [MAX_BUFFER_SIZE]; //分配缓冲区
  430. if ( pszBuffer == NULL )
  431. return FALSE;
  432. memset(pszBuffer , 0 , MAX_BUFFER_SIZE);
  433.             
  434. //读入多边形记录
  435. for ( i = 1 ; i <= m_iRecordCount ; i++ ) //m_iRecordCount
  436. {
  437. iLength = SetRecordPos(i);
  438. if ( iLength <= 0 )
  439. return FALSE;
  441. pPolygon = new CMapPolygon();
  442. iIndex = i - 1;
  443.                 pPolygon->SetIndex(iIndex);
  444. if (pPolygon == NULL )
  445. return FALSE;
  446. //获得记录头信息
  447. if (!GetRecordHeader(RecordHeader))
  448. return FALSE;
  449. if ( !GetShpInfo(shpIn))
  450. return FALSE;
  451.  if (shpIn.ishpType != POLYGON )//类型不匹配
  452.                  {  
  453.                       delete pPolygon;
  454.   continue;
  455.  }
  456.  if ( shpIn.iNumParts*sizeof(int) > MAX_BUFFER_SIZE )
  457.                  {
  458.  //复合多边型中的多边形个数大于最大缓冲区长度,忽略该对象
  459.  delete pPolygon;
  460.  continue;
  461.                  } 
  462.  //计算对象内容实际长度
  463.  j = sizeof(SHPINFO) + shpIn.iNumParts*sizeof(int) ;
  464.  j += shpIn.iNumPoints*sizeof(SHPPOINT);  
  465.                  
  466.  //判断实际长度是否与索引文件中记录的一致 
  467.  if ( RecordHeader.iContentLength*2 != j )
  468.                  {
  469.      delete pPolygon;
  470.  continue;
  471.  }  
  472.  //设置shp矩形范围
  473.  objRectangle.SetLeft(shpIn.Box[0].dbX);
  474.  objRectangle.SetTop(shpIn.Box[0].dbY);
  475.  objRectangle.SetRight(shpIn.Box[1].dbX);
  476.  objRectangle.SetBottom(shpIn.Box[1].dbY); 
  477.  pPolygon->SetExtent(objRectangle);
  478.  pIParts = new int[shpIn.iNumParts];
  479.  if ( pIParts == NULL )
  480.                  {
  481. delete pPolygon;
  482. return FALSE;
  483.  }
  484.  //读入复合多边型段索引
  485.  if ( fShp.Read(pIParts,shpIn.iNumParts*4) != (uint)(shpIn.iNumParts*4))
  486.  {
  487. delete pPolygon;
  488. return FALSE;
  489.  }
  491.  //点坐标存储所占字节数
  492.  iLength = shpIn.iNumPoints*sizeof(SHPPOINT);
  493.  //初始化缓冲区数据
  494.  iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  495.  if ( iDataLen < 0 )
  496.                  {
  497.   delete pPolygon;
  498.   delete pIParts;
  499.   return FALSE;
  500.  
  501.  }  
  502.  lpVer = pszBuffer;
  503.  for ( j = 0 ;  j < shpIn.iNumParts ; j++ )
  504.  {
  505. pParts  = new CMapParts();
  506. pPoints = new CMapPoints();
  507.   if ( pParts == NULL || pPoints == NULL)
  508. return FALSE;
  509. if ( j == shpIn.iNumParts - 1 )
  510.                     {
  511.     k = pIParts[j];        //本段第一个顶点索引
  512.     m = shpIn.iNumPoints ; //下一个段第一个顶点索引 
  513.                     }
  514.                    else
  515.                     {
  516. k = pIParts[j];
  517. m = pIParts[j+1];
  518. }
  519. //处理第i段的顶点
  520.     for ( ; k < m ; k++)
  521.                     {   
  522. pPoint = new CMapPoint();
  523. if ( pPoint == NULL )
  524. return FALSE;
  526. //需要读入数据更新缓冲区
  527. if ( lpVer == pszBuffer + iDataLen && !bEof)
  528. {
  529. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  530. if ( iDataLen < 0 )
  531. {
  532. delete pPolygon;
  533. delete pIParts;
  534. return FALSE;
  535.  
  536. }  
  537. lpVer = pszBuffer;
  538. }
  539. dbTmp = *(double*)lpVer;
  540.     pPoint->SetX(dbTmp);
  541.                         lpVer += 8;
  542. //需要读入数据更新缓冲区
  543. if ( lpVer == pszBuffer + iDataLen && !bEof)
  544. {
  545. iDataLen = ReadPoint(pszBuffer,iLength,bEof);
  546. if ( iDataLen < 0 )
  547. {
  548. delete pPolygon;
  549. delete pIParts;
  550. return FALSE;
  551.  
  552. }  
  553. lpVer = pszBuffer;
  554. }
  555. dbTmp = *(double*)(lpVer);
  556.                         pPoint->SetY(dbTmp); 
  557. pPoints->Add(pPoint); 
  558. lpVer += 8;
  560. }  
  561.                     pParts->Add(pPoints);   
  562.     pPolygon->Add(pParts); 
  564.  }
  565.  m_ObList.AddTail( pPolygon);
  566.      delete []pIParts;
  567.             }
  568. delete []pszBuffer;
  569. break;
  570. default:
  571. return FALSE;
  572. break;
  574.     }    
  575. return TRUE;   
  577. }
  579. /*************************************************
  580.   描述:         计算每条shp对象相对文件头的偏移量
  581.   输入:         记录索引值(从零开始)
  582.   输出：        该shp对象数据在文件中的位置  
  583. *************************************************/
  584. int CShpFile::SetRecordPos( int iRecord )
  585. {
  586.     unsigned int iOffset,iTmp;
  587. SHXRECORD shxRD;
  589. if ( iRecord < 0 )
  590. return 0;
  591.     //获得索引文件记录偏移量相对文件头
  592. if (iRecord == 1 )
  593.      iOffset = sizeof(SHPHEADER)  ;  
  594. else
  595. iOffset = sizeof(SHPHEADER) + (iRecord-1)*sizeof(shxRecord) ;
  596. if ( iOffset > m_shxFileLength*2 - sizeof(shxRecord) )
  597. return 0;
  598. fShx.Seek( iOffset , CFile::begin );
  599. int m = sizeof(shxRD);
  600. fShx.Read( &shxRD , sizeof(shxRD));
  601. iTmp = shxRD.iOffset;
  602. SwapWord(sizeof(int),&iTmp);
  603. fShp.Seek(iTmp*2 ,  CFile::begin );
  604. iTmp = shxRD.iContentLength;
  605. SwapWord(sizeof(int),&iTmp);
  606.    
  608. return iTmp*2;
  609. }
  611. /*************************************************
  612.   描述:         获得每条shp对象记录记录头的信息
  613.   输入:         记录头结构对象
  614.   输出：        成功返回TRUE 失败返回FALSE    
  615. *************************************************/
  617. BOOL CShpFile::GetRecordHeader(SHPRECORDHEADER& RecordHeader )
  618. {
  619. int iLength,iNum;
  621. if(fShp.Read(&RecordHeader,sizeof(RecordHeader))!= sizeof(RecordHeader))
  622. return FALSE;
  623. if ( !m_bBigEndian )
  624.     {  
  625. iNum    = RecordHeader.iRecordNum;
  626.         iLength = RecordHeader.iContentLength;
  627. SwapWord(sizeof(int),&iLength);
  628. SwapWord(sizeof(int),&iNum);
  629. RecordHeader.iRecordNum = iNum;
  630.         RecordHeader.iContentLength = iLength;
  631. }
  632.     return TRUE;
  635. }
  636. /*************************************************
  637.   描述:         获得每条shp对象描述信息
  638.   输入:         描述信息结构对象
  639.   输出：        成功返回TRUE 失败返回FALSE    
  640. *************************************************/
  642. BOOL CShpFile::GetShpInfo(SHPINFO& varInfo)
  643. {
  645. if(fShp.Read(&varInfo,sizeof(varInfo))!= sizeof(varInfo))
  646. return FALSE;
  647. return TRUE;
  648. }
  650. /*************************************************
  651.   描述:         读入点对象数据
  652.   输入:         数据缓冲区指针 缓冲区最大32K 
  653.                 如果超出需要分多次读取，要读取的长度、
  654. 是否已读取完成
  655.   输出：        读取数据的实际长度   
  656. *************************************************/
  658. int  CShpFile::ReadPoint(char* pszBuffer,int& iLength,BOOL& bEof)
  659. {
  660. if ( iLength > MAX_BUFFER_SIZE)
  661.     {
  662. iLength -= MAX_BUFFER_SIZE;
  663. if ( fShp.Read(pszBuffer,MAX_BUFFER_SIZE) != MAX_BUFFER_SIZE )
  664. return FILE_READERR;
  665. bEof = FALSE;
  666. return MAX_BUFFER_SIZE;
  667.     }
  668.     else
  669.     {   
  670. if ( fShp.Read(pszBuffer,iLength) != (uint)iLength )
  671. return FILE_READERR;
  672. bEof = TRUE;
  673. return iLength;
  674. }     
  675. }
  678. /*************************************************
  679.   描述:         根据点对象查找shp对象是否选中
  680.   输入:         点对象
  681.   输出：        查找到shp对象的索引值 返回值-表示未查找到   
  682. *************************************************/
  683. int CShpFile::SearchShape(CMapPoint& pt )
  684. {
  685. unsigned long iCount;
  686. POSITION pos;
  687.     CMapPolygon *pPolygon;
  689. if ( GetShpType() != POLYGON ) //只判断多边形对象
  690. return -1;
  691. iCount = m_ObList.GetCount()-1;
  693. for ( pos = m_ObList.GetHeadPosition()  ; pos != NULL ;  )
  694.     {
  695. pPolygon = (CMapPolygon*)m_ObList.GetAt(pos);
  696. if ( pPolygon->IsPointIn(pt) )
  697.   return pPolygon->GetIndex(); 
  698. m_ObList.GetNext(pos); 
  699.     } 
  700. return -1;
  702. }
  704. /*************************************************
  705.   描述:         绘制shp对象
  706.   输入:         设备指针、图例对象指针、坐标变换参数结构对象
  707.   输出：        无
  708. *************************************************/
  709. void CShpFile::DrawShp(CDC*pDC ,  CMapRender* m_pRender , DrawParam& draw )
  710.  {           
  711.     
  712.  int iDrawMode;
  714.  //计算当前屏幕的实际坐标范围
  715.  m_CurMapExtent.SetLeft(draw.m_StartX );
  716.  m_CurMapExtent.SetBottom(draw.m_StartY);
  717.  m_CurMapExtent.SetRight(draw.m_StartX + draw.m_ScreenWidth * draw.m_Scale);
  718.  m_CurMapExtent.SetTop(draw.m_StartY - draw.m_ScreenHeigh *draw.m_Scale);  
  719.  
  720.  //设置绘制模式
  721.  iDrawMode = pDC->SetROP2(R2_COPYPEN);
  722.  
  723.  switch ( m_shpType )
  724.      {
  725.  case POINT: 
  726. {
  727.                 DrawPoint(pDC , m_pRender ,  draw );
  728. }
  729. break;
  730.          case POLYLINE: 
  731. {
  732.     DrawPLine(pDC , m_pRender ,  draw );
  734. } 
  735.             break;
  736.  case POLYGON: 
  737. {
  738.     DrawPolygon(pDC , m_pRender ,  draw );
  740. }  
  741.     break;     
  742.         default:
  743. break;
  744.  }
  745.  pDC->SetROP2(iDrawMode);
  746.  //int r = RGB_GETRED(16773020);
  747.  //int g = RGB_GETGREEN(16773020);
  748.  //int b = RGB_GETBLUE(16773020);
  750.     
  751.  
  752.  }
  754. /*************************************************
  755.   描述:         对选中的shp对象闪烁
  756.   输入:         设备指针、坐标变换参数结构对象、
  757.                 shp对象的索引值
  758.   输出：        无
  759. *************************************************/
  761. void  CShpFile::FlashShp(CDC*pDC , DrawParam& draw , int iIndex)
  762. {
  764.  int i,j,k,m,iCount,iDrawMode;
  765.  CMapPoint *pPoint;
  766.  CMapPoints *pPoints;
  767.  CMapParts *pParts;
  768.  //CMapLine  *pPline;
  769.  CMapPolygon *pPolygon;
  770.  CMapRectangle MapExtent;
  771.  CPoint    *pPtArray;  //顶点数组
  772.  int       *pPolygonCount; //每个多边型的顶点数组
  773.  CRect  rc;
  774.  POSITION pos;
  775.  CBrush br1(RGB(0,0,0));
  776.      CBrush br2(RGB(255,255,255));
  777.  CBrush *pOldBrush;
  779.   if ( iIndex < 0 )
  780.   return;
  781.  iDrawMode = pDC->SetROP2(R2_XORPEN);
  782.  switch ( m_shpType )
  783.  {
  784. case POINT: {
  785. }
  786. break;
  787. case POLYLINE: {
  788.    }
  789.         break; 
  790. case POLYGON: {
  791. for ( pos = m_ObList.GetHeadPosition()  ; pos != NULL ;  )
  792. {
  793. pPolygon = (CMapPolygon*)m_ObList.GetAt(pos);
  794.         if (iIndex == (int) pPolygon->GetIndex() )
  795. {
  796. iCount = pPolygon->GetCount(); //多边形个数
  797.                     pPolygonCount = new int[iCount];
  798. if ( pPolygonCount == NULL )
  799. return;
  801. //计算复合多边型每部分的顶点数,和总顶点数
  803. for ( m= 0,i = 0 ; i < pPolygon->GetCount() ; i++ )
  804. {
  805. pParts =  pPolygon->GetParts(i);
  806. k = 0;
  807. for ( j = 0 ; j < pParts->GetCount() ; j++)
  808. {
  809. pPoints = pParts->Get(j); 
  810.                             k += pPoints->GetCount();
  811. } 
  812. pPolygonCount[i] = k;
  813. m += k;
  814. }
  815. pPtArray = new CPoint[m];
  816.                     if ( pPtArray == NULL )
  817.                     { 
  818. delete []pPolygonCount;
  819. return ;
  820. }
  822. for ( m= 0 , i = 0 ; i < pPolygon->GetCount() ; i++ )
  823. {
  824. pParts =  pPolygon->GetParts(i);
  825. for ( j = 0 ; j < pParts->GetCount() ; j++)
  826. {
  827. pPoints = pParts->Get(j); 
  828.                             for ( k = 0 ; k < pPoints->GetCount(); k++ )
  829.                             {
  830. pPoint = pPoints->Get(k); 
  831. pPtArray[m].x = (int)((pPoint->GetX() - draw.m_StartX)/draw.m_Scale);
  832.                                 pPtArray[m++].y =  (long)((draw.m_StartY - pPoint->GetY() )/draw.m_Scale);
  834. }
  835. } 
  837. }
  838. pOldBrush = pDC->SelectObject(&br1); 
  839. if ( pPolygon->GetCount() > 1)
  840.                     { 
  842. pDC->PolyPolygon(pPtArray,pPolygonCount,iCount);
  843.                         i = 0;
  844. while ( i < 150000 )
  845.                         {
  846. i++;
  847. }
  848. pDC->PolyPolygon(pPtArray,pPolygonCount,iCount);
  849. pDC->SelectObject(&br2);
  850. pDC->PolyPolygon(pPtArray,pPolygonCount,iCount);
  851. i = 0;
  852. while ( i < 350000 ) //延时
  853.                         {
  854. i++;
  855. }
  856. pDC->PolyPolygon(pPtArray,pPolygonCount,iCount);
  858. }
  859. else
  860.                     {      
  861.    pDC->Polygon(pPtArray, m);
  862.    i = 0;
  863.    while ( i < 150000 )
  864.                        {
  865. i++;
  866.    }
  867.    pDC->Polygon(pPtArray, m);
  868.    pDC->SelectObject(&br2);
  869.    pDC->Polygon(pPtArray, m);
  870.    i = 0;
  871.    while ( i < 350000 )
  872.                        {
  873. i++;
  874.    }
  875.    pDC->Polygon(pPtArray, m);
  877. }
  878. delete []pPolygonCount;
  879. delete []pPtArray;
  880.                     pDC->SelectObject(pOldBrush); 
  881. break;   
  882.                 }
  883. m_ObList.GetNext(pos); 
  884. } 
  887. }
  888. break;
  889.         default:
  890. break;
  892.  } 
  893.  pDC->SetROP2(iDrawMode); 
  895. }
  897. /*************************************************
  898.   描述:         绘制点对象
  899.   输入:         设备指针、图例对象指针、坐标变换参数结构对象
  900.   输出：        无
  901. *************************************************/
  902. void CShpFile::DrawPoint(CDC*pDC ,  CMapRender* m_pRender , DrawParam& draw )
  903. {
  905. int    iIndex,iField;
  906. CBrush *pOldBrush;
  907. SIMPLERENDER simpleRender;
  908. CBrush brSimple;
  909. CPen   pen;
  910. CBrush br(RGB(255,239,156));
  911. CMapFields *pFields;
  912.     CMapField  *pField;
  913.     CMapPoint *pPoint;
  914. POSITION pos;
  915. CString csValue;
  916. RENDERINFO *rInfo;
  918. if ( m_pRender == NULL )
  919.     {
  920. pOldBrush = pDC->SelectObject(&br);
  921. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  922. {  
  923. pPoint = (CMapPoint*)m_ObList.GetAt(pos);
  924. //判断要绘制的的对象是否在当前屏幕范围内
  925. if ( !m_CurMapExtent.IsPointIn(*pPoint)) 
  926.             {
  928. m_ObList.GetNext(pos);
  929. continue;
  930.             }
  931. DrawPointElement(pDC,pPoint,draw );
  932. m_ObList.GetNext(pos);
  934. }
  935. pDC->SelectObject(pOldBrush);
  937. } else if ( m_pRender->GetRenderType() == SIMPLE_RENDER )
  938. {
  939. m_pRender->GetSimpleRender(simpleRender);
  940. //pen.CreatePen(PS_SOLID,1,simpleRender.OutlineColor);
  941. if ( simpleRender.iIndex == 0 )
  942.         {  
  943.          brSimple.CreateSolidBrush(simpleRender.FillColor);
  944. pOldBrush = pDC->SelectObject(&brSimple);
  945.         }
  946.         else
  947. {
  948.    if (!brSimple.CreateHatchBrush( simpleRender.iIndex,
  949.                                simpleRender.FillColor))
  950.    { 
  951.   pOldBrush = pDC->SelectObject(&br);
  952.    } 
  953.    else
  954.            {
  955.   pOldBrush = pDC->SelectObject(&brSimple);
  956.    }   
  957. } 
  958. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  959. {  
  960. pPoint = (CMapPoint*)m_ObList.GetAt(pos);
  961. if ( !m_CurMapExtent.IsPointIn(*pPoint)) 
  962.             {
  963. m_ObList.GetNext(pos);
  964. continue;
  965.             }
  966. DrawPointElement(pDC,pPoint,draw );
  967. m_ObList.GetNext(pos);
  968. }
  969. pDC->SelectObject(pOldBrush);
  970. pen.DeleteObject();
  971. brSimple.DeleteObject(); 
  973.         
  974.     } 
  975. else if ( m_pRender->GetRenderType() == UNIQUE_RENDER )
  976.     { 
  977. iField = m_pRender->GetFieldIndex();
  978. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  979. {  
  981. pPoint = (CMapPoint*)m_ObList.GetAt(pos);
  982. if ( !m_CurMapExtent.IsPointIn(*pPoint)) 
  983.             {
  984. m_ObList.GetNext(pos);
  985. continue;
  986.             }
  987.             iIndex = pPoint->GetIndex();
  988.             pRecordSet->Move(iIndex,BookmarkFirst);
  989. pFields = pRecordSet->GetFields(0);
  990. if ( iField >= 0 && iField < pFields->GetCout())   
  991. {  
  992. pField = pFields->GetField(iField);
  993. csValue = pField->GetValueAsString();
  994. rInfo = m_pRender->GetByValue(csValue);
  995. ASSERT(rInfo);
  996. CBrush brush(rInfo->clr); 
  997.     pOldBrush = pDC->SelectObject(&brush);
  998.     DrawPointElement(pDC,pPoint,draw );
  999.                 pDC->SelectObject(pOldBrush);
  1000. }
  1001. m_ObList.GetNext(pos);
  1003. }
  1006. }
  1007. }
  1009. /*************************************************
  1010.   描述:         绘制单个的点对象
  1011.   输入:         设备指针、点对象对象指针、
  1012.                 坐标变换参数结构对象
  1013.   输出：        无
  1014. *************************************************/
  1016. void CShpFile::DrawPointElement(CDC*pDC,CMapPoint *pPoint, DrawParam& draw )
  1017. {
  1018. int iX,iY;
  1019. CRect rc;
  1021. if ( pPoint == NULL )
  1022. return;
  1024. iX = (int)((pPoint->GetX()-draw.m_StartX )/draw.m_Scale);
  1025. iY = (int)((draw.m_StartY-pPoint->GetY())/draw.m_Scale);
  1027. rc.left = iX - 4;
  1028. rc.right = iX  + 4;
  1029. rc.top = iY  - 4;
  1030. rc.bottom = iY  + 4;
  1031. pDC->Rectangle(&rc); 
  1033. }
  1035. /*************************************************
  1036.   描述:         绘制线对象
  1037.   输入:         设备指针、图例对象指针、坐标变换参数结构对象
  1038.   输出：        无
  1039. *************************************************/
  1040. void CShpFile::DrawPLine(CDC*pDC ,  CMapRender* m_pRender , DrawParam& draw )
  1041. {
  1042.     int    iIndex,iField; 
  1043. CPen   *pOldPen;
  1044. SIMPLERENDER simpleRender;
  1045. CPen   penSimple;
  1046. CPen   pen(PS_SOLID,1,RGB(255,0,0));
  1047. CBrush br(RGB(255,239,156));
  1048. CMapFields *pFields;
  1049.     CMapField  *pField;
  1050.     CMapLine *pLine;
  1051. POSITION pos;
  1052. CString csValue;
  1053. CMapRectangle shpRC;
  1054. RENDERINFO *rInfo;
  1055. if ( m_pRender == NULL )
  1056.     {
  1057. pOldPen = pDC->SelectObject(&pen);
  1058. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1059. {  
  1060. pLine = (CMapLine*)m_ObList.GetAt(pos);
  1061.             shpRC = pLine->GetExtent();
  1062. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1063. {
  1064. m_ObList.GetNext(pos);
  1065. continue;
  1066. }
  1067. DrawPLineElement(pDC,pLine,draw );
  1068. m_ObList.GetNext(pos);
  1070. }
  1071. pDC->SelectObject(pOldPen);
  1073. } else if ( m_pRender->GetRenderType() == SIMPLE_RENDER )
  1074. {
  1075. m_pRender->GetSimpleRender(simpleRender);
  1076. if ( simpleRender.iIndex == 0 )
  1077.         {  
  1078.          pOldPen = pDC->SelectObject(&pen);
  1079.         }
  1080.         else
  1081. {
  1082.    if (!penSimple.CreatePen(PS_SOLID,1,simpleRender.FillColor))
  1083.    { 
  1084.   pOldPen = pDC->SelectObject(&pen);
  1085.    } 
  1086.    else
  1087.            {
  1088.    pOldPen = pDC->SelectObject(&penSimple);
  1089.    }   
  1090. } 
  1091. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1092. {  
  1093. pLine = (CMapLine*)m_ObList.GetAt(pos);
  1094. shpRC = pLine->GetExtent();
  1095. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1096. {
  1097. m_ObList.GetNext(pos);
  1098. continue;
  1099. }
  1100. DrawPLineElement(pDC,pLine,draw );
  1101. m_ObList.GetNext(pos);
  1102. }
  1103. pDC->SelectObject(pOldPen);
  1105. if ( penSimple.GetSafeHandle() != NULL ) 
  1106.          penSimple.DeleteObject();  
  1108.         
  1109.     } 
  1110. else if (m_pRender->GetRenderType() == UNIQUE_RENDER )
  1111.     { 
  1112. iField = m_pRender->GetFieldIndex();
  1113. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1114. {  
  1116. pLine = (CMapLine*)m_ObList.GetAt(pos); 
  1117. shpRC = pLine->GetExtent();
  1118. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1119. {
  1120. m_ObList.GetNext(pos);
  1121. continue;
  1122. }
  1123.             iIndex = pLine->GetIndex();
  1124.             pRecordSet->Move(iIndex,BookmarkFirst);
  1125. pFields = pRecordSet->GetFields(0);
  1126. if ( iField >= 0 && iField < pFields->GetCout())   
  1127. {  
  1128. pField = pFields->GetField(iField);
  1129. csValue = pField->GetValueAsString();
  1130. rInfo = m_pRender->GetByValue(csValue);
  1131. ASSERT(rInfo);
  1132. CPen penTemp(PS_SOLID,1,rInfo->clr); 
  1133.     pOldPen = pDC->SelectObject(&penTemp);
  1134.     DrawPLineElement(pDC,pLine,draw );
  1135.                 pDC->SelectObject(pOldPen);
  1136. }
  1137. m_ObList.GetNext(pos);
  1139. }
  1142. }
  1145. }
  1146. /*************************************************
  1147.   描述:         绘制单个的线对象
  1148.   输入:         设备指针、线对象对象指针、
  1149.                 坐标变换参数结构对象
  1150.   输出：        无
  1151. *************************************************/
  1153. void CShpFile::DrawPLineElement(CDC*pDC, CMapLine *pPline , DrawParam& draw )
  1154. {
  1156. int i,j,k,iCount;
  1157. CMapPoint *pPoint;
  1158. CMapPoints *pPoints;
  1159. CMapParts *pParts;
  1160. CMapRectangle MapExtent;
  1161. CPoint    *pPtArray;  //顶点数组
  1163. if ( pPline == NULL )
  1164. return;
  1165. for ( i = 0 ; i < pPline->GetCount() ; i++ )
  1166. {
  1167. pParts =  pPline->GetParts(i);
  1168. for ( j = 0 ; j < pParts->GetCount() ; j++)
  1169. {
  1170. pPoints = pParts->Get(j); 
  1171. iCount = pPoints->GetCount();
  1172. pPtArray = new CPoint[iCount];
  1173. if ( pPtArray == NULL )
  1174. return ;
  1175. for ( k = 0 ; k < iCount; k++)
  1176. {
  1177. pPoint = pPoints->Get(k); 
  1178. pPtArray[k].x = (int)((pPoint->GetX()-draw.m_StartX)/draw.m_Scale);
  1179. pPtArray[k].y = (int)((draw.m_StartY - pPoint->GetY())/draw.m_Scale);
  1180.     
  1181. }
  1182. }
  1183. }
  1184. //绘制多义线
  1185. pDC->Polyline(pPtArray,pPoints->GetCount()); 
  1186. delete []pPtArray;
  1189. }
  1191. /*************************************************
  1192.   描述:         绘制面对象
  1193.   输入:         设备指针、图例对象指针、坐标变换参数结构对象
  1194.   输出：        无
  1195. *************************************************/
  1196. void CShpFile::DrawPolygon(CDC*pDC ,  CMapRender* m_pRender , DrawParam& draw )
  1197. {
  1198. int    iIndex,iField; 
  1199. //CPen   *pOldPen;
  1200. CBrush *pOldBrush;
  1201. SIMPLERENDER simpleRender;
  1202. CBrush brSimple;
  1203. CPen   pen;
  1204. CBrush br(RGB(255,239,156));
  1205. CMapFields *pFields;
  1206.     CMapField  *pField;
  1207.     POSITION pos;
  1208. CString csValue;
  1209. RENDERINFO *rInfo;
  1210. CMapPolygon *pPolygon;
  1211. CMapRectangle shpRC;
  1213. if ( m_pRender == NULL )
  1214.     {
  1215. pOldBrush = pDC->SelectObject(&br);
  1216. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1217. {  
  1218. pPolygon = (CMapPolygon*)m_ObList.GetAt(pos);
  1219. shpRC = pPolygon->GetExtent(); 
  1220. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1221. {
  1222. //要绘制的对象外接矩形是不是与屏幕相交
  1223. m_ObList.GetNext(pos);
  1224. continue;
  1225.             }
  1226. DrawPolygonElement(pDC,pPolygon,draw );
  1227. m_ObList.GetNext(pos);
  1229. }
  1230. pDC->SelectObject(pOldBrush);
  1232. } else if ( m_pRender->GetRenderType() == SIMPLE_RENDER )
  1233. {
  1234. m_pRender->GetSimpleRender(simpleRender);
  1235. //pen.CreatePen(PS_SOLID,1,simpleRender.OutlineColor);
  1236. if ( simpleRender.iIndex == 0 )
  1237.         {  
  1238.          brSimple.CreateSolidBrush(simpleRender.FillColor);
  1239. pOldBrush = pDC->SelectObject(&brSimple);
  1240.         }
  1241.         else
  1242. {
  1243.    if (!brSimple.CreateHatchBrush( simpleRender.iIndex,
  1244.                                simpleRender.FillColor))
  1245.    { 
  1246.   pOldBrush = pDC->SelectObject(&br);
  1247.    } 
  1248.    else
  1249.            {
  1250.   pOldBrush = pDC->SelectObject(&brSimple);
  1251.    }   
  1252. } 
  1253. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1254. {  
  1255. pPolygon = (CMapPolygon*)m_ObList.GetAt(pos);
  1256. shpRC = pPolygon->GetExtent();
  1257. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1258. {
  1259. //要绘制的对象外接矩形是不是与屏幕相交
  1260. m_ObList.GetNext(pos);
  1261. continue;
  1262.             }
  1263. DrawPolygonElement(pDC,pPolygon,draw );
  1264. m_ObList.GetNext(pos);
  1265. }
  1266. pDC->SelectObject(pOldBrush);
  1267. if ( brSimple.GetSafeHandle() != NULL )
  1268. brSimple.DeleteObject(); 
  1270.         
  1271.     } 
  1272. else if ( m_pRender->GetRenderType() == UNIQUE_RENDER )
  1273.     { 
  1274. iField = m_pRender->GetFieldIndex();
  1275. for( pos = m_ObList.GetHeadPosition(); pos != NULL; )
  1276. {  
  1278. pPolygon = (CMapPolygon*)m_ObList.GetAt(pos);
  1279.             shpRC = pPolygon->GetExtent(); 
  1280. if ( !m_CurMapExtent.IsInsercet(shpRC))
  1281. {
  1282. //要绘制的对象外接矩形是不是与屏幕相交
  1283. m_ObList.GetNext(pos);
  1284. continue;
  1285.             }
  1286.         iIndex = pPolygon ->GetIndex();
  1287.             pRecordSet->Move(iIndex,BookmarkFirst);
  1288. pFields = pRecordSet->GetFields(0);
  1289. if ( iField >= 0 && iField < pFields->GetCout())   
  1290. {  
  1291. pField = pFields->GetField(iField);
  1292. csValue = pField->GetValueAsString();
  1293. rInfo = m_pRender->GetByValue(csValue);
  1294. ASSERT(rInfo != NULL);
  1295. CBrush brush(rInfo->clr); 
  1296.     pOldBrush = pDC->SelectObject(&brush);
  1297.     DrawPolygonElement(pDC,pPolygon,draw );
  1298.                 pDC->SelectObject(pOldBrush);
  1299. }
  1300. m_ObList.GetNext(pos);
  1302. }
  1305. }
  1306. }
  1308. /*************************************************
  1309.   描述:         绘制单个的面对象
  1310.   输入:         设备指针、面对象对象指针、
  1311.                 坐标变换参数结构对象
  1312.   输出：        无
  1313. *************************************************/
  1315. void CShpFile::DrawPolygonElement(CDC*pDC , CMapPolygon* pPolygon , DrawParam& draw )
  1316. {
  1317. int i,j,k,m,iCount;
  1318. CMapPoint *pPoint;
  1319. CMapPoints *pPoints;
  1320. CMapParts *pParts;
  1321. CPoint    *pPtArray;  //顶点数组
  1322. int       *pPolygonCount; //每个多边型的顶点数组
  1324. if ( pPolygon == NULL )
  1325. return;
  1326. iCount = pPolygon->GetCount(); //多边形个数
  1327.     pPolygonCount = new int[iCount];
  1328.     
  1329. if ( pPolygonCount == NULL )
  1330. return;
  1332. //计算复合多边型每部分的顶点数,和总顶点数
  1333. for ( m= 0,i = 0 ; i < pPolygon->GetCount() ; i++ )
  1334. {
  1335. pParts =  pPolygon->GetParts(i);
  1336. k = 0;
  1337. for ( j = 0 ; j < pParts->GetCount() ; j++)
  1338. {
  1339. pPoints = pParts->Get(j); 
  1340.             k += pPoints->GetCount();
  1341. } 
  1342. pPolygonCount[i] = k;
  1343. m += k;
  1344. }
  1346. pPtArray = new CPoint[m];
  1347.     if ( pPtArray == NULL )
  1348.     { 
  1349. delete []pPolygonCount;
  1350. return ;
  1351. }
  1353. for ( m= 0 , i = 0 ; i < pPolygon->GetCount() ; i++ )
  1354. {
  1355. pParts =  pPolygon->GetParts(i);
  1356. for ( j = 0 ; j < pParts->GetCount() ; j++)
  1357. {
  1358. pPoints = pParts->Get(j); 
  1359.             for ( k = 0 ; k < pPoints->GetCount(); k++ )
  1360.             {
  1361. pPoint = pPoints->Get(k); 
  1362. pPtArray[m].x = (int)((pPoint->GetX() - draw.m_StartX)/draw.m_Scale);
  1363.                 pPtArray[m++].y =  (long)((draw.m_StartY - pPoint->GetY() )/draw.m_Scale);
  1365. }
  1366. } 
  1368. }
  1369. if ( pPolygon->GetCount() > 1)
  1370. pDC->PolyPolygon(pPtArray,pPolygonCount,iCount); //绘制复合多边形
  1371. else
  1372. pDC->Polygon(pPtArray, m); 
  1373. delete []pPolygonCount;
  1374. delete []pPtArray;  
  1376. }