public JazzGraphContainer(int index, string name, Control view)
{
this.Index = index;
this.mName = name ?? "";
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Dirty;
ulong iid = 0;
if (!this.mName.StartsWith("0x") ||
!ulong.TryParse(this.mName.Substring(2),
System.Globalization.NumberStyles.HexNumber,
null, out iid))
{
iid = FNVHash.HashString64(this.mName);
}
this.Key = new RK(GlobalManager.kJazzTID, 0, iid);
this.Comp = true;
this.JP = null;
this.RIE = null;
StateMachine sm = new StateMachine(name);
this.Scene = new StateMachineScene(sm, view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
}
private void ComputeLayout()
{
KKLayoutParameters kkp = new KKLayoutParameters();
kkp.Height = 600;
kkp.Width = 900;
kkp.MaxIterations = 1500;
kkp.AdjustForGravity = true;
kkp.ExchangeVertices = true;
KKLayoutAlgorithm<FlockVertex, FlockEdge, FlockGraphDirected> kka;
kka = new KKLayoutAlgorithm<FlockVertex, FlockEdge, FlockGraphDirected>(directed, kkp);
kka.IterationEnded += new LayoutIterationEndedEventHandler<FlockVertex, FlockEdge>(kka_IterationEnded);
kka.Compute();
//Get Points, Set Size
for (int i = 0; i < directed.VertexCount; i++)
{
FlockVertex v = directed.Vertices.ElementAt(i);
Point point = kka.VertexPositions.ElementAt(i).Value;
Size size = v.VertexSize;
v.FlockRect = new Rect(point, size);
}
}
public JazzGraphContainer(int index,
StateMachine sm, Control view, TabPage page)
{
this.Index = index;
this.mName = sm.Name;
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Dirty;
this.Key = new RK(GlobalManager.kJazzTID, 0,
FNVHash.HashString64(this.mName));
this.Comp = true;
this.JP = null;
this.RIE = null;
this.Scene = new StateMachineScene(sm, view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
this.mPage = page;
this.mPage.Controls.Add(view);
this.mPage.Text = this.mName + " *";
this.mPage.SizeChanged +=
new EventHandler(this.OnTabSizeChanged);
}
public void KKLayoutAlgorithm(
[NotNull] IBidirectionalGraph <string, Edge <string> > graph,
int maxCrossCount)
{
IDictionary <string, Size> verticesSizes = GetVerticesSizes(graph.Vertices);
var parameters = new KKLayoutParameters
{
Width = 1000,
Height = 1000
};
foreach (bool exchange in new[] { true, false })
{
parameters.ExchangeVertices = exchange;
int iteration = 0;
var algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(
graph,
parameters)
{
Rand = new Random(12345)
};
algorithm.IterationEnded += (sender, args) =>
{
Assert.LessOrEqual(args.Iteration, parameters.MaxIterations);
Assert.AreEqual(iteration++, args.Iteration);
};
LayoutResults results = ExecuteLayoutAlgorithm(algorithm, verticesSizes, true);
results.CheckResult(maxCrossCount);
}
}
public void Constructor()
{
var verticesPositions = new Dictionary <string, Point>();
var graph = new BidirectionalGraph <string, Edge <string> >();
var algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph);
algorithm.IterationEnded += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true);
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph);
algorithm.ProgressChanged += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportProgress: true);
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph);
algorithm.IterationEnded += (sender, args) => { };
algorithm.ProgressChanged += (sender, args) => { };
AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true, expectedReportProgress: true);
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions);
AssertAlgorithmProperties(algorithm, graph, verticesPositions);
var parameters = new KKLayoutParameters();
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, parameters);
AssertAlgorithmProperties(algorithm, graph, parameters: parameters);
algorithm = new KKLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, parameters);
AssertAlgorithmProperties(algorithm, graph, verticesPositions, parameters: parameters);
}
public JazzGraphContainer(int index, JazzPackage jp,
IResourceIndexEntry rie, Control view, TabPage page)
{
this.Index = index;
this.UndoRedo = new UndoManager();
this.SaveState = JazzSaveState.Saved;
this.Key = new RK(rie);
this.Comp = rie.Compressed == 0xFFFF;
this.JP = jp;
this.RIE = rie;
IResource res = null;
GenericRCOLResource rcol = null;
try
{
res = WrapperDealer.GetResource(0, jp.Package, rie);
}
catch (Exception ex)
{
MainForm.ShowException(ex,
"Could not load JAZZ resource: " + this.Key + "\n",
MainForm.kName + ": Unable to load JAZZ resource");
}
if (res != null)
{
rcol = res as GenericRCOLResource;
if (rcol != null)
{
this.Scene = new StateMachineScene(
new StateMachine(rcol), view, this);
KKLayoutAlgorithm <StateNode, StateEdge> layout
= new KKLayoutAlgorithm <StateNode, StateEdge>(
this.Scene.StateGraph, this.Scene);
layout.LengthFactor = 1.25f;
this.Scene.Layout = layout;
layout.ShuffleNodes();
this.Scene.LayoutPaused = true;
this.Scene.StartLayout();
}
else
{
this.Scene = null;
}
}
if (!KeyNameReg.TryFindName(rie.Instance, out this.mName))
{
this.mName = "0x" + rie.Instance.ToString("X16");
}
if (this.Scene != null)
{
this.mPage = page;
this.mPage.Controls.Add(view);
this.mPage.Text = this.mName;
this.mPage.SizeChanged +=
new EventHandler(this.OnTabSizeChanged);
}
}
/// <summary>
/// Performs the actual layout algorithm.
/// </summary>
/// <param name="graph">The object containing the graph data</param>
/// <param name="rootNode">Root node</param>
protected override void PerformLayout(GraphMapData graph, INode rootNode)
{
BidirectionalGraph<string, WeightedEdge<string>> bGraph = GraphSharpUtility.GetBidirectionalGraph(graph);
IDictionary<string, Vector> nodePositions = GraphSharpUtility.GetNodePositions(graph);
KKLayoutParameters kkLayoutParameters = new KKLayoutParameters();
KKLayoutAlgorithm<string, WeightedEdge<string>, BidirectionalGraph<string, WeightedEdge<string>>> kkLayoutAlgorithm = new KKLayoutAlgorithm<string, WeightedEdge<string>, BidirectionalGraph<string, WeightedEdge<string>>>(bGraph, nodePositions, kkLayoutParameters);
kkLayoutAlgorithm.Compute();
GraphSharpUtility.SetNodePositions(graph, kkLayoutAlgorithm.VertexPositions);
GraphSharpUtility.FSAOverlapRemoval(graph);
}
static SettingsDialog()
{
sKKLayoutSettings = new KKLayoutAlgorithm <StateNode, StateEdge>(
new Digraph <StateNode, StateEdge>(), new Box2F(0, 0, 1, 1));
sKKLayoutSettings.LengthFactor = 1.25f;
sBalloonCirclesLayoutSettings = new BalloonCirclesLayoutAlgorithm2 <StateNode, StateEdge>(
new Digraph <StateNode, StateEdge>(), new Box2F(0, 0, 1, 1));
sSimpleTreeLayoutSettings = new SimpleTreeLayoutAlgorithm <DGNode, DGEdge>(
new Digraph <DGNode, DGEdge>(), new Box2F(0, 0, 1, 1));
sSimpleTreeLayoutSettings.LayerGap = 30;
}
static SettingsDialog()
{
sKKLayoutSettings = new KKLayoutAlgorithm<StateNode, StateEdge>(
new Digraph<StateNode, StateEdge>(), new Box2F(0, 0, 1, 1));
sKKLayoutSettings.LengthFactor = 1.25f;
sBalloonCirclesLayoutSettings = new BalloonCirclesLayoutAlgorithm2<StateNode, StateEdge>(
new Digraph<StateNode, StateEdge>(), new Box2F(0, 0, 1, 1));
sSimpleTreeLayoutSettings = new SimpleTreeLayoutAlgorithm<DGNode, DGEdge>(
new Digraph<DGNode, DGEdge>(), new Box2F(0, 0, 1, 1));
sSimpleTreeLayoutSettings.LayerGap = 30;
}
private static void CopyLayoutSettings(
KKLayoutAlgorithm <StateNode, StateEdge> source,
KKLayoutAlgorithm <StateNode, StateEdge> target)
{
if (target.State != ComputeState.Running &&
target.AsyncState != ComputeState.Running)
{
target.MaxIterations = source.MaxIterations;
target.MovementTolerance = source.MovementTolerance;
}
target.K = source.K;
target.AdjustForGravity = source.AdjustForGravity;
target.ExchangeVertices = source.ExchangeVertices;
target.LengthFactor = source.LengthFactor;
target.DisconnectedMultiplier = source.DisconnectedMultiplier;
}
private static void CopyLayoutSettings(
KKLayoutAlgorithm<StateNode, StateEdge> source,
KKLayoutAlgorithm<StateNode, StateEdge> target)
{
if (target.State != ComputeState.Running &&
target.AsyncState != ComputeState.Running)
{
target.MaxIterations = source.MaxIterations;
target.MovementTolerance = source.MovementTolerance;
}
target.K = source.K;
target.AdjustForGravity = source.AdjustForGravity;
target.ExchangeVertices = source.ExchangeVertices;
target.LengthFactor = source.LengthFactor;
target.DisconnectedMultiplier = source.DisconnectedMultiplier;
}
/// <summary>
/// Performs the actual layout algorithm.
/// </summary>
/// <param name="graph">The object containing the graph data</param>
/// <param name="rootNode">Root node</param>
protected override void PerformLayout(GraphMapData graph, INode rootNode)
{
BidirectionalGraph <string, WeightedEdge <string> > bGraph = GraphSharpUtility.GetBidirectionalGraph(graph);
IDictionary <string, Vector> nodePositions = GraphSharpUtility.GetNodePositions(graph);
KKLayoutParameters kkLayoutParameters = new KKLayoutParameters();
KKLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > > kkLayoutAlgorithm = new KKLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > >(bGraph, nodePositions, kkLayoutParameters);
kkLayoutAlgorithm.Compute();
GraphSharpUtility.SetNodePositions(graph, kkLayoutAlgorithm.VertexPositions);
GraphSharpUtility.FSAOverlapRemoval(graph);
}
public void StandardFactory()
{
var positions = new Dictionary <TestVertex, Point>();
var sizes = new Dictionary <TestVertex, Size>();
var borders = new Dictionary <TestVertex, Thickness>();
var layoutTypes = new Dictionary <TestVertex, CompoundVertexInnerLayoutType>();
var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var simpleContext = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Simple);
var compoundContext1 = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Compound);
var compoundContext2 = new CompoundLayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
positions,
sizes,
LayoutMode.Compound,
borders,
layoutTypes);
var nullGraphContext = new LayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
null,
positions,
sizes,
LayoutMode.Simple);
var factory = new StandardLayoutAlgorithmFactory <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >();
CollectionAssert.AreEqual(
new[]
{
"Circular", "Tree", "FR", "BoundedFR", "KK",
"ISOM", "LinLog", "Sugiyama", "CompoundFDP",
"Random"
},
factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
simpleContext,
new CircularLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"NotExist",
simpleContext,
new CircularLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"Circular",
nullGraphContext,
new CircularLayoutParameters()));
Assert.IsInstanceOf <CircularLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Circular",
simpleContext,
new CircularLayoutParameters()));
Assert.IsInstanceOf <SimpleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Tree",
simpleContext,
new SimpleTreeLayoutParameters()));
Assert.IsInstanceOf <FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"FR",
simpleContext,
new FreeFRLayoutParameters()));
Assert.IsInstanceOf <FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"BoundedFR",
simpleContext,
new BoundedFRLayoutParameters()));
Assert.IsInstanceOf <KKLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"KK",
simpleContext,
new KKLayoutParameters()));
Assert.IsInstanceOf <ISOMLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"ISOM",
simpleContext,
new ISOMLayoutParameters()));
Assert.IsInstanceOf <LinLogLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"LinLog",
simpleContext,
new LinLogLayoutParameters()));
Assert.IsInstanceOf <SugiyamaLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Sugiyama",
simpleContext,
new SugiyamaLayoutParameters()));
Assert.IsInstanceOf <CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"CompoundFDP",
simpleContext,
new CompoundFDPLayoutParameters()));
Assert.IsInstanceOf <RandomLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"Random",
simpleContext,
new RandomLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"CompoundFDP",
compoundContext1,
new CompoundFDPLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"Circular",
compoundContext2,
new CompoundFDPLayoutParameters()));
Assert.IsInstanceOf <CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"CompoundFDP",
compoundContext2,
new CompoundFDPLayoutParameters()));
var testParameters = new TestLayoutParameters();
var circularParameters = new CircularLayoutParameters();
ILayoutParameters createdParameters = factory.CreateParameters(string.Empty, circularParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("NotExist", circularParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("Circular", null);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(circularParameters, createdParameters);
createdParameters = factory.CreateParameters("Circular", testParameters);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("Circular", circularParameters);
Assert.IsInstanceOf <CircularLayoutParameters>(createdParameters);
Assert.AreNotSame(circularParameters, createdParameters);
var treeParameters = new SimpleTreeLayoutParameters();
createdParameters = factory.CreateParameters("Tree", null);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Tree", testParameters);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("Tree", treeParameters);
Assert.IsInstanceOf <SimpleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
var frParameters = new FreeFRLayoutParameters();
createdParameters = factory.CreateParameters("FR", null);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(frParameters, createdParameters);
createdParameters = factory.CreateParameters("FR", testParameters);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("FR", frParameters);
Assert.IsInstanceOf <FreeFRLayoutParameters>(createdParameters);
Assert.AreNotSame(frParameters, createdParameters);
var boundedFrParameters = new BoundedFRLayoutParameters();
createdParameters = factory.CreateParameters("BoundedFR", null);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(boundedFrParameters, createdParameters);
createdParameters = factory.CreateParameters("BoundedFR", testParameters);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("BoundedFR", boundedFrParameters);
Assert.IsInstanceOf <BoundedFRLayoutParameters>(createdParameters);
Assert.AreNotSame(boundedFrParameters, createdParameters);
var kkParameters = new KKLayoutParameters();
createdParameters = factory.CreateParameters("KK", null);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(kkParameters, createdParameters);
createdParameters = factory.CreateParameters("KK", testParameters);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("KK", kkParameters);
Assert.IsInstanceOf <KKLayoutParameters>(createdParameters);
Assert.AreNotSame(kkParameters, createdParameters);
var isomParameters = new ISOMLayoutParameters();
createdParameters = factory.CreateParameters("ISOM", null);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(isomParameters, createdParameters);
createdParameters = factory.CreateParameters("ISOM", testParameters);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("ISOM", isomParameters);
Assert.IsInstanceOf <ISOMLayoutParameters>(createdParameters);
Assert.AreNotSame(isomParameters, createdParameters);
var linLogParameters = new LinLogLayoutParameters();
createdParameters = factory.CreateParameters("LinLog", null);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(linLogParameters, createdParameters);
createdParameters = factory.CreateParameters("LinLog", testParameters);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("LinLog", linLogParameters);
Assert.IsInstanceOf <LinLogLayoutParameters>(createdParameters);
Assert.AreNotSame(linLogParameters, createdParameters);
var sugiyamaParameters = new SugiyamaLayoutParameters();
createdParameters = factory.CreateParameters("Sugiyama", null);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(sugiyamaParameters, createdParameters);
createdParameters = factory.CreateParameters("Sugiyama", testParameters);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Sugiyama", sugiyamaParameters);
Assert.IsInstanceOf <SugiyamaLayoutParameters>(createdParameters);
Assert.AreNotSame(sugiyamaParameters, createdParameters);
var compoundFDPParameters = new CompoundFDPLayoutParameters();
createdParameters = factory.CreateParameters("CompoundFDP", null);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(compoundFDPParameters, createdParameters);
createdParameters = factory.CreateParameters("CompoundFDP", testParameters);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("CompoundFDP", compoundFDPParameters);
Assert.IsInstanceOf <CompoundFDPLayoutParameters>(createdParameters);
Assert.AreNotSame(compoundFDPParameters, createdParameters);
var randomParameters = new RandomLayoutParameters();
createdParameters = factory.CreateParameters("Random", null);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(randomParameters, createdParameters);
createdParameters = factory.CreateParameters("Random", testParameters);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(treeParameters, createdParameters);
createdParameters = factory.CreateParameters("Random", randomParameters);
Assert.IsInstanceOf <RandomLayoutParameters>(createdParameters);
Assert.AreNotSame(randomParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("Circular"));
Assert.IsFalse(factory.IsValidAlgorithm("circular"));
Assert.IsTrue(factory.IsValidAlgorithm("Tree"));
Assert.IsTrue(factory.IsValidAlgorithm("FR"));
Assert.IsTrue(factory.IsValidAlgorithm("BoundedFR"));
Assert.IsTrue(factory.IsValidAlgorithm("KK"));
Assert.IsTrue(factory.IsValidAlgorithm("ISOM"));
Assert.IsTrue(factory.IsValidAlgorithm("LinLog"));
Assert.IsTrue(factory.IsValidAlgorithm("Sugiyama"));
Assert.IsTrue(factory.IsValidAlgorithm("CompoundFDP"));
Assert.IsTrue(factory.IsValidAlgorithm("Random"));
var algorithm1 = new TestLayoutAlgorithm();
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new CircularLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, circularParameters);
Assert.AreEqual("Circular", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new SimpleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, treeParameters);
Assert.AreEqual("Tree", factory.GetAlgorithmType(algorithm3));
var algorithm4 = new FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, frParameters);
Assert.AreEqual("FR", factory.GetAlgorithmType(algorithm4));
var algorithm5 = new FRLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, boundedFrParameters);
Assert.AreEqual("BoundedFR", factory.GetAlgorithmType(algorithm5));
var algorithm6 = new KKLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, kkParameters);
Assert.AreEqual("KK", factory.GetAlgorithmType(algorithm6));
var algorithm7 = new ISOMLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, isomParameters);
Assert.AreEqual("ISOM", factory.GetAlgorithmType(algorithm7));
var algorithm8 = new LinLogLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph);
Assert.AreEqual("LinLog", factory.GetAlgorithmType(algorithm8));
var algorithm9 = new SugiyamaLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, sugiyamaParameters);
Assert.AreEqual("Sugiyama", factory.GetAlgorithmType(algorithm9));
var algorithm10 = new CompoundFDPLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, sizes, borders, layoutTypes);
Assert.AreEqual("CompoundFDP", factory.GetAlgorithmType(algorithm10));
var algorithm11 = new RandomLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, sizes, null, randomParameters);
Assert.AreEqual("Random", factory.GetAlgorithmType(algorithm11));
Assert.IsFalse(factory.NeedEdgeRouting(string.Empty));
Assert.IsTrue(factory.NeedEdgeRouting("Circular"));
Assert.IsTrue(factory.NeedEdgeRouting("Tree"));
Assert.IsTrue(factory.NeedEdgeRouting("FR"));
Assert.IsTrue(factory.NeedEdgeRouting("BoundedFR"));
Assert.IsTrue(factory.NeedEdgeRouting("KK"));
Assert.IsTrue(factory.NeedEdgeRouting("ISOM"));
Assert.IsTrue(factory.NeedEdgeRouting("LinLog"));
Assert.IsFalse(factory.NeedEdgeRouting("Sugiyama"));
Assert.IsTrue(factory.NeedEdgeRouting("CompoundFDP"));
Assert.IsTrue(factory.NeedEdgeRouting("Random"));
Assert.IsFalse(factory.NeedOverlapRemoval(string.Empty));
Assert.IsFalse(factory.NeedOverlapRemoval("Circular"));
Assert.IsFalse(factory.NeedOverlapRemoval("Tree"));
Assert.IsTrue(factory.NeedOverlapRemoval("FR"));
Assert.IsTrue(factory.NeedOverlapRemoval("BoundedFR"));
Assert.IsTrue(factory.NeedOverlapRemoval("KK"));
Assert.IsTrue(factory.NeedOverlapRemoval("ISOM"));
Assert.IsTrue(factory.NeedOverlapRemoval("LinLog"));
Assert.IsFalse(factory.NeedOverlapRemoval("Sugiyama"));
Assert.IsFalse(factory.NeedOverlapRemoval("CompoundFDP"));
Assert.IsTrue(factory.NeedOverlapRemoval("Random"));
}
