public void TestIsVertexValidRoundaboutExit() { var tags = new TagsTableCollectionIndex(); var graph = new DynamicGraphRouterDataSource <LiveEdge>(tags); var vertex1 = graph.AddVertex(0, 0); var vertex2 = graph.AddVertex(1, 1); var vertex3 = graph.AddVertex(2, 2); var vertex4 = graph.AddVertex(3, 3); var edge = new LiveEdge() { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"))) }; var onwayEdge = new LiveEdge() { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"), Tag.Create("oneway", "yes"))) }; graph.AddEdge(vertex1, vertex2, onwayEdge, null); graph.AddEdge(vertex2, vertex3, edge, null); graph.AddEdge(vertex2, vertex4, onwayEdge, null); var encoder = new OpenLR.Referenced.Osm.ReferencedOsmEncoder(new BasicRouterDataSource <LiveEdge>(graph), new EncoderMock()); Assert.IsTrue(encoder.IsVertexValid(vertex3)); }
/// <summary> /// Builds the data. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedString"></param> /// <returns></returns> public override IBasicRouterDataSource <CHEdgeData> BuildData(IOsmRoutingInterpreter interpreter, string embeddedString) { string key = string.Format("CHEdgeDifference.Routing.IBasicRouterDataSource<CHEdgeData>.OSM.{0}", embeddedString); var data = StaticDictionary.Get <IBasicRouterDataSource <CHEdgeData> >( key); if (data == null) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( memoryData, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(); var preProcessor = new CHPreProcessor(memoryData, new EdgeDifference(memoryData, witnessCalculator), witnessCalculator); preProcessor.Start(); data = memoryData; StaticDictionary.Add <IBasicRouterDataSource <CHEdgeData> >(key, data); } return(data); }
/// <summary> /// Returns a new router. /// </summary> /// <param name="interpreter"></param> /// <param name="embedded_name"></param> /// <returns></returns> public override IRouter<RouterPoint> BuildRouter(IRoutingInterpreter interpreter, string embedded_name) { if (_data == null) { _data = new Dictionary<string, DynamicGraphRouterDataSource<CHEdgeData>>(); } DynamicGraphRouterDataSource<CHEdgeData> data = null; if (!_data.TryGetValue(embedded_name, out data)) { OsmTagsIndex tags_index = new OsmTagsIndex(); // do the data processing. data = new DynamicGraphRouterDataSource<CHEdgeData>(tags_index); CHEdgeDataGraphProcessingTarget target_data = new CHEdgeDataGraphProcessingTarget( data, interpreter, data.TagsIndex, VehicleEnum.Car); XmlDataProcessorSource data_processor_source = new XmlDataProcessorSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.UnitTests.{0}", embedded_name))); DataProcessorFilterSort sorter = new DataProcessorFilterSort(); sorter.RegisterSource(data_processor_source); target_data.RegisterSource(sorter); target_data.Pull(); // do the pre-processing part. CHPreProcessor pre_processor = new CHPreProcessor(data, new SparseOrdering(data), new DykstraWitnessCalculator(data)); pre_processor.Start(); _data[embedded_name] = data; } return new Router<CHEdgeData>(data, interpreter, new CHRouter( data)); }
/// <summary> /// Builds data source. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedString"></param> /// <returns></returns> public override IBasicRouterDataSource <LiveEdge> BuildData(IOsmRoutingInterpreter interpreter, string embeddedString) { string key = string.Format("Dykstra.Routing.IBasicRouterDataSource<SimpleWeighedEdge>.OSM.{0}", embeddedString); var data = StaticDictionary.Get <IBasicRouterDataSource <LiveEdge> >( key); if (data == null) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); data = memoryData; StaticDictionary.Add <IBasicRouterDataSource <LiveEdge> >(key, data); } return(data); }
/// <summary> /// Tests preprocessing data from a PBF file. /// </summary> /// <param name="name"></param> /// <param name="pbfFile"></param> public static void TestPreprocessing(string name, string pbfFile) { FileInfo testFile = new FileInfo(string.Format(@".\TestFiles\{0}", pbfFile)); Stream stream = testFile.OpenRead(); var progress = new OsmStreamFilterProgress(); progress.RegisterSource(new PBFOsmStreamSource(stream)); var performanceInfo = new PerformanceInfoConsumer("LivePreProcessor", 20000); performanceInfo.Start(); performanceInfo.Report("Pulling from {0}...", testFile.Name); var tagsIndex = new TagsTableCollectionIndex(); // creates a tagged index. // read from the OSM-stream. // var memoryGraph = new MemoryMappedGraph<LiveEdge>(1000000, @"c:\temp\"); var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, new OsmRoutingInterpreter(), tagsIndex); targetData.RegisterSource(progress); targetData.Pull(); stream.Dispose(); performanceInfo.Stop(); // make sure the router is still here after GC to note the memory difference. OsmSharp.Logging.Log.TraceEvent("LivePreProcessor", Logging.TraceEventType.Information, memoryData.ToString()); memoryData = null; GC.Collect(); }
/// <summary> /// Executes the CH contractions while verifying each step. /// </summary> /// <param name="stream"></param> public void DoTestCHSparseVerifiedContraction(Stream stream) { _pathsBeforeContraction = new Dictionary <uint, Dictionary <uint, Dictionary <uint, PathSegment <long> > > >(); _interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. _data = new DynamicGraphRouterDataSource <CHEdgeData>(new MemoryDirectedGraph <CHEdgeData>(), tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( _data, _interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource(stream); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(); var preProcessor = new CHPreProcessor(_data, new EdgeDifferenceContractedSearchSpace(_data, witnessCalculator), witnessCalculator); preProcessor.OnBeforeContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnBeforeContractionEvent); preProcessor.OnAfterContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnAfterContractionEvent); preProcessor.Start(); }
/// <summary> /// Executes the CH contractions while verifying each step. /// </summary> /// <param name="stream"></param> public void DoTestCHSparseVerifiedContraction(Stream stream) { _interpreter = new OsmRoutingInterpreter(); var tagsIndex = new SimpleTagsIndex(); // do the data processing. _data = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamWriter( _data, _interpreter, _data.TagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource(stream); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. //INodeWitnessCalculator witness_calculator = new CHRouterWitnessCalculator(_data); INodeWitnessCalculator witnessCalculator = new DykstraWitnessCalculator(_data); var preProcessor = new CHPreProcessor(_data, new EdgeDifferenceContractedSearchSpace(_data, witnessCalculator), witnessCalculator); preProcessor.OnBeforeContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnBeforeContractionEvent); preProcessor.OnAfterContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnAfterContractionEvent); preProcessor.Start(); }
/// <summary> /// Returns a new router. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedName"></param> /// <param name="contract"></param> /// <returns></returns> public override Router BuildRouter(IOsmRoutingInterpreter interpreter, string embeddedName, bool contract) { if (_data == null) { _data = new Dictionary<string, DynamicGraphRouterDataSource<LiveEdge>>(); } DynamicGraphRouterDataSource<LiveEdge> data = null; if (!_data.TryGetValue(embeddedName, out data)) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. data = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget( data, interpreter, tagsIndex, new Vehicle[] { Vehicle.Car }, false); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.Test.Unittests.{0}", embeddedName))); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); _data[embeddedName] = data; } return Router.CreateLiveFrom(data, new Dykstra(), interpreter); }
public void RoutingRegressionTest1() { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); var basicRouter = new Dykstra(); var router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // resolve the three points in question. var point35 = new GeoCoordinate(51.01257, 4.000753); var point35resolved = router.Resolve(Vehicle.Car, point35); var point45 = new GeoCoordinate(51.01315, 3.999588); var point45resolved = router.Resolve(Vehicle.Car, point45); // route between 35 and 45. var routebefore = router.Calculate(Vehicle.Car, point35resolved, point45resolved); // route between 35 and 45. var routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
/// <summary> /// Executes the CH contractions while verifying each step. /// </summary> /// <param name="stream"></param> public void DoTestCHEdgeDifferenceVerifiedContraction(Stream stream) { _interpreter = new OsmRoutingInterpreter(); OsmTagsIndex tags_index = new OsmTagsIndex(); // do the data processing. _data = new DynamicGraphRouterDataSource<CHEdgeData>(tags_index); CHEdgeDataGraphProcessingTarget target_data = new CHEdgeDataGraphProcessingTarget( _data, _interpreter, _data.TagsIndex, VehicleEnum.Car); XmlDataProcessorSource data_processor_source = new XmlDataProcessorSource(stream); DataProcessorFilterSort sorter = new DataProcessorFilterSort(); sorter.RegisterSource(data_processor_source); target_data.RegisterSource(sorter); target_data.Pull(); // do the pre-processing part. DykstraWitnessCalculator witness_calculator = new DykstraWitnessCalculator( _data); CHPreProcessor pre_processor = new CHPreProcessor(_data, new EdgeDifference(_data, witness_calculator), witness_calculator); pre_processor.OnBeforeContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnBeforeContractionEvent); pre_processor.OnAfterContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnAfterContractionEvent); pre_processor.Start(); }
/// <summary> /// Creates a router. /// </summary> /// <param name="interpreter"></param> /// <param name="manifestResourceName"></param> /// <returns></returns> protected override Router CreateRouter(IOsmRoutingInterpreter interpreter, string manifestResourceName) { SimpleTagsIndex tagsIndex = new SimpleTagsIndex(); // do the data processing. var data = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(); var preProcessor = new CHPreProcessor(data, new EdgeDifference(data, witnessCalculator), witnessCalculator); preProcessor.Start(); //IBasicRouter<LiveEdge> basicRouter = new DykstraRoutingLive(memoryData.TagsIndex); return(Router.CreateCHFrom(data, new CHRouter(), interpreter)); }
public void TestOneHop() { // build test data. var tagsIndex = new TagsTableCollectionIndex(); var tags = new TagsCollection(new Tag() { Key = "highway", Value = "residential" }); var tagsId = tagsIndex.Add(tags); var graph = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); var vertex1 = graph.AddVertex(50.909909938361324f, 4.452434778213501f); var vertex2 = graph.AddVertex(50.916698097895550f, 4.459059834480286f); graph.AddEdge(vertex1, vertex2, new LiveEdge() { Distance = 890.65f, Forward = true, Tags = tagsId }); // calculate route. var router = new BasicRouter(); var route = router.Calculate(new BasicRouterDataSource <LiveEdge>(graph), OsmSharp.Routing.Vehicle.Car, vertex1, vertex2, true); // verify result. Assert.IsNotNull(route); Assert.AreEqual(vertex2, route.Vertex); Assert.AreEqual(OsmSharp.Routing.Vehicle.Car.Weight(tags, 890.65f), route.Weight); Assert.AreEqual(vertex1, route.From.Vertex); Assert.AreEqual(0, route.From.Weight); }
/// <summary> /// Creates a new target. /// </summary> /// <param name="stream"></param> /// <param name="dynamicGraph"></param> /// <param name="interpreter"></param> /// <param name="tagsIndex"></param> /// <param name="vehicle"></param> public CHEdgeGraphFileStreamTarget(Stream stream, DynamicGraphRouterDataSource <CHEdgeData> dynamicGraph, IOsmRoutingInterpreter interpreter, ITagsCollectionIndex tagsIndex, Vehicle vehicle) : base(dynamicGraph, interpreter, tagsIndex, vehicle) { _graph = dynamicGraph; _graphStream = stream; }
/// <summary> /// Returns a new router. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedName"></param> /// <param name="contract"></param> /// <returns></returns> public override Router BuildRouter(IOsmRoutingInterpreter interpreter, string embeddedName, bool contract) { if (_data == null) { _data = new Dictionary <string, DynamicGraphRouterDataSource <CHEdgeData> >(); } DynamicGraphRouterDataSource <CHEdgeData> data = null; if (!_data.TryGetValue(embeddedName, out data)) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. data = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.Test.Unittests.{0}", embeddedName))); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var preProcessor = new CHPreProcessor(data, new SparseOrdering(data), new DykstraWitnessCalculator()); preProcessor.Start(); _data[embeddedName] = data; } return(Router.CreateCHFrom(data, new CHRouter(), interpreter)); }
/// <summary> /// Builds the data. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedString"></param> /// <returns></returns> public override IBasicRouterDataSource <CHEdgeData> BuildData(IOsmRoutingInterpreter interpreter, string embeddedString) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( memoryData, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedString)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var preProcessor = new CHPreProcessor(memoryData, new SparseOrdering(memoryData), new DykstraWitnessCalculator()); preProcessor.Start(); return(memoryData); }
/// <summary> /// Deserializes the vertices /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> /// <param name="size"></param> protected virtual void DeserializeVertices(LimitedStream stream, long size, DynamicGraphRouterDataSource <TEdgeData> graph) { RuntimeTypeModel typeModel = RuntimeTypeModel.Create(); typeModel.Add(typeof(SerializableVertex), true); long position = stream.Position; uint vertex = 0; while (stream.Position - position < size) { // keep reading vertices until the appriated number of bytes have been read. var vertices = typeModel.DeserializeWithSize(stream, null, typeof(SerializableVertex[])) as SerializableVertex[]; if (vertices != null) { // there are a vertices. for (int idx = 0; idx < vertices.Length; idx++) { if (vertices[idx] != null) { // there is a vertex. graph.AddVertex(vertices[idx].Latitude, vertices[idx].Longitude); } vertex++; } } } }
/// <summary> /// Does the v1 deserialization. /// </summary> /// <param name="stream"></param> /// <param name="lazy"></param> /// <param name="vehicles"></param> /// <returns></returns> protected override IBasicRouterDataSource <TEdgeData> DoDeserialize( LimitedStream stream, bool lazy, IEnumerable <string> vehicles) { ITagsCollectionIndex tagsCollectionIndex = this.CreateTagsCollectionIndex(); DynamicGraphRouterDataSource <TEdgeData> graph = this.CreateGraph(tagsCollectionIndex); // deserialize vertices. var sizeBytes = new byte[8]; stream.Read(sizeBytes, 0, 8); var position = stream.Position; var size = BitConverter.ToInt64(sizeBytes, 0); this.DeserializeVertices(stream, size, graph); stream.Seek(position + size, System.IO.SeekOrigin.Begin); // deserialize edges. stream.Read(sizeBytes, 0, 8); position = stream.Position; size = BitConverter.ToInt64(sizeBytes, 0); this.DeserializeEdges(stream, size, graph); stream.Seek(position + size, System.IO.SeekOrigin.Begin); // deserialize tags. stream.Read(sizeBytes, 0, 8); position = stream.Position; size = BitConverter.ToInt64(sizeBytes, 0); this.DeserializeTags(stream, size, tagsCollectionIndex); stream.Seek(position + size, System.IO.SeekOrigin.Begin); return(graph); }
/// <summary> /// Preprocesses the data from the given OsmStreamReader and converts it directly to a routable data source. /// </summary> /// <param name="reader"></param> /// <param name="tagsIndex"></param> /// <param name="interpreter"></param> /// <param name="vehicle"></param> /// <param name="leaveReverseEdges"></param> /// <returns></returns> public static DynamicGraphRouterDataSource <CHEdgeData> Preprocess(OsmStreamSource reader, ITagsIndex tagsIndex, IOsmRoutingInterpreter interpreter, Vehicle vehicle, bool leaveReverseEdges) { // pull in the data. var dynamicGraphRouterDataSource = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( dynamicGraphRouterDataSource, interpreter, tagsIndex, vehicle); targetData.RegisterSource(reader); targetData.Pull(); // compress the graph. INodeWitnessCalculator witnessCalculator = new DykstraWitnessCalculator(); var edgeDifference = new EdgeDifference( dynamicGraphRouterDataSource, witnessCalculator); var preProcessor = new CHPreProcessor( dynamicGraphRouterDataSource, edgeDifference, witnessCalculator); preProcessor.Start(); return(dynamicGraphRouterDataSource); }
/// <summary> /// Serializes the given graph and tags index to the given stream. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> /// <param name="metaTags"></param> public void Serialize(Stream stream, DynamicGraphRouterDataSource <TEdgeData> graph, TagsCollectionBase metaTags) { if (stream == null) { throw new ArgumentNullException("stream"); } if (graph == null) { throw new ArgumentNullException("graph"); } // write the header. this.WriteVersionHeader(stream); // write the vehicles. this.WriteVehicleProfiles(stream, graph.GetSupportedProfiles()); // write the meta-data. this.WriteMeta(stream, metaTags); // wrap the stream. var routingSerializerStream = new LimitedStream(stream); // do the version-specific serialization. this.DoSerialize(routingSerializerStream, graph); }
/// <summary> /// Returns a new router. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedName"></param> /// <param name="contract"></param> /// <returns></returns> public override Router BuildRouter(IOsmRoutingInterpreter interpreter, string embeddedName, bool contract) { if (_data == null) { _data = new Dictionary <string, DynamicGraphRouterDataSource <LiveEdge> >(); } DynamicGraphRouterDataSource <LiveEdge> data = null; if (!_data.TryGetValue(embeddedName, out data)) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. data = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget( data, interpreter, tagsIndex, new Vehicle[] { Vehicle.Car }, false); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.Test.Unittests.{0}", embeddedName))); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); _data[embeddedName] = data; } return(Router.CreateLiveFrom(data, new Dykstra(), interpreter)); }
/// <summary> /// Creates a new target. /// </summary> /// <param name="stream"></param> /// <param name="dynamicGraph"></param> /// <param name="interpreter"></param> /// <param name="tagsIndex"></param> /// <param name="vehicle"></param> public CHEdgeGraphFileStreamTarget(Stream stream, DynamicGraphRouterDataSource<CHEdgeData> dynamicGraph, IOsmRoutingInterpreter interpreter, ITagsCollectionIndex tagsIndex, Vehicle vehicle) : base(dynamicGraph, interpreter, tagsIndex, vehicle) { _graph = dynamicGraph; _graphStream = stream; }
public static Stream TestSerialization(string name, string pbfFile, DynamicGraphRouterDataSource <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 CHEdgeDataDataSourceSerializer(); 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> /// Deserializes all edges. /// </summary> /// <param name="stream"></param> /// <param name="size"></param> /// <param name="graph"></param> protected override void DeserializeEdges(LimitedStream stream, long size, DynamicGraphRouterDataSource <LiveEdge> graph) { var typeModel = RuntimeTypeModel.Create(); typeModel.Add(typeof(SerializableEdge), true); typeModel.Add(typeof(GeoCoordinateSimple), true); long position = stream.Position; while (stream.Position < position + size) { // keep looping until the appropriate number of bytes have been read. var serializableEdges = typeModel.DeserializeWithSize(stream, null, typeof(SerializableEdge[])) as SerializableEdge[]; for (int idx = 0; idx < serializableEdges.Length; idx++) { ICoordinateCollection coordinateCollection = null; if (serializableEdges[idx].Coordinates != null) { coordinateCollection = new CoordinateArrayCollection <GeoCoordinateSimple>(serializableEdges[idx].Coordinates); } graph.AddEdge(serializableEdges[idx].FromId, serializableEdges[idx].ToId, new LiveEdge() { Distance = serializableEdges[idx].Distance, Value = serializableEdges[idx].Value }, coordinateCollection); } } }
public void TestTwoNeighboursOneWay() { var tags = new TagsTableCollectionIndex(); var graph = new DynamicGraphRouterDataSource <LiveEdge>(tags); var vertex1 = graph.AddVertex(0, 0); var vertex2 = graph.AddVertex(1, 1); var vertex3 = graph.AddVertex(2, 2); var edge = new LiveEdge() { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("FOW", "2"), Tag.Create("FRC", "3"), Tag.Create("ONEWAY", "FT"))) }; graph.AddEdge(vertex1, vertex2, edge, null); graph.AddEdge(vertex2, vertex3, edge, null); var encoder = new OpenLR.Referenced.MultiNet.ReferencedMultiNetEncoder(new BasicRouterDataSource <LiveEdge>(graph), new EncoderMock()); Assert.IsFalse(encoder.IsVertexValid(vertex2)); }
public void RoutingRegressionTest1() { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); var basicRouter = new DykstraRoutingLive(); var router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // resolve the three points in question. var point35 = new GeoCoordinate(51.01257, 4.000753); var point35resolved = router.Resolve(Vehicle.Car, point35); var point45 = new GeoCoordinate(51.01315, 3.999588); var point45resolved = router.Resolve(Vehicle.Car, point45); // route between 35 and 45. var routebefore = router.Calculate(Vehicle.Car, point35resolved, point45resolved); // route between 35 and 45. var routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
/// <summary> /// Returns a new router. /// </summary> /// <param name="interpreter"></param> /// <param name="embeddedName"></param> /// <param name="contract"></param> /// <returns></returns> public override Router BuildRouter(IOsmRoutingInterpreter interpreter, string embeddedName, bool contract) { if (_data == null) { _data = new Dictionary<string, DynamicGraphRouterDataSource<CHEdgeData>>(); } DynamicGraphRouterDataSource<CHEdgeData> data = null; if (!_data.TryGetValue(embeddedName, out data)) { var tagsIndex = new SimpleTagsIndex(); // do the data processing. data = new DynamicGraphRouterDataSource<CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.Test.Unittests.{0}", embeddedName))); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var preProcessor = new CHPreProcessor(data, new SparseOrdering(data), new DykstraWitnessCalculator()); preProcessor.Start(); _data[embeddedName] = data; } return Router.CreateCHFrom(data, new CHRouter(), interpreter); }
/// <summary> /// Tests preprocessing data from a PBF file. /// </summary> /// <param name="name"></param> /// <param name="pbfFile"></param> public static void TestPreprocessing(string name, string pbfFile) { FileInfo testFile = new FileInfo(string.Format(@".\TestFiles\{0}", pbfFile)); Stream stream = testFile.OpenRead(); var progress = new OsmStreamFilterProgress(); progress.RegisterSource(new PBFOsmStreamSource(stream)); var performanceInfo = new PerformanceInfoConsumer("LivePreProcessor", 20000); performanceInfo.Start(); performanceInfo.Report("Pulling from {0}...", testFile.Name); var tagsIndex = new TagsTableCollectionIndex(); // creates a tagged index. // read from the OSM-stream. var memoryGraph = new MemoryMappedFileDynamicGraph <LiveEdge>(1000000, @"c:\temp\"); var memoryData = new DynamicGraphRouterDataSource <LiveEdge>(memoryGraph, tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, new OsmRoutingInterpreter(), tagsIndex); targetData.RegisterSource(progress); targetData.Pull(); stream.Dispose(); performanceInfo.Stop(); // make sure the router is still here after GC to note the memory difference. OsmSharp.Logging.Log.TraceEvent("LivePreProcessor", Logging.TraceEventType.Information, memoryData.ToString()); memoryData = null; GC.Collect(); }
/// <summary> /// Tests routing from a serialized routing file. /// </summary> /// <param name="name"></param> /// <param name="stream"></param> /// <param name="testCount"></param> public static void TestSerializedRouting(string name, Stream stream, int testCount) { var vehicle = Vehicle.Car; var tagsIndex = new TagsTableCollectionIndex(); // creates a tagged index. // read from the OSM-stream. var reader = new OsmSharp.Osm.PBF.Streams.PBFOsmStreamSource(stream); var interpreter = new OsmRoutingInterpreter(); var data = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); data.DropVertexIndex(); var targetData = new LiveGraphOsmStreamTarget(data, interpreter, tagsIndex); targetData.RegisterSource(reader); targetData.Pull(); data.RebuildVertexIndex(); // creates the live edge router. var router = new Dykstra(); var performanceInfo = new PerformanceInfoConsumer("LiveRouting"); performanceInfo.Start(); performanceInfo.Report("Routing {0} routes...", testCount); var successCount = 0; var totalCount = testCount; var latestProgress = -1.0f; while (testCount > 0) { var from = (uint)OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(data.VertexCount - 1) + 1; var to = (uint)OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(data.VertexCount - 1) + 1; var route = router.Calculate(data, interpreter, vehicle, from, to); if (route != null) { successCount++; } testCount--; // report progress. var progress = (float)System.Math.Round(((double)(totalCount - testCount) / (double)totalCount) * 100); if (progress != latestProgress) { OsmSharp.Logging.Log.TraceEvent("LiveRouting", TraceEventType.Information, "Routing... {0}%", progress); latestProgress = progress; } } performanceInfo.Stop(); OsmSharp.Logging.Log.TraceEvent("LiveRouting", OsmSharp.Logging.TraceEventType.Information, string.Format("{0}/{1} routes successfull!", successCount, totalCount)); }
/// <summary> /// Builds the edge difference. /// </summary> private EdgeDifference BuildEdgeDifference(IOsmRoutingInterpreter interpreter) { DynamicGraphRouterDataSource <CHEdgeData> data = this.BuildData(interpreter); // do the pre-processing part. INodeWitnessCalculator witnessCalculator = new DykstraWitnessCalculator(); return(new EdgeDifference( data, witnessCalculator)); }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <param name="vehicle"></param> public CHEdgeGraphFileStreamTarget(Stream stream, Vehicle vehicle) { _graphStream = stream; var tagsIndex = new TagsTableCollectionIndex(); var interpreter = new OsmRoutingInterpreter(); _graph = new DynamicGraphRouterDataSource<CHEdgeData>(tagsIndex); _graphTarget = new CHEdgeGraphOsmStreamTarget( _graph, interpreter, tagsIndex, vehicle); }
/// <summary> /// Serializes all edges. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> protected override void SerializeEdges(LimitedStream stream, DynamicGraphRouterDataSource <LiveEdge> graph) { var typeModel = RuntimeTypeModel.Create(); typeModel.Add(typeof(SerializableEdge), true); typeModel.Add(typeof(GeoCoordinateSimple), true); int blockSize = 1000; var arcsQueue = new List <SerializableEdge>(blockSize); uint vertex = 0; while (vertex < graph.VertexCount) { // keep looping and serialize all vertices. var arcs = graph.GetEdges(vertex); if (arcs != null) { // serialize the arcs, but serialize them only once. // choose only those arcs that start at a vertex smaller than the target. for (int idx = 0; idx < arcs.Length; idx++) { if (arcs[idx].Key > vertex) { GeoCoordinateSimple[] coordinates; if (!graph.GetEdgeShape(vertex, arcs[idx].Key, out coordinates)) { coordinates = null; } arcsQueue.Add(new SerializableEdge() { Distance = arcs[idx].Value.Distance, FromId = vertex, ToId = arcs[idx].Key, Value = arcs[idx].Value.Value, Coordinates = coordinates }); if (arcsQueue.Count == blockSize) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } } } // serialize. vertex++; } } if (arcsQueue.Count > 0) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <param name="vehicle"></param> public CHEdgeGraphFileStreamTarget(Stream stream, Vehicle vehicle) { _graphStream = stream; var tagsIndex = new SimpleTagsCollectionIndex(); var interpreter = new OsmRoutingInterpreter(); _graph = new DynamicGraphRouterDataSource <CHEdgeData>(tagsIndex); _graphTarget = new CHEdgeGraphOsmStreamTarget( _graph, interpreter, tagsIndex, vehicle); }
/// <summary> /// Tests routing from a serialized routing file. /// </summary> /// <param name="name"></param> /// <param name="stream"></param> /// <param name="testCount"></param> public static void TestSerializedRouting(string name, Stream stream, int testCount) { var vehicle = Vehicle.Car; var tagsIndex = new TagsTableCollectionIndex(); // creates a tagged index. // read from the OSM-stream. var reader = new OsmSharp.Osm.PBF.Streams.PBFOsmStreamSource(stream); var interpreter = new OsmRoutingInterpreter(); var data = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); data.DropVertexIndex(); var targetData = new LiveGraphOsmStreamTarget(data, interpreter, tagsIndex); targetData.RegisterSource(reader); targetData.Pull(); data.RebuildVertexIndex(); // creates the live edge router. var router = new Dykstra(); var performanceInfo = new PerformanceInfoConsumer("LiveRouting"); performanceInfo.Start(); performanceInfo.Report("Routing {0} routes...", testCount); var successCount = 0; var totalCount = testCount; var latestProgress = -1.0f; while (testCount > 0) { var from = (uint)OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(data.VertexCount - 1) + 1; var to = (uint)OsmSharp.Math.Random.StaticRandomGenerator.Get().Generate(data.VertexCount - 1) + 1; var route = router.Calculate(data, interpreter, vehicle, from, to); if (route != null) { successCount++; } testCount--; // report progress. var progress = (float)System.Math.Round(((double)(totalCount - testCount) / (double)totalCount) * 100); if (progress != latestProgress) { OsmSharp.Logging.Log.TraceEvent("LiveRouting", TraceEventType.Information, "Routing... {0}%", progress); latestProgress = progress; } } performanceInfo.Stop(); OsmSharp.Logging.Log.TraceEvent("LiveRouting", OsmSharp.Logging.TraceEventType.Information, string.Format("{0}/{1} routes successfull!", successCount, totalCount)); }
/// <summary> /// Preprocesses the data from the given OsmStreamReader and converts it directly to a routable data source. /// </summary> /// <param name="reader"></param> /// <param name="tagsIndex"></param> /// <param name="interpreter"></param> /// <returns></returns> public static DynamicGraphRouterDataSource <LiveEdge> Preprocess(OsmStreamSource reader, ITagsIndex tagsIndex, IRoutingInterpreter interpreter) { var dynamicGraphRouterDataSource = new DynamicGraphRouterDataSource <LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamWriter(dynamicGraphRouterDataSource, interpreter, dynamicGraphRouterDataSource.TagsIndex); targetData.RegisterSource(reader); targetData.Pull(); return(dynamicGraphRouterDataSource); }
/// <summary> /// Serializes all edges. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> protected override void SerializeEdges(LimitedStream stream, DynamicGraphRouterDataSource <CHEdgeData> graph) { var typeModel = RuntimeTypeModel.Create(); typeModel.Add(typeof(SerializableEdge), true); int blockSize = 1000; var arcsQueue = new List <SerializableEdge>(blockSize); uint vertex = 0; while (vertex < graph.VertexCount) { // keep looping and serialize all vertices. var arcs = graph.GetEdges(vertex); if (arcs != null) { // serialize the arcs, but serialize them only once. // choose only those arcs that start at a vertex smaller than the target. for (int idx = 0; idx < arcs.Length; idx++) { if (arcs[idx].Key > vertex) { arcsQueue.Add(new SerializableEdge() { FromId = vertex, ToId = arcs[idx].Key, ContractedVertexId = arcs[idx].Value.ContractedVertexId, Direction = arcs[idx].Value.Direction, Tags = arcs[idx].Value.Tags, Weight = arcs[idx].Value.Weight }); if (arcsQueue.Count == blockSize) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } } } // serialize. vertex++; } } if (arcsQueue.Count > 0) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } }
/// <summary> /// Builds the edge difference. /// </summary> private CHPreProcessor BuildCHPreProcessor(IOsmRoutingInterpreter interpreter) { DynamicGraphRouterDataSource <CHEdgeData> data = this.BuildData(interpreter); // do the pre-processing part. INodeWitnessCalculator witnessCalculator = new DykstraWitnessCalculator(); var edgeDifference = new EdgeDifference( data, witnessCalculator); var preProcessor = new CHPreProcessor( data, edgeDifference, witnessCalculator); return(preProcessor); }
public void RoutingRegressionTest9ResolvingReverse() { // build a graph to encode from. var tags = new TagsTableCollectionIndex(); var graphDataSource = new DynamicGraphRouterDataSource <LiveEdge>(tags); var vertex1 = graphDataSource.AddVertex(51.05849821468899f, 3.7240000000000000f); var vertex2 = graphDataSource.AddVertex(51.05849821468899f, 3.7254400000000000f); var vertex3 = graphDataSource.AddVertex(51.05849821468899f, 3.7225627899169926f); var edge = new LiveEdge() // all edges are identical. { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"), Tag.Create("oneway", "yes"))) }; graphDataSource.AddEdge(vertex1, vertex2, edge, null); graphDataSource.AddEdge(vertex3, vertex1, edge, null); // {RectF:[(3,71326552867889,51,048498214689),(3,73326552867889,51,068498214689)]} var edges = graphDataSource.GetEdges(new GeoCoordinateBox( new GeoCoordinate(51.068498214689, 3.73326552867889), new GeoCoordinate(51.048498214689, 3.71326552867889))); while (edges.MoveNext()) { if (edges.Vertex1 == 1 && edges.Vertex2 == 2) { Assert.IsTrue(edges.EdgeData.Forward); } else if (edges.Vertex1 == 2 && edges.Vertex2 == 1) { Assert.IsFalse(edges.EdgeData.Forward); } if (edges.Vertex1 == 1 && edges.Vertex2 == 3) { Assert.IsFalse(edges.EdgeData.Forward); } else if (edges.Vertex1 == 3 && edges.Vertex2 == 1) { Assert.IsTrue(edges.EdgeData.Forward); } } }
/// <summary> /// Creates a router using live interpreted edges. /// </summary> /// <param name="reader">The data to route on.</param> /// <param name="interpreter">The routing interpreter.</param> /// <param name="vehicle">The vehicle profile.</param> /// <returns></returns> public static Router CreateCHFrom(OsmStreamSource reader, IOsmRoutingInterpreter interpreter, Vehicle vehicle) { var tagsIndex = new TagsTableCollectionIndex(); // creates a tagged index. // read from the OSM-stream. DynamicGraphRouterDataSource <CHEdgeData> data = CHEdgeGraphOsmStreamTarget.Preprocess( reader, interpreter, vehicle); // creates the live edge router. var liveEdgeRouter = new TypedRouterCHEdge( data, interpreter, new CHRouter()); return(new Router(liveEdgeRouter)); // create the actual router. }
/// <summary> /// Serializes all edges. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> protected override void SerializeEdges(LimitedStream stream, DynamicGraphRouterDataSource <LiveEdge> graph) { var typeModel = RuntimeTypeModel.Create(); typeModel.Add(typeof(SerializableEdge), true); typeModel.Add(typeof(GeoCoordinateSimple), true); int blockSize = 10000; var arcsQueue = new List <SerializableEdge>(blockSize); uint vertex = 0; while (vertex < graph.VertexCount) { // keep looping and serialize all vertices. var edges = graph.GetEdges(vertex); // serialize the arcs, but serialize them only once. // choose only those arcs that start at a vertex smaller than the target. foreach (var edge in edges) { if (edge.Neighbour > vertex) { arcsQueue.Add(new SerializableEdge() { Distance = edge.EdgeData.Distance, FromId = vertex, ToId = edge.Neighbour, Value = edge.EdgeData.Value, Coordinates = edge.Intermediates.ToSimpleArray() }); if (arcsQueue.Count == blockSize) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } } } // move to next vertex. vertex++; } if (arcsQueue.Count > 0) { // execute serialization. typeModel.SerializeWithSize(stream, arcsQueue.ToArray()); arcsQueue.Clear(); } }
/// <summary> /// Serializes the given graph and tags index to the given stream. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> public void Serialize(Stream stream, DynamicGraphRouterDataSource<PreProcessedEdge> graph) { if (stream == null) throw new ArgumentNullException("stream"); if (graph == null) throw new ArgumentNullException("graph"); // write the header. this.WriteVersionHeader(stream); // wrap the stream. var routingSerializerStream = new RoutingSerializerStream(stream); // do the version-specific serialization. this.DoSerialize(routingSerializerStream, graph); }
/// <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> /// Builds a raw data source. /// </summary> /// <returns></returns> public DynamicGraphRouterDataSource<LiveEdge> BuildDykstraDataSource( IOsmRoutingInterpreter interpreter, string embeddedName) { var tagsIndex = new SimpleTagsIndex(); // do the data processing. var data = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget( data, interpreter, data.TagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.Test.Unittests.{0}", embeddedName))); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); return data; }
/// <summary> /// Creates a router. /// </summary> /// <param name="interpreter"></param> /// <param name="manifestResourceName"></param> /// <returns></returns> protected override Router CreateRouter(IOsmRoutingInterpreter interpreter, string manifestResourceName) { SimpleTagsIndex tagsIndex = new SimpleTagsIndex(); // do the data processing. DynamicGraphRouterDataSource<LiveEdge> memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); LiveGraphOsmStreamTarget target_data = new LiveGraphOsmStreamTarget( memoryData, interpreter, memoryData.TagsIndex); XmlOsmStreamSource dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName)); OsmStreamFilterSort sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); target_data.RegisterSource(sorter); target_data.Pull(); IBasicRouter<LiveEdge> basicRouter = new DykstraRoutingLive(memoryData.TagsIndex); return Router.CreateLiveFrom(memoryData, basicRouter, interpreter); }
/// <summary> /// Builds a raw data source. /// </summary> /// <returns></returns> public DynamicGraphRouterDataSource<PreProcessedEdge> BuildDykstraDataSource( IRoutingInterpreter interpreter, string embedded_name) { OsmTagsIndex tags_index = new OsmTagsIndex(); // do the data processing. DynamicGraphRouterDataSource<PreProcessedEdge> data = new DynamicGraphRouterDataSource<PreProcessedEdge>(tags_index); PreProcessedDataGraphProcessingTarget target_data = new PreProcessedDataGraphProcessingTarget( data, interpreter, data.TagsIndex, VehicleEnum.Car); XmlDataProcessorSource data_processor_source = new XmlDataProcessorSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format( "OsmSharp.UnitTests.{0}", embedded_name))); DataProcessorFilterSort sorter = new DataProcessorFilterSort(); sorter.RegisterSource(data_processor_source); target_data.RegisterSource(sorter); target_data.Pull(); return data; }
public void RoutingRegressionTest1() { OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); SimpleTagsIndex tags_index = new SimpleTagsIndex(); // do the data processing. DynamicGraphRouterDataSource<LiveEdge> memory_data = new DynamicGraphRouterDataSource<LiveEdge>(tags_index); LiveGraphOsmStreamTarget target_data = new LiveGraphOsmStreamTarget( memory_data, interpreter, memory_data.TagsIndex); XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); OsmStreamFilterSort sorter = new OsmStreamFilterSort(); sorter.RegisterSource(data_processor_source); target_data.RegisterSource(sorter); target_data.Pull(); IBasicRouter<LiveEdge> basic_router = new DykstraRoutingLive(memory_data.TagsIndex); Router router = Router.CreateLiveFrom(memory_data, basic_router, interpreter); // resolve the three points in question. GeoCoordinate point35 = new GeoCoordinate(51.01257, 4.000753); RouterPoint point35resolved = router.Resolve(Vehicle.Car, point35); // GeoCoordinate point40 = new GeoCoordinate(51.01250, 4.000013); // RouterPoint point40resolved = router.Resolve(Vehicle.Car, point40); GeoCoordinate point45 = new GeoCoordinate(51.01315, 3.999588); RouterPoint point45resolved = router.Resolve(Vehicle.Car, point45); // route between 35 and 45. Route routebefore = router.Calculate(Vehicle.Car, point35resolved, point45resolved); // GeoCoordinate point129 = new GeoCoordinate(51.01239, 3.999573); // RouterPoint point129resolved = router.Resolve(Vehicle.Car, point129); // route between 35 and 45. Route routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
public static Stream TestSerialization(string name, string pbfFile, DynamicGraphRouterDataSource<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 CHEdgeDataDataSourceSerializer(); 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> /// Creates a router. /// </summary> /// <param name="interpreter"></param> /// <param name="manifestResourceName"></param> /// <returns></returns> protected override Router CreateRouter(IOsmRoutingInterpreter interpreter, string manifestResourceName) { SimpleTagsIndex tagsIndex = new SimpleTagsIndex(); // do the data processing. var data = new DynamicGraphRouterDataSource<CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, data.TagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(data); var preProcessor = new CHPreProcessor(data, new EdgeDifference(data, witnessCalculator), witnessCalculator); preProcessor.Start(); //IBasicRouter<LiveEdge> basicRouter = new DykstraRoutingLive(memoryData.TagsIndex); return Router.CreateCHFrom(data, new CHRouter(data), interpreter); }
/// <summary> /// Calculates a route to test on. /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <returns></returns> private OsmSharpRoute Calculate(GeoCoordinate from, GeoCoordinate to) { if (_router == null) { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new OsmTagsIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource<SimpleWeighedEdge>(tagsIndex); var targetData = new SimpleWeighedDataGraphProcessingTarget( memoryData, interpreter, memoryData.TagsIndex, VehicleEnum.Car); var dataProcessorSource = new XmlDataProcessorSource( Assembly.GetExecutingAssembly().GetManifestResourceStream( "OsmSharp.UnitTests.test_instructions.osm")); var sorter = new DataProcessorFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); _router = new Router<SimpleWeighedEdge>( memoryData, interpreter, new DykstraRoutingLive(memoryData.TagsIndex)); } RouterPoint fromPoint = _router.Resolve(VehicleEnum.Car, from); RouterPoint toPoint = _router.Resolve(VehicleEnum.Car, to); return _router.Calculate(VehicleEnum.Car, fromPoint, toPoint); }
/// <summary> /// Executes the CH contractions while verifying each step. /// </summary> /// <param name="stream"></param> public void DoTestCHSparseVerifiedContraction(Stream stream) { _pathsBeforeContraction = new Dictionary<uint, Dictionary<uint, Dictionary<uint, PathSegment<long>>>>(); _interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. _data = new DynamicGraphRouterDataSource<CHEdgeData>(new MemoryDirectedGraph<CHEdgeData>(), tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( _data, _interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource(stream); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(); var preProcessor = new CHPreProcessor(_data, new EdgeDifferenceContractedSearchSpace(_data, witnessCalculator), witnessCalculator); preProcessor.OnBeforeContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnBeforeContractionEvent); preProcessor.OnAfterContractionEvent += new CHPreProcessor.VertexDelegate(pre_processor_OnAfterContractionEvent); preProcessor.Start(); }
/// <summary> /// Builds a raw router to compare against. /// </summary> /// <returns></returns> public void BuildDykstraRouter(string embeddedName, IOsmRoutingInterpreter interpreter) { var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var data = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget( data, interpreter, tagsIndex, new Vehicle[] { Vehicle.Car }); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedName)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // initialize the router. _referenceRouter = Router.CreateLiveFrom(data, new Dykstra(), interpreter); }
/// <summary> /// Creates a router. /// </summary> /// <param name="interpreter"></param> /// <param name="manifestResourceName"></param> /// <returns></returns> protected override Router CreateRouter(IOsmRoutingInterpreter interpreter, string manifestResourceName) { TagsTableCollectionIndex tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var data = new DynamicGraphRouterDataSource<CHEdgeData>(new MemoryDirectedGraph<CHEdgeData>(), tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream(manifestResourceName)); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); // do the pre-processing part. var witnessCalculator = new DykstraWitnessCalculator(); var preProcessor = new CHPreProcessor(data, new EdgeDifferenceContractedSearchSpace(data, witnessCalculator), witnessCalculator); preProcessor.Start(); return Router.CreateCHFrom(data, new CHRouter(), interpreter); }
/// <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 RoutingRegressionTest10ResolvingReverse() { // build a graph to encode from. var tags = new TagsTableCollectionIndex(); var graphDataSource = new DynamicGraphRouterDataSource<LiveEdge>(tags); var vertex1 = graphDataSource.AddVertex(51.05849821468899f, 3.7240000000000000f); var vertex2 = graphDataSource.AddVertex(51.05849821468899f, 3.7254400000000000f); var vertex3 = graphDataSource.AddVertex(51.05849821468899f, 3.7225627899169926f); var edge = new LiveEdge() // all edges are identical. { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"), Tag.Create("oneway", "yes"))) }; var shape1 = new CoordinateArrayCollection<OsmSharp.Math.Geo.Simple.GeoCoordinateSimple>( new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple[] { new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 1, Longitude = 1 }, new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 2, Longitude = 2 } }); var shape2 = new CoordinateArrayCollection<OsmSharp.Math.Geo.Simple.GeoCoordinateSimple>( new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple[] { new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 3, Longitude = 3 }, new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 4, Longitude = 4 } }); graphDataSource.AddEdge(vertex1, vertex2, edge, shape1); graphDataSource.AddEdge(vertex3, vertex1, edge, shape2); // {RectF:[(3,71326552867889,51,048498214689),(3,73326552867889,51,068498214689)]} var edges = graphDataSource.GetEdges(new GeoCoordinateBox( new GeoCoordinate(51.068498214689, 3.73326552867889), new GeoCoordinate(51.048498214689, 3.71326552867889))); while (edges.MoveNext()) { if (edges.Vertex1 == 1 && edges.Vertex2 == 2) { Assert.IsTrue(edges.EdgeData.Forward); var shapes = edges.Intermediates.ToSimpleArray(); Assert.AreEqual(2, shapes.Length); Assert.AreEqual(1, shapes[0].Latitude); Assert.AreEqual(1, shapes[0].Longitude); Assert.AreEqual(2, shapes[1].Latitude); Assert.AreEqual(2, shapes[1].Longitude); } else if (edges.Vertex1 == 2 && edges.Vertex2 == 1) { Assert.IsFalse(edges.EdgeData.Forward); var shapes = edges.Intermediates.ToSimpleArray(); Assert.AreEqual(2, shapes.Length); Assert.AreEqual(2, shapes[0].Latitude); Assert.AreEqual(2, shapes[0].Longitude); Assert.AreEqual(1, shapes[1].Latitude); Assert.AreEqual(1, shapes[1].Longitude); } if (edges.Vertex1 == 1 && edges.Vertex2 == 3) { Assert.IsFalse(edges.EdgeData.Forward); var shapes = edges.Intermediates.ToSimpleArray(); Assert.AreEqual(2, shapes.Length); Assert.AreEqual(4, shapes[0].Latitude); Assert.AreEqual(4, shapes[0].Longitude); Assert.AreEqual(3, shapes[1].Latitude); Assert.AreEqual(3, shapes[1].Longitude); } else if (edges.Vertex1 == 3 && edges.Vertex2 == 1) { Assert.IsTrue(edges.EdgeData.Forward); var shapes = edges.Intermediates.ToSimpleArray(); Assert.AreEqual(2, shapes.Length); Assert.AreEqual(3, shapes[0].Latitude); Assert.AreEqual(3, shapes[0].Longitude); Assert.AreEqual(4, shapes[1].Latitude); Assert.AreEqual(4, shapes[1].Longitude); } } }
public void RoutingRegressionTest9ResolvingReverse() { // build a graph to encode from. var tags = new TagsTableCollectionIndex(); var graphDataSource = new DynamicGraphRouterDataSource<LiveEdge>(tags); var vertex1 = graphDataSource.AddVertex(51.05849821468899f, 3.7240000000000000f); var vertex2 = graphDataSource.AddVertex(51.05849821468899f, 3.7254400000000000f); var vertex3 = graphDataSource.AddVertex(51.05849821468899f, 3.7225627899169926f); var edge = new LiveEdge() // all edges are identical. { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"), Tag.Create("oneway", "yes"))) }; graphDataSource.AddEdge(vertex1, vertex2, edge, null); graphDataSource.AddEdge(vertex3, vertex1, edge, null); // {RectF:[(3,71326552867889,51,048498214689),(3,73326552867889,51,068498214689)]} var edges = graphDataSource.GetEdges(new GeoCoordinateBox( new GeoCoordinate(51.068498214689, 3.73326552867889), new GeoCoordinate(51.048498214689, 3.71326552867889))); while(edges.MoveNext()) { if(edges.Vertex1 == 1 && edges.Vertex2 == 2) { Assert.IsTrue(edges.EdgeData.Forward); } else if(edges.Vertex1 == 2 && edges.Vertex2 == 1) { Assert.IsFalse(edges.EdgeData.Forward); } if (edges.Vertex1 == 1 && edges.Vertex2 == 3) { Assert.IsFalse(edges.EdgeData.Forward); } else if (edges.Vertex1 == 3 && edges.Vertex2 == 1) { Assert.IsTrue(edges.EdgeData.Forward); } } }
/// <summary> /// Builds the data source. /// </summary> /// <returns></returns> private DynamicGraphRouterDataSource<CHEdgeData> BuildData(IOsmRoutingInterpreter interpreter) { DynamicGraphRouterDataSource<CHEdgeData> data = null; if (data == null) { var tagsIndex = new SimpleTagsIndex(); // do the data processing. data = new DynamicGraphRouterDataSource<CHEdgeData>(tagsIndex); var targetData = new CHEdgeGraphOsmStreamTarget( data, interpreter, tagsIndex, Vehicle.Car); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_network.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); } return data; }
public void RoutingRegressionTest4() { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_routing_regression1.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); var basicRouter = new Dykstra(); var router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // resolve the three points in question. var point35 = new GeoCoordinate(51.01257, 4.000753); var point35ResolvedCar = router.Resolve(Vehicle.Car, point35); var point35ResolvedBicycle = router.Resolve(Vehicle.Bicycle, point35); }
public void RoutingRegressionTest3() { var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new TagsTableCollectionIndex(); // do the data processing. var memoryData = new DynamicGraphRouterDataSource<LiveEdge>(tagsIndex); var targetData = new LiveGraphOsmStreamTarget(memoryData, interpreter, tagsIndex); var dataProcessorSource = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.Unittests.test_network.osm")); var sorter = new OsmStreamFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); var basicRouter = new Dykstra(); var router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // build coordinates list of resolved points. var testPoints = new List<GeoCoordinate>(); testPoints.Add(new GeoCoordinate(51.0581719, 3.7201622)); testPoints.Add(new GeoCoordinate(51.0580439, 3.7202134)); testPoints.Add(new GeoCoordinate(51.0580573, 3.7204378)); testPoints.Add(new GeoCoordinate(51.0581862, 3.7203758)); // build a matrix of routes between all points. var referenceRoutes = new Route[testPoints.Count][]; var permuationArray = new int[testPoints.Count]; for (int fromIdx = 0; fromIdx < testPoints.Count; fromIdx++) { permuationArray[fromIdx] = fromIdx; referenceRoutes[fromIdx] = new Route[testPoints.Count]; for (int toIdx = 0; toIdx < testPoints.Count; toIdx++) { // create router from scratch. router = Router.CreateLiveFrom( memoryData, basicRouter, interpreter); // resolve points. var from = router.Resolve(Vehicle.Car, testPoints[fromIdx]); var to = router.Resolve(Vehicle.Car, testPoints[toIdx]); // calculate route. referenceRoutes[fromIdx][toIdx] = router.Calculate(Vehicle.Car, from, to); } } // resolve points in some order and compare the resulting routes. // they should be identical in length except for some numerical rounding errors. var enumerator = new PermutationEnumerable<int>( permuationArray); foreach (int[] permutation in enumerator) { // create router from scratch. router = Router.CreateLiveFrom(memoryData, basicRouter, interpreter); // resolve in the order of the permutation. var resolvedPoints = new RouterPoint[permutation.Length]; for (int idx = 0; idx < permutation.Length; idx++) { resolvedPoints[permutation[idx]] = router.Resolve(Vehicle.Car, testPoints[permutation[idx]]); } for (int fromIdx = 0; fromIdx < testPoints.Count; fromIdx++) { for (int toIdx = 0; toIdx < testPoints.Count; toIdx++) { // calculate route. var route = router.Calculate(Vehicle.Car, resolvedPoints[fromIdx], resolvedPoints[toIdx]); Assert.AreEqual(referenceRoutes[fromIdx][toIdx].TotalDistance, route.TotalDistance, 0.1); } } } }
public void RoutingRegressionTest11ResolvingReverse() { // build a graph to encode from. var tags = new TagsTableCollectionIndex(); var graphDataSource = new DynamicGraphRouterDataSource<LiveEdge>(tags); var vertex1 = graphDataSource.AddVertex(51.05849821468899f, 3.7240000000000000f); var vertex2 = graphDataSource.AddVertex(51.05849821468899f, 3.7254400000000000f); var vertex3 = graphDataSource.AddVertex(51.05849821468899f, 3.7225627899169926f); var edgeData = new LiveEdge() // all edges are identical. { Distance = 100, Forward = true, Tags = tags.Add(new TagsCollection( Tag.Create("highway", "tertiary"), Tag.Create("oneway", "yes"))) }; var shape1 = new CoordinateArrayCollection<OsmSharp.Math.Geo.Simple.GeoCoordinateSimple>( new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple[] { new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 1, Longitude = 1 }, new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 2, Longitude = 2 } }); var shape2 = new CoordinateArrayCollection<OsmSharp.Math.Geo.Simple.GeoCoordinateSimple>( new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple[] { new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 3, Longitude = 3 }, new OsmSharp.Math.Geo.Simple.GeoCoordinateSimple() { Latitude = 4, Longitude = 4 } }); graphDataSource.AddEdge(vertex1, vertex2, edgeData, shape1); graphDataSource.AddEdge(vertex3, vertex1, edgeData, shape2); var edges = new List<Edge<LiveEdge>>(graphDataSource.GetEdges(1)); Assert.AreEqual(2, edges.Count); foreach(var edge in edges) { if (edge.Neighbour == 2) { Assert.AreEqual(true, edge.EdgeData.Forward); } else if(edge.Neighbour == 3) { Assert.AreEqual(false, edge.EdgeData.Forward); } } edges = new List<Edge<LiveEdge>>(graphDataSource.GetEdges(2)); Assert.AreEqual(1, edges.Count); Assert.AreEqual(false, edges[0].EdgeData.Forward); edges = new List<Edge<LiveEdge>>(graphDataSource.GetEdges(3)); Assert.AreEqual(1, edges.Count); Assert.AreEqual(true, edges[0].EdgeData.Forward); }
/// <summary> /// Serializes the given graph and tags index to the given stream. /// </summary> /// <param name="stream"></param> /// <param name="graph"></param> protected abstract void DoSerialize(RoutingSerializerStream stream, DynamicGraphRouterDataSource<PreProcessedEdge> graph);
/// <summary> /// Calculates the TSP. /// </summary> /// <param name="dataStream"></param> /// <param name="csvStream"></param> /// <param name="pbf"></param> /// <param name="vehicleEnum"></param> /// <returns></returns> private OsmSharpRoute CalculateTSP(Stream dataStream, Stream csvStream, bool pbf, VehicleEnum vehicleEnum) { // create the router. var interpreter = new OsmRoutingInterpreter(); var tagsIndex = new OsmTagsIndex(); // do the data processing. var osmData = new DynamicGraphRouterDataSource<PreProcessedEdge>(tagsIndex); var targetData = new PreProcessedDataGraphProcessingTarget( osmData, interpreter, osmData.TagsIndex, vehicleEnum); var dataProcessorSource = new XmlDataProcessorSource(dataStream); var sorter = new DataProcessorFilterSort(); sorter.RegisterSource(dataProcessorSource); targetData.RegisterSource(sorter); targetData.Pull(); IRouter<RouterPoint> router = new Router<PreProcessedEdge>(osmData, interpreter, new DykstraRoutingPreProcessed(osmData.TagsIndex)); // read the source files. const int latitudeIdx = 2; const int longitudeIdx = 3; string[][] pointStrings = OsmSharp.Tools.DelimitedFiles.DelimitedFileHandler.ReadDelimitedFileFromStream( csvStream, DelimiterType.DotCommaSeperated); var points = new List<RouterPoint>(); int cnt = 10; foreach (string[] line in pointStrings) { if (points.Count >= cnt) { break; } var latitudeString = (string)line[latitudeIdx]; var longitudeString = (string)line[longitudeIdx]; //string route_ud = (string)line[1]; double longitude = 0; double latitude = 0; if (double.TryParse(longitudeString, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out longitude) && double.TryParse(latitudeString, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out latitude)) { var point = new GeoCoordinate(latitude, longitude); RouterPoint resolved = router.Resolve(VehicleEnum.Car, point); if (resolved != null && router.CheckConnectivity(VehicleEnum.Car, resolved, 100)) { points.Add(resolved); } } } var tspSolver = new RouterTSPWrapper<RouterPoint, RouterTSP>( new RouterTSPAEXGenetic(), router, interpreter); return tspSolver.CalculateTSP(vehicleEnum, points.ToArray()); }