public GraphBalancerAlgorithm(
IMutableBidirectionalGraph <TVertex, TEdge> visitedGraph,
VertexFactory <TVertex> vertexFactory,
EdgeFactory <TVertex, TEdge> edgeFactory,
TVertex source,
TVertex sink,
IDictionary <TEdge, double> capacities)
{
Contract.Requires(visitedGraph != null);
Contract.Requires(vertexFactory != null);
Contract.Requires(edgeFactory != null);
Contract.Requires(source != null);
Contract.Requires(visitedGraph.ContainsVertex(source));
Contract.Requires(sink != null);
Contract.Requires(visitedGraph.ContainsVertex(sink));
Contract.Requires(capacities != null);
this.visitedGraph = visitedGraph;
this.source = source;
this.sink = sink;
this.capacities = capacities;
// setting preflow = l(e) = 1
foreach (var edge in this.VisitedGraph.Edges)
{
this.preFlow.Add(edge, 1);
}
}
void IMutableBidirectionalGraph <TVertex, TEdge> .ClearEdges(TVertex v)
{
IMutableBidirectionalGraph <TVertex, TEdge> ithis = this;
Contract.Requires(v != null);
Contract.Requires(ithis.ContainsVertex(v));
Contract.Ensures(!ithis.ContainsVertex(v));
}
public GraphBalancerAlgorithm(
IMutableBidirectionalGraph <TVertex, TEdge> visitedGraph,
TVertex source,
TVertex sink,
IVertexFactory <TVertex> vertexFactory,
IEdgeFactory <TVertex, TEdge> edgeFactory
)
{
if (visitedGraph == null)
{
throw new ArgumentNullException("visitedGraph");
}
if (vertexFactory == null)
{
throw new ArgumentNullException("vertexFactory");
}
if (edgeFactory == null)
{
throw new ArgumentNullException("edgeFactory");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (!visitedGraph.ContainsVertex(source))
{
throw new ArgumentException("source is not part of the graph");
}
if (sink == null)
{
throw new ArgumentNullException("sink");
}
if (!visitedGraph.ContainsVertex(sink))
{
throw new ArgumentException("sink is not part of the graph");
}
this.visitedGraph = visitedGraph;
this.vertexFactory = vertexFactory;
this.edgeFactory = edgeFactory;
this.source = source;
this.sink = sink;
// setting capacities = u(e) = +infty
foreach (var edge in this.VisitedGraph.Edges)
{
this.capacities.Add(edge, double.MaxValue);
}
// setting preflow = l(e) = 1
foreach (var edge in this.VisitedGraph.Edges)
{
this.preFlow.Add(edge, 1);
}
}
int IMutableBidirectionalGraph <TVertex, TEdge> .RemoveInEdgeIf(TVertex v, EdgePredicate <TVertex, TEdge> predicate)
{
IMutableBidirectionalGraph <TVertex, TEdge> ithis = this;
Contract.Requires(v != null);
Contract.Requires(predicate != null);
Contract.Requires(ithis.ContainsVertex(v));
Contract.Ensures(ithis.ContainsVertex(v));
Contract.Ensures(Enumerable.All(ithis.InEdges(v), e => predicate(e)));
Contract.Ensures(Contract.Result <int>() == Contract.OldValue(Enumerable.Count(ithis.InEdges(v), e => predicate(e))));
Contract.Ensures(ithis.InDegree(v) == Contract.OldValue(ithis.InDegree(v)) - Contract.Result <int>());
return(default(int));
}
/// <summary>
/// Hides the vertex <code>v</code>.
/// </summary>
/// <param name="v">The vertex to hide.</param>
public bool HideVertex(TVertex v)
{
if (_graph.ContainsVertex(v) && !hiddenVertices.Contains(v))
{
HideEdges(EdgesFor(v));
//hide the vertex
_graph.RemoveVertex(v);
hiddenVertices.Add(v);
OnVertexHidden(v);
return(true);
}
return(false);
}
void IMutableBidirectionalGraph <TVertex, TEdge> .ClearInEdges(TVertex v)
{
IMutableBidirectionalGraph <TVertex, TEdge> ithis = this;
Contract.Requires(v != null);
Contract.Requires(ithis.ContainsVertex(v));
Contract.Ensures(ithis.EdgeCount == Contract.OldValue(ithis.EdgeCount) - Contract.OldValue(ithis.InDegree(v)));
Contract.Ensures(ithis.InDegree(v) == 0);
}
/// <inheritdoc />
public bool HideVertex(TVertex vertex)
{
if (!_hiddenVertices.Contains(vertex))
{
if (_graph.ContainsVertex(vertex))
{
HideEdges(EdgesFor(vertex));
// Hide the vertex
_graph.RemoveVertex(vertex);
_hiddenVertices.Add(vertex);
OnVertexHidden(vertex);
return(true);
}
throw new VertexNotFoundException();
}
return(false);
}
private void PlaceBlock(int modeIndex, LeftRightMode leftRightMode, UpperLowerEdges upperLowerEdges, SugiVertex v)
{
if (!double.IsNaN(v.HorizontalPositions[modeIndex]))
{
return;
}
double delta = Parameters.VertexDistance;
v.HorizontalPositions[modeIndex] = 0;
Data w = v;
do
{
SugiVertex wVertex = w as SugiVertex;
Segment wSegment = w as Segment;
if (_sparseCompactionGraph.ContainsVertex(w) &&
((leftRightMode == LeftRightMode.Left && _sparseCompactionGraph.InDegree(w) > 0) ||
(leftRightMode == LeftRightMode.Right && _sparseCompactionGraph.OutDegree(w) > 0)))
{
var edges = leftRightMode == LeftRightMode.Left
? _sparseCompactionGraph.InEdges(w)
: _sparseCompactionGraph.OutEdges(w);
foreach (var edge in edges)
{
SugiVertex u = null;
Data pred = leftRightMode == LeftRightMode.Left ? edge.Source : edge.Target;
if (pred is SugiVertex)
{
u = ((SugiVertex)pred).Roots[modeIndex];
}
else
{
var segment = (Segment)pred;
u = upperLowerEdges == UpperLowerEdges.Upper ? segment.PVertex.Roots[modeIndex] : segment.QVertex.Roots[modeIndex];
}
PlaceBlock(modeIndex, leftRightMode, upperLowerEdges, u);
if (v.Sinks[modeIndex] == v)
{
v.Sinks[modeIndex] = u.Sinks[modeIndex];
}
//var xDelta = delta + (v.Roots[modeIndex].BlockWidths[modeIndex] + u.BlockWidths[modeIndex]) / 2.0;
var xDelta = delta + ((wVertex != null ? wVertex.Size.Width : 0.0) + ((pred is SugiVertex) ? ((SugiVertex)pred).Size.Width : u.BlockWidths[modeIndex])) / 2.0;
if (v.Sinks[modeIndex] != u.Sinks[modeIndex])
{
var s = leftRightMode == LeftRightMode.Left
? v.HorizontalPositions[modeIndex] - u.HorizontalPositions[modeIndex] - xDelta
: u.HorizontalPositions[modeIndex] - v.HorizontalPositions[modeIndex] - xDelta;
u.Sinks[modeIndex].Shifts[modeIndex] = leftRightMode == LeftRightMode.Left
? Math.Min(u.Sinks[modeIndex].Shifts[modeIndex], s)
: Math.Max(u.Sinks[modeIndex].Shifts[modeIndex], s);
}
else
{
v.HorizontalPositions[modeIndex] =
leftRightMode == LeftRightMode.Left
? Math.Max(v.HorizontalPositions[modeIndex], u.HorizontalPositions[modeIndex] + xDelta)
: Math.Min(v.HorizontalPositions[modeIndex], u.HorizontalPositions[modeIndex] - xDelta);
}
}
}
if (wSegment != null)
{
w = (upperLowerEdges == UpperLowerEdges.Upper) ? wSegment.QVertex : wSegment.PVertex;
}
else if (wVertex.Type == VertexTypes.PVertex && upperLowerEdges == UpperLowerEdges.Upper)
{
w = wVertex.Segment;
}
else if (wVertex.Type == VertexTypes.QVertex && upperLowerEdges == UpperLowerEdges.Lower)
{
w = wVertex.Segment;
}
else
{
w = wVertex.Aligns[modeIndex];
}
} while (w != v);
}
private void PlaceBlock(
int modeIndex,
LeftRightMode leftRightMode,
UpperLowerEdges upperLowerEdges,
[NotNull] SugiVertex v)
{
if (!double.IsNaN(v.SlicePositions[modeIndex]))
{
return;
}
double delta = Parameters.SliceGap;
v.SlicePositions[modeIndex] = 0;
Data w = v;
do
{
var wVertex = w as SugiVertex;
var wSegment = w as Segment;
if (_sparseCompactionGraph.ContainsVertex(w) &&
(leftRightMode == LeftRightMode.Left && _sparseCompactionGraph.InDegree(w) > 0 ||
leftRightMode == LeftRightMode.Right && _sparseCompactionGraph.OutDegree(w) > 0))
{
IEnumerable <IEdge <Data> > edges = leftRightMode == LeftRightMode.Left
? _sparseCompactionGraph.InEdges(w)
: _sparseCompactionGraph.OutEdges(w);
foreach (IEdge <Data> edge in edges)
{
SugiVertex u;
Data predecessor = leftRightMode == LeftRightMode.Left ? edge.Source : edge.Target;
if (predecessor is SugiVertex vertex)
{
u = vertex.Roots[modeIndex];
}
else
{
var segment = (Segment)predecessor;
u = upperLowerEdges == UpperLowerEdges.Upper ? segment.PVertex.Roots[modeIndex] : segment.QVertex.Roots[modeIndex];
}
PlaceBlock(modeIndex, leftRightMode, upperLowerEdges, u);
if (v.Sinks[modeIndex] == v)
{
v.Sinks[modeIndex] = u.Sinks[modeIndex];
}
double xDelta = delta
+ (
(wVertex?.Size.Width ?? 0.0)
+ (predecessor is SugiVertex sugiVertex
? sugiVertex.Size.Width
: u.BlockWidths[modeIndex])
) / 2.0;
if (v.Sinks[modeIndex] != u.Sinks[modeIndex])
{
double s = leftRightMode == LeftRightMode.Left
? v.SlicePositions[modeIndex] - u.SlicePositions[modeIndex] - xDelta
: u.SlicePositions[modeIndex] - v.SlicePositions[modeIndex] - xDelta;
u.Sinks[modeIndex].Shifts[modeIndex] = leftRightMode == LeftRightMode.Left
? Math.Min(u.Sinks[modeIndex].Shifts[modeIndex], s)
: Math.Max(u.Sinks[modeIndex].Shifts[modeIndex], s);
}
else
{
v.SlicePositions[modeIndex] = leftRightMode == LeftRightMode.Left
? Math.Max(v.SlicePositions[modeIndex], u.SlicePositions[modeIndex] + xDelta)
: Math.Min(v.SlicePositions[modeIndex], u.SlicePositions[modeIndex] - xDelta);
}
}
}
if (wSegment != null)
{
w = upperLowerEdges == UpperLowerEdges.Upper ? wSegment.QVertex : wSegment.PVertex;
}
// ReSharper disable once PossibleNullReferenceException
// Justification: If not a segment then it's a vertex
else if (wVertex.Type == VertexTypes.PVertex && upperLowerEdges == UpperLowerEdges.Upper)
{
w = wVertex.Segment;
}
else if (wVertex.Type == VertexTypes.QVertex && upperLowerEdges == UpperLowerEdges.Lower)
{
w = wVertex.Segment;
}
else
{
w = wVertex.Aligns[modeIndex];
}
} while (w != v);
}