public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters oldParameters)
{
switch (algorithmType)
{
/*case "Tree":
* return oldParameters.CreateNewParameter<SimpleTreeLayoutParameters>();
* case "Circular":
* return oldParameters.CreateNewParameter<CircularLayoutParameters>();
* case "FR":
* return oldParameters.CreateNewParameter<FreeFRLayoutParameters>();
* case "BoundedFR":
* return oldParameters.CreateNewParameter<BoundedFRLayoutParameters>();
* case "KK":
* return oldParameters.CreateNewParameter<KKLayoutParameters>();
* case "ISOM":
* return oldParameters.CreateNewParameter<ISOMLayoutParameters>();
* case "LinLog":
* return oldParameters.CreateNewParameter<LinLogLayoutParameters>();
* case "EfficientSugiyama":
* return oldParameters.CreateNewParameter<EfficientSugiyamaLayoutParameters>();
* case "Sugiyama":
* return oldParameters.CreateNewParameter<SugiyamaLayoutParameters>();
* case "CompoundFDP":
* return oldParameters.CreateNewParameter<CompoundFDPLayoutParameters>();*/
default:
return(null);
}
}
public static Size GetLineSizeFromLayoutParams(ILayoutParameters parameters)
{
var textLayout = Utilities.GetTextLayoutFromLayoutParams(parameters);
textLayout.Text = "a\na";
return(new Size(parameters.Width, textLayout.GetCoordinateFromIndex(2).Y));
}
public static Size GetCharSizeFromLayoutParams(ILayoutParameters parameters)
{
var textLayout = GetTextLayoutFromLayoutParams(parameters);
textLayout.Text = "a\na";
return(new Size(textLayout.GetCoordinateFromIndex(1).X, textLayout.GetCoordinateFromIndex(2).Y));
}
public static TextLayout GetTextLayoutFromLayoutParams(ILayoutParameters parameters)
{
var result = new TextLayout();
result.Font = parameters.Font;
return(result);
}
public static TParam CreateNewParameter <TParam>(this ILayoutParameters oldParameters)
where TParam : class, ILayoutParameters, new()
{
return(!(oldParameters is TParam)
? new TParam() :
(TParam)(oldParameters as TParam).Clone());
}
public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters oldParameters)
{
switch (algorithmType)
{
/*case "DoubleTree":
* return !( oldParameters is DoubleTreeLayoutParameters ) ? new DoubleTreeLayoutParameters() : (DoubleTreeLayoutParameters)( oldParameters as DoubleTreeLayoutParameters ).Clone();
* case "BaloonTree":
* return !( oldParameters is BalloonTreeLayoutParameters ) ? new BalloonTreeLayoutParameters() : (BalloonTreeLayoutParameters)( oldParameters as BalloonTreeLayoutParameters ).Clone();*/
default:
return(null);
}
}
public override double PrepareForDrawing(ILayoutParameters parameters)
{
var baseResult = base.PrepareForDrawing(parameters);
#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
// MonoDevelop complains about comparing double to a const int,
// but we detect uninitialized case here, so it's ok.
if (LineHeight == 0) // UI has not been initalized yet
#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
{
return(baseResult);
}
targetImageHeight = PreferedHeightInLines * LineHeight;
ShellProvider.NumberOfDummyLines = PreferedHeightInLines;
return(baseResult);
}
public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters oldParameters)
{
switch (algorithmType)
{
case "DoubleTree":
return(oldParameters.CreateNewParameter <DoubleTreeLayoutParameters>());
case "BalloonTree":
return(oldParameters.CreateNewParameter <BalloonTreeLayoutParameters>());
case "RadialTree":
return(oldParameters.CreateNewParameter <RadialTreeLayoutParameters>());
default:
return(null);
}
}
/// <inheritdoc />
public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
switch (algorithmType)
{
case DoubleTreeAlgorithm:
return(parameters.CreateNewParameters <DoubleTreeLayoutParameters>());
case BalloonTreeAlgorithm:
return(parameters.CreateNewParameters <BalloonTreeLayoutParameters>());
}
return(null);
}
public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters oldParameters)
{
switch (algorithmType)
{
case "Tree":
return(oldParameters.CreateNewParameter <SimpleTreeLayoutParameters>());
case "Circular":
return(oldParameters.CreateNewParameter <CircularLayoutParameters>());
case "FR":
return(oldParameters.CreateNewParameter <FreeFRLayoutParameters>());
case "BoundedFR":
return(oldParameters.CreateNewParameter <BoundedFRLayoutParameters>());
case "KK":
return(oldParameters.CreateNewParameter <KKLayoutParameters>());
case "ISOM":
return(oldParameters.CreateNewParameter <ISOMLayoutParameters>());
case "LinLog":
return(oldParameters.CreateNewParameter <LinLogLayoutParameters>());
case "EfficientSugiyama":
return(oldParameters.CreateNewParameter <EfficientSugiyamaLayoutParameters>());
case "Sugiyama":
return(oldParameters.CreateNewParameter <SugiyamaLayoutParameters>());
case "CompoundFDP":
return(oldParameters.CreateNewParameter <CompoundFDPLayoutParameters>());
case "StressMajorization":
return(oldParameters.CreateNewParameter <StressMajorizationLayoutParameters>());
case "Grid":
return(oldParameters.CreateNewParameter <GridLayoutParameters>());
default:
return(null);
}
}
/// <inheritdoc />
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(
string algorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context,
ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
var layoutContext = context as ContextualLayoutContext <TVertex, TEdge, TGraph>;
if (layoutContext is null)
{
throw new ArgumentException(
$"Layout context must be a not null {nameof(ContextualLayoutContext<TVertex, TEdge, TGraph>)}.",
nameof(context));
}
switch (algorithmType)
{
case DoubleTreeAlgorithm:
return(new DoubleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(
layoutContext.Graph,
layoutContext.Positions,
layoutContext.Sizes,
layoutContext.SelectedVertex,
parameters as DoubleTreeLayoutParameters));
case BalloonTreeAlgorithm:
return(new BalloonTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(
layoutContext.Graph,
layoutContext.Positions,
layoutContext.SelectedVertex,
parameters as BalloonTreeLayoutParameters));
}
return(null);
}
/// <inheritdoc />
public ILayoutParameters CreateParameters(string algorithmType, ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
switch (algorithmType)
{
case CircularAlgorithm:
return(parameters.CreateNewParameters <CircularLayoutParameters>());
case TreeAlgorithm:
return(parameters.CreateNewParameters <SimpleTreeLayoutParameters>());
case FRAlgorithm:
return(parameters.CreateNewParameters <FreeFRLayoutParameters>());
case BoundedFRAlgorithm:
return(parameters.CreateNewParameters <BoundedFRLayoutParameters>());
case KKAlgorithm:
return(parameters.CreateNewParameters <KKLayoutParameters>());
case ISOMAlgorithm:
return(parameters.CreateNewParameters <ISOMLayoutParameters>());
case LinLogAlgorithm:
return(parameters.CreateNewParameters <LinLogLayoutParameters>());
case SugiyamaAlgorithm:
return(parameters.CreateNewParameters <SugiyamaLayoutParameters>());
case CompoundFDPAlgorithm:
return(parameters.CreateNewParameters <CompoundFDPLayoutParameters>());
case RandomAlgorithm:
return(parameters.CreateNewParameters <RandomLayoutParameters>());
}
return(null);
}
/// <inheritdoc />
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(
string algorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context,
ILayoutParameters parameters)
{
if (algorithmType is null)
{
throw new ArgumentNullException(nameof(algorithmType));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.Graph is null)
{
return(null);
}
return(CreateAlgorithmInternal(algorithmType, context, parameters));
}
public virtual double PrepareForDrawing(ILayoutParameters parameters)
{
cursorInRow = null;
defaultForeground = parameters.DefaultForeground;
selectionColor = parameters.SelectionColor;
textLayout = TextLayoutCache.GetValue(parameters);
lineSize = LineSizeCache.GetValue(parameters);
charWidth = CharSizeCache.GetValue(parameters).Width;
if (lineSize.Width == 0)
{
return(0);
}
// Math.Max used to prevent division by zero errors on windows narrower than one character
MaximalColumn = Math.Max(((int)(lineSize.Width / charWidth)) - 1, 0);
var charsOnLine = MaximalColumn + 1;
var lengthInTextElementsAtLeastOne = lengthInTextElements == 0 ? 1 : lengthInTextElements; // because even empty line has height of one line
lineCount = Math.Max(minimalSublineCount, DivisionWithCeiling(lengthInTextElementsAtLeastOne, charsOnLine));
return(lineSize.Height * lineCount);
}
/// <summary>
/// Generate and initialize layout algorithm
/// </summary>
/// <param name="newAlgorithmType">Layout algorithm type</param>
/// <param name="iGraph">Graph</param>
/// <param name="positions">Optional vertex positions</param>
/// <param name="sizes">Optional vertex sizes</param>
/// <param name="parameters">Optional algorithm parameters</param>
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateLayoutAlgorithm(LayoutAlgorithmTypeEnum newAlgorithmType, TGraph iGraph, IDictionary <TVertex, Point> positions = null, IDictionary <TVertex, Size> sizes = null, ILayoutParameters parameters = null)
{
if (iGraph == null)
{
return(null);
}
if (parameters == null)
{
parameters = CreateLayoutParameters(newAlgorithmType);
}
var graph = iGraph.CopyToGraph <TGraph, TVertex, TEdge>();
var tGraph = (IMutableBidirectionalGraph <TVertex, TEdge>)graph;
if (tGraph != null)
{
tGraph.RemoveEdgeIf(a => a.SkipProcessing == ProcessingOptionEnum.Exclude);
tGraph.RemoveVertexIf(a => a.SkipProcessing == ProcessingOptionEnum.Exclude);
}
switch (newAlgorithmType)
{
case LayoutAlgorithmTypeEnum.Tree:
return(new SimpleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, sizes, parameters as SimpleTreeLayoutParameters));
case LayoutAlgorithmTypeEnum.SimpleRandom:
return(new RandomLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as RandomLayoutAlgorithmParams));
case LayoutAlgorithmTypeEnum.Circular:
return(new CircularLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, sizes, parameters as CircularLayoutParameters));
case LayoutAlgorithmTypeEnum.FR:
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as FRLayoutParametersBase));
case LayoutAlgorithmTypeEnum.BoundedFR:
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as BoundedFRLayoutParameters));
case LayoutAlgorithmTypeEnum.KK:
return(new KKLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as KKLayoutParameters));
case LayoutAlgorithmTypeEnum.ISOM:
return(new ISOMLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as ISOMLayoutParameters));
case LayoutAlgorithmTypeEnum.LinLog:
return(new LinLogLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, positions, parameters as LinLogLayoutParameters));
case LayoutAlgorithmTypeEnum.EfficientSugiyama:
return(new EfficientSugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, parameters as EfficientSugiyamaLayoutParameters, positions, sizes));
case LayoutAlgorithmTypeEnum.Sugiyama:
return(new SugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, sizes, positions, parameters as SugiyamaLayoutParameters,
e => (e is TypedEdge <TVertex>
?(e as TypedEdge <TVertex>).Type
: EdgeTypes.Hierarchical)));
case LayoutAlgorithmTypeEnum.CompoundFDP:
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(graph, sizes, new Dictionary <TVertex, Thickness>(), new Dictionary <TVertex, CompoundVertexInnerLayoutType>(),
positions, parameters as CompoundFDPLayoutParameters));
/*case LayoutAlgorithmTypeEnum.BalloonTree:
* return new BalloonTreeLayoutAlgorithm<TVertex, TEdge, TGraph>(Graph, Positions, Sizes, parameters as BalloonTreeLayoutParameters, Graph.Vertices.FirstOrDefault());*/
default:
return(null);
}
}
public void StandardFactory()
{
var vertex = new TestVertex("10");
var positions = new Dictionary <TestVertex, Point>();
var sizes = new Dictionary <TestVertex, Size>();
var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
graph.AddVertex(vertex);
var context = new ContextualLayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
vertex,
positions,
sizes);
var factory = new ContextualLayoutAlgorithmFactory <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >();
CollectionAssert.AreEqual(
new[] { "DoubleTree", "BalloonTree" },
factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
context,
new DoubleTreeLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"NotExist",
context,
new DoubleTreeLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"doubletree",
context,
new DoubleTreeLayoutParameters()));
Assert.IsInstanceOf <DoubleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"DoubleTree",
context,
new DoubleTreeLayoutParameters()));
Assert.IsInstanceOf <BalloonTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"BalloonTree",
context,
new BalloonTreeLayoutParameters()));
var testParameters = new TestLayoutParameters();
var doubleTreeParameters = new DoubleTreeLayoutParameters();
ILayoutParameters createdParameters = factory.CreateParameters(string.Empty, doubleTreeParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("NotExist", doubleTreeParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", null);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(doubleTreeParameters, createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", testParameters);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", doubleTreeParameters);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(doubleTreeParameters, createdParameters);
var balloonTreeParameters = new BalloonTreeLayoutParameters();
createdParameters = factory.CreateParameters("BalloonTree", null);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(balloonTreeParameters, createdParameters);
createdParameters = factory.CreateParameters("BalloonTree", testParameters);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("BalloonTree", balloonTreeParameters);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(balloonTreeParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("DoubleTree"));
Assert.IsFalse(factory.IsValidAlgorithm("doubletree"));
Assert.IsTrue(factory.IsValidAlgorithm("BalloonTree"));
var algorithm1 = new TestLayoutAlgorithm();
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new DoubleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, vertex, doubleTreeParameters);
Assert.AreEqual("DoubleTree", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new BalloonTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, vertex, balloonTreeParameters);
Assert.AreEqual("BalloonTree", factory.GetAlgorithmType(algorithm3));
Assert.IsFalse(factory.NeedEdgeRouting(string.Empty));
Assert.IsTrue(factory.NeedEdgeRouting("DoubleTree"));
Assert.IsTrue(factory.NeedEdgeRouting("BalloonTree"));
Assert.IsFalse(factory.NeedOverlapRemoval(string.Empty));
Assert.IsFalse(factory.NeedOverlapRemoval("DoubleTree"));
Assert.IsFalse(factory.NeedOverlapRemoval("BalloonTree"));
}
private static ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithmInternal(
[NotNull] string algorithmType,
[NotNull] ILayoutContext <TVertex, TEdge, TGraph> context,
[CanBeNull] ILayoutParameters parameters)
{
if (context.Mode == LayoutMode.Simple)
{
if (string.Equals(algorithmType, CircularAlgorithm))
{
return(new CircularLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
context.Sizes,
parameters as CircularLayoutParameters));
}
if (string.Equals(algorithmType, TreeAlgorithm))
{
return(new SimpleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
context.Sizes,
parameters as SimpleTreeLayoutParameters));
}
if (string.Equals(algorithmType, FRAlgorithm))
{
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
parameters as FRLayoutParametersBase));
}
if (string.Equals(algorithmType, BoundedFRAlgorithm))
{
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
parameters as BoundedFRLayoutParameters));
}
if (string.Equals(algorithmType, KKAlgorithm))
{
return(new KKLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
parameters as KKLayoutParameters));
}
if (string.Equals(algorithmType, ISOMAlgorithm))
{
return(new ISOMLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
parameters as ISOMLayoutParameters));
}
if (string.Equals(algorithmType, LinLogAlgorithm))
{
return(new LinLogLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
parameters as LinLogLayoutParameters));
}
if (string.Equals(algorithmType, SugiyamaAlgorithm))
{
return(new SugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
context.Sizes,
parameters as SugiyamaLayoutParameters));
}
if (string.Equals(algorithmType, CompoundFDPAlgorithm))
{
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
context.Sizes,
new Dictionary <TVertex, Thickness>(),
new Dictionary <TVertex, CompoundVertexInnerLayoutType>(),
parameters as CompoundFDPLayoutParameters));
}
if (string.Equals(algorithmType, RandomAlgorithm))
{
return(new RandomLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Positions,
context.Sizes,
new Dictionary <TVertex, RandomVertexType>(),
parameters as RandomLayoutParameters));
}
return(null);
}
if (context.Mode == LayoutMode.Compound &&
context is ICompoundLayoutContext <TVertex, TEdge, TGraph> compoundContext &&
string.Equals(algorithmType, CompoundFDPAlgorithm))
{
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
compoundContext.Graph,
compoundContext.Positions,
compoundContext.Sizes,
compoundContext.VerticesBorders,
compoundContext.LayoutTypes,
parameters as CompoundFDPLayoutParameters));
}
return(null);
}
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(string newAlgorithmType, ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
if (context == null || context.Graph == null)
{
return(null);
}
if (context.Mode == LayoutMode.Simple)
{
switch (newAlgorithmType)
{
case "Tree":
return(new SimpleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
context.Sizes,
parameters as SimpleTreeLayoutParameters));
case "Circular":
return(new CircularLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
context.Sizes,
parameters as CircularLayoutParameters));
case "FR":
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as FRLayoutParametersBase));
case "BoundedFR":
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as BoundedFRLayoutParameters));
case "KK":
return(new KKLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as KKLayoutParameters));
case "ISOM":
return(new ISOMLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as ISOMLayoutParameters));
case "LinLog":
return(new LinLogLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Positions,
parameters as LinLogLayoutParameters));
case "EfficientSugiyama":
return(new EfficientSugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph,
parameters as EfficientSugiyamaLayoutParameters,
context.Positions,
context.Sizes));
case "Sugiyama":
return(new SugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(context.Graph, context.Sizes,
context.Positions,
parameters as
SugiyamaLayoutParameters,
e => (e is TypedEdge <TVertex>
?(e as TypedEdge <TVertex>).Type
: EdgeTypes.Hierarchical)));
case "CompoundFDP":
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
context.Graph,
context.Sizes,
new Dictionary <TVertex, Thickness>(),
new Dictionary <TVertex, CompoundVertexInnerLayoutType>(),
context.Positions,
parameters as CompoundFDPLayoutParameters));
default:
return(null);
}
}
else if (context.Mode == LayoutMode.Compound)
{
var compoundContext = context as ICompoundLayoutContext <TVertex, TEdge, TGraph>;
switch (newAlgorithmType)
{
case "CompoundFDP":
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(
compoundContext.Graph,
compoundContext.Sizes,
compoundContext.VertexBorders,
compoundContext.LayoutTypes,
compoundContext.Positions,
parameters as CompoundFDPLayoutParameters));
default:
return(null);
}
}
return(null);
}
ILayoutAlgorithm <TVertex, TEdge, TGraph> ILayoutAlgorithmFactory <TVertex, TEdge, TGraph> .CreateAlgorithm(string newAlgorithmType, ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
Contract.Requires(newAlgorithmType != null);
Contract.Requires(context as ContextualLayoutContext <TVertex, TEdge, TGraph> != null);
var laf = (ILayoutAlgorithmFactory <TVertex, TEdge, TGraph>) this;
Contract.Requires(laf.AlgorithmTypes.Contains(newAlgorithmType));
return(default(ILayoutAlgorithm <TVertex, TEdge, TGraph>));
}
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 ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateAlgorithm(string newAlgorithmType,
ILayoutContext <TVertex, TEdge, TGraph> context, ILayoutParameters parameters)
{
var layoutContext = context as ContextualLayoutContext <TVertex, TEdge, TGraph>;
switch (newAlgorithmType)
{
/*case "DoubleTree":
* return new DoubleTreeLayoutAlgorithm<TVertex, TEdge, TGraph>( layoutContext.Graph, layoutContext.Positions, layoutContext.Sizes, parameters as DoubleTreeLayoutParameters, layoutContext.SelectedVertex );
* case "BalloonTree":
* return new BalloonTreeLayoutAlgorithm<TVertex, TEdge, TGraph>( layoutContext.Graph, layoutContext.Positions, layoutContext.Sizes, parameters as BalloonTreeLayoutParameters, layoutContext.SelectedVertex );*/
default:
return(null);
}
}
public ILayoutAlgorithm <TVertex, TEdge, TGraph> CreateLayoutAlgorithm(LayoutAlgorithmTypeEnum newAlgorithmType, TGraph Graph, IDictionary <TVertex, Point> Positions = null, IDictionary <TVertex, Size> Sizes = null, ILayoutParameters parameters = null)
{
if (Graph == null)
{
return(null);
}
if (parameters == null)
{
parameters = CreateLayoutParameters(newAlgorithmType);
}
switch (newAlgorithmType)
{
case LayoutAlgorithmTypeEnum.Tree:
return(new SimpleTreeLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, Sizes, parameters as SimpleTreeLayoutParameters));
case LayoutAlgorithmTypeEnum.SimpleRandom:
return(new RandomLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph));
case LayoutAlgorithmTypeEnum.Circular:
return(new CircularLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, Sizes, parameters as CircularLayoutParameters));
case LayoutAlgorithmTypeEnum.FR:
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, parameters as FRLayoutParametersBase));
case LayoutAlgorithmTypeEnum.BoundedFR:
return(new FRLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, parameters as BoundedFRLayoutParameters));
case LayoutAlgorithmTypeEnum.KK:
return(new KKLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, parameters as KKLayoutParameters));
case LayoutAlgorithmTypeEnum.ISOM:
return(new ISOMLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, parameters as ISOMLayoutParameters));
case LayoutAlgorithmTypeEnum.LinLog:
return(new LinLogLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Positions, parameters as LinLogLayoutParameters));
case LayoutAlgorithmTypeEnum.EfficientSugiyama:
return(new EfficientSugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, parameters as EfficientSugiyamaLayoutParameters, Positions, Sizes));
case LayoutAlgorithmTypeEnum.Sugiyama:
return(new SugiyamaLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Sizes, Positions, parameters as SugiyamaLayoutParameters,
e => (e is TypedEdge <TVertex>
?(e as TypedEdge <TVertex>).Type
: EdgeTypes.Hierarchical)));
case LayoutAlgorithmTypeEnum.CompoundFDP:
return(new CompoundFDPLayoutAlgorithm <TVertex, TEdge, TGraph>(Graph, Sizes, new Dictionary <TVertex, Thickness>(), new Dictionary <TVertex, CompoundVertexInnerLayoutType>(),
Positions, parameters as CompoundFDPLayoutParameters));
/*case LayoutAlgorithmTypeEnum.BalloonTree:
* return new BalloonTreeLayoutAlgorithm<TVertex, TEdge, TGraph>(Graph, Positions, Sizes, parameters as BalloonTreeLayoutParameters, Graph.Vertices.FirstOrDefault());*/
default:
return(null);
}
}
ILayoutParameters ILayoutAlgorithmFactory <TVertex, TEdge, TGraph> .CreateParameters(string algorithmType, ILayoutParameters oldParameters)
{
Contract.Requires(algorithmType != null);
var laf = (ILayoutAlgorithmFactory <TVertex, TEdge, TGraph>) this;
Contract.Requires(laf.AlgorithmTypes.Contains(algorithmType));
return(default(ILayoutParameters));
}
