private static Queue <VertexGroup> GetContainerLikeItems(AlternatingLayer alternatingLayer, VertexTypes containerLikeVertexType)
{
Queue <VertexGroup> queue = new Queue <VertexGroup>();
foreach (var item in alternatingLayer)
{
var vertex = item as SugiVertex;
if (vertex != null && vertex.Type == containerLikeVertexType)
{
queue.Enqueue(new VertexGroup()
{
Position = vertex.Position, Size = 1
});
}
else if (vertex == null)
{
var container = item as ISegmentContainer;
if (container.Count > 0)
{
queue.Enqueue(new VertexGroup()
{
Position = container.Position, Size = container.Count
});
}
}
}
return(queue);
}
private static void OutputAlternatingLayer(AlternatingLayer alternatingLayer, int layerIndex, int crossCount)
{
Debug.Write(layerIndex + " | " + crossCount + ": ");
foreach (var element in alternatingLayer)
{
if (element is SugiVertex)
{
var vertex = element as SugiVertex;
Debug.Write(string.Format("{0},{1}\t", vertex.OriginalVertex, vertex.Type.ToString()[0]));
}
else
{
var segmentContainer = element as SegmentContainer;
if (segmentContainer == null)
{
continue;
}
for (int j = 0; j < segmentContainer.Count; j++)
{
Debug.Write("| \t");
}
}
}
Debug.WriteLine("");
}
/// <summary>
/// Assigns the positions of the vertices and segment container
/// on the actual layer.
/// </summary>
/// <param name="alternatingLayer">The actual layer (L_i).</param>
private static void AssignPositionsOnActualLayer(AlternatingLayer alternatingLayer)
{
//assign positions to vertices on the actualLayer (L_i)
for (int i = 1; i < alternatingLayer.Count; i += 2)
{
var precedingContainer = alternatingLayer[i - 1] as SegmentContainer;
var vertex = alternatingLayer[i] as SugiVertex;
if (i == 1)
{
vertex.Position = precedingContainer.Count;
}
else
{
var previousVertex = alternatingLayer[i - 2] as SugiVertex;
vertex.Position = previousVertex.Position + precedingContainer.Count + 1;
}
}
//assign positions to containers on the actualLayer (L_i+1)
for (int i = 0; i < alternatingLayer.Count; i += 2)
{
var container = alternatingLayer[i] as SegmentContainer;
if (i == 0)
{
container.Position = 0;
}
else
{
var precedingVertex = alternatingLayer[i - 1] as SugiVertex;
container.Position = precedingVertex.Position + 1;
}
}
}
/// <summary>
/// Assigns the positions of the vertices and segment container on the actual layer.
/// </summary>
/// <param name="alternatingLayer">The actual layer (L_i).</param>
private static void AssignPositionsOnActualLayer([NotNull, ItemNotNull] AlternatingLayer alternatingLayer)
{
Debug.Assert(alternatingLayer != null);
// Assign positions to vertices on the actualLayer (L_i)
for (int i = 1; i < alternatingLayer.Count; i += 2)
{
var precedingContainer = (SegmentContainer)alternatingLayer[i - 1];
var vertex = (SugiVertex)alternatingLayer[i];
if (i == 1)
{
vertex.Position = precedingContainer.Count;
}
else
{
var previousVertex = (SugiVertex)alternatingLayer[i - 2];
vertex.Position = previousVertex.Position + precedingContainer.Count + 1;
}
}
// Assign positions to containers on the actualLayer (L_i+1)
for (int i = 0; i < alternatingLayer.Count; i += 2)
{
var container = (SegmentContainer)alternatingLayer[i];
if (i == 0)
{
container.Position = 0;
}
else
{
var precedingVertex = (SugiVertex)alternatingLayer[i - 1];
container.Position = precedingVertex.Position + 1;
}
}
}
private static Queue <VertexGroup> GetContainerLikeItems(
[NotNull, ItemNotNull] AlternatingLayer alternatingLayer,
VertexTypes containerLikeVertexType)
{
var queue = new Queue <VertexGroup>();
foreach (IData item in alternatingLayer)
{
var vertex = item as SugiVertex;
if (vertex != null && vertex.Type == containerLikeVertexType)
{
queue.Enqueue(new VertexGroup(vertex.Position)
{
Size = 1
});
}
else if (vertex is null)
{
var container = (ISegmentContainer)item;
if (container.Count > 0)
{
queue.Enqueue(new VertexGroup(container.Position)
{
Size = container.Count
});
}
}
}
return(queue);
}
/// <summary>
/// Sweeps between the <paramref name="startLayerIndex"/> and <paramref name="endLayerIndex"/>
/// in the way represented by the step
/// </summary>
/// <param name="startLayerIndex">The index of the start layer (where the sweeping starts from).</param>
/// <param name="endLayerIndex">The index of the last layer (where the sweeping ends).</param>
/// <param name="step">Increment or decrement of the layer index. (1 or -1)</param>
/// <returns>The number of the edge crossings.</returns>
private int Sweeping(int startLayerIndex, int endLayerIndex, int step, bool enableSameMeasureOptimization, out bool changed, ref int phase)
{
int crossings = 0;
changed = false;
if (_alternatingLayers.Length > 0)
{
AlternatingLayer alternatingLayer;
if (_alternatingLayers[startLayerIndex] == null)
{
alternatingLayer = new AlternatingLayer();
alternatingLayer.AddRange(_layers[startLayerIndex].OfType <IData>());
alternatingLayer.EnsureAlternatingAndPositions();
AddAlternatingLayerToSparseCompactionGraph(alternatingLayer, startLayerIndex);
_alternatingLayers[startLayerIndex] = alternatingLayer;
}
else
{
alternatingLayer = _alternatingLayers[startLayerIndex];
}
OutputAlternatingLayer(alternatingLayer, startLayerIndex, 0);
for (int i = startLayerIndex; i != endLayerIndex; i += step)
{
int ci = Math.Min(i, i + step);
int prevCrossCount = _crossCounts[ci];
if (_alternatingLayers[i + step] != null)
{
alternatingLayer.SetPositions();
_alternatingLayers[i + step].SetPositions();
prevCrossCount = DoCrossCountingAndOptimization(alternatingLayer, _alternatingLayers[i + step], (i < i + step), false, (phase == 2), int.MaxValue);
_crossCounts[ci] = prevCrossCount;
}
int crossCount = CrossingMinimizationBetweenLayers(ref alternatingLayer, i, i + step, enableSameMeasureOptimization, prevCrossCount, phase);
if (crossCount < prevCrossCount || phase == 2 || changed)
{
/* set the sparse compaction graph */
AddAlternatingLayerToSparseCompactionGraph(alternatingLayer, i + step);
ReplaceLayer(alternatingLayer, i + step);
_alternatingLayers[i + step] = alternatingLayer;
OutputAlternatingLayer(alternatingLayer, i + step, crossCount);
_crossCounts[i] = crossCount;
crossings += crossCount;
changed = true;
}
else
{
Debug.WriteLine("Layer " + (i + step) + " has not changed.");
alternatingLayer = _alternatingLayers[i + step];
crossings += prevCrossCount;
}
}
}
return(crossings);
}
private void ComputeMeasureValues(
[NotNull, ItemNotNull] AlternatingLayer alternatingLayer,
int nextLayerIndex,
bool straightSweep)
{
Debug.Assert(alternatingLayer != null);
AssignPositionsOnActualLayer(alternatingLayer);
AssignMeasuresOnNextLayer(_layers[nextLayerIndex], straightSweep);
}
private void AddAlternatingLayerToSparseCompactionGraph(
[NotNull, ItemNotNull] AlternatingLayer nextAlternatingLayer,
int layerIndex)
{
Debug.Assert(nextAlternatingLayer != null);
var sparseCompactionGraphEdgesOfLayer = _sparseCompactionByLayerBackup[layerIndex];
if (sparseCompactionGraphEdgesOfLayer != null)
{
foreach (Edge <Data> edge in sparseCompactionGraphEdgesOfLayer)
{
_sparseCompactionGraph.RemoveEdge(edge);
}
}
sparseCompactionGraphEdgesOfLayer = new List <Edge <Data> >();
SugiVertex prevVertex = null;
for (int i = 1; i < nextAlternatingLayer.Count; i += 2)
{
var vertex = (SugiVertex)nextAlternatingLayer[i];
var prevContainer = nextAlternatingLayer[i - 1] as SegmentContainer;
var nextContainer = nextAlternatingLayer[i + 1] as SegmentContainer;
if (prevContainer != null && prevContainer.Count > 0)
{
Segment lastSegment = prevContainer[prevContainer.Count - 1];
var edge = new Edge <Data>(lastSegment, vertex);
sparseCompactionGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
else if (prevVertex != null)
{
var edge = new Edge <Data>(prevVertex, vertex);
sparseCompactionGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
if (nextContainer != null && nextContainer.Count > 0)
{
Segment firstSegment = nextContainer[0];
var edge = new Edge <Data>(vertex, firstSegment);
sparseCompactionGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
if (!_sparseCompactionGraph.ContainsVertex(vertex))
{
_sparseCompactionGraph.AddVertex(vertex);
}
prevVertex = vertex;
}
_sparseCompactionByLayerBackup[layerIndex] = sparseCompactionGraphEdgesOfLayer;
}
private void AddAlternatingLayerToSparseCompactionGraph(AlternatingLayer nextAlternatingLayer, int layerIndex)
{
if (_sparseCompactionByLayerBackup == null)
{
throw new InvalidOperationException();
}
var sparseCompationGraphEdgesOfLayer = _sparseCompactionByLayerBackup[layerIndex];
if (sparseCompationGraphEdgesOfLayer != null)
{
foreach (var edge in sparseCompationGraphEdgesOfLayer)
{
_sparseCompactionGraph.RemoveEdge(edge);
}
}
sparseCompationGraphEdgesOfLayer = new List <Edge <Data> >();
SugiVertex?prevVertex = null;
for (int i = 1; i < nextAlternatingLayer.Count; i += 2)
{
var vertex = (SugiVertex)nextAlternatingLayer[i];
var prevContainer = nextAlternatingLayer[i - 1] as SegmentContainer;
var nextContainer = nextAlternatingLayer[i + 1] as SegmentContainer;
if (prevContainer != null && prevContainer.Count > 0)
{
var lastSegment = prevContainer[prevContainer.Count - 1];
var edge = new Edge <Data>(lastSegment, vertex);
sparseCompationGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
else if (prevVertex != null)
{
var edge = new Edge <Data>(prevVertex, vertex);
sparseCompationGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
if (nextContainer != null && nextContainer.Count > 0)
{
var firstSegment = nextContainer[0];
var edge = new Edge <Data>(vertex, firstSegment);
sparseCompationGraphEdgesOfLayer.Add(edge);
_sparseCompactionGraph.AddVerticesAndEdge(edge);
}
if (vertex != null && !_sparseCompactionGraph.ContainsVertex(vertex))
{
_sparseCompactionGraph.AddVertex(vertex);
}
prevVertex = vertex;
}
_sparseCompactionByLayerBackup[layerIndex] = sparseCompationGraphEdgesOfLayer;
}
private void PlaceQVertices(
[NotNull, ItemNotNull] AlternatingLayer alternatingLayer,
[NotNull, ItemNotNull] IEnumerable <SugiVertex> nextLayer,
bool straightSweep)
{
Debug.Assert(alternatingLayer != null);
Debug.Assert(nextLayer != null);
VertexTypes type = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex;
var qVertices = new HashSet <SugiVertex>();
foreach (SugiVertex vertex in nextLayer)
{
if (vertex.Type != type)
{
continue;
}
qVertices.Add(vertex);
}
for (int i = 0; i < alternatingLayer.Count; ++i)
{
var segmentContainer = alternatingLayer[i] as SegmentContainer;
if (segmentContainer is null)
{
continue;
}
for (int j = 0; j < segmentContainer.Count; ++j)
{
ThrowIfCancellationRequested();
Segment segment = segmentContainer[j];
SugiVertex vertex = straightSweep ? segment.QVertex : segment.PVertex;
if (!qVertices.Contains(vertex))
{
continue;
}
alternatingLayer.RemoveAt(i);
segmentContainer.Split(segment, out ISegmentContainer container1, out ISegmentContainer container2);
container1.Position = segmentContainer.Position;
container2.Position = segmentContainer.Position + container1.Count + 1;
alternatingLayer.Insert(i, container1);
alternatingLayer.Insert(i + 1, vertex);
alternatingLayer.Insert(i + 2, container2);
++i;
break;
}
}
}
private void ReplaceLayer(AlternatingLayer alternatingLayer, int i)
{
_layers[i].Clear();
foreach (var item in alternatingLayer)
{
var vertex = item as SugiVertex;
if (vertex == null)
{
continue;
}
_layers[i].Add(vertex);
vertex.IndexInsideLayer = i;
}
}
private List <SugiVertex> FindVerticesWithSameMeasure(
[NotNull, ItemNotNull] AlternatingLayer nextAlternatingLayer,
bool straightSweep,
[NotNull] out IList <int> ranges,
out int maxRangeLength)
{
Debug.Assert(nextAlternatingLayer != null);
VertexTypes ignorableVertexType = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex;
var verticesWithSameMeasure = new List <SugiVertex>();
SugiVertex[] vertices = nextAlternatingLayer.OfType <SugiVertex>().ToArray();
int startIndex;
int endIndex;
maxRangeLength = 0;
ranges = new List <int>();
for (startIndex = 0; startIndex < vertices.Length; startIndex = endIndex + 1)
{
ThrowIfCancellationRequested();
endIndex = FindNearVertexEndIndex(startIndex, vertices);
if (endIndex > startIndex)
{
int rangeLength = 0;
for (int i = startIndex; i <= endIndex; ++i)
{
ThrowIfCancellationRequested();
if (vertices[i].Type == ignorableVertexType || vertices[i].DoNotOptimize)
{
continue;
}
++rangeLength;
verticesWithSameMeasure.Add(vertices[i]);
}
if (rangeLength > 0)
{
maxRangeLength = Math.Max(rangeLength, maxRangeLength);
ranges.Add(rangeLength);
}
}
}
return(verticesWithSameMeasure);
}
private static IList <CrossCounterPair> FindVirtualEdgePairs(
[NotNull, ItemNotNull] AlternatingLayer topLayer,
[NotNull, ItemNotNull] AlternatingLayer bottomLayer)
{
var virtualEdgePairs = new List <CrossCounterPair>();
Queue <VertexGroup> firstLayerQueue = GetContainerLikeItems(topLayer, VertexTypes.PVertex);
Queue <VertexGroup> secondLayerQueue = GetContainerLikeItems(bottomLayer, VertexTypes.QVertex);
var group1 = new VertexGroup();
var group2 = new VertexGroup();
while (firstLayerQueue.Count > 0 || secondLayerQueue.Count > 0)
{
if (group1.Size == 0)
{
group1 = firstLayerQueue.Dequeue();
}
if (group2.Size == 0)
{
group2 = secondLayerQueue.Dequeue();
}
if (group1.Size <= group2.Size)
{
virtualEdgePairs.Add(
new CrossCounterPair
{
First = group1.Position,
Second = group2.Position,
Weight = group1.Size
});
group2.Size -= group1.Size;
group1.Size = 0;
}
else
{
virtualEdgePairs.Add(
new CrossCounterPair
{
First = group1.Position,
Second = group2.Position,
Weight = group2.Size
});
group1.Size -= group2.Size;
group2.Size = 0;
}
}
return(virtualEdgePairs);
}
private void ReplaceLayer([NotNull, ItemNotNull] AlternatingLayer alternatingLayer, int i)
{
Debug.Assert(alternatingLayer != null);
_layers[i].Clear();
foreach (IData item in alternatingLayer)
{
var vertex = item as SugiVertex;
if (vertex is null)
{
continue;
}
_layers[i].Add(vertex);
vertex.IndexInsideLayer = i;
}
}
public AlternatingLayer Clone()
{
var clonedLayer = new AlternatingLayer();
foreach (IData item in this)
{
if (item is ICloneable cloneable)
{
clonedLayer.Add(cloneable.Clone() as IData);
}
else
{
clonedLayer.Add(item);
}
}
return(clonedLayer);
}
private void PlaceQVertices(AlternatingLayer alternatingLayer, IList <SugiVertex> nextLayer, bool straightSweep, CancellationToken cancellationToken)
{
var type = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex;
var qVertices = new HashSet <SugiVertex>();
foreach (var vertex in nextLayer)
{
if (vertex.Type != type)
{
continue;
}
qVertices.Add(vertex);
}
for (int i = 0; i < alternatingLayer.Count; i++)
{
var segmentContainer = alternatingLayer[i] as SegmentContainer;
if (segmentContainer == null)
{
continue;
}
for (int j = 0; j < segmentContainer.Count; j++)
{
cancellationToken.ThrowIfCancellationRequested();
var segment = segmentContainer[j];
var vertex = straightSweep ? segment.QVertex : segment.PVertex;
if (!qVertices.Contains(vertex))
{
continue;
}
alternatingLayer.RemoveAt(i);
ISegmentContainer sc1, sc2;
segmentContainer.Split(segment, out sc1, out sc2);
sc1.Position = segmentContainer.Position;
sc2.Position = segmentContainer.Position + sc1.Count + 1;
alternatingLayer.Insert(i, sc1);
alternatingLayer.Insert(i + 1, vertex);
alternatingLayer.Insert(i + 2, sc2);
i = i + 1;
break;
}
}
}
private IList <CrossCounterPair> FindVirtualEdgePairs(AlternatingLayer topLayer, AlternatingLayer bottomLayer)
{
var virtualEdgePairs = new List <CrossCounterPair>();
Queue <VertexGroup> firstLayerQueue = GetContainerLikeItems(topLayer, VertexTypes.PVertex);
Queue <VertexGroup> secondLayerQueue = GetContainerLikeItems(bottomLayer, VertexTypes.QVertex);
VertexGroup vg1, vg2;
vg1 = new VertexGroup();
vg2 = new VertexGroup();
while (firstLayerQueue.Count > 0 || secondLayerQueue.Count > 0)
{
if (vg1.Size == 0)
{
vg1 = firstLayerQueue.Dequeue();
}
if (vg2.Size == 0)
{
vg2 = secondLayerQueue.Dequeue();
}
if (vg1.Size <= vg2.Size)
{
virtualEdgePairs.Add(
new CrossCounterPair
{
First = vg1.Position,
Second = vg2.Position,
Weight = vg1.Size
});
vg2.Size -= vg1.Size;
vg1.Size = 0;
}
else
{
virtualEdgePairs.Add(
new CrossCounterPair
{
First = vg1.Position,
Second = vg2.Position,
Weight = vg2.Size
});
vg1.Size -= vg2.Size;
vg2.Size = 0;
}
}
return(virtualEdgePairs);
}
private static AlternatingLayer InitialOrderingOfNextLayer(IEnumerable <IData> alternatingLayer, IEnumerable <SugiVertex> nextLayer, bool straightSweep)
{
//get the list of the containers and vertices
var segmentContainerStack = new Stack <ISegmentContainer>(alternatingLayer.OfType <ISegmentContainer>().Reverse());
var ignorableVertexType = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex;
var vertexStack = new Stack <SugiVertex>(nextLayer.Where(v => v.Type != ignorableVertexType).OrderBy(v => v.MeasuredPosition).Reverse());
var newAlternatingLayer = new AlternatingLayer();
while (vertexStack.Count > 0 && segmentContainerStack.Count > 0)
{
var vertex = vertexStack.Peek();
var segmentContainer = segmentContainerStack.Peek();
if (vertex.MeasuredPosition <= segmentContainer.Position)
{
newAlternatingLayer.Add(vertexStack.Pop());
}
else if (vertex.MeasuredPosition >= (segmentContainer.Position + segmentContainer.Count - 1))
{
newAlternatingLayer.Add(segmentContainerStack.Pop());
}
else
{
vertexStack.Pop();
segmentContainerStack.Pop();
var k = (int)Math.Ceiling(vertex.MeasuredPosition - segmentContainer.Position);
ISegmentContainer sc1, sc2;
segmentContainer.Split(k, out sc1, out sc2);
newAlternatingLayer.Add(sc1);
newAlternatingLayer.Add(vertex);
sc2.Position = segmentContainer.Position + k;
segmentContainerStack.Push(sc2);
}
}
if (vertexStack.Count > 0)
{
newAlternatingLayer.AddRange(vertexStack.OfType <IData>());
}
if (segmentContainerStack.Count > 0)
{
newAlternatingLayer.AddRange(segmentContainerStack.OfType <IData>());
}
return(newAlternatingLayer);
}
public AlternatingLayer Clone()
{
var clonedLayer = new AlternatingLayer();
foreach (var item in this)
{
var cloneableItem = item as ICloneable;
if (cloneableItem != null)
{
clonedLayer.Add(cloneableItem.Clone() as IData);
}
else
{
clonedLayer.Add(item);
}
}
return(clonedLayer);
}
private IList <SugiEdge> FindRealEdges([NotNull, ItemNotNull] AlternatingLayer topLayer)
{
Debug.Assert(topLayer != null);
var realEdges = new List <SugiEdge>();
foreach (IData item in topLayer)
{
var vertex = item as SugiVertex;
if (vertex is null || vertex.Type == VertexTypes.PVertex)
{
continue;
}
realEdges.AddRange(_graph.OutEdges(vertex));
}
return(realEdges);
}
private IList <SugiEdge> FindRealEdges(AlternatingLayer topLayer)
{
var realEdges = new List <SugiEdge>();
foreach (var item in topLayer)
{
var vertex = item as SugiVertex;
if (vertex == null || vertex.Type == VertexTypes.PVertex)
{
continue;
}
foreach (var edge in _graph.OutEdges(vertex))
{
realEdges.Add(edge);
}
}
return(realEdges);
}
private IList <SugiVertex> FindVerticesWithSameMeasure(AlternatingLayer nextAlternatingLayer, bool straightSweep, out IList <int> ranges, out int maxRangeLength)
{
var ignorableVertexType = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex;
var verticesWithSameMeasure = new List <SugiVertex>();
var vertices = nextAlternatingLayer.OfType <SugiVertex>().ToArray();
int startIndex, endIndex;
maxRangeLength = 0;
int rangeCount = 0;
ranges = new List <int>();
for (startIndex = 0; startIndex < vertices.Length; startIndex = endIndex + 1)
{
for (endIndex = startIndex + 1;
endIndex < vertices.Length && vertices[startIndex].MeasuredPosition == vertices[endIndex].MeasuredPosition;
endIndex++)
{
}
endIndex -= 1;
if (endIndex > startIndex)
{
int rangeLength = 0;
for (int i = startIndex; i <= endIndex; i++)
{
if (vertices[i].Type == ignorableVertexType || vertices[i].DoNotOpt)
{
continue;
}
rangeLength++;
verticesWithSameMeasure.Add(vertices[i]);
}
if (rangeLength > 0)
{
maxRangeLength = Math.Max(rangeLength, maxRangeLength);
ranges.Add(rangeLength);
rangeCount++;
}
}
}
return(verticesWithSameMeasure);
}
private int CrossingMinimizationBetweenLayers(
[NotNull, ItemNotNull] ref AlternatingLayer alternatingLayer,
int actualLayerIndex,
int nextLayerIndex,
bool enableSameMeasureOptimization,
int prevCrossCount,
int phase)
{
// Decide which way we are sweeping (up or down)
// Straight = down, reverse = up
bool straightSweep = actualLayerIndex < nextLayerIndex;
AlternatingLayer nextAlternatingLayer = alternatingLayer.Clone();
// 1
AppendSegmentsToAlternatingLayer(nextAlternatingLayer, straightSweep);
// 2
ComputeMeasureValues(alternatingLayer, nextLayerIndex, straightSweep);
nextAlternatingLayer.SetPositions();
// 3
nextAlternatingLayer = InitialOrderingOfNextLayer(nextAlternatingLayer, _layers[nextLayerIndex], straightSweep);
// 4
PlaceQVertices(nextAlternatingLayer, _layers[nextLayerIndex], straightSweep);
nextAlternatingLayer.SetPositions();
// 5
int crossCount = DoCrossCountingAndOptimization(
alternatingLayer,
nextAlternatingLayer,
straightSweep,
enableSameMeasureOptimization,
phase == 2,
prevCrossCount);
// 6
nextAlternatingLayer.EnsureAlternatingAndPositions();
alternatingLayer = nextAlternatingLayer;
return(crossCount);
}
/// <summary>
/// Replaces the P or Q vertices of the actualLayer with their
/// segment on the next layer.
/// </summary>
/// <param name="alternatingLayer">The actual alternating layer. It will be modified.</param>
/// <param name="straightSweep">If true, we are sweeping down else we're sweeping up.</param>
private void AppendSegmentsToAlternatingLayer(AlternatingLayer alternatingLayer, bool straightSweep)
{
var type = straightSweep ? VertexTypes.PVertex : VertexTypes.QVertex;
for (int i = 1; i < alternatingLayer.Count; i += 2)
{
var vertex = alternatingLayer[i] as SugiVertex;
if (vertex.Type == type)
{
var precedingContainer = alternatingLayer[i - 1] as SegmentContainer;
var succeedingContainer = alternatingLayer[i + 1] as SegmentContainer;
precedingContainer.Append(vertex.Segment);
precedingContainer.Join(succeedingContainer);
//remove the vertex and the succeeding container from the alternating layer
alternatingLayer.RemoveRange(i, 2);
i -= 2;
}
}
}
private static void ReinsertVerticesIntoLayer(
AlternatingLayer layer,
HashSet <SugiVertex> vertexSet,
IList <SugiVertex> vertexList)
{
int reinsertIndex = 0;
for (int i = 0; i < layer.Count; i++)
{
var vertex = layer[i] as SugiVertex;
if (vertex == null || !vertexSet.Contains(vertex))
{
continue;
}
layer.RemoveAt(i);
layer.Insert(i, vertexList[reinsertIndex]);
reinsertIndex++;
}
}
private IList <SugiEdge> FindRealEdges(AlternatingLayer topLayer, CancellationToken cancellationToken)
{
var realEdges = new List <SugiEdge>();
foreach (var item in topLayer)
{
var vertex = item as SugiVertex;
if (vertex == null || vertex.Type == VertexTypes.PVertex)
{
continue;
}
foreach (var edge in _graph.OutEdges(vertex))
{
cancellationToken.ThrowIfCancellationRequested();
realEdges.Add(edge);
}
}
return(realEdges);
}
private void OutputAlternatingLayer(AlternatingLayer alternatingLayer, int layerIndex, int crossCount)
{
/*!PCL-NON-COMPL! //Debug.Write(layerIndex + " | " + crossCount + ": ");
* for (int i = 0; i < alternatingLayer.Count; i++)
* {
* if (alternatingLayer[i] is SugiVertex)
* {
* var vertex = alternatingLayer[i] as SugiVertex;
* Debug.Write(string.Format("{0},{1}\t", vertex.OriginalVertex, vertex.Type.ToString()[0]));
* }
* else
* {
* var segmentContainer = alternatingLayer[i] as SegmentContainer;
* for (int j = 0; j < segmentContainer.Count; j++)
* {
* Debug.Write("| \t");
* }
* }
* }
* Debug.WriteLine("");*/
}
private void OutputAlternatingLayer(AlternatingLayer alternatingLayer, int layerIndex, int crossCount)
{
Debug.Write(layerIndex + " | " + crossCount + ": ");
for (int i = 0; i < alternatingLayer.Count; i++)
{
if (alternatingLayer[i] is SugiVertex)
{
var vertex = alternatingLayer[i] as SugiVertex;
Debug.Write(string.Format("{0},{1}\t", vertex.OriginalVertex, vertex.Type.ToString()[0]));
}
else
{
var segmentContainer = alternatingLayer[i] as SegmentContainer;
for (int j = 0; j < segmentContainer.Count; j++)
{
Debug.Write("| \t");
}
}
}
Debug.WriteLine("");
}
private int CrossingMinimizationBetweenLayers(
ref AlternatingLayer alternatingLayer,
int actualLayerIndex,
int nextLayerIndex,
bool enableSameMeasureOptimization,
int prevCrossCount,
int phase,
CancellationToken cancellationToken)
{
//decide which way we are sweeping (up or down)
//straight = down, reverse = up
bool straightSweep = (actualLayerIndex < nextLayerIndex);
var nextAlternatingLayer = alternatingLayer.Clone();
/* 1 */
AppendSegmentsToAlternatingLayer(nextAlternatingLayer, straightSweep);
/* 2 */
ComputeMeasureValues(alternatingLayer, nextLayerIndex, straightSweep, cancellationToken);
nextAlternatingLayer.SetPositions();
/* 3 */
nextAlternatingLayer = InitialOrderingOfNextLayer(nextAlternatingLayer, _layers[nextLayerIndex], straightSweep);
/* 4 */
PlaceQVertices(nextAlternatingLayer, _layers[nextLayerIndex], straightSweep, cancellationToken);
nextAlternatingLayer.SetPositions();
/* 5 */
int crossCount = DoCrossCountingAndOptimization(alternatingLayer, nextAlternatingLayer, straightSweep, enableSameMeasureOptimization, (phase == 2), prevCrossCount, cancellationToken);
/* 6 */
nextAlternatingLayer.EnsureAlternatingAndPositions();
alternatingLayer = nextAlternatingLayer;
return(crossCount);
}
private static void ReinsertVerticesIntoLayer(
[NotNull, ItemNotNull] AlternatingLayer layer,
[NotNull, ItemNotNull] ICollection <SugiVertex> vertexSet,
[NotNull, ItemNotNull] IList <SugiVertex> vertexList)
{
Debug.Assert(layer != null);
Debug.Assert(vertexSet != null);
Debug.Assert(vertexList != null);
int reinsertIndex = 0;
for (int i = 0; i < layer.Count; ++i)
{
var vertex = layer[i] as SugiVertex;
if (vertex is null || !vertexSet.Contains(vertex))
{
continue;
}
layer.RemoveAt(i);
layer.Insert(i, vertexList[reinsertIndex]);
++reinsertIndex;
}
}
