Example #1
0
        public void TestCHEdgeDifferenceNonContracted()
        {
            IRoutingInterpreter interpreter    = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
            EdgeDifference      edgeDifference = this.BuildEdgeDifference(interpreter);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(3, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(20));
            Assert.AreEqual(0, edgeDifference.Calculate(21));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));
        }
        /// <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);
                }
            }
        }
        public void TestCHEdgeDifferenceContractions()
        {
            IRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
            CHPreProcessor processor = this.BuildCHPreProcessor(interpreter);
            //processor.InitializeQueue();
            INodeWeightCalculator edge_difference = processor.NodeWeightCalculator;

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(3, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));
            Assert.AreEqual(-1, edge_difference.Calculate(20));
            Assert.AreEqual(0, edge_difference.Calculate(21));
            Assert.AreEqual(0, edge_difference.Calculate(22));
            Assert.AreEqual(-1, edge_difference.Calculate(23));

            // contract 20.
            processor.Contract(20);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(3, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));
            Assert.AreEqual(-1, edge_difference.Calculate(21));
            Assert.AreEqual(0, edge_difference.Calculate(22));
            Assert.AreEqual(-1, edge_difference.Calculate(23));

            // contract 21.
            processor.Contract(21);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));
            Assert.AreEqual(0, edge_difference.Calculate(22));
            Assert.AreEqual(-1, edge_difference.Calculate(23));

            // contract 23.
            processor.Contract(23);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));
            Assert.AreEqual(-1, edge_difference.Calculate(22));

            // contract 22.
            processor.Contract(22);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-1, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            // contract 16.
            processor.Contract(16);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-1, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            // contract 17.
            processor.Contract(17);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(0, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(3);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(-2, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(0, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(4);

            Assert.AreEqual(0, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(3, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(0, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(1);

            Assert.AreEqual(1, edge_difference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-2, edge_difference.Calculate(5)); // witness paths from 11<->6.
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(0, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(5);

            Assert.AreEqual(1, edge_difference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-2, edge_difference.Calculate(6));
            Assert.AreEqual(0, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(6);

            Assert.AreEqual(0, edge_difference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-1, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(7);

            Assert.AreEqual(0, edge_difference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(0, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(2);

            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(-2, edge_difference.Calculate(11)); // witness paths from 18<->10.
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(11);

            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(1, edge_difference.Calculate(10));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-2, edge_difference.Calculate(18)); // witness paths from 10<->8.
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(18);

            Assert.AreEqual(0, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(0, edge_difference.Calculate(10));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(8);

            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(0, edge_difference.Calculate(10));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(9);

            Assert.AreEqual(-2, edge_difference.Calculate(10)); // witness paths from 19<->12.
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-2, edge_difference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(10);

            Assert.AreEqual(-2, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-2, edge_difference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(12);

            Assert.AreEqual(-1, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-1, edge_difference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(13);

            Assert.AreEqual(-1, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(-1, edge_difference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(14);

            Assert.AreEqual(-1, edge_difference.Calculate(15));
            Assert.AreEqual(-1, edge_difference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(15);

            Assert.AreEqual(0, edge_difference.Calculate(19));

            processor.Contract(19);
        }
        public void TestCHEdgeDifferenceNonContracted()
        {
            IRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
            EdgeDifference edge_difference = this.BuildEdgeDifference(interpreter);

            Assert.AreEqual(1, edge_difference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edge_difference.Calculate(2));
            Assert.AreEqual(0, edge_difference.Calculate(3));
            Assert.AreEqual(0, edge_difference.Calculate(4));
            Assert.AreEqual(0, edge_difference.Calculate(5));
            Assert.AreEqual(0, edge_difference.Calculate(6));
            Assert.AreEqual(3, edge_difference.Calculate(7));
            Assert.AreEqual(3, edge_difference.Calculate(8));
            Assert.AreEqual(0, edge_difference.Calculate(9));
            Assert.AreEqual(3, edge_difference.Calculate(10));
            Assert.AreEqual(3, edge_difference.Calculate(11));
            Assert.AreEqual(0, edge_difference.Calculate(12));
            Assert.AreEqual(0, edge_difference.Calculate(13));
            Assert.AreEqual(0, edge_difference.Calculate(14));
            Assert.AreEqual(0, edge_difference.Calculate(15));
            Assert.AreEqual(3, edge_difference.Calculate(16));
            Assert.AreEqual(0, edge_difference.Calculate(17));
            Assert.AreEqual(0, edge_difference.Calculate(18));
            Assert.AreEqual(0, edge_difference.Calculate(19));
            Assert.AreEqual(-1, edge_difference.Calculate(20));
            Assert.AreEqual(0, edge_difference.Calculate(21));
            Assert.AreEqual(0, edge_difference.Calculate(22));
            Assert.AreEqual(-1, edge_difference.Calculate(23));
        }
        /// <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);
                }
            }
        }
Example #6
0
        public void TestCHEdgeDifferenceContractions()
        {
            IRoutingInterpreter interpreter = new OsmSharp.Routing.Osm.Interpreter.OsmRoutingInterpreter();
            CHPreProcessor      processor   = this.BuildCHPreProcessor(interpreter);
            //processor.InitializeQueue();
            INodeWeightCalculator edgeDifference = processor.NodeWeightCalculator;

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(3, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(20));
            Assert.AreEqual(0, edgeDifference.Calculate(21));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 20.
            processor.Contract(20);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(3, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(21));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 21.
            processor.Contract(21);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(0, edgeDifference.Calculate(22));
            Assert.AreEqual(-1, edgeDifference.Calculate(23));

            // contract 23.
            processor.Contract(23);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));
            Assert.AreEqual(-1, edgeDifference.Calculate(22));

            // contract 22.
            processor.Contract(22);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(16));
            Assert.AreEqual(0, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            // contract 16.
            processor.Contract(16);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(3, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(17));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            // contract 17.
            processor.Contract(17);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(3));
            Assert.AreEqual(0, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(3);

            Assert.AreEqual(1, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(6, edgeDifference.Calculate(2));
            Assert.AreEqual(-2, edgeDifference.Calculate(4));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(4);

            Assert.AreEqual(0, edgeDifference.Calculate(1)); // witness paths from 2<->4.
            Assert.AreEqual(3, edgeDifference.Calculate(2));
            Assert.AreEqual(0, edgeDifference.Calculate(5));
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(1);

            Assert.AreEqual(1, edgeDifference.Calculate(2));  // witness paths from 11<->5.
            Assert.AreEqual(-2, edgeDifference.Calculate(5)); // witness paths from 11<->6.
            Assert.AreEqual(0, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(5);

            Assert.AreEqual(1, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-2, edgeDifference.Calculate(6));
            Assert.AreEqual(0, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(6);

            Assert.AreEqual(0, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(-1, edgeDifference.Calculate(7));
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(3, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(7);

            Assert.AreEqual(0, edgeDifference.Calculate(2)); // witness paths from 11<->5.
            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(11));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(2);

            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(3, edgeDifference.Calculate(10));
            Assert.AreEqual(-2, edgeDifference.Calculate(11)); // witness paths from 18<->10.
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(18));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(11);

            Assert.AreEqual(3, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(1, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(18)); // witness paths from 10<->8.
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(18);

            Assert.AreEqual(0, edgeDifference.Calculate(8));
            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(0, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(8);

            Assert.AreEqual(0, edgeDifference.Calculate(9));
            Assert.AreEqual(0, edgeDifference.Calculate(10));
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(9);

            Assert.AreEqual(-2, edgeDifference.Calculate(10)); // witness paths from 19<->12.
            Assert.AreEqual(0, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(10);

            Assert.AreEqual(-2, edgeDifference.Calculate(12));
            Assert.AreEqual(0, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-2, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(12);

            Assert.AreEqual(-1, edgeDifference.Calculate(13));
            Assert.AreEqual(0, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(13);

            Assert.AreEqual(-1, edgeDifference.Calculate(14));
            Assert.AreEqual(0, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(14);

            Assert.AreEqual(-1, edgeDifference.Calculate(15));
            Assert.AreEqual(-1, edgeDifference.Calculate(19)); // witness paths from 15<->10.

            processor.Contract(15);

            Assert.AreEqual(0, edgeDifference.Calculate(19));

            processor.Contract(19);
        }