Example #1
0
        /// <summary>
        /// Test if routes between resolved nodes are correctly calculated.
        ///
        /// 20----x----21----x----16
        /// </summary>
        protected void DoTestResolveCase1()
        {
            // initialize data.
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data = this.BuildData(interpreter, "OsmSharp.Test.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.5);
            var      vertex2021 = new GeoCoordinate(point[1], point[0]);

            point = vertex21 + ((vertex16 - vertex21) * 0.5);
            var vertex2116 = new GeoCoordinate(point[1], point[0]);

            // calculate route.
            IRoutingAlgorithm <TEdgeData> basicRouter = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(data, interpreter, basicRouter);

            Route route = router.Calculate(Vehicle.Car,
                                           router.Resolve(Vehicle.Car, vertex2021),
                                           router.Resolve(Vehicle.Car, vertex2116));

            Assert.AreEqual(3, route.Segments.Length);
            Assert.AreEqual(vertex2021.Latitude, route.Segments[0].Latitude, 0.0001);
            Assert.AreEqual(vertex2021.Longitude, route.Segments[0].Longitude, 0.0001);

            Assert.AreEqual(vertex21.Latitude, route.Segments[1].Latitude, 0.0001);
            Assert.AreEqual(vertex21.Longitude, route.Segments[1].Longitude, 0.0001);

            Assert.AreEqual(vertex2116.Latitude, route.Segments[2].Latitude, 0.0001);
            Assert.AreEqual(vertex2116.Longitude, route.Segments[2].Longitude, 0.0001);
        }
Example #2
0
 /// <summary>
 /// Builds a router.
 /// </summary>
 /// <returns></returns>
 public override Router BuildRouter(IBasicRouterDataSource <LiveEdge> data,
                                    IOsmRoutingInterpreter interpreter,
                                    IRoutingAlgorithm <LiveEdge> basicRouter)
 {
     // initialize the router.
     return(Router.CreateLiveFrom(data, basicRouter, interpreter));
 }
Example #3
0
        /// <summary>
        /// Tests if the many-to-many weights are the same as the point-to-point weights.
        /// </summary>
        protected void DoTestManyToMany1()
        {
            var interpreter = new OsmRoutingInterpreter();
            IBasicRouterDataSource <EdgeData> data        = this.BuildData(interpreter);
            IRoutingAlgorithm <EdgeData>      basicRouter = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(
                data, interpreter, basicRouter);
            var resolvedPoints = new RouterPoint[3];

            resolvedPoints[0] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229));
            resolvedPoints[1] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801));
            resolvedPoints[2] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0581001, 3.7200612));

            double[][] weights = router.CalculateManyToManyWeight(Vehicle.Car, resolvedPoints, resolvedPoints);

            for (int x = 0; x < weights.Length; x++)
            {
                for (int y = 0; y < weights.Length; y++)
                {
                    double manyToMany   = weights[x][y];
                    double pointToPoint = router.CalculateWeight(Vehicle.Car, resolvedPoints[x], resolvedPoints[y]);

                    Assert.AreEqual(pointToPoint, manyToMany);
                }
            }
        }
Example #4
0
        /// <summary>
        /// Creates a router using live interpreted edges.
        /// </summary>
        /// <param name="data">The data to route on.</param>
        /// <param name="basicRouter">A custom routing implementation.</param>
        /// <param name="interpreter">The routing interpreter.</param>
        /// <returns></returns>
        public static Router CreateCHFrom(IBasicRouterDataSource <CHEdgeData> data, IRoutingAlgorithm <CHEdgeData> basicRouter,
                                          IRoutingInterpreter interpreter)
        {
            // creates the live edge router.
            var liveEdgeRouter = new TypedRouterCHEdge(
                data, interpreter, basicRouter);

            return(new Router(liveEdgeRouter)); // create the actual router.
        }
Example #5
0
        public HalfFaultMetrics(Graph graph, IRoutingAlgorithm algorithm, int seed, int iterations)
        {
            this.graph      = graph;
            this.algorithm  = algorithm;
            random          = new Random(seed);
            iterationsTotal = iterations;

            InitHops(graph.Count);
        }
Example #6
0
        /// <summary>
        /// Creates a router using interpreted edges.
        /// </summary>
        /// <param name="data">The data to route on.</param>
        /// <param name="basicRouter">A custom routing implementation.</param>
        /// <param name="interpreter">The routing interpreter.</param>
        /// <returns></returns>
        public static Router CreateCHFrom(IRoutingAlgorithmData <CHEdgeData> data, IRoutingAlgorithm <CHEdgeData> basicRouter,
                                          IRoutingInterpreter interpreter)
        {
            // creates the edge router.
            var typedRouter = new TypedRouterCHEdge(
                data, interpreter, basicRouter);

            return(new Router(typedRouter)); // create the actual router.
        }
Example #7
0
        /// <summary>
        /// Tests that a router actually finds the shortest route.
        /// </summary>
        protected void DoTestShortestResolved2()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data        = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <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

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(5, route.Segments.Length);
        }
Example #8
0
        /// <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.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <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));

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(10, route.Segments.Length);
        }
Example #9
0
        /// <summary>
        /// Tests that a router actually finds the shortest route.
        /// </summary>
        protected void DoTestShortest2()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data        = this.BuildData(interpreter, "OsmSharp.Routing.Test.data.test_network.osm");
            IRoutingAlgorithm <TEdgeData>     basicRouter = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(
                data, interpreter, basicRouter);
            RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0579235, 3.7199811));
            RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229));

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(6, route.Segments.Length);
        }
Example #10
0
        /// <summary>
        /// Tests that a router actually finds the shortest route.
        /// </summary>
        protected void DoTestShortest5()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data         = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <TEdgeData>     basic_router = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(
                data, interpreter, basic_router);
            RouterPoint source = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801));
            RouterPoint target = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0581001, 3.7200612));

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(7, route.Segments.Length);
        }
Example #11
0
        /// <summary>
        /// Tests that a router actually finds the shortest route.
        /// </summary>
        protected void DoTestShortestAgainstDirection()
        {
            var interpreter = new OsmRoutingInterpreter();
            IBasicRouterDataSource <EdgeData> data        = this.BuildData(interpreter);
            IRoutingAlgorithm <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

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(6, route.Segments.Length);

            float latitude, longitude;

            data.GetVertex(10, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[0].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[0].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);

            data.GetVertex(12, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[1].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[1].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[1].Type);

            data.GetVertex(13, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[2].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[2].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[2].Type);

            data.GetVertex(14, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[3].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[3].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[3].Type);

            data.GetVertex(15, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[4].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[4].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[4].Type);

            data.GetVertex(19, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[5].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[5].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Stop, route.Segments[5].Type);
        }
        /// <summary>
        /// Tests that a router actually finds the shortest route.
        /// </summary>
        /// <param name="vehicle"></param>
        /// <param name="access_tags"></param>
        protected void DoTestShortestWithoutAccess(Vehicle vehicle, List <KeyValuePair <string, string> > access_tags)
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <EdgeData> data        = this.BuildData(interpreter, vehicle, access_tags);
            IRoutingAlgorithm <EdgeData>     basicRouter = this.BuildBasicRouter(data, vehicle);
            Router router = this.BuildRouter(
                data, interpreter, basicRouter);
            RouterPoint source = router.Resolve(vehicle, new GeoCoordinate(51.0579530, 3.7196168)); // -56
            RouterPoint target = router.Resolve(vehicle, new GeoCoordinate(51.0582205, 3.7192647)); // -52

            Route route = router.Calculate(vehicle, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(6, route.Segments.Length);

            float latitude, longitude;

            data.GetVertex(10, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[0].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[0].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);

            data.GetVertex(12, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[1].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[1].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[1].Type);

            data.GetVertex(13, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[2].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[2].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[2].Type);

            data.GetVertex(14, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[3].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[3].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[3].Type);

            data.GetVertex(15, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[4].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[4].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Along, route.Segments[4].Type);

            data.GetVertex(19, out latitude, out longitude);
            Assert.AreEqual(latitude, route.Segments[5].Latitude, 0.00001);
            Assert.AreEqual(longitude, route.Segments[5].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Stop, route.Segments[5].Type);
        }
Example #13
0
 public static string AlgorithmToString(IRoutingAlgorithm algorithm)
 {
     if (algorithm is DijkstraRouting)
     {
         return(DijkstraRouting.Name);
     }
     if (algorithm is NoCahceDijkstraRouting)
     {
         return(NoCahceDijkstraRouting.Name);
     }
     if (algorithm is GreedyPromotionRouting)
     {
         return(GreedyPromotionRouting.Name);
     }
     if (algorithm is AdvancedGreedyPromotionRouting)
     {
         return(AdvancedGreedyPromotionRouting.Name);
     }
     if (algorithm is RestrictedGreedyPromotionRouting)
     {
         return(RestrictedGreedyPromotionRouting.Name);
     }
     if (algorithm is RestrictedGreedyPromotion2Routing)
     {
         return(RestrictedGreedyPromotion2Routing.Name);
     }
     if (algorithm is BrutCoordsRouting)
     {
         return(BrutCoordsRouting.Name);
     }
     if (algorithm is HotPotatoRouting)
     {
         return(HotPotatoRouting.Name);
     }
     if (algorithm is OFTRouting)
     {
         return(OFTRouting.Name);
     }
     if (algorithm is CirculantGreedyPromotionRouting)
     {
         return(CirculantGreedyPromotionRouting.Name);
     }
     else
     {
         return("None");
     }
 }
Example #14
0
        /// <summary>
        /// Test if the resolving of nodes returns those same nodes.
        ///
        /// (does not work on a lazy loading data source!)
        /// </summary>
        protected void DoTestResolveAllNodes()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data        = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <TEdgeData>     basicRouter = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(
                data, interpreter, basicRouter);

            for (int idx = 1; idx < data.VertexCount; idx++)
            {
                float latitude, longitude;
                if (data.GetVertex((uint)idx, out latitude, out longitude))
                {
                    var point = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude));
                    Assert.AreEqual(idx, (point as RouterPoint).Id);
                }
            }
        }
Example #15
0
        /// <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,
                                        IOsmRoutingInterpreter interpreter)
        {
            IBasicRouterDataSource <TEdgeData> data =
                this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_segments.osm", vehicle);
            IRoutingAlgorithm <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)
            {
                Route route = router.Calculate(vehicle, resolvedFrom, resolvedTo);
                return(route != null);
            }
            return(false);
        }
        public StressMetrics(Graph graph, IRoutingAlgorithm algorithm, int seed)
        {
            this.graph     = graph;
            this.algorithm = algorithm;
            lengths        = new double[graph.Count, graph.Count];
            random         = new Random(seed);

            InitHops(graph.Count);

            for (int i = 0; i < graph.Enabled.Length; i++)
            {
                graph.Enabled[i] = true;
            }
            for (int s = 0; s < graph.Count; s++)
            {
                for (int d = 0; d < graph.Count; d++)
                {
                    lengths[s, d] = 0;
                }
            }
            algorithm.Refresh();
        }
Example #17
0
        /// <summary>
        /// Test if the connectivity test succeed/fail.
        /// </summary>
        protected void DoTestConnectivity1()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data        = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <TEdgeData>     basicRouter = this.BuildBasicRouter(data);
            Router router = this.BuildRouter(
                data, interpreter, basicRouter);
            var resolvedPoints = new RouterPoint[3];

            resolvedPoints[0] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0578532, 3.7192229));
            resolvedPoints[1] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0576193, 3.7191801));
            resolvedPoints[2] = router.Resolve(Vehicle.Car, new GeoCoordinate(51.0581001, 3.7200612));

            // test connectivity succes.
            Assert.IsTrue(router.CheckConnectivity(Vehicle.Car, resolvedPoints[0], 5));
            //Assert.IsTrue(router.CheckConnectivity(VehicleEnum.Car, resolved_points[1], 5));
            Assert.IsTrue(router.CheckConnectivity(Vehicle.Car, resolvedPoints[2], 5));

            // test connectivity failiure.
            Assert.IsFalse(router.CheckConnectivity(Vehicle.Car, resolvedPoints[0], 1000));
            Assert.IsFalse(router.CheckConnectivity(Vehicle.Car, resolvedPoints[1], 1000));
            Assert.IsFalse(router.CheckConnectivity(Vehicle.Car, resolvedPoints[2], 1000));
        }
Example #18
0
        /// <summary>
        /// Test if routes between two resolved nodes are correctly calculated.
        /// </summary>
        protected void DoTestResolveBetweenTwo()
        {
            // initialize data.
            var interpreter = new OsmRoutingInterpreter();
            var data        = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");

            var vertex20 = new GeoCoordinate(51.0578532, 3.7192229);
            var vertex21 = new GeoCoordinate(51.0578518, 3.7195654);

            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]);

                point = vertex21 + ((vertex20 - vertex21) * position1);
                var vertex2120 = new GeoCoordinate(point[1], point[0]);

                // calculate route.
                IRoutingAlgorithm <TEdgeData> basicRouter = this.BuildBasicRouter(data);
                Router router = this.BuildRouter(data, interpreter, basicRouter);

                Route route = router.Calculate(Vehicle.Car,
                                               router.Resolve(Vehicle.Car, vertex2021),
                                               router.Resolve(Vehicle.Car, vertex2120));

                if (vertex2021.Latitude != vertex2120.Latitude &&
                    vertex2021.Longitude != vertex2120.Longitude)
                {
                    Assert.AreEqual(2, route.Segments.Length);
                    Assert.AreEqual(vertex2021.Latitude, route.Segments[0].Latitude, 0.0001);
                    Assert.AreEqual(vertex2021.Longitude, route.Segments[0].Longitude, 0.0001);

                    Assert.AreEqual(vertex2120.Latitude, route.Segments[1].Latitude, 0.0001);
                    Assert.AreEqual(vertex2120.Longitude, route.Segments[1].Longitude, 0.0001);
                }
            }
        }
Example #19
0
        /// <summary>
        /// Tests that a router preserves tags given to resolved points.
        /// </summary>
        protected void DoTestResolvedTags()
        {
            var interpreter = new OsmRoutingInterpreter();
            IRoutingAlgorithmData <TEdgeData> data        = this.BuildData(interpreter, "OsmSharp.Test.Unittests.test_network.osm");
            IRoutingAlgorithm <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"));

            Route route = router.Calculate(Vehicle.Car, source, target);

            Assert.IsNotNull(route);
            Assert.AreEqual(5, route.Segments.Length);

            // float latitude, longitude;
            // data.GetVertex(20, out latitude, out longitude);
            Assert.AreEqual(51.0578537, route.Segments[0].Latitude, 0.00001);
            Assert.AreEqual(3.71922278, route.Segments[0].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Start, route.Segments[0].Type);
            Assert.IsNotNull(route.Segments[0].Points[0].Tags);
            Assert.AreEqual(1, route.Segments[0].Points[0].Tags.Length);
            Assert.AreEqual("source", route.Segments[0].Points[0].Tags[0].Value);

            // data.GetVertex(23, out latitude, out longitude);
            Assert.AreEqual(51.05762, route.Segments[4].Latitude, 0.00001);
            Assert.AreEqual(3.71918, route.Segments[4].Longitude, 0.00001);
            Assert.AreEqual(RouteSegmentType.Stop, route.Segments[4].Type);
            Assert.IsNotNull(route.Segments[4].Points[0].Tags);
            Assert.AreEqual(1, route.Segments[4].Points[0].Tags.Length);
            Assert.AreEqual("target", route.Segments[4].Points[0].Tags[0].Value);
        }
Example #20
0
 /// <summary>
 /// Builds a router.
 /// </summary>
 /// <returns></returns>
 public override Router BuildRouter(IRoutingAlgorithmData <Edge> data, IRoutingInterpreter interpreter,
                                    IRoutingAlgorithm <Edge> basicRouter)
 {
     // initialize the router.
     return(Router.CreateFrom(data, basicRouter, interpreter));
 }
Example #21
0
        /// <summary>
        /// Creates a router using interpreted edges.
        /// </summary>
        /// <param name="data">The data to route on.</param>
        /// <param name="basicRouter">A custom routing implementation.</param>
        /// <param name="interpreter">The routing interpreter.</param>
        /// <returns></returns>
        public static Router CreateCHFrom(IRoutingAlgorithmData<CHEdgeData> data, IRoutingAlgorithm<CHEdgeData> basicRouter, 
            IRoutingInterpreter interpreter)
        {
            // creates the edge router.
            var typedRouter = new TypedRouterCHEdge(
                data, interpreter, basicRouter);

            return new Router(typedRouter); // create the actual router.
        }
Example #22
0
 /// <summary>
 /// Creates a new type router using edges of type LiveEdge.
 /// </summary>
 public TypedRouterLiveEdge(IBasicRouterDataSource <LiveEdge> graph, IRoutingInterpreter interpreter,
                            IRoutingAlgorithm <LiveEdge> router)
     : base(graph, interpreter, router)
 {
 }
Example #23
0
 /// <summary>
 /// Creates a new type router using edges of type CHEdgeData.
 /// </summary>
 /// <param name="graph"></param>
 /// <param name="interpreter"></param>
 /// <param name="router"></param>
 public TypedRouterCHEdge(IBasicRouterDataSource <CHEdgeData> graph, IRoutingInterpreter interpreter, IRoutingAlgorithm <CHEdgeData> router)
     : base(graph, interpreter, router)
 {
     DefaultSearchDelta = 0.1f;
 }
Example #24
0
 /// <summary>
 /// Returns a new router.
 /// </summary>
 /// <param name="data"></param>
 /// <param name="interpreter"></param>
 /// <param name="basicRouter"></param>
 /// <returns></returns>
 public override Router BuildRouter(IRoutingAlgorithmData <CHEdgeData> data,
                                    IRoutingInterpreter interpreter, IRoutingAlgorithm <CHEdgeData> basicRouter)
 {
     return(Router.CreateCHFrom(data, basicRouter, interpreter));
 }
Example #25
0
        /// <summary>
        /// Test resolving all nodes.
        /// </summary>
        protected void DoTestResolveBetweenNodes()
        {
            var interpreter = new OsmRoutingInterpreter();
            IBasicRouterDataSource <EdgeData> data        = this.BuildData(interpreter);
            IRoutingAlgorithm <EdgeData>      basicRouter = this.BuildBasicRouter(data);

            const float delta  = 0.001f;
            var         result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0578761, 3.7193972), delta, null, null, null);

            Assert.IsTrue((result.Vertex1 == 20 && result.Vertex2 == 21) ||
                          (result.Vertex1 == 21 && result.Vertex2 == 20));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0576510, 3.7194124), delta, null, null, null); //,-104, -14, -12
            Assert.IsTrue((result.Vertex1 == 22 && result.Vertex2 == 23) ||
                          (result.Vertex1 == 23 && result.Vertex2 == 22));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0576829, 3.7196791), delta, null, null, null); //,-105, -12, -10
            Assert.IsTrue((result.Vertex1 == 22 && result.Vertex2 == 16) ||
                          (result.Vertex1 == 16 && result.Vertex2 == 22));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0577819, 3.7196308), delta, null, null, null); //,-106, -10,  -8
            Assert.IsTrue((result.Vertex1 == 21 && result.Vertex2 == 16) ||
                          (result.Vertex1 == 16 && result.Vertex2 == 21));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0577516, 3.7198975), delta, null, null, null); //,-107, -10, -18
            Assert.IsTrue((result.Vertex1 == 17 && result.Vertex2 == 16) ||
                          (result.Vertex1 == 16 && result.Vertex2 == 17));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0578218, 3.7200626), delta, null, null, null); //,-108, -18, -20
            Assert.IsTrue((result.Vertex1 == 17 && result.Vertex2 == 7) ||
                          (result.Vertex1 == 7 && result.Vertex2 == 17));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0578170, 3.7202480), delta, null, null, null); //,-109, -20, -76
            Assert.IsTrue((result.Vertex1 == 6 && result.Vertex2 == 7) ||
                          (result.Vertex1 == 7 && result.Vertex2 == 6));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0577580, 3.7204004), delta, null, null, null); //,-110, -76, -74
            Assert.IsTrue((result.Vertex1 == 5 && result.Vertex2 == 6) ||
                          (result.Vertex1 == 6 && result.Vertex2 == 5));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0579032, 3.7204258), delta, null, null, null); //,-111, -74, -72
            Assert.IsTrue((result.Vertex1 == 1 && result.Vertex2 == 5) ||
                          (result.Vertex1 == 5 && result.Vertex2 == 1));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580453, 3.7204614), delta, null, null, null); //,-112, -72, -70
            Assert.IsTrue((result.Vertex1 == 4 && result.Vertex2 == 1) ||
                          (result.Vertex1 == 1 && result.Vertex2 == 4));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581938, 3.7203953), delta, null, null, null); //,-113, -70, -68
            Assert.IsTrue((result.Vertex1 == 3 && result.Vertex2 == 4) ||
                          (result.Vertex1 == 4 && result.Vertex2 == 3));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581826, 3.7201413), delta, null, null, null); //,-114, -46, -68
            Assert.IsTrue((result.Vertex1 == 3 && result.Vertex2 == 2) ||
                          (result.Vertex1 == 2 && result.Vertex2 == 3));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580310, 3.7201998), delta, null, null, null); //,-115, -46, -72
            Assert.IsTrue((result.Vertex1 == 2 && result.Vertex2 == 1) ||
                          (result.Vertex1 == 1 && result.Vertex2 == 2));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0579208, 3.7200525), delta, null, null, null); //,-116, -20, -22
            Assert.IsTrue((result.Vertex1 == 11 && result.Vertex2 == 7) ||
                          (result.Vertex1 == 7 && result.Vertex2 == 11));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580134, 3.7199966), delta, null, null, null); //,-117, -46, -22
            Assert.IsTrue((result.Vertex1 == 2 && result.Vertex2 == 11) ||
                          (result.Vertex1 == 11 && result.Vertex2 == 2));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581251, 3.7198950), delta, null, null, null); //,-118, -46, -48
            Assert.IsTrue((result.Vertex1 == 18 && result.Vertex2 == 2) ||
                          (result.Vertex1 == 2 && result.Vertex2 == 18));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0579479, 3.7197985), delta, null, null, null); //,-119, -22, -56
            Assert.IsTrue((result.Vertex1 == 10 && result.Vertex2 == 11) ||
                          (result.Vertex1 == 11 && result.Vertex2 == 10));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580166, 3.7195496), delta, null, null, null); //,-120, -56, -65
            Assert.IsTrue((result.Vertex1 == 10 && result.Vertex2 == 9) ||
                          (result.Vertex1 == 9 && result.Vertex2 == 10));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581299, 3.7195673), delta, null, null, null); //,-121, -65, -50
            Assert.IsTrue((result.Vertex1 == 8 && result.Vertex2 == 9) ||
                          (result.Vertex1 == 9 && result.Vertex2 == 8));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581651, 3.7196664), delta, null, null, null); //,-122, -50, -48
            Assert.IsTrue((result.Vertex1 == 8 && result.Vertex2 == 18) ||
                          (result.Vertex1 == 18 && result.Vertex2 == 8));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0582050, 3.7194505), delta, null, null, null); //,-123, -50, -52
            Assert.IsTrue((result.Vertex1 == 19 && result.Vertex2 == 8) ||
                          (result.Vertex1 == 8 && result.Vertex2 == 19));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0582082, 3.7191330), delta, null, null, null); //,-124, -52, -54
            Assert.IsTrue((result.Vertex1 == 15 && result.Vertex2 == 19) ||
                          (result.Vertex1 == 19 && result.Vertex2 == 15));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0581651, 3.7189628), delta, null, null, null); //,-125, -54, -62
            Assert.IsTrue((result.Vertex1 == 15 && result.Vertex2 == 14) ||
                          (result.Vertex1 == 14 && result.Vertex2 == 15));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580725, 3.7189781), delta, null, null, null); //,-126, -62, -60
            Assert.IsTrue((result.Vertex1 == 14 && result.Vertex2 == 13) ||
                          (result.Vertex1 == 13 && result.Vertex2 == 14));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0580006, 3.7191305), delta, null, null, null); //,-127, -60, -58
            Assert.IsTrue((result.Vertex1 == 13 && result.Vertex2 == 12) ||
                          (result.Vertex1 == 12 && result.Vertex2 == 13));
            result = basicRouter.SearchClosest(data, interpreter, Vehicle.Car, new GeoCoordinate(51.0579783, 3.7194149), delta, null, null, null); //,-128, -58, -56
            Assert.IsTrue((result.Vertex1 == 10 && result.Vertex2 == 12) ||
                          (result.Vertex1 == 12 && result.Vertex2 == 10));
        }
Example #26
0
        /// <summary>
        /// Creates a router using live interpreted edges.
        /// </summary>
        /// <param name="data">The data to route on.</param>
        /// <param name="basicRouter">A custom routing implementation.</param>
        /// <param name="interpreter">The routing interpreter.</param>
        /// <returns></returns>
        public static Router CreateCHFrom(IBasicRouterDataSource<CHEdgeData> data, IRoutingAlgorithm<CHEdgeData> basicRouter, 
            IRoutingInterpreter interpreter)
        {
            // creates the live edge router.
            var liveEdgeRouter = new TypedRouterCHEdge(
                data, interpreter, basicRouter);

            return new Router(liveEdgeRouter); // create the actual router.
        }
Example #27
0
 /// <summary>
 /// Builds the router.
 /// </summary>
 /// <param name="data"></param>
 /// <param name="interpreter"></param>
 /// <param name="basicRouter"></param>
 /// <returns></returns>
 public abstract Router BuildRouter(IBasicRouterDataSource <TEdgeData> data,
                                    IRoutingInterpreter interpreter, IRoutingAlgorithm <TEdgeData> basicRouter);
 /// <summary>
 /// Builds the router;
 /// </summary>
 /// <param name="data"></param>
 /// <param name="interpreter"></param>
 /// <param name="basicRouter"></param>
 /// <returns></returns>
 public abstract Router BuildRouter(IRoutingAlgorithmData <TEdgeData> data,
                                    IOsmRoutingInterpreter interpreter, IRoutingAlgorithm <TEdgeData> basicRouter);
Example #29
0
 public SwitchingMatrix(IRoutingAlgorithm routingAlgorithm)
 {
     this.routingAlgorithm = routingAlgorithm;
 }
Example #30
0
 /// <summary>
 /// Creates a new type router using edges of type CHEdgeData.
 /// </summary>
 /// <param name="graph"></param>
 /// <param name="interpreter"></param>
 /// <param name="router"></param>
 public TypedRouterCHEdge(IRoutingAlgorithmData <CHEdgeData> graph, IRoutingInterpreter interpreter, IRoutingAlgorithm <CHEdgeData> router)
     : base(graph, interpreter, router)
 {
     DefaultSearchDelta = 0.0125f;
 }
Example #31
0
 /// <summary>
 /// Creates a new type router using edges of type Edge.
 /// </summary>
 /// <param name="graph"></param>
 /// <param name="interpreter"></param>
 /// <param name="router"></param>
 public TypedRouterEdge(IRoutingAlgorithmData <Edge> graph, IRoutingInterpreter interpreter,
                        IRoutingAlgorithm <Edge> router)
     : base(graph, interpreter, router)
 {
 }