ElementEdgesArray.cs 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Collections.ObjectModel;
  4. using System.Linq;
  5. using Autodesk.Revit.DB;
  6. using SAGA.RevitUtils;
  7. namespace SAGA.RevitUtils
  8. {
  9. /// <summary>
  10. /// 边集数组的形式存储边的集合
  11. /// </summary>
  12. public class ElementEdgesArray
  13. {
  14. public ElementEdgesArray()
  15. {
  16. m_Vertexes = new List<ElementsVertex>();
  17. Vertexes = new ReadOnlyCollection<ElementsVertex>(m_Vertexes);
  18. m_Edges = new List<ElementsEdge>();
  19. Edges = new ReadOnlyCollection<ElementsEdge>(m_Edges);
  20. VERelations = new Dictionary<string, List<string>>();
  21. }
  22. #region 编号系统
  23. private int m_CurrentIndex;
  24. /// <summary>
  25. /// 生成节点索引
  26. /// </summary>
  27. /// <returns></returns>
  28. private string GenerateVertexIndex()
  29. {
  30. return "V" + (++m_CurrentIndex);
  31. }
  32. /// <summary>
  33. /// 生成节点索引
  34. /// </summary>
  35. /// <returns></returns>
  36. private string GenerateEdgeIndex()
  37. {
  38. return "E" + (++m_CurrentIndex);
  39. }
  40. #endregion
  41. /// <summary>
  42. /// 根据条件获当前可用的点
  43. /// </summary>
  44. /// <param name="predicate"></param>
  45. /// <returns></returns>
  46. public List<ElementsVertex> GetAvailableVertexes(Predicate<ElementsVertex> predicate)
  47. {
  48. return Vertexes.Where(v =>
  49. {
  50. if (!IsAvailable(v))
  51. return false;
  52. if (predicate != null)
  53. {
  54. return predicate(v);
  55. }
  56. return true;
  57. }
  58. ).ToList();
  59. }
  60. /// <summary>
  61. /// 根据条件获取当前可用的边 [为空的话则不做限制]
  62. /// </summary>
  63. /// <param name="predicate"></param>
  64. /// <returns></returns>
  65. public List<ElementsEdge> GetAvailableEdges(Predicate<ElementsEdge> predicate)
  66. {
  67. return Edges.Where(e =>
  68. {
  69. if (!IsAvailable(e))
  70. return false;
  71. if (predicate != null)
  72. {
  73. return predicate(e);
  74. }
  75. return true;
  76. }
  77. ).ToList();
  78. }
  79. /// <summary>
  80. /// 判断节点是否可用
  81. /// </summary>
  82. /// <typeparam name="T"></typeparam>
  83. /// <param name="node"></param>
  84. /// <returns></returns>
  85. public bool IsAvailable<T>(GraphNode<T> node) where T: GraphNode<T>
  86. {
  87. if (node.Parent != null)
  88. return false;
  89. return true;
  90. }
  91. public ElementsVertex GetVertexById(string eId)
  92. { return this.Vertexes.FirstOrDefault(c => c.Id == eId); }
  93. public ElementsEdge GetEdgeById(string eId)
  94. {
  95. return this.Edges.FirstOrDefault(c => c.Id == eId);
  96. }
  97. #region 点处理
  98. /*
  99. * 增加一个点和边的关联关系,便于以后的查找速度
  100. */
  101. private Dictionary<string, List<string>> VERelations { get; set; }
  102. /// <summary>
  103. /// 增加点与边的关联关系
  104. /// </summary>
  105. /// <param name="vId"></param>
  106. /// <param name="eId"></param>
  107. private void AddVERelation(string vId, string eId)
  108. {
  109. if (!VERelations.TryGetValue(vId, out List<string> list))
  110. {
  111. list = new List<string>();
  112. VERelations.Add(vId,list);
  113. }
  114. if (list.Any(c => c == eId))
  115. return;
  116. list.Add(eId);
  117. }
  118. /// <summary>
  119. /// 移除点与边的关系
  120. /// </summary>
  121. /// <param name="vId"></param>
  122. /// <param name="eId"></param>
  123. private void RemoveVERelation(string vId, string eId)
  124. {
  125. if (!VERelations.TryGetValue(vId, out List<string> list))
  126. {
  127. return;
  128. }
  129. list.Remove(eId);
  130. }
  131. /// <summary>
  132. /// 指点边关联的信息
  133. /// </summary>
  134. /// <param name="eId"></param>
  135. private void RemoveERelation( string eId)
  136. {
  137. foreach (var relation in VERelations)
  138. {
  139. if (relation.Value != null)
  140. {
  141. relation.Value.Remove(eId);
  142. }
  143. }
  144. }
  145. /// <summary>
  146. /// 移除点关联的所有边的信息
  147. /// </summary>
  148. /// <param name="vId"></param>
  149. private void RemoveVRelation(string vId)
  150. {
  151. VERelations.Remove(vId);
  152. }
  153. /// <summary>
  154. /// 获取点与边的关联关系
  155. /// </summary>
  156. /// <param name="vId"></param>
  157. /// <returns></returns>
  158. private List<string> GetVERelation(string vId)
  159. {
  160. VERelations.TryGetValue(vId, out List<string> list);
  161. return new List<string>(list ?? new List<string>());
  162. }
  163. public List<ElementsVertex> m_Vertexes;
  164. /// <summary>
  165. /// 点的集合信息
  166. /// </summary>
  167. public ReadOnlyCollection<ElementsVertex> Vertexes { get; private set; }
  168. /// <summary>
  169. /// 增加节点
  170. /// </summary>
  171. /// <param name="vertex"></param>
  172. /// <returns></returns>
  173. public ElementsVertex AddVertex(ElementsVertex vertex)
  174. {
  175. if (vertex == null)
  176. return vertex;
  177. //这里是否要自主合并,如果出现兼容点直接进行合并
  178. var existVertexes = this.GetAvailableVertexes(v =>(!string.IsNullOrEmpty(vertex.Id)&&v.Id==vertex.Id)|| v.IsMatch(vertex)).ToList();
  179. if (!existVertexes.Any())
  180. {
  181. m_Vertexes.Add((vertex));
  182. //点名称赋值
  183. vertex.Id = GenerateVertexIndex();
  184. }
  185. else if (existVertexes.Count == 1)
  186. {
  187. var exist = existVertexes[0];
  188. exist.ExtendRefElements(vertex);
  189. return exist;
  190. }
  191. else
  192. {
  193. //将多关联的信息维护到点中【原始边中的点】
  194. var newVertex= CombineVertex(existVertexes,vertex.RefData.ToList());
  195. return newVertex;
  196. }
  197. return vertex;
  198. }
  199. #endregion
  200. #region 删除节点
  201. /*
  202. * 删除节点右两种操作
  203. * 1、删除节点,把连带的边也删掉
  204. * 2、删除节点,将连带的边删除掉,给指点的点创建新边。
  205. * 新包含删除的的节点为边集合信息
  206. */
  207. /// <summary>
  208. /// 删除指定Id的节点
  209. /// </summary>
  210. /// <param name="id"></param>
  211. public void DeleteVertex(string id)
  212. {
  213. List<string> edgeIds = GetVERelation(id);
  214. RemoveVRelation(id);
  215. edgeIds.ForEach(e => {
  216. RemoveERelation(e);
  217. this.m_Edges.RemoveAll(ie=>ie.Id==e);
  218. });
  219. }
  220. /// <summary>
  221. /// 删除指定Id的节点,并把该节点关联的点直连成新的边
  222. /// </summary>
  223. /// <param name="id"></param>
  224. /// <param name="predicate">重新连接的点</param>
  225. public void DeleteVertex(string id,Predicate<string> predicate)
  226. {
  227. List<string> edgeIds = GetVERelation(id);
  228. var baseVertex = GetVertexById(id);
  229. if (baseVertex == null)
  230. return;
  231. List<Tuple<ElementsVertex, ElementsEdge>> tupleList = new List<Tuple<ElementsVertex, ElementsEdge>>();
  232. foreach (var edgeId in edgeIds)
  233. {
  234. var elementEdge = GetEdgeById(edgeId);
  235. if (elementEdge == null)
  236. continue;
  237. var otherVertex = elementEdge.GetAnotherVertex(id);
  238. if (otherVertex == null)
  239. continue;
  240. if (predicate != null && !predicate(otherVertex.Id))
  241. continue;
  242. tupleList.Add(new Tuple<ElementsVertex, ElementsEdge>(otherVertex, elementEdge));
  243. }
  244. for (int i = 0; i < tupleList.Count; i++)
  245. {
  246. var start = tupleList[i].Item1;
  247. var startElements = tupleList[i].Item2.RefData.ToList();
  248. for (int j = i+1; j < tupleList.Count; j++)
  249. {
  250. var end = tupleList[j].Item1;
  251. var endElements = tupleList[j].Item2.RefData.ToList();
  252. var newPathElments = new List<Element>(startElements);
  253. newPathElments.AddRange(baseVertex.RefData);
  254. newPathElments.AddRange(endElements);
  255. this.AddEdge(new ElementsEdge(newPathElments) { Start = start, End = end });
  256. }
  257. }
  258. DeleteVertex(id);
  259. }
  260. #endregion
  261. #region 合并点
  262. #endregion
  263. #region 边处理
  264. private List<ElementsEdge> m_Edges;
  265. /// <summary>
  266. /// 边的集合信息
  267. /// </summary>
  268. public ReadOnlyCollection<ElementsEdge> Edges { get; private set; }
  269. /// <summary>
  270. /// 增加边信息
  271. /// </summary>
  272. /// <param name="edge"></param>
  273. /// <returns></returns>
  274. public void AddEdge(ElementsEdge edge)
  275. {
  276. if (edge?.Start == null || edge.End==null)
  277. throw new ArgumentNullException(nameof(edge)+"及其关联开始结束点信息不能为null");
  278. edge.Id = GenerateEdgeIndex();
  279. edge.Start = AddVertex(edge.Start);
  280. edge.End = AddVertex(edge.End);
  281. AddVERelation(edge.Start.Id, edge.Id);
  282. AddVERelation(edge.End.Id, edge.Id);
  283. this.m_Edges.Add(edge);
  284. }
  285. #endregion
  286. private ElementsVertex CombineVertex(List<ElementsVertex> vertexs,List<Element> elements)
  287. {
  288. var refElements = vertexs.SelectMany(c => c.RefData).ToList();
  289. if (elements != null)
  290. {
  291. refElements.AddRange(elements);
  292. }
  293. refElements= refElements.Distinct(new ElementEqualityComparer()).ToList();
  294. ElementsVertex combineVertex = new ElementsVertex(refElements);
  295. this.m_Vertexes.Add(combineVertex);
  296. combineVertex.Id = GenerateVertexIndex();
  297. combineVertex.Children.AddRange(vertexs);
  298. foreach (var elementsVertex in vertexs)
  299. {
  300. var list = GetVERelation(elementsVertex.Id);
  301. list.ForEach(eid=>AddVERelation(combineVertex.Id,eid));
  302. }
  303. return combineVertex;
  304. }
  305. #region 点关联信息
  306. /// <summary>
  307. /// 获取点的连接关系
  308. /// </summary>
  309. /// <param name="baseVertex"></param>
  310. /// <param name="preVertexes"></param>
  311. /// <returns></returns>
  312. public List<Tuple<ElementsVertex, ElementsEdge>> GetNextVertexes(ElementsVertex baseVertex,
  313. List<ElementsVertex> preVertexes)
  314. {
  315. List<Tuple<ElementsVertex, ElementsEdge>> tuples=new List<Tuple<ElementsVertex, ElementsEdge>>();
  316. string baseVertexId = baseVertex.Id;
  317. var listEdges = GetVERelation(baseVertexId);
  318. var edges = this.GetAvailableEdges(e => listEdges.Any(id => id == e.Id));
  319. foreach (var edge in edges)
  320. {
  321. ElementsVertex useVertex = null;
  322. if (edge.RealStart.Id == baseVertexId)
  323. {
  324. useVertex = edge.RealEnd;
  325. }
  326. else if (edge.RealEnd.Id == baseVertexId)
  327. {
  328. useVertex = edge.RealStart;
  329. }
  330. if (useVertex == null || preVertexes.Any(v => v.Id == useVertex.Id))
  331. continue;
  332. tuples.Add(new Tuple<ElementsVertex, ElementsEdge>(useVertex,edge));
  333. }
  334. return tuples;
  335. }
  336. /// <summary>
  337. /// 获取与点关联的点
  338. /// </summary>
  339. /// <param name="baseVertex"></param>
  340. /// <param name="predicate"></param>
  341. /// <returns></returns>
  342. public List<ElementsVertex> GetRefVertexes(ElementsVertex baseVertex,
  343. Predicate<ElementsVertex> predicate)
  344. {
  345. //如果判断方向的话,在这里加一些标志,遍历过程中,和返回
  346. List<ElementsVertex> vertexes = new List<ElementsVertex>();
  347. List<ElementsVertex> opVertexes = new List<ElementsVertex>() { baseVertex };
  348. for (int i = 0; i < opVertexes.Count; i++)
  349. {
  350. var currentVertex = opVertexes[i];
  351. string baseVertexId = currentVertex.Id;
  352. var listEdges = GetVERelation(baseVertexId);
  353. var edges = this.Edges.Where(e => e.Children.Count==0&&listEdges.Any(id => id == e.Id));
  354. foreach (var edge in edges)
  355. {
  356. ElementsVertex useVertex = null;
  357. if (edge.RealStart.Id == baseVertexId)
  358. {
  359. useVertex = edge.RealEnd;
  360. }
  361. else if (edge.RealEnd.Id == baseVertexId)
  362. {
  363. useVertex = edge.RealStart;
  364. }
  365. if (useVertex == null)
  366. continue;
  367. if (vertexes.Any(v => v.Id == useVertex.Id) || opVertexes.Any(v => v.Id == useVertex.Id))
  368. continue;
  369. if (predicate == null || predicate(useVertex))
  370. {
  371. vertexes.Add(useVertex);
  372. }
  373. else
  374. {
  375. opVertexes.Add(useVertex);
  376. }
  377. }
  378. }
  379. return vertexes;
  380. }
  381. /// <summary>
  382. /// 获取到指定点的路径信息
  383. /// </summary>
  384. /// <param name="baseVertex"></param>
  385. /// <param name="predicate"></param>
  386. /// <returns></returns>
  387. public List<Tuple<ElementsVertex, List<ElementsVertex>>> GetRefVertexPaths(ElementsVertex baseVertex,
  388. Predicate<ElementsVertex> predicate)
  389. {
  390. List<Tuple<ElementsVertex, List<ElementsVertex>>> paths = new List<Tuple<ElementsVertex, List<ElementsVertex>>>();
  391. paths = GetRefVertexPaths(baseVertex, predicate, new List<ElementsVertex>());
  392. return paths;
  393. }
  394. private List<Tuple<ElementsVertex, List<ElementsVertex>>> GetRefVertexPaths(ElementsVertex baseVertex, Predicate<ElementsVertex> predicate,List<ElementsVertex> pathVertexes)
  395. {
  396. List<Tuple<ElementsVertex, List<ElementsVertex>>> result = new List<Tuple<ElementsVertex, List<ElementsVertex>>>();
  397. //路径算法总结
  398. var refVertexes = GetRefVertexes(baseVertex,null);
  399. var newPath = new List<ElementsVertex>(pathVertexes);
  400. newPath.Add(baseVertex);
  401. foreach (ElementsVertex vertex in refVertexes)
  402. {
  403. //pathVertexes使用新的path,避免出现环路错误
  404. if ( newPath.Any(v=>v.Id==vertex.Id))
  405. continue;
  406. if (predicate == null || predicate(vertex))
  407. {
  408. //结束遍历;去除第一个基础点,基础点是为了遍历控制
  409. result.Add(new Tuple<ElementsVertex, List<ElementsVertex>>(vertex, new List<ElementsVertex>(newPath.GetRange(1, newPath.Count-1))));
  410. }
  411. else
  412. {
  413. //调整path
  414. var tranPath = new List<ElementsVertex>(newPath);
  415. // tranPath.Add(vertex);
  416. result.AddRange(GetRefVertexPaths(vertex, predicate, tranPath));
  417. }
  418. }
  419. return result;
  420. }
  421. #endregion
  422. #region 边操作
  423. /// <summary>
  424. /// 移除指定边
  425. /// </summary>
  426. /// <param name="edge"></param>
  427. /// <returns></returns>
  428. public bool RemoveEdge(ElementsEdge edge)
  429. {
  430. RemoveVERelation(edge.RealStart.Id, edge.Id);
  431. RemoveVERelation(edge.RealEnd.Id, edge.Id);
  432. //this.m_Edges.RemoveAll(e => e.Id == edge.Id);
  433. return this.m_Edges.Remove(edge);
  434. }
  435. public List<string> GetEdgeIds(string vId1, string vId2)
  436. {
  437. var list1 = GetVERelation(vId1);
  438. var list2 = GetVERelation(vId2);
  439. List<string> result=new List<string>();
  440. foreach (string strId1 in list1)
  441. {
  442. foreach (string strId2 in list2)
  443. {
  444. if (strId1 == strId2)
  445. {
  446. result.Add(strId1);
  447. }
  448. }
  449. }
  450. if (result.Any())
  451. {
  452. result = result.Distinct().ToList();
  453. }
  454. return result;
  455. }
  456. /// <summary>
  457. /// 获取两点之间的点
  458. /// </summary>
  459. /// <param name="vId1"></param>
  460. /// <param name="vId2"></param>
  461. /// <returns></returns>
  462. public List<ElementsEdge> GetEdges(string vId1, string vId2)
  463. {
  464. List<ElementsEdge> edges=new List<ElementsEdge>();
  465. var ids = GetEdgeIds(vId1, vId2);
  466. edges.AddRange(this.GetAvailableEdges(e => ids.Any(id => id == e.Id)));
  467. return edges;
  468. }
  469. /// <summary>
  470. /// 获取指定点关联的边信息
  471. /// </summary>
  472. /// <param name="vId"></param>
  473. /// <returns></returns>
  474. public List<ElementsEdge> GetEdges(string vId)
  475. {
  476. List<ElementsEdge> edges = new List<ElementsEdge>();
  477. var ids = GetVERelation(vId);
  478. edges.AddRange(this.GetAvailableEdges(e => ids.Any(id => id == e.Id)));
  479. return edges;
  480. }
  481. /// <summary>
  482. /// 取指定条件的父边
  483. /// </summary>
  484. /// <param name="baseEdge"></param>
  485. /// <param name="predicate"></param>
  486. /// <returns></returns>
  487. public List<ElementsEdge> GetParentEdges(ElementsEdge baseEdge, Predicate<ElementsEdge> predicate)
  488. {
  489. List<ElementsEdge> edges = new List<ElementsEdge>();
  490. var parent = baseEdge.Parent;
  491. while(parent!=null)
  492. {
  493. if (predicate == null || predicate(parent))
  494. {
  495. edges.Add(parent);
  496. }
  497. else
  498. {
  499. break;
  500. }
  501. parent = parent.Parent;
  502. }
  503. return edges;
  504. }
  505. #endregion
  506. /// <summary>
  507. /// 整理节点连接值
  508. /// </summary>
  509. public void ArrangeVertex()
  510. {
  511. var availableEdges = this.GetAvailableEdges(null);
  512. foreach (var availableEdge in availableEdges)
  513. {
  514. availableEdge.ArrangeChildrenVertex();
  515. }
  516. }
  517. #region 逻辑处理
  518. /*
  519. * 先串联再并联,
  520. * 循环操作
  521. */
  522. /// <summary>
  523. /// 并联处理
  524. /// </summary>
  525. /// <param name="edgeArray"></param>
  526. /// <returns></returns>
  527. private static ElementEdgesArray ParallelHandle(ElementEdgesArray edgeArray)
  528. {
  529. var originEdges = edgeArray.GetAvailableEdges(null);
  530. HandledMap map = new HandledMap();
  531. for (int i = 0; i < originEdges.Count; i++)
  532. {
  533. ElementsEdge baseElementsEdge = originEdges[i];
  534. if (map.GetHandled(baseElementsEdge))
  535. continue;
  536. var refEdges = edgeArray.GetEdges(baseElementsEdge.RealStart.Id, baseElementsEdge.RealEnd.Id);
  537. if (refEdges.Count > 1)
  538. {
  539. ElementsEdge edge = new ElementsEdge(new List<Element>());
  540. edge.Start = baseElementsEdge.RealStart;
  541. edge.End = baseElementsEdge.RealEnd;
  542. edge.Children.AddRange(refEdges);
  543. edge.EdgeType = EdgeType.Parallel;
  544. edgeArray.AddEdge(edge);
  545. refEdges.ForEach(e => map.SetHandled(e.Id, true));
  546. }
  547. }
  548. return edgeArray;
  549. }
  550. /// <summary>
  551. /// 串联处理
  552. /// </summary>
  553. /// <param name="edgeArray"></param>
  554. /// <returns></returns>
  555. private static ElementEdgesArray SeriesHandle(ElementEdgesArray edgeArray)
  556. {
  557. //节点处只有一个关联变,则表示串联
  558. var originEdges = edgeArray.GetAvailableEdges(null);
  559. HandledMap map = new HandledMap();
  560. for (int i = 0; i < originEdges.Count; i++)
  561. {
  562. ElementsEdge baseElementsEdge = originEdges[i];
  563. if (map.GetHandled(baseElementsEdge))
  564. continue;
  565. var oriRefEdges = edgeArray.GetEdges(baseElementsEdge.RealStart.Id, baseElementsEdge.RealEnd.Id);
  566. if (oriRefEdges.Count > 1)
  567. continue;
  568. //在这个没有多个边的基础上,下面的next方法才有意义
  569. List<ElementsVertex> searchVertexes = new List<ElementsVertex>() { baseElementsEdge.RealStart, baseElementsEdge.RealEnd };
  570. List<ElementsEdge> useEdges = new List<ElementsEdge>() { baseElementsEdge };
  571. List<ElementsVertex> ends = new List<ElementsVertex>();//端点信息
  572. for (int j = 0; j < searchVertexes.Count; j++)
  573. {
  574. ElementsVertex baseVertex = searchVertexes[j];
  575. ElementsVertex preVertex = searchVertexes[(j + 1) % 2];
  576. var refEdges = edgeArray.GetNextVertexes(baseVertex, new List<ElementsVertex>() { preVertex });
  577. while (refEdges.Count == 1)
  578. {
  579. var tempEdge = refEdges[0].Item2;
  580. //判处已经存在的边
  581. if (tempEdge==null||map.GetHandled(tempEdge)||useEdges.Any(d=>d.Id==tempEdge.Id))
  582. break;
  583. if (j == 0)
  584. {
  585. useEdges.Insert(0, tempEdge);
  586. }
  587. else
  588. {
  589. useEdges.Add(tempEdge);
  590. }
  591. map.SetHandled(tempEdge, true);
  592. preVertex = baseVertex;// refEdges[0].Item2.GetAnotherVertex(baseVertex);
  593. //迭代基础点,不能放在上面一句
  594. baseVertex = refEdges[0].Item1;
  595. refEdges = edgeArray.GetNextVertexes(refEdges[0].Item1, new List<ElementsVertex>() { preVertex });
  596. }
  597. ends.Add(baseVertex);
  598. }
  599. if (useEdges.Count != 1)
  600. {
  601. ElementsEdge edge = new ElementsEdge(new List<Element>());
  602. edge.Start = ends[0];
  603. edge.End = ends[1];
  604. edge.Children.AddRange(useEdges);
  605. edge.EdgeType = EdgeType.Series;
  606. edgeArray.AddEdge(edge);
  607. }
  608. }
  609. return edgeArray;
  610. }
  611. /// <summary>
  612. /// 整理图形信息
  613. /// </summary>
  614. /// <param name="edgeArray"></param>
  615. /// <returns></returns>
  616. public static ElementEdgesArray ArrangeHandle(ElementEdgesArray edgeArray)
  617. {
  618. var preCount = edgeArray.GetAvailableEdges(null).Count;
  619. do
  620. {
  621. edgeArray = SeriesHandle(edgeArray);
  622. var current = edgeArray.GetAvailableEdges(null).Count;
  623. if (current == 1)
  624. break;
  625. edgeArray = ParallelHandle(edgeArray);
  626. current = edgeArray.GetAvailableEdges(null).Count;
  627. if (current == 1)
  628. break;
  629. if (current == preCount)
  630. break;
  631. preCount = current;
  632. } while (true);
  633. return edgeArray;
  634. }
  635. #endregion
  636. #region 获取关联元素
  637. /// <summary>
  638. /// 获取数组包含的element集合
  639. /// </summary>
  640. /// <returns></returns>
  641. public List<Element> GetRefElements()
  642. {
  643. List<Element> result = new List<Element>();
  644. result.AddRange(this.m_Vertexes.SelectMany(v => v.RefData));
  645. result.AddRange(this.m_Edges.SelectMany(e => e.RefData));
  646. return result.Distinct(new ElementEqualComparer()).ToList();
  647. }
  648. #endregion
  649. #region 获取路径
  650. /// <summary>
  651. /// 获取以指定元素开始到结尾的路径
  652. /// </summary>
  653. /// <param name="elementsVertex"></param>
  654. /// <returns></returns>
  655. public List<List<ElementsVertex>> GetRouted(ElementsVertex elementsVertex)
  656. {
  657. //遍历队列中如果出现已经存在的点,则视为这是一条回路,则放弃该路径
  658. List<List<ElementsVertex>> routeds =new List<List<ElementsVertex>>();
  659. var baseVertex = elementsVertex;
  660. List<ElementsVertex> newRouted = new List<ElementsVertex>();
  661. GetRouted(newRouted, baseVertex, ref routeds);
  662. return routeds;
  663. }
  664. private void GetRouted(List<ElementsVertex> routed,ElementsVertex elementsVertex,ref List<List<ElementsVertex>> allRouteds)
  665. {
  666. List<List<ElementsVertex>> routeds =allRouteds;
  667. var baseVertex = elementsVertex;
  668. //发现环路则退出
  669. if (routed.Any(c => c.Id == baseVertex.Id))
  670. {
  671. return;
  672. }
  673. var preVextex = routed.LastOrDefault();
  674. var refVertexes = GetRefVertexes(baseVertex, null);
  675. if (preVextex != null)
  676. {
  677. refVertexes.RemoveAll(v => v.Id == preVextex.Id);
  678. }
  679. var newRouted = new List<ElementsVertex>(routed);
  680. newRouted.Add(baseVertex);
  681. if (!refVertexes.Any())
  682. {
  683. routeds.Add(newRouted);
  684. }
  685. else
  686. {
  687. foreach (var refVertex in refVertexes)
  688. {
  689. GetRouted(newRouted, refVertex, ref routeds);
  690. }
  691. }
  692. }
  693. #endregion
  694. }
  695. }