public void Delete() { if (!isDirected) // irányított { for (int i = 0; i < Edges.Count;) { Edge temp = Edges[i]; Edges.RemoveAt(i); temp.DeleteEdge(); EdgeAdded(); } } else // nem irányított { for (int i = 0; i < InEdges.Count;) { Edge temp = InEdges[i]; InEdges.RemoveAt(i); temp.DeleteEdge(); EdgeAdded(); } for (int i = 0; i < OutEdges.Count;) { Edge temp = OutEdges[i]; OutEdges.RemoveAt(i); temp.DeleteEdge(); EdgeAdded(); } } this.parent.Children.Remove(this); this.Visibility = System.Windows.Visibility.Hidden; }
// Add an edge from this node to dest. If this is a cBranch type of node and it already // has an edge to dest then node edge is added and the node type is changed to fall public void AddEdgeTo(StructureNode dest) { if (BlockType != BlockTerminationType.Branch || !HasEdgeTo(dest)) { OutEdges.Add(dest); } else { //reset the type to fall if no edge was added (i.e. this edge already existed) BlockType = BlockTerminationType.FallThrough; } }
public ET ConnectTo <ET>(VertexT targetVertex) where ET : EdgeT { var ps = new[] { typeof(GraphT), typeof(VertexT), typeof(VertexT) }; var pss = new object[] { Graph, this, targetVertex }; var e = (ET)typeof(ET).GetConstructor(ps).Invoke(pss); Graph.Edges.Add(e); OutEdges.Add(e); targetVertex.InEdges.Add(e); return(e); }
/* Menentukan level (kedalaman) tiap rumah dengan DFS. * Dimulai dari NomorRumah = 1 dan level = 0. */ public static void TentukanLevel(int NomorRumah_dicari, int level, List <int> path, GraphKingdomMap graph) { foreach (var vert in graph.Vertices) { if (vert.NomorRumah == NomorRumah_dicari) { if (!path.Contains <int>(vert.NomorRumah)) { path.Add(vert.NomorRumah); } // menentukan level vert.Level = level; // cari tetangga yang belum dikunjungi graph.TryGetOutEdges(vert, out IEnumerable <DataEdge> OutEdges); int i = 0; bool DeadEnd = true; while ((i < OutEdges.Count()) && (DeadEnd)) { if (!path.Contains(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah)) { DeadEnd = false; TentukanLevel(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah, level + 1, path, graph); } else { i++; } } // jika tidak ada tentangga yang belum dikunjungi dan belum balik ke istana if (level > 0) { foreach (var edge in OutEdges) { if (edge.Target.Level < level) { level = level - 1; TentukanLevel(edge.Target.NomorRumah, level, path, graph); } } } // jika tidak ada tentangga yang belum dikunjungi dan sudah balik ke istana, berhenti else { break; } } } }
private bool AddEdgeUnchecked( NodeId source, NodeId target, BufferPointer <NodeEdgeListHeader> targetInEdges, bool isLight, bool bulkAddingTargetIncoming) { BufferPointer <NodeEdgeListHeader> outEdges = OutEdges.GetBufferPointer(source.Value); var edgeSetItem = new LinkedEdgeSetItem(source, target, isLight); int index = 0; if (!bulkAddingTargetIncoming) { ConcurrentBigSet <LinkedEdgeSetItem> .GetAddOrUpdateResult result = m_edgeSet.GetOrAdd(edgeSetItem); if (result.IsFound) { // Edge already existed return(false); } index = result.Index; } else { index = m_edgeSet.ReservedNextIndex(m_edgeSetBuffer); m_edgeSetBuffer[index] = edgeSetItem; } // Update head index for in edges and out edges int inEdgesNext = Interlocked.Exchange(ref targetInEdges.Buffer[targetInEdges.Index].FirstIndex, index); int outEdgesNext = Interlocked.Exchange(ref outEdges.Buffer[outEdges.Index].FirstIndex, index); var linkedEdgeSetItemPtr = m_edgeSetBuffer.GetBufferPointer(index); // Update next pointers linkedEdgeSetItemPtr.Buffer[linkedEdgeSetItemPtr.Index].NextTargetIncomingEdgeIndex = inEdgesNext; linkedEdgeSetItemPtr.Buffer[linkedEdgeSetItemPtr.Index].NextSourceOutgoingEdgeIndex = outEdgesNext; Interlocked.Increment(ref m_edgeCount); // Update edge counts targetInEdges.Buffer[targetInEdges.Index].InterlockedIncrementCount(); outEdges.Buffer[outEdges.Index].InterlockedIncrementCount(); return(true); }
/* Melakukan DFS dari start hingga destination ditemukan. */ public static void DFS(int startLevel, int start, int destination, List <int> route, GraphKingdomMap graph) { foreach (var vert in graph.Vertices) { // mencari NomorRumah dari daftar rumah if (vert.NomorRumah == start) { // menambahkan rumah ke rute route.Add(vert.NomorRumah); // jika rumah = destination, method berakhir if (vert.NomorRumah == destination) { break; } // cari tetangga rumah graph.TryGetOutEdges(vert, out IEnumerable <DataEdge> OutEdges); int i = 0; bool DeadEnd = true; while ((i < OutEdges.Count()) && (DeadEnd)) { // mencari tujuan yang belum pernah dikunjungi dan bukan parent dari start if ((!route.Contains(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah)) && (OutEdges.ElementAt <DataEdge>(i).Target.Level > startLevel)) { DeadEnd = false; } else { i++; } } // jika ditemukan tujuan, pindah ke tujuan if (!DeadEnd) { DFS(startLevel, OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah, destination, route, graph); } else { // jika tidak ditemukan tujuan dan belum kembali ke start if (vert.Level > startLevel) { foreach (var edge in OutEdges) { // backtrack if (edge.Target.Level < vert.Level) { DFS(startLevel, edge.Target.NomorRumah, destination, route, graph); } } } // jika tidak ditemukan tujuan dan sudah kembali ke start, berhenti else { route.RemoveAt(route.Count() - 1); break; } } } } }
public IEnumerator <T> GetEnumerator() { return(OutEdges.Select(x => x.Value).GetEnumerator()); }
/// <summary> /// These iterate from the end of the list because List.Remove is linear in /// the number of items, so callers have been optimized where possible to /// remove only the last or next-to-last edges (but in some cases such as /// rectilinear, this optimization isn't always possible). /// </summary> /// <param name="edge"></param> internal void RemoveOutEdge(VisibilityEdge edge) { OutEdges.Remove(edge); }
/// <summary> /// Does this node have an edge to dest? /// </summary> /// <param name="dest"></param> /// <returns></returns> public bool HasEdgeTo(StructureNode dest) { return(OutEdges.Contains(dest)); }
IEnumerator <IEdge> IEnumerable <IEdge> .GetEnumerator() { return(OutEdges.GetEnumerator()); }
private void AddEdge(Edge edge) { OutEdges.Add(edge); edge.TargetNode.InEdges.Add(edge); }
public ResearchNode OutResearch() { return(OutEdges.First().OutResearch()); }
public IEnumerable <ResearchNode> DirectChildren() { return(OutEdges.Select(e => e.OutResearch())); }
public override int LayoutLowerPriority() { return(OutEdges.Count()); }
public override int DefaultPriority() { return(InEdges.Count() + OutEdges.Count()); }