/// <summary>
/// Checks connectivity of all given points and returns only those that are valid.
/// </summary>
/// <param name="router"></param>
/// <param name="vehicle"></param>
/// <param name="resolvedPoints"></param>
/// <param name="weight"></param>
/// <returns></returns>
public static RouterPoint[] CheckConnectivityAndRemoveInvalid(
this Router router, Vehicle vehicle, RouterPoint[] resolvedPoints, float weight)
{
var connectedPoints = new List<RouterPoint>();
for (int idx = 0; idx < resolvedPoints.Length; idx++)
{
RouterPoint resolvedPoint = resolvedPoints[idx];
if (resolvedPoint != null &&
router.CheckConnectivity(vehicle, resolvedPoint, weight))
{ // the point is connected.
connectedPoints.Add(resolvedPoint);
}
}
return connectedPoints.ToArray();
}
/// <summary>
/// Called right after the contraction.
/// </summary>
/// <param name="vertex"></param>
/// <param name="edges"></param>
void pre_processor_OnAfterContractionEvent(uint vertex, List<Edge<CHEdgeData>> edges)
{
// get dictionary for vertex.
var pathsBeforeContraction = _pathsBeforeContraction[vertex];
// create a new CHRouter
var router = new CHRouter();
// calculate all the routes between the neighbours of the contracted vertex.
foreach (var from in edges)
{
// initialize the from-list.
var fromList = new PathSegmentVisitList();
fromList.UpdateVertex(new PathSegment<long>(from.Neighbour));
// initalize the from dictionary.
var fromDic = pathsBeforeContraction[from.Neighbour];
foreach (var to in edges)
{
// initialize the to-list.
var toList = new PathSegmentVisitList();
toList.UpdateVertex(new PathSegment<long>(to.Neighbour));
// calculate the route.
var route = router.Calculate(_data, _interpreter, Vehicle.Car, fromList, toList, double.MaxValue, null);
if ((fromDic[to.Neighbour] == null && route != null) ||
(fromDic[to.Neighbour] != null && route == null))
{ // the route match!
Assert.Fail("Routes are different before/after contraction!");
}
else if (fromDic[to.Neighbour] != null && route != null)
{
this.ComparePaths(fromDic[to.Neighbour], route);
}
}
}
if (_referenceRouter != null)
{ // do crazy verification!
var chRouter = Router.CreateCHFrom(_data, router, new OsmRoutingInterpreter());
// 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] = chRouter.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);
}
// limit tests to a fixed number.
int maxTestCount = 100;
int testEveryOther = (resolved.Length * resolved.Length) / maxTestCount;
testEveryOther = System.Math.Max(testEveryOther, 1);
// 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++)
{
int testNumber = fromIdx * resolved.Length + toIdx;
if (testNumber % testEveryOther == 0)
{
Route referenceRoute = _referenceRouter.Calculate(Vehicle.Car,
resolvedReference[fromIdx], resolvedReference[toIdx]);
Route route = chRouter.Calculate(Vehicle.Car,
resolved[fromIdx], resolved[toIdx]);
if (referenceRoute != null)
{
Assert.IsNotNull(referenceRoute);
Assert.IsNotNull(route);
this.CompareRoutes(referenceRoute, route);
}
}
}
}
}
_pathsBeforeContraction.Remove(vertex);
}
public void RoutingRegressionTest2()
{
var interpreter = new OsmRoutingInterpreter();
var tagsIndex = new TagsIndex();
// do the data processing.
var memoryData = new RouterDataSource<Edge>(new Graph<Edge>(), tagsIndex);
var targetData = new GraphOsmStreamTarget(memoryData, interpreter, tagsIndex);
var dataProcessorSource = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Routing.Test.data.test_network.osm"));
var sorter = new OsmStreamFilterSort();
sorter.RegisterSource(dataProcessorSource);
targetData.RegisterSource(sorter);
targetData.Pull();
var basicRouter = new Dykstra();
var router = Router.CreateFrom(memoryData, basicRouter, interpreter);
// build coordinates list of resolved points.
var testPoints = new List<GeoCoordinate>();
testPoints.Add(new GeoCoordinate(51.0582204, 3.7193524));
testPoints.Add(new GeoCoordinate(51.0582199, 3.7194002));
testPoints.Add(new GeoCoordinate(51.0581727, 3.7195833));
testPoints.Add(new GeoCoordinate(51.0581483, 3.7195553));
testPoints.Add(new GeoCoordinate(51.0581883, 3.7196617));
testPoints.Add(new GeoCoordinate(51.0581628, 3.7196889));
// 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.CreateFrom(
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.CreateFrom(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]);
// TODO: changed the resolve accuracy to .5m. Make sure this is more accurate in the future.
Assert.AreEqual(referenceRoutes[fromIdx][toIdx].TotalDistance, route.TotalDistance, 1);
}
}
}
}
/// <summary>
/// Calculates a route between one source and many target points.
/// </summary>
/// <returns></returns>
public double[] CalculateOneToManyWeight(Vehicle vehicle, RouterPoint source, RouterPoint[] targets, CancellationToken cancellationToken = new CancellationToken())
{
return this.CalculateOneToManyWeight(vehicle, source, targets, new HashSet<int>(), cancellationToken);
}
/// <summary>
/// Returns true if the given point is connected for a radius of at least the given weight.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="points"></param>
/// <param name="weight"></param>
/// <returns></returns>
public bool[] CheckConnectivity(Vehicle vehicle, RouterPoint[] points, float weight, CancellationToken cancellationToken = new CancellationToken())
{
if (vehicle == null) { throw new ArgumentNullException("vehicle"); }
if (points == null) { throw new ArgumentNullException("points"); }
foreach (var point in points)
{
if (vehicle.UniqueName != point.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, point.Vehicle.UniqueName));
}
}
return _router.CheckConnectivity(vehicle, points, weight, cancellationToken);
}
/// <summary>
/// Calculates a shortest route from a given point to any of the targets points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source">The source point.</param>
/// <param name="targets">The target point(s).</param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <returns></returns>
public Route CalculateToClosest(Vehicle vehicle, RouterPoint source, RouterPoint[] targets, float max)
{
return(_router.CalculateToClosest(vehicle, source, targets, max));
}
/// <summary>
/// Calculates all routes between many sources/targets.
/// </summary>
/// <returns></returns>
public double[][] CalculateManyToManyWeight(Vehicle vehicle, RouterPoint[] sources, RouterPoint[] targets, HashSet<int> invalidSet, CancellationToken cancellationToken = new CancellationToken())
{
if (vehicle == null) { throw new ArgumentNullException("vehicle"); }
if (sources == null) { throw new ArgumentNullException("source"); }
if (targets == null) { throw new ArgumentNullException("targets"); }
if (invalidSet == null) { throw new ArgumentNullException("invalidSet"); }
foreach (var source in sources)
{
foreach (var target in targets)
{
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
}
}
return _router.CalculateManyToManyWeight(vehicle, sources, targets, invalidSet, cancellationToken);
}
/// <summary>
/// Compares all routes against the reference router.
/// </summary>
public void TestCompareAll(string embedded_name)
{
// build the routing settings.
IRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
// get the osm data source.
IBasicRouterDataSource<PreProcessedEdge> data = this.BuildDykstraDataSource(interpreter, embedded_name);
// build the reference router.;
IRouter<RouterPoint> reference_router = this.BuildDykstraRouter(
this.BuildDykstraDataSource(interpreter, embedded_name), interpreter, new DykstraRoutingPreProcessed(data.TagsIndex));
// build the router to be tested.
IRouter<RouterPoint> router = this.BuildRouter(interpreter, embedded_name);
// loop over all nodes and resolve their locations.
RouterPoint[] resolved_reference = new RouterPoint[data.VertexCount - 1];
RouterPoint[] 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))
{
resolved_reference[idx - 1] = reference_router.Resolve(VehicleEnum.Car, new GeoCoordinate(latitude, longitude));
resolved[idx - 1] = router.Resolve(VehicleEnum.Car, new GeoCoordinate(latitude, longitude));
}
Assert.IsNotNull(resolved_reference[idx - 1]);
Assert.IsNotNull(resolved[idx - 1]);
Assert.AreEqual(resolved_reference[idx - 1].Location.Latitude,
resolved[idx - 1].Location.Latitude, 0.0001);
Assert.AreEqual(resolved_reference[idx - 1].Location.Longitude,
resolved[idx - 1].Location.Longitude, 0.0001);
}
// check all the routes having the same weight(s).
for (int from_idx = 0; from_idx < resolved.Length; from_idx++)
{
for (int to_idx = 0; to_idx < resolved.Length; to_idx++)
{
OsmSharpRoute reference_route = reference_router.Calculate(VehicleEnum.Car,
resolved_reference[from_idx], resolved_reference[to_idx]);
OsmSharpRoute route = router.Calculate(VehicleEnum.Car,
resolved[from_idx], resolved[to_idx]);
Assert.IsNotNull(reference_route);
Assert.IsNotNull(route);
Assert.AreEqual(reference_route.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>
/// Builds a route along all the given points.
/// </summary>
/// <param name="vehicle"></param>
/// <param name="resolved"></param>
/// <param name="coordinates"></param>
/// <returns></returns>
public Route BuildRoute(Vehicle vehicle, RouterPoint[] resolved, GeoCoordinate[] coordinates)
{
var routes = new Route[resolved.Length - 1];
for (int idx = 1; idx < resolved.Length; idx++)
{
if (resolved[idx - 1] == null || resolved[idx] == null)
{ // failed to resolve point(s), replace with a dummy route.
routes[idx - 1] = null;
}
else
{ // both points are resolved, calculate route.
var localRoute = _router.Calculate(vehicle, resolved[idx - 1], resolved[idx]);
if (localRoute != null)
{ // route was found.
routes[idx - 1] = localRoute;
}
else
{ // failed to calculate route, replace with a dummy route.
routes[idx - 1] = null;
}
}
}
// add dummy routes in place of routes that have not been found.
for (int idx = 0; idx < routes.Length; idx++)
{
if (routes[idx] == null)
{ // the route is null here.
GeoCoordinate coordinate1, coordinate2;
if (idx > 0 &&
routes[idx - 1] != null)
{ // there is a route before this one, take the last point of it as start of this one.
coordinate1 = new GeoCoordinate(
routes[idx - 1].Segments[routes[idx - 1].Segments.Length - 1].Latitude,
routes[idx - 1].Segments[routes[idx - 1].Segments.Length - 1].Longitude);
}
else
{ // take the coordinate itself.
coordinate1 = coordinates[idx];
}
if (routes.Length > idx + 1 &&
routes[idx + 1] != null)
{ // there is a route before this one, take the last point of it as start of this one.
coordinate2 = new GeoCoordinate(
routes[idx + 1].Segments[0].Latitude,
routes[idx + 1].Segments[0].Longitude);
}
else
{ // take the coordinate itself.
coordinate2 = coordinates[idx + 1];
}
// build the dummy route.
routes[idx] = this.BuildDummyRoute(vehicle, coordinate1, coordinate2);
}
}
// concatenate the routes.
var route = routes[0];
for (int idx = 1; idx < routes.Length; idx++)
{
route = Route.Concatenate(route, routes[idx]);
}
return route;
}
/// <summary>
/// Returns true if the given point is connected for a radius of at least the given weight.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="point"></param>
/// <param name="weight"></param>
/// <returns></returns>
public bool CheckConnectivity(Vehicle vehicle, RouterPoint point, float weight)
{
return(_router.CheckConnectivity(vehicle, point, weight));
}
/// <summary>
/// Compares all routes against the reference router.
/// </summary>
public void TestCompareAll(string embeddedName, bool contract)
{
// build the routing settings.
IOsmRoutingInterpreter 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, contract);
// 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);
}
// limit tests to a fixed number.
int maxTestCount = 1000;
int testEveryOther = (resolved.Length * resolved.Length) / maxTestCount;
testEveryOther = System.Math.Max(testEveryOther, 1);
// 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++)
{
int testNumber = fromIdx * resolved.Length + toIdx;
if (testNumber % testEveryOther == 0)
{
Route referenceRoute = referenceRouter.Calculate(Vehicle.Car,
resolvedReference[fromIdx], resolvedReference[toIdx]);
Route route = router.Calculate(Vehicle.Car,
resolved[fromIdx], resolved[toIdx]);
if (referenceRoute != null)
{
Assert.IsNotNull(referenceRoute);
Assert.IsNotNull(route);
this.CompareRoutes(referenceRoute, route);
}
}
}
}
}
/// <summary>
/// Returns all points located at a given weight (distance/time) from the orgin.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="orgine"></param>
/// <param name="weight"></param>
/// <returns></returns>
public HashSet <GeoCoordinate> CalculateRange(Vehicle vehicle, RouterPoint orgine, float weight)
{
return(_router.CalculateRange(vehicle, orgine, weight));
}
/// <summary>
/// Calculates a route between one source and many target points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <returns></returns>
public double[] CalculateOneToManyWeight(Vehicle vehicle, RouterPoint source, RouterPoint[] targets)
{
return(_router.CalculateOneToManyWeight(vehicle, source, targets));
}
/// <summary>
/// Calculates the weight between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public double CalculateWeight(Vehicle vehicle, RouterPoint source, RouterPoint target)
{
return(_router.CalculateWeight(vehicle, source, target));
}
/// <summary>
/// Returns all points located at a given weight (distance/time) from the orgin.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="orgine"></param>
/// <param name="weight"></param>
/// <returns></returns>
public HashSet<GeoCoordinate> CalculateRange(Vehicle vehicle, RouterPoint orgine, float weight)
{
if (vehicle.UniqueName != orgine.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, orgine.Vehicle.UniqueName));
}
return _router.CalculateRange(vehicle, orgine, weight);
}
/// <summary>
/// Builds a route along all the given point in the order given by the tsp solution.
/// </summary>
/// <returns></returns>
public Route BuildRoute(Vehicle vehicle, RouterPoint[] resolved, GeoCoordinate[] coordinates, OsmSharp.Logistics.Routes.IRoute tspSolution, bool isRound)
{
// sort resolved and coordinates.
var solution = tspSolution.ToArray();
var size = isRound ? solution.Length + 1 : solution.Length;
var sortedResolved = new RouterPoint[size];
var sortedCoordinates = new GeoCoordinate[size];
for (int idx = 0; idx < solution.Length; idx++)
{
sortedResolved[idx] = resolved[solution[idx]];
sortedCoordinates[idx] = coordinates[solution[idx]];
}
// make round if needed.
if (isRound)
{
sortedResolved[size - 1] = sortedResolved[0];
sortedCoordinates[size - 1] = sortedCoordinates[0];
}
// build the route.
return this.BuildRoute(vehicle, sortedResolved, sortedCoordinates);
}
/// <summary>
/// Calculates the weight between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public double CalculateWeight(Vehicle vehicle, RouterPoint source, RouterPoint target)
{
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
return _router.CalculateWeight(vehicle, source, target);
}
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)
{
Route route = _router.Calculate(Vehicle.Car,
_point1, _point2);
if (route != null)
{
_routeLayer.Clear();
_routeLayer.AddRoute(route);
}
}
}
}
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);
LiveGraphOsmStreamTarget target_data = new LiveGraphOsmStreamTarget(
memory_data, interpreter, memory_data.TagsIndex);
XmlOsmStreamSource data_processor_source = new XmlOsmStreamSource(
Assembly.GetExecutingAssembly().GetManifestResourceStream("OsmSharp.Test.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.0582204, 3.7193524));
testPoints.Add(new GeoCoordinate(51.0582199, 3.7194002));
//testPoints.Add(new GeoCoordinate(51.0582178, 3.7195025));
testPoints.Add(new GeoCoordinate(51.0581727, 3.7195833));
testPoints.Add(new GeoCoordinate(51.0581483, 3.7195553));
//testPoints.Add(new GeoCoordinate(51.0581219, 3.7195231));
//testPoints.Add(new GeoCoordinate(51.0580965, 3.7194918));
testPoints.Add(new GeoCoordinate(51.0581883, 3.7196617));
testPoints.Add(new GeoCoordinate(51.0581628, 3.7196889));
// build a matrix of routes between all points.
Route[][] referenceRoutes = new Route[testPoints.Count][];
int[] 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(
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)
{
//int[] permutation = new int[] { 5, 0, 1, 2, 4, 3, 6, 7, 8 };
//// incrementally resolve points.
//// create router from scratch.
//router = new Router<SimpleWeighedEdge>(memory_data, interpreter, basic_router);
//// resolve in the order of the permutation.
//RouterPoint[] resolvedPoints = new RouterPoint[permutation.Length];
//resolvedPoints[permutation[0]] = router.Resolve(VehicleEnum.Car, testPoints[permutation[0]]);
//for (int idx = 1; idx < permutation.Length; idx++)
//{
// resolvedPoints[permutation[idx]] = router.Resolve(VehicleEnum.Car, testPoints[permutation[idx]]);
// for (int fromIdx = 0; fromIdx <= idx; fromIdx++)
// {
// for (int toIdx = 0; toIdx <= idx; toIdx++)
// {
// // calculate route.
// OsmSharpRoute route = router.Calculate(VehicleEnum.Car,
// resolvedPoints[permutation[fromIdx]], resolvedPoints[permutation[toIdx]]);
// Assert.AreEqual(referenceRoutes[permutation[fromIdx]][permutation[toIdx]].TotalDistance,
// route.TotalDistance, 0.1);
// }
// }
//}
// 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.
Route route = router.Calculate(Vehicle.Car, resolvedPoints[fromIdx], resolvedPoints[toIdx]);
Assert.AreEqual(referenceRoutes[fromIdx][toIdx].TotalDistance, route.TotalDistance, 0.1);
}
}
}
}
/// <summary>
/// Calculates a route between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source">The source point.</param>
/// <param name="target">The target point.</param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <returns></returns>
public Route Calculate(Vehicle vehicle, RouterPoint source, RouterPoint target, float max)
{
return _router.Calculate(vehicle, source, target, max);
}
/// <summary>
/// Calculates all routes between one source and many target points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <param name="geometryOnly">Flag to return .</param>
/// <param name="cancellationToken">An optional cancellation token.</param>
/// <returns></returns>
public Route[] CalculateOneToMany(Vehicle vehicle, RouterPoint source, RouterPoint[] targets, float max = float.MaxValue, bool geometryOnly = false, CancellationToken cancellationToken = new CancellationToken())
{
if (vehicle == null) { throw new ArgumentNullException("vehicle"); }
if (source == null) { throw new ArgumentNullException("source"); }
if (targets == null) { throw new ArgumentNullException("targets"); }
foreach (var target in targets)
{
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
}
return _router.CalculateOneToMany(vehicle, source, targets, max, geometryOnly, cancellationToken);
}
/// <summary>
/// Calculates all routes between many sources/targets.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="sources"></param>
/// <param name="targets"></param>
/// <returns></returns>
public Route[][] CalculateManyToMany(Vehicle vehicle, RouterPoint[] sources, RouterPoint[] targets)
{
return _router.CalculateManyToMany(vehicle, sources, targets);
}
/// <summary>
/// Calculates the weight between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="cancellationToken">An optional cancellation token.</param>
/// <returns></returns>
public double CalculateWeight(Vehicle vehicle, RouterPoint source, RouterPoint target, CancellationToken cancellationToken = new CancellationToken())
{
if (vehicle == null) { throw new ArgumentNullException("vehicle"); }
if (source == null) { throw new ArgumentNullException("source"); }
if (target == null) { throw new ArgumentNullException("target"); }
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
return _router.CalculateWeight(vehicle, source, target, cancellationToken);
}
/// <summary>
/// Calculates all routes between one source and many target points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <returns></returns>
public Route[] CalculateOneToMany(Vehicle vehicle, RouterPoint source, RouterPoint[] targets)
{
return _router.CalculateOneToMany(vehicle, source, targets);
}
public void RoutingSerializationCHSortedRoutingComparisonTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
interpreter,
Vehicle.Car);
// create serializer.
var routingSerializer = new OsmSharp.Routing.CH.Serialization.Sorted.CHEdgeDataDataSourceSerializer(true);
// serialize/deserialize.
TagsCollectionBase metaData = new TagsCollection();
metaData.Add("some_key", "some_value");
byte[] byteArray;
using (var stream = new MemoryStream())
{
try
{
routingSerializer.Serialize(stream, original, metaData);
byteArray = stream.ToArray();
}
catch (Exception)
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
throw;
}
}
IBasicRouterDataSource<CHEdgeData> deserializedVersion =
routingSerializer.Deserialize(new MemoryStream(byteArray), out metaData);
Assert.AreEqual(original.TagsIndex.Get(0), deserializedVersion.TagsIndex.Get(0));
Assert.IsTrue(deserializedVersion.SupportsProfile(Vehicle.Car));
Assert.IsFalse(deserializedVersion.SupportsProfile(Vehicle.Bicycle));
// create reference router.
original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
interpreter,
Vehicle.Car);
var basicRouterOriginal = new CHRouter();
Router referenceRouter = Router.CreateCHFrom(
original, basicRouterOriginal, interpreter);
// try to do some routing on the deserialized version.
var basicRouter = new CHRouter();
Router router = Router.CreateCHFrom(
deserializedVersion, basicRouter, interpreter);
// loop over all nodes and resolve their locations.
var resolvedReference = new RouterPoint[original.VertexCount];
var resolved = new RouterPoint[original.VertexCount];
for (uint idx = 1; idx < original.VertexCount + 1; idx++)
{ // resolve each vertex.
float latitude, longitude;
if (original.GetVertex(idx, out latitude, out longitude))
{
resolvedReference[idx - 1] = referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
resolved[idx - 1] = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
}
Assert.IsNotNull(resolvedReference[idx - 1]);
Assert.IsNotNull(resolved[idx - 1]);
Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude,
resolved[idx - 1].Location.Latitude, 0.0001);
Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude,
resolved[idx - 1].Location.Longitude, 0.0001);
}
// // check all the routes having the same weight(s).
// for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++)
// {
// for (int toIdx = 0; toIdx < resolved.Length; toIdx++)
// {
// OsmSharpRoute referenceRoute = referenceRouter.Calculate(VehicleEnum.Car,
// resolvedReference[fromIdx], resolvedReference[toIdx]);
// OsmSharpRoute route = router.Calculate(VehicleEnum.Car,
// resolved[fromIdx], resolved[toIdx]);
// Assert.IsNotNull(referenceRoute);
// Assert.IsNotNull(route);
// //Assert.AreEqual(referenceRoute.TotalDistance, route.TotalDistance, 0.1);
// // TODO: meta data is missing in some CH routing; see issue
// //Assert.AreEqual(reference_route.TotalTime, route.TotalTime, 0.0001);
// }
// }
}
/// <summary>
/// Calculates a route between one source and many target points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="targets"></param>
/// <returns></returns>
public double[] CalculateOneToManyWeight(Vehicle vehicle, RouterPoint source, RouterPoint[] targets)
{
return _router.CalculateOneToManyWeight(vehicle, source, targets);
}
public void TestCHDataSourceTopologicalSortTest()
{
const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm";
// creates a new interpreter.
var interpreter = new OsmRoutingInterpreter();
// do the data processing.
var original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
interpreter,
Vehicle.Car);
var sortedGraph = CHEdgeDataDataSourceSerializer.SortGraph(original);
original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource(
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(embeddedString)),
interpreter,
Vehicle.Car);
var basicRouterOriginal = new CHRouter();
Router referenceRouter = Router.CreateCHFrom(
original, basicRouterOriginal, interpreter);
// try to do some routing on the deserialized version.
var basicRouter = new CHRouter();
Router router = Router.CreateCHFrom(
new DynamicGraphRouterDataSource<CHEdgeData>(sortedGraph, original.TagsIndex), basicRouter, interpreter);
// loop over all nodes and resolve their locations.
var resolvedReference = new RouterPoint[original.VertexCount];
var resolved = new RouterPoint[original.VertexCount];
for (uint idx = 1; idx < original.VertexCount + 1; idx++)
{ // resolve each vertex.
float latitude, longitude;
if (original.GetVertex(idx, out latitude, out longitude))
{
resolvedReference[idx - 1] = referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
resolved[idx - 1] = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
}
Assert.IsNotNull(resolvedReference[idx - 1]);
Assert.IsNotNull(resolved[idx - 1]);
//Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude,
// resolved[idx - 1].Location.Latitude, 0.0001);
//Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude,
// resolved[idx - 1].Location.Longitude, 0.0001);
}
//// check all the routes having the same weight(s).
//for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++)
//{
// for (int toIdx = 0; toIdx < resolved.Length; toIdx++)
// {
// 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.1);
// // TODO: meta data is missing in some CH routing; see issue
// //Assert.AreEqual(reference_route.TotalTime, route.TotalTime, 0.0001);
// }
//}
}
/// <summary>
/// Returns all points located at a given weight (distance/time) from the orgin.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="orgine"></param>
/// <param name="weight"></param>
/// <returns></returns>
public HashSet<GeoCoordinate> CalculateRange(Vehicle vehicle, RouterPoint orgine, float weight)
{
return _router.CalculateRange(vehicle, orgine, weight);
}
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);
}
}
}
}
/// <summary>
/// Calculates a shortest route from a given point to any of the targets points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source">The source point.</param>
/// <param name="targets">The target point(s).</param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <returns></returns>
public Route CalculateToClosest(Vehicle vehicle, RouterPoint source, RouterPoint[] targets, float max)
{
return _router.CalculateToClosest(vehicle, source, targets, max);
}
/// <summary>
/// Calculates all routes between many sources/targets.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="sources"></param>
/// <param name="targets"></param>
/// <returns></returns>
public double[][] CalculateManyToManyWeight(Vehicle vehicle, RouterPoint[] sources, RouterPoint[] targets)
{
foreach (var source in sources)
{
foreach (var target in targets)
{
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
}
}
return _router.CalculateManyToManyWeight(vehicle, sources, targets);
}
/// <summary>
/// Calculates the weight between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public double CalculateWeight(Vehicle vehicle, RouterPoint source, RouterPoint target)
{
return _router.CalculateWeight(vehicle, source, target);
}
/// <summary>
/// Calculates a shortest route from a given point to any of the targets points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source">The source point.</param>
/// <param name="targets">The target point(s).</param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <param name="geometryOnly">Flag to return .</param>
/// <returns></returns>
public Route CalculateToClosest(Vehicle vehicle, RouterPoint source, RouterPoint[] targets, float max = float.MaxValue, bool geometryOnly = false)
{
foreach (var target in targets)
{
if (source.Vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Not all vehicle profiles match, {0} and {1} are given, expecting identical profiles.",
source.Vehicle.UniqueName, target.Vehicle.UniqueName));
}
if (vehicle.UniqueName != target.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, target.Vehicle.UniqueName));
}
}
return _router.CalculateToClosest(vehicle, source, targets, max);
}
/// <summary>
/// Returns true if the given point is connected for a radius of at least the given weight.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="point"></param>
/// <param name="weight"></param>
/// <returns></returns>
public bool[] CheckConnectivity(Vehicle vehicle, RouterPoint[] point, float weight)
{
return _router.CheckConnectivity(vehicle, point, weight);
}
/// <summary>
/// Returns true if the given point is connected for a radius of at least the given weight.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="points"></param>
/// <param name="weight"></param>
/// <returns></returns>
public bool[] CheckConnectivity(Vehicle vehicle, RouterPoint[] points, float weight)
{
foreach (var point in points)
{
if (vehicle.UniqueName != point.Vehicle.UniqueName)
{ // vehicles are different.
throw new ArgumentException(string.Format("Given vehicle profile does not match resolved points, {0} and {1} are given, expecting identical profiles.",
vehicle.UniqueName, point.Vehicle.UniqueName));
}
}
return _router.CheckConnectivity(vehicle, points, weight);
}
/// <summary>
/// Calculates a route between two given points.
/// </summary>
/// <param name="vehicle">The vehicle profile.</param>
/// <param name="source">The source point.</param>
/// <param name="target">The target point.</param>
/// <param name="max">The maximum weight to stop the calculation.</param>
/// <returns></returns>
public Route Calculate(Vehicle vehicle, RouterPoint source, RouterPoint target, float max)
{
return(_router.Calculate(vehicle, source, target, max));
}
