/// <summary>
/// Removes node overlap occurring in the input graph
/// </summary>
/// <param name="graph">GraphMapData</param>
public static void FSAOverlapRemoval(GraphMapData graph)
{
ICollection <NodeMapData> nodes = graph.GetNodes();
IDictionary <string, Rect> rectangles = new Dictionary <string, Rect>(nodes.Count);
foreach (NodeMapData node in nodes)
{
Point location = new Point(node.Position.X, node.Position.Y);
Rect rect = new Rect(location, node.Dimension);
rectangles[node.Id] = rect;
}
OverlapRemovalParameters overlapRemovalParameters = new OverlapRemovalParameters()
{
HorizontalGap = 0F,
VerticalGap = 0F
};
FSAAlgorithm <string> overlapRemoval = new FSAAlgorithm <string>(rectangles, overlapRemovalParameters);
overlapRemoval.Compute();
foreach (NodeMapData node in nodes)
{
Rect rect = overlapRemoval.Rectangles[node.Id];
Point pos = new Point(rect.X, rect.Y);
node.Position = pos;
}
}
public void Constructor()
{
Constructor_Test <double, OverlapRemovalParameters, FSAAlgorithm <double, OverlapRemovalParameters> >(
(rectangles, parameters) => new FSAAlgorithm <double, OverlapRemovalParameters>(rectangles, parameters));
var rects = new Dictionary <double, Rect>();
var param = new OverlapRemovalParameters();
var algorithm = new FSAAlgorithm <double>(rects, param);
AssertAlgorithmProperties(algorithm, rects, param);
#region Local function
void AssertAlgorithmProperties <TObject>(
FSAAlgorithm <TObject> algo,
IDictionary <TObject, Rect> r,
IOverlapRemovalParameters p)
{
AssertAlgorithmState(algo);
Assert.AreSame(r, algo.Rectangles);
Assert.AreSame(p, algo.Parameters);
Assert.AreSame(p, algo.GetParameters());
}
#endregion
}
private object RemoveOverlaps2()
{
OverlapRemovalParameters params2 = new OverlapRemovalParameters();
params2.HorizontalGap = 40;
params2.VerticalGap = 40;
var vertexRectangles = new Dictionary <string, Rectangle>();
for (int i = 0; i < vertexLabels.Length; ++i)
{
var vertex = vertexPositions[vertexLabels[i]];
var border = vertexBorders[vertexLabels[i]];
var rect = new Rectangle();
rect.Width = border.Right - border.Left;
rect.Height = border.Bottom - border.Top;
vertexRectangles.Add(vertexLabels[i], rect);
}
FSAAlgorithm <string> algo2;
algo2 = new FSAAlgorithm <string>(null, params2);
algo2.Compute();
return(null);
}
/// <summary>
/// Removes node overlap occurring in the input graph
/// </summary>
/// <param name="graph">GraphMapData</param>
public static void FSAOverlapRemoval(GraphMapData graph)
{
ICollection<NodeMapData> nodes = graph.GetNodes();
IDictionary<string, Rect> rectangles = new Dictionary<string, Rect>(nodes.Count);
foreach (NodeMapData node in nodes)
{
Point location = new Point(node.Position.X, node.Position.Y);
Rect rect = new Rect(location, node.Dimension);
rectangles[node.Id] = rect;
}
OverlapRemovalParameters overlapRemovalParameters = new OverlapRemovalParameters()
{
HorizontalGap = 0F,
VerticalGap = 0F
};
FSAAlgorithm<string> overlapRemoval = new FSAAlgorithm<string>(rectangles, overlapRemovalParameters);
overlapRemoval.Compute();
foreach (NodeMapData node in nodes)
{
Rect rect = overlapRemoval.Rectangles[node.Id];
Point pos = new Point(rect.X, rect.Y);
node.Position = pos;
}
}
private void RunFSA(CancellationToken cancellationToken)
{
OverlapRemovalParameters parameters = new OverlapRemovalParameters
{
HorizontalGap = 20,
VerticalGap = 30
};
var oneWayFSA = new FSAAlgorithm <ElementVertex>(Rectangles, parameters);
oneWayFSA.Compute(cancellationToken);
Rectangles = oneWayFSA.Rectangles;
}
public void Compute([NotNull] OverlapRemovalParameters parameters)
{
Dictionary <int, Rect> rectangles = GetRectangles();
Dictionary <int, Rect> initialRectangles = rectangles.ToDictionary(
pair => pair.Key,
pair => new Rect(pair.Value.Location, pair.Value.Size));
var algorithm = new FSAAlgorithm <int>(rectangles, parameters);
algorithm.Compute();
foreach (KeyValuePair <int, Rect> pair in algorithm.Rectangles)
{
Rect initialRectangle = initialRectangles[pair.Key];
// Size must not change
Assert.AreEqual(initialRectangle.Size, pair.Value.Size);
// Fulfill minimum spacing
AssertNoOverlap(Distinct(algorithm.Rectangles.Values));
foreach (KeyValuePair <int, Rect> innerPair in algorithm.Rectangles.Where(p => pair.Key != p.Key))
{
if (NearEqual(pair.Value, innerPair.Value))
{
continue;
}
if (Math.Abs(pair.Value.Location.X - innerPair.Value.Location.X) >= parameters.HorizontalGap)
{
continue;
}
if (Math.Abs(pair.Value.Location.Y - innerPair.Value.Location.Y) >= parameters.VerticalGap)
{
continue;
}
Assert.Fail("Minimum spacing not fulfilled.");
}
}
}
private void ComputerOverlapRemoval()
{
//Overlap Param
OverlapRemovalParameters orp = new OverlapRemovalParameters();
orp.VerticalGap = 2;
orp.HorizontalGap = 2;
//Get Rect for Each Vertex
Dictionary<FlockVertex, Rect> rectangles = new Dictionary<FlockVertex, Rect>();
for (int i = 0; i < directed.VertexCount; i++)
{
FlockVertex v = directed.Vertices.ElementAt(i);
rectangles.Add(v, v.FlockRect);
}
try
{
FSAAlgorithm<FlockVertex> ora = new FSAAlgorithm<FlockVertex>(rectangles, orp);
ora.Compute();
//Update New Rect Postions
for (int i = 0; i < ora.Rectangles.Count; i++)
{
FlockVertex v = directed.Vertices.ElementAt(i);
v.FlockRect = ora.Rectangles.ElementAt(i).Value;
v.FlockPoint = new Point(v.FlockRect.X, v.FlockRect.Y);
}
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("Error at Overlap: {0}. {1}", ex.Message, ex.StackTrace));
}
}
protected static LayoutResults ExecuteLayoutAlgorithm <TVertex, TEdge>(
[NotNull] ILayoutAlgorithm <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> > algorithm,
[NotNull] IDictionary <TVertex, Size> verticesSizes,
bool requireOverlapRemoval = false)
where TVertex : class
where TEdge : IEdge <TVertex>
{
var results = new LayoutResults();
Assert.DoesNotThrow(algorithm.Compute);
IDictionary <TVertex, Point> verticesPositions = algorithm.VerticesPositions;
if (requireOverlapRemoval)
{
var rectangles = new Dictionary <TVertex, Rect>();
foreach (TVertex vertex in algorithm.VisitedGraph.Vertices)
{
Point position = algorithm.VerticesPositions[vertex];
Size size = verticesSizes[vertex];
rectangles[vertex] = new Rect(
position.X - size.Width * (float)0.5,
position.Y - size.Height * (float)0.5,
size.Width,
size.Height);
}
var overlapRemoval = new FSAAlgorithm <TVertex>(
rectangles,
new OverlapRemovalParameters());
Assert.DoesNotThrow(overlapRemoval.Compute);
foreach (KeyValuePair <TVertex, Rect> pair in overlapRemoval.Rectangles)
{
verticesPositions[pair.Key] = new Point(
pair.Value.Left + pair.Value.Size.Width * 0.5,
pair.Value.Top + pair.Value.Size.Height * 0.5);
}
}
IDictionary <TEdge, Point[]> edgeRoutes =
algorithm is IEdgeRoutingAlgorithm <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> > routingAlgorithm
? routingAlgorithm.EdgeRoutes
: new Dictionary <TEdge, Point[]>();
// Compute metrics
var positionsMetric = new PositionsMetricCalculator <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> >(
algorithm.VisitedGraph,
verticesPositions,
verticesSizes,
edgeRoutes);
positionsMetric.Calculate();
results.PositionsSet = positionsMetric.PositionsSet;
var overlapMetric = new OverlapMetricCalculator <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> >(
algorithm.VisitedGraph,
verticesPositions,
verticesSizes,
edgeRoutes);
overlapMetric.Calculate();
results.OverlapCount = overlapMetric.OverlapCount;
results.OverlappedArea = overlapMetric.OverlappedArea;
var areaMetric = new LayoutAreaMetricCalculator <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> >(
algorithm.VisitedGraph,
verticesPositions,
verticesSizes,
edgeRoutes);
areaMetric.Calculate();
results.TopLeft = areaMetric.TopLeft;
results.BottomRight = areaMetric.BottomRight;
results.Area = areaMetric.Area;
results.Ratio = areaMetric.Ratio;
var edgeMetric = new EdgeCrossingCalculator <TVertex, TEdge, IVertexAndEdgeListGraph <TVertex, TEdge> >(
algorithm.VisitedGraph,
verticesPositions,
verticesSizes,
edgeRoutes);
edgeMetric.Calculate();
results.CrossCount = edgeMetric.CrossCount;
results.MaximumEdgeLength = edgeMetric.MaximumEdgeLength;
results.MinimumEdgeLength = edgeMetric.MinimumEdgeLength;
results.AverageEdgeLength = edgeMetric.AverageEdgeLength;
return(results);
}
public void StandardFactory()
{
var rectangles = new Dictionary <int, Rect>();
var context = new TestOverlapRemovalContext(rectangles);
var factory = new StandardOverlapRemovalAlgorithmFactory <int>();
CollectionAssert.AreEqual(new[] { "FSA", "OneWayFSA" }, factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
context,
new OverlapRemovalParameters()));
Assert.IsInstanceOf <FSAAlgorithm <int> >(
factory.CreateAlgorithm(
"FSA",
context,
new OverlapRemovalParameters()));
Assert.IsInstanceOf <OneWayFSAAlgorithm <int> >(
factory.CreateAlgorithm(
"OneWayFSA",
context,
new OneWayFSAParameters()));
var fsaParameters = new OverlapRemovalParameters();
IOverlapRemovalParameters createdParameters = factory.CreateParameters(string.Empty, fsaParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("fsa", fsaParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("FSA", fsaParameters);
Assert.IsInstanceOf <OverlapRemovalParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
createdParameters = factory.CreateParameters("FSA", null);
Assert.IsInstanceOf <OverlapRemovalParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
var oneWayFSAParameters = new OneWayFSAParameters();
createdParameters = factory.CreateParameters("OneWayFSA", oneWayFSAParameters);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
createdParameters = factory.CreateParameters("OneWayFSA", null);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
createdParameters = factory.CreateParameters("OneWayFSA", fsaParameters);
Assert.IsInstanceOf <OneWayFSAParameters>(createdParameters);
Assert.AreNotSame(fsaParameters, createdParameters);
Assert.AreNotSame(oneWayFSAParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("FSA"));
Assert.IsTrue(factory.IsValidAlgorithm("OneWayFSA"));
Assert.IsFalse(factory.IsValidAlgorithm("fsa"));
var algorithm1 = new FSAAlgorithm <int, OverlapRemovalParameters>(rectangles, new OverlapRemovalParameters());
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new FSAAlgorithm <int>(rectangles, new OverlapRemovalParameters());
Assert.AreEqual("FSA", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new OneWayFSAAlgorithm <int>(rectangles, new OneWayFSAParameters());
Assert.AreEqual("OneWayFSA", factory.GetAlgorithmType(algorithm3));
}
