void mapControl1_MapMouseClick(MapControlEventArgs e) { if (_router != null) { if (_point1 == null) { _point1 = _router.Resolve(Vehicle.Car, e.Position); } else if (_point2 == null) { _point2 = _router.Resolve(Vehicle.Car, e.Position); } else { _point1 = _point2; _point2 = _router.Resolve(Vehicle.Car, e.Position); } if (_point1 != null && _point2 != null) { OsmSharpRoute route = _router.Calculate(Vehicle.Car, _point1, _point2); if (route != null) { _routeLayer.Clear(); _routeLayer.AddRoute(route); } } } }
/// <summary> /// Tests that a router preserves tags that are located on ways/arcs in the route. /// </summary> protected void DoTestArcTags() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229)); source.Tags.Add(new KeyValuePair <string, string>("name", "source")); RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801)); target.Tags.Add(new KeyValuePair <string, string>("name", "target")); OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(5, route.Entries.Length); Assert.AreEqual("highway", route.Entries[1].Tags[0].Key); Assert.AreEqual("residential", route.Entries[1].Tags[0].Value); Assert.AreEqual("highway", route.Entries[2].Tags[0].Key); Assert.AreEqual("residential", route.Entries[2].Tags[0].Value); Assert.AreEqual("highway", route.Entries[3].Tags[0].Key); Assert.AreEqual("residential", route.Entries[3].Tags[0].Value); }
public AggregatedPointEnumerator(OsmSharpRoute route) { _idx = -1; _route = route; _current = null; }
/// <summary> /// Test if routes between resolved nodes are correctly calculated. /// /// 20--x---x--21---------16 /// </summary> protected void DoTestResolveCase2() { // initialize data. var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); var vertex20 = new GeoCoordinate(51.0578532, 3.7192229); var vertex21 = new GeoCoordinate(51.0578518, 3.7195654); var vertex16 = new GeoCoordinate(51.0577299, 3.719745); PointF2D point = vertex20 + ((vertex21 - vertex20) * 0.25); var vertex20211 = new GeoCoordinate(point[1], point[0]); point = vertex20 + ((vertex21 - vertex20) * 0.75); var vertex20212 = new GeoCoordinate(point[1], point[0]); // calculate route. IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter(data, interpreter, basicRouter); OsmSharpRoute route = router.Calculate(Vehicle.Car, router.Resolve(Vehicle.Car, vertex20211), router.Resolve(Vehicle.Car, vertex20212)); Assert.AreEqual(2, route.Entries.Length); Assert.AreEqual(vertex20211.Latitude, route.Entries[0].Latitude, 0.0001); Assert.AreEqual(vertex20211.Longitude, route.Entries[0].Longitude, 0.0001); //Assert.AreEqual(vertex_21.Latitude, route.Entries[1].Latitude, 0.0001); //Assert.AreEqual(vertex_21.Longitude, route.Entries[1].Longitude, 0.0001); Assert.AreEqual(vertex20212.Latitude, route.Entries[1].Latitude, 0.0001); Assert.AreEqual(vertex20212.Longitude, route.Entries[1].Longitude, 0.0001); }
/// <summary> /// Aggregates a route by remove information useless to the generation of routing instructions. /// </summary> /// <param name="route"></param> /// <returns></returns> public AggregatedPoint Aggregate(OsmSharpRoute route) { // create the enumerator. AggregatedPointEnumerator enumerator = new AggregatedPointEnumerator(route); AggregatedRoutePoint previous = null; AggregatedRoutePoint current = null; AggregatedRoutePoint next = null; // loop over all aggregated points. while (enumerator.MoveNext()) { // get the next point. next = enumerator.Current; // process this.Process(route, previous, current, next); // make the next, current and the current previous. previous = current; current = next; next = null; } // process once more, the current current has not been processed. this.Process(route, previous, current, next); return(p); }
/// <summary> /// Test if routes from a resolved node to itself is correctly calculated. /// /// Regression Test: Routing to self with a resolved node returns a route to the nearest real node and back. /// </summary> protected void DoTestResolveBetweenRouteToSelf() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter(data, interpreter, basicRouter); // first test a non-between node. RouterPoint resolved = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801)); OsmSharpRoute route = router.Calculate(Vehicle.Car, resolved, resolved); Assert.AreEqual(1, route.Entries.Length); Assert.AreEqual(0, route.TotalDistance); Assert.AreEqual(0, route.TotalTime); resolved = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578761, 3.7193972)); //,-103, -4, -8 route = router.Calculate(Vehicle.Car, resolved, resolved); Assert.AreEqual(1, route.Entries.Length); Assert.AreEqual(0, route.TotalDistance); Assert.AreEqual(0, route.TotalTime); resolved = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576510, 3.7194124)); //,-104, -14, -12 route = router.Calculate(Vehicle.Car, resolved, resolved); Assert.AreEqual(1, route.Entries.Length); Assert.AreEqual(0, route.TotalDistance); Assert.AreEqual(0, route.TotalTime); resolved = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576829, 3.7196791)); //,-105, -12, -10 route = router.Calculate(Vehicle.Car, resolved, resolved); Assert.AreEqual(1, route.Entries.Length); Assert.AreEqual(0, route.TotalDistance); Assert.AreEqual(0, route.TotalTime); }
/// <summary> /// Raises the intermidiate results event. /// </summary> /// <param name="result"></param> /// <param name="weight"></param> protected void RaiseIntermidiateResult(OsmSharpRoute result, double weight) { if (IntermidiateResult != null) { this.IntermidiateResult(result, weight); } }
/// <summary> /// Adds a new OsmSharpRoute. /// </summary> /// <param name="route">Stream.</param> /// <param name="argb">Stream.</param> public void AddRoute(OsmSharpRoute route, int argb) { if (route.Entries != null && route.Entries.Length > 0) { // there are entries. // get x/y. var x = new double[route.Entries.Length]; var y = new double[route.Entries.Length]; for (int idx = 0; idx < route.Entries.Length; idx++) { x[idx] = _projection.LongitudeToX( route.Entries[idx].Longitude); y[idx] = _projection.LatitudeToY( route.Entries[idx].Latitude); } // set the default color if none is given. SimpleColor blue = new SimpleColor() { Value = argb }; SimpleColor color = SimpleColor.FromArgb(argb); this.Scene.AddLine(float.MinValue, float.MaxValue, x, y, color.Value, 4); } }
/// <summary> /// Calculates metrics for the given route. /// </summary> /// <param name="route"></param> /// <returns></returns> public Dictionary <string, double> Calculate(OsmSharpRoute route) { OsmSharp.Routing.ArcAggregation.ArcAggregator aggregator = new OsmSharp.Routing.ArcAggregation.ArcAggregator(_interpreter); AggregatedPoint p = aggregator.Aggregate(route); return(this.Calculate(route.Vehicle, p)); }
/// <summary> /// Adds a new OsmSharpRoute. /// </summary> /// <param name="route">Stream.</param> public void AddRoute(OsmSharpRoute route) { // set the default color if none is given. SimpleColor blue = SimpleColor.FromKnownColor(KnownColor.Blue); SimpleColor transparantBlue = SimpleColor.FromArgb(128, blue.R, blue.G, blue.B); this.AddRoute(route, transparantBlue.Value); }
/// <summary> /// Generates instructions. /// </summary> /// <param name="route"></param> /// <param name="interpreter"></param> /// <param name="language_generator"></param> /// <returns></returns> public List <Instruction> Generate(OsmSharpRoute route, IRoutingInterpreter interpreter, ILanguageGenerator language_generator) { OsmSharp.Routing.ArcAggregation.ArcAggregator aggregator = new OsmSharp.Routing.ArcAggregation.ArcAggregator(interpreter); AggregatedPoint point = aggregator.Aggregate(route); return(this.Generate(point, interpreter, language_generator)); }
/// <summary> /// Compares all routes against the reference router. /// </summary> public void TestCompareAll(string embeddedName) { // build the routing settings. IRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter(); // get the osm data source. IBasicRouterDataSource <LiveEdge> data = this.BuildDykstraDataSource(interpreter, embeddedName); // build the reference router.; Router referenceRouter = this.BuildDykstraRouter( this.BuildDykstraDataSource(interpreter, embeddedName), interpreter, new DykstraRoutingLive(data.TagsIndex)); // build the router to be tested. Router router = this.BuildRouter(interpreter, embeddedName); // loop over all nodes and resolve their locations. var resolvedReference = new RouterPoint[data.VertexCount - 1]; var resolved = new RouterPoint[data.VertexCount - 1]; for (uint idx = 1; idx < data.VertexCount; idx++) { // resolve each vertex. float latitude, longitude; if (data.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++) { OsmSharpRoute referenceRoute = referenceRouter.Calculate(Vehicle.Car, resolvedReference[fromIdx], resolvedReference[toIdx]); OsmSharpRoute route = router.Calculate(Vehicle.Car, resolved[fromIdx], resolved[toIdx]); Assert.IsNotNull(referenceRoute); Assert.IsNotNull(route); Assert.AreEqual(referenceRoute.TotalDistance, route.TotalDistance, 0.0001); // TODO: meta data is missing in some CH routing; see issue //Assert.AreEqual(reference_route.TotalTime, route.TotalTime, 0.0001); } } }
/// <summary> /// Converts a simple VRP solution into a solution containing the actual routes. /// </summary> /// <param name="vehicle"></param> /// <param name="solution"></param> /// <param name="points"></param> protected OsmSharpRoute[] ConvertSolution(Vehicle vehicle, int[][] solution, RouterPoint[] points) { var routes = new OsmSharpRoute[solution.Length]; for (int routeIdx = 0; routeIdx < solution.Length; routeIdx++) { // concatenate the route(s). OsmSharpRoute tsp = null; OsmSharpRoute route; for (int idx = 0; idx < solution[routeIdx].Length - 1; idx++) { route = _router.Calculate(Vehicle.Car, points[solution[routeIdx][idx]], points[solution[routeIdx][idx + 1]]); if (route != null && route.Entries.Length > 0) { if (tsp == null) { // first route = start tsp = route; } else { // concatenate. tsp = OsmSharpRoute.Concatenate(tsp, route); } } } // concatenate the route from the last to the first point again. route = _router.Calculate(vehicle, points[solution[routeIdx][solution[routeIdx].Length - 1]], points[solution[routeIdx][0]]); if (route.Entries.Length > 0) { tsp = OsmSharpRoute.Concatenate(tsp, route); } // set the result. routes[routeIdx] = tsp; if (routes[routeIdx] != null) { // route exists! var tags = new List <RouteTags>(); var customerCount = new RouteTags(); customerCount.Key = "customer_count"; customerCount.Value = solution[routeIdx].Length.ToString(); tags.Add(customerCount); routes[routeIdx].Tags = tags.ToArray(); // set the correct vehicle type. routes[routeIdx].Vehicle = vehicle; } } return(routes); }
/// <summary> /// Builds an OsmSharRoute. /// </summary> /// <param name="vehicle"></param> /// <param name="points"></param> /// <param name="tspSolution"></param> /// <param name="weight"></param> /// <returns></returns> public OsmSharpRoute BuildRoute(Vehicle vehicle, RouterPoint[] points, IRoute tspSolution, double weight) { int[] solution = tspSolution.ToArray(); OsmSharpRoute tsp = null; OsmSharpRoute route; for (int idx = 0; idx < solution.Length - 1; idx++) { route = _router.Calculate(Vehicle.Car, points[solution[idx]], points[solution[idx + 1]]); if (tsp == null) { // first route = start tsp = route; } else { // concatenate. tsp = OsmSharpRoute.Concatenate(tsp, route); } } if (tspSolution.IsRound) { // concatenate the route from the last to the first point again. route = _router.Calculate(Vehicle.Car, points[solution[solution.Length - 1]], points[solution[0]]); tsp = OsmSharpRoute.Concatenate(tsp, route); } if (tsp != null) { tsp.Vehicle = vehicle; // set the correct vehicle type. if (_interpreter != null) { // there is an interpreter set: calculate time/distance. // calculate metrics. var calculator = new TimeCalculator(_interpreter); Dictionary <string, double> metrics = calculator.Calculate(tsp); tsp.TotalDistance = metrics[TimeCalculator.DISTANCE_KEY]; tsp.TotalTime = metrics[TimeCalculator.TIME_KEY]; } tsp.Tags = new RouteTags[1]; tsp.Tags[0] = new RouteTags(); tsp.Tags[0].Key = "internal_weight"; tsp.Tags[0].Value = weight.ToString(System.Globalization.CultureInfo.InvariantCulture); } return(tsp); }
public void TestTSPWrapperVehicle() { // calculate TSP. OsmSharpRoute route = this.CalculateTSP(Assembly.GetExecutingAssembly() .GetManifestResourceStream( @"OsmSharp.UnitTests.tsp_real.osm"), Assembly.GetExecutingAssembly() .GetManifestResourceStream( @"OsmSharp.UnitTests.tsp_real.csv"), false, Vehicle.Car); Assert.IsNotNull(route); Assert.AreEqual(Vehicle.Car, route.Vehicle); }
/// <summary> /// Tests that a router actually finds the shortest route. /// </summary> protected void DoTestShortestResolved2() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0581843, 3.7201209)); // between 2 - 3 RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0581484, 3.7194957)); // between 9 - 8 OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(5, route.Entries.Length); }
/// <summary> /// Tests that a router actually finds the shortest route. /// </summary> protected void DoTestShortestResolved1() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578153, 3.7193937)); RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0582408, 3.7194636)); OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(10, route.Entries.Length); }
/// <summary> /// Tests that a router actually finds the shortest route. /// </summary> protected void DoTestShortestAgainstDirection() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <EdgeData> data = this.BuildData(interpreter); IBasicRouter <EdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0579530, 3.7196168)); // -56 RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0582205, 3.7192647)); // -52 OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(6, route.Entries.Length); float latitude, longitude; data.GetVertex(10, 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); data.GetVertex(12, 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); data.GetVertex(13, 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); data.GetVertex(14, 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); data.GetVertex(15, 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.Along, route.Entries[4].Type); data.GetVertex(19, out latitude, out longitude); Assert.AreEqual(latitude, route.Entries[5].Latitude, 0.00001); Assert.AreEqual(longitude, route.Entries[5].Longitude, 0.00001); Assert.AreEqual(RoutePointEntryType.Stop, route.Entries[5].Type); }
/// <summary> /// Tests that a router actually finds the shortest route. /// </summary> protected void DoTestShortestDefault() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229)); RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801)); OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(5, route.Entries.Length); float latitude, longitude; data.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); data.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); data.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); data.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); data.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); }
/// <summary> /// Tests access for a given vehicle type and for a given network between two given points. /// </summary> /// <param name="vehicle"></param> /// <param name="from"></param> /// <param name="to"></param> /// <param name="interpreter"></param> protected bool DoTestForVehicle(Vehicle vehicle, GeoCoordinate from, GeoCoordinate to, IRoutingInterpreter interpreter) { IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_segments.osm", vehicle); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter(data, interpreter, basicRouter); RouterPoint resolvedFrom = router.Resolve(vehicle, from); RouterPoint resolvedTo = router.Resolve(vehicle, to); if (resolvedFrom != null && resolvedTo != null) { OsmSharpRoute route = router.Calculate(vehicle, resolvedFrom, resolvedTo); return(route != null); } return(false); }
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); LiveGraphOsmStreamWriter target_data = new LiveGraphOsmStreamWriter( memory_data, interpreter, memory_data.TagsIndex); XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.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. OsmSharpRoute 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. OsmSharpRoute routeafter = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Assert.AreEqual(routebefore.TotalDistance, routeafter.TotalDistance); }
/// <summary> /// Test if routes between two resolved nodes are correctly calculated. /// </summary> protected void DoTestResolveBetweenClose() { // initialize data. var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); var vertex20 = new GeoCoordinate(51.0578532, 3.7192229); var vertex21 = new GeoCoordinate(51.0578518, 3.7195654); var vertex16 = new GeoCoordinate(51.0577299, 3.719745); for (double position1 = 0.1; position1 < 0.91; position1 = position1 + 0.1) { PointF2D point = vertex20 + ((vertex21 - vertex20) * position1); var vertex2021 = new GeoCoordinate(point[1], point[0]); for (double position2 = 0.1; position2 < 0.91; position2 = position2 + 0.1) { point = vertex21 + ((vertex16 - vertex21) * position2); var vertex2116 = new GeoCoordinate(point[1], point[0]); // calculate route. IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter(data, interpreter, basicRouter); OsmSharpRoute route = router.Calculate(Vehicle.Car, router.Resolve(Vehicle.Car, vertex2021), router.Resolve(Vehicle.Car, vertex2116)); Assert.AreEqual(3, route.Entries.Length); Assert.AreEqual(vertex2021.Latitude, route.Entries[0].Latitude, 0.0001); Assert.AreEqual(vertex2021.Longitude, route.Entries[0].Longitude, 0.0001); Assert.AreEqual(vertex21.Latitude, route.Entries[1].Latitude, 0.0001); Assert.AreEqual(vertex21.Longitude, route.Entries[1].Longitude, 0.0001); Assert.AreEqual(vertex2116.Latitude, route.Entries[2].Latitude, 0.0001); Assert.AreEqual(vertex2116.Longitude, route.Entries[2].Longitude, 0.0001); } } }
/// <summary> /// Tests that a router actually finds the shortest route. /// </summary> /// <param name="vehicle"></param> /// <param name="accessTags"></param> protected void DoTestShortestWithAccess(Vehicle vehicle, List <KeyValuePair <string, string> > accessTags) { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <EdgeData> data = this.BuildData(interpreter, vehicle, accessTags); IBasicRouter <EdgeData> basicRouter = this.BuildBasicRouter(data, vehicle); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(vehicle, new GeoCoordinate(51.0582205, 3.7192647)); // -52 RouterPoint target = router.Resolve(vehicle, new GeoCoordinate(51.0579530, 3.7196168)); // -56 OsmSharpRoute route = router.Calculate(vehicle, source, target); Assert.IsNotNull(route); Assert.AreEqual(4, route.Entries.Length); float latitude, longitude; data.GetVertex(19, 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); data.GetVertex(8, 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); data.GetVertex(9, 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); data.GetVertex(10, 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.Stop, route.Entries[3].Type); }
/// <summary> /// Tests that a router preserves tags given to resolved points. /// </summary> protected void DoTestResolvedTags() { var interpreter = new OsmRoutingInterpreter(); IBasicRouterDataSource <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.UnitTests.test_network.osm"); IBasicRouter <TEdgeData> basicRouter = this.BuildBasicRouter(data); Router router = this.BuildRouter( data, interpreter, basicRouter); RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229)); source.Tags.Add(new KeyValuePair <string, string>("name", "source")); RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801)); target.Tags.Add(new KeyValuePair <string, string>("name", "target")); OsmSharpRoute route = router.Calculate(Vehicle.Car, source, target); Assert.IsNotNull(route); Assert.AreEqual(5, route.Entries.Length); float latitude, longitude; data.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); Assert.IsNotNull(route.Entries[0].Points[0].Tags); Assert.AreEqual(1, route.Entries[0].Points[0].Tags.Length); Assert.AreEqual("source", route.Entries[0].Points[0].Tags[0].Value); data.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); Assert.IsNotNull(route.Entries[4].Points[0].Tags); Assert.AreEqual(1, route.Entries[4].Points[0].Tags.Length); Assert.AreEqual("target", route.Entries[4].Points[0].Tags[0].Value); }
private void MapMarkerClicked(object sender, EventArgs e) { if (sender is MapMarker) { lock (_router) { MapMarker marker = sender as MapMarker; RouterPoint point = _router.Resolve(Vehicle.Car, marker.Location); if (point != null) { if (_previousPoint != null) { _routeLayer.Clear(); OsmSharpRoute route = _router.Calculate(Vehicle.Car, _previousPoint, point); if (route != null) { _routeLayer.AddRoute(route); } _routeLayer.Invalidate(); } _previousPoint = point; } } } }
public void RoutingRegressionTest2() { OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); SimpleTagsIndex tags_index = new SimpleTagsIndex(); // do the data processing. DynamicGraphRouterDataSource <LiveEdge> memory_data = new DynamicGraphRouterDataSource <LiveEdge>(tags_index); LiveGraphOsmStreamWriter target_data = new LiveGraphOsmStreamWriter( memory_data, interpreter, memory_data.TagsIndex); XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.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 point45 = new GeoCoordinate(51.01315, 3.999588); RouterPoint point45resolved = router.Resolve(Vehicle.Car, point45); GeoCoordinate point40 = new GeoCoordinate(51.01250, 4.000013); RouterPoint point40resolved = router.Resolve(Vehicle.Car, point40); // calculate two smaller routes. OsmSharpRoute route3545 = router.Calculate(Vehicle.Car, point35resolved, point45resolved); OsmSharpRoute route4540 = router.Calculate(Vehicle.Car, point45resolved, point40resolved); OsmSharpRoute route3540concatenated = OsmSharpRoute.Concatenate(route3545, route4540); OsmSharpRoute route3540 = router.Calculate(Vehicle.Car, point35resolved, point40resolved); // check if both routes are equal. Assert.AreEqual(route3540.Entries.Length, route3540concatenated.Entries.Length); for (int idx = 0; idx < route3540.Entries.Length; idx++) { Assert.AreEqual(route3540.Entries[idx].Distance, route3540concatenated.Entries[idx].Distance); Assert.AreEqual(route3540.Entries[idx].Latitude, route3540concatenated.Entries[idx].Latitude); Assert.AreEqual(route3540.Entries[idx].Longitude, route3540concatenated.Entries[idx].Longitude); Assert.AreEqual(route3540.Entries[idx].Time, route3540concatenated.Entries[idx].Time); Assert.AreEqual(route3540.Entries[idx].Type, route3540concatenated.Entries[idx].Type); Assert.AreEqual(route3540.Entries[idx].WayFromName, route3540concatenated.Entries[idx].WayFromName); // something that is allowed to be different in this case! // route3540.Entries[idx].Points != null // check sidestreets. if (route3540.Entries[idx].SideStreets != null && route3540.Entries[idx].SideStreets.Length > 0) { // check if the sidestreets represent the same information. for (int metricIdx = 0; metricIdx < route3540concatenated.Entries[idx].SideStreets.Length; metricIdx++) { Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].WayName, route3540concatenated.Entries[idx].SideStreets[metricIdx].WayName); Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].Latitude, route3540concatenated.Entries[idx].SideStreets[metricIdx].Latitude); Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].Longitude, route3540concatenated.Entries[idx].SideStreets[metricIdx].Longitude); } } else { Assert.IsTrue(route3540concatenated.Entries[idx].SideStreets == null || route3540concatenated.Entries[idx].SideStreets.Length == 0); } if (route3540.Entries[idx].Tags != null && route3540.Entries[idx].Tags.Length > 0) { // check if the Tags represent the same information. for (int metricIdx = 0; metricIdx < route3540concatenated.Entries[idx].Tags.Length; metricIdx++) { Assert.AreEqual(route3540.Entries[idx].Tags[metricIdx].Key, route3540concatenated.Entries[idx].Tags[metricIdx].Key); Assert.AreEqual(route3540.Entries[idx].Tags[metricIdx].Value, route3540concatenated.Entries[idx].Tags[metricIdx].Value); } } else { Assert.IsTrue(route3540concatenated.Entries[idx].Tags == null || route3540concatenated.Entries[idx].Tags.Length == 0); } Assert.AreEqual(route3540.Entries[idx].Distance, route3540concatenated.Entries[idx].Distance); } if (route3540.Tags != null && route3540.Tags.Length > 0) { for (int tagIdx = 0; tagIdx < route3540.Tags.Length; tagIdx++) { if (route3540.Tags[tagIdx].Key != "debug_route") { Assert.AreEqual(route3540.Tags[tagIdx].Key, route3540concatenated.Tags[tagIdx].Key); Assert.AreEqual(route3540.Tags[tagIdx].Value, route3540concatenated.Tags[tagIdx].Value); } } } else { Assert.IsTrue(route3540concatenated.Tags == null || route3540concatenated.Tags.Length == 0); } if (route3540.Metrics != null) { for (int metricIdx = 0; metricIdx < route3540concatenated.Entries.Length; metricIdx++) { Assert.AreEqual(route3540.Metrics[metricIdx].Key, route3540concatenated.Metrics[metricIdx].Key); Assert.AreEqual(route3540.Metrics[metricIdx].Value, route3540concatenated.Metrics[metricIdx].Value); } } else { Assert.IsNull(route3540concatenated.Metrics); } // remove the point in between, the only difference between the regular and the concatenated route. route3540concatenated.Entries[7].Points = null; // create the language generator. var languageGenerator = new LanguageTestGenerator(); // generate the instructions. var instructionGenerator = new InstructionGenerator(); List <Instruction> instructions = instructionGenerator.Generate(route3540, interpreter, languageGenerator); List <Instruction> instructionsConcatenated = instructionGenerator.Generate(route3540concatenated, interpreter, languageGenerator); Assert.AreEqual(instructions.Count, instructionsConcatenated.Count); for (int idx = 0; idx < instructions.Count; idx++) { Assert.AreEqual(instructions[idx].Location.Center, instructionsConcatenated[idx].Location.Center); Assert.AreEqual(instructions[idx].Text, instructionsConcatenated[idx].Text); } }
public void RoutingRegressionTest4() { OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); SimpleTagsIndex tags_index = new SimpleTagsIndex(); // do the data processing. DynamicGraphRouterDataSource <LiveEdge> memory_data = new DynamicGraphRouterDataSource <LiveEdge>(tags_index); LiveGraphOsmStreamWriter target_data = new LiveGraphOsmStreamWriter( memory_data, interpreter, memory_data.TagsIndex); XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource( Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.UnitTests.test_network.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); // build coordinates list of resolved points. List <GeoCoordinate> 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. OsmSharpRoute[][] referenceRoutes = new OsmSharpRoute[testPoints.Count][]; int[] permuationArray = new int[testPoints.Count]; for (int fromIdx = 0; fromIdx < testPoints.Count; fromIdx++) { permuationArray[fromIdx] = fromIdx; referenceRoutes[fromIdx] = new OsmSharpRoute[testPoints.Count]; for (int toIdx = 0; toIdx < testPoints.Count; toIdx++) { // create router from scratch. router = Router.CreateLiveFrom( memory_data, basic_router, interpreter); // resolve points. RouterPoint from = router.Resolve(Vehicle.Car, testPoints[fromIdx]); RouterPoint 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. PermutationEnumerable <int> enumerator = new PermutationEnumerable <int>( permuationArray); foreach (int[] permutation in enumerator) { // create router from scratch. router = Router.CreateLiveFrom(memory_data, basic_router, interpreter); // resolve in the order of the permutation. RouterPoint[] 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. OsmSharpRoute route = router.Calculate(Vehicle.Car, resolvedPoints[fromIdx], resolvedPoints[toIdx]); Assert.AreEqual(referenceRoutes[fromIdx][toIdx].TotalDistance, route.TotalDistance, 0.1); } } } }
public void RouteConcatenateTagsTest() { OsmSharpRoute route1 = new OsmSharpRoute(); route1.Vehicle = Vehicle.Car; RoutePointEntry route1entry1 = new RoutePointEntry(); route1entry1.Distance = 10; route1entry1.Latitude = -1; route1entry1.Longitude = -1; route1entry1.Metrics = null; route1entry1.Points = new RoutePoint[1]; route1entry1.Points[0] = new RoutePoint(); route1entry1.Points[0].Name = "TestPoint1"; route1entry1.Points[0].Tags = new RouteTags[1]; route1entry1.Points[0].Tags[0] = new RouteTags(); route1entry1.Points[0].Tags[0].Value = "TestValue1"; route1entry1.Points[0].Tags[0].Key = "TestKey1"; route1entry1.SideStreets = null; route1entry1.Tags = new RouteTags[1]; route1entry1.Tags[0] = new RouteTags(); route1entry1.Tags[0].Key = "highway"; route1entry1.Tags[0].Value = "residential"; route1entry1.Time = 10; route1entry1.Type = RoutePointEntryType.Start; route1entry1.WayFromName = string.Empty; route1entry1.WayFromNames = null; RoutePointEntry route1entry2 = new RoutePointEntry(); route1entry2.Distance = 10; route1entry2.Latitude = -1; route1entry2.Longitude = -1; route1entry2.Metrics = null; route1entry2.Points = new RoutePoint[1]; route1entry2.Points[0] = new RoutePoint(); route1entry2.Points[0].Name = "TestPoint2"; route1entry2.Points[0].Tags = new RouteTags[1]; route1entry2.Points[0].Tags[0] = new RouteTags(); route1entry2.Points[0].Tags[0].Value = "TestValue2"; route1entry1.Points[0].Tags[0].Key = "TestKey2"; route1entry2.SideStreets = null; route1entry2.Tags = new RouteTags[1]; route1entry2.Tags[0] = new RouteTags(); route1entry2.Tags[0].Key = "highway"; route1entry2.Tags[0].Value = "residential"; route1entry2.Time = 10; route1entry2.Type = RoutePointEntryType.Start; route1entry2.WayFromName = string.Empty; route1entry2.WayFromNames = null; route1.Entries = new RoutePointEntry[2]; route1.Entries[0] = route1entry1; route1.Entries[1] = route1entry2; OsmSharpRoute route2 = new OsmSharpRoute(); route2.Vehicle = Vehicle.Car; RoutePointEntry route2entry1 = new RoutePointEntry(); route2entry1.Distance = 10; route2entry1.Latitude = -1; route2entry1.Longitude = -1; route2entry1.Metrics = null; route2entry1.Points = new RoutePoint[1]; route2entry1.Points[0] = new RoutePoint(); route2entry1.Points[0].Name = "TestPoint3"; route2entry1.Points[0].Tags = new RouteTags[1]; route2entry1.Points[0].Tags[0] = new RouteTags(); route2entry1.Points[0].Tags[0].Value = "TestValue3"; route2entry1.Points[0].Tags[0].Key = "TestKey3"; route2entry1.SideStreets = null; route2entry1.Tags = new RouteTags[1]; route2entry1.Tags[0] = new RouteTags(); route2entry1.Tags[0].Key = "highway"; route2entry1.Tags[0].Value = "residential"; route2entry1.Time = 10; route2entry1.Type = RoutePointEntryType.Start; route2entry1.WayFromName = string.Empty; route2entry1.WayFromNames = null; RoutePointEntry route2entry2 = new RoutePointEntry(); route2entry2.Distance = 10; route2entry2.Latitude = -1; route2entry2.Longitude = -1; route2entry2.Metrics = null; route2entry2.Points = new RoutePoint[1]; route2entry2.Points[0] = new RoutePoint(); route2entry2.Points[0].Name = "TestPoint4"; route2entry2.Points[0].Tags = new RouteTags[1]; route2entry2.Points[0].Tags[0] = new RouteTags(); route2entry2.Points[0].Tags[0].Value = "TestValue4"; route2entry1.Points[0].Tags[0].Key = "TestKey4"; route2entry2.SideStreets = null; route2entry2.Tags = new RouteTags[1]; route2entry2.Tags[0] = new RouteTags(); route2entry2.Tags[0].Key = "highway"; route2entry2.Tags[0].Value = "residential"; route2entry2.Time = 10; route2entry2.Type = RoutePointEntryType.Start; route2entry2.WayFromName = string.Empty; route2entry2.WayFromNames = null; route2.Entries = new RoutePointEntry[2]; route2.Entries[0] = route2entry1; route2.Entries[1] = route2entry2; OsmSharpRoute concatenated = OsmSharpRoute.Concatenate(route1, route2); // test the result. Assert.IsNotNull(concatenated); Assert.IsNotNull(concatenated.Entries); Assert.AreEqual(route1.Vehicle, concatenated.Vehicle); Assert.AreEqual(3, concatenated.Entries.Length); Assert.AreEqual("TestPoint1", concatenated.Entries[0].Points[0].Name); Assert.AreEqual("TestPoint2", concatenated.Entries[1].Points[0].Name); Assert.AreEqual("TestPoint3", concatenated.Entries[1].Points[1].Name); Assert.AreEqual("TestPoint4", concatenated.Entries[2].Points[0].Name); }
/// <summary> /// Saves the route to a gpx file. /// </summary> /// <param name="file"></param> /// <param name="route"></param> internal static void Save(FileInfo file, OsmSharpRoute route) { XmlFileSource source = new XmlFileSource(file); GpxDocument output_document = new GpxDocument(source); gpxType output_gpx = new gpxType(); output_gpx.trk = new trkType[1]; // initialize all objects. List<wptType> segments = new List<wptType>(); trkType track = new trkType(); List<wptType> poi_gpx = new List<wptType>(); track.trkseg = new trksegType[1]; // ============= CONSTRUCT TRACK SEGMENT ============== trksegType track_segment = new trksegType(); // loop over all points. for (int idx = 0; idx < route.Entries.Length; idx++) { // get the current entry. RoutePointEntry entry = route.Entries[idx]; // ================== INITIALIZE A NEW SEGMENT IF NEEDED! ======== wptType waypoint; if (entry.Points != null) { // loop over all points and create a waypoint for each. for (int p_idx = 0; p_idx < entry.Points.Length; p_idx++) { RoutePoint point = entry.Points[p_idx]; waypoint = new wptType(); waypoint.lat = (decimal)point.Latitude; waypoint.lon = (decimal)point.Longitude; waypoint.name = point.Name; poi_gpx.Add(waypoint); } } // insert poi's. double longitde = entry.Longitude; double latitude = entry.Latitude; waypoint = new wptType(); waypoint.lat = (decimal)entry.Latitude; waypoint.lon = (decimal)entry.Longitude; segments.Add(waypoint); } // put the segment in the track. track_segment.trkpt = segments.ToArray(); track.trkseg[0] = track_segment; // set the track to the output. output_gpx.trk[0] = track; output_gpx.wpt = poi_gpx.ToArray(); // save the ouput. output_document.Gpx = output_gpx; output_document.Save(); }
static void MainTemp(string[] args) { NpgsqlConnection schemaConnection = new NpgsqlConnection(connPostGreSql); schemaConnection.Open(); var databaseName = "GIS"; DataTable dataTables = schemaConnection.GetSchema("Tables", new string[] { databaseName, "public", null, null }); foreach (DataRow rowTable in dataTables.Rows) { string tableName = rowTable["table_name"].ToString(); if (tableName != "geometry_collection") { continue; } DataTable dataColumns = schemaConnection.GetSchema("Columns", new string[] { databaseName, "public", tableName }); StringBuilder sb = new StringBuilder(); sb.AppendLine("public class " + tableName); sb.AppendLine("{"); sb.AppendLine("\tpublic " + tableName + "(){}"); foreach (DataRow rowColumn in dataColumns.Rows) { string columnName = rowColumn["column_name"].ToString(); string type = rowColumn["data_type"].ToString(); sb.AppendLine("\tpublic " + type + " " + columnName + " {get;set;}"); } sb.AppendLine("}"); sb.Replace("int8", "long"); sb.Replace("int4", "int"); sb.Replace("text", "string"); sb.Replace("oid", "long"); sb.Replace("numeric", "float"); sb.Replace("timestamp", "DateTime"); var def = sb.ToString(); } schemaConnection.Close(); return; var geometryRetrieval = geometryCollection.GetSingleObjectWithId("8", true, connPostGreSql); // testing GeometryCollection Aram.OSMParser.geometryCollection col = new Aram.OSMParser.geometryCollection(); // col.gisId = col.gisType = "dummy"; col.format = "txt"; col.largeObject = null; col.lastUpdate = DateTime.Now; col.latitude = 563213212; col.longitude = 171231231; col.name = "Test2"; col.pivot = new Aram.OSMParser.Vector3GaPS() { x = 1f, y = 2f, z = 3f }; col.version = new Aram.OSMParser.GaPSlabsVersion() { versionTitle = "development", major = 0, minor = 1 }; col.AddGeometryCollectionToDatabase(connPostGreSql, false); var bytes = File.ReadAllBytes(@"C:\Users\admgaming\Documents\Visual Studio 2012\Projects\GaPSLabs\AramOSMParser\OsmParserTestApplication\bin\Debug\Npgsql.xml"); col.largeObject = bytes; col.UpdateThisGeometryOnDatabase(connPostGreSql, true); var resultBytes = geometryCollection.GetLargeObject(col.largeObjectReference, connPostGreSql); File.WriteAllBytes("c:\\dummy", resultBytes); return; // ERROR: 42704: invalid large-object descriptor: 0 ?? // largeobject only works within a transaction. Use bytea as an alternative to large objects. // http://www.postgresql.org/message-id/002701c49d7e$0f059240$d604460a@zaphod NpgsqlConnection testConnection = new NpgsqlConnection(connPostGreSql); testConnection.Open(); NpgsqlTypes.LargeObjectManager lm = new NpgsqlTypes.LargeObjectManager(testConnection); var generatedLO = lm.Create(NpgsqlTypes.LargeObjectManager.READWRITE); // It must be within a transaction var TransWrite = testConnection.BeginTransaction(); LargeObject lo = lm.Open(generatedLO, LargeObjectManager.READWRITE); lo.Write(new byte[] { 0, 10, 50, 24 }); lo.Close(); TransWrite.Commit(); var TransRead = testConnection.BeginTransaction(); var loOid = lo.GetOID(); var readlo = lm.Open(loOid, LargeObjectManager.READWRITE); var resultLo = readlo.Read(readlo.Size()); lm.Delete(generatedLO); TransRead.Commit(); testConnection.Close(); return; OSMPostgresqlSource sourceVisTest = new OSMPostgresqlSource(connPostGreSql); var bounds = sourceVisTest.Bounds; return; GaPSlabsSimulationLibrary.SUMOSimulationFCD df = new GaPSlabsSimulationLibrary.SUMOSimulationFCD(); //df.LoadFromXML(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMO Packet Tester\Pedestrians.xml"); //df.LoadFromXML(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMO Packet Tester\bufferoutput - 500.xml"); ServiceGapslabsClient client2 = ServicePropertiesClass.GetGapslabsService(ServicePropertiesClass.ServiceUri); int id = client2.LoadSUMOFCDSimulationList(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMO Packet Tester\bufferoutput - 500.xml", "__POSTFIX"); //client.LoadSUMOFCDSimulation(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMO Packet Tester\bufferoutput - 500.xml"); while (!client2.IsSimulationLoadedList(id)) { } var vvvv = client2.GetTimestepAtList(6, id); var vvvv2 = client2.GetTimestepAtList(7, id); return; int size = 16777216; int[] aa = new int[size]; int[] bbb = new int[size]; int[] cccc = new int[size]; for (int i = 0; i < size; i++) { aa[i] = i; bbb[i] = i; } var apointer = aa.ToIntPtr <int[]>(); var bpointer = bbb.ToIntPtr <int[]>(); var cpointer = cccc.ToIntPtr <int[]>(); long MinGPU = 1000000; long MinCPU = 1000000; long MinCPUParallel = 100000; Stopwatch watch = new Stopwatch(); bool SkipCpu = false; GPU_WarmUp(); int TestCounter = 0; int blockSize = 16; while (TestCounter++ < 7) { watch.Restart(); GPU_Add(apointer, bpointer, cpointer, size, blockSize); watch.Stop(); Console.WriteLine("Total GPU" + "(" + blockSize + ")" + ": " + watch.ElapsedMilliseconds); if (watch.ElapsedMilliseconds < MinGPU) { MinGPU = watch.ElapsedMilliseconds; } blockSize *= 2; } Console.WriteLine("Minimum GPU was " + MinGPU); if (!SkipCpu) { TestCounter = 0; while (TestCounter++ < 10) { watch.Restart(); CPU_AddParallel(apointer, bpointer, cpointer, size); watch.Stop(); Console.WriteLine("Total CPU Parallel: " + watch.ElapsedMilliseconds); if (watch.ElapsedMilliseconds < MinCPUParallel) { MinCPUParallel = watch.ElapsedMilliseconds; } } Console.WriteLine("Minimum CPU was " + MinCPU); TestCounter = 0; while (TestCounter++ < 10) { watch.Restart(); CPU_Add(apointer, bpointer, cpointer, size); watch.Stop(); Console.WriteLine("Total CPU: " + watch.ElapsedMilliseconds); if (watch.ElapsedMilliseconds < MinCPU) { MinCPU = watch.ElapsedMilliseconds; } } Console.WriteLine("Minimum CPU was " + MinCPU); } //apointer.Free(); //bpointer.Free(); //cpointer.Free(); Console.ReadLine(); return; //GaPSlabsSimulationLibrary.SUMOSimulationFCD simulation = new GaPSlabsSimulationLibrary.SUMOSimulationFCD(); //simulation.LoadFromXML(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMOData\fcdoutput.xml"); //simulation.LoadFromCSV(@"C:\Users\admgaming\Desktop\Notable Software\iMobility\stkhlm-taxi.csv"); ServiceGapslabsClient client = ServicePropertiesClass.GetGapslabsService(ServicePropertiesClass.ServiceUri); //client.LoadSUMOFCDSimulation(@"C:\Users\admgaming\Desktop\Dropbox\GaPSLabs\SUMO Packet Tester\bufferoutput - 500.xml"); //while (!client.IsSimulationLoaded()) // Console.WriteLine("Loading..."); //Console.WriteLine("Load finished"); //Console.ReadLine(); //return; OSMPostgresqlSource sour = new OSMPostgresqlSource(connPostGreSql); // var TrafficNodes = sour.GetNodeIdsInBoundWithInfo(sour.Bounds, "traffic_signals"); var result = client.GetWayTags("134972364", connPostGreSql); BoundsWCF b = new BoundsWCF(); b.minlat = 59.32973; b.maxlat = 59.34481; b.minlon = 18.07556; b.maxlon = 18.1062; client.GetWayExtIdsInBound(connPostGreSql, b); client.InitializeRouter(connPostGreSql); OsmNodeWCF n1 = new OsmNodeWCF(); n1.id = "none"; n1.order = -1; n1.lat = 59.330957; n1.lon = 18.059285; //n1.lat = 59.374563; //n1.lon = 18.0135727; OsmNodeWCF n2 = new OsmNodeWCF(); n2.id = "none"; n2.order = -1; n2.lat = 59.33784; n2.lon = 18.088558; //n2.lat = 59.37225; //n2.lon = 18.00733; var RouterResult = client.RouteUsingDykstra(VehicleEnum.Car, n1, n2); OsmGeo.ShapeInterperter = new SimpleShapeInterpreter(); PostgreSQLSimpleSchemaSource source = new PostgreSQLSimpleSchemaSource(connPostGreSql); // keeps a memory-efficient version of the osm-tags. OsmTagsIndex tags_index = new OsmTagsIndex(); // creates a routing interpreter. (used to translate osm-tags into a routable network) OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); // create routing inter OsmSourceRouterDataSource routing_data = new OsmSourceRouterDataSource( interpreter, tags_index, source); // create the router object. //IRouter<RouterPoint> router = new Router<PreProcessedEdge>(routing_data, interpreter, // new DykstraRoutingPreProcessed(routing_data.TagsIndex)); IRouter <RouterPoint> router = new Router <PreProcessedEdge>(routing_data, interpreter , new DykstraRoutingPreProcessed(routing_data.TagsIndex)); // resolve both points; find the closest routable road. //RouterPoint point1 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(60.1674654,18.454302)); // RouterPoint point2 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(60.1673373,18.4541732)); // Working //RouterPoint point1 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(59.3863281, 18.0176665)); //RouterPoint point2 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(59.3675634, 18.0140447)); // Working RouterPoint point1 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(59.374563, 18.0135727)); RouterPoint point2 = router.Resolve(VehicleEnum.Car, new GeoCoordinate(59.37225, 18.00733)); //ArrayList al=new ArrayList(); //foreach (var en in Enum.GetValues(typeof(VehicleEnum))) //{ // al.Add(Enum.GetName(typeof(VehicleEnum), (VehicleEnum)en) + "=" + router.SupportsVehicle((VehicleEnum)en)); //} // calculate route. OsmSharpRoute route = router.Calculate(VehicleEnum.Car, point1, point2); route.SaveAsGpx(new FileInfo("route.gpx")); Console.ReadLine(); }
/// <summary> /// Processes a part of the route. /// </summary> /// <param name="route"></param> /// <param name="previous"></param> /// <param name="current"></param> /// <param name="next"></param> private void Process(OsmSharpRoute route, AggregatedRoutePoint previous, AggregatedRoutePoint current, AggregatedRoutePoint next) { // process the current point. if (current != null) { if (previous == null) { // point is always significant, it is the starting point! // create point. p = new AggregatedPoint(); p.Angle = null; p.ArcsNotTaken = null; p.Location = new GeoCoordinate(current.Entry.Latitude, current.Entry.Longitude); p.Points = new List <PointPoi>(); if (current.Entry.Points != null) { foreach (RoutePoint route_point in current.Entry.Points) { PointPoi poi = new PointPoi(); poi.Name = route_point.Name; poi.Tags = route_point.Tags.ConvertTo(); poi.Location = new GeoCoordinate(route_point.Latitude, route_point.Longitude); poi.Angle = null; // there is no previous point; no angle is specified. p.Points.Add(poi); } } previous_point = p; } else { // test if point is significant. AggregatedArc next_arc = this.CreateArcAndPoint(previous, current, next); // test if the next point is significant. if (previous_arc == null) { // this arc is always significant; it is the first arc. previous_point.Next = next_arc; previous_arc = next_arc; } else { // there is a previous arc; a test can be done if the current point is significant. if (this.IsSignificant(route.Vehicle, previous_arc, next_arc)) { // the arc is significant; append it to the previous arc. previous_arc.Next.Next = next_arc; previous_arc = next_arc; previous_point = next_arc.Next; } else { // if the arc is not significant compared to the previous one, the previous one can extend until the next point. // THIS IS THE AGGREGATION STEP! // add distance. Meter distance_to_next = previous_arc.Next.Location.DistanceReal(next_arc.Next.Location); previous_arc.Distance = previous_arc.Distance + distance_to_next; // set point. previous_arc.Next = next_arc.Next; } } } } }
internal static void Save(FileInfo file, OsmSharpRoute osmSharpRoute) { throw new NotImplementedException(); }