/// <summary>
/// Creates a new routing network from existing data.
/// </summary>
private RoutingNetwork(GeometricGraph graph, ArrayBase <uint> edgeData,
float maxEdgeDistance = Constants.DefaultMaxEdgeDistance)
{
_graph = graph;
_edgeData = edgeData;
_maxEdgeDistance = maxEdgeDistance;
}
/// <summary>
/// Creates a new routing network.
/// </summary>
public RoutingNetwork(MemoryMap map, GeometricGraph graph,
float maxEdgeDistance = Constants.DefaultMaxEdgeDistance)
{
_graph = graph;
_edgeData = new MemoryArray <uint>(_edgeDataSize * graph.EdgeCount);
_maxEdgeDistance = maxEdgeDistance;
}
public void SortHilbertTestSteps4()
{
var n = 4;
// build locations.
var locations = new List <Coordinate>();
locations.Add(new Coordinate(-90, -180));
locations.Add(new Coordinate(-90, -60));
locations.Add(new Coordinate(-90, 60));
locations.Add(new Coordinate(-90, 180));
locations.Add(new Coordinate(-30, -180));
locations.Add(new Coordinate(-30, -60));
locations.Add(new Coordinate(-30, 60));
locations.Add(new Coordinate(-30, 180));
locations.Add(new Coordinate(30, -180));
locations.Add(new Coordinate(30, -60));
locations.Add(new Coordinate(30, 60));
locations.Add(new Coordinate(30, 180));
locations.Add(new Coordinate(90, -180));
locations.Add(new Coordinate(90, -60));
locations.Add(new Coordinate(90, 60));
locations.Add(new Coordinate(90, 180));
// build graph.
var graph = new GeometricGraph(1);
for (var vertex = 0; vertex < locations.Count; vertex++)
{
graph.AddVertex((uint)vertex, locations[vertex].Latitude,
locations[vertex].Longitude);
}
// build a sorted version in-place.
graph.Sort(n);
// test if sorted.
for (uint vertex = 1; vertex < graph.VertexCount - 1; vertex++)
{
Assert.IsTrue(
graph.Distance(n, vertex) <=
graph.Distance(n, vertex + 1));
}
// sort locations.
locations.Sort((x, y) =>
{
return(HilbertCurve.HilbertDistance(x.Latitude, x.Longitude, n).CompareTo(
HilbertCurve.HilbertDistance(y.Latitude, y.Longitude, n)));
});
// confirm sort.
for (uint vertex = 0; vertex < graph.VertexCount; vertex++)
{
float latitude, longitude;
graph.GetVertex(vertex, out latitude, out longitude);
Assert.AreEqual(latitude, locations[(int)vertex].Latitude);
Assert.AreEqual(longitude, locations[(int)vertex].Longitude);
}
}
/// <summary>
/// Creates a new tile-based isochrone builder.
/// </summary>
/// <param name="edgeVisitor">The algorithm that visits the edges.</param>
/// <param name="limits">The limits to generate isochrones for.</param>
/// <param name="level">The level of detail specified as an OpenStreetMap tile zoom level.</param>
public TileBasedIsochroneBuilder(GeometricGraph graph, IEdgeVisitor <float> edgeVisitor, List <float> limits, int level)
{
_graph = graph;
_limits = limits;
_level = level;
_edgeVisitor = edgeVisitor;
}
public void TestEdgeCount()
{
var graph = new GeometricGraph(1, 100);
// add edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
Assert.AreEqual(1, graph.EdgeCount);
graph = new GeometricGraph(1, 100);
// add edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddVertex(11001, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
graph.AddEdge(0, 11001, new uint[] { 10 }, null);
Assert.AreEqual(2, graph.EdgeCount);
graph.AddEdge(0, 11001, new uint[] { 20 }, null);
Assert.AreEqual(3, graph.EdgeCount);
Assert.AreEqual(2, graph.RemoveEdges(0, 11001));
Assert.AreEqual(1, graph.EdgeCount);
Assert.AreEqual(1, graph.RemoveEdges(0, 1));
Assert.AreEqual(0, graph.EdgeCount);
}
public void TestSetVertex()
{
var graph = new GeometricGraph(1, 100);
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 1, 1);
graph.AddVertex(2, 2, 2);
float latitude, longitude;
Assert.IsTrue(graph.GetVertex(0, out latitude, out longitude));
Assert.AreEqual(0, latitude);
Assert.AreEqual(0, longitude);
Assert.AreEqual(0, graph.GetVertex(0).Latitude);
Assert.AreEqual(0, graph.GetVertex(0).Longitude);
Assert.IsTrue(graph.GetVertex(1, out latitude, out longitude));
Assert.AreEqual(1, latitude);
Assert.AreEqual(1, longitude);
Assert.AreEqual(1, graph.GetVertex(1).Latitude);
Assert.AreEqual(1, graph.GetVertex(1).Longitude);
Assert.IsTrue(graph.GetVertex(2, out latitude, out longitude));
Assert.AreEqual(2, latitude);
Assert.AreEqual(2, longitude);
Assert.AreEqual(2, graph.GetVertex(2).Latitude);
Assert.AreEqual(2, graph.GetVertex(2).Longitude);
Assert.IsFalse(graph.GetVertex(10000, out latitude, out longitude));
}
/// <summary>
/// Creates a router point for the given vertex.
/// </summary>
public static RouterPoint CreateRouterPointForVertex(this GeometricGraph graph, uint vertex, uint neighbour)
{
float latitude, longitude;
if (!graph.GetVertex(vertex, out latitude, out longitude))
{
throw new ArgumentException("Vertex doesn't exist, cannot create routerpoint.");
}
var edges = graph.GetEdgeEnumerator(vertex);
while (true)
{
if (!edges.MoveNext())
{
throw new ArgumentException("No edges associated with vertex and it's neigbour, cannot create routerpoint.");
}
if (edges.To == neighbour)
{
break;
}
}
if (edges.DataInverted)
{
return(new RouterPoint(latitude, longitude, edges.Id, ushort.MaxValue));
}
return(new RouterPoint(latitude, longitude, edges.Id, 0));
}
/// <summary>
/// Creates a new routing network.
/// </summary>
public RoutingNetwork(MemoryMap map, GeometricGraph graph,
float maxEdgeDistance = Constants.DefaultMaxEdgeDistance)
{
_graph = graph;
_edgeData = Context.ArrayFactory.CreateMemoryBackedArray <uint>(_edgeDataSize * graph.EdgeCount);
_maxEdgeDistance = maxEdgeDistance;
}
/// <summary>
/// Searches for an edge that has the exact start- and endpoints given within the given tolerance.
/// </summary>
public static uint SearchEdgeExact(this GeometricGraph graph, Coordinate location1, Coordinate location2, float tolerance)
{
var vertex1 = graph.SearchClosest(location1.Latitude, location1.Longitude, 0.01f, 0.01f);
if (vertex1 == Constants.NO_VERTEX)
{
return(Constants.NO_EDGE);
}
var vertex1Location = graph.GetVertex(vertex1);
if (Coordinate.DistanceEstimateInMeter(location1, vertex1Location) > tolerance)
{
return(Constants.NO_EDGE);
}
var edgeEnumerator = graph.GetEdgeEnumerator();
var best = float.MaxValue;
var bestEdge = Constants.NO_EDGE;
while (edgeEnumerator.MoveNext())
{
var vertex2Location = graph.GetVertex(edgeEnumerator.To);
var dist = Coordinate.DistanceEstimateInMeter(location2, vertex2Location);
if (dist < tolerance &&
dist < best)
{
best = dist;
bestEdge = edgeEnumerator.Id;
}
}
return(bestEdge);
}
public void TestVertexCountAndTrim()
{
var graph = new GeometricGraph(1, 100);
// add edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
// trim.
graph.Trim();
Assert.AreEqual(2, graph.VertexCount);
Assert.AreEqual(1, graph.EdgeCount);
graph = new GeometricGraph(1, 100);
// add edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddVertex(11001, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
graph.AddEdge(0, 11001, new uint[] { 10 }, null);
// trim.
graph.Trim();
Assert.AreEqual(11002, graph.VertexCount);
Assert.AreEqual(2, graph.EdgeCount);
graph = new GeometricGraph(1, 100);
// trim.
graph.Trim(); // keep minimum one vertex.
Assert.AreEqual(0, graph.VertexCount);
}
/// <summary>
/// Creates a new dykstra edge visitor.
/// </summary>
public DykstraEdgeVisitor(GeometricGraph geometricGraph,
Func <ushort, Factor> getFactor, IEnumerable <EdgePath <float> > source, float limitInSeconds)
{
_geometricGraph = geometricGraph;
_getFactor = getFactor;
_source = source;
_limitInSeconds = limitInSeconds;
}
public ResolveMultipleAlgorithm(GeometricGraph graph, float latitude, float longitude, float maxOffset, float maxDistance, Func <GeometricEdge, bool> isAcceptable)
{
this._graph = graph;
this._latitude = latitude;
this._longitude = longitude;
this._maxDistance = maxDistance;
this._maxOffset = maxOffset;
this._isAcceptable = isAcceptable;
}
public void TestRemoveEdges()
{
var graph = new GeometricGraph(1, 100);
// add and remove edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
Assert.AreEqual(1, graph.RemoveEdges(0));
Assert.AreEqual(0, graph.RemoveEdges(1));
// verify all edges.
var edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(0, edges.Count());
graph = new GeometricGraph(1, 100);
// add and remove edges.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddVertex(2, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
graph.AddEdge(0, 2, new uint[] { 10 }, null);
Assert.AreEqual(2, graph.RemoveEdges(0));
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(0, edges.Count());
graph = new GeometricGraph(1, 100);
// add and remove edges.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddVertex(2, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
graph.AddEdge(0, 2, new uint[] { 20 }, null);
graph.AddEdge(1, 2, new uint[] { 30 }, null);
Assert.AreEqual(2, graph.RemoveEdges(0));
// verify all edges.
edges = graph.GetEdgeEnumerator(0);
Assert.AreEqual(0, edges.Count());
edges = graph.GetEdgeEnumerator(1);
Assert.AreEqual(1, edges.Count());
edges = graph.GetEdgeEnumerator(2);
Assert.AreEqual(1, edges.Count());
}
/// <summary>
/// Creates a new resolve algorithm.
/// </summary>
public ResolveVertexAlgorithm(GeometricGraph graph, float latitude, float longitude,
float maxOffsetInMeter, float maxDistance, Func <GeometricEdge, bool> isAcceptable)
{
_graph = graph;
_latitude = latitude;
_longitude = longitude;
_maxDistance = maxDistance;
_maxOffsetInMeter = maxOffsetInMeter;
_isAcceptable = isAcceptable;
}
public ResolveAlgorithm(GeometricGraph graph, float latitude, float longitude, float maxOffsetInMeter, float maxDistance, Func <GeometricEdge, bool> isAcceptable, Func <GeometricEdge, bool> isBetter)
{
this._graph = graph;
this._latitude = latitude;
this._longitude = longitude;
this._maxDistance = maxDistance;
this._maxOffsetInMeter = maxOffsetInMeter;
this._isAcceptable = isAcceptable;
this._isBetter = isBetter;
}
public static long Distance(this GeometricGraph graph, int n, uint vertex)
{
float latitude;
float longitude;
if (!graph.GetVertex(vertex, out latitude, out longitude))
{
throw new Exception(string.Format("Cannot calculate hilbert distance, vertex {0} does not exist.", (object)vertex));
}
return(HilbertCurve.HilbertDistance(latitude, longitude, (long)n));
}
public void TestGetShape()
{
var graph = new GeometricGraph(2, 100);
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 1, 1);
graph.AddVertex(2, 0, 1);
graph.AddVertex(3, 0, 2);
var edge1 = graph.AddEdge(0, 1, new uint[] { 0, 10 },
new Coordinate(0.25f, 0.25f),
new Coordinate(0.50f, 0.50f),
new Coordinate(0.75f, 0.75f));
var shape = graph.GetShape(graph.GetEdge(edge1));
Assert.IsNotNull(shape);
Assert.AreEqual(5, shape.Count);
Assert.AreEqual(0, shape[0].Latitude);
Assert.AreEqual(0, shape[0].Longitude);
Assert.AreEqual(0.25, shape[1].Latitude);
Assert.AreEqual(0.25, shape[1].Longitude);
Assert.AreEqual(0.5, shape[2].Latitude);
Assert.AreEqual(0.5, shape[2].Longitude);
Assert.AreEqual(0.75, shape[3].Latitude);
Assert.AreEqual(0.75, shape[3].Longitude);
Assert.AreEqual(1, shape[4].Latitude);
Assert.AreEqual(1, shape[4].Longitude);
shape = graph.GetShape(graph.GetEdgeEnumerator(0).First());
Assert.IsNotNull(shape);
Assert.AreEqual(5, shape.Count);
Assert.AreEqual(0, shape[0].Latitude);
Assert.AreEqual(0, shape[0].Longitude);
Assert.AreEqual(0.25, shape[1].Latitude);
Assert.AreEqual(0.25, shape[1].Longitude);
Assert.AreEqual(0.5, shape[2].Latitude);
Assert.AreEqual(0.5, shape[2].Longitude);
Assert.AreEqual(0.75, shape[3].Latitude);
Assert.AreEqual(0.75, shape[3].Longitude);
Assert.AreEqual(1, shape[4].Latitude);
Assert.AreEqual(1, shape[4].Longitude);
shape = graph.GetShape(graph.GetEdgeEnumerator(1).First(x => x.To == 0));
Assert.IsNotNull(shape);
Assert.AreEqual(5, shape.Count);
Assert.AreEqual(1, shape[0].Latitude);
Assert.AreEqual(1, shape[0].Longitude);
Assert.AreEqual(0.75, shape[1].Latitude);
Assert.AreEqual(0.75, shape[1].Longitude);
Assert.AreEqual(0.5, shape[2].Latitude);
Assert.AreEqual(0.5, shape[2].Longitude);
Assert.AreEqual(0.25, shape[3].Latitude);
Assert.AreEqual(0.25, shape[3].Longitude);
Assert.AreEqual(0, shape[4].Latitude);
Assert.AreEqual(0, shape[4].Longitude);
}
public static HashSet <uint> Search(this GeometricGraph graph, int n, float minLatitude, float minLongitude, float maxLatitude, float maxLongitude)
{
List <long> longList = HilbertCurve.HilbertDistances(System.Math.Max(minLatitude, -90f), System.Math.Max(minLongitude, -180f), System.Math.Min(maxLatitude, 90f), System.Math.Min(maxLongitude, 180f), (long)n);
longList.Sort();
HashSet <uint> uintSet = new HashSet <uint>();
int index = 0;
uint vertex1 = 0;
uint vertex2 = graph.VertexCount - 1U;
for (; index < longList.Count && vertex1 < graph.VertexCount; ++index)
{
long num1 = longList[index];
long maxHilbert;
for (maxHilbert = num1; index < longList.Count - 1 && longList[index + 1] <= maxHilbert + 1L; ++index)
{
maxHilbert = longList[index + 1];
}
uint vertex;
int count;
float latitude;
float longitude;
if (num1 == maxHilbert)
{
if (graph.Search(num1, n, vertex1, vertex2, out vertex, out count))
{
int num2 = count;
for (; count > 0; --count)
{
if (graph.GetVertex(vertex + (uint)(count - 1), out latitude, out longitude) && (double)minLatitude < (double)latitude && ((double)minLongitude < (double)longitude && (double)maxLatitude > (double)latitude) && (double)maxLongitude > (double)longitude)
{
uintSet.Add(vertex + (uint)(count - 1));
}
}
vertex1 = vertex + (uint)num2;
}
}
else if (graph.SearchRange(num1, maxHilbert, n, vertex1, vertex2, out vertex, out count))
{
int num2 = count;
for (; count > 0; --count)
{
if (graph.GetVertex(vertex + (uint)(count - 1), out latitude, out longitude) && (double)minLatitude < (double)latitude && ((double)minLongitude < (double)longitude && (double)maxLatitude > (double)latitude) && (double)maxLongitude > (double)longitude)
{
uintSet.Add(vertex + (uint)(count - 1));
}
}
vertex1 = vertex + (uint)num2;
}
}
return(uintSet);
}
public void SearchClosestVertexTest()
{
var graph = new GeometricGraph(1);
graph.AddVertex(0, 1, 1);
graph.AddVertex(1, 2, 2);
graph.Sort();
Assert.AreEqual(0, graph.SearchClosest(1, 1, 1, 1));
Assert.AreEqual(1, graph.SearchClosest(2, 2, 1, 1));
Assert.AreEqual(Constants.NO_VERTEX, graph.SearchClosest(3, 3, .5f, .5f));
}
/// <summary>
/// Deserializes from a stream.
/// </summary>
public static RoutingNetwork Deserialize(Stream stream, RoutingNetworkProfile profile)
{
var version = stream.ReadByte();
if (version > 2)
{
throw new Exception(string.Format("Cannot deserialize routing network: Invalid version #: {0}, upgrade Itinero.", version));
}
var position = stream.Position;
var initialPosition = stream.Position;
// read maxEdgeDistance if version # = 2.
var maxEdgeDistance = Constants.DefaultMaxEdgeDistance;
if (version == 2)
{
var bytes = new byte[4];
stream.Read(bytes, 0, 4);
maxEdgeDistance = BitConverter.ToSingle(bytes, 0);
}
// deserialize graph.
var graph = GeometricGraph.Deserialize(stream, profile == null ? null : profile.GeometricGraphProfile);
var size = stream.Position - position;
var edgeLength = graph.EdgeCount;
var edgeSize = 1;
ArrayBase <uint> edgeData;
if (profile == null)
{ // just create arrays and read the data.
edgeData = Context.ArrayFactory.CreateMemoryBackedArray <uint>(edgeLength * edgeSize);
edgeData.CopyFrom(stream);
size += edgeLength * edgeSize * 4;
}
else
{ // create accessors over the exact part of the stream that represents vertices/edges.
position = stream.Position;
var map = new MemoryMapStream(new CappedStream(stream, position,
edgeLength * edgeSize * 4));
edgeData = new Array <uint>(map.CreateUInt32(edgeLength * edgeSize), profile.EdgeDataProfile);
size += edgeLength * edgeSize * 4;
}
// make stream is positioned correctly.
stream.Seek(initialPosition + size, System.IO.SeekOrigin.Begin);
return(new RoutingNetwork(graph, edgeData, maxEdgeDistance));
}
public RoutingNetwork(MemoryMap map, RoutingNetworkProfile profile, float maxEdgeDistance = 5000f)
{
this._maxEdgeDistance = maxEdgeDistance;
if (profile == null)
{
this._graph = new GeometricGraph(map, 1);
this._edgeData = (ArrayBase <uint>) new Array <uint>(map, (long)this._edgeDataSize * this._graph.EdgeCount);
}
else
{
this._graph = new GeometricGraph(map, profile.GeometricGraphProfile, 1);
this._edgeData = (ArrayBase <uint>) new Array <uint>(map, (long)this._edgeDataSize * this._graph.EdgeCount, profile.EdgeDataProfile);
}
}
public static void Sort(this GeometricGraph graph, int n)
{
if (graph.VertexCount <= 0U)
{
return;
}
QuickSort.Sort((Func <long, long>)(vertex => graph.Distance(n, (uint)vertex)), (Action <long, long>)((vertex1, vertex2) =>
{
if (vertex1 == vertex2)
{
return;
}
graph.Switch((uint)vertex1, (uint)vertex2);
}), 0L, (long)(graph.VertexCount - 1U));
}
/// <summary>
/// Creates a new routing network.
/// </summary>
public RoutingNetwork(MemoryMap map, RoutingNetworkProfile profile,
float maxEdgeDistance = Constants.DefaultMaxEdgeDistance)
{
_maxEdgeDistance = maxEdgeDistance;
if (profile == null)
{
_graph = new GeometricGraph(map, 1);
_edgeData = new Array <uint>(map, _edgeDataSize * _graph.EdgeCount);
}
else
{
_graph = new GeometricGraph(map, profile.GeometricGraphProfile, 1);
_edgeData = new Array <uint>(map, _edgeDataSize * _graph.EdgeCount, profile.EdgeDataProfile);
}
}
public void TestArgumentExcptions()
{
// create graph with one vertex and start adding 2.
var graph = new GeometricGraph(1, 2);
// make sure to add 1 and 2.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 1, 1);
graph.AddEdge(0, 1, new uint[] { 1 }, null);
Assert.Catch <ArgumentOutOfRangeException>(() =>
{
graph.GetEdgeEnumerator(2);
});
}
public void TestTwoEdgesWithIsBetter()
{
var vertex0 = new Coordinate(51.26779566943717f, 4.801347255706787f);
var vertex1 = new Coordinate(51.26689735000000f, 4.801347255706787f);
var vertex2 = new Coordinate(51.26689735000000f, 4.801347255706787f);
var graph = new GeometricGraph(1);
graph.AddVertex(0, vertex0.Latitude, vertex0.Longitude);
graph.AddVertex(1, vertex1.Latitude, vertex1.Longitude);
graph.AddVertex(2, vertex2.Latitude, vertex2.Longitude);
graph.AddEdge(0, 1, new uint[] { 0 }, null);
var expectedEdgeId = graph.AddEdge(0, 2, new uint[] { 1 }, null);
// resolve on vertex0.
var location = vertex0;
var resolver = new ResolveAlgorithm(graph, location.Latitude, location.Longitude, Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); }, (edge) => { return(edge.Data[0] == 1); });
resolver.Run();
var result = resolver.Result;
Assert.IsNotNull(result);
Assert.AreEqual(expectedEdgeId, result.EdgeId);
// resolve on vertex1.
location = vertex1;
resolver = new ResolveAlgorithm(graph, location.Latitude, location.Longitude, Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); }, (edge) => { return(edge.Data[0] == 1); });
resolver.Run();
result = resolver.Result;
Assert.IsNotNull(result);
Assert.AreEqual(expectedEdgeId, result.EdgeId);
// resolve right in between.
location = new Coordinate((vertex0.Latitude + vertex1.Latitude) / 2,
(vertex0.Longitude + vertex1.Longitude) / 2);
resolver = new ResolveAlgorithm(graph, location.Latitude, location.Longitude, Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); }, (edge) => { return(edge.Data[0] == 1); });
resolver.Run();
result = resolver.Result;
Assert.IsNotNull(result);
Assert.AreEqual(expectedEdgeId, result.EdgeId);
}
public void TestSerialize()
{
var graph = new GeometricGraph(1, 100);
// add one edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
// serialize.
graph.Compress();
var expectedSize = graph.SizeInBytes;
using (var stream = new System.IO.MemoryStream())
{
Assert.AreEqual(expectedSize, graph.Serialize(stream));
}
graph = new GeometricGraph(1, 100);
// add one edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddVertex(2, 0, 0);
graph.AddVertex(3, 0, 0);
graph.AddVertex(4, 0, 0);
graph.AddVertex(5, 0, 0);
graph.AddEdge(0, 1, new uint[] { 10 }, null);
graph.AddEdge(0, 2, new uint[] { 20 }, null);
graph.AddEdge(0, 3, new uint[] { 30 }, null);
graph.AddEdge(0, 4, new uint[] { 40 }, null);
graph.AddEdge(5, 1, new uint[] { 50 }, null);
graph.AddEdge(5, 2, new uint[] { 60 }, null);
graph.AddEdge(5, 3, new uint[] { 70 }, null);
graph.AddEdge(5, 4, new uint[] { 80 }, null);
// serialize.
graph.Compress();
expectedSize = graph.SizeInBytes;
using (var stream = new System.IO.MemoryStream())
{
Assert.AreEqual(expectedSize, graph.Serialize(stream));
}
}
public static RoutingNetwork Deserialize(Stream stream, RoutingNetworkProfile profile)
{
int num1 = stream.ReadByte();
if (num1 > 2)
{
throw new Exception(string.Format("Cannot deserialize routing network: Invalid version #: {0}, upgrade OsmSharp.Routing.", (object)num1));
}
long position1 = stream.Position;
long position2 = stream.Position;
float num2 = 5000f;
if (num1 == 2)
{
byte[] buffer = new byte[4];
stream.Read(buffer, 0, 4);
num2 = BitConverter.ToSingle(buffer, 0);
}
GeometricGraph graph = GeometricGraph.Deserialize(stream, profile == null ? (GeometricGraphProfile)null : profile.GeometricGraphProfile);
long num3 = stream.Position - position1;
long edgeCount = graph.EdgeCount;
int num4 = 1;
ArrayBase <uint> arrayBase;
long num5;
if (profile == null)
{
arrayBase = (ArrayBase <uint>) new MemoryArray <uint>(edgeCount * (long)num4);
arrayBase.CopyFrom(stream);
num5 = num3 + edgeCount * (long)num4 * 4L;
}
else
{
long position3 = stream.Position;
arrayBase = (ArrayBase <uint>) new Array <uint>(((MemoryMap) new MemoryMapStream((Stream) new CappedStream(stream, position3, edgeCount * (long)num4 * 4L))).CreateUInt32(edgeCount * (long)num4), profile.EdgeDataProfile);
num5 = num3 + edgeCount * (long)num4 * 4L;
}
stream.Seek(position2 + num5, SeekOrigin.Begin);
ArrayBase <uint> edgeData = arrayBase;
double num6 = (double)num2;
return(new RoutingNetwork(graph, edgeData, (float)num6));
}
public void TestRemoveEdge()
{
var graph = new GeometricGraph(1, 100);
// add and remove edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
graph.AddEdge(0, 1, new uint[] { 1 }, null);
Assert.IsTrue(graph.RemoveEdges(0, 1) != 0);
graph = new GeometricGraph(1, 100);
// add and remove edge.
graph.AddVertex(0, 0, 0);
graph.AddVertex(1, 0, 0);
var edge = graph.AddEdge(0, 1, new uint[] { 10 }, null);
Assert.IsTrue(graph.RemoveEdge(edge));
}
public void TestOneEdge()
{
var vertex0 = new Coordinate(51.26779566943717f, 4.801347255706787f);
var vertex1 = new Coordinate(51.26689735000000f, 4.801347255706787f);
var graph = new GeometricGraph(1);
graph.AddVertex(0, (float)vertex0.Latitude, (float)vertex0.Longitude);
graph.AddVertex(1, (float)vertex1.Latitude, (float)vertex1.Longitude);
graph.AddEdge(0, 1, new uint[] { 0 }, null);
// resolve on vertex0.
var location = vertex0;
var resolver = new ResolveAlgorithm(graph, (float)location.Latitude, (float)location.Longitude,
Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); });
resolver.Run();
var result = resolver.Result;
Assert.IsNotNull(result);
// resolve on vertex1.
location = vertex1;
resolver = new ResolveAlgorithm(graph, (float)location.Latitude, (float)location.Longitude, Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); });
resolver.Run();
result = resolver.Result;
Assert.IsNotNull(result);
// resolve right in between.
location = new Coordinate((vertex0.Latitude + vertex1.Latitude) / 2,
(vertex0.Longitude + vertex1.Longitude) / 2);
resolver = new ResolveAlgorithm(graph, (float)location.Latitude, (float)location.Longitude, Constants.DefaultMaxEdgeDistance, 50f,
(edge) => { return(true); });
resolver.Run();
result = resolver.Result;
Assert.IsNotNull(result);
}
public static RouterPoint CreateRouterPointForVertex(this GeometricGraph graph, uint vertex)
{
float latitude;
float longitude;
if (!graph.GetVertex(vertex, out latitude, out longitude))
{
throw new ArgumentException("Vertex doesn't exist, cannot create routerpoint.");
}
GeometricGraph.EdgeEnumerator edgeEnumerator = graph.GetEdgeEnumerator(vertex);
if (!edgeEnumerator.MoveNext())
{
throw new ArgumentException("No edges associated with vertex, cannot create routerpoint.");
}
if (edgeEnumerator.DataInverted)
{
return(new RouterPoint(latitude, longitude, edgeEnumerator.Id, ushort.MaxValue));
}
return(new RouterPoint(latitude, longitude, edgeEnumerator.Id, (ushort)0));
}
