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);
}
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(CultureInfo.InvariantCulture);
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[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;
}
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
}
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 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 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
}