private void runRelaxTest(BidirectionalGraph <MyVertex, MyEdge> g, List <MyVertex> verts, List <MyEdge> edges) { g.AddVertexRange(verts); g.AddEdgeRange(edges); var relaxer = new BasicForceRelaxer <MyVertex, MyEdge>(g); relaxer.Reset(); engine.AddSimulator(new BasicSimulator(delegate { for (int i = 0; i < 10; i++) { relaxer.Relax(TW.Graphics.Elapsed); } foreach (var n in g.Vertices) { TW.Graphics.LineManager3D.AddCenteredBox(n.Position, 1, n.Color); } foreach (var e in g.Edges) { TW.Graphics.LineManager3D.AddLine(e.Source.Position, e.Source.Color, e.Target.Position, e.Target.Color); } })); }
public void TransitiveClosure_IsolatedVertices() { const string vertex1 = "/test"; const string vertex2 = "/test/123"; const string vertex3 = "/test/456"; const string vertex4 = "/test/notlinked"; var edge12 = new EquatableEdge <string>(vertex1, vertex2); var edge23 = new EquatableEdge <string>(vertex2, vertex3); var graph = new BidirectionalGraph <string, EquatableEdge <string> >(); graph.AddVertexRange(new[] { vertex1, vertex2, vertex3, vertex4 }); graph.AddEdgeRange(new[] { edge12, edge23 }); BidirectionalGraph <string, EquatableEdge <string> > result = graph.ComputeTransitiveClosure((u, v) => new EquatableEdge <string>(u, v)); AssertHasVertices(result, new[] { vertex1, vertex2, vertex3, vertex4 }); AssertHasEdges( result, new[] { edge12, new EquatableEdge <string>(vertex1, vertex3), edge23 }); }
public List <BidirectionalGraph <string, Edge <string> > > GetDatabaseConnectedComponents(BidirectionalGraph <string, Edge <string> > graph) { IncrementalConnectedComponentsAlgorithm <string, Edge <string> > a = new IncrementalConnectedComponentsAlgorithm <string, Edge <string> >(graph as IMutableVertexAndEdgeSet <string, Edge <string> >); a.Compute(); KeyValuePair <int, IDictionary <string, int> > components = a.GetComponents(); List <BidirectionalGraph <string, Edge <string> > > connectedComponents = new List <BidirectionalGraph <string, Edge <string> > >(components.Key); var grouped = components.Value.GroupBy(t => t.Value); foreach (var group in grouped) { BidirectionalGraph <string, Edge <string> > g = new BidirectionalGraph <string, Edge <string> >(true, group.Count()); foreach (var item in group) { g.AddVertex(item.Key); } foreach (var item in g.Vertices) { g.AddEdgeRange(graph.OutEdges(item)); } connectedComponents.Add(g); } return(connectedComponents); }
private void OnClickMenuOpen(object sender, RoutedEventArgs e) { var newGraph = new BidirectionalGraph <object, IEdge <object> >(); var filePath = SimpleFileDialog.Show(); if (filePath == null) { return; } try { _fileTool = new FileTool(filePath); _fileTool.OpenFile(); newGraph.AddVertexRange(_fileTool.GenerateVertexes()); newGraph.AddEdgeRange(_fileTool.GenerateEdges()); MainGraphLayout.Graph = newGraph; } catch (KeyNotFoundException) { ShowError("Key for edge not found!"); } catch (Exception) { ShowError("Unknown exception!"); } }
private static TGraph GenerateGroupGraph(ICollection <TVertex> vertices, ICollection <TEdge> edges) { var graph = new BidirectionalGraph <TVertex, TEdge>(true, vertices.Count, edges.Count); graph.AddVertexRange(vertices); graph.AddEdgeRange(edges); return((TGraph)(object)graph); }
private static BidirectionalGraph <object, IEdge <object> > TypeGraph(PreparedMetricsReport metrics) { var graph = new BidirectionalGraph <object, IEdge <object> >(false); graph.AddVertexRange(metrics.Report.TypeGraph.Vertices.Select(v => v.FullName)); graph.AddEdgeRange(metrics.Report.TypeGraph.Edges.Select(e => new Edge <object>(e.Item1.FullName, e.Item2.FullName))); return(graph); }
private void FillGraph() { var graph = new BidirectionalGraph <object, IEdge <object> >(false); graph.AddVertexRange(cycle.Namespaces); graph.AddEdgeRange( from namespaceInCycle in cycle.Namespaces from outOfNamespaceReference in cycle.TypesReferencingOutOf(namespaceInCycle) select new Edge <object>(namespaceInCycle, outOfNamespaceReference.TargetNamespace.Name)); Graph = graph; }
private void UpdateGraph(TypeCycle cycle) { var graph = new BidirectionalGraph <object, IEdge <object> >(false); graph.AddVertexRange(cycle.TypesInCycle.Select(t => t.DisplayName)); graph.AddEdgeRange( from type in cycle.TypesInCycle from referencedType in type.ReferencedTypes select new Edge <object>(referencedType.Source, referencedType.Target)); Graph = graph; Changed(() => Graph); }
public BidirectionalGraph <Resource.Resource, AssociationViewEdge> CreateResourceLoadGraph() { var resourceModel = _resourceModelProvider.GetResourceModel(); var resourceGraph = new BidirectionalGraph <Resource.Resource, AssociationViewEdge>(); var resources = resourceModel.GetAllResources() .Where(r => !r.IsAbstract() && !r.FullName.IsEdFiSchoolYearType()) .ToArray(); resourceGraph.AddVertexRange(resources); var edges = resources // Abstract resources are already covered by their concrete resources in the model .Where(res => !res.IsAbstract()) // Add edges for all references (incoming associations) and descriptor usages .SelectMany( res => // Add all incoming reference in the entire resource res.AllContainedReferences.SelectMany(AssociationViewEdge.CreateEdges) // Add direct descriptor associations .Concat( res.AllContainedItemTypesOrSelf.SelectMany( rc => rc.Properties.Where(p => p.IsDirectLookup) .Select( p => new AssociationViewEdge( p.DescriptorResource, p.Parent.ResourceRoot, p.EntityProperty.IncomingAssociations.Single()))))) // Eliminate redundant edges .Distinct(AssociationViewEdge.Comparer); resourceGraph.AddEdgeRange(edges.Where(e => !e.Source.FullName.IsEdFiSchoolYearType())); // Apply predefined graph transformations if (_graphTransformers.Any()) { foreach (var graphTransformer in _graphTransformers) { graphTransformer.Transform(resourceGraph); } } resourceGraph.BreakCycles(edge => edge.AssociationView.IsSoftDependency); return(resourceGraph); }
public ActionGraph(IEngineConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } var graph = new BidirectionalGraph <IAction, Edge <IAction> >(false); graph.AddVertexRange(config.Actions); var edges = config.Links.Select(x => new Edge <IAction>(x.From, x.To)); graph.AddEdgeRange(edges); _graph = graph; }
public static IImmutableBidirectionalGraph <TVertex, TVertexId, TEdge, TEdgeId> Create( IImmutableSet <TVertex> vertices, IImmutableSet <TEdge> edges, bool allowParallelEdges = false) { var vertexDictionary = vertices.ToImmutableDictionary(i => i.Id); var edgeDictionary = edges.ToImmutableDictionary(i => i.Id); var graph = new BidirectionalGraph <TVertexId, VertexIdEdge <TVertexId, TEdgeId> >(allowParallelEdges); graph.AddVertexRange(vertexDictionary.Keys); graph.AddEdgeRange(edges.Select(ToVertexIdEdge)); return(CreateInstance(vertexDictionary, edgeDictionary, graph)); }
public static BidirectionalGraph <TVertex, TEdge> CopyToBidirectionalGraph <TVertex, TEdge>( [NotNull] this IVertexAndEdgeListGraph <TVertex, TEdge> graph) where TEdge : IEdge <TVertex> { if (graph is null) { throw new ArgumentNullException(nameof(graph)); } var newGraph = new BidirectionalGraph <TVertex, TEdge>(); newGraph.AddVertexRange(graph.Vertices); newGraph.AddEdgeRange(graph.Edges); return(newGraph); }
private void UpdateGraph(Graph <VertexBase> newGraph) { var graph = new BidirectionalGraph <VisualVertex, VisualEdge>(); var vertexDict = newGraph.NameVertexDictionary.ToDictionary(kvp => kvp.Key, kvp => new VisualVertex(kvp.Value)); graph.AddVertexRange(vertexDict.Values); graph.AddEdgeRange(newGraph.Edges.Select(edge => new VisualEdge(edge, vertexDict))); ShowAllEdgesArrows(newGraph.IsDirected); ClearLayout(); GenerateGraph(graph); if (Parent is ZoomControl zoomControl) { zoomControl.ZoomToFill(); } }
public static BidirectionalGraph <TVertex, TEdge> CopyToBidirectionalGraph <TVertex, TEdge>( this IVertexAndEdgeListGraph <TVertex, TEdge> graph, bool includeEmpty = true) where TEdge : IEdge <TVertex> { var newGraph = new BidirectionalGraph <TVertex, TEdge>(); //copy the vertices if (!includeEmpty) { newGraph.AddVerticesAndEdgeRange(graph.Edges); } else { newGraph.AddVertexRange(graph.Vertices); newGraph.AddEdgeRange(graph.Edges); } return(newGraph); }
/// <summary> /// Generates the change graph. /// </summary> /// <returns>A graph representation of the interaction between resources during the update.</returns> public BidirectionalGraph <IChangeVertex, TaggedEdge <IChangeVertex, string> > GenerateChangeGraph() { var parameters = new List <ParameterVertex>(); var direct = new DirectModificationVertex(); var resourceVertices = this.Changes.Select(ResourceVertex.Create).ToList(); var edges = new List <TaggedEdge <IChangeVertex, string> >(); var graph = new BidirectionalGraph <IChangeVertex, TaggedEdge <IChangeVertex, string> >(); graph.Clear(); // Create edge list foreach (var resource in resourceVertices) { foreach (var detail in resource.Change.ResourceChange.Details) { var edgeName = detail.Target.Name ?? detail.Target.Attribute.Value; if (detail.ChangeSource == ChangeSource.ParameterReference) { // Value of stack parameter has changed var param = parameters.FirstOrDefault(p => p.Name == detail.CausingEntity); if (param == null) { param = new ParameterVertex(detail.CausingEntity); parameters.Add(param); } edges.Add(new TaggedEdge <IChangeVertex, string>(param, resource, edgeName)); } if (detail.ChangeSource == ChangeSource.DirectModification && detail.Evaluation == EvaluationType.Static) { // User directly modified a property edges.Add(new TaggedEdge <IChangeVertex, string>(direct, resource, edgeName)); } if (detail.ChangeSource == ChangeSource.ResourceReference) { // Change via Ref to another resource var causingEntity = resourceVertices.First(r => r.Name == detail.CausingEntity); edges.Add(new TaggedEdge <IChangeVertex, string>(causingEntity, resource, edgeName)); } if (detail.ChangeSource == ChangeSource.ResourceAttribute) { // Change via GetAtt from another resource var causingEntity = resourceVertices.First( r => r.Name == detail.CausingEntity.Split('.').First()); edges.Add(new TaggedEdge <IChangeVertex, string>(causingEntity, resource, edgeName)); } } } if (edges.Any(e => e.Source.GetType() == typeof(DirectModificationVertex))) { graph.AddVertex(direct); } graph.AddVertexRange(parameters); graph.AddVertexRange(resourceVertices); graph.AddEdgeRange(edges); return(graph); }
public List <BidirectionalGraph <Word, Edge <Word> > > GetDatabaseConnectedComponents() { BidirectionalGraph <Word, Edge <Word> > graph = new BidirectionalGraph <Word, Edge <Word> >(true); //C vertexs foreach (var item in DBHelper._DictBase.CUDictbase.CtoU) { graph.AddVertex(DBHelper._DictBase.GetCWordByID(item.Key)); } //U vertexs foreach (var item in DBHelper._DictBase.CUDictbase.UtoC) { graph.AddVertex(DBHelper._DictBase.GetUWordByID(item.Key)); } //K vertexs foreach (var item in DBHelper._DictBase.CKDictbase.KtoC) { graph.AddVertex(DBHelper._DictBase.GetKWordByID(item.Key)); } //add C to U edges foreach (var item in DBHelper._DictBase.CUDictbase.CtoU) { foreach (var item2 in item.Value) { graph.AddEdge(new Edge <Word>(DBHelper._DictBase.GetCWordByID(item.Key), DBHelper._DictBase.GetUWordByID(item2))); } } //add C to K edges foreach (var item in DBHelper._DictBase.CKDictbase.CtoK) { foreach (var item2 in item.Value) { graph.AddEdge(new Edge <Word>(DBHelper._DictBase.GetCWordByID(item.Key), DBHelper._DictBase.GetKWordByID(item2))); } } if (WordRelaionGraph == null) { WordRelaionGraph = new BidirectionalGraph <Word, Edge <Word> >(true); foreach (var item in graph.Vertices) { WordRelaionGraph.AddVertex(item); } foreach (var item in graph.Edges) { WordRelaionGraph.AddEdge(item); } } IncrementalConnectedComponentsAlgorithm <Word, Edge <Word> > a = new IncrementalConnectedComponentsAlgorithm <Word, Edge <Word> >(graph as IMutableVertexAndEdgeSet <Word, Edge <Word> >); a.Compute(); KeyValuePair <int, IDictionary <Word, int> > components = a.GetComponents(); List <BidirectionalGraph <Word, Edge <Word> > > connectedComponents = new List <BidirectionalGraph <Word, Edge <Word> > >(components.Key); var grouped = components.Value.GroupBy(t => t.Value); foreach (var group in grouped) { BidirectionalGraph <Word, Edge <Word> > g = new BidirectionalGraph <Word, Edge <Word> >(true, group.Count()); foreach (var item in group) { g.AddVertex(item.Key); } foreach (var item in g.Vertices) { g.AddEdgeRange(graph.OutEdges(item)); } connectedComponents.Add(g); } return(connectedComponents); }
public static QuickGraph.UndirectedGraph <string, Edge <string> > DatabaseToGraph(string dbFileName) { Dictionary <string, string> irpan = new Dictionary <string, string>(); if (false) { string[] lines = System.IO.File.ReadAllLines(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "new_CnUy2007.txt")); foreach (var item in lines) { string c = item.Split('\t')[0]; string u = item.Split('\t')[1]; if (irpan.ContainsKey(c)) { continue; } irpan.Add(c, u); } } char[] spliter = new char[] { ',' }; DictBase dictBase = new DictBase(); Dictionary <string, int> cWordDict = new Dictionary <string, int>(); Dictionary <string, int> uWordDict = new Dictionary <string, int>(); Dictionary <string, int> kWordDict = new Dictionary <string, int>(); Dictionary <int, string> ccWordDict = new Dictionary <int, string>(); Dictionary <int, string> uuWordDict = new Dictionary <int, string>(); Dictionary <int, string> kkWordDict = new Dictionary <int, string>(); QuickGraph.UndirectedGraph <string, Edge <string> > graph = new UndirectedGraph <string, Edge <string> >(false); zuk_dbSQLDataSet.zuk_fixedDataTable zukTable = new zuk_dbSQLDataSet.zuk_fixedDataTable(); if (dbFileName.IndexOf("\\") > -1) { zukTable.ReadXml(dbFileName); } else { zukTable.ReadXml(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, dbFileName)); } foreach (zuk_dbSQLDataSet.zuk_fixedRow row in zukTable) { string strChinese = row.Zh.Trim(); string[] strUyghurs;// = row.Ug.Split(spliter, StringSplitOptions.RemoveEmptyEntries); if (irpan.ContainsKey(strChinese)) { strUyghurs = irpan[strChinese].Split(spliter, StringSplitOptions.RemoveEmptyEntries); } else { strUyghurs = row.Ug.Split(spliter, StringSplitOptions.RemoveEmptyEntries); } string[] strKazaks = row.Kz.Split(spliter, StringSplitOptions.RemoveEmptyEntries); //trim for (int i = 0; i < strUyghurs.Length; i++) { strUyghurs[i] = strUyghurs[i].Trim(); } for (int i = 0; i < strKazaks.Length; i++) { strKazaks[i] = strKazaks[i].Trim(); } //add to db int cID = cWordDict.Count; cWordDict.Add(strChinese, cID); ccWordDict.Add(cID, strChinese); graph.AddVertex("c" + cID); //u for (int i = 0; i < strUyghurs.Length; i++) { if (!uWordDict.ContainsKey(strUyghurs[i])) { int uID = uWordDict.Count; uWordDict.Add(strUyghurs[i], uID); uuWordDict.Add(uID, strUyghurs[i]); graph.AddVertex("u" + uID); graph.AddEdge(new Edge <string>("c" + cID.ToString(), "u" + uID.ToString())); } else { graph.AddEdge(new Edge <string>("c" + cID, "u" + uWordDict[strUyghurs[i]])); } } //k for (int i = 0; i < strKazaks.Length; i++) { if (!kWordDict.ContainsKey(strKazaks[i])) { int kID = kWordDict.Count; kWordDict.Add(strKazaks[i], kID); kkWordDict.Add(kID, strKazaks[i]); graph.AddVertex("k" + kID); graph.AddEdge(new Edge <string>("c" + cID.ToString(), "k" + kID.ToString())); } graph.AddEdge(new Edge <string>("c" + cID, "k" + kWordDict[strKazaks[i]])); } } var maxU = graph.Vertices.Where <string>(t => t.StartsWith("u")).OrderByDescending(t => graph.AdjacentEdges(t).Count()); var maxU2 = maxU.ToDictionary(t => uuWordDict[int.Parse(t.TrimStart('u'))], t => graph.AdjacentEdges(t).Count()); var maxK = graph.Vertices.Where <string>(t => t.StartsWith("k")).OrderByDescending(t => graph.AdjacentEdges(t).Count()); var maxK2 = maxK.ToDictionary(t => kkWordDict[int.Parse(t.TrimStart('k'))], t => graph.AdjacentEdges(t).Count()); //Test foreach (var item in maxU2) { if (item.Value > 1) { continue; } graph.RemoveVertex("u" + uWordDict[item.Key]); } foreach (var item in maxK2) { if (item.Value > 1) { continue; } graph.RemoveVertex("k" + kWordDict[item.Key]); } IncrementalConnectedComponentsAlgorithm <string, Edge <string> > a = new IncrementalConnectedComponentsAlgorithm <string, Edge <string> >(graph as IMutableVertexAndEdgeSet <string, Edge <string> >); a.Compute(); KeyValuePair <int, IDictionary <string, int> > components = a.GetComponents(); List <BidirectionalGraph <string, Edge <string> > > connectedComponents = new List <BidirectionalGraph <string, Edge <string> > >(components.Key); var grouped = components.Value.GroupBy(t => t.Value); foreach (var group in grouped) { BidirectionalGraph <string, Edge <string> > g = new BidirectionalGraph <string, Edge <string> >(true, group.Count()); foreach (var item in group) { g.AddVertex(item.Key); } foreach (var item in g.Vertices) { g.AddEdgeRange(graph.AdjacentEdges(item)); } connectedComponents.Add(g); } var connectedComponentsSorted = connectedComponents.OrderByDescending(t => t.VertexCount).ToList(); return(graph); }
public BidirectionalGraph<AssemblyVertex, EquatableEdge<AssemblyVertex>> GenerateAssemblyReferenceGraph(IEnumerable<Regex> exclusions, IEnumerable<Regex> ignoring, ConcurrentBag<string> files, bool verbose, bool checkAssemblyVersionMatch = true) { if (verbose) Console.WriteLine("Processing {0} files.", files.Count); var edges = new ConcurrentBag<EquatableEdge<AssemblyVertex>>(); var vertices = new List<AssemblyVertex>(); var ignoreList = ignoring.ToList(); var excludeList = exclusions.ToList(); var current = 0; var total = files.Count; Parallel.ForEach(files, file => { if (verbose) Console.Write("\rProcessing file: {0} of {1}", ++current, total); AssemblyDefinition assembly; try { assembly = AssemblyDefinition.ReadAssembly(new MemoryStream(_fileSystem.File.ReadAllBytes(file))); } catch (Exception) { if (verbose) Console.WriteLine("Skipping file as it does not appear to be a .Net assembly: {0}", file); return; } //We need to load the assembly to ensure that the assembly name is the same as the file name (to be exact) if (ignoreList.Any(i => i.IsMatch(assembly.Name.Name.ToLowerInvariant()))) { if (verbose) Console.WriteLine("Ignoring file: {0}", file); return; } //Check for 32bitness on our source assembly var required32Bit = Required32BitSet(assembly); var assemblyName = new AssemblyName(assembly.FullName); //If we dont have references (I know, unlikely right?) if (!assembly.MainModule.AssemblyReferences.Any()) { vertices.Add(CreateAssemblyVertex(assemblyName.FullName, assemblyName.Name, true, Required32BitSet(assembly), excludeList)); return; } //Otherwise create edges for them... foreach (var reference in assembly.MainModule.AssemblyReferences) { var foundFileMatch = files.Any(f => CheckDependentFileMatchesManifest(f, reference, checkAssemblyVersionMatch, required32Bit)); if (!foundFileMatch) { foundFileMatch = _gacResolver.AssemblyExists(reference.FullName); } if (!ignoreList.Any(i => i.IsMatch(reference.Name.ToLowerInvariant()))) edges.Add(CreateNewEdge(reference, foundFileMatch, required32Bit, assemblyName, excludeList)); else if (verbose) Console.WriteLine("Ignoring: {0}",assemblyName.Name); } }); if (verbose) Console.WriteLine(); if (verbose) Console.WriteLine("Creating Graph..."); var graph = new BidirectionalGraph<AssemblyVertex, EquatableEdge<AssemblyVertex>>(); var allVertices = edges.Select(e => e.Source).Concat(edges.Select(e => e.Target)).Concat(vertices); var distinctVertices = allVertices.Distinct(); graph.AddVertexRange(distinctVertices); graph.AddEdgeRange(edges); return graph; }
protected override void Initialize() { Window.IsMouseVisible = true; Shader = Content.Load <Effect>("Shader"); DrawNodesPass = Shader.CurrentTechnique.Passes["DrawNodes"]; DrawEdgesPass = Shader.CurrentTechnique.Passes["DrawEdges"]; UpdateNodesPass = Shader.CurrentTechnique.Passes["UpdateNodes"]; PhotoAtlas = Texture2D.New(GraphicsDevice, 100, 100, PixelFormat.R8G8B8A8.UNorm, arraySize: 2048); ReadUsers(); var edges = new List <EdgeVertex>(); var edgeIndices = new List <int>(); var vertices = new NodeVertex[_users.Length]; var graph = new BidirectionalGraph <NodeType, EdgeType>(); graph.AddVertexRange(_users); graph.AddEdgeRange(_users.SelectMany(i => i.FriendsSet.Select(j => new EdgeType(i, j)))); var points = new Dictionary <NodeType, Point>(); var alg = new GraphSharp.Algorithms.Layout.Simple.FDP.ISOMLayoutAlgorithm <NodeType, EdgeType, GraphType>(graph, points, new ISOMLayoutParameters() { Width = 128, Height = 78 }); for (var i = 0; i < _users.Length; i++) { var user = _users[i]; var angle = 3.2 * Math.Sqrt(i + 1); var position = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)) * (float)angle * 0.25f; points.Add(user, new Point(position.X, position.Y)); } alg.Compute(); var positions = new Vector2[_users.Length]; foreach (var point in alg.VertexPositions) { positions[point.Key.ArrayIndex] = new Vector2((float)point.Value.X, (float)point.Value.Y); } float dt = 1 / 60f; for (var iterCount = 10; iterCount != 0; iterCount--) { for (var i = 0; i < positions.Length; i++) { for (var j = i + 1; j < positions.Length; j++) { var delta = positions[j] - positions[i]; var distance = delta.Length(); delta /= distance; var force = dt * delta * (RepulsionForce / ((float)Math.Pow(distance / RepulsionDistance, RepulsionPower) + RepulsionMax)); positions[i] -= force; positions[j] += force; } } } for (var i = 0; i < _users.Length; i++) { var user = _users[i]; //var position = positions[i]; //var point = alg.VertexPositions[user]; //var position = new Vector2((float)point.X, (float)point.Y); var angle = 3.2 * Math.Sqrt(i + 1); var position = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)) * (float)angle * 0.25f; //var angle = MathUtil.TwoPi * i / _users.Length; //var r = 2 * _users.Length / MathUtil.TwoPi; //var position = new Vector2((float)Math.Cos(angle), (float)Math.Sin(angle)) * r; user.Position = position; vertices[i] = new NodeVertex(position, i, edgeIndices.Count, user.AllFriends.Length); edgeIndices.AddRange(user.AllFriends.Select(j => j.ArrayIndex)); edges.AddRange(user.Friends.Select(j => new EdgeVertex(i, j.ArrayIndex))); } NodesBuffer = Buffer.Structured.New(GraphicsDevice, vertices, true); NewNodesBuffer = Buffer.Structured.New(GraphicsDevice, vertices, true); EdgesBuffer = Buffer.Structured.New(GraphicsDevice, edges.ToArray()); EdgeIndicesBuffer = Buffer.Structured.New(GraphicsDevice, edgeIndices.ToArray()); _scale = 1 / vertices.Last().Position.Length(); _position = Vector2.Zero; _rotation = 0; Shader.Parameters["Edges"].SetResource(EdgesBuffer); Shader.Parameters["EdgeIndices"].SetResource(EdgeIndicesBuffer); Shader.Parameters["atlas"].SetResource(PhotoAtlas); Shader.Parameters["atlasSampler"].SetResource(GraphicsDevice.SamplerStates.LinearWrap); //Shader.Parameters["scale"].SetValue(Scale2); //Shader.Parameters["camPos"].SetValue(_position); Layout(); }
public void Merge_Test( [NotNull] IEnumerable <int> setupVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > setupEdges, int vertexToMerge, int expectedEdgesAdded, int expectedEdgesRemoved, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > expectedEdges) { int verticesAdded = 0; int edgesAdded = 0; int verticesRemoved = 0; int edgesRemoved = 0; var graph = new BidirectionalGraph <int, EquatableEdge <int> >(); int[] verticesArray = setupVertices.ToArray(); graph.AddVertexRange(verticesArray); graph.AddEdgeRange(setupEdges); graph.VertexAdded += v => { Assert.IsNotNull(v); ++verticesAdded; }; graph.VertexRemoved += v => { Assert.IsNotNull(v); // ReSharper disable once AccessToModifiedClosure ++verticesRemoved; }; graph.EdgeAdded += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesAdded; }; graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; graph.MergeVertex(vertexToMerge, (source, target) => new EquatableEdge <int>(source, target)); CheckCounters(); AssertHasVertices(graph, verticesArray.Except(new[] { vertexToMerge })); AssertHasEdges(graph, expectedEdges); #region Local function void CheckCounters() { Assert.AreEqual(0, verticesAdded); Assert.AreEqual(1, verticesRemoved); Assert.AreEqual(expectedEdgesAdded, edgesAdded); Assert.AreEqual(expectedEdgesRemoved, edgesRemoved); verticesRemoved = 0; edgesAdded = 0; edgesRemoved = 0; } #endregion }
public BidirectionalGraph<AssemblyVertex, EquatableEdge<AssemblyVertex>> GenerateAssemblyReferenceGraph(IEnumerable<Regex> exclusions, ConcurrentBag<string> files, bool verbose) { if (verbose) Console.WriteLine("Processing {0} files.", files.Count); var edges = new ConcurrentBag<EquatableEdge<AssemblyVertex>>(); var current = 0; var total = files.Count; Parallel.ForEach(files, file => { if (verbose) Console.Write("\rProcessing file: {0} of {1}", ++current, total); AssemblyDefinition assembly; try { assembly = AssemblyDefinition.ReadAssembly(new MemoryStream(_fileSystem.File.ReadAllBytes(file))); } catch (Exception) { if (verbose) Console.WriteLine("Skipping file as it does not appear to be a .Net assembly: {0}", file); return; } foreach (var reference in assembly.MainModule.AssemblyReferences) { var exists = files.Any(f => { var fileInfo = new FileInfo(f); return reference.Name.Equals(fileInfo.Name.Replace(fileInfo.Extension, ""), StringComparison.OrdinalIgnoreCase); }); if (!exists) { string assemblyPath; exists = _gacResolver.AssemblyExists(reference.FullName, out assemblyPath); } var assemblyName = new AssemblyName(assembly.FullName); edges.Add(CreateNewEdge(reference, exists, assemblyName, exclusions)); } }); if (verbose) Console.WriteLine(); if (verbose) Console.WriteLine("Creating Graph..."); var graph = new BidirectionalGraph<AssemblyVertex, EquatableEdge<AssemblyVertex>>(); var allVertices = edges.Select(e => e.Source).Concat(edges.Select(e => e.Target)); var distinctVertices = allVertices.Distinct(); graph.AddVertexRange(distinctVertices); graph.AddEdgeRange(edges); return graph; }
public void MergeIf_Test( [NotNull] IEnumerable <int> setupVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > setupEdges, [NotNull, InstantHandle] VertexPredicate <int> vertexPredicate, int expectedVerticesRemoved, int expectedEdgesAdded, int expectedEdgesRemoved, [NotNull] IEnumerable <int> expectedVertices, [NotNull, ItemNotNull] IEnumerable <EquatableEdge <int> > expectedEdges) { int verticesAdded = 0; int edgesAdded = 0; int verticesRemoved = 0; int edgesRemoved = 0; var graph = new BidirectionalGraph <int, EquatableEdge <int> >(); graph.AddVertexRange(setupVertices); graph.AddEdgeRange(setupEdges); graph.VertexAdded += v => { Assert.IsNotNull(v); ++verticesAdded; }; graph.VertexRemoved += v => { Assert.IsNotNull(v); // ReSharper disable once AccessToModifiedClosure ++verticesRemoved; }; graph.EdgeAdded += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesAdded; }; graph.EdgeRemoved += e => { Assert.IsNotNull(e); // ReSharper disable once AccessToModifiedClosure ++edgesRemoved; }; graph.MergeVerticesIf(vertexPredicate, (source, target) => new EquatableEdge <int>(source, target)); CheckCounters(); AssertHasVertices(graph, expectedVertices); EquatableEdge <int>[] edges = expectedEdges.ToArray(); if (!edges.Any()) { AssertNoEdge(graph); } else { AssertHasEdges(graph, edges); } #region Local function void CheckCounters() { Assert.AreEqual(0, verticesAdded); Assert.AreEqual(expectedVerticesRemoved, verticesRemoved); Assert.AreEqual(expectedEdgesAdded, edgesAdded); Assert.AreEqual(expectedEdgesRemoved, edgesRemoved); verticesRemoved = 0; edgesAdded = 0; edgesRemoved = 0; } #endregion }