public void OpenFile(string fileName)
{
//graph where the vertices and edges should be put in
var graph = new CompoundGraph <object, IEdge <object> >();
try
{
//open the file of the graph
var reader = XmlReader.Create(fileName);
//create the serializer
var serializer = new GraphMLDeserializer <object, IEdge <object>, CompoundGraph <object, IEdge <object> > >();
//deserialize the graph
serializer.Deserialize(reader, graph,
id => id, (source, target, id) => new Edge <object>(source, target)
);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
layout.Graph = graph;
layout.UpdateLayout();
}
private double EvaluateEdgeLength(
CompoundGraph <object, IEdge <object> > compoundGraph,
CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
Dictionary <object, Size> sizes,
double idealEdgeLength,
double nestingFactor)
{
double edgeLengthError = 0.0;
foreach (var edge in compoundGraph.Edges)
{
var uPos = algorithm.VertexPositions[edge.Source];
var vPos = algorithm.VertexPositions[edge.Target];
var uSize = sizes[edge.Source];
var vSize = sizes[edge.Target];
var uPoint = LayoutUtil.GetClippingPoint(uSize, uPos, vPos);
var vPoint = LayoutUtil.GetClippingPoint(vSize, vPos, uPos);
double length = (uPoint - vPoint).Length;
bool isInterEdge = compoundGraph.GetParent(edge.Source) != compoundGraph.GetParent(edge.Target);
var iel = isInterEdge
? idealEdgeLength *
(algorithm.LevelOfVertex(edge.Source) + algorithm.LevelOfVertex(edge.Target) + 1) *
nestingFactor
: idealEdgeLength;
double err = Math.Pow(length - iel, 2);
edgeLengthError += err;
}
return(edgeLengthError);
}
public TestCompoundLayout()
{
InitializeComponent();
var g = new CompoundGraph <object, IEdge <object> >();
var vertices = new string[30];
for (int i = 0; i < 30; i++)
{
vertices[i] = i.ToString();
g.AddVertex(vertices[i]);
}
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5], vertices[i]);
}
g.AddChildVertex(vertices[5], vertices[4]);
g.AddChildVertex(vertices[5], vertices[2]);
g.AddChildVertex(vertices[16], vertices[0]);
g.AddChildVertex(vertices[16], vertices[1]);
g.AddChildVertex(vertices[16], vertices[3]);
g.AddChildVertex(vertices[16], vertices[20]);
g.AddChildVertex(vertices[16], vertices[21]);
g.AddChildVertex(vertices[16], vertices[22]);
g.AddChildVertex(vertices[16], vertices[23]);
g.AddChildVertex(vertices[16], vertices[24]);
g.AddChildVertex(vertices[4], vertices[25]);
g.AddChildVertex(vertices[4], vertices[26]);
g.AddChildVertex(vertices[4], vertices[27]);
g.AddEdge(new Edge <object>(vertices[0], vertices[1]));
g.AddEdge(new Edge <object>(vertices[0], vertices[2]));
g.AddEdge(new Edge <object>(vertices[2], vertices[4]));
g.AddEdge(new Edge <object>(vertices[0], vertices[7]));
g.AddEdge(new Edge <object>(vertices[8], vertices[7]));
//g.AddEdge(new Edge<object>(vertices[13], vertices[12]));
g.AddEdge(new Edge <object>(vertices[3], vertices[20]));
g.AddEdge(new Edge <object>(vertices[20], vertices[21]));
g.AddEdge(new Edge <object>(vertices[20], vertices[22]));
g.AddEdge(new Edge <object>(vertices[22], vertices[23]));
g.AddEdge(new Edge <object>(vertices[23], vertices[24]));
g.AddEdge(new Edge <object>(vertices[0], vertices[28]));
g.AddEdge(new Edge <object>(vertices[0], vertices[29]));
g.AddEdge(new Edge <object>(vertices[25], vertices[27]));
g.AddEdge(new Edge <object>(vertices[26], vertices[25]));
g.AddEdge(new Edge <object>(vertices[14], vertices[27]));
g.AddEdge(new Edge <object>(vertices[14], vertices[26]));
g.AddEdge(new Edge <object>(vertices[14], vertices[25]));
g.AddEdge(new Edge <object>(vertices[26], vertices[27]));
layout.LayoutMode = LayoutMode.Automatic;
layout.LayoutAlgorithmType = "CompoundFDP";
layout.OverlapRemovalConstraint = AlgorithmConstraints.Automatic;
layout.OverlapRemovalAlgorithmType = "FSA";
layout.HighlightAlgorithmType = "Simple";
layout.Graph = g;
}
public TestCompoundLayout()
{
InitializeComponent();
var g = new CompoundGraph<object, IEdge<object>>();
var vertices = new string[30];
for (int i = 0; i < 30; i++)
{
vertices[i] = i.ToString();
g.AddVertex(vertices[i]);
}
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i%5], vertices[i]);
}
g.AddChildVertex(vertices[5], vertices[4]);
g.AddChildVertex(vertices[5], vertices[2]);
g.AddChildVertex(vertices[16], vertices[0]);
g.AddChildVertex(vertices[16], vertices[1]);
g.AddChildVertex(vertices[16], vertices[3]);
g.AddChildVertex(vertices[16], vertices[20]);
g.AddChildVertex(vertices[16], vertices[21]);
g.AddChildVertex(vertices[16], vertices[22]);
g.AddChildVertex(vertices[16], vertices[23]);
g.AddChildVertex(vertices[16], vertices[24]);
g.AddChildVertex(vertices[4], vertices[25]);
g.AddChildVertex(vertices[4], vertices[26]);
g.AddChildVertex(vertices[4], vertices[27]);
g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
g.AddEdge(new Edge<object>(vertices[0], vertices[2]));
g.AddEdge(new Edge<object>(vertices[2], vertices[4]));
g.AddEdge(new Edge<object>(vertices[0], vertices[7]));
g.AddEdge(new Edge<object>(vertices[8], vertices[7]));
//g.AddEdge(new Edge<object>(vertices[13], vertices[12]));
g.AddEdge(new Edge<object>(vertices[3], vertices[20]));
g.AddEdge(new Edge<object>(vertices[20], vertices[21]));
g.AddEdge(new Edge<object>(vertices[20], vertices[22]));
g.AddEdge(new Edge<object>(vertices[22], vertices[23]));
g.AddEdge(new Edge<object>(vertices[23], vertices[24]));
g.AddEdge(new Edge<object>(vertices[0], vertices[28]));
g.AddEdge(new Edge<object>(vertices[0], vertices[29]));
g.AddEdge(new Edge<object>(vertices[25], vertices[27]));
g.AddEdge(new Edge<object>(vertices[26], vertices[25]));
g.AddEdge(new Edge<object>(vertices[14], vertices[27]));
g.AddEdge(new Edge<object>(vertices[14], vertices[26]));
g.AddEdge(new Edge<object>(vertices[14], vertices[25]));
g.AddEdge(new Edge<object>(vertices[26], vertices[27]));
layout.LayoutMode = LayoutMode.Automatic;
layout.LayoutAlgorithmType = "CompoundFDP";
layout.OverlapRemovalConstraint = AlgorithmConstraints.Automatic;
layout.OverlapRemovalAlgorithmType = "FSA";
layout.HighlightAlgorithmType = "Simple";
layout.Graph = g;
}
public static ICompoundGraph <TVertex, TEdge> CreateCompoundGraph <TVertex, TEdge>(
int vertexCount,
int edgeCount,
[NotNull, InstantHandle] Func <int, TVertex> vertexFactory,
[NotNull, InstantHandle] Func <TVertex, TVertex, TEdge> edgeFactory,
[NotNull] Random random)
where TEdge : IEdge <TVertex>
{
var graph = new CompoundGraph <TVertex, TEdge>(false, vertexCount);
var verticesMap = new Dictionary <int, TVertex>();
for (int i = 0; i < vertexCount; ++i)
{
TVertex vertex = vertexFactory(i);
verticesMap[i] = vertex;
graph.AddVertex(vertex);
}
for (int i = 0; i < vertexCount / 3; ++i)
{
int vertexIndex1;
int vertexIndex2;
TVertex vertex1;
TVertex vertex2;
do
{
vertexIndex1 = random.Next(vertexCount);
vertexIndex2 = random.Next(vertexCount);
vertex1 = verticesMap[vertexIndex1];
vertex2 = verticesMap[vertexIndex2];
} while (vertexIndex1 == vertexIndex2 ||
graph.IsChildVertex(vertex2));
graph.AddChildVertex(vertex1, vertex2);
}
for (int i = 0; i < edgeCount; ++i)
{
int childIndex;
int parentIndex;
TVertex child;
TVertex parent;
do
{
childIndex = random.Next(vertexCount);
parentIndex = random.Next(vertexCount);
child = verticesMap[childIndex];
parent = verticesMap[parentIndex];
} while (childIndex == parentIndex ||
graph.ContainsEdge(parent, child));
// Create the edge between the 2 vertex
graph.AddEdge(edgeFactory(parent, child));
}
return(graph);
}
private string[] InitVertices(CompoundGraph <object, IEdge <object> > g, int vertexCount)
{
var vertices = new string[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
vertices[i] = i.ToString();
g.AddVertex(vertices[i]);
}
return(vertices);
}
private int EvaluateEdgeCrossing(
CompoundGraph <object, IEdge <object> > compoundGraph,
CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
Dictionary <object, Size> sizes)
{
int crossings = 0;
foreach (var edge in compoundGraph.Edges)
{
var uPos1 = algorithm.VertexPositions[edge.Source];
var vPos1 = algorithm.VertexPositions[edge.Target];
var uSize1 = sizes[edge.Source];
var vSize1 = sizes[edge.Target];
var uPoint1 = LayoutUtil.GetClippingPoint(uSize1, uPos1, vPos1);
var vPoint1 = LayoutUtil.GetClippingPoint(vSize1, vPos1, uPos1);
foreach (var edge2 in compoundGraph.Edges)
{
if (edge == edge2)
{
continue;
}
var uPos2 = algorithm.VertexPositions[edge.Source];
var vPos2 = algorithm.VertexPositions[edge.Target];
var uSize2 = sizes[edge.Source];
var vSize2 = sizes[edge.Target];
var uPoint2 = LayoutUtil.GetClippingPoint(uSize2, uPos2, vPos2);
var vPoint2 = LayoutUtil.GetClippingPoint(vSize2, vPos2, uPos2);
Vector v1 = (vPoint1 - uPoint1);
Vector v2 = (vPoint2 - uPoint2);
if (v1 == v2 || v1 == -v2)
{
continue; //parallel edges
}
var t2 = (uPoint1.Y - uPoint2.Y + (uPoint2.X - uPoint1.X) * v1.Y / v1.X) / (v2.Y - v2.X * v1.Y / v1.X);
var t1 = (uPoint2.X - uPoint1.X + t2 * v2.X) / v1.X;
var p = uPoint1 + t1 * v1;
var b1 = t1 > 0 && (p - uPoint1).Length < (vPoint1 - uPoint1).Length;
var b2 = t2 > 0 && (p - uPoint2).Length < (vPoint2 - uPoint2).Length;
if (b1 && b2)
{
crossings++;
}
}
}
return(crossings);
}
static void Main(string[] args)
{
CompoundGraph root = new CompoundGraph();
root.Add(new Circle(0, 0, 0));
root.Add(new Circle(5, 5, 5));
root.Add(new Circle(10, 10, 10));
root.Add(new Dot(50, 50));
CompoundGraph comp = new CompoundGraph();
comp.Add(new Circle(0, 0, 50));
root.Add(comp);
root.draw();
}
private IBidirectionalGraph <object, IEdge <object> > ConvertGraph(PocGraph graph)
{
var g = new CompoundGraph <object, IEdge <object> >();
foreach (var item in graph.Vertices)
{
g.AddVertex(item.ID);
}
foreach (var item in graph.Edges)
{
g.AddEdge(new Edge <object>(item.Source.ID, item.Target.ID));
}
return(g);
}
private void EvaluateNodeDistances(
CompoundGraph <object, IEdge <object> > compoundGraph,
CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
Dictionary <object, Size> sizes,
out double minimalMinDistance,
out double averageMinDistance,
out double maximalMinDistance)
{
minimalMinDistance = 0.0;
averageMinDistance = 0.0;
maximalMinDistance = 0.0;
double count = 0;
foreach (var level in algorithm.Levels)
{
foreach (var u in level)
{
double m = double.PositiveInfinity;
foreach (var v in level)
{
if (u == v || compoundGraph.GetParent(u) != compoundGraph.GetParent(v))
{
continue;
}
var uPoint = LayoutUtil.GetClippingPoint(sizes[u], algorithm.VertexPositions[u],
algorithm.VertexPositions[v]);
var vPoint = LayoutUtil.GetClippingPoint(sizes[v], algorithm.VertexPositions[v],
algorithm.VertexPositions[u]);
double distance = (uPoint - vPoint).Length;
m = Math.Min(m, distance);
}
if (double.IsPositiveInfinity(m))
{
continue;
}
minimalMinDistance = Math.Min(minimalMinDistance, m);
averageMinDistance += m;
count++;
maximalMinDistance = Math.Max(maximalMinDistance, m);
}
}
}
private double EvaluateNodeOverlaps(
CompoundGraph <object, IEdge <object> > compoundGraph,
CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
IDictionary <object, Size> vertexSizes)
{
double overlapArea = 0.0;
foreach (var level in algorithm.Levels)
{
foreach (var u in level)
{
foreach (var v in level)
{
if (u == v || compoundGraph.GetParent(u) != compoundGraph.GetParent(v))
{
continue;
}
var uSize = vertexSizes[u];
var vSize = vertexSizes[v];
var uPosition = algorithm.VertexPositions[u];
var vPosition = algorithm.VertexPositions[v];
var uRect = new Rect(uPosition, uSize);
var vRect = new Rect(vPosition, vSize);
//get the overlap size
uRect.Intersect(vRect);
if (double.IsNegativeInfinity(uRect.Width) || double.IsNegativeInfinity(uRect.Height))
{
continue;
}
overlapArea += uRect.Width * uRect.Height;
}
}
}
return(overlapArea);
}
private Size EvaluateCanvasSize(
CompoundGraph <object, IEdge <object> > compoundGraph,
CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
Dictionary <object, Size> sizes)
{
Point topLeft = new Point(double.PositiveInfinity, double.PositiveInfinity);
Point bottomRight = new Point(double.NegativeInfinity, double.NegativeInfinity);
foreach (var v in compoundGraph.Vertices)
{
var pos = algorithm.VertexPositions[v];
var size = sizes[v];
topLeft.X = Math.Min(topLeft.X, pos.X - size.Width / 2.0);
topLeft.Y = Math.Min(topLeft.Y, pos.Y - size.Height / 2.0);
bottomRight.X = Math.Max(bottomRight.X, pos.X + size.Width / 2.0);
bottomRight.Y = Math.Max(bottomRight.Y, pos.Y + size.Height / 2.0);
}
var sizeVector = bottomRight - topLeft;
return(new Size(sizeVector.X, sizeVector.Y));
}
private double EvaluateFitnessForGraph(CompoundFDPLayoutParameters chromosome, CompoundGraph <object, IEdge <object> > compoundGraph)
{
var sizes = new Dictionary <object, Size>();
var borders = new Dictionary <object, Thickness>();
var layoutType = new Dictionary <object, CompoundVertexInnerLayoutType>();
var s = new Size(20, 20);
foreach (var v in compoundGraph.SimpleVertices)
{
sizes[v] = s;
}
var b = new Thickness(5, 10, 5, 5);
foreach (var v in compoundGraph.CompoundVertices)
{
sizes[v] = new Size();
borders[v] = b;
layoutType[v] = CompoundVertexInnerLayoutType.Automatic;
}
//run the compound FDP algorithm
var algorithm =
new CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > >(
compoundGraph, sizes, borders, layoutType, null, chromosome);
algorithm.Compute();
double fitness = 0.0;
//refresh the sizes of the compound vertices
foreach (var v in compoundGraph.CompoundVertices)
{
var border = borders[v];
var innerCanvasSize = algorithm.InnerCanvasSizes[v];
var size = new Size(
border.Left + innerCanvasSize.Width + border.Right,
border.Top + innerCanvasSize.Height + border.Bottom
);
sizes[v] = size;
}
//NODE OVERLAP
double overlaps = EvaluateNodeOverlaps(compoundGraph, algorithm, sizes);
/*if (overlaps > 0.0)
* return double.NaN;*/
fitness += overlaps * NODE_OVERLAP_MULTIPLIER;
//CANVAS SIZE
Size canvasSize = EvaluateCanvasSize(compoundGraph, algorithm, sizes);
fitness += canvasSize.Width * canvasSize.Height * CANVAS_SIZE_MULTIPLIER;
//CANVAS RATIO
double canvasRatio = canvasSize.Width / canvasSize.Height;
canvasRatio = canvasRatio < 1 ? 1 / canvasRatio : canvasRatio;
fitness += canvasRatio * CANVAS_RATIO_MULTIPLIER;
//NODE DISTANCES
double minimalMinDistance, averageMinDistance, maximalMinDistance;
double idealDistance = chromosome.IdealEdgeLength;
EvaluateNodeDistances(compoundGraph, algorithm, sizes, out minimalMinDistance, out averageMinDistance, out maximalMinDistance);
fitness += (averageMinDistance - idealDistance) * NODE_DISTANCE_MULTIPLIER;
fitness += (minimalMinDistance - idealDistance) * NODE_DISTANCE_MULTIPLIER;
fitness += (maximalMinDistance - idealDistance) * NODE_DISTANCE_MULTIPLIER;
//EDGE LENGTH
double edgeLength = EvaluateEdgeLength(compoundGraph, algorithm, sizes, chromosome.IdealEdgeLength, chromosome.NestingFactor);
fitness += edgeLength * EDGE_LENGTH_MULTIPLIER;
//EDGE CROSSING
double edgeCrossing = EvaluateEdgeCrossing(compoundGraph, algorithm, sizes);
fitness += edgeCrossing * EDGE_CROSSING_MULTIPLIER;
//PHASE_LENGTH
double phaseLength = (chromosome.Phase1Iterations + chromosome.Phase2Iterations +
chromosome.Phase3Iterations) * PHASE_LENGTH_MULTIPLIER;
fitness += phaseLength;
return(fitness);
}
private void InitGraphs()
{
graphs = new CompoundGraph <object, IEdge <object> > [6];
#region Big graph
var g = new CompoundGraph <object, IEdge <object> >();
string[] vertices = InitVertices(g, 20);
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5], vertices[i]);
}
g.AddChildVertex(vertices[5], vertices[4]);
g.AddChildVertex(vertices[5], vertices[2]);
g.AddChildVertex(vertices[16], vertices[0]);
g.AddChildVertex(vertices[16], vertices[1]);
g.AddChildVertex(vertices[16], vertices[3]);
g.AddEdge(new Edge <object>(vertices[0], vertices[1]));
g.AddEdge(new Edge <object>(vertices[0], vertices[2]));
g.AddEdge(new Edge <object>(vertices[2], vertices[4]));
g.AddEdge(new Edge <object>(vertices[0], vertices[7]));
g.AddEdge(new Edge <object>(vertices[8], vertices[7]));
graphs[BIG_GRAPH] = g;
#endregion
#region Small graph
g = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(g, 2);
//add the containments
/*g.AddChildVertex(vertices[0], vertices[1]);
* g.AddChildVertex(vertices[0], vertices[2]);*/
//add the edges
/*g.AddEdge(new Edge<object>(vertices[2], vertices[3]));
* g.AddEdge(new Edge<object>(vertices[3], vertices[4]));*/
graphs[SMALL_GRAPH] = g;
#endregion
#region Flat graph
g = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(g, 10);
g.AddEdge(new Edge <object>(vertices[0], vertices[1]));
g.AddEdge(new Edge <object>(vertices[1], vertices[2]));
g.AddEdge(new Edge <object>(vertices[2], vertices[3]));
g.AddEdge(new Edge <object>(vertices[3], vertices[0]));
g.AddEdge(new Edge <object>(vertices[1], vertices[3]));
g.AddEdge(new Edge <object>(vertices[2], vertices[0]));
graphs[FLAT_GRAPH] = g;
#endregion
#region Repulsion graph
g = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(g, 20);
graphs[REP_GRAPH] = g;
#endregion
#region Star
g = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(g, 13);
for (int i = 1; i < 13; i++)
{
g.AddEdge(new Edge <object>(vertices[0], vertices[i]));
}
for (int i = 0; i < 4; i++)
{
g.AddEdge(new Edge <object>(vertices[i * 3 + 1], vertices[i * 3 + 2]));
g.AddEdge(new Edge <object>(vertices[i * 3 + 1], vertices[i * 3 + 3]));
g.AddEdge(new Edge <object>(vertices[i * 3 + 2], vertices[i * 3 + 3]));
}
graphs[STAR_GRAPH] = g;
#endregion
#region Combined
g = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(g, 50);
//add the containments
g.AddChildVertex(vertices[0], vertices[1]);
g.AddChildVertex(vertices[0], vertices[2]);
//add the edges
g.AddEdge(new Edge <object>(vertices[2], vertices[3]));
g.AddEdge(new Edge <object>(vertices[3], vertices[4]));
g.AddEdge(new Edge <object>(vertices[10], vertices[11]));
g.AddEdge(new Edge <object>(vertices[11], vertices[12]));
g.AddEdge(new Edge <object>(vertices[12], vertices[13]));
g.AddEdge(new Edge <object>(vertices[13], vertices[10]));
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5 + 20], vertices[i + 20]);
}
g.AddChildVertex(vertices[25], vertices[24]);
g.AddChildVertex(vertices[25], vertices[22]);
g.AddChildVertex(vertices[36], vertices[20]);
g.AddChildVertex(vertices[36], vertices[21]);
g.AddChildVertex(vertices[36], vertices[23]);
g.AddEdge(new Edge <object>(vertices[20], vertices[21]));
g.AddEdge(new Edge <object>(vertices[20], vertices[22]));
g.AddEdge(new Edge <object>(vertices[22], vertices[24]));
g.AddEdge(new Edge <object>(vertices[20], vertices[27]));
g.AddEdge(new Edge <object>(vertices[28], vertices[27]));
graphs[COMBINED_GRAPH] = g;
#endregion
}
private IBidirectionalGraph<object, IEdge<object>> ConvertGraph(PocGraph graph)
{
var g = new CompoundGraph<object, IEdge<object>>();
foreach (var item in graph.Vertices)
{
g.AddVertex(item.ID);
}
foreach (var item in graph.Edges)
{
g.AddEdge(new Edge<object>(item.Source.ID, item.Target.ID));
}
return g;
}
public void Construction()
{
var graph = new CompoundGraph <int, Edge <int> >();
AssertGraphProperties(graph);
graph = new CompoundGraph <int, Edge <int> >(true);
AssertGraphProperties(graph);
graph = new CompoundGraph <int, Edge <int> >(false);
AssertGraphProperties(graph, false);
graph = new CompoundGraph <int, Edge <int> >(true, 12);
AssertGraphProperties(graph);
graph = new CompoundGraph <int, Edge <int> >(false, 12);
AssertGraphProperties(graph, false);
// From graph
var otherGraph1 = new AdjacencyGraph <int, Edge <int> >();
graph = new CompoundGraph <int, Edge <int> >(otherGraph1);
AssertGraphProperties(graph);
var otherGraph2 = new AdjacencyGraph <int, Edge <int> >(false);
graph = new CompoundGraph <int, Edge <int> >(otherGraph2);
AssertGraphProperties(graph, false);
var otherNonEmptyGraph1 = new AdjacencyGraph <int, Edge <int> >();
otherNonEmptyGraph1.AddVertexRange(new[] { 1, 2 });
graph = new CompoundGraph <int, Edge <int> >(otherNonEmptyGraph1);
AssertGraphProperties(graph, vertices: new[] { 1, 2 });
var graphEdges = new[]
{
new Edge <int>(1, 2),
new Edge <int>(1, 3),
new Edge <int>(2, 3)
};
var otherNonEmptyGraph2 = new AdjacencyGraph <int, Edge <int> >();
otherNonEmptyGraph2.AddVerticesAndEdgeRange(graphEdges);
graph = new CompoundGraph <int, Edge <int> >(otherNonEmptyGraph2);
AssertGraphProperties(graph, vertices: new[] { 1, 2, 3 }, edges: graphEdges);
// From CompoundGraph
var otherCompoundGraph = new CompoundGraph <int, Edge <int> >();
graph = new CompoundGraph <int, Edge <int> >(otherCompoundGraph);
AssertGraphProperties(graph);
var otherNonEmptyCompoundGraph1 = new CompoundGraph <int, Edge <int> >();
otherNonEmptyCompoundGraph1.AddVerticesAndEdgeRange(graphEdges);
graph = new CompoundGraph <int, Edge <int> >(otherNonEmptyCompoundGraph1);
AssertGraphProperties(graph, vertices: new[] { 1, 2, 3 }, edges: graphEdges);
var otherNonEmptyCompoundGraph2 = new CompoundGraph <int, Edge <int> >();
otherNonEmptyCompoundGraph2.AddVerticesAndEdgeRange(graphEdges);
otherNonEmptyCompoundGraph2.AddChildVertex(2, 3);
graph = new CompoundGraph <int, Edge <int> >(otherNonEmptyCompoundGraph2);
AssertGraphProperties(graph, vertices: new[] { 1, 2, 3 }, edges: graphEdges, compoundVertices: new[] { 2 });
var otherNonEmptyCompoundGraph3 = new CompoundGraph <int, Edge <int> >();
otherNonEmptyCompoundGraph3.AddVerticesAndEdgeRange(graphEdges);
otherNonEmptyCompoundGraph3.AddChildVertex(1, 2);
otherNonEmptyCompoundGraph3.AddChildVertex(2, 3);
graph = new CompoundGraph <int, Edge <int> >(otherNonEmptyCompoundGraph3);
AssertGraphProperties(graph, vertices: new[] { 1, 2, 3 }, edges: graphEdges, compoundVertices: new[] { 1, 2 });
#region Local function
void AssertGraphProperties <TVertex, TEdge>(
CompoundGraph <TVertex, TEdge> g,
bool parallelEdges = true,
IEnumerable <TVertex> vertices = null,
IEnumerable <TEdge> edges = null,
IEnumerable <TVertex> compoundVertices = null)
where TEdge : IEdge <TVertex>
{
Assert.IsTrue(g.IsDirected);
Assert.AreEqual(parallelEdges, g.AllowParallelEdges);
TVertex[] verticesArray = vertices?.ToArray();
if (vertices is null && edges is null)
{
AssertEmptyGraph(g);
}
private void ShowGraph(int graphIndex)
{
CompoundGraph <object, IEdge <object> > g = graphs[graphIndex];
_rectDict.Clear();
_lineDict.Clear();
lc.Children.Clear();
var origo = new Ellipse();
origo.Width = 100;
origo.Height = 100;
origo.Fill = Brushes.Black;
origo.OpacityMask = new RadialGradientBrush(Colors.Black, Colors.Transparent);
Canvas.SetLeft(origo, -5);
Canvas.SetTop(origo, -5);
lc.Children.Add(origo);
var sizes = new Dictionary <object, Size>();
var borders = new Dictionary <object, Thickness>();
var layoutType = new Dictionary <object, CompoundVertexInnerLayoutType>();
var s = new Size(20, 20);
foreach (var v in g.SimpleVertices)
{
sizes[v] = s;
}
var b = new Thickness(5, 10, 5, 5);
foreach (var v in g.CompoundVertices)
{
sizes[v] = new Size();
borders[v] = b;
layoutType[v] = CompoundVertexInnerLayoutType.Automatic;
}
var worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += (sender, e) =>
{
//var layoutAlgorithm =
// new CompoundFDPLayoutAlgorithm
// <object, IEdge<object>, ICompoundGraph<object, IEdge<object>>>(
// g, sizes, borders, layoutType, null,
// parameters);
//layoutAlgorithm.IterationEnded += (o, evt) =>
//{
// var args = evt as TestingCompoundLayoutIterationEventArgs<object, IEdge<object>, TestingCompoundVertexInfo, object>;
// var positions = args.VertexPositions;
// var innerSizes = (args as ICompoundLayoutIterationEventArgs<object>).InnerCanvasSizes;
// var vertexInfos = args.VertexInfos;
// Dispatcher.Invoke(new Action(delegate
// {
// var pDict = new Dictionary<object, Point>();
// var compoundVerticesToCheck =
// new Queue<object>();
// var compoundVertices = new List<object>();
// var root =
// g.CompoundVertices.Where(
// cv => g.GetParent(cv) == null);
// foreach (var r in root)
// compoundVerticesToCheck.Enqueue(r);
// while (compoundVerticesToCheck.Count > 0)
// {
// var next = compoundVerticesToCheck.Dequeue();
// if (!g.IsCompoundVertex(next))
// continue;
// compoundVertices.Add(next);
// foreach (
// var childrenVertex in
// g.GetChildrenVertices(next))
// {
// compoundVerticesToCheck.Enqueue(
// childrenVertex);
// }
// }
// //draw the compound vertices
// foreach (var v in compoundVertices)
// {
// var size = innerSizes[v];
// size.Width += b.Left + b.Right;
// size.Height += b.Top + b.Bottom;
// var pos = positions[v];
// pDict[v] = pos;
// AddRect(v, pos, size);
// }
// //draw the simple vertices
// foreach (var v in g.SimpleVertices)
// {
// var pos = positions[v];
// pDict[v] = pos;
// AddRect(v, pos, s);
// }
// //draw the simple edges
// foreach (var edge in g.Edges)
// {
// var pos1 = pDict[edge.Source];
// var pos2 = pDict[edge.Target];
// AddLine(edge, pos1, pos2, true);
// }
// //draw the containment edges
// /*foreach (var v in g.CompoundVertices)
// {
// var pos1 = pDict[v];
// foreach (var c in g.GetChildrenVertices(v))
// {
// var pos2 = pDict[c];
// AddLine(c, pos1, pos2, false);
// }
// }*/
// //draw the lines of the forces
// foreach (var forceLine in _forceLines)
// lc.Children.Remove(forceLine);
// var springColor = Brushes.Orange;
// var repulsionColor = Brushes.Red;
// var gravityColor = Brushes.Green;
// var applicationColor = Brushes.Yellow;
// foreach (var kvp in vertexInfos)
// {
// var line = CreateLine(pDict[kvp.Key],
// kvp.Value.SpringForce,
// springColor);
// lc.Children.Add(line);
// _forceLines.Add(line);
// line = CreateLine(pDict[kvp.Key],
// kvp.Value.RepulsionForce,
// repulsionColor);
// lc.Children.Add(line);
// _forceLines.Add(line);
// line = CreateLine(pDict[kvp.Key],
// kvp.Value.GravityForce,
// gravityColor);
// lc.Children.Add(line);
// _forceLines.Add(line);
// line = CreateLine(pDict[kvp.Key],
// kvp.Value.ApplicationForce,
// applicationColor);
// lc.Children.Add(line);
// _forceLines.Add(line);
// }
// //set the position of the gravity center
// Animate(origo, Canvas.LeftProperty, args.GravitationCenter.X - origo.Width / 2.0, animationDuration);
// Animate(origo, Canvas.TopProperty, args.GravitationCenter.Y - origo.Height / 2.0, animationDuration);
// txtMessage.Text = args.Message;
// }));
// do
// {
// Thread.Sleep((int) animationDuration.TimeSpan.TotalMilliseconds);
// } while (_paused);
//};
//layoutAlgorithm.Compute();
};
worker.RunWorkerAsync();
}
private void ShowGraph(int graphIndex)
{
CompoundGraph <object, IEdge <object> > graph = _graphs[graphIndex];
_rectangles.Clear();
_lines.Clear();
Layout.Children.Clear();
var origo = new Ellipse
{
Width = 100,
Height = 100,
Fill = System.Windows.Media.Brushes.Black,
OpacityMask = new RadialGradientBrush(Colors.Black, Colors.Transparent)
};
Canvas.SetLeft(origo, -5);
Canvas.SetTop(origo, -5);
Layout.Children.Add(origo);
var sizes = new Dictionary <object, Size>();
var borders = new Dictionary <object, Thickness>();
var layoutType = new Dictionary <object, CompoundVertexInnerLayoutType>();
var size = new Size(20, 20);
foreach (object vertex in graph.SimpleVertices)
{
sizes[vertex] = size;
}
var thickness = new Thickness(5, 10, 5, 5);
foreach (object vertex in graph.CompoundVertices)
{
sizes[vertex] = default;
borders[vertex] = thickness;
layoutType[vertex] = CompoundVertexInnerLayoutType.Automatic;
}
var worker = new BackgroundWorker
{
WorkerReportsProgress = true
};
worker.DoWork += (sender, args) =>
{
var layoutAlgorithm = new CompoundFDPLayoutAlgorithm <object, IEdge <object>, ICompoundGraph <object, IEdge <object> > >(
graph,
sizes,
borders,
layoutType,
_parameters);
layoutAlgorithm.IterationEnded += (s, iterationArgs) =>
{
var testIterationArgs = iterationArgs as TestingCompoundLayoutIterationEventArgs <object, IEdge <object>, TestingCompoundVertexInfo, object>;
IDictionary <object, Point> positions = testIterationArgs?.VerticesPositions;
if (positions is null)
{
return;
}
IDictionary <object, Size> innerSizes = ((ICompoundLayoutIterationEventArgs <object>)testIterationArgs).InnerCanvasSizes;
IDictionary <object, TestingCompoundVertexInfo> verticesInfos = testIterationArgs.VerticesInfos;
Dispatcher.Invoke(() =>
{
var points = new Dictionary <object, Point>();
var compoundVerticesToCheck = new Queue <object>();
var compoundVertices = new List <object>();
var roots = graph.CompoundVertices.Where(vertex => graph.GetParent(vertex) is null);
foreach (object root in roots)
{
compoundVerticesToCheck.Enqueue(root);
}
while (compoundVerticesToCheck.Count > 0)
{
object next = compoundVerticesToCheck.Dequeue();
if (!graph.IsCompoundVertex(next))
{
continue;
}
compoundVertices.Add(next);
foreach (object childrenVertex in graph.GetChildrenVertices(next))
{
compoundVerticesToCheck.Enqueue(childrenVertex);
}
}
// Draw the compound vertices
foreach (object vertex in compoundVertices)
{
Size innerSize = innerSizes[vertex];
innerSize.Width += thickness.Left + thickness.Right;
innerSize.Height += thickness.Top + thickness.Bottom;
Point pos = positions[vertex];
points[vertex] = pos;
AddRectangle(vertex, pos, innerSize);
}
// Draw the simple vertices
foreach (object vertex in graph.SimpleVertices)
{
Point pos = positions[vertex];
points[vertex] = pos;
AddRectangle(vertex, pos, size);
}
// Draw the simple edges
foreach (IEdge <object> edge in graph.Edges)
{
Point pos1 = points[edge.Source];
Point pos2 = points[edge.Target];
AddLine(edge, pos1, pos2, true);
}
// Draw the containment edges
foreach (object vertex in graph.CompoundVertices)
{
Point pos1 = points[vertex];
foreach (object child in graph.GetChildrenVertices(vertex))
{
Point pos2 = points[child];
AddLine(child, pos1, pos2, false);
}
}
// Draw the lines of the forces
foreach (Line forceLine in _forceLines)
{
Layout.Children.Remove(forceLine);
}
SolidColorBrush springColor = System.Windows.Media.Brushes.Orange;
SolidColorBrush repulsionColor = System.Windows.Media.Brushes.Red;
SolidColorBrush gravityColor = System.Windows.Media.Brushes.Green;
SolidColorBrush applicationColor = System.Windows.Media.Brushes.Yellow;
foreach (KeyValuePair <object, TestingCompoundVertexInfo> pair in verticesInfos)
{
Line line = CreateLine(points[pair.Key], pair.Value.SpringForce, springColor);
Layout.Children.Add(line);
_forceLines.Add(line);
line = CreateLine(points[pair.Key], pair.Value.RepulsionForce, repulsionColor);
Layout.Children.Add(line);
_forceLines.Add(line);
line = CreateLine(points[pair.Key], pair.Value.GravityForce, gravityColor);
Layout.Children.Add(line);
_forceLines.Add(line);
line = CreateLine(points[pair.Key], pair.Value.ApplicationForce, applicationColor);
Layout.Children.Add(line);
_forceLines.Add(line);
}
// Set the position of the gravity center
Animate(
origo,
Canvas.LeftProperty,
testIterationArgs.GravitationCenter.X - origo.Width / 2.0,
_animationDuration);
Animate(
origo,
Canvas.TopProperty,
testIterationArgs.GravitationCenter.Y - origo.Height / 2.0,
_animationDuration);
TxtMessage.Text = testIterationArgs.Message;
});
do
{
Thread.Sleep((int)_animationDuration.TimeSpan.TotalMilliseconds);
} while (_paused);
};
layoutAlgorithm.Compute();
};
worker.RunWorkerAsync();
}
private static CompoundGraph <object, IEdge <object> >[] InitGraphs()
{
var graphs = new CompoundGraph <object, IEdge <object> > [6];
#region Big graph
var graph = new CompoundGraph <object, IEdge <object> >();
string[] vertices = InitVertices(graph, 20);
for (int i = 6; i < 15; ++i)
{
graph.AddChildVertex(vertices[i % 5], vertices[i]);
}
graph.AddChildVertex(vertices[5], vertices[4]);
graph.AddChildVertex(vertices[5], vertices[2]);
graph.AddChildVertex(vertices[16], vertices[0]);
graph.AddChildVertex(vertices[16], vertices[1]);
graph.AddChildVertex(vertices[16], vertices[3]);
graph.AddEdge(new Edge <object>(vertices[0], vertices[1]));
graph.AddEdge(new Edge <object>(vertices[0], vertices[2]));
graph.AddEdge(new Edge <object>(vertices[2], vertices[4]));
graph.AddEdge(new Edge <object>(vertices[0], vertices[7]));
graph.AddEdge(new Edge <object>(vertices[8], vertices[7]));
graphs[BigGraph] = graph;
#endregion
#region Small graph
graph = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(graph, 10);
// Add the containements
graph.AddChildVertex(vertices[0], vertices[1]);
graph.AddChildVertex(vertices[0], vertices[2]);
graph.AddChildVertex(vertices[3], vertices[4]);
graph.AddChildVertex(vertices[3], vertices[5]);
graph.AddChildVertex(vertices[3], vertices[6]);
graph.AddChildVertex(vertices[3], vertices[7]);
graph.AddChildVertex(vertices[3], vertices[8]);
graph.AddChildVertex(vertices[3], vertices[9]);
// Add the edges
graph.AddEdge(new Edge <object>(vertices[2], vertices[4]));
graph.AddEdge(new Edge <object>(vertices[1], vertices[5]));
graphs[SmallGraph] = graph;
#endregion
#region Flat graph
graph = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(graph, 10);
graph.AddEdge(new Edge <object>(vertices[0], vertices[1]));
graph.AddEdge(new Edge <object>(vertices[1], vertices[2]));
graph.AddEdge(new Edge <object>(vertices[2], vertices[3]));
graph.AddEdge(new Edge <object>(vertices[3], vertices[0]));
graph.AddEdge(new Edge <object>(vertices[1], vertices[3]));
graph.AddEdge(new Edge <object>(vertices[2], vertices[0]));
graphs[FlatGraph] = graph;
#endregion
#region Repulsion graph
graph = new CompoundGraph <object, IEdge <object> >();
InitVertices(graph, 50);
graphs[RepGraph] = graph;
#endregion
#region Star
graph = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(graph, 13);
for (int i = 1; i < 13; ++i)
{
graph.AddEdge(new Edge <object>(vertices[0], vertices[i]));
}
for (int i = 0; i < 4; ++i)
{
graph.AddEdge(new Edge <object>(vertices[i * 3 + 1], vertices[i * 3 + 2]));
graph.AddEdge(new Edge <object>(vertices[i * 3 + 1], vertices[i * 3 + 3]));
graph.AddEdge(new Edge <object>(vertices[i * 3 + 2], vertices[i * 3 + 3]));
}
graphs[StarGraph] = graph;
#endregion
#region Combined
graph = new CompoundGraph <object, IEdge <object> >();
vertices = InitVertices(graph, 51);
// Add the containements
graph.AddChildVertex(vertices[0], vertices[1]);
graph.AddChildVertex(vertices[0], vertices[2]);
// Add the edges
graph.AddEdge(new Edge <object>(vertices[2], vertices[3]));
graph.AddEdge(new Edge <object>(vertices[3], vertices[4]));
graph.AddEdge(new Edge <object>(vertices[10], vertices[11]));
graph.AddEdge(new Edge <object>(vertices[11], vertices[12]));
graph.AddEdge(new Edge <object>(vertices[12], vertices[13]));
graph.AddEdge(new Edge <object>(vertices[13], vertices[10]));
for (int i = 6; i < 15; ++i)
{
graph.AddChildVertex(vertices[i % 5 + 20], vertices[i + 20]);
}
graph.AddChildVertex(vertices[25], vertices[24]);
graph.AddChildVertex(vertices[25], vertices[22]);
graph.AddChildVertex(vertices[36], vertices[20]);
graph.AddChildVertex(vertices[36], vertices[21]);
graph.AddChildVertex(vertices[36], vertices[23]);
graph.AddEdge(new Edge <object>(vertices[20], vertices[21]));
graph.AddEdge(new Edge <object>(vertices[20], vertices[22]));
graph.AddEdge(new Edge <object>(vertices[22], vertices[24]));
graph.AddEdge(new Edge <object>(vertices[20], vertices[27]));
graph.AddEdge(new Edge <object>(vertices[28], vertices[27]));
graph.AddEdge(new Edge <object>(vertices[4], vertices[39]));
graph.AddEdge(new Edge <object>(vertices[39], vertices[40]));
graph.AddEdge(new Edge <object>(vertices[39], vertices[41]));
graph.AddEdge(new Edge <object>(vertices[39], vertices[42]));
graph.AddEdge(new Edge <object>(vertices[42], vertices[43]));
graph.AddEdge(new Edge <object>(vertices[42], vertices[44]));
graph.AddEdge(new Edge <object>(vertices[1], vertices[45]));
graph.AddEdge(new Edge <object>(vertices[45], vertices[46]));
graph.AddEdge(new Edge <object>(vertices[45], vertices[47]));
graph.AddEdge(new Edge <object>(vertices[45], vertices[48]));
graph.AddEdge(new Edge <object>(vertices[48], vertices[49]));
graph.AddEdge(new Edge <object>(vertices[48], vertices[50]));
graphs[CombinedGraph] = graph;
#endregion
return(graphs);
}
private string[] InitVertices(CompoundGraph<object, IEdge<object>> g, int vertexCount)
{
var vertices = new string[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
vertices[i] = i.ToString();
g.AddVertex(vertices[i]);
}
return vertices;
}
private void InitGraphs()
{
graphs = new CompoundGraph<object, IEdge<object>>[10];
#region Big graph
var g = new CompoundGraph<object, IEdge<object>>();
string[] vertices = InitVertices(g, 20);
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5], vertices[i]);
}
g.AddChildVertex(vertices[5], vertices[4]);
g.AddChildVertex(vertices[5], vertices[2]);
g.AddChildVertex(vertices[16], vertices[0]);
g.AddChildVertex(vertices[16], vertices[1]);
g.AddChildVertex(vertices[16], vertices[3]);
g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
g.AddEdge(new Edge<object>(vertices[0], vertices[2]));
g.AddEdge(new Edge<object>(vertices[2], vertices[4]));
g.AddEdge(new Edge<object>(vertices[0], vertices[7]));
g.AddEdge(new Edge<object>(vertices[8], vertices[7]));
graphs[BIG_GRAPH] = g;
#endregion
#region Small graph
g = new CompoundGraph<object, IEdge<object>>();
vertices = InitVertices(g, 10);
//add the containments
g.AddChildVertex(vertices[0], vertices[1]);
g.AddChildVertex(vertices[0], vertices[2]);
g.AddChildVertex(vertices[3], vertices[4]);
g.AddChildVertex(vertices[3], vertices[5]);
g.AddChildVertex(vertices[3], vertices[6]);
g.AddChildVertex(vertices[3], vertices[7]);
g.AddChildVertex(vertices[3], vertices[8]);
g.AddChildVertex(vertices[3], vertices[9]);
//add the edges
g.AddEdge(new Edge<object>(vertices[2], vertices[4]));
g.AddEdge(new Edge<object>(vertices[1], vertices[5]));
//g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
graphs[SMALL_GRAPH] = g;
#endregion
#region Flat graph
g = new CompoundGraph<object, IEdge<object>>();
vertices = InitVertices(g, 10);
g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
g.AddEdge(new Edge<object>(vertices[1], vertices[2]));
g.AddEdge(new Edge<object>(vertices[2], vertices[3]));
g.AddEdge(new Edge<object>(vertices[3], vertices[0]));
g.AddEdge(new Edge<object>(vertices[1], vertices[3]));
g.AddEdge(new Edge<object>(vertices[2], vertices[0]));
graphs[FLAT_GRAPH] = g;
#endregion
#region Repulsion graph
g = new CompoundGraph<object, IEdge<object>>();
vertices = InitVertices(g, 50);
graphs[REP_GRAPH] = g;
#endregion
#region Star
g = new CompoundGraph<object, IEdge<object>>();
vertices = InitVertices(g, 13);
for (int i = 1; i < 13; i++ )
g.AddEdge(new Edge<object>(vertices[0], vertices[i]));
for (int i = 0; i < 4; i++)
{
g.AddEdge(new Edge<object>(vertices[i * 3 + 1], vertices[i * 3 + 2]));
g.AddEdge(new Edge<object>(vertices[i * 3 + 1], vertices[i * 3 + 3]));
g.AddEdge(new Edge<object>(vertices[i * 3 + 2], vertices[i * 3 + 3]));
}
graphs[STAR_GRAPH] = g;
#endregion
#region Combined
g = new CompoundGraph<object, IEdge<object>>();
vertices = InitVertices(g, 51);
//add the containments
g.AddChildVertex(vertices[0], vertices[1]);
g.AddChildVertex(vertices[0], vertices[2]);
//add the edges
g.AddEdge(new Edge<object>(vertices[2], vertices[3]));
g.AddEdge(new Edge<object>(vertices[3], vertices[4]));
g.AddEdge(new Edge<object>(vertices[10], vertices[11]));
g.AddEdge(new Edge<object>(vertices[11], vertices[12]));
g.AddEdge(new Edge<object>(vertices[12], vertices[13]));
g.AddEdge(new Edge<object>(vertices[13], vertices[10]));
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5 + 20], vertices[i + 20]);
}
g.AddChildVertex(vertices[25], vertices[24]);
g.AddChildVertex(vertices[25], vertices[22]);
g.AddChildVertex(vertices[36], vertices[20]);
g.AddChildVertex(vertices[36], vertices[21]);
g.AddChildVertex(vertices[36], vertices[23]);
g.AddEdge(new Edge<object>(vertices[20], vertices[21]));
g.AddEdge(new Edge<object>(vertices[20], vertices[22]));
g.AddEdge(new Edge<object>(vertices[22], vertices[24]));
g.AddEdge(new Edge<object>(vertices[20], vertices[27]));
g.AddEdge(new Edge<object>(vertices[28], vertices[27]));
g.AddEdge(new Edge<object>(vertices[4], vertices[39]));
g.AddEdge(new Edge<object>(vertices[39], vertices[40]));
g.AddEdge(new Edge<object>(vertices[39], vertices[41]));
g.AddEdge(new Edge<object>(vertices[39], vertices[42]));
g.AddEdge(new Edge<object>(vertices[42], vertices[43]));
g.AddEdge(new Edge<object>(vertices[42], vertices[44]));
g.AddEdge(new Edge<object>(vertices[1], vertices[45]));
g.AddEdge(new Edge<object>(vertices[45], vertices[46]));
g.AddEdge(new Edge<object>(vertices[45], vertices[47]));
g.AddEdge(new Edge<object>(vertices[45], vertices[48]));
g.AddEdge(new Edge<object>(vertices[48], vertices[49]));
g.AddEdge(new Edge<object>(vertices[48], vertices[50]));
graphs[COMBINED_GRAPH] = g;
#endregion
}
public ActionResult Index(float startingCaptial, float lowInterest, float highInterest, int intervals, int periods)
{
CompoundGraph graph = new CompoundGraph(startingCaptial, lowInterest, highInterest, intervals, periods);
return(View(graph));
}
void RecGraph(MainForm frm, string file)
{
var g = new CompoundGraph<object, IEdge<object>>();
var map = new Dictionary<uint, CodeBlock>();
string[] ent = File.ReadAllText(file).Split(new string[] { "block:" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string e in ent)
{
string[] st = e.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var entr = new CodeBlock();
entr["block"] = st[0];
for (int i = 1; i < st.Length; i++)
{
if (st[i] == "{")
break;
else
{
string[] lst = st[i].Split(new char[] { ':' }, 2);
if (lst.Length == 2)
{
entr[lst[0]] = lst[1];
}
}
}
map[entr.block] = entr;
}
map = map.Where(x => x.Value.runs > 0).ToDictionary(x => x.Key, x => x.Value);
long v = map.Sum(x => x.Value.cost);
CodeBlock.gcost = v;
double runcumsum = 0;
var intrnode = map.Values.OrderByDescending(x => x.cost).Where(x => (runcumsum += x.cost) < 0.60 * v).Take(1000).ToList();
var varp = intrnode.Select(x => x.hash);
long v1 = intrnode.Sum(x => x.cost);
foreach (var r in intrnode)
{
g.AddVertex(r);
}
var newstuff = new List<CodeBlock>();
reloop:
foreach (var r in intrnode)
{
CodeBlock va, vb;
if (map.TryGetValue(r["pNextBlock"], out va))
{
if (!g.ContainsVertex(va)) { newstuff.Add(va); g.AddVertex(va); v1 += va.cost; }
g.AddEdge(new Edge<object>(r, va));
}
if (map.TryGetValue(r["pBranchBlock"], out vb))
{
if (!g.ContainsVertex(vb)) { newstuff.Add(vb); g.AddVertex(vb); v1 += vb.cost; }
g.AddEdge(new Edge<object>(r, vb));
}
}
if (newstuff.Count != 0)
{
intrnode = newstuff;
newstuff = new List<CodeBlock>();
goto reloop;
}
frm.Text = "Showing " + v1 * 100 / v + "% (using " + g.VertexCount + " out of " + map.Count + ", " + g.VertexCount * 100 / map.Count + "% of blocks)";
var ordlst = map.Values.OrderByDescending(x => x.cost).ToList();
double rvv = 0;
foreach (var i in ordlst)
{
rvv += i.cost;
i.cumsum = rvv;
}
var cs = frm.chart2.Series.Add("CumSum(cost) / decrease(cost)");
var pr = frm.chart1.Series.Add("Cost / addr");
var bl = frm.chart1.Series.Add("gopc / addr");
var gs = frm.chart1.Series.Add("cycl / addr");
cs.ChartType = SeriesChartType.StepLine;
pr.ChartType = SeriesChartType.BoxPlot;
bl.ChartType = SeriesChartType.BoxPlot;
gs.ChartType = SeriesChartType.BoxPlot;
foreach (var i in ordlst)
{
cs.Points.AddY(i.cumsum * 100.0 / CodeBlock.gcost);
}
rvv = 0;
foreach (var i in ordlst.OrderBy(x => x.pos))
{
rvv += i.cost;
//if (rvv > v * 0.01)
{
pr.Points.AddXY(i.pos, Math.Log(i.cost + 1));
bl.Points.AddXY(i.pos, Math.Log(i.guest_opcodes + 1));
gs.Points.AddXY(i.pos, Math.Log(i.guest_cycles / 4 + 1));
}
}
/*
var vertices = new string[30];
for (int i = 0; i < 30; i++)
{
vertices[i] = i.ToString();
g.AddVertex(vertices[i]);
}
for (int i = 6; i < 15; i++)
{
g.AddChildVertex(vertices[i % 5], vertices[i]);
}
g.AddChildVertex(vertices[5], vertices[4]);
g.AddChildVertex(vertices[5], vertices[2]);
g.AddChildVertex(vertices[16], vertices[0]);
g.AddChildVertex(vertices[16], vertices[1]);
g.AddChildVertex(vertices[16], vertices[3]);
g.AddChildVertex(vertices[16], vertices[20]);
g.AddChildVertex(vertices[16], vertices[21]);
g.AddChildVertex(vertices[16], vertices[22]);
g.AddChildVertex(vertices[16], vertices[23]);
g.AddChildVertex(vertices[16], vertices[24]);
g.AddChildVertex(vertices[4], vertices[25]);
g.AddChildVertex(vertices[4], vertices[26]);
g.AddChildVertex(vertices[4], vertices[27]);
g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
g.AddEdge(new Edge<object>(vertices[0], vertices[2]));
g.AddEdge(new Edge<object>(vertices[2], vertices[4]));
g.AddEdge(new Edge<object>(vertices[0], vertices[7]));
g.AddEdge(new Edge<object>(vertices[8], vertices[7]));
//g.AddEdge(new Edge<object>(vertices[13], vertices[12]));
g.AddEdge(new Edge<object>(vertices[3], vertices[20]));
g.AddEdge(new Edge<object>(vertices[20], vertices[21]));
g.AddEdge(new Edge<object>(vertices[20], vertices[22]));
g.AddEdge(new Edge<object>(vertices[22], vertices[23]));
g.AddEdge(new Edge<object>(vertices[23], vertices[24]));
g.AddEdge(new Edge<object>(vertices[0], vertices[28]));
g.AddEdge(new Edge<object>(vertices[0], vertices[29]));
g.AddEdge(new Edge<object>(vertices[25], vertices[27]));
g.AddEdge(new Edge<object>(vertices[26], vertices[25]));
g.AddEdge(new Edge<object>(vertices[14], vertices[27]));
g.AddEdge(new Edge<object>(vertices[14], vertices[26]));
g.AddEdge(new Edge<object>(vertices[14], vertices[25]));
g.AddEdge(new Edge<object>(vertices[26], vertices[27]));
*/
layout.LayoutMode = LayoutMode.Automatic;
layout.LayoutAlgorithmType = "CompoundFDP";
layout.OverlapRemovalConstraint = AlgorithmConstraints.Automatic;
layout.OverlapRemovalAlgorithmType = "FSA";
layout.HighlightAlgorithmType = "Simple";
/*
using (FileStream w = File.Create("c:\\fail.bin"))
g.SerializeToBinary(w);
*/
layout.Graph = g;
}
public void OpenFile(string fileName)
{
//graph where the vertices and edges should be put in
var graph = new CompoundGraph<object, IEdge<object>>();
try
{
//open the file of the graph
var reader = XmlReader.Create(fileName);
//create the serializer
var serializer = new GraphMLDeserializer<object, IEdge<object>, CompoundGraph<object, IEdge<object>>>();
//deserialize the graph
serializer.Deserialize(reader, graph,
id => id, (source, target, id) => new Edge<object>(source, target)
);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
layout.Graph = graph;
layout.UpdateLayout();
}
private static double EvaluateFitnessForGraph(
[NotNull] CompoundFDPLayoutParameters chromosome,
[NotNull] CompoundGraph <object, IEdge <object> > compoundGraph)
{
var verticesSizes = new Dictionary <object, Size>();
var verticesBorders = new Dictionary <object, Thickness>();
var layoutTypes = new Dictionary <object, CompoundVertexInnerLayoutType>();
var size = new Size(20, 20);
foreach (object v in compoundGraph.SimpleVertices)
{
verticesSizes[v] = size;
}
var border = new Thickness(5, 10, 5, 5);
foreach (object v in compoundGraph.CompoundVertices)
{
verticesSizes[v] = new Size();
verticesBorders[v] = border;
layoutTypes[v] = CompoundVertexInnerLayoutType.Automatic;
}
// Run the compound FDP algorithm
var algorithm = new CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > >(
compoundGraph,
verticesSizes,
verticesBorders,
layoutTypes,
chromosome);
algorithm.Compute();
double fitness = 0.0;
// Refresh the sizes of the compound vertices
foreach (object v in compoundGraph.CompoundVertices)
{
Thickness b = verticesBorders[v];
Size innerCanvasSize = algorithm.InnerCanvasSizes[v];
var s = new Size(
b.Left + innerCanvasSize.Width + b.Right,
b.Top + innerCanvasSize.Height + b.Bottom);
verticesSizes[v] = s;
}
// NODE OVERLAP
double overlaps = EvaluateNodeOverlaps(compoundGraph, algorithm, verticesSizes);
fitness += overlaps * NodeOverlapMultiplier;
// CANVAS SIZE
Size canvasSize = EvaluateCanvasSize(compoundGraph, algorithm, verticesSizes);
fitness += canvasSize.Width * canvasSize.Height * CanvasSizeMultiplier;
// CANVAS RATIO
double canvasRatio = canvasSize.Width / canvasSize.Height;
canvasRatio = canvasRatio < 1 ? 1 / canvasRatio : canvasRatio;
fitness += canvasRatio * CanvasRatioMultiplier;
// NODE DISTANCES
double idealDistance = chromosome.IdealEdgeLength;
EvaluateNodeDistances(
compoundGraph,
algorithm,
verticesSizes,
out double minimalMinDistance,
out double averageMinDistance,
out double maximalMinDistance);
fitness += (averageMinDistance - idealDistance) * NodeDistanceMultiplier;
fitness += (minimalMinDistance - idealDistance) * NodeDistanceMultiplier;
fitness += (maximalMinDistance - idealDistance) * NodeDistanceMultiplier;
// EDGE LENGTH
double edgeLength = EvaluateEdgeLength(
compoundGraph,
algorithm,
verticesSizes,
chromosome.IdealEdgeLength,
chromosome.NestingFactor);
fitness += edgeLength * EdgeLengthMultiplier;
// EDGE CROSSING
double edgeCrossing = EvaluateEdgeCrossing(compoundGraph, algorithm, verticesSizes);
fitness += edgeCrossing * EdgeCrossingMultiplier;
// PHASE_LENGTH
double phaseLength = chromosome.Phase1Iterations + chromosome.Phase2Iterations + chromosome.Phase3Iterations;
phaseLength *= PhaseLengthMultiplier;
fitness += phaseLength;
return(fitness);
}
void RecGraph(MainForm frm, string file)
{
var g = new CompoundGraph <object, IEdge <object> >();
var map = new Dictionary <uint, CodeBlock>();
string[] ent = File.ReadAllText(file).Split(new string[] { "block:" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string e in ent)
{
string[] st = e.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var entr = new CodeBlock();
entr["block"] = st[0];
for (int i = 1; i < st.Length; i++)
{
if (st[i] == "{")
{
break;
}
else
{
string[] lst = st[i].Split(new char[] { ':' }, 2);
if (lst.Length == 2)
{
entr[lst[0]] = lst[1];
}
}
}
map[entr.block] = entr;
}
map = map.Where(x => x.Value.runs > 0).ToDictionary(x => x.Key, x => x.Value);
long v = map.Sum(x => x.Value.cost);
CodeBlock.gcost = v;
double runcumsum = 0;
var intrnode = map.Values.OrderByDescending(x => x.cost).Where(x => (runcumsum += x.cost) < 0.60 * v).Take(1000).ToList();
var varp = intrnode.Select(x => x.hash);
long v1 = intrnode.Sum(x => x.cost);
foreach (var r in intrnode)
{
g.AddVertex(r);
}
var newstuff = new List <CodeBlock>();
reloop:
foreach (var r in intrnode)
{
CodeBlock va, vb;
if (map.TryGetValue(r["pNextBlock"], out va))
{
if (!g.ContainsVertex(va))
{
newstuff.Add(va); g.AddVertex(va); v1 += va.cost;
}
g.AddEdge(new Edge <object>(r, va));
}
if (map.TryGetValue(r["pBranchBlock"], out vb))
{
if (!g.ContainsVertex(vb))
{
newstuff.Add(vb); g.AddVertex(vb); v1 += vb.cost;
}
g.AddEdge(new Edge <object>(r, vb));
}
}
if (newstuff.Count != 0)
{
intrnode = newstuff;
newstuff = new List <CodeBlock>();
goto reloop;
}
frm.Text = "Showing " + v1 * 100 / v + "% (using " + g.VertexCount + " out of " + map.Count + ", " + g.VertexCount * 100 / map.Count + "% of blocks)";
var ordlst = map.Values.OrderByDescending(x => x.cost).ToList();
double rvv = 0;
foreach (var i in ordlst)
{
rvv += i.cost;
i.cumsum = rvv;
}
var cs = frm.chart2.Series.Add("CumSum(cost) / decrease(cost)");
var pr = frm.chart1.Series.Add("Cost / addr");
var bl = frm.chart1.Series.Add("gopc / addr");
var gs = frm.chart1.Series.Add("cycl / addr");
cs.ChartType = SeriesChartType.StepLine;
pr.ChartType = SeriesChartType.BoxPlot;
bl.ChartType = SeriesChartType.BoxPlot;
gs.ChartType = SeriesChartType.BoxPlot;
foreach (var i in ordlst)
{
cs.Points.AddY(i.cumsum * 100.0 / CodeBlock.gcost);
}
rvv = 0;
foreach (var i in ordlst.OrderBy(x => x.pos))
{
rvv += i.cost;
//if (rvv > v * 0.01)
{
pr.Points.AddXY(i.pos, Math.Log(i.cost + 1));
bl.Points.AddXY(i.pos, Math.Log(i.guest_opcodes + 1));
gs.Points.AddXY(i.pos, Math.Log(i.guest_cycles / 4 + 1));
}
}
/*
* var vertices = new string[30];
*
* for (int i = 0; i < 30; i++)
* {
* vertices[i] = i.ToString();
* g.AddVertex(vertices[i]);
* }
*
* for (int i = 6; i < 15; i++)
* {
* g.AddChildVertex(vertices[i % 5], vertices[i]);
* }
* g.AddChildVertex(vertices[5], vertices[4]);
* g.AddChildVertex(vertices[5], vertices[2]);
* g.AddChildVertex(vertices[16], vertices[0]);
* g.AddChildVertex(vertices[16], vertices[1]);
* g.AddChildVertex(vertices[16], vertices[3]);
* g.AddChildVertex(vertices[16], vertices[20]);
* g.AddChildVertex(vertices[16], vertices[21]);
* g.AddChildVertex(vertices[16], vertices[22]);
* g.AddChildVertex(vertices[16], vertices[23]);
* g.AddChildVertex(vertices[16], vertices[24]);
* g.AddChildVertex(vertices[4], vertices[25]);
* g.AddChildVertex(vertices[4], vertices[26]);
* g.AddChildVertex(vertices[4], vertices[27]);
*
* g.AddEdge(new Edge<object>(vertices[0], vertices[1]));
* g.AddEdge(new Edge<object>(vertices[0], vertices[2]));
* g.AddEdge(new Edge<object>(vertices[2], vertices[4]));
* g.AddEdge(new Edge<object>(vertices[0], vertices[7]));
* g.AddEdge(new Edge<object>(vertices[8], vertices[7]));
* //g.AddEdge(new Edge<object>(vertices[13], vertices[12]));
* g.AddEdge(new Edge<object>(vertices[3], vertices[20]));
* g.AddEdge(new Edge<object>(vertices[20], vertices[21]));
* g.AddEdge(new Edge<object>(vertices[20], vertices[22]));
* g.AddEdge(new Edge<object>(vertices[22], vertices[23]));
* g.AddEdge(new Edge<object>(vertices[23], vertices[24]));
* g.AddEdge(new Edge<object>(vertices[0], vertices[28]));
* g.AddEdge(new Edge<object>(vertices[0], vertices[29]));
* g.AddEdge(new Edge<object>(vertices[25], vertices[27]));
* g.AddEdge(new Edge<object>(vertices[26], vertices[25]));
* g.AddEdge(new Edge<object>(vertices[14], vertices[27]));
* g.AddEdge(new Edge<object>(vertices[14], vertices[26]));
* g.AddEdge(new Edge<object>(vertices[14], vertices[25]));
* g.AddEdge(new Edge<object>(vertices[26], vertices[27]));
*/
layout.LayoutMode = LayoutMode.Automatic;
layout.LayoutAlgorithmType = "CompoundFDP";
layout.OverlapRemovalConstraint = AlgorithmConstraints.Automatic;
layout.OverlapRemovalAlgorithmType = "FSA";
layout.HighlightAlgorithmType = "Simple";
/*
* using (FileStream w = File.Create("c:\\fail.bin"))
* g.SerializeToBinary(w);
*/
layout.Graph = g;
}
