public void InvalidParameters() { var parameters = new SimpleTreeLayoutParameters(); Assert.Throws <ArgumentOutOfRangeException>(() => parameters.VertexGap = -1); Assert.Throws <ArgumentOutOfRangeException>(() => parameters.LayerGap = -1); }
public void SimpleTreeLayoutAlgorithm( [NotNull] IBidirectionalGraph <string, Edge <string> > graph, int maxCrossCount) { IDictionary <string, Size> verticesSizes = GetVerticesSizes(graph.Vertices); var parameters = new SimpleTreeLayoutParameters { LayerGap = 15, VertexGap = 20 }; foreach (LayoutDirection direction in Enum.GetValues(typeof(LayoutDirection))) { parameters.Direction = direction; foreach (SpanningTreeGeneration treeGen in Enum.GetValues(typeof(SpanningTreeGeneration))) { parameters.SpanningTreeGeneration = treeGen; var algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >( graph, verticesSizes, parameters); LayoutResults results = ExecuteLayoutAlgorithm(algorithm, verticesSizes); results.CheckResult(maxCrossCount); CheckTreeLayout(algorithm, verticesSizes); } } }
/// <summary> /// Initializes a new instance of the <see cref="DatasetGraphModel"/> class. /// </summary> /// <param name="context">The context that is used to execute actions on the UI thread.</param> /// <param name="facade">The project that holds the graph of datasets.</param> /// <param name="datasetModelBuilder">The function that builds <see cref="DatasetModel"/> objects.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="context"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="facade"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="datasetModelBuilder"/> is <see langword="null" />. /// </exception> public DatasetGraphModel( IContextAware context, ProjectFacade facade, Func <DatasetFacade, DatasetModel> datasetModelBuilder) : base(context) { { Enforce.Argument(() => facade); } m_Project = facade; m_Project.OnDatasetCreated += (s, e) => AddDatasetToGraph(); m_Project.OnDatasetDeleted += (s, e) => RemoveDatasetFromGraph(); m_DatasetModelBuilder = datasetModelBuilder; LayoutType = "Tree"; LayoutParameters = new SimpleTreeLayoutParameters { LayerGap = 250, VertexGap = 250, Direction = LayoutDirection.TopToBottom, }; ReloadProject(); }
public void Constructor_Throws() { var verticesPositions = new Dictionary <string, Point>(); var verticesSizes = new Dictionary <string, Size>(); var graph = new BidirectionalGraph <string, Edge <string> >(); var parameters = new SimpleTreeLayoutParameters(); // ReSharper disable ObjectCreationAsStatement // ReSharper disable AssignNullToNotNullAttribute Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesSizes)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesSizes, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, (IDictionary <string, Size>)null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, verticesSizes)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, (IDictionary <string, Size>)null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, verticesSizes)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, null)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, null, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, verticesSizes, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, null, null, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, null, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, verticesSizes, parameters)); Assert.Throws <ArgumentNullException>( () => new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, null, parameters)); // ReSharper restore AssignNullToNotNullAttribute // ReSharper restore ObjectCreationAsStatement }
public ParallelStacksGraphLayout() { // TODO : Replace the current tree layout with EfficientSugiyama layout when Direction is available for this type of layout var par = new SimpleTreeLayoutParameters(); par.LayerGap = 30; par.VertexGap = 50; par.Direction = LayoutDirection.BottomToTop; par.SpanningTreeGeneration = SpanningTreeGeneration.DFS; this.LayoutParameters = par; }
/// <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); IDictionary <string, Size> nodeSizes = GraphSharpUtility.GetNodeSizes(graph); SimpleTreeLayoutParameters simpleTreeLayoutParameters = new SimpleTreeLayoutParameters(); SimpleTreeLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > > simpleTreeLayoutAlgorithm = new SimpleTreeLayoutAlgorithm <string, WeightedEdge <string>, BidirectionalGraph <string, WeightedEdge <string> > >(bGraph, nodePositions, nodeSizes, simpleTreeLayoutParameters); simpleTreeLayoutAlgorithm.Compute(); GraphSharpUtility.SetNodePositions(graph, simpleTreeLayoutAlgorithm.VertexPositions); }
public MainWindowViewModel(List <string> allProcess, List <ProcessTreeMine> psTree) { allProcessString = allProcess; psTreeMine = psTree; Graph = new PocGraph(true); allProcess.RemoveRange(0, 2); List <PocVertex> existingVertices = new List <PocVertex>(); existingVertices.Add(new PocVertex("Start_Process", true)); foreach (var item in allProcess) { if (HashClass.UnPermittedProcess.FirstOrDefault(x => item.ToLower().Contains(x.ToLower().Replace(".exe", ""))) != null) { existingVertices.Add(new PocVertex(item, false, item)); } else { existingVertices.Add(new PocVertex(item, true, item)); } } foreach (var existingVertex in existingVertices) { Graph.AddVertex(existingVertex); } foreach (var item in psTree) { AddNewGraphEdge(existingVertices[0], existingVertices.FirstOrDefault(x => x.ID == item.fatherName) ?? new PocVertex("NullProcess", false)); if (item.ChildList.Count > 0) { foreach (var processTreeMine in item.ChildList) { GenerateTree(processTreeMine, item.fatherName, existingVertices); } } //else //{ // AddNewGraphEdge(existingVertices[0], existingVertices.FirstOrDefault(x => x.ID==item.fatherName)??new PocVertex("NullProcess",false)); //} } TreeLayoutParameters = new SimpleTreeLayoutParameters(); TreeLayoutParameters.Direction = GraphSharp.Algorithms.Layout.LayoutDirection.TopToBottom; //THIS IS WHAT YOU EXPECT TreeLayoutParameters.LayerGap = 200.0; TreeLayoutParameters.OptimizeWidthAndHeight = true; //TreeLayoutParameters.SpanningTreeGeneration =SpanningTreeGeneration.DFS; TreeLayoutParameters.VertexGap = 1.0; TreeLayoutParameters.WidthPerHeight = 1.0; ConfigLayoutAlgorithmType(); //Pick a default Layout Algorithm Type LayoutAlgorithmType = "ISOM"; }
public void Clone() { var parameters = new SimpleTreeLayoutParameters(); var clonedParameters = (SimpleTreeLayoutParameters)parameters.Clone(); Assert.AreEqual(parameters, clonedParameters); parameters = new SimpleTreeLayoutParameters(); parameters.Direction = LayoutDirection.LeftToRight; parameters.VertexGap = 50; parameters.LayerGap = 50; parameters.SpanningTreeGeneration = SpanningTreeGeneration.BFS; clonedParameters = (SimpleTreeLayoutParameters)parameters.Clone(); Assert.AreEqual(parameters, clonedParameters); }
public void ParameterRaise() { string expectedPropertyName = null; var parameters = new SimpleTreeLayoutParameters(); parameters.PropertyChanged += (sender, args) => { // ReSharper disable AccessToModifiedClosure if (expectedPropertyName is null) { Assert.Fail("Must not raise."); } else { Assert.AreEqual(expectedPropertyName, args.PropertyName); } // ReSharper restore AccessToModifiedClosure }; parameters.Direction = LayoutDirection.TopToBottom; expectedPropertyName = nameof(SimpleTreeLayoutParameters.Direction); parameters.Direction = LayoutDirection.BottomToTop; expectedPropertyName = null; parameters.VertexGap = 10; expectedPropertyName = nameof(SimpleTreeLayoutParameters.VertexGap); parameters.VertexGap = 42; expectedPropertyName = null; parameters.LayerGap = 10; expectedPropertyName = nameof(SimpleTreeLayoutParameters.LayerGap); parameters.LayerGap = 42; expectedPropertyName = null; parameters.SpanningTreeGeneration = SpanningTreeGeneration.DFS; expectedPropertyName = nameof(SimpleTreeLayoutParameters.SpanningTreeGeneration); parameters.SpanningTreeGeneration = SpanningTreeGeneration.BFS; }
/// <summary> /// Creates a new instance of <see cref="PointedTreeGraphLayout"/>. /// </summary> public PointedTreeGraphLayout() { HighlightAlgorithmType = "Simple"; LayoutAlgorithmType = "Tree"; OverlapRemovalAlgorithmType = "FSA"; OverlapRemovalConstraint = AlgorithmConstraints.Must; OverlapRemovalParameters = new OverlapRemovalParameters { HorizontalGap = 10, VerticalGap = 10 }; LayoutParameters = new SimpleTreeLayoutParameters { VertexGap = 10, Direction = LayoutDirection.TopToBottom, SpanningTreeGeneration = SpanningTreeGeneration.DFS }; AnimationLength = new TimeSpan(0); IsAnimationEnabled = false; }
private ILayoutParameters GetParameter(string type) { switch (type) { case "Tree": var treeParam = new SimpleTreeLayoutParameters(); treeParam.Direction = LayoutDirection.BottomToTop; treeParam.LayerGap = 20; treeParam.SpanningTreeGeneration = SpanningTreeGeneration.BFS; treeParam.VertexGap = 20.0; treeParam.WidthPerHeight = 50; return(treeParam); case "BoundedFR": var frParam = new BoundedFRLayoutParameters(); return(frParam); case "ISOM": var isomParam = new ISOMLayoutParameters(); return(isomParam); case "LinLog": var linlogParam = new LinLogLayoutParameters(); return(linlogParam); case "EfficientSugiyama": var sugiyamaParam = new EfficientSugiyamaLayoutParameters(); sugiyamaParam.EdgeRouting = SugiyamaEdgeRoutings.Orthogonal; sugiyamaParam.WidthPerHeight = 5; return(sugiyamaParam); default: return(null); } }
public void Constructor() { var verticesPositions = new Dictionary <string, Point>(); var verticesSizes = new Dictionary <string, Size>(); var graph = new BidirectionalGraph <string, Edge <string> >(); var algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes); AssertAlgorithmProperties(algorithm, graph); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes); algorithm.IterationEnded += (sender, args) => { }; AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes); algorithm.ProgressChanged += (sender, args) => { }; AssertAlgorithmProperties(algorithm, graph, expectedReportProgress: true); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes); algorithm.IterationEnded += (sender, args) => { }; algorithm.ProgressChanged += (sender, args) => { }; AssertAlgorithmProperties(algorithm, graph, expectedReportIterationEnd: true, expectedReportProgress: true); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, null, verticesSizes); AssertAlgorithmProperties(algorithm, graph); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, verticesSizes); AssertAlgorithmProperties(algorithm, graph, verticesPositions); var parameters = new SimpleTreeLayoutParameters(); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesSizes, parameters); AssertAlgorithmProperties(algorithm, graph, parameters: parameters); algorithm = new SimpleTreeLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(graph, verticesPositions, verticesSizes, parameters); AssertAlgorithmProperties(algorithm, graph, verticesPositions, parameters: parameters); }
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")); }