public void TestLiveEdgeDynamicGraphEdge10000()
{
int count = 10000;
IDynamicGraph <LiveEdge> graph = this.CreateGraph();
uint vertex1 = graph.AddVertex(51, 1);
while (count > 0)
{
uint vertex2 = graph.AddVertex(51, 1);
graph.AddArc(vertex1, vertex2, new LiveEdge()
{
Tags = 0,
Forward = false
}, null);
KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(vertex1);
Assert.AreEqual(10000 - count + 1, arcs.Length);
graph.AddArc(vertex2, vertex1, new LiveEdge()
{
Tags = 0,
Forward = false
}, null);
arcs = graph.GetArcs(vertex2);
Assert.AreEqual(1, arcs.Length);
Assert.AreEqual(0, arcs[0].Value.Tags);
Assert.AreEqual(vertex1, arcs[0].Key);
count--;
}
}
public void TestLiveEdgeDynamicGraphEdge()
{
IDynamicGraph <LiveEdge> graph = this.CreateGraph();
uint vertex1 = graph.AddVertex(51, 1);
uint vertex2 = graph.AddVertex(51, 2);
graph.AddArc(vertex1, vertex2, new LiveEdge()
{
Forward = true,
Tags = 0
}, null);
KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(vertex1);
Assert.AreEqual(1, arcs.Length);
Assert.AreEqual(0, arcs[0].Value.Tags);
Assert.AreEqual(vertex2, arcs[0].Key);
graph.AddArc(vertex2, vertex1, new LiveEdge()
{
Forward = true,
Tags = 0
}, null);
arcs = graph.GetArcs(vertex2);
Assert.AreEqual(1, arcs.Length);
Assert.AreEqual(0, arcs[0].Value.Tags);
Assert.AreEqual(vertex1, arcs[0].Key);
}
/// <summary>
/// Calculates the edge-difference if u would be contracted.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
public float Calculate(uint vertex)
{
// get the neighbours.
KeyValuePair <uint, CHEdgeData>[] neighbours = _data.GetArcs(vertex);
// simulate the construction of new edges.
int new_edges = 0;
int removed = neighbours.Length;
// loop over all neighbours and check for witnesses.
foreach (KeyValuePair <uint, CHEdgeData> from in neighbours)
{ // loop over all incoming neighbours
foreach (KeyValuePair <uint, CHEdgeData> to in neighbours)
{ // loop over all outgoing neighbours
if (to.Key != from.Key)
{ // the neighbours point to different vertices.
// a new edge is needed.
if (!_witness_calculator.Exists(from.Key, to.Key, vertex,
(float)from.Value.Weight + (float)to.Value.Weight, int.MaxValue))
{ // no witness exists.
new_edges++;
}
}
}
}
return(new_edges - removed);
}
/// <summary>
/// Calculates the ordering.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
public float Calculate(uint vertex)
{
KeyValuePair <uint, CHEdgeData>[] neighbours = _data.GetArcs(vertex);
// check the proper conditions.
if (neighbours.Length == 2)
{
return(-1);
}
return(float.MaxValue);
}
/// <summary>
/// Calculates the ordering.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
public float Calculate(uint vertex)
{
KeyValuePair <uint, CHEdgeData>[] neighbours = _data.GetArcs(vertex);
// remove all informative edges.
neighbours = neighbours.RemoveInformativeEdges();
// check the proper conditions.
if (neighbours.Length == 2)
{
return(-1);
}
return(float.MaxValue);
}
/// <summary>
/// Calculates the edge-difference if u would be contracted.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
public float Calculate(uint vertex)
{
short contracted = 0;
_contraction_count.TryGetValue(vertex, out contracted);
// get the neighbours.
KeyValuePair <uint, CHEdgeData>[] neighbours = _data.GetArcs(vertex);
// simulate the construction of new edges.
int new_edges = 0;
int removed = neighbours.Length;
// loop over all neighbours and check for witnesses.
foreach (KeyValuePair <uint, CHEdgeData> from in neighbours)
{ // loop over all incoming neighbours
foreach (KeyValuePair <uint, CHEdgeData> to in neighbours)
{ // loop over all outgoing neighbours
if (to.Key != from.Key)
{ // the neighbours point to different vertices.
// a new edge is needed.
if (!_witness_calculator.Exists(from.Key, to.Key, vertex,
(float)from.Value.Weight + (float)to.Value.Weight, 50))
{ // no witness exists.
new_edges++;
}
}
}
}
// get the depth.
long depth = 0;
_depth.TryGetValue(vertex, out depth);
return((3 * (new_edges - removed)) + (2 * contracted));// +depth;
//return (new_edges - removed) + depth;
}
public void TestLiveEdgeDynamicGraphVertex()
{
IDynamicGraph <LiveEdge> graph = this.CreateGraph();
uint vertex = graph.AddVertex(51, 4);
float latitude, longitude;
graph.GetVertex(vertex, out latitude, out longitude);
Assert.AreEqual(51, latitude);
Assert.AreEqual(4, longitude);
KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(vertex);
Assert.AreEqual(0, arcs.Length);
}
/// <summary>
/// Moves to the next item.
/// </summary>
/// <returns></returns>
public bool MoveNext()
{
if (_current == null)
{
_current = this.FindHighest();
_index.Add(_current.Vertex);
_currentCount = 1;
return(_current != null);
}
// search for the next arc.
KeyValuePair <uint, CHEdgeData>[] edges = _graph.GetArcs(_current.Vertex);
int arcIdx = _current.ArcIdx;
arcIdx++;
while (arcIdx < edges.Length)
{ // check if it is 'lower'.
if (!edges[arcIdx].Value.ToHigher &&
!_index.Contains(edges[arcIdx].Key))
{ // yes the arc is 'lower' take it!
_current.ArcIdx = arcIdx; // move the arcIdx.
Position newPosition = new Position();
newPosition.Parent = _current;
newPosition.ArcIdx = -1;
newPosition.Vertex = edges[arcIdx].Key;
newPosition.Depth = _current.Depth + 1;
_current = newPosition;
_index.Add(_current.Vertex);
_currentCount++;
return(true);
}
arcIdx++; // move to the next arc.
}
// move to parent.
if (_current.Parent != null)
{ // set parent as current and move next.
_current = _current.Parent;
return(this.MoveNext());
}
// also enumerate all the other 'islands' of vertices unconnected to the current vertices.
return(this.MoveToNextIsland());
}
/// <summary>
/// Returns the arcs that point to lower vertices.
/// </summary>
/// <param name="graph"></param>
/// <param name="vertexId"></param>
/// <returns></returns>
public static KeyValuePair <uint, CHEdgeData>[] GetArcsLower(this IDynamicGraph <CHEdgeData> graph,
uint vertexId)
{
KeyValuePair <uint, CHEdgeData>[] arcs = graph.GetArcs(vertexId);
KeyValuePair <uint, CHEdgeData>[] higherArcs = new KeyValuePair <uint, CHEdgeData> [arcs.Length];
int higherIdx = 0;
for (int idx = 0; idx < arcs.Length; idx++)
{
if (!arcs[idx].Value.ToHigher)
{
higherArcs[higherIdx] = arcs[idx];
higherIdx++;
}
}
Array.Resize(ref higherArcs, higherIdx);
return(higherArcs);
}
/// <summary>
/// Adds all downward edges.
/// </summary>
/// <param name="graph"></param>
public static void AddDownwardEdges(this IDynamicGraph <CHEdgeData> graph)
{ // add the reverse edges to get a easy depth-first search.
for (uint vertexId = 1; vertexId < graph.VertexCount; vertexId++)
{
List <KeyValuePair <uint, CHEdgeData> > arcs =
new List <KeyValuePair <uint, CHEdgeData> >(graph.GetArcs(vertexId));
foreach (KeyValuePair <uint, CHEdgeData> arc in arcs)
{
if (arc.Value.ToHigher)
{
// create severse edge.
CHEdgeData reverseEdge = new CHEdgeData();
reverseEdge.SetDirection(arc.Value.Backward, arc.Value.Forward, false);
reverseEdge.Weight = arc.Value.Weight;
graph.AddArc(arc.Key, vertexId, reverseEdge, null);
}
}
}
}
public void TestLiveEdgeDynamicGraphVertex10000()
{
IDynamicGraph <LiveEdge> graph = this.CreateGraph();
int count = 10000;
while (count > 0)
{
uint vertex = graph.AddVertex(51, 4);
float latitude, longitude;
graph.GetVertex(vertex, out latitude, out longitude);
Assert.AreEqual(51, latitude);
Assert.AreEqual(4, longitude);
KeyValuePair <uint, LiveEdge>[] arcs = graph.GetArcs(vertex);
Assert.AreEqual(0, arcs.Length);
count--;
}
Assert.AreEqual((uint)10000, graph.VertexCount);
}
/// <summary>
/// Returns all arcs starting at a given vertex.
/// </summary>
/// <param name="vertexId"></param>
/// <returns></returns>
public KeyValuePair <uint, TEdgeData>[] GetArcs(uint vertexId)
{
return(_graph.GetArcs(vertexId));
}
/// <summary>
/// Does the v2 serialization.
/// </summary>
/// <param name="stream"></param>
/// <param name="graph"></param>
/// <returns></returns>
protected override void DoSerialize(LimitedStream stream,
DynamicGraphRouterDataSource <CHEdgeData> graph)
{
// sort the graph.
IDynamicGraph <CHEdgeData> sortedGraph = CHEdgeDataDataSourceSerializer.SortGraph(graph);
// create the regions.
SortedDictionary <ulong, List <uint> > regions = new SortedDictionary <ulong, List <uint> >();
for (uint newVertexId = 1; newVertexId < sortedGraph.VertexCount + 1; newVertexId++)
{
// add to the CHRegions.
float latitude, longitude;
sortedGraph.GetVertex(newVertexId, out latitude, out longitude);
Tile tile = Tile.CreateAroundLocation(new GeoCoordinate(
latitude, longitude), RegionZoom);
List <uint> regionVertices;
if (!regions.TryGetValue(tile.Id, out regionVertices))
{
regionVertices = new List <uint>();
regions.Add(tile.Id, regionVertices);
}
regionVertices.Add(newVertexId);
}
// serialize the sorted graph.
// [START_OF_BLOCKS][[SIZE_OF_REGION_INDEX][REGION_INDEX][REGIONS]][[SIZE_OF_BLOCK_INDEX][BLOCK_INDEX][BLOCKS]]
// STRART_OF_BLOCKS: 4bytes
// SIZE_OF_REGION_INDEX: 4bytes
// REGION_INDEX: see SIZE_OF_REGION_INDEX
// REGIONS: see START_OF_BLOCKS - 4bytes
// SIZE_OF_BLOCK_INDEX: 4bytes
// BLOCK_INDEX: see SIZE_OF_BLOCK_INDEX.
// BLOCKS: from START_OF_BLOCKS + 4bytes + SIZE_OF_BLOCKS_INDEX until END.
// serialize regions and build their index.
CHVertexRegionIndex chRegionIndex = new CHVertexRegionIndex();
chRegionIndex.LocationIndex = new int[regions.Count];
chRegionIndex.RegionIds = new ulong[regions.Count];
var memoryStream = new MemoryStream();
int regionIdx = 0;
foreach (KeyValuePair <ulong, List <uint> > region in regions)
{
// serialize.
CHVertexRegion chRegion = new CHVertexRegion();
chRegion.Vertices = region.Value.ToArray();
_runtimeTypeModel.Serialize(memoryStream, chRegion);
// set index.
chRegionIndex.LocationIndex[regionIdx] = (int)memoryStream.Position;
chRegionIndex.RegionIds[regionIdx] = region.Key;
regionIdx++;
}
stream.Seek(8, SeekOrigin.Begin); // move to beginning of [REGION_INDEX]
_runtimeTypeModel.Serialize(stream, chRegionIndex); // write region index.
int sizeRegionIndex = (int)(stream.Position - 8); // now at beginning of [REGIONS]
memoryStream.Seek(0, SeekOrigin.Begin);
memoryStream.WriteTo(stream); // write regions.
memoryStream.Dispose();
int startOfBlocks = (int)stream.Position; // now at beginning of [SIZE_OF_BLOCK_INDEX]
stream.Seek(0, SeekOrigin.Begin); // move to beginning
stream.Write(BitConverter.GetBytes(startOfBlocks), 0, 4); // write start position of blocks. Now at [SIZE_OF_REGION_INDEX]
stream.Write(BitConverter.GetBytes(sizeRegionIndex), 0, 4); // write size of blocks index.
// serialize the blocks and build their index.
memoryStream = new MemoryStream();
List <int> blockLocations = new List <int>();
uint vertexId = 1;
while (vertexId < sortedGraph.VertexCount)
{
uint blockId = vertexId;
List <CHArc> blockArcs = new List <CHArc>();
List <CHVertex> blockVertices = new List <CHVertex>();
while (vertexId < blockId + BlockVertexSize &&
vertexId < sortedGraph.VertexCount + 1)
{ // create this block.
CHVertex chVertex = new CHVertex();
float latitude, longitude;
sortedGraph.GetVertex(vertexId, out latitude, out longitude);
chVertex.Latitude = latitude;
chVertex.Longitude = longitude;
chVertex.ArcIndex = (ushort)(blockArcs.Count);
foreach (KeyValuePair <uint, CHEdgeData> sortedArc in sortedGraph.GetArcs(vertexId))
{
CHArc chArc = new CHArc();
chArc.TargetId = sortedArc.Key;
chArc.ShortcutId = sortedArc.Value.ContractedVertexId;
chArc.Weight = sortedArc.Value.Weight;
chArc.Direction = sortedArc.Value.Direction;
blockArcs.Add(chArc);
}
chVertex.ArcCount = (ushort)(blockArcs.Count - chVertex.ArcIndex);
blockVertices.Add(chVertex);
vertexId++; // move to the next vertex.
}
// create block.
CHBlock block = new CHBlock();
block.Arcs = blockArcs.ToArray();
block.Vertices = blockVertices.ToArray(); // TODO: get rid of the list and create an array to begin with.
// write blocks.
_runtimeTypeModel.Serialize(memoryStream, block);
blockLocations.Add((int)memoryStream.Position);
}
CHBlockIndex blockIndex = new CHBlockIndex();
blockIndex.LocationIndex = blockLocations.ToArray();
stream.Seek(startOfBlocks + 4, SeekOrigin.Begin); // move to beginning of [BLOCK_INDEX]
_runtimeTypeModel.Serialize(stream, blockIndex); // write region index.
int sizeBlockIndex = (int)(stream.Position - (startOfBlocks + 4)); // now at beginning of [BLOCKS]
memoryStream.Seek(0, SeekOrigin.Begin);
memoryStream.WriteTo(stream); // write blocks.
memoryStream.Dispose();
stream.Seek(startOfBlocks, SeekOrigin.Begin); // move to [SIZE_OF_BLOCK_INDEX]
stream.Write(BitConverter.GetBytes(sizeBlockIndex), 0, 4); // write start position of blocks. Now at [SIZE_OF_REGION_INDEX]
stream.Flush();
}
/// <summary>
/// Returns a topologically sorted version of the given graph.
/// </summary>
/// <param name="graph"></param>
/// <returns></returns>
public IDynamicGraph <CHEdgeData> SortGraph(IDynamicGraph <CHEdgeData> graph)
{
// also add all downward edges.
graph.AddDownwardEdges();
// sort the topologically ordered vertices into bins representing a certain height range.
List <uint>[] heightBins = new List <uint> [1000];
foreach (var vertexDepth in new CHDepthFirstEnumerator(graph))
{ // enumerates all vertixes depth-first.
int binIdx = (int)(vertexDepth.Depth / _heightBinSize);
if (heightBins.Length < binIdx)
{ // resize bin array if needed.
Array.Resize(ref heightBins, System.Math.Max(heightBins.Length + 1000, binIdx + 1));
}
// add to the current bin.
List <uint> bin = heightBins[binIdx];
if (bin == null)
{ // create new bin.
bin = new List <uint>();
heightBins[binIdx] = bin;
}
bin.Add(vertexDepth.VertexId);
}
// temp test.
MemoryDynamicGraph <CHEdgeData> sortedGraph = new MemoryDynamicGraph <CHEdgeData>();
Dictionary <uint, uint> currentBinIds = new Dictionary <uint, uint>();
uint newVertexId;
for (int idx = 0; idx < heightBins.Length; idx++)
{
List <uint> bin = heightBins[idx];
if (bin != null)
{ // translate ids.
// fill current bin ids and add vertices to the new graph.
foreach (uint binVertexId in bin)
{
float latitude, longitude;
graph.GetVertex(binVertexId, out latitude, out longitude);
newVertexId = sortedGraph.AddVertex(latitude, longitude);
currentBinIds.Add(binVertexId, newVertexId); // add to the current bin index.
}
}
}
// rebuild the CH graph based on the new ordering and build the CHRegions.
newVertexId = 0;
for (int idx = 0; idx < heightBins.Length; idx++)
{
List <uint> bin = heightBins[idx];
if (bin != null)
{ // translate ids.
foreach (uint binVertexId in bin)
{
currentBinIds.TryGetValue(binVertexId, out newVertexId);
// get the higher arcs and convert their ids.
//KeyValuePair<uint, CHEdgeData>[] arcs = graph.GetArcsHigher(binVertexId);
KeyValuePair <uint, CHEdgeData>[] arcs = graph.GetArcs(binVertexId);
foreach (KeyValuePair <uint, CHEdgeData> arc in arcs)
{
if (arc.Value.IsInformative || arc.Value.ToHigher)
{
// get target vertex.
uint nextVertexArcId = CHEdgeDataDataSourceSerializer.SearchVertex(arc.Key, currentBinIds, heightBins);
// convert edge.
CHEdgeData newEdge = new CHEdgeData();
newEdge.Direction = arc.Value.Direction;
if (arc.Value.HasContractedVertex)
{ // contracted info.
newEdge.ContractedVertexId = CHEdgeDataDataSourceSerializer.SearchVertex(arc.Value.ContractedVertexId, currentBinIds, heightBins);
}
else
{ // no contracted info.
newEdge.ContractedVertexId = 0;
}
newEdge.Tags = arc.Value.Tags;
newEdge.Weight = arc.Value.Weight;
sortedGraph.AddArc(newVertexId, nextVertexArcId, newEdge, null);
}
}
}
}
}
return(sortedGraph);
}
/// <summary>
/// Contracts the given vertex.
/// </summary>
/// <param name="vertex"></param>
public void Contract(uint vertex)
{
if (_contracted.Length > vertex && _contracted[vertex])
{
throw new Exception("Is already contracted!");
}
// keep the neighbours.
HashSet <uint> neighbours = new HashSet <uint>();
// get all information from the source.
KeyValuePair <uint, CHEdgeData>[] edges = _target.GetArcs(vertex);
// report the before contraction event.
this.OnBeforeContraction(vertex, edges);
// remove the edges from the neighbours to the target.
foreach (KeyValuePair <uint, CHEdgeData> edge in edges)
{ // remove the edge.
_target.DeleteArc(edge.Key, vertex);
// keep the neighbour.
neighbours.Add(edge.Key);
}
// loop over each combination of edges just once.
for (int x = 1; x < edges.Length; x++)
{ // loop over all elements first.
KeyValuePair <uint, CHEdgeData> xEdge = edges[x];
for (int y = 0; y < x; y++)
{ // loop over all elements.
KeyValuePair <uint, CHEdgeData> yEdge = edges[y];
// calculate the total weight.
float weight = xEdge.Value.Weight + yEdge.Value.Weight;
// add the combinations of these edges.
if (((xEdge.Value.Backward && yEdge.Value.Forward) ||
(yEdge.Value.Backward && xEdge.Value.Forward)) &&
(xEdge.Key != yEdge.Key))
{ // there is a connection from x to y and there is no witness path.
bool witnessXToY = _witnessCalculator.Exists(xEdge.Key, yEdge.Key, vertex, weight, 100);
bool witnessYToX = _witnessCalculator.Exists(yEdge.Key, xEdge.Key, vertex, weight, 100);
// create x-to-y data and edge.
CHEdgeData dataXToY = new CHEdgeData();
bool forward = (xEdge.Value.Backward && yEdge.Value.Forward) &&
!witnessXToY;
bool backward = (yEdge.Value.Backward && xEdge.Value.Forward) &&
!witnessYToX;
dataXToY.SetDirection(forward, backward, true);
dataXToY.Weight = weight;
dataXToY.ContractedVertexId = vertex;
if ((dataXToY.Forward || dataXToY.Backward) ||
!_target.HasNeighbour(xEdge.Key, yEdge.Key))
{ // add the edge if there is usefull info or if there needs to be a neighbour relationship.
_target.AddArc(xEdge.Key, yEdge.Key, dataXToY, _comparer);
}
// create y-to-x data and edge.
CHEdgeData dataYToX = new CHEdgeData();
forward = (yEdge.Value.Backward && xEdge.Value.Forward) &&
!witnessYToX;
backward = (xEdge.Value.Backward && yEdge.Value.Forward) &&
!witnessXToY;
dataYToX.SetDirection(forward, backward, true);
dataYToX.Weight = weight;
dataYToX.ContractedVertexId = vertex;
if ((dataYToX.Forward || dataYToX.Backward) ||
!_target.HasNeighbour(yEdge.Key, xEdge.Key))
{ // add the edge if there is usefull info or if there needs to be a neighbour relationship.
_target.AddArc(yEdge.Key, xEdge.Key, dataYToX, _comparer);
}
}
}
}
// mark the vertex as contracted.
this.MarkContracted(vertex);
// notify a contracted neighbour.
_calculator.NotifyContracted(vertex);
// report the after contraction event.
this.OnAfterContraction(vertex, edges);
}
