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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
NetLayer.cs
资源名称：MainSystem.rar　[点击查看]
上传用户：xum6868
上传日期：2009-12-02
资源大小：102k
文件大小：37k
源码类别：

GIS编程

开发平台：

C#

NetLayer.cs：源码内容
  1. using System;
  2. using System.Collections;
  4. namespace MainSystem
  5. {
  6. public class NetPoint
  7. {
  8. public double x;
  9. public double y;
  11. public NetPoint()
  12. {
  13. x = 0;
  14. y = 0;
  15. }
  17. public NetPoint( double x, double y )
  18. {
  19. this.x = x;
  20. this.y = y;
  21. }
  22. }
  24. public class NetLine
  25. {
  26. // 属性
  27. public ArrayList m_pCoords = null;
  28. private MapObjects2.MapLayer m_layer = null;
  30. // 构造函数
  31. public NetLine(MapObjects2.MapLayer layer)
  32. {
  33. m_pCoords = new ArrayList();
  34. m_layer = layer;
  35. }
  37. // 计算线的几何长度
  38. public double CalcLength()
  39. {
  40. double dLength = 0.0 ; // 保存计算出的线几何长度的结果
  41. int loop ; // 保存循环计数
  43. // 检查线的有效性
  44. if ( m_pCoords.Count < 2 )
  45. return 0.0 ;
  46. // 计算线的几何长度
  47. double dist = 0.0 ;
  48. for ( loop = 1 ; loop < m_pCoords.Count ; loop ++ )
  49. {
  50. dist = Math.Sqrt ( ( ((NetPoint)m_pCoords[loop -1]).x - ((NetPoint)m_pCoords[loop]).x ) * 
  51. ( ((NetPoint)m_pCoords[loop -1]).x - ((NetPoint)m_pCoords[loop]).x ) + 
  52. ( ((NetPoint)m_pCoords[loop -1]).y - ((NetPoint)m_pCoords[loop]).y ) * 
  53. ( ((NetPoint)m_pCoords[loop -1]).y - ((NetPoint)m_pCoords[loop]).y ) ) ;
  54. dLength += dist ;
  55. }
  57. return dLength ;
  58. }
  60. // 通过线的id得到线数据
  61. public bool GetLineData(int id)
  62. {
  63. MapObjects2.Recordset rs;
  64. rs = m_layer.SearchExpression("GeoID = " + id.ToString());
  66. if (null == rs)
  67. return false;
  69. rs.MoveFirst();
  70.  
  71. if (rs.EOF) 
  72. return false;
  74. MapObjects2.Line line = (MapObjects2.Line)rs.Fields.Item("shape").Value;
  75. MapObjects2.Points pts;
  77. pts = (MapObjects2.Points)line.Parts.Item(0);
  78.   
  79. m_pCoords.Clear();
  80.  
  81. for (int i = 0; i < pts.Count; i ++)
  82. {
  83. NetPoint pt = new NetPoint(pts.Item(i).X,pts.Item(i).Y);
  84. m_pCoords.Add(pt); 
  85. }
  87. return true;
  88. }
  90. // 得到距离某点最近的线段，返回该线段的id
  91. public int GetNearestLineData( double x, double y)
  92. {
  93. MapObjects2.Recordset rs = m_layer.Records;
  94. MapObjects2.Point pt = new MapObjects2.PointClass();
  95. pt.X = x;
  96. pt.Y = y;
  98. double dDist = 9999999;
  99. int id = -1;
  101. rs.MoveFirst(); 
  102. while(!rs.EOF)
  103. {
  104. MapObjects2.Line line= (MapObjects2.Line)rs.Fields.Item("shape").Value;
  105. double d = line.DistanceTo(pt);   
  107. if (dDist > d)
  108. {
  109. dDist = d;
  110. string szValue = rs.Fields.Item("Geoid").ValueAsString;
  111. id = Convert.ToInt32(szValue);
  112. }
  113. rs.MoveNext(); 
  114. }
  116. if (id != -1)
  117. {
  118. if (!GetLineData(id))
  119. return -1;
  120. }
  121. return id;
  122. }
  124. public void AddCoord( NetPoint pt )
  125. {
  126. m_pCoords.Add( pt );
  127. }
  129. public bool IsPtCoincide( NetPoint ptFirst, NetPoint ptSecond )
  130. {
  131. if ( Math.Abs(ptFirst.x - ptSecond.x ) <= 0.00000001 && 
  132. Math.Abs(ptFirst.y - ptSecond.y ) <= 0.00000001 )
  133. return true;
  134. return false;
  135. }
  137. public void GetNearestPoint( NetPoint ptP, NetPoint ptA, NetPoint ptB,
  138. out NetPoint ptNearest, out double dDistance )
  139. {
  140. double Px,Py,Ax,Ay,Bx,By ;
  141. double AB2,PA2,PB2,AB,PA,PB,S,AREA ;
  142. double med,med1,k1,k2,b1,b2 ;
  144. ptNearest = new NetPoint();
  145. dDistance = 0;
  147. if ( IsPtCoincide(ptA,ptB) )
  148. {
  149. ptNearest = ptA;
  150. return ;
  151. }
  153. Px = ptP.x ;
  154. Py = ptP.y ;
  155. Ax = ptA.x ;
  156. Ay = ptA.y ;
  157. Bx = ptB.x ;
  158. By = ptB.y ;
  159. AB2 = (Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By) ;
  160. PB2 = (Px - Bx) * (Px - Bx) + (Py - By) * (Py - By) ;
  161. PA2 = (Ax - Px) * (Ax - Px) + (Ay - Py) * (Ay - Py) ;
  163. if(PA2 + AB2 < PB2 || AB2 + PB2 < PA2)
  164. {                       
  165. if(PA2>PB2)
  166. {
  167. med = PB2 ;
  168. ptNearest.x = Bx ;
  169. ptNearest.y = By ;
  170. }
  171. else
  172. {
  173. med = PA2 ;
  174. ptNearest.x = Ax ;
  175. ptNearest.y = Ay ;
  176. }
  177. med = Math.Sqrt(med) ;
  178. dDistance = med ;
  179. return ;
  180. }
  182. if (PA2 < 0.00000001 || PB2 < 0.00000001)
  183. {
  184. if(PA2 < 0.00000001)
  185. {
  186. med = Math.Sqrt(PA2) ;
  187. dDistance = med ;
  188. ptNearest.x = Ax ;
  189. ptNearest.y = Ay ;
  190. return ;
  191. }
  192. else 
  193. {
  194. med = Math.Sqrt(PB2) ;
  195. dDistance = med ;
  196. ptNearest.x = Bx ;
  197. ptNearest.y = By ;
  198. return ;
  199. }
  200. }
  202. AB = Math.Sqrt(AB2) ;
  203. PA = Math.Sqrt(PA2) ;
  204. PB = Math.Sqrt(PB2) ;
  205. S = (AB + PA + PB) / 2.0 ;
  206. AREA = S ;
  207. AREA *= (S - PA) ;
  208. AREA *= (S - PB) ;
  209. AREA *= (S - AB) ;
  210. AREA = Math.Sqrt(AREA) ;
  211. med = (2.0 * AREA) / AB ;
  212. dDistance = med ;
  214. med = Ay - By ;
  215. med1 = Ax - Bx ;
  216. if(Math.Abs(med) < 0.00000001 || Math.Abs(med1) < 0.00000001)
  217. {
  218. if(Math.Abs(med) < 0.00000001)
  219. {
  220. ptNearest.x = Px ;
  221. ptNearest.y = Ay ;
  222. }
  223. else
  224. {
  225. ptNearest.y = Py ;
  226. ptNearest.x = Ax ;
  227. }
  228. }
  229. else
  230. {
  231. k1 = (Ay - By) / ( Ax - Bx) ;
  232. k2 = -1.0 / k1 ;
  233. b1 = Ay - k1 * Ax ;
  234. b2 = Py - k2 * Px ;
  235. S = (b2 - b1) / (k1 - k2) ;
  236. ptNearest.x = S ;
  237. S = k1 * S + b1 ;
  238. ptNearest.y = S ;
  239. }
  240. return;
  241. }
  243. public void GetNearestPoint( NetPoint point, out NetPoint ptNearestPoint, 
  244. out int nSegmentIndex,out double dLeastDistance )
  245. {
  247. int nPointNum = m_pCoords.Count;
  248. double dDistance;
  249. NetPoint ptTemp;
  251. GetNearestPoint( point, (NetPoint)m_pCoords[0],(NetPoint)m_pCoords[1],out ptNearestPoint,out dLeastDistance);
  252. nSegmentIndex = 0 ;
  254. //遍历每一条弧段来搜索最近的点
  255. int nIndex ;
  256. for( nIndex = 1 ; nIndex < nPointNum-1 ; nIndex ++ ) 
  257. {
  258. //得到最近的点
  259. GetNearestPoint( point, (NetPoint)m_pCoords[0], (NetPoint)m_pCoords[1], out ptTemp, out dDistance ) ;
  261. //比较最小的距离
  262. if( dDistance < dLeastDistance )
  263. {
  264. dLeastDistance = dDistance ;
  265. ptNearestPoint = ptTemp ; 
  266. nSegmentIndex = nIndex ;
  267. }
  268. }
  269. return ;
  270. }
  272. // 获得根据给定点分裂线得到的两个部分的比例, 但并不真正分裂线
  273. // point: 给定点
  274. // ptNearestPoint: 分裂线时的分裂点 (返回)
  275. // dRatio: 起始结点部分的比例 (返回)
  276. public bool GetSplitRatioByNearestPoint( NetPoint point, out NetPoint ptNearest, out double dRatio )
  277. {
  278. int nIndex;
  279. double dDistance;
  281. int nPointNum = m_pCoords.Count;
  282. //首先得到最近的点和线段索引
  283. GetNearestPoint( point, out ptNearest, out nIndex, out dDistance );
  285. //检查线上最近的点是否与首尾点相重合
  286. if( nIndex == 0 )
  287. {
  288. if( IsPtCoincide( ptNearest, (NetPoint)m_pCoords[0] ) )
  289. {
  290. dRatio = 0;
  291. return true;
  292. }
  293. }
  295. if( nIndex == nPointNum-2 )
  296. {
  297. if( IsPtCoincide( ptNearest, (NetPoint)m_pCoords[nPointNum-1] ))
  298. {
  299. dRatio = 1;
  300. return true;
  301. }
  302. }
  304. //计算分裂出来的第二条线的长度
  305. int nLoop;
  306. double dLength = 0;
  307. //如果最近点与本线上的下一点不重合,则需将最近点计算在内
  308. if ( !IsPtCoincide(ptNearest, (NetPoint)m_pCoords[nIndex+1] ) )
  309. {
  310. dLength += Math.Sqrt( ( ((NetPoint)m_pCoords[nIndex+1]).x - ptNearest.x ) * 
  311. ( ((NetPoint)m_pCoords[nIndex+1]).x - ptNearest.x ) + 
  312. ( ((NetPoint)m_pCoords[nIndex+1]).y - ptNearest.y ) * 
  313. ( ((NetPoint)m_pCoords[nIndex+1]).y - ptNearest.y )
  314. );
  315. }
  316. for( nLoop = nIndex+2 ; nLoop < nPointNum ; nLoop ++ )
  317. {
  318. dLength += Math.Sqrt( ( ((NetPoint)m_pCoords[nLoop]).x - ((NetPoint)m_pCoords[nLoop-1]).x ) * 
  319. ( ((NetPoint)m_pCoords[nLoop]).x - ((NetPoint)m_pCoords[nLoop-1]).x ) + 
  320. ( ((NetPoint)m_pCoords[nLoop]).y - ((NetPoint)m_pCoords[nLoop-1]).y ) * 
  321. ( ((NetPoint)m_pCoords[nLoop]).y - ((NetPoint)m_pCoords[nLoop-1]).y )
  322. );
  323. }
  325. dRatio = 1 - dLength / CalcLength();
  326. return true;
  327. }
  328. }
  330. public class NetEdge
  331. {
  332. public int  nLink; // 连接的弧段索引(数组下标索引)
  333. public float fAngle; // 该弧段的水平夹角
  335. public NetEdge()
  336. {
  337. nLink = -1;
  338. fAngle = 0;
  339. }
  340. };
  342. public class NetNode : NetPoint
  343. {
  344. public ArrayList m_arrLinks = null; // 与该点连接的弧段数组, 弧段按角度排序
  346. public NetNode() 
  347. {
  348. m_arrLinks = new ArrayList();
  349. }
  351. public NetNode( double x, double y ) 
  352. {
  353. this.x = x;
  354. this.y = y;
  355. m_arrLinks = new ArrayList();
  356. }
  358. // 加入一个连接的弧段(调用前需确定弧段是连接在该点上的)
  359. public bool Add( int nLink, double dAngle )
  360. {
  361. // 结点连接的弧段按角度排序
  362. int i = 0;
  363. for (  i = 0; i < m_arrLinks.Count; i++ )
  364. {
  365. if ( dAngle < ((NetEdge)m_arrLinks[i]).fAngle )
  366. break;
  367. }
  368. NetEdge pEdge = new NetEdge();
  369. pEdge.nLink = nLink;
  370. pEdge.fAngle = (float)dAngle;
  371. m_arrLinks.Insert(i, pEdge );
  373. return true;
  374. }
  376. // 删除一个已连接的弧段
  377. public bool Remove( int nLink )
  378. {
  379. for ( int i = 0; i < m_arrLinks.Count ; i++ )
  380. {
  381. if ( nLink == ((NetEdge)m_arrLinks[i]).nLink )
  382. {
  383. m_arrLinks.RemoveAt( i );
  384. break;
  385. }
  386. }
  387. return true;
  388. }
  390. // 得到一个连接弧段的角度
  391. public double GetLinkAngle( int nLink )
  392. {
  393. for ( int i = 0; i < m_arrLinks.Count ; i++ )
  394. {
  395. if ( nLink == ((NetEdge)m_arrLinks[i]).nLink )
  396. {
  397. return ((NetEdge)m_arrLinks[i]).fAngle;
  398. }
  399. }
  400. return -1;
  401. }
  402. }
  404. // 网络弧段(链)类
  405. public class NetLink
  406. {
  407. public int m_GeoID; // 弧段ID(GeoID)
  408. public int m_nFNode; // 起始结点(数组下标索引)
  409. public int m_nTNode; // 终止结点(数组下标索引)
  410. public double m_fLength; // 长度
  411. public double m_fFromImp; // 正向阻力(阻力系数*长度 或 (1+阻力系数)*长度)
  412. public double m_fToImp; // 逆向阻力
  414. public NetLink()
  415. {
  416. m_GeoID = -1;
  417. m_nFNode = -1;
  418. m_nTNode = -1;
  419. m_fLength = 0;
  420. m_fFromImp = 0;
  421. m_fToImp = 0;
  422. }
  424. public void Copy( NetLink link )
  425. {
  426. m_GeoID = link.m_GeoID;
  427. m_nFNode = link.m_nFNode;
  428. m_nTNode = link.m_nTNode;
  429. m_fLength = link.m_fLength;
  430. m_fFromImp = link.m_fFromImp;
  431. m_fToImp = link.m_fToImp;
  432. }
  434. public bool IsEqual( NetLink link )
  435. {
  436. return m_GeoID == link.m_GeoID;
  437. }
  438. }
  440. public class NetLinkSeg
  441. {
  442. public int nSegID; // 分裂点后面的部分的弧段索引(数组下标索引)
  443. public double dRatio; // 分裂点前面的到起始结点部分的比例
  444. };
  446. // 用于备份弧段的类
  447. public class NetLinkBackup
  448. {
  449. public int m_nIndex; // 弧段的索引
  450. public NetLink m_Link=null; // 备份的弧段对象
  451. public ArrayList m_arrSegs; // 该弧段被多次分割的比例列表, 数目=段数-1, 即等于分裂点数
  453. public NetLinkBackup()
  454. {
  455. m_nIndex = -1;
  456. m_Link = new NetLink();
  457. m_arrSegs = new ArrayList();
  458. }
  460. public bool Add( int nSeg, double dRatio )
  461. {
  462. int i = 0;
  463. for ( i = 0; i < m_arrSegs.Count; i++ )
  464. {
  465. if ( dRatio < ((NetLinkSeg)m_arrSegs[i]).dRatio )
  466. break;
  467. }
  468. NetLinkSeg pSeg = new NetLinkSeg();
  469. pSeg.nSegID = nSeg;
  470. pSeg.dRatio = dRatio;
  471. m_arrSegs.Insert( i, pSeg );
  473. return true;
  474. }
  475. }
  477. public class NetPath
  478. {
  479. public double m_dLength; // 该点到给定点的最短路径长度, -1表示无穷大,即不连通
  480. public int m_nPreNode; // 该点在该路径上的前趋结点
  481. public NetPath()
  482. {
  483. m_dLength = -1;
  484. m_nPreNode = -1;
  485. }
  486. }
  488. /// <summary>
  489. /// Summary description for NetLayer.
  490. /// </summary>
  491. public class NetLayer
  492. {
  493. private ArrayList m_arrLinks; // 弧段表
  494. private ArrayList m_arrNodes; // 结点表
  495. private ArrayList m_arrStops; // 站点表
  496. private ArrayList m_arrLinkBackups; // 弧段备份表
  498. private int m_nLinkNum; // 原始弧段数目(网络拓扑建立完成后) 注意: 和m_arrLinks的大小可能是不相等的
  499. private int m_nNodeNum; // 原始结点数目(网络拓扑建立完成后) 注意: 和m_arrNodes的大小可能是不相等的
  500. private NetPath[] m_pPath; // 某一个点到所有点的最短路径. 每个点只记录它在路径上的前趋结点
  502. private MapObjects2.MapLayer m_layer = null;
  503. private System.Data.DataSet m_dataSet = null; 
  505. public NetLayer(MapObjects2.MapLayer layer, System.Data.DataSet dataSet)
  506. {
  507. m_nLinkNum = 0;
  508. m_nNodeNum = 0;
  509. m_pPath = null;
  510. m_dataSet = dataSet;
  511. m_layer = layer;
  512. }
  514. public bool ReadNetTable()
  515. {
  516. m_arrLinks = new ArrayList();
  517. m_arrNodes = new ArrayList();
  518. m_arrStops = new ArrayList();
  519. m_arrLinkBackups = new ArrayList();
  521. System.Data.DataTable Tbl = m_dataSet.Tables["AAT"];
  522. System.Data.DataRow[] rows = Tbl.Select();
  523. foreach (System.Data.DataRow myRow in rows)
  524. {
  525. NetLink lk = new NetLink();
  526. lk.m_GeoID = (int)myRow["GeoID"];
  527. lk.m_nFNode = (int)myRow["FNODE"];
  528. lk.m_nTNode = (int)myRow["TNODE"];
  529. lk.m_fLength = (double)myRow["LENGTH"];
  530. lk.m_fFromImp  = (double)myRow["FIMP"]; 
  531. lk.m_fToImp  = (double)myRow["TIMP"]; 
  532. m_arrLinks.Add( lk );
  533. }
  535. Tbl = m_dataSet.Tables["NAT"];
  536. rows = Tbl.Select();
  537. foreach (System.Data.DataRow myRow in rows)
  538. {
  539. int nNode, nLink;
  540. double x, y, dAngle;
  541. string szArcID, szAngle;
  543. nNode = (int)myRow["NODEID"];
  544. x = (double)myRow["X"];
  545. y = (double)myRow["Y"];
  546. szArcID = myRow["ARCID"].ToString();
  547. szAngle = myRow["ANGLE"].ToString();
  548. NetNode node = new NetNode(x,y);
  549. m_arrNodes.Add( node );
  551. int nPos;
  552. string szTemp;
  553. while ( (nPos = szArcID.IndexOf( ';' )) != -1 )
  554. {
  555. szTemp = szArcID.Substring( 0,nPos );
  556. nLink = Convert.ToInt32( szTemp );
  557. szArcID = szArcID.Substring( nPos+1 );
  559. nPos = szAngle.IndexOf( ';' );
  560. if ( nPos == -1 )
  561. continue;
  562. szTemp = szAngle.Substring(0, nPos );
  563. dAngle = Convert.ToDouble( szTemp );
  564. szAngle = szAngle.Substring( nPos + 1 );
  565. node.Add( nLink, dAngle );
  566. }
  567. }
  568. return true;
  569. }
  571. public bool PathAnalysis( double x1, double y1, double x2, double y2, out ArrayList path )
  572. {
  573. path = new ArrayList();
  574. NetPoint pt1 = new NetPoint( x1, y1 );
  575. NetPoint pt2 = new NetPoint( x2, y2 );
  577. ArrayList points = new ArrayList();
  578. points.Add( pt1 );
  579. points.Add( pt2 );
  581. ArrayList stops = null;
  582. if ( !LoadStops( points, out stops ) )
  583. return false;
  584. if ( stops.Count != 2 )
  585. return false;
  587. ArrayList nodes = null;
  588. double dDistance;
  589. dDistance = Path( (int)stops[0], (int)stops[1], out nodes, false );
  590. if ( dDistance < 0 )
  591. return false;
  593. NetLine line = null;
  594. if ( !CreateResultPath( nodes, out line, false ) )
  595. return false;
  597. for ( int i = 0; i < line.m_pCoords.Count; i++ )
  598. {
  599. path.Add( ((NetPoint)line.m_pCoords[i]).x );
  600. path.Add( ((NetPoint)line.m_pCoords[i]).y );
  601. }
  602. UnloadStops();
  603. return true;
  604. }
  607. // 加入一组坐标作为站点或者中心点, 用于分析. LoadStops与UnloadStops必须一一对应
  608. private bool LoadStops( ArrayList pPoints, out ArrayList pNodes )
  609. {
  610. int nLineID;
  611. int i, nNewNode;
  612. NetPoint ptNearest;
  613. double dRatio;
  614. pNodes = new ArrayList();
  616. // 先清空站点表
  617. m_arrStops.Clear();
  618. int nNum = pPoints.Count;
  619. for ( i = 0; i < nNum; i++ )
  620. {
  621. // 计算距离该点最近的线
  622. NetLine line = new NetLine(m_layer);
  623. nLineID = line.GetNearestLineData( ((NetPoint)pPoints[i]).x, ((NetPoint)pPoints[i]).y);
  624. if ( nLineID == -1 )
  625. {
  626. line = null;
  627. return false;
  628. }
  630. // 计算该点分裂该线的位置, 并不实际分裂该线, 只是计算分裂的比例, 用于更改弧段表和结点表
  631. dRatio = 0;
  632. line.GetSplitRatioByNearestPoint( (NetPoint)pPoints[i], out ptNearest, out dRatio );
  634. // 更新弧段表和结点表
  635. UpdateLinkNodeTable( nLineID, ptNearest, dRatio, out nNewNode );
  636. line = null;
  638. if ( pNodes.Count > 0 )
  639. {
  640. if ( ((int)pNodes[pNodes.Count-1]) == nNewNode )
  641. continue;
  642. }
  643. pNodes.Add( nNewNode );
  644. }
  646. // 填充需要返回的结点数组
  647. if ( pNodes.Count == 0 )
  648. {
  649. pNodes = null;
  650. return false;
  651. }
  652. return true;
  653. }
  655. // 外部结点更新弧段表和结点表
  656. // nNewNode: 加入该点后返回的新结点的标识
  657. private bool UpdateLinkNodeTable( int nLineID, NetPoint ptNearest, double dRatio, out int nNewNode )
  658. {
  659. int i, j;
  660. bool bFound;
  661. double dRatio2;
  662. int nCurLink, nNewLink;
  663. int nCurFNode, nCurTNode;
  664. nNewNode = -1;
  666. // 与某条弧段的首点或者位点重合, 不需要更改弧段表和结点表
  667. if ( Math.Abs(dRatio) < 0.00000001 )
  668. {
  669. // 首点
  670. nCurLink = GetNode( nLineID, out nCurFNode, out nCurTNode );
  671. nNewNode = nCurFNode;
  672. return true;
  673. }
  674. else if ( Math.Abs(1-dRatio) < 0.00000001 )
  675. {
  676. // 尾点
  677. nCurLink = GetNode( nLineID, out nCurFNode, out nCurTNode );
  678. nNewNode = nCurTNode;
  679. return true;
  680. }
  682. bFound = false;
  683. for ( i = 0; i < m_arrLinkBackups.Count; i++ )
  684. {
  685. if ( ((NetLinkBackup)m_arrLinkBackups[i]).m_Link.m_GeoID == nLineID )
  686. {
  687. bFound = true;
  688. break;
  689. }
  690. }
  692. if ( bFound )
  693. {
  694. for ( j = 0; j < ((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs.Count; j++ )
  695. {
  696. // 如果新点与原有的点重合, 则直接返回原来的点
  697. double r = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j]).dRatio;
  698. if ( Math.Abs( r - dRatio) < 0.00000001 )
  699. {
  700. if ( j == 0 )
  701. {
  702. nCurLink = GetNode( nLineID, out nCurFNode, out nCurTNode );
  703. nNewNode = nCurTNode;
  704. return true;
  705. }
  706. else
  707. {
  708. nCurLink = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j-1]).nSegID;
  709. nNewNode = ((NetLink)m_arrLinks[nCurLink]).m_nTNode;
  710. return true;
  711. }
  712. }
  714. // 没有重合的点
  715. r = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j]).dRatio;
  716. if ( dRatio < r )
  717. break;
  718. }
  719. if ( j == 0 )
  720. {
  721. // 第一段
  722. nCurLink = GetNode( nLineID, out nCurFNode, out nCurTNode );
  723. if ( nCurLink == -1 )
  724. return false;
  726. // 更新结点表
  727. nNewLink = m_arrLinks.Count;
  728. NetNode pNode = new NetNode( ptNearest.x, ptNearest.y );
  729. pNode.Add( nNewLink, -1 ); // 这里暂时用-1角度,待修改 Add code here
  730. pNode.Add( nCurLink, -1 );
  731. m_arrNodes.Add( pNode );
  733. ((NetNode)m_arrNodes[nCurTNode]).Remove( nCurLink );
  734. ((NetNode)m_arrNodes[nCurTNode]).Add( nNewLink, -1 );
  736. // 更新弧段表
  737. nNewNode = m_arrNodes.Count - 1;
  738. dRatio2 = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[0]).dRatio;
  739. NetLink pLink = new NetLink();
  740. pLink.m_GeoID = nLineID;
  741. pLink.m_nFNode = nNewNode;
  742. pLink.m_nTNode = ((NetLink)m_arrLinks[((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[0]).nSegID]).m_nFNode;
  743. pLink.m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * ( dRatio2 - dRatio ));
  744. pLink.m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * ( dRatio2 - dRatio ));
  745. pLink.m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp * ( dRatio2 - dRatio ));
  746. m_arrLinks.Add( pLink );
  748. ((NetLink)m_arrLinks[nCurLink]).m_nTNode = nNewNode;
  749. ((NetLink)m_arrLinks[nCurLink]).m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * dRatio);
  750. ((NetLink)m_arrLinks[nCurLink]).m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * dRatio);
  751. ((NetLink)m_arrLinks[nCurLink]).m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp* dRatio);
  753. ((NetLinkBackup)m_arrLinkBackups[i]).Add( nNewLink, dRatio );
  754. }
  755. else if ( j == ((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs.Count )
  756. {
  757. // 最后一段
  758. nCurLink = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j-1]).nSegID;
  759. nCurFNode = ((NetLink)m_arrLinks[nCurLink]).m_nFNode;
  760. nCurTNode = ((NetLink)m_arrLinks[nCurLink]).m_nTNode;
  762. // 更新结点表
  763. nNewLink = m_arrLinks.Count;
  764. NetNode pNode = new NetNode( ptNearest.x, ptNearest.y );
  765. pNode.Add( nNewLink, -1 ); // 这里暂时用-1角度,待修改 Add code here
  766. pNode.Add( nCurLink, -1 );
  767. m_arrNodes.Add( pNode );
  769. double dAngle = ((NetNode)m_arrNodes[nCurTNode]).GetLinkAngle( nCurLink ); // 最后一段保留原角度
  770. ((NetNode)m_arrNodes[nCurTNode]).Remove( nCurLink );
  771. ((NetNode)m_arrNodes[nCurTNode]).Add( nNewLink, dAngle );
  773. // 更新弧段表
  774. nNewNode = m_arrNodes.Count - 1;
  775. NetLink pLink = new NetLink();
  776. pLink.m_GeoID = nLineID;
  777. pLink.m_nFNode = nNewNode;
  778. pLink.m_nTNode = nCurTNode;
  779. pLink.m_fLength = (float)(((NetLink)m_arrLinks[i]).m_fLength * ( 1 - dRatio ));
  780. pLink.m_fFromImp = (float)(((NetLink)m_arrLinks[i]).m_fFromImp * ( 1 - dRatio ));
  781. pLink.m_fToImp = (float)(((NetLink)m_arrLinks[i]).m_fToImp * ( 1 - dRatio ));
  782. m_arrLinks.Add( pLink );
  784. dRatio2 = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j-1]).dRatio;
  785. ((NetLink)m_arrLinks[nCurLink]).m_nTNode = nNewNode;
  786. ((NetLink)m_arrLinks[nCurLink]).m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * ( dRatio - dRatio2) );
  787. ((NetLink)m_arrLinks[nCurLink]).m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * ( dRatio - dRatio2) );
  788. ((NetLink)m_arrLinks[nCurLink]).m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp* ( dRatio - dRatio2) );
  789. ((NetLinkBackup)m_arrLinkBackups[i]).Add( nNewLink, dRatio );
  790. }
  791. else
  792. {
  793. // 中间某一段
  794. nCurLink = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j-1]).nSegID;
  795. nCurFNode = ((NetLink)m_arrLinks[nCurLink]).m_nFNode;
  796. nCurTNode = ((NetLink)m_arrLinks[nCurLink]).m_nTNode;
  798. // 更新结点表
  799. nNewLink = m_arrLinks.Count;
  800. NetNode pNode = new NetNode( ptNearest.x, ptNearest.y );
  801. pNode.Add( nNewLink, -1 ); // 这里暂时用-1角度,待修改 Add code here
  802. pNode.Add( nCurLink, -1 );
  803. m_arrNodes.Add( pNode );
  805. ((NetNode)m_arrNodes[nCurTNode]).Remove( nCurLink );
  806. ((NetNode)m_arrNodes[nCurTNode]).Add( nNewLink, -1 );
  808. // 更新弧段表
  809. nNewNode = m_arrNodes.Count - 1;
  810. dRatio2 = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j]).dRatio;
  811. NetLink pLink = new NetLink();
  812. pLink.m_GeoID = nLineID;
  813. pLink.m_nFNode = nNewNode;
  814. pLink.m_nTNode = nCurTNode;
  815. pLink.m_fLength = (float)(((NetLink)m_arrLinks[i]).m_fLength * ( dRatio2 - dRatio ));
  816. pLink.m_fFromImp = (float)(((NetLink)m_arrLinks[i]).m_fFromImp * ( dRatio2 - dRatio ));
  817. pLink.m_fToImp = (float)(((NetLink)m_arrLinks[i]).m_fToImp * ( dRatio2 - dRatio ));
  818. m_arrLinks.Add( pLink );
  820. dRatio2 = ((NetLinkSeg)((NetLinkBackup)m_arrLinkBackups[i]).m_arrSegs[j-1]).dRatio;
  821. ((NetLink)m_arrLinks[nCurLink]).m_nTNode = nNewNode;
  822. ((NetLink)m_arrLinks[nCurLink]).m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * ( dRatio - dRatio2) );
  823. ((NetLink)m_arrLinks[nCurLink]).m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * ( dRatio - dRatio2) );
  824. ((NetLink)m_arrLinks[nCurLink]).m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp* ( dRatio - dRatio2) );
  825. ((NetLinkBackup)m_arrLinkBackups[i]).Add( nNewLink, dRatio );
  826. }
  827. }
  828. else
  829. {
  830. nCurLink = GetNode( nLineID, out nCurFNode, out nCurTNode );
  831. if ( nCurLink == -1 )
  832. return false;
  834. nNewLink = m_arrLinks.Count;
  835. // 备份
  836. NetLinkBackup pBackup = new NetLinkBackup();
  837. pBackup.m_nIndex = nCurLink;
  838. pBackup.m_Link.Copy((NetLink)m_arrLinks[nCurLink]);
  839. pBackup.Add( nNewLink, dRatio );
  840. m_arrLinkBackups.Add( pBackup );
  842. // 更新结点表
  843. NetNode pNode = new NetNode( ptNearest.x, ptNearest.y );
  844. pNode.Add( nNewLink, -1 ); // 这里暂时用0角度,待修改 Add code here
  845. pNode.Add( nCurLink, -1 );
  846. m_arrNodes.Add( pNode );
  848. double dAngle = ((NetNode)m_arrNodes[nCurTNode]).GetLinkAngle( nCurLink ); // 最后一段保留原角度
  849. ((NetNode)m_arrNodes[((NetLink)m_arrLinks[nCurLink]).m_nTNode]).Remove( nCurLink );
  850. ((NetNode)m_arrNodes[((NetLink)m_arrLinks[nCurLink]).m_nTNode]).Add( nNewLink, dAngle );
  852. // 更新弧段表
  853. nNewNode = m_arrNodes.Count - 1;
  854. NetLink pLink = new NetLink();
  855. pLink.m_GeoID = nLineID;
  856. pLink.m_nFNode = nNewNode;
  857. pLink.m_nTNode = ((NetLink)m_arrLinks[nCurLink]).m_nTNode;
  858. pLink.m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * ( 1 - dRatio ));
  859. pLink.m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * ( 1 - dRatio ));
  860. pLink.m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp * ( 1 - dRatio ));
  861. m_arrLinks.Add( pLink );
  863. ((NetLink)m_arrLinks[nCurLink]).m_nTNode = nNewNode;
  864. ((NetLink)m_arrLinks[nCurLink]).m_fLength = (float)(((NetLink)m_arrLinks[nCurLink]).m_fLength * dRatio);
  865. ((NetLink)m_arrLinks[nCurLink]).m_fFromImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fFromImp * dRatio);
  866. ((NetLink)m_arrLinks[nCurLink]).m_fToImp = (float)(((NetLink)m_arrLinks[nCurLink]).m_fToImp* dRatio);
  867. }
  868. return true;
  869. }
  871. // 得到结点号, 返回弧段索引号(数组下标索引), -1表示失败
  872. private int GetNode( int nLineID, out int nFNode, out int nTNode )
  873. {
  874. nFNode = -1;
  875. nTNode = -1;
  876. for ( int i = 0; i < m_arrLinks.Count; i++ )
  877. {
  878. if ( nLineID == ((NetLink)m_arrLinks[i]).m_GeoID )
  879. {
  880. nFNode = ((NetLink)m_arrLinks[i]).m_nFNode;
  881. nTNode = ((NetLink)m_arrLinks[i]).m_nTNode;
  882. return i;
  883. }
  884. }
  885. return -1;
  886. }
  888. // 计算两点间的最短路径
  889. // 参数含义:  nBeginNode 起始结点
  890. //            nEndNode 终止结点
  891. //            pNodes 路径顺序经过的结点数组, 返回参数
  892. //   bWeight TRUE为计算考虑方向权重最优路径, FALSE为不考虑方向权重的最短路径
  893. // 注意: pNode在函数内部开辟内存, 函数调用者负责在外部删除该内存
  894. // 返回路径总长度，<0 表示没有连通的路径
  895. private double Path( int nBeginNode, int nEndNode, out ArrayList pNodes, bool bWeight )
  896. {
  897. pNodes= null;
  898. if ( nBeginNode < 0 || nBeginNode >= m_arrNodes.Count )
  899. return -1;
  900. if ( nEndNode < 0 || nEndNode >= m_arrNodes.Count )
  901. return -1;
  903. pNodes = new ArrayList();
  904. // 如果两个结点相同
  905. if ( nBeginNode == nEndNode )
  906. {
  907. pNodes.Add( nBeginNode );
  908. return 0;
  909. }
  910. // 计算nBeginNode到其他所有结点的最短路径
  911. if ( !CalcPath( nBeginNode, nEndNode, bWeight ) )
  912. return -1;
  914. // 提取从nBeginNode到nEndNode的路径
  915. // 从nEndNode向前搜索前趋结点
  916. int nNode;
  917. nNode = nEndNode;
  918. while ( true )
  919. {
  920. // 如果没有前趋结点, 不连通
  921. if ( m_pPath[nNode].m_nPreNode == -1 )
  922. return -1;
  924. // 如果前趋结点为起始结点, 路径结束
  925. if ( m_pPath[nNode].m_nPreNode == nBeginNode )
  926. {
  927. pNodes.Add( nNode );
  928. break;
  929. }
  931. // 加入中间结点
  932. pNodes.Add( nNode );
  933. nNode = m_pPath[nNode].m_nPreNode;
  934. }
  936. // 加入起点
  937. pNodes.Add( nBeginNode );
  938. // 因为是从nEndNode到nBeginNode加入的, 所以要作一次倒序
  939. pNodes.Reverse();
  941. return m_pPath[nEndNode].m_dLength;
  942. }
  944. // 计算一个点到所有点的最短路径. 采用Dijkstra算法
  945. // 参数bWeight表示是否考虑方向权重
  946. // 如果nEndNode不等于-1, 则只计算nNode到nEndNode的最短路径,
  947. private bool CalcPath( int nNode, int nEndNode , bool bWeight )
  948. {
  949. if ( nNode < 0 || nNode >= m_arrNodes.Count )
  950. return false;
  952. int i, j, nNodeNum;
  953. int nLink;
  954. byte[] pMark = null; // 处理标志数组
  955. nNodeNum = m_arrNodes.Count;
  956. if ( nNodeNum == 0 )
  957. return true;
  959. pMark = new byte[nNodeNum];
  960. for ( i = 0; i < nNodeNum; i++ )
  961. pMark[i] = 0;
  963. // (1) 初始化
  964. // 初始化路径数组, 类的构造函数会将长度置为-1, 前趋结点为-1
  965. m_pPath = null;
  966. m_pPath = new NetPath[nNodeNum];
  967. for ( i = 0; i < nNodeNum; i++ )
  968. m_pPath[i] = new NetPath();
  969. // 自身
  970. m_pPath[nNode].m_dLength = 0;
  971. m_pPath[nNode].m_nPreNode = nNode;
  973. // 对于与该结点直接相连的点, 初始化路径长度为连接弧度的阻力
  974. for ( i = 0; i < ((NetNode)m_arrNodes[nNode]).m_arrLinks.Count; i++ )
  975. {
  976. nLink = ((NetEdge)((NetNode)m_arrNodes[nNode]).m_arrLinks[i]).nLink;
  977. if ( ((NetLink)m_arrLinks[nLink]).m_nFNode == nNode )
  978. {
  979. // 路径长度, 正向
  980. m_pPath[((NetLink)m_arrLinks[nLink]).m_nTNode].m_dLength = 
  981. bWeight ? ((NetLink)m_arrLinks[nLink]).m_fFromImp  : ((NetLink)m_arrLinks[nLink]).m_fLength;
  983. // 前趋结点, 如果长度<0, 无前趋结点
  984. if ( m_pPath[((NetLink)m_arrLinks[nLink]).m_nTNode].m_dLength < 0 )
  985. m_pPath[((NetLink)m_arrLinks[nLink]).m_nTNode].m_nPreNode = -1;
  986. else
  987. m_pPath[((NetLink)m_arrLinks[nLink]).m_nTNode].m_nPreNode = nNode;
  988. }
  989. else if ( ((NetLink)m_arrLinks[nLink]).m_nTNode == nNode )
  990. {
  991. // 路径长度, 逆向
  992. m_pPath[((NetLink)m_arrLinks[nLink]).m_nFNode].m_dLength = 
  993. bWeight ? ((NetLink)m_arrLinks[nLink]).m_fToImp : ((NetLink)m_arrLinks[nLink]).m_fLength;
  995. // 前趋结点, 如果长度<0, 无前趋结点
  996. if ( m_pPath[((NetLink)m_arrLinks[nLink]).m_nFNode].m_dLength < 0 )
  997. m_pPath[((NetLink)m_arrLinks[nLink]).m_nFNode].m_nPreNode = -1;
  998. else
  999. m_pPath[((NetLink)m_arrLinks[nLink]).m_nFNode].m_nPreNode = nNode;
  1000. }
  1001. }
  1003. // 开始处理
  1004. int nMinNode;
  1005. double dDist, dMinDist;
  1006. for ( i = 0; i < nNodeNum; i++ )
  1007. {
  1008. // (2) 在未处理结点中找出距离值最小的结点
  1009. nMinNode = -1;
  1010. dMinDist = 1.7e+308;
  1011. for ( j = 0; j < nNodeNum; j++ )
  1012. {
  1013. // 让过自身
  1014. if ( j == nNode )
  1015. continue;
  1016. // 让过不连通结点
  1017. if ( m_pPath[j].m_dLength < 0 ) // <0 表示无穷大
  1018. continue;
  1019. // 让过处理过的结点
  1020. if ( pMark[j] == 1 )
  1021. continue;
  1023. // 在未处理过的结点中找出距离最小的
  1024. if ( m_pPath[j].m_dLength < dMinDist )
  1025. {
  1026. dMinDist = m_pPath[j].m_dLength;
  1027. nMinNode = j;
  1028. }
  1029. }
  1031. // 如果没找到, 则表示与其他点不连通
  1032. if ( nMinNode == -1 )
  1033. {
  1034. pMark = null;
  1035. return true;
  1036. }
  1037. // 处理该距离最小的点
  1038. pMark[nMinNode] = 1;
  1040. // (3) 调整余下的结点的最短路径
  1041. for ( j = 0; j < nNodeNum; j++ )
  1042. {
  1043. // 让过自身
  1044. if ( j == nNode )
  1045. continue;
  1047. // 让过处理过的结点
  1048. if ( pMark[j] == 1 )
  1049. continue;
  1051. // 调整未处理过的结点的最短路径
  1052. // 计算直接相连的结点间的距离
  1053. dDist = GetConnectedDistance( nMinNode, j, bWeight );
  1054. if ( dDist < 0 ) // 不连通
  1055. continue;
  1057. // 更新未处理过的结点的最短路径
  1058. if ( m_pPath[j].m_dLength < 0 || 
  1059. m_pPath[j].m_dLength > m_pPath[nMinNode].m_dLength + dDist )
  1060. {
  1061. m_pPath[j].m_dLength = m_pPath[nMinNode].m_dLength + dDist ;
  1062. m_pPath[j].m_nPreNode = nMinNode;
  1063. }
  1064. }
  1065. }
  1067. pMark = null;
  1068. return true;
  1069. }
  1071. // 得到两个结点直接连接的距离, 不直接连接则返回-1
  1072. // 返回的结果考虑了方向权重, 因此是与nNode1,nNode2的参数顺序有关的
  1073. private double GetConnectedDistance( int nNode1, int nNode2, bool bWeight )
  1074. {
  1075. if ( nNode1 < 0 || nNode1 >= m_arrNodes.Count )
  1076. return -1;
  1077. if ( nNode2 < 0 || nNode2 >= m_arrNodes.Count )
  1078. return -1;
  1079. if ( nNode1 == nNode2 )
  1080. return 0;
  1082. int nLink;
  1083. double dDistance;
  1084. double dMinDist = 1.7e+308;
  1085. int nRes = 0;
  1086. int i = 0;
  1087. // 遍历与结点1相连的弧段, 判断弧段的另一端的结点是否为结点2, 是则返回距离
  1088. for ( i = 0; i < ((NetNode)m_arrNodes[nNode1]).m_arrLinks.Count; i++ )
  1089. {
  1090. nLink = ((NetEdge)((NetNode)m_arrNodes[nNode1]).m_arrLinks[i]).nLink;
  1091. if ( ((NetLink)m_arrLinks[nLink]).m_nFNode == nNode1 )
  1092. {
  1093. if ( ((NetLink)m_arrLinks[nLink]).m_nTNode == nNode2 )
  1094. {
  1095. dDistance = bWeight ? ((NetLink)m_arrLinks[nLink]).m_fFromImp : ((NetLink)m_arrLinks[nLink]).m_fLength;
  1096. if ( dDistance < dMinDist )
  1097. {
  1098. dMinDist = dDistance;
  1099. nRes = 1;
  1100. }
  1101. }
  1102. }
  1103. else if ( ((NetLink)m_arrLinks[nLink]).m_nTNode == nNode1 )
  1104. {
  1105. if ( ((NetLink)m_arrLinks[nLink]).m_nFNode == nNode2 )
  1106. {
  1107. dDistance = bWeight ? ((NetLink)m_arrLinks[nLink]).m_fToImp : ((NetLink)m_arrLinks[nLink]).m_fLength;
  1108. if ( dDistance < dMinDist )
  1109. {
  1110. dMinDist = dDistance;
  1111. nRes = -1;
  1112. }
  1113. }
  1114. }
  1115. }
  1117. if ( nRes == 0 )
  1118. return -1;
  1119. return dMinDist;
  1120. }
  1122. // 由结点生成路径的结果图层
  1123. // 参数含义: pNodes: 网络分析结果结点集
  1124. //           nNum: 结点数目
  1125. //           szLayerName: 结果图层名称
  1126. //           bWeight TRUE为计算考虑方向权重最优路径, FALSE为不考虑方向权重的最短路径
  1127. private bool CreateResultPath( ArrayList pNodes, out NetLine line, bool bWeight )
  1128. {
  1130. line = new NetLine(m_layer);
  1131. int i, j;
  1133. // 将分析结果结点集转换为线加入到结果图层中
  1134. int nNum;
  1135. int nRes;
  1136. int nNode1, nNode2, nLink;
  1137. double dDistance, dRatio;
  1138. double dTotalImp;
  1139. nNum = pNodes.Count;
  1141. int idLine;
  1142. dTotalImp = 0;
  1143. for ( i = 0; i < nNum-1; i++ )
  1144. {
  1145. // 得到连接两个结点的最短弧段
  1146. nNode1 = (int)pNodes[i];
  1147. nNode2 = (int)pNodes[i+1];
  1148. nRes = IsConnectedDirectly( nNode1, nNode2, out nLink, out dDistance, bWeight );
  1150. // 不连通则返回false. 这种情况理论上是不可能出现的.
  1151. if ( nRes == 0 )
  1152. {
  1153. return false;
  1154. }
  1155. if ( nLink == -1 )
  1156. continue;
  1158. // 将该弧段的结点按路径顺序加入到结果图层的线中去
  1159. idLine = ((NetLink)m_arrLinks[nLink]).m_GeoID;
  1160. NetLine tmpLine = new NetLine(m_layer);
  1161. tmpLine.GetLineData( idLine );
  1163. // 只加入起始结点和终止结点之间的点
  1164. double dDist;
  1165. int nSegIndex1, nSegIndex2;
  1166. NetPoint ptNearst1, ptNearst2, ptTemp;
  1168. ptTemp = new NetPoint();
  1169. ptTemp.x= ((NetNode)m_arrNodes[nNode1]).x;
  1170. ptTemp.y= ((NetNode)m_arrNodes[nNode1]).y;
  1171. tmpLine.GetNearestPoint( ptTemp, out ptNearst1, out nSegIndex1, out dDist );
  1172. ptTemp.x= ((NetNode)m_arrNodes[nNode2]).x;
  1173. ptTemp.y= ((NetNode)m_arrNodes[nNode2]).y;
  1174. tmpLine.GetNearestPoint( ptTemp, out ptNearst2, out nSegIndex2, out dDist );
  1175. dRatio = ((NetLink)m_arrLinks[nLink]).m_fLength / tmpLine.CalcLength();
  1177. if ( nRes == 1 )
  1178. {
  1179. // 正向
  1180. line.AddCoord( ptNearst1 );
  1181. for ( j = nSegIndex1; j < nSegIndex2; j++ )
  1182. line.AddCoord( (NetPoint)tmpLine.m_pCoords[j+1] );
  1183. line.AddCoord( ptNearst2 );
  1184. dTotalImp += ((NetLink)m_arrLinks[nLink]).m_fFromImp;
  1185. }
  1186. else if ( nRes == -1 )
  1187. {
  1188. // 逆向
  1189. line.AddCoord( ptNearst1 );
  1190. for ( j = nSegIndex1; j > nSegIndex2; j-- )
  1191. line.AddCoord( (NetPoint)tmpLine.m_pCoords[j] );
  1192. line.AddCoord( ptNearst2 );
  1193. dTotalImp += ((NetLink)m_arrLinks[nLink]).m_fToImp;
  1194. }
  1195. tmpLine = null;
  1197. if ( line.m_pCoords.Count < 2 )
  1198. {
  1199. line.m_pCoords.Clear();
  1200. continue;
  1201. }
  1202. }
  1204. return true;
  1205. }
  1207. // 判断两个结点是否直接相连. 即两个结点在同一条弧段上
  1208. // 返回值: 0  不直接连通
  1209. //         1  直接连通, 且从nNode1到nNode2为正向连接
  1210. //         -1 直接连通, 且从nNode1到nNode2为逆向连接
  1211. // 如果两个结点直接连通, 则同时返回连接两个结点的弧段nLink,以及直接连通的最小阻力加权距离dDistance
  1212. // 如果不直接连通, 则nLink=-1, dDistance=-1
  1213. private int IsConnectedDirectly( int nNode1, int nNode2, out int nLink, out double dDistance, bool bWeight )
  1214. {
  1215. nLink = -1;
  1216. dDistance = 0;
  1217. if ( nNode1 < 0 || nNode1 >= m_arrNodes.Count )
  1218. return 0;
  1219. if ( nNode2 < 0 || nNode2 >= m_arrNodes.Count )
  1220. return 0;
  1221. if ( nNode1 == nNode2 )
  1222. return 1;
  1224. int i = 0;
  1225. int nRes = 0;
  1226. int nMinLink = -1;
  1227. double dMinDist = 1.7e+308;
  1228. // 遍历与结点1相连的弧段, 判断弧段的另一端的结点是否为结点2
  1229. for ( i = 0; i < ((NetNode)m_arrNodes[nNode1]).m_arrLinks.Count; i++ )
  1230. {
  1231. nLink = ((NetEdge)((NetNode)m_arrNodes[nNode1]).m_arrLinks[i]).nLink;
  1232. if ( ((NetLink)m_arrLinks[nLink]).m_nFNode == nNode1 )
  1233. {
  1234. if ( ((NetLink)m_arrLinks[nLink]).m_nTNode == nNode2 )
  1235. {
  1236. dDistance = bWeight ?((NetLink)m_arrLinks[nLink]).m_fFromImp : ((NetLink)m_arrLinks[nLink]).m_fLength;
  1237. if ( dDistance < dMinDist )
  1238. {
  1239. dMinDist = dDistance;
  1240. nMinLink = nLink;
  1241. nRes = 1;
  1242. }
  1243. }
  1244. }
  1245. else if ( ((NetLink)m_arrLinks[nLink]).m_nTNode == nNode1 )
  1246. {
  1247. if ( ((NetLink)m_arrLinks[nLink]).m_nFNode == nNode2 )
  1248. {
  1249. dDistance = bWeight ? ((NetLink)m_arrLinks[nLink]).m_fToImp : ((NetLink)m_arrLinks[nLink]).m_fLength;
  1250. if ( dDistance < dMinDist )
  1251. {
  1252. dMinDist = dDistance;
  1253. nMinLink = nLink;
  1254. nRes = -1;
  1255. }
  1256. }
  1257. }
  1258. }
  1260. if ( nRes == 0 )
  1261. {
  1262. nLink = -1;
  1263. dDistance = -1;
  1264. return 0;
  1265. }
  1267. nLink = nMinLink;
  1268. dDistance = dMinDist;
  1269. return nRes;
  1270. }
  1272. // 去除加入的站点或中心点. UnloadStops与LoadStops必须一一对应
  1273. private bool UnloadStops()
  1274. {
  1275. int i, j;
  1276. int nLink, nNode;
  1277. double dAngle;
  1278. // 清空站点表
  1279. m_arrStops.Clear();
  1281. // 利用备份数据, 恢复弧段表和结点表, 并清除备份数据
  1282. for ( i = 0; i < m_arrLinkBackups.Count; i++ )
  1283. {
  1284. nLink = ((NetLinkBackup)m_arrLinkBackups[i]).m_nIndex;
  1285. // 恢复弧段表
  1286. ((NetLink)m_arrLinks[nLink]).Copy( ((NetLinkBackup)m_arrLinkBackups[i]).m_Link );
  1288. // 恢复点表
  1289. nNode = ((NetLink)m_arrLinks[nLink]).m_nTNode;
  1290. dAngle = ((NetNode)m_arrNodes[nNode]).GetLinkAngle( nLink );
  1291. for ( j = ((NetNode)m_arrNodes[nNode]).m_arrLinks.Count-1; j >=0 ; j-- )
  1292. {
  1293. if ( ((NetEdge)((NetNode)m_arrNodes[nNode]).m_arrLinks[j]).nLink >= m_nLinkNum )
  1294. {
  1295. ((NetNode)m_arrNodes[nNode]).m_arrLinks.RemoveAt( j );
  1296. }
  1297. }
  1298. ((NetNode)m_arrNodes[nNode]).Add( nLink, dAngle );
  1299. }
  1300. m_arrLinkBackups.Clear();
  1301. m_pPath = null;
  1302. return true;
  1303. }
  1305. }
  1306. }