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
}
