public void TestRandomBlockTagSerializaton()
{
TagsTableCollectionIndex tagsIndex = new TagsTableCollectionIndex();
TagsCollection tagsCollection = new TagsCollection();
for (int i = 0; i < 100; i++)
{
int tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(10) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
int tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(10);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
uint tagsId = tagsIndex.Add(tagsCollection);
}
ITagsCollectionIndexReadonly tagsIndexReadonly = this.SerializeDeserializeBlock(tagsIndex, 10, 0);
Assert.AreEqual(tagsIndex.Max, tagsIndexReadonly.Max);
for (uint idx = 0; idx < tagsIndex.Max; idx++)
{
ComparisonHelpers.CompareTags(tagsIndex.Get(idx),
tagsIndexReadonly.Get(idx));
}
}
/// <summary>
/// Tests preprocessing data from a PBF file.
/// </summary>
/// <param name="name"></param>
/// <param name="pbfFile"></param>
public static void TestSerialization(string name, string pbfFile)
{
FileInfo testFile = new FileInfo(string.Format(@".\TestFiles\{0}", pbfFile));
Stream stream = testFile.OpenRead();
PBFOsmStreamSource source = new PBFOsmStreamSource(stream);
FileInfo testOutputFile = new FileInfo(@"test.routing");
testOutputFile.Delete();
Stream writeStream = testOutputFile.OpenWrite();
CHEdgeGraphFileStreamTarget target = new CHEdgeGraphFileStreamTarget(writeStream,
Vehicle.Car);
target.RegisterSource(source);
PerformanceInfoConsumer performanceInfo = new PerformanceInfoConsumer("CHSerializer");
performanceInfo.Start();
performanceInfo.Report("Pulling from {0}...", testFile.Name);
var data = CHEdgeGraphOsmStreamTarget.Preprocess(
source, new OsmRoutingInterpreter(), Vehicle.Car);
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
var routingSerializer = new CHEdgeDataDataSourceSerializer(true);
routingSerializer.Serialize(writeStream, data, metaData);
stream.Dispose();
writeStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("CHSerializer", OsmSharp.Logging.TraceEventType.Information,
string.Format("Serialized file: {0}KB", testOutputFile.Length / 1024));
performanceInfo.Stop();
}
public void MapCSSEvalTagTest()
{
string function = "tag('width')";
TagsCollectionBase tags = new TagsCollection();
tags.Add("width", "2");
Assert.AreEqual(2, EvalInterpreter.Instance.InterpretDouble(function, tags));
}
/// <summary>
/// Tests the probable speed.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="speed"></param>
/// <param name="tags"></param>
protected void TextProbableSpeed(Vehicle vehicle, double speed, params string[] tags)
{
// build tags collection.
TagsCollection tagsCollection = new TagsCollection();
for (int idx = 0; idx < tags.Length; idx = idx + 2)
{
tagsCollection.Add(tags[idx], tags[idx + 1]);
}
Assert.AreEqual(speed, vehicle.ProbableSpeed(tagsCollection).Value);
}
/// <summary>
/// Returns the union of the two tags collections
/// </summary>
// TODO: write tests for TagsCollectionBase.Union
public TagsCollectionBase Union(TagsCollectionBase other)
{
if (other.Count == 0)
{
return(this);
}
if (this.Count == 0)
{
return(other);
}
var union = new TagsCollection();
// add all from this
foreach (var tag in this)
{
union.Add(tag);
}
// add all from other
foreach (var tag in other)
{
// if it exists in both
if (union.ContainsKey(tag.Key))
{
// collisions cause exceptions
if (union[tag.Key] != tag.Value)
{
throw new ArgumentException("Contains a collision with collection", nameof(other));
}
}
else
{
union.Add(tag);
}
}
return(union);
}
public void TestBooleanParsing()
{
// test IsTrue.
TagsCollectionBase tags = new TagsCollection();
tags.Add("area", "yes");
Assert.IsTrue(tags.IsTrue("area"));
tags = new TagsCollection();
tags.Add("area", "1");
Assert.IsTrue(tags.IsTrue("area"));
tags = new TagsCollection();
tags.Add("area", "true");
Assert.IsTrue(tags.IsTrue("area"));
tags = new TagsCollection();
tags.Add("area", "false");
Assert.IsFalse(tags.IsTrue("area"));
tags = new TagsCollection();
tags.Add("area", "0");
Assert.IsFalse(tags.IsTrue("area"));
tags = new TagsCollection();
tags.Add("area", "no");
Assert.IsFalse(tags.IsTrue("area"));
// test IsFalse.
tags = new TagsCollection();
tags.Add("area", "yes");
Assert.IsFalse(tags.IsFalse("area"));
tags = new TagsCollection();
tags.Add("area", "1");
Assert.IsFalse(tags.IsFalse("area"));
tags = new TagsCollection();
tags.Add("area", "true");
Assert.IsFalse(tags.IsFalse("area"));
tags = new TagsCollection();
tags.Add("area", "false");
Assert.IsTrue(tags.IsFalse("area"));
tags = new TagsCollection();
tags.Add("area", "0");
Assert.IsTrue(tags.IsFalse("area"));
tags = new TagsCollection();
tags.Add("area", "no");
Assert.IsTrue(tags.IsFalse("area"));
}
/// <summary>
/// Creates a new tags collection with only the given keys.
/// </summary>
/// <param name="keys"></param>
/// <returns></returns>
public virtual TagsCollectionBase KeepKeysOf(ICollection <string> keys)
{
TagsCollection collection = new TagsCollection(this.Count);
foreach (var tag in this)
{
if (keys.Contains(tag.Key))
{
collection.Add(tag);
}
}
return(collection);
}
/// <summary>
/// Tests serializing a stream.
/// </summary>
/// <param name="name"></param>
/// <param name="stream"></param>
/// <param name="scene"></param>
/// <param name="compress"></param>
public static void TestSerialize(string name, Stream stream, Scene2D scene, bool compress)
{
PerformanceInfoConsumer performanceInfo = new PerformanceInfoConsumer(string.Format("{0}.Serialize", name));
performanceInfo.Start();
performanceInfo.Report("Serializing stream...");
TagsCollectionBase metaTags = new TagsCollection();
metaTags.Add("generated_by", "performance_test");
scene.Serialize(stream, compress, metaTags);
performanceInfo.Stop();
Console.Write("", scene.BackColor);
}
/// <summary>
/// Returns the tags with the given id.
/// </summary>
/// <param name="tagsId"></param>
/// <returns></returns>
public TagsCollectionBase Get(uint tagsId)
{
OsmTags osmTags = _tagsCollectionTable.Get(tagsId);
if (osmTags != null)
{
TagsCollection collection = new TagsCollection();
for (int idx = 0; idx < osmTags.Tags.Length; idx++)
{
collection.Add(
_tagsTable.Get(osmTags.Tags[idx]));
}
return(collection);
}
return(null);
}
/// <summary>
/// Tests preprocessing data from a PBF file.
/// </summary>
/// <param name="name"></param>
/// <param name="pbfFile"></param>
public static void TestSerialization(string name, string pbfFile)
{
var testFile = new FileInfo(string.Format(@".\TestFiles\{0}", pbfFile));
var stream = testFile.OpenRead();
var source = new OsmSharp.Osm.Streams.Filters.OsmStreamFilterProgress();
source.RegisterSource(new PBFOsmStreamSource(stream));
var testOutputFile = new FileInfo(@"test.pedestrian.routing");
testOutputFile.Delete();
Stream writeStream = testOutputFile.OpenWrite();
var tagsIndex = new TagsTableCollectionIndex();
var interpreter = new OsmRoutingInterpreter();
var graph = new DynamicGraphRouterDataSource<CHEdgeData>(tagsIndex);
var performanceInfo = new PerformanceInfoConsumer("CHSerializerFlatFile.Serialize");
performanceInfo.Start();
performanceInfo.Report("Pulling from {0}...", testFile.Name);
var data = CHEdgeGraphOsmStreamTarget.Preprocess(
source, new OsmRoutingInterpreter(), Vehicle.Car);
var metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
var routingSerializer = new CHEdgeFlatfileSerializer();
routingSerializer.Serialize(writeStream, data, metaData);
stream.Dispose();
writeStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("CHSerializerFlatFile", OsmSharp.Logging.TraceEventType.Information,
string.Format("Serialized file: {0}KB", testOutputFile.Length / 1024));
performanceInfo.Stop();
performanceInfo = new PerformanceInfoConsumer("CHSerializerFlatFile.Deserialize");
performanceInfo.Start();
performanceInfo.Report("Deserializing again...");
// open file again and read.
writeStream = testOutputFile.OpenRead();
var deserializedGraph = routingSerializer.Deserialize(writeStream);
performanceInfo.Stop();
}
/// <summary>
/// Tests the can traverse functionality.
/// </summary>
protected void TestVehicleCanTranverse(Vehicle vehicle, bool result, params string[] tags)
{
// build tags collection.
TagsCollection tagsCollection = new TagsCollection();
for (int idx = 0; idx < tags.Length; idx = idx + 2)
{
tagsCollection.Add(tags[idx], tags[idx + 1]);
}
if (result)
{ // assume the result is true.
Assert.IsTrue(vehicle.CanTraverse(tagsCollection));
}
else
{ // assume the result is false.
Assert.IsFalse(vehicle.CanTraverse(tagsCollection));
}
}
/// <summary>
/// Tests the given tags collection index.
/// </summary>
/// <param name="tagsCollectionIndex"></param>
protected void TestTagsCollectionIndex(ITagsCollectionIndex tagsCollectionIndex)
{
List<KeyValuePair<uint, TagsCollectionBase>> addedTags = new List<KeyValuePair<uint, TagsCollectionBase>>();
for (int i = 0; i < 100; i++)
{
TagsCollection tagsCollection = new TagsCollection();
int tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
int tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
int addCount = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(2) + 1;
for (int idx = 0; idx < addCount; idx++)
{
uint tagsId = tagsCollectionIndex.Add(tagsCollection);
addedTags.Add(new KeyValuePair<uint, TagsCollectionBase>(tagsId, tagsCollection));
TagsCollectionBase indexTags = tagsCollectionIndex.Get(tagsId);
Assert.AreEqual(tagsCollection.Count, indexTags.Count);
foreach (Tag tag in tagsCollection)
{
Assert.IsTrue(indexTags.ContainsKeyValue(tag.Key, tag.Value));
}
}
}
// check the index.
foreach (KeyValuePair<uint, TagsCollectionBase> pair in addedTags)
{
TagsCollectionBase indexTags = tagsCollectionIndex.Get(pair.Key);
Assert.AreEqual(pair.Value.Count, indexTags.Count);
foreach (Tag tag in pair.Value)
{
Assert.IsTrue(indexTags.ContainsKeyValue(tag.Key, tag.Value));
}
foreach (Tag tag in indexTags)
{
Assert.IsTrue(pair.Value.ContainsKeyValue(tag.Key, tag.Value));
}
}
}
/// <summary>
/// Tests adding simple tags to the given index.
/// </summary>
/// <param name="index"></param>
/// <param name="collectionCount"></param>
public static void FillIndex(ITagsCollectionIndex index, int collectionCount)
{
for (int i = 0; i < collectionCount; i++)
{
TagsCollection tagsCollection = new TagsCollection();
int tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
int tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(100);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
int addCount = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(2) + 1;
for (int idx = 0; idx < addCount; idx++)
{
uint tagsId = index.Add(tagsCollection);
}
}
}
public void TestTagIndexSerialization()
{
// set the seed manually.
OsmSharp.Math.Random.StaticRandomGenerator.Set(116542346);
// build a tags index and keep what was added.
var tagsIndex = new TagsIndex(new MemoryMappedStream(new MemoryStream()));
var addedTags = new List<KeyValuePair<uint, TagsCollectionBase>>();
for (int i = 0; i < 100; i++)
{
var tagsCollection = new TagsCollection();
var tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
var tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
var addCount = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(2) + 1;
for (int idx = 0; idx < addCount; idx++)
{
var tagsId = tagsIndex.Add(tagsCollection);
addedTags.Add(new KeyValuePair<uint, TagsCollectionBase>(tagsId, tagsCollection));
var indexTags = tagsIndex.Get(tagsId);
Assert.AreEqual(tagsCollection.Count, indexTags.Count);
foreach (var tag in tagsCollection)
{
Assert.IsTrue(indexTags.ContainsKeyValue(tag.Key, tag.Value));
}
}
}
// serialize/deserialize.
var deserializedTagsIndex = this.SerializeDeserialize(tagsIndex, false);
// verify if what was added is still there.
this.TestTagIndexContent(deserializedTagsIndex, addedTags);
}
private void ModifyTags(long id, TagsCollectionBase neTags, string table, string refColumn)
{
OracleCommand command;
TagsCollectionBase tagsToInsert = null;
if (neTags == null)
{
tagsToInsert = new TagsCollection();
}
else
{
tagsToInsert = new TagsCollection(neTags);
}
// suppose there are no tags present yet.
TagsCollectionBase tags_to_update = new TagsCollection();
TagsCollectionBase tags_to_delete = new TagsCollection();
// adjust the data based on the tags already present.
command = this.CreateCommand(string.Format("select * from {0} where {1}=:{1}",table,refColumn));
command.Parameters.Add(refColumn, id);
OracleDataReader reader = command.ExecuteReader();
while (reader.Read())
{
string k = reader["key"].ToStringEmptyWhenNull();
string v = reader["value"].ToStringEmptyWhenNull();
if (tagsToInsert.ContainsKey(k))
{
// there is at least an update or no insert.
string new_value = tagsToInsert[k];
tagsToInsert.RemoveKeyValue(new Tag(k, v));
// see if there is an update needed.
if (new_value != v)
{
// tags need to be updated.
tags_to_update.Add(k, new_value);
}
}
else
{
// tags are not found; delete them!
tags_to_delete.Add(k, v);
}
}
reader.Close();
// delete old tags.
foreach(Tag tag in tags_to_delete)
{
command = this.CreateCommand(string.Format("delete from {0} where {1}=:{1} and key=:key", table, refColumn));
command.Parameters.Add(new OracleParameter(refColumn, id));
command.Parameters.Add(new OracleParameter("key", tag.Key));
command.ExecuteNonQuery();
command.Dispose();
}
// update tags.
foreach (Tag pair in tags_to_update)
{
command = this.CreateCommand(string.Format("update {0} set value=:value where {1}=:{1} and key=:key", table, refColumn));
command.Parameters.Add(new OracleParameter("value", pair.Value));
command.Parameters.Add(new OracleParameter(refColumn, id));
command.Parameters.Add(new OracleParameter("key", pair.Key));
command.ExecuteNonQuery();
command.Dispose();
}
// insert tags.
foreach (Tag pair in tagsToInsert)
{
command = this.CreateCommand(string.Format("insert into {0} ({1},key,value) values (:{1},:key,:value)",table,refColumn));
command.Parameters.Add(new OracleParameter(refColumn, id));
command.Parameters.Add(new OracleParameter("key", pair.Key));
command.Parameters.Add(new OracleParameter("value", pair.Value));
command.ExecuteNonQuery();
command.Dispose();
}
}
public void RoutingSerializationV2CompressedRoutingTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network.osm";
// create the tags index.
var tagsIndex = new TagsTableCollectionIndex();
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original =
new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex);
var targetData = new LiveGraphOsmStreamTarget(
original, interpreter, tagsIndex);
var dataProcessorSource = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString));
targetData.RegisterSource(dataProcessorSource);
targetData.Pull();
// create serializer.
var routingSerializer = new V2RoutingDataSourceLiveEdgeSerializer(true);
// 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;
}
}
IBasicRouterDataSource<LiveEdge> 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 DykstraRoutingLive();
Router router = Router.CreateLiveFrom(deserializedVersion, basicRouter, interpreter);
RouterPoint source = router.Resolve(Vehicle.Car,
new GeoCoordinate(51.0578532, 3.7192229));
RouterPoint target = router.Resolve(Vehicle.Car,
new GeoCoordinate(51.0576193, 3.7191801));
// calculate the route.
Route route = router.Calculate(Vehicle.Car, source, target);
Assert.IsNotNull(route);
Assert.AreEqual(5, route.Entries.Length);
float latitude, longitude;
deserializedVersion.GetVertex(20, out latitude, out longitude);
Assert.AreEqual(latitude, route.Entries[0].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Entries[0].Longitude, 0.00001);
Assert.AreEqual(RoutePointEntryType.Start, route.Entries[0].Type);
deserializedVersion.GetVertex(21, out latitude, out longitude);
Assert.AreEqual(latitude, route.Entries[1].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Entries[1].Longitude, 0.00001);
Assert.AreEqual(RoutePointEntryType.Along, route.Entries[1].Type);
deserializedVersion.GetVertex(16, out latitude, out longitude);
Assert.AreEqual(latitude, route.Entries[2].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Entries[2].Longitude, 0.00001);
Assert.AreEqual(RoutePointEntryType.Along, route.Entries[2].Type);
deserializedVersion.GetVertex(22, out latitude, out longitude);
Assert.AreEqual(latitude, route.Entries[3].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Entries[3].Longitude, 0.00001);
Assert.AreEqual(RoutePointEntryType.Along, route.Entries[3].Type);
deserializedVersion.GetVertex(23, out latitude, out longitude);
Assert.AreEqual(latitude, route.Entries[4].Latitude, 0.00001);
Assert.AreEqual(longitude, route.Entries[4].Longitude, 0.00001);
Assert.AreEqual(RoutePointEntryType.Stop, route.Entries[4].Type);
}
public void TestSimpleTagSerializatonNonBeginPosition()
{
TagsTableCollectionIndex tagsIndex = new TagsTableCollectionIndex();
TagsCollection tagsCollection = new TagsCollection();
tagsCollection.Add("key1", "value1");
uint tagsId = tagsIndex.Add(tagsCollection);
ITagsCollectionIndexReadonly tagsIndexReadonly = this.SerializeDeserialize(tagsIndex, 1201);
Assert.AreEqual(tagsIndex.Max, tagsIndexReadonly.Max);
for (uint idx = 0; idx < tagsIndex.Max; idx++)
{
ComparisonHelpers.CompareTags(tagsIndex.Get(idx),
tagsIndexReadonly.Get(idx));
}
}
/// <summary>
/// Tests the given tags collection index.
/// </summary>
/// <param name="tagsCollectionIndex"></param>
protected void TestTagIndex(ITagsIndex tagsCollectionIndex)
{
// set the seed manually.
OsmSharp.Math.Random.StaticRandomGenerator.Set(116542346);
var addedTags = new List<KeyValuePair<uint, TagsCollectionBase>>();
for (int i = 0; i < 100; i++)
{
var tagsCollection = new TagsCollection();
var tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
var tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(3);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
var addCount = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(2) + 1;
for (int idx = 0; idx < addCount; idx++)
{
var tagsId = tagsCollectionIndex.Add(tagsCollection);
addedTags.Add(new KeyValuePair<uint, TagsCollectionBase>(tagsId, tagsCollection));
var indexTags = tagsCollectionIndex.Get(tagsId);
Assert.AreEqual(tagsCollection.Count, indexTags.Count);
foreach (var tag in tagsCollection)
{
Assert.IsTrue(indexTags.ContainsKeyValue(tag.Key, tag.Value));
}
}
}
// test complete content.
this.TestTagIndexContent(tagsCollectionIndex, addedTags);
}
/// <summary>
/// Tests preprocessing data from a PBF file.
/// </summary>
/// <param name="name"></param>
/// <param name="pbfFile"></param>
public static void TestSerialization(string name, string pbfFile)
{
var testFile = new FileInfo(string.Format(@".\TestFiles\{0}", pbfFile));
var performanceInfo = new PerformanceInfoConsumer("LiveSerializerFlatFile.Serialize", 100000);
performanceInfo.Start();
performanceInfo.Report("Pulling from {0}...", testFile.Name);
var stream = testFile.OpenRead();
var source = new PBFOsmStreamSource(stream);
var progress = new OsmStreamFilterProgress();
progress.RegisterSource(source);
var testOutputFile = new FileInfo(@"test.routing");
testOutputFile.Delete();
Stream writeStream = testOutputFile.OpenWrite();
var tagsIndex = new TagsTableCollectionIndex();
var interpreter = new OsmRoutingInterpreter();
var graph = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex);
var routingSerializer = new LiveEdgeFlatfileSerializer();
// read from the OSM-stream.
using (var fileFactory = new MemoryMappedFileFactory(@"d:\temp\"))
{
using (var memoryMappedGraph = new MemoryMappedGraph<LiveEdge>(10000, fileFactory))
{
using (var coordinates = new HugeCoordinateIndex(fileFactory, 10000))
{
var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(memoryMappedGraph, tagsIndex);
var targetData = new LiveGraphOsmStreamTarget(memoryData, new OsmRoutingInterpreter(), tagsIndex, coordinates);
targetData.RegisterSource(progress);
targetData.Pull();
performanceInfo.Stop();
performanceInfo = new PerformanceInfoConsumer("LiveSerializerFlatFile.Serialize", 100000);
performanceInfo.Start();
performanceInfo.Report("Writing file for {0}...", testFile.Name);
var metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
routingSerializer.Serialize(writeStream, memoryData, metaData);
}
}
}
stream.Dispose();
writeStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("LiveSerializerFlatFile", OsmSharp.Logging.TraceEventType.Information,
string.Format("Serialized file: {0}KB", testOutputFile.Length / 1024));
performanceInfo.Stop();
performanceInfo = new PerformanceInfoConsumer("LiveSerializerFlatFile.Serialize", 100000);
performanceInfo.Start();
performanceInfo.Report("Reading file for {0}...", testFile.Name);
var testInputFile = new FileInfo(@"europe-latest.osm.pbf.routing");
Stream readStream = testInputFile.OpenRead();
var deserializedGraph = routingSerializer.Deserialize(readStream, false);
readStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("LiveSerializerFlatFile", OsmSharp.Logging.TraceEventType.Information,
string.Format("Read: {0}KB", testInputFile.Length / 1024));
OsmSharp.Logging.Log.TraceEvent("LiveSerializerFlatFile", Logging.TraceEventType.Information, deserializedGraph.ToInvariantString());
performanceInfo.Stop();
}
public void TestRandomPartialTagSerializaton()
{
TagsTableCollectionIndex tagsIndex = new TagsTableCollectionIndex();
TagsCollection tagsCollection = new TagsCollection();
for (int i = 0; i < 100; i++)
{
int tagCollectionSize = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(10) + 1;
for (int idx = 0; idx < tagCollectionSize; idx++)
{
int tagValue = OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(10);
tagsCollection.Add(
string.Format("key_{0}", tagValue),
string.Format("value_{0}", tagValue));
}
uint tagsId = tagsIndex.Add(tagsCollection);
}
uint from = 40;
uint to = 50;
ITagsCollectionIndexReadonly tagsIndexReadonly = this.SerializeDeserialize(tagsIndex, from, to);
Assert.AreEqual(System.Math.Min(to, tagsIndex.Max), tagsIndexReadonly.Max);
for (uint idx = 0; idx < tagsIndex.Max; idx++)
{
if (idx >= from && idx < to)
{
ComparisonHelpers.CompareTags(tagsIndex.Get(idx),
tagsIndexReadonly.Get(idx));
}
else
{
Assert.IsNull(tagsIndexReadonly.Get(idx));
}
}
from = 0;
to = 100;
tagsIndexReadonly = this.SerializeDeserialize(tagsIndex, from, to);
Assert.AreEqual(System.Math.Min(to, tagsIndex.Max), tagsIndexReadonly.Max);
for (uint idx = 0; idx < tagsIndex.Max; idx++)
{
if (idx >= from && idx < to)
{
ComparisonHelpers.CompareTags(tagsIndex.Get(idx),
tagsIndexReadonly.Get(idx));
}
else
{
Assert.IsNull(tagsIndexReadonly.Get(idx));
}
}
from = 10;
to = 1000;
tagsIndexReadonly = this.SerializeDeserialize(tagsIndex, from, to);
Assert.AreEqual(System.Math.Min(to, tagsIndex.Max), tagsIndexReadonly.Max);
for (uint idx = 0; idx < tagsIndex.Max; idx++)
{
if (idx >= from && idx < to)
{
ComparisonHelpers.CompareTags(tagsIndex.Get(idx),
tagsIndexReadonly.Get(idx));
}
else
{
Assert.IsNull(tagsIndexReadonly.Get(idx));
}
}
}
/// <summary>
/// Converts a RouteTags array to a list of KeyValuePairs.
/// </summary>
/// <param name="tags"></param>
/// <returns></returns>
public static TagsCollectionBase ConvertToTagsCollection(this RouteTags[] tags)
{
var tagsList = new TagsCollection();
if (tags != null)
{
foreach (var pair in tags)
{
tagsList.Add(new Tag(pair.Key, pair.Value));
}
}
return tagsList;
}
public void Scene2DSimpleSerializeDeserializeTest()
{
// create the MapCSS image source.
var imageSource = new MapCSSDictionaryImageSource();
// load mapcss style interpreter.
var mapCSSInterpreter = new MapCSSInterpreter(
Assembly.GetExecutingAssembly().GetManifestResourceStream(
"OsmSharp.UI.Test.Unittests.Data.MapCSS.test.mapcss"),
imageSource);
// initialize the data source.
var xmlSource = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(
"OsmSharp.UI.Test.Unittests.Data.test.osm"));
IEnumerable<OsmGeo> dataSource = xmlSource;
MemoryDataSource source = MemoryDataSource.CreateFrom(xmlSource);
// get data.
var scene = new Scene2D(new OsmSharp.Math.Geo.Projections.WebMercator(), 16);
var projection = new WebMercator();
GeoCoordinateBox box = null;
foreach (var osmGeo in dataSource)
{
ICompleteOsmGeo completeOsmGeo = null;
switch (osmGeo.Type)
{
case OsmGeoType.Node:
completeOsmGeo = osmGeo as Node;
if(completeOsmGeo.Tags == null)
{ // make sure every node has a tags collection.
completeOsmGeo.Tags = new TagsCollection();
}
break;
case OsmGeoType.Way:
completeOsmGeo = CompleteWay.CreateFrom(osmGeo as Way,
source);
break;
case OsmGeoType.Relation:
completeOsmGeo = CompleteRelation.CreateFrom(osmGeo as Relation,
source);
break;
}
// update box.
if (completeOsmGeo != null)
{
if (box == null) { box = completeOsmGeo.BoundingBox; }
else if (completeOsmGeo.BoundingBox != null) { box = box + completeOsmGeo.BoundingBox; }
}
// translate each object into scene object.
mapCSSInterpreter.Translate(scene, projection, source, osmGeo as OsmGeo);
}
// create the stream.
TagsCollectionBase metaTags = new TagsCollection();
metaTags.Add("SomeTestKey", "SomeTestValue");
var stream = new MemoryStream();
scene.Serialize(stream, true, metaTags);
// deserialize the stream.
metaTags = null;
stream.Seek(0, SeekOrigin.Begin);
IPrimitives2DSource sceneSource = Scene2D.Deserialize(stream, true, out metaTags);
// test meta tags.
Assert.IsTrue(metaTags.ContainsKeyValue("SomeTestKey", "SomeTestValue"));
if (box != null)
{
// query both and get the same results.
int counter = 100;
var rand = new Random();
while (counter > 0)
{
var queryBox = new GeoCoordinateBox(
box.GenerateRandomIn(rand),
box.GenerateRandomIn(rand));
var zoomFactor = (float)projection.ToZoomFactor(15);
View2D testView = View2D.CreateFromBounds(
projection.LatitudeToY(queryBox.MaxLat),
projection.LongitudeToX(queryBox.MinLon),
projection.LatitudeToY(queryBox.MinLat),
projection.LongitudeToX(queryBox.MaxLon));
var testScene = new Scene2D(new OsmSharp.Math.Geo.Projections.WebMercator(), 16);
IEnumerable<Primitive2D> primitives = sceneSource.Get(testView, zoomFactor);
// var resultIndex = new HashSet<Scene2DPrimitive>(testScene.Get(testView, zoomFactor));
// var resultReference = new HashSet<Scene2DPrimitive>(scene.Get(testView, zoomFactor));
//Assert.AreEqual(resultReference.Count, resultIndex.Count);
//foreach (var data in resultIndex)
//{
// Assert.IsTrue(resultReference.Contains(data));
//}
//foreach (var data in resultReference)
//{
// Assert.IsTrue(resultIndex.Contains(data));
//}
counter--;
}
}
}
private static TagsCollectionBase ConvertToTags(Osm.Xml.v0_6.tag[] tag)
{
TagsCollectionBase tags = null;
if (tag != null && tag.Length > 0)
{
tags = new TagsCollection();
foreach (Osm.Xml.v0_6.tag t in tag)
{
tags.Add(t.k, t.v);
}
}
return tags;
}
/// <summary>
/// Tests preprocessing data from a PBF file.
/// </summary>
/// <param name="name"></param>
/// <param name="pbfFile"></param>
public static RouterDataSource<CHEdgeData> TestSerialization(string name, string pbfFile)
{
var testFilePath = Path.Combine (
Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
"TestFiles", pbfFile);
//var testFilePath = @"/Users/xivk/work/OSM/bin/africa-latest.osm.pbf";
var testFile = new FileInfo(testFilePath);
var stream = testFile.OpenRead();
var source = new OsmSharp.Osm.Streams.Filters.OsmStreamFilterProgress();
source.RegisterSource(new PBFOsmStreamSource(stream));
var testOutputFile = new FileInfo(@"test.routing");
testOutputFile.Delete();
Stream writeStream = testOutputFile.Open(FileMode.CreateNew, FileAccess.ReadWrite);
var performanceInfo = new PerformanceInfoConsumer("CHSerializerFlatFile.Serialize");
performanceInfo.Start();
performanceInfo.Report("Pulling from {0}...", testFile.Name);
var data = CHEdgeGraphOsmStreamTarget.Preprocess(
source, new TagsIndex(new MemoryMappedStream(new MemoryStream())),
new OsmRoutingInterpreter(), Vehicle.Car);
(data.Graph as DirectedGraph<CHEdgeData>).Compress(true);
//var graphCopy = new DirectedGraph<CHEdgeData>();
//graphCopy.CopyFrom(data);
//data = new RouterDataSource<CHEdgeData>(graphCopy, data.TagsIndex);
var metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
var routingSerializer = new CHEdgeSerializer();
routingSerializer.Serialize(writeStream, data, metaData);
stream.Dispose();
writeStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("CHSerializerFlatFile", OsmSharp.Logging.TraceEventType.Information,
string.Format("Serialized file: {0}KB", testOutputFile.Length / 1024));
performanceInfo.Stop();
performanceInfo = new PerformanceInfoConsumer("CHSerializerFlatFile.Deserialize");
performanceInfo.Start();
performanceInfo.Report("Deserializing again...");
// open file again and read.
writeStream = testOutputFile.OpenRead();
var deserializedGraph = routingSerializer.Deserialize(writeStream, false);
performanceInfo.Stop();
return data;
}
public void RoutingSerializationRoutingTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network.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 =
new RouterDataSource<Edge>(new Graph<Edge>(), tagsIndex);
var targetData = new GraphOsmStreamTarget(
original, interpreter, tagsIndex, null, false);
var dataProcessorSource = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString));
targetData.RegisterSource(dataProcessorSource);
targetData.Pull();
// 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 source = router.Resolve(Vehicle.Car,
new GeoCoordinate(51.0578532, 3.7192229));
var target = router.Resolve(Vehicle.Car,
new GeoCoordinate(51.0576193, 3.7191801));
// calculate the route.
var route = router.Calculate(Vehicle.Car, source, target);
Assert.IsNotNull(route);
Assert.AreEqual(5, route.Segments.Length);
float latitude, longitude;
//deserializedVersion.GetVertex(20, out latitude, out longitude);
Assert.AreEqual(51.0578537, route.Segments[0].Latitude, 0.00001);
Assert.AreEqual(3.71922255, route.Segments[0].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);
//deserializedVersion.GetVertex(21, out latitude, out longitude);
Assert.AreEqual(51.0578537, route.Segments[1].Latitude, 0.00001);
Assert.AreEqual(3.71956515, route.Segments[1].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[1].Type);
//deserializedVersion.GetVertex(16, out latitude, out longitude);
Assert.AreEqual(51.05773, route.Segments[2].Latitude, 0.00001);
Assert.AreEqual(3.719745, route.Segments[2].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[2].Type);
//deserializedVersion.GetVertex(22, out latitude, out longitude);
Assert.AreEqual(51.05762, route.Segments[3].Latitude, 0.00001);
Assert.AreEqual(3.71965766, route.Segments[3].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Along, route.Segments[3].Type);
deserializedVersion.GetVertex(23, out latitude, out longitude);
Assert.AreEqual(51.05762, route.Segments[4].Latitude, 0.00001);
Assert.AreEqual(3.71917963, route.Segments[4].Longitude, 0.00001);
Assert.AreEqual(RouteSegmentType.Stop, route.Segments[4].Type);
}
public static Stream TestSerialization(string name, string pbfFile, RouterDataSource<CHEdgeData> data)
{
var testOutputFile = new FileInfo(@"test.routing");
testOutputFile.Delete();
var writeStream = testOutputFile.OpenWrite();
var performanceInfo = new PerformanceInfoConsumer("CHSerializer");
performanceInfo.Start();
performanceInfo.Report("Writing to {0}...", testOutputFile.Name);
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
var routingSerializer = new CHEdgeSerializer();
routingSerializer.Serialize(writeStream, data, metaData);
writeStream.Dispose();
OsmSharp.Logging.Log.TraceEvent("CHSerializer", OsmSharp.Logging.TraceEventType.Information,
string.Format("Serialized file: {0}KB", testOutputFile.Length / 1024));
performanceInfo.Stop();
return testOutputFile.OpenRead();
}
/// <summary>
/// Builds a dummy route (as the crow flies) for segments of a route not found.
/// </summary>
/// <returns></returns>
public virtual Route BuildDummyRoute(Vehicle vehicle, GeoCoordinate coordinate1, GeoCoordinate coordinate2)
{
var route = new Route();
route.Vehicle = vehicle.UniqueName;
var segments = new RouteSegment[2];
segments[0] = new RouteSegment();
segments[0].Distance = 0;
segments[0].Time = 0;
segments[0].Type = RouteSegmentType.Start;
segments[0].Vehicle = vehicle.UniqueName;
segments[0].Latitude = (float)coordinate1.Latitude;
segments[0].Longitude = (float)coordinate1.Longitude;
var distance = coordinate1.DistanceReal(coordinate2).Value;
var timeEstimage = distance / (vehicle.MaxSpeed().Value) * 3.6;
var tags = new TagsCollection();
tags.Add("route", "not_found");
segments[1] = new RouteSegment();
segments[1].Distance = distance;
segments[1].Time = timeEstimage;
segments[1].Type = RouteSegmentType.Stop;
segments[1].Vehicle = vehicle.UniqueName;
segments[1].Latitude = (float)coordinate2.Latitude;
segments[1].Longitude = (float)coordinate2.Longitude;
segments[1].Tags = RouteTagsExtensions.ConvertFrom(tags);
route.Segments = segments;
return route;
}
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);
// }
//}
}
public void RoutingSerializationDataSourceTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network.osm";
// create the tags index.
var tagsIndex = new TagsTableCollectionIndex();
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original =
new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex);
var targetData = new LiveGraphOsmStreamTarget(
original, interpreter, tagsIndex, null, false);
var dataProcessorSource = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString));
targetData.RegisterSource(dataProcessorSource);
targetData.Pull();
// store some lat/lons.
var verticesLocations = new List<GeoCoordinate>();
for (uint vertex = 1; vertex <= 5; vertex++)
{
float latitude, longitude;
if(original.GetVertex(vertex, out latitude, out longitude))
{
verticesLocations.Add(
new GeoCoordinate(latitude, longitude));
}
}
// create serializer.
var routingSerializer = new RoutingDataSourceLiveEdgeSerializer(false);
// serialize/deserialize.
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
IBasicRouterDataSource<LiveEdge> deserializedVersion;
byte[] byteArray;
using (var stream = new MemoryStream())
{
try
{
routingSerializer.Serialize(stream, original, metaData);
byteArray = stream.ToArray();
}
catch (Exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw;
}
}
using (var stream = new MemoryStream(byteArray))
{
try
{
deserializedVersion = routingSerializer.Deserialize(stream, out metaData, false);
}
catch (Exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw;
}
}
//Assert.AreEqual(original.VertexCount, deserializedVersion.VertexCount);
Assert.AreEqual(original.TagsIndex.Get(0), deserializedVersion.TagsIndex.Get(0));
for (uint vertex = 1; vertex <= 5; vertex++)
{
float latitude, longitude;
if (deserializedVersion.GetVertex(vertex, out latitude, out longitude))
{
Assert.AreEqual(verticesLocations[(int)vertex - 1].Latitude, latitude, 0.000001);
Assert.AreEqual(verticesLocations[(int)vertex - 1].Longitude, longitude, 0.000001);
}
}
}
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 = 1; 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 RoutingSerializationCHEdgeData()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// load the network.
var referenceNetwork = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)), new OsmRoutingInterpreter(), Vehicle.Car);
// serialize network.
var routingSerializer = new OsmSharp.Routing.CH.Serialization.Sorted.CHEdgeDataDataSourceSerializer(false);
// serialize/deserialize.
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
byte[] byteArray;
using (var stream = new MemoryStream())
{
try
{
routingSerializer.Serialize(stream, referenceNetwork, metaData);
byteArray = stream.ToArray();
}
catch (Exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw;
}
}
var network = routingSerializer.Deserialize(new MemoryStream(byteArray), out metaData);
// compare networks.
Assert.IsNotNull(network);
// Assert.AreEqual(referenceNetwork.VertexCount, network.VertexCount);
for (uint vertex = 1; vertex < referenceNetwork.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 referenceArcs = referenceNetwork.GetEdges(vertex).ToKeyValuePairs();
var arcs = network.GetEdges(vertex).ToKeyValuePairs();
Assert.AreEqual(referenceArcs.Length, arcs.Length);
for (int idx = 0; idx < referenceArcs.Length; idx++)
{
var referenceArc = referenceArcs[idx];
// find the same edge in the new arcs.
var arc = arcs.First((x) => { return x.Key == referenceArcs[idx].Key; });
Assert.AreEqual(referenceArc.Key, arc.Key);
Assert.AreEqual(referenceArc.Value.Forward, arc.Value.Forward);
Assert.AreEqual(referenceArc.Value.ForwardWeight, arc.Value.ForwardWeight);
Assert.AreEqual(referenceArc.Value.ForwardContractedId, arc.Value.ForwardContractedId);
Assert.AreEqual(referenceArc.Value.Backward, arc.Value.Backward);
Assert.AreEqual(referenceArc.Value.BackwardWeight, arc.Value.BackwardWeight);
Assert.AreEqual(referenceArc.Value.BackwardContractedId, arc.Value.BackwardContractedId);
Assert.AreEqual(referenceArc.Value.RepresentsNeighbourRelations, arc.Value.RepresentsNeighbourRelations);
Assert.AreEqual(referenceArc.Value.Tags, arc.Value.Tags);
ICoordinateCollection referenceCoordinates;
ICoordinateCollection coordinates;
if (referenceNetwork.GetEdgeShape(vertex, referenceArc.Key, out referenceCoordinates))
{ // there is a shape.
Assert.IsTrue(network.GetEdgeShape(vertex, arc.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, arc.Key, out coordinates));
}
if (referenceNetwork.GetEdgeShape(referenceArc.Key, vertex, out referenceCoordinates))
{ // there is a shape.
Assert.IsTrue(network.GetEdgeShape(arc.Key, vertex, 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, arc.Key, out coordinates));
}
// check tags.
var referenceTags = referenceNetwork.TagsIndex.Get(referenceArc.Value.Tags);
var tags = network.TagsIndex.Get(arc.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));
}
}
}
}
}
/// <summary>
/// Does the actual testing.
/// </summary>
/// <param name="embeddedString"></param>
private void DoRoutingSerializationV2CHRoutingV2ComparisonTest(string embeddedString)
{
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)),
interpreter, Vehicle.Car);
// create serializer.
var routingSerializer = new OsmSharp.Routing.CH.Serialization.Sorted.v2.CHEdgeDataDataSourceSerializer(true);
// 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;
}
}
IBasicRouterDataSource<CHEdgeData> deserializedVersion =
routingSerializer.Deserialize(new MemoryStream(byteArray), out metaData);
Assert.AreEqual(original.TagsIndex.Get(0), deserializedVersion.TagsIndex.Get(0));
Assert.IsTrue(deserializedVersion.SupportsProfile(Vehicle.Car));
Assert.IsFalse(deserializedVersion.SupportsProfile(Vehicle.Bicycle));
// create reference router.
original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
interpreter,
Vehicle.Car);
var basicRouterOriginal = new CHRouter();
Router referenceRouter = Router.CreateCHFrom(
original, basicRouterOriginal, interpreter);
// try to do some routing on the deserialized version.
var basicRouter = new CHRouter();
Router router = Router.CreateCHFrom(
deserializedVersion, basicRouter, interpreter);
this.TestCompareAll(original, referenceRouter, router);
}
/// <summary>
/// Creates a router.
/// </summary>
/// <param name="interpreter"></param>
/// <param name="manifestResourceName"></param>
/// <returns></returns>
protected override Router CreateRouter(IOsmRoutingInterpreter interpreter, string manifestResourceName)
{
var tagsIndex = new TagsTableCollectionIndex();
// do the data processing.
var source = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName));
var data = CHEdgeGraphOsmStreamTarget.Preprocess(
source, new OsmRoutingInterpreter(), Vehicle.Car);
// serialize.
var memoryStream = new MemoryStream();
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
var routingSerializer = new CHEdgeDataDataSourceSerializer();
routingSerializer.Serialize(memoryStream, data, metaData);
memoryStream.Seek(0, SeekOrigin.Begin);
var deserialized = routingSerializer.Deserialize(memoryStream);
return Router.CreateCHFrom(deserialized, new CHRouter(), new OsmRoutingInterpreter());
}