示例#1
0
        /// <summary>
        /// Creates a new instance of the profile search algorithm.
        /// </summary>
        public ProfileSearch(TransitDb db, DateTime departureTime,
                             TransfersDb transfersDb, Func <uint, DateTime, bool> isTripPossible)
        {
            _db            = db;
            _transfersDb   = transfersDb;
            _sources       = new Dictionary <uint, uint>();
            _targets       = new Dictionary <uint, uint>();
            _departureTime = departureTime;

            _isTripPossible = isTripPossible;
        }
示例#2
0
        public void TestAddTransfer()
        {
            var db = new TransfersDb(256);

            db.AddTransfer(0, 1, 60);

            var enumeration = db.GetTransferEnumerator();

            Assert.IsTrue(enumeration.MoveTo(0));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(60, enumeration.Seconds);
            Assert.AreEqual(1, enumeration.Stop);
            Assert.IsTrue(enumeration.MoveTo(1));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(60, enumeration.Seconds);
            Assert.AreEqual(0, enumeration.Stop);

            db.AddTransfer(0, 2, 61);
            db.AddTransfer(1, 2, 62);
            db.AddTransfer(2, 4, 63);
            db.AddTransfer(2, 3, 64);
            db.AddTransfer(4, 5, 65);

            enumeration = db.GetTransferEnumerator();

            Assert.IsTrue(enumeration.MoveTo(0));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(60, enumeration.Seconds);
            Assert.AreEqual(1, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(61, enumeration.Seconds);
            Assert.AreEqual(2, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveTo(1));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(60, enumeration.Seconds);
            Assert.AreEqual(0, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(62, enumeration.Seconds);
            Assert.AreEqual(2, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveTo(2));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(61, enumeration.Seconds);
            Assert.AreEqual(0, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(62, enumeration.Seconds);
            Assert.AreEqual(1, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(63, enumeration.Seconds);
            Assert.AreEqual(4, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(64, enumeration.Seconds);
            Assert.AreEqual(3, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveTo(4));
            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(63, enumeration.Seconds);
            Assert.AreEqual(2, enumeration.Stop);

            Assert.IsTrue(enumeration.MoveNext());
            Assert.AreEqual(65, enumeration.Seconds);
            Assert.AreEqual(5, enumeration.Stop);
        }
示例#3
0
        public void TestTwoHopsOneTransferCloseStopsSuccessful()
        {
            // build dummy db.
            var db = new TransitDb();

            db.AddStop(0, 0, db.StopAttributes.Add(new Attribute("name", "stop1")));
            db.AddStop(1, 1, db.StopAttributes.Add(new Attribute("name", "stop2")));
            db.AddStop(2, 2, db.StopAttributes.Add(new Attribute("name", "stop3")));
            db.AddStop(3, 3, db.StopAttributes.Add(new Attribute("name", "stop4")));
            db.AddTrip(0, 0, db.TripAttributes.Add(new Attribute("name", "trip1")));
            db.AddTrip(0, 0, db.TripAttributes.Add(new Attribute("name", "trip2")));
            db.AddConnection(0, 1, 0, 8 * 3600, 8 * 3600 + 10 * 60);
            db.AddConnection(2, 3, 1, 8 * 3600 + 15 * 60, 8 * 3600 + 25 * 60);

            db.SortConnections(DefaultSorting.DepartureTime, null);

            // build dummy transfers db.
            var transfersDb = new TransfersDb(1024);

            transfersDb.AddTransfer(1, 2, 100);

            // run algorithm.
            var departureTime = new System.DateTime(2017, 05, 10, 07, 30, 00);
            var algorithm     = new ProfileSearch(db, departureTime, transfersDb,
                                                  (profileId, day) => true);

            algorithm.SetSourceStop(0, 07 * 3600 + 30 * 60);
            algorithm.SetTargetStop(3, 0);
            algorithm.Run();

            // build route.
            var routeBuilder = new ProfileSearchRouteBuilder(algorithm, false);

            routeBuilder.Run();
            var route = routeBuilder.Route;

            Assert.IsNotNull(route);

            Assert.IsNotNull(route.Shape);
            Assert.AreEqual(6, route.Shape.Length);
            Assert.AreEqual(0, route.Shape[0].Latitude);
            Assert.AreEqual(0, route.Shape[0].Longitude);
            Assert.AreEqual(0, route.Shape[1].Latitude);
            Assert.AreEqual(0, route.Shape[1].Longitude);
            Assert.AreEqual(1, route.Shape[2].Latitude);
            Assert.AreEqual(1, route.Shape[2].Longitude);
            Assert.AreEqual(2, route.Shape[3].Latitude);
            Assert.AreEqual(2, route.Shape[3].Longitude);
            Assert.AreEqual(2, route.Shape[4].Latitude);
            Assert.AreEqual(2, route.Shape[4].Longitude);
            Assert.AreEqual(3, route.Shape[5].Latitude);
            Assert.AreEqual(3, route.Shape[5].Longitude);

            Assert.IsNotNull(route.Stops);
            Assert.AreEqual(6, route.Stops.Length);
            var stop = route.Stops[0];

            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop1"));
            Assert.AreEqual(0, stop.Shape);
            Assert.AreEqual(0, stop.Coordinate.Latitude);
            Assert.AreEqual(0, stop.Coordinate.Longitude);
            stop = route.Stops[1];
            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop1"));
            Assert.AreEqual(1, stop.Shape);
            Assert.AreEqual(0, stop.Coordinate.Latitude);
            Assert.AreEqual(0, stop.Coordinate.Longitude);
            stop = route.Stops[2];
            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop2"));
            Assert.AreEqual(2, stop.Shape);
            Assert.AreEqual(1, stop.Coordinate.Latitude);
            Assert.AreEqual(1, stop.Coordinate.Longitude);
            stop = route.Stops[3];
            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop3"));
            Assert.AreEqual(3, stop.Shape);
            Assert.AreEqual(2, stop.Coordinate.Latitude);
            Assert.AreEqual(2, stop.Coordinate.Longitude);
            stop = route.Stops[4];
            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop3"));
            Assert.AreEqual(4, stop.Shape);
            Assert.AreEqual(2, stop.Coordinate.Latitude);
            Assert.AreEqual(2, stop.Coordinate.Longitude);
            stop = route.Stops[5];
            Assert.IsNotNull(stop.Attributes);
            Assert.AreEqual(1, stop.Attributes.Count);
            Assert.IsTrue(stop.Attributes.Contains("name", "stop4"));
            Assert.AreEqual(5, stop.Shape);
            Assert.AreEqual(3, stop.Coordinate.Latitude);
            Assert.AreEqual(3, stop.Coordinate.Longitude);

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

            var meta = route.ShapeMeta[0];

            Assert.AreEqual(0, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((07 * 3600) + (30 * 60)).ToInvariantString()));
            Assert.AreEqual(0, meta.Time);

            meta = route.ShapeMeta[1];
            Assert.AreEqual(1, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((08 * 3600) + (00 * 60)).ToInvariantString()));
            Assert.AreEqual(meta.Time, 30 * 60);

            meta = route.ShapeMeta[2];
            Assert.AreEqual(2, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((08 * 3600) + (10 * 60)).ToInvariantString()));
            Assert.AreEqual(meta.Time, 40 * 60);

            meta = route.ShapeMeta[3];
            Assert.AreEqual(3, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((08 * 3600) + (10 * 60) + 100).ToInvariantString()));
            Assert.AreEqual(meta.Time, 40 * 60 + 100);

            meta = route.ShapeMeta[4];
            Assert.AreEqual(4, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((08 * 3600) + (15 * 60)).ToInvariantString()));
            Assert.AreEqual(meta.Time, 45 * 60);

            meta = route.ShapeMeta[5];
            Assert.AreEqual(5, meta.Shape);
            Assert.IsNotNull(meta.Attributes);
            Assert.IsTrue(meta.Attributes.Contains(Itinero.Transit.Constants.TimeOfDayKey,
                                                   ((08 * 3600) + (25 * 60)).ToInvariantString()));
            Assert.AreEqual(meta.Time, 55 * 60);
        }
示例#4
0
        public void TestTwoHopsOneTransferCloseStopsSuccessfulSkippedPseudo()
        {
            // build dummy db.
            var db = new TransitDb();

            db.AddStop(0, 0, 0);
            db.AddStop(1, 1, 1);
            db.AddStop(2, 2, 2);
            db.AddStop(3, 3, 3);
            db.AddTrip(0, 0, 0);
            db.AddTrip(0, 0, 0);
            db.AddTrip(0, 0, 0);
            db.AddConnection(0, 1, 0, 8 * 3600, 8 * 3600 + 10 * 60);
            db.AddConnection(1, 2, 0, 8 * 3600 + 10 * 60, 8 * 3600 + 15 * 60);
            db.AddConnection(2, 3, 0, 8 * 3600 + 15 * 60, 8 * 3600 + 25 * 60);

            db.SortConnections(DefaultSorting.DepartureTime, null);

            // build dummy transfers db.
            var transfersDb = new TransfersDb(1024);

            transfersDb.AddTransfer(1, 2, 60); // this leads to a transfer time faster than the actual connection.

            // run algorithm.
            var departureTime = new DateTime(2017, 05, 10, 07, 30, 00);
            var algorithm     = new ProfileSearch(db, departureTime, transfersDb,
                                                  (profileId, day) => true);

            algorithm.SetSourceStop(0, 07 * 3600 + 30 * 60);
            algorithm.SetTargetStop(3, 0);
            algorithm.Run();

            // test results.
            Assert.IsTrue(algorithm.HasRun);
            Assert.IsTrue(algorithm.HasSucceeded);

            // check arrival profile(s).
            var arrivalStops = algorithm.ArrivalStops;

            Assert.AreEqual(3, arrivalStops.Count);
            Assert.AreEqual(3, arrivalStops[2]);
            var arrivalProfiles = algorithm.ArrivalProfiles;

            Assert.AreEqual(3, arrivalProfiles.Count);
            Assert.AreEqual(08 * 3600 + 25 * 60, arrivalProfiles[2].Seconds);
            Assert.AreEqual(55 * 60, algorithm.Duration(2));
            Assert.AreEqual(new DateTime(2017, 05, 10, 08, 25, 00), algorithm.ArrivalTime(2));

            // check stop profiles.
            var connections = db.GetConnectionsEnumerator(DefaultSorting.DepartureTime);
            var profiles    = algorithm.GetStopProfiles(3);

            Assert.AreEqual(3, profiles.Count);
            var profile = profiles[0];

            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(2, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 55 * 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(2);
            Assert.AreEqual(4, profiles.Count);
            profile = profiles[0];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(1, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 45 * 60, profile.Seconds);
            profile = profiles[3];
            Assert.IsTrue(profile.IsTransfer);
            Assert.AreEqual(1, profile.PreviousStopId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 40 * 60 + 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(1);
            Assert.AreEqual(3, profiles.Count);
            profile = profiles[0];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(0, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 40 * 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(0);
            Assert.AreEqual(1, profiles.Count);
            profile = profiles[0];
            Assert.AreEqual(Itinero.Transit.Constants.NoConnectionId, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds, profile.Seconds);

            // build dummy transfers db.
            transfersDb = new TransfersDb(1024);
            transfersDb.AddTransfer(1, 2, 6 * 60); // this leads to a transfer time slower than the actual connection.

            // run algorithm.
            departureTime = new DateTime(2017, 05, 10, 07, 30, 00);
            algorithm     = new ProfileSearch(db, departureTime, transfersDb,
                                              (profileId, day) => true);
            algorithm.SetSourceStop(0, 07 * 3600 + 30 * 60);
            algorithm.SetTargetStop(3, 0);
            algorithm.Run();

            // test results.
            Assert.IsTrue(algorithm.HasRun);
            Assert.IsTrue(algorithm.HasSucceeded);

            // check arrival profile(s).
            arrivalStops = algorithm.ArrivalStops;
            Assert.AreEqual(3, arrivalStops.Count);
            Assert.AreEqual(3, arrivalStops[2]);
            arrivalProfiles = algorithm.ArrivalProfiles;
            Assert.AreEqual(3, arrivalProfiles.Count);
            Assert.AreEqual(08 * 3600 + 25 * 60, arrivalProfiles[2].Seconds);
            Assert.AreEqual(55 * 60, algorithm.Duration(2));
            Assert.AreEqual(new DateTime(2017, 05, 10, 08, 25, 00), algorithm.ArrivalTime(2));

            // check stop profiles.
            connections = db.GetConnectionsEnumerator(DefaultSorting.DepartureTime);
            profiles    = algorithm.GetStopProfiles(3);
            Assert.AreEqual(3, profiles.Count);
            profile = profiles[0];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(2, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 55 * 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(2);
            Assert.AreEqual(3, profiles.Count);
            profile = profiles[0];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(1, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 45 * 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(1);
            Assert.AreEqual(3, profiles.Count);
            profile = profiles[0];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[1];
            Assert.IsTrue(profile.IsEmpty);
            profile = profiles[2];
            Assert.AreEqual(0, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds + 40 * 60, profile.Seconds);

            profiles = algorithm.GetStopProfiles(0);
            Assert.AreEqual(1, profiles.Count);
            profile = profiles[0];
            Assert.AreEqual(Itinero.Transit.Constants.NoConnectionId, profile.PreviousConnectionId);
            Assert.AreEqual((int)(departureTime - departureTime.Date).TotalSeconds, profile.Seconds);

            var tripStatus = algorithm.GetTripStatus(0);

            Assert.AreEqual(2, tripStatus.Transfers);
            Assert.AreEqual(0, tripStatus.StopId);
            Assert.AreEqual(08 * 3600 + 00 * 60, tripStatus.DepartureTime);
        }