private static double EvaluateEdgeLength(
[NotNull] ICompoundGraph <object, IEdge <object> > compoundGraph,
[NotNull] CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
[NotNull] IReadOnlyDictionary <object, Size> verticesSizes,
double idealEdgeLength,
double nestingFactor)
{
double edgeLengthError = 0.0;
foreach (IEdge <object> edge in compoundGraph.Edges)
{
Point uPos = algorithm.VerticesPositions[edge.Source];
Point vPos = algorithm.VerticesPositions[edge.Target];
Size uSize = verticesSizes[edge.Source];
Size vSize = verticesSizes[edge.Target];
Point uPoint = LayoutUtils.GetClippingPoint(uSize, uPos, vPos);
Point vPoint = LayoutUtils.GetClippingPoint(vSize, vPos, uPos);
double length = (uPoint - vPoint).Length;
bool isInterEdge = compoundGraph.GetParent(edge.Source) != compoundGraph.GetParent(edge.Target);
double iel = isInterEdge
? idealEdgeLength *
(algorithm.LevelOfVertex(edge.Source) + algorithm.LevelOfVertex(edge.Target) + 1) *
nestingFactor
: idealEdgeLength;
double error = Math.Pow(length - iel, 2);
edgeLengthError += error;
}
return(edgeLengthError);
}
int ICompoundGraph <TVertex, TEdge> .GetChildrenCount(TVertex vertex)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(ithis.ContainsVertex(vertex));
Contract.Ensures(Contract.Result <int>() >= 0);
return(default(int));
}
IEnumerable <TVertex> ICompoundGraph <TVertex, TEdge> .GetChildrenVertices(TVertex vertex)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(!vertex.Equals(default(TVertex)));
Contract.Requires(ithis.ContainsVertex(vertex));
return(new List <TVertex>());
}
bool ICompoundGraph <TVertex, TEdge> .IsChildVertex(TVertex vertex)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(!vertex.Equals(default(TVertex)));
Contract.Requires(ithis.ContainsVertex(vertex));
return(default(bool));
}
bool ICompoundGraph <TVertex, TEdge> .AddChildVertex(TVertex parent, TVertex child)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(!parent.Equals(default(TVertex)));
Contract.Requires(ithis.ContainsVertex(parent));
return(default(bool));
}
int ICompoundGraph <TVertex, TEdge> .AddChildVertexRange(TVertex parent, IEnumerable <TVertex> children)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(!parent.Equals(default(TVertex)));
Contract.Requires(ithis.ContainsVertex(parent));
Contract.Ensures(Contract.Result <int>() >= 0);
return(default(int));
}
TVertex ICompoundGraph <TVertex, TEdge> .GetParent(TVertex vertex)
{
ICompoundGraph <TVertex, TEdge> ithis = this;
Contract.Requires(!vertex.Equals(default(TVertex)));
Contract.Requires(ithis.ContainsVertex(vertex));
//TODO this is a bug in the MS Contract, i think -- solve it
//Contract.Ensures( Contract.Result<TVertex>().Equals( default( TVertex ) ) || ithis.ContainsVertex( Contract.Result<TVertex>() ) );
return(default(TVertex));
}
private static void EvaluateNodeDistances(
[NotNull] ICompoundGraph <object, IEdge <object> > compoundGraph,
[NotNull] CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
[NotNull] IReadOnlyDictionary <object, Size> verticesSizes,
out double minimalMinDistance,
out double averageMinDistance,
out double maximalMinDistance)
{
minimalMinDistance = 0.0;
averageMinDistance = 0.0;
maximalMinDistance = 0.0;
foreach (HashSet <object> level in algorithm.Levels)
{
foreach (object u in level)
{
double m = double.PositiveInfinity;
foreach (object v in level)
{
if (ReferenceEquals(u, v) || compoundGraph.GetParent(u) != compoundGraph.GetParent(v))
{
continue;
}
Point uPoint = LayoutUtils.GetClippingPoint(
verticesSizes[u],
algorithm.VerticesPositions[u],
algorithm.VerticesPositions[v]);
Point vPoint = LayoutUtils.GetClippingPoint(
verticesSizes[v],
algorithm.VerticesPositions[v],
algorithm.VerticesPositions[u]);
double distance = (uPoint - vPoint).Length;
m = Math.Min(m, distance);
}
if (double.IsPositiveInfinity(m))
{
continue;
}
minimalMinDistance = Math.Min(minimalMinDistance, m);
averageMinDistance += m;
maximalMinDistance = Math.Max(maximalMinDistance, m);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CompoundGraph{TVertex,TEdge}"/> class.
/// </summary>
/// <param name="graph">Graph from which initializing this graph.</param>
public CompoundGraph([NotNull] ICompoundGraph <TVertex, TEdge> graph)
// ReSharper disable once ConstantConditionalAccessQualifier
: base(graph?.AllowParallelEdges ?? throw new ArgumentNullException(nameof(graph)), graph.VertexCount)
{
// Copy the vertices
// ReSharper disable once VirtualMemberCallInConstructor
AddVertexRange(graph.Vertices);
// Copy the containment information
foreach (TVertex vertex in graph.CompoundVertices)
{
AddChildVertexRange(vertex, graph.GetChildrenVertices(vertex));
}
// Copy the edges
AddEdgeRange(graph.Edges);
}
public CompoundGraph(ICompoundGraph <TVertex, TEdge> graph)
: base(graph.AllowParallelEdges, graph.VertexCount)
{
//copy the vertices
AddVertexRange(graph.Vertices);
//copy the containment information
foreach (var vertex in graph.Vertices)
{
if (!graph.IsChildVertex(vertex))
{
continue;
}
var parent = graph.GetParent(vertex);
AddChildVertex(parent, vertex);
}
//copy the edges
AddEdgeRange(graph.Edges);
}
private static double EvaluateNodeOverlaps(
[NotNull] ICompoundGraph <object, IEdge <object> > compoundGraph,
[NotNull] CompoundFDPLayoutAlgorithm <object, IEdge <object>, CompoundGraph <object, IEdge <object> > > algorithm,
[NotNull] IDictionary <object, Size> verticesSizes)
{
double overlapArea = 0.0;
foreach (HashSet <object> level in algorithm.Levels)
{
foreach (object u in level)
{
foreach (object v in level)
{
if (ReferenceEquals(u, v) || compoundGraph.GetParent(u) != compoundGraph.GetParent(v))
{
continue;
}
Point uPosition = algorithm.VerticesPositions[u];
Point vPosition = algorithm.VerticesPositions[v];
Size uSize = verticesSizes[u];
Size vSize = verticesSizes[v];
var uRect = new Rect(uPosition, uSize);
var vRect = new Rect(vPosition, vSize);
// Get the overlap size
uRect.Intersect(vRect);
if (double.IsNegativeInfinity(uRect.Width) || double.IsNegativeInfinity(uRect.Height))
{
continue;
}
overlapArea += uRect.Width * uRect.Height;
}
}
}
return(overlapArea);
}
