def finish(self, edges):
translate = {
'WALK': TransportType.WALK,
'RAIL': TransportType.TRAIN,
'TRAM': TransportType.TRAM,
'BUS': TransportType.BUS,
}
points = set()
points.update(s.from_vertex for s in edges)
points.update(s.to_vertex for s in edges)
new_edges = []
for it in self.search_request.result['itineraries']:
prev_point = self.start
for index, leg in enumerate(it['legs']):
transport_type = translate.get(leg['mode'])
if not transport_type:
continue
# print(leg)
start_time = datetime.fromtimestamp(
int(leg['startTime']) / 1000)
end_time = datetime.fromtimestamp(int(leg['endTime']) / 1000)
if 'departure' in leg[
'to']: # plannerstack can include 1 second of waiting, which we want to ignore
end_dep_time = datetime.fromtimestamp(
int(leg['to']['departure']) / 1000)
if end_dep_time - end_time <= timedelta(seconds=1):
end_time = end_dep_time
p_loc_name = leg['to']['name']
if p_loc_name == 'Destination':
loc = self.end.location
else:
p_loc_lat = float(leg['to']['lat'])
p_loc_lon = float(leg['to']['lon'])
loc = self.location_holder.create_location(
p_loc_name, (p_loc_lat, p_loc_lon))
p_end = get_or_add(points, Point(loc, end_time))
if index == 0: # walk to first stop will be added later
prev_point = p_end
continue
# logger.info('Arrival time ' + str(int(leg['to']['arrival'])) + ' ' + str(start_time))
if start_time > prev_point.time:
p_start = get_or_add(
points, Point(prev_point.location, start_time))
new_edges.append(
Segment(TransportType.WAIT, prev_point, p_start))
else:
p_start = prev_point
segment = Segment(transport_type, p_start, p_end)
if 'routeShortName' in leg:
segment.route_name = transport_type.to_dutch(
) + ' ' + leg['routeShortName']
if 'platformCode' in leg['from']:
segment.platform_code = leg['from']['platformCode']
new_edges.append(segment)
prev_point = p_end
for s in new_edges:
if not any(se.has_same_points_and_type(s) for se in edges):
# logger.info('Adding segment ' + str(s))
edges.append(s)
def test(self):
noon = noon_today()
start = Point(Location('Madurodam'), noon)
end = Point(Location('Martinitoren'), noon)
segments = []
self.generator.create_edges(start, end, FixTime.START, segments)
self.assertEqual(len(segments), 4)
def create_segment(start, end, fix_time, transport_type, option=None):
time_sec, map_url = WalkGenerator.get_bike_travel_time(start.location, end.location, transport_type)
delta_t = timedelta(seconds=time_sec)
if fix_time == FixTime.START:
new_point = Point(end.location, start.time + delta_t)
segment = Segment(transport_type, start, new_point)
else:
new_point = Point(start.location, end.time - delta_t)
segment = Segment(transport_type, new_point, end)
segment.map_url = map_url
return segment, new_point
def create_edges(self, start, end, fix_time, edges):
st_start_loc = self.closest_stations(start.location, 2)
st_end_loc = self.closest_stations(end.location, 2)
stops_1 = [
Point(s, start.time + timedelta(minutes=50)) for s in st_start_loc
]
stops_2 = [
Point(s, start.time + timedelta(minutes=140)) for s in st_end_loc
]
for s1 in stops_1:
for s2 in stops_2:
# take the train
edges.append(Segment(TransportType.TRAIN, s1, s2))
def create_edges(self, start, end, fix_time):
b = Point('b', start.time + datetime.timedelta(seconds=20))
c = Point('c', start.time + datetime.timedelta(seconds=80))
d = Point('d', start.time + datetime.timedelta(seconds=50))
edges = [
Segment(TransportType.BIKE, start, b),
Segment(TransportType.TRAIN, start, c),
Segment(TransportType.TRAIN, start, d),
Segment(TransportType.TRAIN, b, c),
Segment(TransportType.BIKE, c, end),
Segment(TransportType.TRAIN, d, end),
Segment(TransportType.CAR, start, end)
]
return edges
def create_segment(self,
start,
end,
fix,
transport_type=TransportType.CAR,
option=False):
route_params = TomTomApi.RouteParams(start=start.location,
end=end.location,
avoid_highways=option)
travel_time, delay = self.tomtom.travel_time(route_params)
delta_t = timedelta(seconds=travel_time)
map_url = self.tomtom.map_url(route_params)
if fix == FixTime.START:
new_point = Point(end.location, start.time + delta_t)
segment = Segment(transport_type, start, new_point)
else:
new_point = Point(start.location, end.time - delta_t)
segment = Segment(transport_type, new_point, end)
segment.delay = delay / 60
segment.map_url = map_url
return segment, new_point
def __init__(self, start, end, fix_time, public_generator, parkings):
self.ppars = []
cargenerator = CarGenerator()
for loc in {start.location, end.location}:
park_loc = self.closest_parking(loc, parkings)
if park_loc:
park = Point(park_loc, end.time)
segment, new_point = cargenerator.create_segment(
start, park, FixTime.START)
request = public_generator.prepare_request(
new_point, end, fix_time)
self.ppars.append((park, request))
def test_points(self):
# location and point are value classes
l1 = Location('a', (2, 3))
l2 = Location('a', (2, 3))
l3 = Location('b', (2, 3))
l4 = Location('a', (3, 3))
t0 = datetime(year=2000, month=1, day=1)
t1 = t0 + timedelta(seconds=60)
p1 = Point(l1, t0)
p2 = Point(l2, t0)
p3 = Point(l3, t0)
p4 = Point(l4, t0)
p5 = Point(l1, t1)
p6 = Point(l2, t1)
self.assertFalse(l1 is l2)
self.assertTrue(l1 == l2)
self.assertFalse(p1 is p2)
self.assertTrue(p1 == p2)
self.assertFalse(l1 == l3)
self.assertFalse(l1 == l4)
self.assertFalse(p1 == p3)
self.assertFalse(p1 == p4)
self.assertTrue(p1.location == p5.location)
self.assertTrue(p2.location == p6.location)
self.assertFalse(p1 == p5)
self.assertFalse(p2 == p6)
ll = [l1, l3]
lp = [p1, p3]
self.assertTrue(l1 in ll)
self.assertTrue(l2 in ll)
self.assertTrue(l3 in ll)
self.assertFalse(l4 in ll)
self.assertTrue(p1 in lp)
self.assertTrue(p2 in lp)
self.assertTrue(p3 in lp)
self.assertFalse(p4 in lp)
sl = set([l1, l2, l3, l4])
sp = set([p1, p2, p3, p4, p5, p6])
self.assertEqual(len(sl), 3)
self.assertEqual(len(sp), 4)
self.assertTrue(Location('a', (2, 3)) in sl)
self.assertTrue(Point(l1, t0) in sp)
self.assertFalse(Location('b', (3, 3)) in sl)
self.assertFalse(Point(l3, t1) in sp)
def test(self):
loc_utr = Location('Utrecht, Varkenmarkt')
loc_ams = Location('Amsterdam, Damrak')
noon = datetime(year=2017, month=11, day=17, hour=12)
start1 = Point(location=loc_utr, time=noon)
end1 = Point(location=loc_ams, time=noon)
start2 = Point(location=loc_utr, time=noon)
end2 = Point(location=loc_ams, time=noon)
generator = WalkGenerator()
segment, new_point = generator.create_segment(start1, end1, FixTime.START, TransportType.WALK)
segment2, new_point2 = generator.create_segment(start2, end2, FixTime.END, TransportType.WALK)
self.assertEqual(segment.transport_type, TransportType.WALK)
self.assertEqual(segment.from_vertex.location, loc_utr)
self.assertEqual(segment.to_vertex.location, loc_ams)
self.assertEqual(segment.from_vertex.time, noon)
self.assertEqual(new_point.time, datetime(2017, 11, 17, 21, 53, 14, 79125))
self.assertEqual(new_point2.time, datetime(2017, 11, 17, 2, 6, 45, 920875))
self.assertEqual(segment2.to_vertex.time, noon)
segment, new_point = generator.create_segment(start1, end1, FixTime.START, TransportType.BIKE)
segment2, new_point2 = generator.create_segment(start2, end2, FixTime.END, TransportType.BIKE)
self.assertEqual(segment.transport_type, TransportType.BIKE)
self.assertEqual(segment.from_vertex.location, loc_utr)
self.assertEqual(segment.to_vertex.location, loc_ams)
self.assertEqual(segment.from_vertex.time, noon)
self.assertAlmostEqual(new_point.time, datetime(2017, 11, 17, 14, 16, 48), delta=timedelta(seconds=1200))
self.assertAlmostEqual(new_point2.time, datetime(2017, 11, 17, 9, 43, 12), delta=timedelta(seconds=1200))
self.assertEqual(segment2.to_vertex.time, noon)
loc_bhd = Location('sloterweg 183, badhoevedorp', (52.33668,4.77682))
loc_mee = Location('Station Meerssen', (51.1923957995,5.99421143532))
start = Point(location=loc_bhd, time=noon)
end = Point(location=loc_mee, time=noon)
segment, new_point = generator.create_segment(start, end, FixTime.START, TransportType.BIKE)
self.assertEqual(segment.transport_type, TransportType.BIKE)
self.assertEqual(segment.from_vertex.location, loc_bhd)
self.assertEqual(segment.to_vertex.location, loc_mee)
self.assertGreater(segment.to_vertex.time - segment.from_vertex.time, timedelta(hours=4))
self.assertLess(segment.to_vertex.time - segment.from_vertex.time, timedelta(hours=14))
loc_bhd = Location('parkzichtlaan', (52.10073, 5.03322))
loc_mee = Location('Utrecht Centraal', (52.089820488, 5.10957062244))
start = Point(location=loc_bhd, time=noon)
end = Point(location=loc_mee, time=noon)
segment, new_point = generator.create_segment(start, end, FixTime.START, TransportType.BIKE)
self.assertEqual(segment.transport_type, TransportType.BIKE)
self.assertEqual(segment.from_vertex.location, loc_bhd)
self.assertEqual(segment.to_vertex.location, loc_mee)
self.assertGreater(segment.to_vertex.time - segment.from_vertex.time, timedelta(minutes=10))
self.assertLess(segment.to_vertex.time - segment.from_vertex.time, timedelta(minutes=30))
def get_plans(self):
t0 = datetime(year=2000, month=1, day=1)
points = {
'a': Point('a', t0),
'z1': Point('z', t0 + timedelta(hours=3)),
'z2': Point('z', t0 + timedelta(hours=3, minutes=1)),
'c': Point('c', t0 + timedelta(hours=2)),
'z3': Point('z', t0 + timedelta(hours=5)),
'a2': Point('a', t0 + timedelta(hours=12)),
'c2': Point('c', t0 + timedelta(hours=13)),
'z4': Point('z', t0 + timedelta(hours=14)),
'z5': Point('z', t0 + timedelta(hours=6)),
'z6': Point('z', t0 + timedelta(hours=2, minutes=59)),
}
carplan = self.create_plan([
Segment(TransportType.CAR, points['a'], points['z1']),
])
bikeplan = self.create_plan([
Segment(TransportType.BIKE, points['a'], points['z2']),
])
publicplan1 = self.create_plan([
Segment(TransportType.WALK, points['a'], points['c']),
Segment(TransportType.TRAIN, points['c'], points['z3']),
])
publicplan2 = self.create_plan([
Segment(TransportType.WAIT, points['a'], points['a2']),
Segment(TransportType.WALK, points['a2'], points['c2']),
Segment(TransportType.TRAIN, points['c2'], points['z4']),
])
walkplan = self.create_plan([
Segment(TransportType.WALK, points['a'], points['z5']),
])
bikeplan2 = self.create_plan([
Segment(TransportType.BIKE, points['a'], points['z6']),
])
return bikeplan, carplan, publicplan1, publicplan2, walkplan, bikeplan2
def finish(self, edges):
loc_1 = Location.midpoint(self.start.location, self.end.location, 0.01)
loc_2 = Location.midpoint(self.start.location, self.end.location, 0.5)
loc_3 = Location.midpoint(self.start.location, self.end.location, 0.99)
loc_4 = self.end.location
if self.fix_time == FixTime.START:
start_time = self.start.time
else:
start_time = self.end.time - timedelta(hours=1)
time_1 = start_time + 0.25 * timedelta(hours=1)
time_2 = start_time + 0.5 * timedelta(hours=1)
time_3 = start_time + 0.75 * timedelta(hours=1)
time_4 = start_time + 0.99 * timedelta(hours=1)
p1 = Point(loc_1, time_1)
p2 = Point(loc_2, time_2)
p3 = Point(loc_3, time_3)
p4 = Point(loc_4, time_4)
edges += [
Segment(TransportType.BUS, p1, p2),
Segment(TransportType.TRAIN, p2, p3),
Segment(TransportType.WALK, p3, p4),
]
def gen_points(req_time, fix_time):
start_time = req_time if fix_time == FixTime.START else req_time-timedelta(hours=10)
end_time = req_time if fix_time == FixTime.END else req_time+timedelta(hours=10)
start = Point(Location('Den Haag'), start_time)
end = Point(Location('Nieuwegein'), end_time)
return start, end
def solve(self,
start_loc_str,
start_hike_time,
user_preferences=UserTravelPreferences()):
logger.info('BEGIN')
log_start = time.time()
start = Point(Location(start_loc_str),
start_hike_time - timedelta(hours=12))
trail = get_trail(start.location)
hike_start_loc = Location('wandeling vertrek',
(trail.begin_lat, trail.begin_lon))
hike_end_loc = Location('wandeling aankomst',
(trail.end_lat, trail.end_lon))
if hike_start_loc.distance_to(hike_end_loc).meters < 100:
hike_end_loc = hike_start_loc
hike_start_loc.loc_str = 'wandeling vertrek/aankomst'
hike_start = Point(hike_start_loc, start_hike_time)
hike_end = Point(
hike_end_loc, start_hike_time +
timedelta(seconds=trail.distance / WALKING_SPEED))
end = Point(Location(start_loc_str),
hike_end.time + timedelta(hours=12))
logger.info('start=' + str(start))
logger.info('hike_start=' + str(hike_start))
logger.info('hike_end=' + str(hike_end))
logger.info('end=' + str(end))
segments = self.generator.create_edges(start, hike_start, FixTime.END)
segments += self.generator.create_edges(hike_end, end, FixTime.START)
hiking_segment = Segment(TransportType.WALK, hike_start, hike_end)
hiking_segment.route_name = trail.title
hiking_segment.map_url = trail.wandelpagina_url
segments.append(hiking_segment)
# for e in segments:
# logger.info('Edge: ' + str(e))
vehicle_positions = VehiclePositions()
# put a bicycle and car at home...
vehicle_positions.add_vehicle(
start.location, Vehicle(TransportType.BIKE, VehicleType.BIKE))
vehicle_positions.add_vehicle(
start.location, Vehicle(TransportType.CAR, VehicleType.CAR))
# add OV fietsen
ov_fiets_stations = OvFietsStations()
vehicle_positions = ov_fiets_stations.add_default_ovfiets_positions(
vehicle_positions, segments)
plans = self.router.make_plans(start, end, segments, vehicle_positions)
plans = list(filter(Planner.has_no_double_biking, plans))
order_and_select(plans, user_preferences, None)
Planner.remove_unnecessary_waiting(plans, FixTime.START)
log_end = time.time()
logger.info('END - time: ' + str(log_end - log_start))
return plans, trail