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; } }