public void InvalidParameters()
{
var parameters = new FreeFRLayoutParameters();
Assert.Throws <ArgumentOutOfRangeException>(() => parameters.VertexCount = -1);
Assert.Throws <ArgumentOutOfRangeException>(() => parameters.MaxIterations = -1);
Assert.Throws <ArgumentOutOfRangeException>(() => parameters.IdealEdgeLength = -1);
}
public void Constructor_Throws()
{
var verticesPositions = new Dictionary <string, Point>();
var parameters = new FreeFRLayoutParameters();
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => new FRLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, parameters));
Assert.Throws <ArgumentNullException>(
() => new FRLayoutAlgorithm <string, Edge <string>, IBidirectionalGraph <string, Edge <string> > >(null, verticesPositions, parameters));
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ObjectCreationAsStatement
}
/// <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)
{
AdjacencyGraph <string, Edge <string> > adjacencyGraph = GraphSharpUtility.GetAdjacencyGraph(graph);
IDictionary <string, Vector> nodePositions = GraphSharpUtility.GetNodePositions(graph);
FreeFRLayoutParameters freeFRLayoutParameters = new FreeFRLayoutParameters()
{
IdealEdgeLength = 125D
};
FRLayoutAlgorithm <string, Edge <string>, AdjacencyGraph <string, Edge <string> > > frLayoutAlgorithm = new FRLayoutAlgorithm <string, Edge <string>, AdjacencyGraph <string, Edge <string> > >(adjacencyGraph, nodePositions, freeFRLayoutParameters);
frLayoutAlgorithm.Compute();
GraphSharpUtility.SetNodePositions(graph, frLayoutAlgorithm.VertexPositions);
GraphSharpUtility.FSAOverlapRemoval(graph);
}
public void Clone()
{
var parameters = new FreeFRLayoutParameters();
var clonedParameters = (FreeFRLayoutParameters)parameters.Clone();
Assert.AreEqual(parameters, clonedParameters);
parameters = new FreeFRLayoutParameters();
parameters.VertexCount = 20;
parameters.AttractionMultiplier = 1.5;
parameters.RepulsiveMultiplier = 0.7;
parameters.MaxIterations = 150;
parameters.Lambda = 0.9;
parameters.CoolingFunction = FRCoolingFunction.Linear;
parameters.IdealEdgeLength = 15;
clonedParameters = (FreeFRLayoutParameters)parameters.Clone();
Assert.AreEqual(parameters, clonedParameters);
}
public void Evaluate(int SpreadMax)
{
if (FBuild[0] || (pd.InputChanged && init))
{
graph.Clear();
VSize.Clear();
VThickness.Clear();
VType.Clear();
VPos.Clear();
VCache.Clear();
for (int i = 0; i < FVertices.SliceCount; i++)
{
graph.AddVertex(FVertices[i]);
VSize.Add(FVertices[i], new Size(FVSize[i], FVSize[i]));
VThickness.Add(FVertices[i], new Thickness(1.0));
VType.Add(FVertices[i], FVType[i]);
VPos.Add(FVertices[i], new Point(FVPos[i].x, FVPos[i].y));
VCache.Add(FVertices[i]);
}
for (int i = 0; i < Math.Max(FEdgeFrom.SliceCount, FEdgeTo.SliceCount); i++)
{
graph.AddEdge(new Edge <string>(FEdgeFrom[i], FEdgeTo[i]));
}
var cparams = new FreeFRLayoutParameters();
foreach (var prop in typeof(FreeFRLayoutParameters).GetProperties())
{
var input = pd.InputPins[prop.Name].Spread[0];
if (!(input.ToString().StartsWith("0") && input.ToString().EndsWith("0")))
{
prop.SetValue(cparams, pd.InputPins[prop.Name].Spread[0]);
}
}
layout = new FRLayoutAlgorithm <string, IEdge <string>, BidirectionalGraph <string, IEdge <string> > >(graph, VPos, cparams);
foreach (var prop in typeof(FreeFRLayoutParameters).GetProperties())
{
var input = pd.InputPins[prop.Name].Spread[0];
if (!(input.ToString().StartsWith("0") && input.ToString().EndsWith("0")))
{
prop.SetValue(layout.Parameters, pd.InputPins[prop.Name].Spread[0]);
}
}
layout.Finished += (sender, args) =>
{
FPosOut.SliceCount = VCache.Count;
for (int i = 0; i < VCache.Count; i++)
{
var point = layout.VertexPositions[VCache[i]];
FPosOut[i] = new Vector2D(point.X, point.Y);
}
};
if (FAsync[0])
{
Task.Run(() =>
{
layout.Compute();
});
}
else
{
layout.Compute();
}
init = true;
}
if (layout != null)
{
FState[0] = layout.State.ToString();
}
}
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"));
}
public void ParameterRaise()
{
HashSet <string> expectedPropertyNames = null;
var parameters = new FreeFRLayoutParameters();
parameters.PropertyChanged += (sender, args) =>
{
// ReSharper disable AccessToModifiedClosure
if (expectedPropertyNames is null)
{
Assert.Fail("Must not raise.");
}
else
{
Assert.IsTrue(expectedPropertyNames.Remove(args.PropertyName));
}
// ReSharper restore AccessToModifiedClosure
};
parameters.VertexCount = 0;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.VertexCount),
nameof(FreeFRLayoutParameters.ConstantOfRepulsion),
nameof(FreeFRLayoutParameters.ConstantOfAttraction),
nameof(FreeFRLayoutParameters.InitialTemperature)
};
parameters.VertexCount = 10;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.AttractionMultiplier = 1.2;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.AttractionMultiplier),
nameof(FreeFRLayoutParameters.ConstantOfAttraction)
};
parameters.AttractionMultiplier = 1.4;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.RepulsiveMultiplier = 0.6;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.RepulsiveMultiplier),
nameof(FreeFRLayoutParameters.ConstantOfRepulsion)
};
parameters.RepulsiveMultiplier = 0.7;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.MaxIterations = 200;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.MaxIterations)
};
parameters.MaxIterations = 150;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.Lambda = 0.95;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.Lambda)
};
parameters.Lambda = 0.99;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.CoolingFunction = FRCoolingFunction.Exponential;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.CoolingFunction)
};
parameters.CoolingFunction = FRCoolingFunction.Linear;
CollectionAssert.IsEmpty(expectedPropertyNames);
expectedPropertyNames = null;
parameters.IdealEdgeLength = 10;
expectedPropertyNames = new HashSet <string>
{
nameof(FreeFRLayoutParameters.IdealEdgeLength),
nameof(FreeFRLayoutParameters.ConstantOfRepulsion),
nameof(FreeFRLayoutParameters.ConstantOfAttraction),
nameof(FreeFRLayoutParameters.K),
nameof(FreeFRLayoutParameters.InitialTemperature)
};
parameters.IdealEdgeLength = 12;
CollectionAssert.IsEmpty(expectedPropertyNames);
}
