/// <summary>
/// Tests routing from a serialized routing file.
/// </summary>
/// <param name="name"></param>
/// <param name="stream"></param>
/// <param name="testCount"></param>
public static void TestResolved(string name, Stream stream, GeoCoordinateBox box, int testCount)
{
var vehicle = Vehicle.Car;
var tagsIndex = new TagsIndex(); // creates a tagged index.
// read from the OSM-stream.
var source = new OsmSharp.Osm.Streams.Filters.OsmStreamFilterProgress();
source.RegisterSource(new OsmSharp.Osm.PBF.Streams.PBFOsmStreamSource(stream));
var data = GraphOsmStreamTarget.Preprocess(source,
new OsmRoutingInterpreter());
//(data.Graph as DirectedGraph<CHEdgeData>).Compress(true);
RoutingResolveTest.TestResolved(data, testCount, box);
}
public void TestGraphSerialize3()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var graph = GraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)),
new TagsIndex(new MemoryMappedStream(new MemoryStream())), interpreter);
// serialize.
using (var stream = new MemoryStream())
{
graph.Serialize(stream, Edge.SizeUints, Edge.MapFromDelegate, Edge.MapToDelegate);
// deserialize.
stream.Seek(0, SeekOrigin.Begin);
var graphDeserialized = RouterDataSource <Edge> .Deserialize(stream, Edge.SizeUints, Edge.MapFromDelegate, Edge.MapToDelegate, false);
// compare.
Assert.AreEqual(graph.VertexCount, graphDeserialized.VertexCount);
for (uint vertex = 1; vertex <= graph.VertexCount; vertex++)
{
float latitude1, longitude1, latitude2, longitude2;
if (graph.GetVertex(vertex, out latitude1, out longitude1) &&
graphDeserialized.GetVertex(vertex, out latitude2, out longitude2))
{
Assert.AreEqual(latitude1, latitude2, 0.000001);
Assert.AreEqual(longitude1, longitude2, 0.000001);
}
var edges = graph.GetEdges(vertex).ToKeyValuePairs();
var edgesDeserialized = graphDeserialized.GetEdges(vertex).ToKeyValuePairs();
Assert.AreEqual(edges.Length, edgesDeserialized.Length);
for (int idx = 0; idx < edges.Length; idx++)
{
Assert.AreEqual(edges[idx].Value.Distance, edgesDeserialized[idx].Value.Distance);
Assert.AreEqual(edges[idx].Value.Tags, edgesDeserialized[idx].Value.Tags);
Assert.AreEqual(edges[idx].Value.Forward, edgesDeserialized[idx].Value.Forward);
}
}
}
}
public void RoutingSerialization()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// create the tags index (and make sure it's serializable).
var tagsIndex = new TagsIndex(new MemoryMappedStream(new MemoryStream()));
// load the network.
var referenceNetwork = GraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)),
tagsIndex, new OsmRoutingInterpreter());
// serialize network.
var routingSerializer = new RoutingDataSourceSerializer();
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
using (var stream = new MemoryStream())
{
routingSerializer.Serialize(stream, referenceNetwork, metaData);
stream.Seek(0, SeekOrigin.Begin);
var network = routingSerializer.Deserialize(stream, out metaData);
// compare networks.
Assert.IsNotNull(network);
Assert.AreEqual(referenceNetwork.VertexCount, network.VertexCount);
for (uint vertex = 0; vertex < network.VertexCount; vertex++)
{
float referenceLatitude, referenceLongitude, latitude, longitude;
Assert.IsTrue(referenceNetwork.GetVertex(vertex, out referenceLatitude, out referenceLongitude));
Assert.IsTrue(network.GetVertex(vertex, out latitude, out longitude));
Assert.AreEqual(referenceLatitude, latitude);
Assert.AreEqual(referenceLongitude, longitude);
var referenceEdges = referenceNetwork.GetEdges(vertex).ToKeyValuePairs();
var edges = network.GetEdges(vertex).ToKeyValuePairs();
Assert.AreEqual(referenceEdges.Length, edges.Length);
for (int idx = 0; idx < referenceEdges.Length; idx++)
{
var referenceEdge = referenceEdges[idx];
// find the same edge in the new arcs.
var edge = edges.First((x) => { return(x.Key == referenceEdges[idx].Key); });
Assert.AreEqual(referenceEdge.Key, edge.Key);
Assert.AreEqual(referenceEdge.Value.Distance, edge.Value.Distance);
Assert.AreEqual(referenceEdge.Value.Forward, edge.Value.Forward);
Assert.AreEqual(referenceEdge.Value.RepresentsNeighbourRelations, edge.Value.RepresentsNeighbourRelations);
Assert.AreEqual(referenceEdge.Value.Tags, edge.Value.Tags);
ICoordinateCollection referenceCoordinates;
ICoordinateCollection coordinates;
if (referenceNetwork.GetEdgeShape(vertex, referenceEdge.Key, out referenceCoordinates))
{ // there is a shape.
Assert.IsTrue(network.GetEdgeShape(vertex, edge.Key, out coordinates));
if (referenceCoordinates == null)
{ // reference shape is null, shape is null.
Assert.IsNull(coordinates);
}
else
{ // reference shape is not null compare them.
Assert.IsNotNull(coordinates);
referenceCoordinates.Reset();
coordinates.Reset();
while (referenceCoordinates.MoveNext())
{
Assert.IsTrue(coordinates.MoveNext());
Assert.AreEqual(referenceCoordinates.Latitude, coordinates.Latitude);
Assert.AreEqual(referenceCoordinates.Longitude, coordinates.Longitude);
}
Assert.IsFalse(coordinates.MoveNext());
}
}
else
{ // there is no shape.
Assert.IsFalse(network.GetEdgeShape(vertex, edge.Key, out coordinates));
}
// check tags.
var referenceTags = referenceNetwork.TagsIndex.Get(referenceEdge.Value.Tags);
var tags = network.TagsIndex.Get(edge.Value.Tags);
if (referenceTags == null)
{ // other tags also have to be null.
Assert.IsNull(tags);
}
else
{ // contents need to be the same.
Assert.AreEqual(referenceTags.Count, tags.Count);
foreach (var referenceTag in referenceTags)
{
Assert.IsTrue(tags.ContainsKeyValue(referenceTag.Key, referenceTag.Value));
}
}
}
}
}
}
public void RoutingSerializationRoutingComparisonTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// create the tags index (and make sure it's serializable).
var tagsIndex = new TagsIndex(new MemoryMappedStream(new MemoryStream()));
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original = GraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
tagsIndex,
interpreter);
// create serializer.
var routingSerializer = new RoutingDataSourceSerializer();
// serialize/deserialize.
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
byte[] byteArray;
using (var stream = new MemoryStream())
{
try
{
routingSerializer.Serialize(stream, original, metaData);
byteArray = stream.ToArray();
}
catch (Exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw;
}
}
var deserializedVersion =
routingSerializer.Deserialize(new MemoryStream(byteArray), out metaData);
Assert.AreEqual(original.TagsIndex.Get(0), deserializedVersion.TagsIndex.Get(0));
//// try to do some routing on the deserialized version.
//var basicRouter =
// new Dykstra();
//var router = Router.CreateFrom(
// deserializedVersion, basicRouter, interpreter);
//var referenceRouter = Router.CreateFrom(
// original, basicRouter, interpreter);
//// loop over all nodes and resolve their locations.
//var resolvedReference = new RouterPoint[original.VertexCount];
//var resolved = new RouterPoint[original.VertexCount];
//for (uint idx = 1; idx < original.VertexCount + 1; idx++)
//{ // resolve each vertex.
// float latitude, longitude;
// if (original.GetVertex(idx, out latitude, out longitude))
// {
// resolvedReference[idx - 1] = referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
// resolved[idx - 1] = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
// }
// Assert.IsNotNull(resolvedReference[idx - 1]);
// Assert.IsNotNull(resolved[idx - 1]);
// Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude,
// resolved[idx - 1].Location.Latitude, 0.0001);
// Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude,
// resolved[idx - 1].Location.Longitude, 0.0001);
//}
//// check all the routes having the same weight(s).
//for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++)
//{
// for (int toIdx = 0; toIdx < resolved.Length; toIdx++)
// {
// var referenceRoute = referenceRouter.Calculate(Vehicle.Car,
// resolvedReference[fromIdx], resolvedReference[toIdx]);
// var route = router.Calculate(Vehicle.Car,
// resolved[fromIdx], resolved[toIdx]);
// Assert.IsNotNull(referenceRoute);
// Assert.IsNotNull(route);
// //Assert.AreEqual(referenceRoute.TotalDistance, route.TotalDistance, 0.1);
// // TODO: meta data is missing in some CH routing; see issue
// //Assert.AreEqual(reference_route.TotalTime, route.TotalTime, 0.0001);
// }
//}
}