/// <summary> /// Insert an edge from one of the noded input graphs. /// Checks edges that are inserted to see if an /// identical edge already exists. /// If so, the edge is not inserted, but its label is merged /// with the existing edge. /// </summary> /// <param name="e"></param> protected virtual void InsertUniqueEdge(Edge e) { int foundIndex = _edgeList.FindEdgeIndex(e); // If an identical edge already exists, simply update its label if (foundIndex >= 0) { Edge existingEdge = _edgeList[foundIndex]; Label existingLabel = existingEdge.Label; Label labelToMerge = e.Label; // check if new edge is in reverse direction to existing edge // if so, must flip the label before merging it if (!existingEdge.IsPointwiseEqual(e)) { labelToMerge = new Label(e.Label); labelToMerge.Flip(); } Depth depth = existingEdge.Depth; // if this is the first duplicate found for this edge, initialize the depths if (depth.IsNull()) { depth.Add(existingLabel); } depth.Add(labelToMerge); existingLabel.Merge(labelToMerge); } else { // no matching existing edge was found // add this new edge to the list of edges in this graph _edgeList.Add(e); } }
public void TestDeleteVertex() { EdgeList expected = new EdgeList(); EdgeList real = Program.Code(); real.DeleteVertex(); expected.Add(new Tuple <int, int>(0, 1)); expected.Add(new Tuple <int, int>(1, 2)); }
public void TestRemove() { EdgeList expected = new EdgeList(); EdgeList real = Program.Code(); real.Remove(new Tuple <int, int>(3, 0)); expected.Add(new Tuple <int, int>(0, 1)); expected.Add(new Tuple <int, int>(1, 3)); expected.Add(new Tuple <int, int>(1, 2)); expected.Add(new Tuple <int, int>(3, 2)); expected.Add(new Tuple <int, int>(0, 3)); Assert.AreEqual(expected.Count, real.Count); Assert.AreEqual(expected.Contains(new Tuple <int, int>(3, 0)), real.Contains(new Tuple <int, int>(3, 0))); }
static void Main(string[] args) { var input = Console.ReadLine(); var inputArr = input.ToCharArray(); Arr = inputArr; var length = inputArr.Length; var sortEdge = new EdgeList(); for (int i = 0; i < length; i++) { var edge = new Edge(); edge.Length = i + 1; edge.Start = length - 1 - i; sortEdge.Add(edge); } var sb = new StringBuilder(); foreach (var edge in sortEdge.Storage) { sb.Append(string.Format("{0} ", length - edge.Length)); } Console.WriteLine(sb.ToString()); }
public eOperationStatus AppendEdge(int Width, int Height, int DeltaX, int DeltaY) { if (MostRecentlySelectedVertex == null) { return(eOperationStatus.NoVertexSelected); } // Add a new point int nextindex = FindNextIndex(); Vertex vP = new Vertex(); vP.Index = nextindex; vP.X = MostRecentlySelectedVertex.X + DeltaX; vP.Y = MostRecentlySelectedVertex.Y + DeltaY; VertexList.Add(vP); // Add an edge Edge oEdge = new Edge(); oEdge.Height = Height; oEdge.Width = Width; oEdge.p1 = MostRecentlySelectedVertex.Index; oEdge.p2 = vP.Index; oEdge.ID = ""; oEdge.HoleGroupID = ""; EdgeList.Add(oEdge); return(eOperationStatus.OK); }
public IEnumerable <TEdge> OutEdges(TVertex v) { IEdgeList <TVertex, TEdge> edges; if (!this.vertedEdges.TryGetValue(v, out edges)) { edges = new EdgeList <TVertex, TEdge>(); foreach (ITransitionFactory <TVertex, TEdge> transitionFactory in this.TransitionFactories) { if (!transitionFactory.IsValid(v)) { continue; } foreach (var edge in transitionFactory.Apply(v)) { if (this.SuccessorVertexPredicate(edge.Target) && this.SuccessorEdgePredicate(edge)) { edges.Add(edge); } } } this.vertedEdges[v] = edges; } return(edges); }
public int RemoveOutEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate) { GraphContracts.AssumeInVertexSet(this, v, "v"); GraphContracts.AssumeNotNull(predicate, "predicate"); EdgeList edges = this.vertexEdges[v]; EdgeList edgeToRemove = new EdgeList(edges.Count); foreach (TEdge edge in edges) { if (predicate(edge)) { edgeToRemove.Add(edge); } } foreach (TEdge edge in edgeToRemove) { edges.Remove(edge); this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge)); } this.edgeCount -= edgeToRemove.Count; GraphContracts.Assert(this.edgeCount >= 0); return(edgeToRemove.Count); }
/// <summary> /// Inserted edges are checked to see if an identical edge already exists. /// If so, the edge is not inserted, but its label is merged /// with the existing edge. /// </summary> /// <param name="e"></param> protected void InsertEdge(Edge e) { //<FIX> MD 8 Oct 03 speed up identical edge lookup // fast lookup Edge existingEdge = edgeList.FindEqualEdge(e); // If an identical edge already exists, simply update its label if (existingEdge != null) { Label existingLabel = existingEdge.Label; Label labelToMerge = e.Label; // check if new edge is in reverse direction to existing edge // if so, must flip the label before merging it if (!existingEdge.IsPointwiseEqual(e)) { labelToMerge = new Label(e.Label); labelToMerge.Flip(); } existingLabel.Merge(labelToMerge); // compute new depth delta of sum of edges int mergeDelta = DepthDelta(labelToMerge); int existingDelta = existingEdge.DepthDelta; int newDelta = existingDelta + mergeDelta; existingEdge.DepthDelta = newDelta; } else { // no matching existing edge was found // add this new edge to the list of edges in this graph //e.setName(name + edges.size()); edgeList.Add(e); e.DepthDelta = DepthDelta(e.Label); } }
// Add a new line into the simple layout struct, new vertices and a new edge public void AddEdge(PointF WorldFrom, PointF WorldTo, int Width, int Height) { int nextindex = FindNextIndex(); Vertex vP1 = new Vertex(); vP1.Index = nextindex++; vP1.X = WorldFrom.X; vP1.Y = WorldFrom.Y; VertexList.Add(vP1); Vertex vP2 = new Vertex(); vP2.Index = nextindex++; vP2.X = WorldTo.X; vP2.Y = WorldTo.Y; VertexList.Add(vP2); // Now add a segment Edge oEdge = new Edge(); oEdge.Height = 30; oEdge.Width = 10; oEdge.p1 = vP1.Index; oEdge.p2 = vP2.Index; oEdge.ID = ""; oEdge.HoleGroupID = ""; EdgeList.Add(oEdge); }
/// <summary> /// Delete all vertexes and edges that have no <see cref="Part"/> associated with them. /// </summary> public void DeleteArtificialVertexes() { VertexList dummies = new VertexList(); foreach (V n in this.Vertexes) { if (n.Node == null) { dummies.Add(n); } } foreach (V n in dummies) { DeleteVertex(n); } EdgeList dummies2 = new EdgeList(); foreach (E l in this.Edges) { if (l.Link == null) { dummies2.Add(l); } } foreach (E l in dummies2) { DeleteEdge(l); } }
/// <inheritdoc /> public IEnumerable <TEdge> OutEdges(TVertex vertex) { if (vertex == null) { throw new ArgumentNullException(nameof(vertex)); } if (!_verticesEdgesCache.TryGetValue(vertex, out IEdgeList <TVertex, TEdge> edges)) { edges = new EdgeList <TVertex, TEdge>(); foreach (ITransitionFactory <TVertex, TEdge> transitionFactory in TransitionFactories) { if (!transitionFactory.IsValid(vertex)) { continue; } foreach (TEdge edge in transitionFactory.Apply(vertex)) { if (SuccessorVertexPredicate(edge.Target) && SuccessorEdgePredicate(edge)) { edges.Add(edge); } } } _verticesEdgesCache[vertex] = edges; } return(edges); }
public eOperationStatus AddHoleInMostRecentlySelectedEdge(int Width) { if (EdgeList.Count == 0) { return(eOperationStatus.NoEdgesDefined); } if (MostRecentlySelectedEdge == null) { return(eOperationStatus.NoEdgeSelected); } double thisEdgeLength = EdgeLength(MostRecentlySelectedEdge); if (Width >= thisEdgeLength) { return(eOperationStatus.EdgeNotWideEnoughForOperation); } // Determine the interpolations based on the width and length float WidthPercent = (float)(Width / thisEdgeLength); Vertex v1 = FindVertexFromIndex(MostRecentlySelectedEdge.p1); Vertex v2 = FindVertexFromIndex(MostRecentlySelectedEdge.p2); /* * Create vectors of the end points */ SVector2 f = new SVector2(v1.X, v1.Y); SVector2 t = new SVector2(v2.X, v2.Y); // Find a new end point and add a vertex for it float lowpercent = (float).5 - WidthPercent; SVector2 LowPartVector = SVector2.Interpolate(f, t, lowpercent); Vertex vNew1 = NewVertex(LowPartVector.X, LowPartVector.Y); // Create a new edge and add it Edge newEdge = new Edge(); newEdge.Width = MostRecentlySelectedEdge.Width; newEdge.Height = MostRecentlySelectedEdge.Height; newEdge.ID = ""; newEdge.HoleGroupID = ""; newEdge.p1 = MostRecentlySelectedEdge.p1; newEdge.p2 = vNew1.Index; EdgeList.Add(newEdge); // Add a new vertex for the other position on the other side of the hole float highpercent = (float).5 + WidthPercent; SVector2 HighPartVector = SVector2.Interpolate(f, t, highpercent); Vertex vNew2 = NewVertex(HighPartVector.X, HighPartVector.Y); // Modify the currently selected edge so that it starts at the vnew2 MostRecentlySelectedEdge.p1 = vNew2.Index; return(eOperationStatus.OK); }
public bool TryGetPath( TVertex source, TVertex target, out IEnumerable <TEdge> path) { Contract.Requires(source != null); Contract.Requires(target != null); if (source.Equals(target)) { path = null; return(false); } var edges = new EdgeList <TVertex, TEdge>(); var todo = new Stack <SEquatableEdge <TVertex> >(); todo.Push(new SEquatableEdge <TVertex>(source, target)); while (todo.Count > 0) { var current = todo.Pop(); Contract.Assert(!current.Source.Equals(current.Target)); VertexData data; if (this.data.TryGetValue(current, out data)) { TEdge edge; if (data.TryGetEdge(out edge)) { edges.Add(edge); } else { TVertex intermediate; if (data.TryGetPredecessor(out intermediate)) { todo.Push(new SEquatableEdge <TVertex>(intermediate, current.Target)); todo.Push(new SEquatableEdge <TVertex>(current.Source, intermediate)); } else { Contract.Assert(false); path = null; return(false); } } } else { // no path found path = null; return(false); } } Contract.Assert(todo.Count == 0); Contract.Assert(edges.Count > 0); path = edges.ToArray(); return(true); }
public void addEdge(int firstVertexId, int secondVertexId, int capacity, bool ignore) { Vertex first = getVertex(firstVertexId, VertexList); Vertex second = getVertex(secondVertexId, VertexList); int weight = 1000000 / capacity; Edge created = new Edge(firstVertexId, secondVertexId, weight, capacity, first, second, false, ignore); EdgeList.Add(created); }
public void TestGetIncidentEdges() { EdgeList expected = new EdgeList(); EdgeList real = Program.Code().GetIncidentEdges(3); real.Remove(new Tuple <int, int>(3, 0)); expected.Add(new Tuple <int, int>(3, 2)); Assert.AreEqual(expected.Count, real.Count); }
private bool TryGetPathInternal( [NotNull] TVertex source, [NotNull] TVertex target, out IEnumerable <TEdge> path) { #if DEBUG && !NET20 var set = new HashSet <TVertex> { source, target }; #endif var edges = new EdgeList <TVertex, TEdge>(); var todo = new Stack <SEquatableEdge <TVertex> >(); todo.Push(new SEquatableEdge <TVertex>(source, target)); while (todo.Count > 0) { SEquatableEdge <TVertex> current = todo.Pop(); Debug.Assert(!current.Source.Equals(current.Target)); if (_data.TryGetValue(current, out VertexData data)) { if (data.TryGetEdge(out TEdge edge)) { edges.Add(edge); } else { if (data.TryGetPredecessor(out TVertex intermediate)) { #if DEBUG && !NET20 Debug.Assert(set.Add(intermediate)); #endif todo.Push(new SEquatableEdge <TVertex>(intermediate, current.Target)); todo.Push(new SEquatableEdge <TVertex>(current.Source, intermediate)); } else { throw new InvalidOperationException("Cannot find predecessor."); } } } else { // No path found path = null; return(false); } } Debug.Assert(todo.Count == 0); Debug.Assert(edges.Count > 0); path = edges; return(true); }
public virtual bool RemoveVertex(TVertex v) { GraphContracts.AssumeNotNull(v, "v"); if (!this.ContainsVertex(v)) { return(false); } // remove outedges { EdgeList edges = this.vertexEdges[v]; if (this.EdgeRemoved != null) // lazily notify { foreach (TEdge edge in edges) { this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge)); } } this.edgeCount -= edges.Count; edges.Clear(); } // iterage over edges and remove each edge touching the vertex EdgeList edgeToRemove = new EdgeList(); foreach (KeyValuePair <TVertex, EdgeList> kv in this.vertexEdges) { if (kv.Key.Equals(v)) { continue; // we've already } // collect edge to remove foreach (TEdge edge in kv.Value) { if (edge.Target.Equals(v)) { edgeToRemove.Add(edge); } } // remove edges foreach (TEdge edge in edgeToRemove) { kv.Value.Remove(edge); this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge)); } // update count this.edgeCount -= edgeToRemove.Count; edgeToRemove.Clear(); } System.Diagnostics.Debug.Assert(this.edgeCount >= 0); this.vertexEdges.Remove(v); this.OnVertexRemoved(new VertexEventArgs <TVertex>(v)); return(true); }
private void insertVertexToSameSenseEdge(Face Fa, int Bounds, int Edge, Vertex3d V) { EdgeLoop EL = Fa.Bounds[Bounds]; Edge E = EL[Edge]; Face Neigbhbor = null; int outloop = -1; double d = Face.GetDualEdge(Fa, Bounds, Edge + 0.5, ref outloop, ref Neigbhbor); EdgeLoop DualEL = Neigbhbor.Bounds[outloop]; int DualEdge = (int)d; Edge F = DualEL[DualEdge]; // Zuerst die neue Kante Edge NewEdge = new Edge(); EdgeList.Add(NewEdge); NewEdge.SameSense = true; NewEdge.EdgeStart = E.EdgeStart; NewEdge.EdgeEnd = V; Line3D L = new Line3D(NewEdge.EdgeStart.Value, V.Value); EdgeCurveList.Add(L); L.Neighbors = new Face[2]; L.Neighbors[0] = E.EdgeCurve.Neighbors[0]; L.Neighbors[1] = E.EdgeCurve.Neighbors[1]; NewEdge.EdgeCurve = L; VertexList.Add(V); E.EdgeStart = V; E.EdgeCurve.A = V.Value; EL.Insert(Edge, NewEdge); // Duale NewEdge = new Edge(); NewEdge.SameSense = false; EdgeList.Add(NewEdge); if (DualEdge + 1 < DualEL.Count) { DualEL.Insert(DualEdge + 1, NewEdge); } else { DualEL.Insert(0, NewEdge); } NewEdge.EdgeStart = V; NewEdge.EdgeEnd = F.EdgeEnd; F.EdgeEnd = V; NewEdge.EdgeCurve = L; }
public virtual bool RemoveVertex(TVertex v) { if (!this.ContainsVertex(v)) { return(false); } // remove outedges { var edges = this.vertexEdges[v]; if (this.EdgeRemoved != null) // lazily notify { foreach (var edge in edges) { this.OnEdgeRemoved(edge); } } this.edgeCount -= edges.Count; edges.Clear(); } // iterage over edges and remove each edge touching the vertex var edgeToRemove = new EdgeList <TVertex, TEdge>(); foreach (var kv in this.vertexEdges) { if (kv.Key.Equals(v)) { continue; // we've already } // collect edge to remove foreach (var edge in kv.Value) { if (edge.Target.Equals(v)) { edgeToRemove.Add(edge); } } // remove edges foreach (var edge in edgeToRemove) { kv.Value.Remove(edge); this.OnEdgeRemoved(edge); } // update count this.edgeCount -= edgeToRemove.Count; edgeToRemove.Clear(); } Contract.Assert(this.edgeCount >= 0); this.vertexEdges.Remove(v); this.OnVertexRemoved(v); return(true); }
public eOperationStatus SplitMostRecentlySelectedEdge(float RelativeDistance) { if (EdgeList.Count == 0) { return(eOperationStatus.NoEdgesDefined); } if (MostRecentlySelectedEdge == null) { return(eOperationStatus.NoEdgeSelected); } Vertex v1 = FindVertexFromIndex(MostRecentlySelectedEdge.p1); Vertex v2 = FindVertexFromIndex(MostRecentlySelectedEdge.p2); SVector2 f = new SVector2(v1.X, v1.Y); SVector2 t = new SVector2(v2.X, v2.Y); SVector2 interpolatedVector = SVector2.Interpolate(f, t, RelativeDistance); /* * Get the point at the at this distance mark */ PointF InterpolatedPoint = new PointF(interpolatedVector.X, interpolatedVector.Y); // Add the interpolated point as a new vertex Vertex vInterpolated = new Vertex(); vInterpolated.Index = FindNextIndex(); vInterpolated.X = InterpolatedPoint.X; vInterpolated.Y = InterpolatedPoint.Y; VertexList.Add(vInterpolated); // Create a new edge with two points, the interpolated point and the current p2 Edge newEdge = new Edge(); newEdge.Width = MostRecentlySelectedEdge.Width; newEdge.Height = MostRecentlySelectedEdge.Height; newEdge.ID = ""; newEdge.HoleGroupID = ""; newEdge.p1 = vInterpolated.Index; newEdge.p2 = MostRecentlySelectedEdge.p2; EdgeList.Add(newEdge); // update the current edge, set its 'p2' point to the interpolated point. This will trim it // Also, clear out any holes, the split edge requires a reset MostRecentlySelectedEdge.p2 = vInterpolated.Index; MostRecentlySelectedEdge.HoleGroupID = ""; return(eOperationStatus.OK); }
public virtual bool RemoveVertex(TVertex v) { GraphContracts.AssumeNotNull(v, "v"); if (!this.ContainsVertex(v)) { return(false); } // collect edges to remove EdgeList edgesToRemove = new EdgeList(); foreach (TEdge outEdge in this.OutEdges(v)) { this.vertexInEdges[outEdge.Target].Remove(outEdge); edgesToRemove.Add(outEdge); } foreach (TEdge inEdge in this.InEdges(v)) { // might already have been removed if (this.vertexOutEdges[inEdge.Source].Remove(inEdge)) { edgesToRemove.Add(inEdge); } } // notify users if (this.EdgeRemoved != null) { foreach (TEdge edge in edgesToRemove) { this.OnEdgeRemoved(new EdgeEventArgs <TVertex, TEdge>(edge)); } } this.vertexOutEdges.Remove(v); this.vertexInEdges.Remove(v); this.edgeCount -= edgesToRemove.Count; this.OnVertexRemoved(new VertexEventArgs <TVertex>(v)); GraphContracts.Assert(this.edgeCount >= 0); return(true); }
public void AddEdge(Vertex a, Vertex b) { Edge edga = new Edge(a, b); //Edge edgb = new Edge(b,a); //if (!EdgeList.Contains(edga) && !EdgeList.Contains(edgb)) //{ EdgeList.Add(edga); //} }
public static EdgeList ToEdges(BipartiteGraph g, List <GraphNode> cycle) { var elist = new EdgeList(); for (int i = 1; i < cycle.Count; i++) { Edge edg = g.Edges.FindByNodes(cycle[cycle.Count - i], cycle[cycle.Count - i - 1]); elist.Add(edg); } return(elist); }
/// <inheritdoc /> public virtual bool RemoveVertex(TVertex vertex) { if (!ContainsVertex(vertex)) { return(false); } // Collect edges to remove var edgesToRemove = new EdgeList <TVertex, TEdge>(); foreach (TEdge outEdge in OutEdges(vertex)) { _vertexInEdges[outEdge.Target].Remove(outEdge); edgesToRemove.Add(outEdge); } foreach (TEdge inEdge in InEdges(vertex)) { // Might already have been removed if (_vertexOutEdges[inEdge.Source].Remove(inEdge)) { edgesToRemove.Add(inEdge); } } // Notify users if (EdgeRemoved != null) { foreach (TEdge edge in edgesToRemove) { OnEdgeRemoved(edge); } } _vertexOutEdges.Remove(vertex); _vertexInEdges.Remove(vertex); EdgeCount -= edgesToRemove.Count; OnVertexRemoved(vertex); return(true); }
public virtual bool RemoveVertex(TVertex v) { if (!this.ContainsVertex(v)) { return(false); } // collect edges to remove var edgesToRemove = new EdgeList <TVertex, TEdge>(); foreach (var outEdge in this.OutEdges(v)) { this.vertexInEdges[outEdge.Target].Remove(outEdge); edgesToRemove.Add(outEdge); } foreach (var inEdge in this.InEdges(v)) { // might already have been removed if (this.vertexOutEdges[inEdge.Source].Remove(inEdge)) { edgesToRemove.Add(inEdge); } } // notify users if (this.EdgeRemoved != null) { foreach (TEdge edge in edgesToRemove) { this.OnEdgeRemoved(edge); } } this.vertexOutEdges.Remove(v); this.vertexInEdges.Remove(v); this.edgeCount -= edgesToRemove.Count; this.OnVertexRemoved(v); return(true); }
/// <summary> /// Deletes all <see cref="Edge"/>s whose "to vertex" and "from vertex" are the same vertex. /// </summary> public void DeleteSelfEdges() { EdgeList deleteList = new EdgeList(); foreach (E link in this.Edges) { if (link.FromVertex == link.ToVertex) { deleteList.Add(link); } } for (int i = 0; i < deleteList.Count; i++) { DeleteEdge(deleteList[i]); } }
internal void DeleteUselessEdges() { EdgeList deleteList = new EdgeList(); foreach (E link in this.Edges) { if (link.FromVertex == null || link.ToVertex == null) { deleteList.Add(link); } } for (int i = 0; i < deleteList.Count; i++) { DeleteEdge(deleteList[i]); } }
public int RemoveInEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate) { var edges = new EdgeList <TVertex, TEdge>(); foreach (var edge in this.InEdges(v)) { if (predicate(edge)) { edges.Add(edge); } } foreach (var edge in edges) { this.RemoveEdge(edge); } return(edges.Count); }
public eOperationStatus AppendEdge(int Width, int Height, int DeltaX, int DeltaY) { if (MostRecentlySelectedLayer == null) { return(eOperationStatus.NoLayerSelected); } eOperationStatus sts = MostRecentlySelectedLayer.AppendEdge(Width, Height, DeltaX, DeltaY); if (sts != eOperationStatus.OK) { return(sts); } #if false if (MostRecentlySelectedVertex == null) { return(eOperationStatus.NoVertexSelected); } // Add a new point int nextindex = FindNextIndex(); Vertex vP = new Vertex(); vP.Index = nextindex; vP.X = MostRecentlySelectedVertex.X + DeltaX; vP.Y = MostRecentlySelectedVertex.Y + DeltaY; VertexList.Add(vP); // Add an edge Edge oEdge = new Edge(); oEdge.Height = Height; oEdge.Width = Width; oEdge.p1 = MostRecentlySelectedVertex.Index; oEdge.p2 = vP.Index; oEdge.ID = ""; oEdge.HoleGroupID = ""; EdgeList.Add(oEdge); #endif // Redraw shapes DrawShapes(); return(eOperationStatus.OK); }
public void TestAddByIndex() { EdgeList expected = new EdgeList(); EdgeList real = Program.Code(); real.AddByIndex(1, new Edge(new Tuple <int, int>(0, 0))); expected.Add(new Tuple <int, int>(0, 1)); expected.Add(new Tuple <int, int>(0, 0)); expected.Add(new Tuple <int, int>(3, 0)); expected.Add(new Tuple <int, int>(1, 3)); expected.Add(new Tuple <int, int>(1, 2)); expected.Add(new Tuple <int, int>(3, 2)); expected.Add(new Tuple <int, int>(0, 3)); Assert.AreEqual(expected.Count, real.Count); Assert.AreEqual(expected.GetEdge(1).Data.Item1, real.GetEdge(1).Data.Item1); }
private static List<List<string>> GetStraight(MatrixWithHeaders matrixWithHeaders) { Dictionary<object, IEnumerable<IEdge<object>>> vertexEdges = new Dictionary<object, IEnumerable<IEdge<object>>>(); BidirectionalGraph<object, IEdge<object>> graph = Graph.AdjacentyMatrixToGraph(matrixWithHeaders) as BidirectionalGraph<object, IEdge<object>>; List<List<string>> straight = new List<List<string>>(); EdgeList<string, Edge<string>> candidates = new EdgeList<string, Edge<string>>(); var matrix = matrixWithHeaders.Matrix; var headers = matrixWithHeaders.Headers; var vertexes = graph.Vertices; foreach (var item in vertexes) { var inEdges = graph.InEdges(item); var outEdges = graph.OutEdges(item); if (inEdges.Count() == 1 && outEdges.Count() == 1) { candidates.Add(new Edge<string>(inEdges.ElementAt(0).Source.ToString(), inEdges.ElementAt(0).Target.ToString())); candidates.Add(new Edge<string>(outEdges.ElementAt(0).Source.ToString(), outEdges.ElementAt(0).Target.ToString())); } } for (int x = candidates.Count() - 1; x > 0; x--) { if (candidates[x - 1].Source == candidates[x].Source && candidates[x - 1].Target == candidates[x].Target) { candidates.RemoveAt(x); } } for (int x = 0; x < candidates.Count; x++) { for (int y = x + 1; y < candidates.Count; y++) { IEdge<object> edge = null; graph.TryGetEdge(candidates[x].Source, candidates[y].Target, out edge); if (edge != null) { var existItems = candidates.Select(z => z.Source == edge.Source.ToString() && z.Target == edge.Target.ToString()).ToList(); bool exist = false; foreach (var item in existItems) { exist = exist || item; } if (exist == false) { List<string> tempList = new List<string>(); for (int z = x; z <= y; z++) { if (tempList.Contains(candidates[z].Source) == false) { tempList.Add(candidates[z].Source); } if (tempList.Contains(candidates[z].Target) == false) { tempList.Add(candidates[z].Target); } } straight.Add(tempList); } } } } return straight; }