def get_route_segment_sub_points(self, routing_table_id, reverse): c_list = DBControl().fetch_data("" \ "SELECT ST_Y(geom) AS lat, ST_X(geom) AS lon " \ "FROM (" \ "SELECT ST_PointN(geom_way, generate_series(1, ST_NPoints(geom_way))) AS geom " \ "FROM %s WHERE id = %d) AS points;" \ % (self.temp_routing_table_name, routing_table_id)) if reverse: c_list = c_list[::-1] point_list = [] last_accepted_bearing = geometry.bearing_between_two_points( c_list[0]['lat'], c_list[0]['lon'], c_list[1]['lat'], c_list[1]['lon']) for i in range(1, c_list.__len__()-1): new_bearing = geometry.bearing_between_two_points( c_list[i]['lat'], c_list[i]['lon'], c_list[i+1]['lat'], c_list[i+1]['lon']) turn = geometry.turn_between_two_segments( new_bearing, last_accepted_bearing) if turn > 22 and turn < 338: last_accepted_bearing = new_bearing point_list.append(self.poi.create_way_point(-1, c_list[i]['lat'], c_list[i]['lon'], {})) return point_list
def insert_into_poi_list(self, poi_list, entry, lat, lon): if entry == {} or entry.has_key("name") == False \ or entry.has_key("lat") == False or entry.has_key("lon") == False: return poi_list entry['distance'] = geometry.distance_between_two_points( lat, lon, entry['lat'], entry['lon']) entry['bearing'] = geometry.bearing_between_two_points( lat, lon, entry['lat'], entry['lon']) # add in pois list sorted by distance if poi_list.__len__() == 0: poi_list.append(entry) else: inserted = False for index in range(0, poi_list.__len__()): if entry['distance'] < poi_list[index]['distance']: poi_list.insert(index, entry) inserted = True break if inserted == False: poi_list.append(entry) return poi_list
def create_transport_route_object(self, start_point, legs, dest_point): cost = 0 route = [] walking_distance = 0 # add the start point start_index = 0 placeholder_segment = { "name": "", "type": "footway", "sub_type": "", "distance": 0, "bearing": 0 } if "$Individual" in legs[0].getClass().getName(): placeholder_segment[ 'distance'] = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].arrival.lat), geometry.convert_coordinate_to_float(legs[0].arrival.lon)) placeholder_segment[ 'bearing'] = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].arrival.lat), geometry.convert_coordinate_to_float(legs[0].arrival.lon)) start_index += 1 else: placeholder_segment[ 'distance'] = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float( legs[0].departure.lat), geometry.convert_coordinate_to_float( legs[0].departure.lon)) placeholder_segment[ 'bearing'] = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float( legs[0].departure.lat), geometry.convert_coordinate_to_float( legs[0].departure.lon)) if placeholder_segment['distance'] > 50: walking_distance += placeholder_segment['distance'] placeholder_segment['name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" route.append(start_point) route.append(placeholder_segment) # check, if the last part of the trip is a walking part dest_index = legs.__len__() if "$Individual" in legs[-1].getClass().getName(): if dest_index > 0: dest_index -= 1 for index in range(start_index, dest_index): leg = legs[index] if "$Public" in leg.getClass().getName(): # create departure and arrival objects line = "%s%s" % (leg.line.product.code.encode("utf-8"), leg.line.label.encode("utf-8")) if leg.destination != None: destination_name = leg.destination.name.encode("utf-8") else: destination_name = leg.arrival.name.encode("utf-8") departure = self.s_finder.get_station(leg.departure, line, destination_name) if leg.departureStop.plannedDeparturePosition != None: departure[ 'platform_number'] = leg.departureStop.plannedDeparturePosition.name arrival = self.s_finder.get_station(leg.arrival, line, destination_name) if leg.arrivalStop.plannedArrivalPosition != None: arrival[ 'platform_number'] = leg.arrivalStop.plannedArrivalPosition.name.encode( "utf-8") self.route_logger.append_to_log( "line: %s; From %s to %s" % (line, departure['name'], arrival['name'])) # create transport segment transport_segment = { "type": "transport", "line": line, "direction": destination_name } # departure and arrival time date_format = self.gateway.jvm.java.text.SimpleDateFormat( "HH:mm", self.gateway.jvm.java.util.Locale.GERMAN) transport_segment['departure_time'] = date_format.format( leg.getDepartureTime()) transport_segment[ 'departure_time_millis'] = leg.getDepartureTime().getTime( ) transport_segment['arrival_time'] = date_format.format( leg.getArrivalTime()) transport_segment['arrival_time_millis'] = leg.getArrivalTime( ).getTime() duration = (leg.getArrivalTime().getTime() - leg.getDepartureTime().getTime()) / 1000 hours, remainder = divmod(duration, 3600) minutes, seconds = divmod(remainder, 60) if hours == 0: transport_segment['duration'] = "%d Min" % minutes else: transport_segment['duration'] = "%d:%d" % (hours, minutes) # intermediate stops intermediate_stop_list = leg.intermediateStops transport_segment['stops'] = [] if intermediate_stop_list == None: transport_segment['number_of_stops'] = 0 else: transport_segment[ 'number_of_stops'] = intermediate_stop_list.__len__() for stop in intermediate_stop_list: transport_segment['stops'].append(stop.location.name) # first leg of trip is_first_leg = False if route.__len__() == 0: is_first_leg = True elif route[-1]['type'] == "footway": is_first_leg = True if is_first_leg == True: # the last route segment was either a footway part or the route is still empty # get cost for first departure if departure['transportation_class'] == 1: if departure['accuracy'] == True: cost += self.costs['change_1'] self.route_logger.append_to_log( "%s: enter tc1 +acc (+%d)" % (departure['name'], self.costs['change_1'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s: enter tc1 -acc (+%d)" % (departure['name'], self.costs['change_2'])) else: if departure['accuracy'] == True: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s: enter tc2 with entrance (+%d)" % (departure['name'], self.costs['change_2'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s: enter tc2 without entrance (+%d)" % (departure['name'], self.costs['change_3'])) # change for another transportation vehicle else: last_transport_segment = route[-2] last_arrival = route[-1] time_for_change = ( leg.getDepartureTime().getTime() - last_transport_segment['arrival_time_millis']) / 60000 self.route_logger.append_to_log("time for change = %d" % time_for_change) placeholder_segment = { "name": "", "type": "footway", "sub_type": "", "distance": 0, "bearing": 0 } placeholder_segment[ 'distance'] = geometry.distance_between_two_points( last_arrival['lat'], last_arrival['lon'], departure['lat'], departure['lon']) walking_distance += placeholder_segment['distance'] placeholder_segment[ 'bearing'] = geometry.bearing_between_two_points( last_arrival['lat'], last_arrival['lon'], departure['lat'], departure['lon']) # tc1-tc1 if last_arrival['transportation_class'] == 1 and departure[ 'transportation_class'] == 1: # tc1-tc1: arrival and departure positions known if last_arrival['accuracy'] == True and departure[ 'accuracy'] == True: # same platform, user can wait for next vehicle if last_arrival['node_id'] == departure['node_id']: cost += self.costs['change_1'] placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "same_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") self.route_logger.append_to_log( "%s - %s: same platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_1'])) elif last_arrival['station_id'] == departure[ 'station_id']: # same station but different stop position last_arrival_line = last_arrival['lines'][0][ 'nr'] is_towards = False for line in departure['lines']: if line['nr'] == last_arrival_line: is_towards = True break if is_towards == True: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "opposite_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id = s_id oppposite platform (+%d)" % (last_arrival['name'], departure['name'], self. costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id = s_id oppposite platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "nearby_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self. costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: # other station placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment[ 'sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s - %s: tc1_acc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) # tc1-tc1: only the destination station of the change is known elif departure['accuracy'] == True: if last_arrival['station_id'] == departure[ 'station_id']: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "nearby_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: # other station placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment[ 'sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) # tc1-tc1: no exact station positions known else: if last_arrival['station_id'] == departure[ 'station_id']: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "nearby_station_no_exact_pos") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_noacc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_noacc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: # other station placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment[ 'sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs[ 'change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_noacc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log( "%s - %s: tc1_noacc-tc1_noacc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc1-tc2 elif last_arrival[ 'transportation_class'] == 1 and departure[ 'transportation_class'] == 2: # station has entrances placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment[ 'sub_type'] = "footway_place_holder" if departure['accuracy'] == True: if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1-tc2+entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s - %s: tc1-tc2+entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc1-tc2 no_entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log( "%s - %s: tc1-tc2 no_entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc2-tc1 elif last_arrival[ 'transportation_class'] == 2 and departure[ 'transportation_class'] == 1: # exact position of station known placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment[ 'sub_type'] = "footway_place_holder" if departure['accuracy'] == True: if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc2-tc1+exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log( "%s - %s: tc2-tc1+exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc2-tc1 not_exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log( "%s - %s: tc2-tc1 not_exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc2-tc2 elif last_arrival[ 'transportation_class'] == 2 and departure[ 'transportation_class'] == 2: if last_arrival['station_id'] == departure[ 'station_id']: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "within_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc2-tc2: same station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log( "%s - %s: tc2-tc2: same station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: placeholder_segment[ 'name'] = self.translator.translate( "transport_creator", "different_station") placeholder_segment[ 'sub_type'] = self.translator.translate( "highway", "footway") if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log( "%s - %s: tc2-tc2: diff station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log( "%s - %s: tc2-tc2: diff station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # something went wrong with the transportation class else: print "parsing error" # raise route_parsing_exception("blub") # add segment and arrival route.append(placeholder_segment) # add departure, transport_segment and arrival route.append(departure) route.append(transport_segment) route.append(arrival) # adding the last footway segment placeholder_segment = { "name": "", "type": "footway", "sub_type": "", "distance": 0, "bearing": 0 } if "$Individual" in legs[-1].getClass().getName(): placeholder_segment[ 'distance'] = geometry.distance_between_two_points( geometry.convert_coordinate_to_float( legs[-1].departure.lat), geometry.convert_coordinate_to_float( legs[-1].departure.lon), dest_point['lat'], dest_point['lon']) placeholder_segment[ 'bearing'] = geometry.bearing_between_two_points( geometry.convert_coordinate_to_float( legs[-1].departure.lat), geometry.convert_coordinate_to_float( legs[-1].departure.lon), dest_point['lat'], dest_point['lon']) else: placeholder_segment[ 'distance'] = geometry.distance_between_two_points( geometry.convert_coordinate_to_float(legs[-1].arrival.lat), geometry.convert_coordinate_to_float(legs[-1].arrival.lon), dest_point['lat'], dest_point['lon']) placeholder_segment[ 'bearing'] = geometry.bearing_between_two_points( geometry.convert_coordinate_to_float(legs[-1].arrival.lat), geometry.convert_coordinate_to_float(legs[-1].arrival.lon), dest_point['lat'], dest_point['lon']) if placeholder_segment['distance'] > 50: walking_distance += placeholder_segment['distance'] placeholder_segment['name'] = self.translator.translate( "transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" route.append(placeholder_segment) route.append(dest_point) # add walking distance to cost value cost += (walking_distance / self.costs['walk_dist_meters']) + 1 self.route_logger.append_to_log( "Fußweg insgesamt = %d, %d Punkte" % (walking_distance, (walking_distance / self.costs['walk_dist_meters']) + 1)) # time calculation departure_time = 0 arrival_time = 0 number_of_trips = 0 transportation_vehicles = [] for part in route: if part['type'] == "transport": number_of_trips += 1 transportation_vehicles.append(part['line']) arrival_time = part['arrival_time_millis'] if departure_time == 0: departure_time = part['departure_time_millis'] minutes_till_departure = (departure_time - int(time.time() * 1000)) / 60000 trip_length = (arrival_time - departure_time) / 60000 cost += (minutes_till_departure / self.costs['min_departure']) + 1 cost += (trip_length / self.costs['min_trip_length']) + 1 self.route_logger.append_to_log( "%d Minuten bis Abfahrt, %d Punkte" % (minutes_till_departure, (minutes_till_departure / self.costs['min_departure']) + 1)) self.route_logger.append_to_log( "%d Minuten Dauer, %d Punkte" % (trip_length, (trip_length / self.costs['min_trip_length']) + 1)) # create and return transport route object if cost < 100: route_description = self.translator.translate("transport_creator", "transport_route_description") \ % (minutes_till_departure, trip_length, (number_of_trips-1), ' '.join(transportation_vehicles), walking_distance) else: route_description = self.translator.translate("transport_creator", "transport_route_description_no_time") \ % (minutes_till_departure, trip_length, (number_of_trips-1), ' '.join(transportation_vehicles), walking_distance) return RouteTransportCreator.TransportRouteObject( route, cost, route_description, departure_time, ','.join(transportation_vehicles))
def find_footway_route(self, start_point, dest_point): print "footway route creator" # a few helper variables t1 = time.time() self.route = [] last_target_id = -1 reverse = False # check for cancel command if Config().has_session_id_to_remove(self.session_id): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) # create temporary routing table distance_between_start_and_destination = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], dest_point['lat'], dest_point['lon']) print "radius = %d" % distance_between_start_and_destination center_point = geometry.get_center_point( start_point['lat'], start_point['lon'], dest_point['lat'], dest_point['lon']) boundaries = geometry.get_boundary_box(center_point['lat'], center_point['lon'], self.minimum_radius + int(distance_between_start_and_destination / 2)) # create temp table DBControl().send_data("" \ "DROP TABLE IF EXISTS %s;" \ "CREATE TABLE %s AS SELECT * FROM %s LIMIT 0;" \ "INSERT INTO %s " \ "SELECT * from %s " \ "WHERE geom_way && ST_MakeEnvelope(%f, %f, %f, %f);" % (self.temp_routing_table_name, self.temp_routing_table_name, self.routing_table_name, self.temp_routing_table_name, self.routing_table_name, boundaries['left'], boundaries['bottom'], boundaries['right'], boundaries['top'])) # check if temp routing table is empty number_of_table_rows = DBControl().fetch_data("SELECT count(*) from %s" \ % self.temp_routing_table_name)[0]['count'] if number_of_table_rows == 0: DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) self.route_logger.append_to_log("Routing table too small", True) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("footway_creator", "foot_route_creation_failed")) # adapt cost column t11 = time.time() # weight list for index, weight in enumerate(self.way_class_weight_list): DBControl().send_data("" \ "UPDATE %s SET cost=km*%d where kmh = %d;" \ % (self.temp_routing_table_name, weight, (index+1)) ) # blocked ways DBControl().send_data("" \ "UPDATE %s SET cost=km*(-1) WHERE osm_id = ANY('{%s}');" \ % (self.temp_routing_table_name, ','.join(str(x) for x in self.blocked_ways)) ) # add table index and recreate source and target columns t12 = time.time() DBControl().send_data("" \ "ALTER TABLE ONLY %s ADD CONSTRAINT pkey_%s PRIMARY KEY (id);" \ "CREATE INDEX idx_%s_source ON %s USING btree (source);" \ "CREATE INDEX idx_%s_target ON %s USING btree (target);" \ "CREATE INDEX idx_%s_osm_source_id ON %s USING btree (osm_source_id);" \ "CREATE INDEX idx_%s_osm_target_id ON %s USING btree (osm_target_id);" \ "CREATE INDEX idx_%s_geom_way ON %s USING gist (geom_way);" \ "ALTER TABLE %s CLUSTER ON idx_%s_geom_way;" \ "SELECT recreate_vertex_of_routing_table('%s');" \ "ANALYZE %s;" \ % (self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name, self.temp_routing_table_name)) t2 = time.time() self.route_logger.append_to_log("Temp table creation: %.2f (%.2f / %.2f / %.2f\nnumber of rows = %d" \ % (t2-t1, t11-t1, t12-t11, t2-t12, number_of_table_rows), True) # check for cancel command if Config().has_session_id_to_remove(self.session_id): DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) # get start and destination vertex start_vertex_list = self.get_nearest_vertex( start_point['lat'], start_point['lon']) if start_vertex_list.__len__() == 0 or Config().has_session_id_to_remove(self.session_id): DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) if start_vertex_list.__len__() == 0: self.route_logger.append_to_log("Found no start vertex", True) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("footway_creator", "foot_route_creation_failed")) else: raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) dest_vertex_list = self.get_nearest_vertex( dest_point['lat'], dest_point['lon']) if dest_vertex_list.__len__() == 0 or Config().has_session_id_to_remove(self.session_id): DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) if dest_vertex_list.__len__(): self.route_logger.append_to_log("Found no destination vertex", True) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("footway_creator", "foot_route_creation_failed")) else: raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) t3 = time.time() # check for cancel command if Config().has_session_id_to_remove(self.session_id): DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) # route calculation best_route = RouteFootwayCreator.RawRoute([], None, None) max_vertex_list_length = start_vertex_list.__len__() if max_vertex_list_length < dest_vertex_list.__len__(): max_vertex_list_length = dest_vertex_list.__len__() print "length = %d (%d / %d)" % (max_vertex_list_length, start_vertex_list.__len__(), dest_vertex_list.__len__()) for x in range(0, max_vertex_list_length): for y in range(0, x+1): if x < start_vertex_list.__len__() and y < dest_vertex_list.__len__() \ and best_route.cost == 1000000: result = DBControl().fetch_data("" \ "SELECT seq, id1 AS node, id2 AS edge_id, cost FROM pgr_dijkstra(" \ "'select id, source, target, cost from %s', %d, %d, false, false)" \ % (self.temp_routing_table_name, start_vertex_list[x].point_id, dest_vertex_list[y].point_id)) if any(result): best_route = RouteFootwayCreator.RawRoute(result, start_vertex_list[x], dest_vertex_list[y]) self.route_logger.append_to_log( "%d %d Cost: %.2f\n start: %s\n dest: %s" % (x, y, best_route.cost, start_vertex_list[x].__str__(), dest_vertex_list[y].__str__()), True) if y < start_vertex_list.__len__() and x < dest_vertex_list.__len__() \ and x != y and best_route.cost == 1000000: result = DBControl().fetch_data("" \ "SELECT seq, id1 AS node, id2 AS edge_id, cost FROM pgr_dijkstra(" \ "'select id, source, target, cost from %s', %d, %d, false, false)" \ % (self.temp_routing_table_name, start_vertex_list[y].point_id, dest_vertex_list[x].point_id)) if any(result): best_route = RouteFootwayCreator.RawRoute(result, start_vertex_list[y], dest_vertex_list[x]) self.route_logger.append_to_log( "%d %d Cost: %.2f\n start: %s\n dest: %s" % (y, x, best_route.cost, start_vertex_list[y].__str__(), dest_vertex_list[x].__str__()), True) if Config().has_session_id_to_remove(self.session_id): DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) if best_route.cost == 1000000: result = DBControl().fetch_data("" \ "SELECT seq, id1 AS node, id2 AS edge_id, cost FROM pgr_dijkstra(" \ "'select id, source, target, km AS cost from %s WHERE kmh != 7', %d, %d, false, false)" \ % (self.temp_routing_table_name, start_vertex_list[0].point_id, dest_vertex_list[0].point_id)) DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) if any(result): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("footway_creator", "foot_route_creation_failed_way_classes_missing")) else: raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "foot_route_creation_failed_no_existing_way")) t4 = time.time() self.route_logger.append_to_log("routing algorithm: %.2f" % (t4-t3), True) for r in best_route.route: if r['edge_id'] == -1: continue part = DBControl().fetch_data("SELECT * from %s where id=%d" \ % (self.temp_routing_table_name, r['edge_id']))[0] # exception for the first route segment # add start point of route first if part['source'] == best_route.start_vertex_tuple.point_id: print "start point added" # check if current point is an intersection next_point = self.poi.create_intersection_by_id(part['osm_source_id']) if next_point == {}: next_point = self.poi.create_way_point_by_id(part['osm_source_id']) self.route.append(next_point) last_target_id = part['source'] elif part['target'] == best_route.start_vertex_tuple.point_id: print "target point added" # check if current point is an intersection next_point = self.poi.create_intersection_by_id(part['osm_target_id']) if next_point == {}: next_point = self.poi.create_way_point_by_id(part['osm_target_id']) self.route.append(next_point) last_target_id = part['target'] # create next point if last_target_id == part['source']: next_point = self.poi.create_intersection_by_id(part['osm_target_id']) if next_point == {}: next_point = self.poi.create_way_point_by_id(part['osm_target_id']) reverse = False last_target_id = part['target'] else: next_point = self.poi.create_intersection_by_id(part['osm_source_id']) if next_point == {}: next_point = self.poi.create_way_point_by_id(part['osm_source_id']) reverse = True last_target_id = part['source'] # create next segment next_segment = self.poi.create_way_segment_by_id(part['osm_id'], reverse ) next_segment['way_class'] = part['kmh'] for point in self.get_route_segment_sub_points(part['id'], reverse) + [next_point]: self.add_point_to_route(point, next_segment.copy()) # check for cancel command if Config().has_session_id_to_remove(self.session_id): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) t5 = time.time() self.route_logger.append_to_log( json.dumps( self.route, indent=4, encoding="utf-8") ) self.route_logger.append_to_log("\n-------------\n") # if no route was found, just use the direct connection between start and destination if self.route.__len__() <= 1: segment = {"name":self.translator.translate("footway_creator", "direct_connection"), "type":"footway", "sub_type":"", "way_id":-1} segment['bearing'] = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], dest_point['lat'], dest_point['lon']) segment['distance'] = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], dest_point['lat'], dest_point['lon']) self.route.append(start_point) self.route.append(segment) self.route.append(dest_point) DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) return self.route # add start point first_segment = None distance_start_p0 = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], self.route[0]['lat'], self.route[0]['lon']) bearing_start_p0 = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], self.route[0]['lat'], self.route[0]['lon']) bearing_p0_p1 = self.route[1]['bearing'] turn = geometry.turn_between_two_segments( bearing_p0_p1, bearing_start_p0) print "start: turn = %d, distance = %d" % (turn, distance_start_p0) print "start tuple: %s" % best_route.start_vertex_tuple.__str__() if distance_start_p0 <= 5: print "small dist, replaced start point" self.route[0] = start_point elif best_route.start_vertex_tuple.way_distance <= 5 \ or (best_route.start_vertex_tuple.way_class in [1,2] and best_route.start_vertex_tuple.way_distance <= 15): if turn >= 158 and turn <= 202: print "replaced first intersection with start point" self.route[1]['distance'] -= distance_start_p0 self.route[0] = start_point elif self.important_intersection(self.route[0]) == False \ and (turn <= 22 or turn >= 338): print "deleted first intersection, not important + straight ahead" self.route[1]['distance'] += distance_start_p0 self.route[0] = start_point else: print "added known first segment" first_segment = self.poi.create_way_segment_by_id( best_route.start_vertex_tuple.way_id) else: print "added placeholder first segment" first_segment = {"name":self.translator.translate("footway_creator", "first_segment"), "type":"footway", "sub_type":"", "way_id":-1, "pois":[]} # should we add a first segment? if first_segment != None: print "really added" self.route[0]['turn'] = turn first_segment['bearing'] = bearing_start_p0 first_segment['distance'] = distance_start_p0 self.route.insert(0, first_segment) self.route.insert(0, start_point) # destination point distance_plast_dest = geometry.distance_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], dest_point['lat'], dest_point['lon']) bearing_plast_dest = geometry.bearing_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], dest_point['lat'], dest_point['lon']) turn = geometry.turn_between_two_segments( bearing_plast_dest, self.route[-2]['bearing']) print "destination: turn = %d, distance = %d" % (turn, distance_plast_dest) print "dest tuple: %s" % best_route.dest_vertex_tuple.__str__() if distance_plast_dest <= 5: print "small dist, replaced dest point" self.route[-1] = dest_point elif best_route.dest_vertex_tuple.way_distance <= 5 \ or (best_route.dest_vertex_tuple.way_class in [1,2] and best_route.dest_vertex_tuple.way_distance <= 15): if turn >= 158 and turn <= 202: # delete last route point, if you should turn around print "replaced last intersection with destination point, turn around" self.route[-2]['distance'] -= distance_plast_dest self.route[-1] = dest_point elif self.important_intersection(self.route[-1]) == False \ and (turn <= 22 or turn >= 338): print "deleted last intersection, not important + straight ahead" self.route[-2]['distance'] += distance_plast_dest self.route[-1] = dest_point else: print "added known last segment" dest_segment = self.poi.create_way_segment_by_id( best_route.dest_vertex_tuple.way_id) self.add_point_to_route(dest_point, dest_segment) else: print "added placeholder last segment" dest_segment = {"name":self.translator.translate("footway_creator", "last_segment"), "type":"footway", "sub_type":"", "way_id":-1, "pois":[]} self.add_point_to_route(dest_point, dest_segment) t6 = time.time() # print time overview DBControl().send_data("DROP TABLE %s;" % self.temp_routing_table_name) self.route_logger.append_to_log( "1. temp table: %.2f\n" \ "2. vertex calculation: %.2f\n" \ "3. route calculation: %.2f\n" \ "4. add route points: %.2f\n" \ "5. add start and destination: %.2f\n" \ "summary: %.2f" \ % (t2-t1, t3-t2, t4-t3, t5-t4, t6-t5, t6-t1), True) return self.route
def add_point_to_route(self, next_point, next_segment, add_all_intersections=False): # calculate distance and bearing of new segment try: next_segment['bearing'] = geometry.bearing_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], next_point['lat'], next_point['lon']) next_segment['distance'] = geometry.distance_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], next_point['lat'], next_point['lon']) if next_segment['distance'] == 0 and next_point['type'] == "intersection": self.route[-1] = next_point return except IndexError as e: # if the route is still empty, add the next route point and exit self.route.append(next_point) return # try to find and delete unimportant intersections and way points try: turn = geometry.turn_between_two_segments( next_segment['bearing'], self.route[-2]['bearing']) if (add_all_intersections == False \ or (add_all_intersections == True and self.route[-1]['type'] != "intersection")) \ and (turn <= 22 or turn >= 338) \ and self.route[-2]['name'] == next_segment['name'] \ and self.route[-2]['sub_type'] == next_segment['sub_type'] \ and self.important_intersection(self.route[-1], self.route[-2]) == False: # delete an unimportant waypoint or intersection del self.route[-2:] except IndexError as e: pass # find and delete zigzag try: turn = geometry.turn_between_two_segments( next_segment['bearing'], self.route[-4]['bearing']) if add_all_intersections == False \ and (turn <= 22 or turn >= 338) \ and self.route[-2]['distance'] < 4 \ and self.important_intersection(self.route[-1], self.route[-2]) == False \ and self.important_intersection(self.route[-3], self.route[-4]) == False: del self.route[-4:] except IndexError as e: pass # delete double train intersection but leave first of two intersections try: turn = geometry.turn_between_two_segments( next_segment['bearing'], self.route[-4]['bearing']) if add_all_intersections == False \ and (turn <= 22 or turn >= 338) \ and self.route[-2]['distance'] < 5 \ and ( \ self.translator.translate("railway", "tram") in self.route[-1]['name'] \ or self.translator.translate("railway", "rail") in self.route[-1]['name'] \ ) \ and ( \ self.translator.translate("railway", "tram") in self.route[-3]['name'] \ or self.translator.translate("railway", "rail") in self.route[-3]['name'] \ ): del self.route[-2:] except IndexError as e: pass # calculate the updated distance and bearing to the potentially new prev point next_segment['bearing'] = geometry.bearing_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], next_point['lat'], next_point['lon']) next_segment['distance'] = geometry.distance_between_two_points( self.route[-1]['lat'], self.route[-1]['lon'], next_point['lat'], next_point['lon']) # update turn value try: if "turn" not in self.route[-1]: self.route[-1]['turn'] = geometry.turn_between_two_segments( next_segment['bearing'], self.route[-2]['bearing']) except IndexError as e: pass # append new segment and point self.route.append(next_segment) self.route.append(next_point)
def follow_this_way(self, start_point, way_id, bearing, add_all_intersections): self.route = [] way = DBControl().fetch_data("SELECT nodes from ways where id = %d" % way_id)[0] # check for cancel command if Config().has_session_id_to_remove(self.session_id): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) # find nearest way point min_dist = 1000000 id_index = 0 i = 0 for id in way['nodes']: wp = DBControl().fetch_data("SELECT ST_y(geom) as lat, ST_X(geom) as lon from nodes where id = %d" % id)[0] dist = geometry.distance_between_two_points(start_point['lat'], start_point['lon'], wp['lat'], wp['lon']) if dist < min_dist: min_dist = dist id_index = i i += 1 if id_index == 0: prev = DBControl().fetch_data("SELECT ST_y(geom) as lat, ST_X(geom) as lon from nodes where id = %d" % way['nodes'][id_index])[0] next = DBControl().fetch_data("SELECT ST_y(geom) as lat, ST_X(geom) as lon from nodes where id = %d" % way['nodes'][id_index+1])[0] else: prev = DBControl().fetch_data("SELECT ST_y(geom) as lat, ST_X(geom) as lon from nodes where id = %d" % way['nodes'][id_index-1])[0] next = DBControl().fetch_data("SELECT ST_y(geom) as lat, ST_X(geom) as lon from nodes where id = %d" % way['nodes'][id_index])[0] bearing_difference = geometry.bearing_between_two_points(prev['lat'], prev['lon'], next['lat'], next['lon']) - bearing if bearing_difference < 0: bearing_difference += 360 if bearing_difference < 90 or bearing_difference >= 270: for index in range( id_index, way['nodes'].__len__()): next_point = self.poi.create_intersection_by_id(way['nodes'][index]) if next_point == {}: next_point = self.poi.create_way_point_by_id(way['nodes'][index]) next_segment = self.poi.create_way_segment_by_id(way_id) self.add_point_to_route(next_point, next_segment, add_all_intersections) last_node_id = way['nodes'][-1] else: for index in range( id_index, -1, -1): next_point = self.poi.create_intersection_by_id(way['nodes'][index]) if next_point == {}: next_point = self.poi.create_way_point_by_id(way['nodes'][index]) next_segment = self.poi.create_way_segment_by_id(way_id, True) self.add_point_to_route(next_point, next_segment, add_all_intersections) last_node_id = way['nodes'][0] # check for cancel command if Config().has_session_id_to_remove(self.session_id): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) last_way_properties = self.poi.create_way_segment_by_id(way_id) while True: found_next_part = False result = DBControl().fetch_data("SELECT w.id, w.nodes \ from ways w join way_nodes wn on w.id = wn.way_id \ where wn.node_id = %d and wn.way_id != %d" % (last_node_id, last_way_properties['way_id'])) if result.__len__() == 0: break for way in result: next_way_properties = self.poi.create_way_segment_by_id(way['id']) if last_way_properties['name'] != next_way_properties['name']: continue if last_node_id == way['nodes'][0]: for index in range(1, way['nodes'].__len__()): next_point = self.poi.create_intersection_by_id(way['nodes'][index]) if next_point == {}: next_point = self.poi.create_way_point_by_id(way['nodes'][index]) next_segment = self.poi.create_way_segment_by_id( last_way_properties['way_id']) self.add_point_to_route(next_point, next_segment, add_all_intersections) last_node_id = way['nodes'][-1] last_way_properties = next_way_properties found_next_part = True break if last_node_id == way['nodes'][-1]: for index in range( way['nodes'].__len__()-2, -1, -1): next_point = self.poi.create_intersection_by_id(way['nodes'][index]) if next_point == {}: next_point = self.poi.create_way_point_by_id(way['nodes'][index]) next_segment = self.poi.create_way_segment_by_id( last_way_properties['way_id'], True) self.add_point_to_route(next_point, next_segment, add_all_intersections) last_node_id = way['nodes'][0] last_way_properties = next_way_properties found_next_part = True break if found_next_part == False: break # check for cancel command if Config().has_session_id_to_remove(self.session_id): raise RouteFootwayCreator.FootwayRouteCreationError( self.translator.translate("message", "process_canceled")) return self.route
def create_transport_route_object( self, start_point, legs, dest_point): cost = 0 route = [] walking_distance = 0 # add the start point start_index = 0 placeholder_segment = {"name":"", "type":"footway", "sub_type":"", "distance":0, "bearing":0} if "$Individual" in legs[0].getClass().getName(): placeholder_segment['distance'] = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].arrival.lat), geometry.convert_coordinate_to_float(legs[0].arrival.lon) ) placeholder_segment['bearing'] = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].arrival.lat), geometry.convert_coordinate_to_float(legs[0].arrival.lon) ) start_index += 1 else: placeholder_segment['distance'] = geometry.distance_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].departure.lat), geometry.convert_coordinate_to_float(legs[0].departure.lon) ) placeholder_segment['bearing'] = geometry.bearing_between_two_points( start_point['lat'], start_point['lon'], geometry.convert_coordinate_to_float(legs[0].departure.lat), geometry.convert_coordinate_to_float(legs[0].departure.lon) ) if placeholder_segment['distance'] > 50: walking_distance += placeholder_segment['distance'] placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" route.append(start_point) route.append(placeholder_segment) # check, if the last part of the trip is a walking part dest_index = legs.__len__() if "$Individual" in legs[-1].getClass().getName(): if dest_index > 0: dest_index -= 1 for index in range(start_index, dest_index): leg = legs[index] if "$Public" in leg.getClass().getName(): # create departure and arrival objects line = "%s%s" % (leg.line.product.code.encode("utf-8"), leg.line.label.encode("utf-8")) if leg.destination != None: destination_name = leg.destination.name.encode("utf-8") else: destination_name = leg.arrival.name.encode("utf-8") departure = self.s_finder.get_station( leg.departure, line, destination_name) if leg.departureStop.plannedDeparturePosition != None: departure['platform_number'] = leg.departureStop.plannedDeparturePosition.name arrival = self.s_finder.get_station( leg.arrival, line, destination_name) if leg.arrivalStop.plannedArrivalPosition != None: arrival['platform_number'] = leg.arrivalStop.plannedArrivalPosition.name.encode("utf-8") self.route_logger.append_to_log("line: %s; From %s to %s" % (line, departure['name'], arrival['name'])) # create transport segment transport_segment = { "type":"transport", "line":line, "direction":destination_name } # departure and arrival time date_format = self.gateway.jvm.java.text.SimpleDateFormat("HH:mm", self.gateway.jvm.java.util.Locale.GERMAN) transport_segment['departure_time'] = date_format.format(leg.getDepartureTime()) transport_segment['departure_time_millis'] = leg.getDepartureTime().getTime() transport_segment['arrival_time'] = date_format.format(leg.getArrivalTime()) transport_segment['arrival_time_millis'] = leg.getArrivalTime().getTime() duration = (leg.getArrivalTime().getTime() - leg.getDepartureTime().getTime())/1000 hours, remainder = divmod(duration, 3600) minutes, seconds = divmod(remainder, 60) if hours == 0: transport_segment['duration'] = "%d Min" % minutes else: transport_segment['duration'] = "%d:%d" % (hours, minutes) # intermediate stops intermediate_stop_list = leg.intermediateStops transport_segment['stops'] = [] if intermediate_stop_list == None: transport_segment['number_of_stops'] = 0 else: transport_segment['number_of_stops'] = intermediate_stop_list.__len__() for stop in intermediate_stop_list: transport_segment['stops'].append(stop.location.name) # first leg of trip is_first_leg = False if route.__len__() == 0: is_first_leg = True elif route[-1]['type'] == "footway": is_first_leg = True if is_first_leg == True: # the last route segment was either a footway part or the route is still empty # get cost for first departure if departure['transportation_class'] == 1: if departure['accuracy'] == True: cost += self.costs['change_1'] self.route_logger.append_to_log("%s: enter tc1 +acc (+%d)" % (departure['name'], self.costs['change_1'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log("%s: enter tc1 -acc (+%d)" % (departure['name'], self.costs['change_2'])) else: if departure['accuracy'] == True: cost += self.costs['change_2'] self.route_logger.append_to_log("%s: enter tc2 with entrance (+%d)" % (departure['name'], self.costs['change_2'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s: enter tc2 without entrance (+%d)" % (departure['name'], self.costs['change_3'])) # change for another transportation vehicle else: last_transport_segment = route[-2] last_arrival = route[-1] time_for_change = (leg.getDepartureTime().getTime() - last_transport_segment['arrival_time_millis']) / 60000 self.route_logger.append_to_log("time for change = %d" % time_for_change) placeholder_segment = {"name":"", "type":"footway", "sub_type":"", "distance":0, "bearing":0} placeholder_segment['distance'] = geometry.distance_between_two_points( last_arrival['lat'], last_arrival['lon'], departure['lat'], departure['lon']) walking_distance += placeholder_segment['distance'] placeholder_segment['bearing'] = geometry.bearing_between_two_points( last_arrival['lat'], last_arrival['lon'], departure['lat'], departure['lon']) # tc1-tc1 if last_arrival['transportation_class'] == 1 and departure['transportation_class'] == 1: # tc1-tc1: arrival and departure positions known if last_arrival['accuracy'] == True and departure['accuracy'] == True: # same platform, user can wait for next vehicle if last_arrival['node_id'] == departure['node_id']: cost += self.costs['change_1'] placeholder_segment['name'] = self.translator.translate("transport_creator", "same_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") self.route_logger.append_to_log("%s - %s: same platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_1'])) elif last_arrival['station_id'] == departure['station_id']: # same station but different stop position last_arrival_line = last_arrival['lines'][0]['nr'] is_towards = False for line in departure['lines']: if line['nr'] == last_arrival_line: is_towards = True break if is_towards == True: placeholder_segment['name'] = self.translator.translate("transport_creator", "opposite_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id = s_id oppposite platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id = s_id oppposite platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: placeholder_segment['name'] = self.translator.translate("transport_creator", "nearby_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: # other station placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s - %s: tc1_acc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) # tc1-tc1: only the destination station of the change is known elif departure['accuracy'] == True: if last_arrival['station_id'] == departure['station_id']: placeholder_segment['name'] = self.translator.translate("transport_creator", "nearby_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_acc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: # other station placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_acc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) # tc1-tc1: no exact station positions known else: if last_arrival['station_id'] == departure['station_id']: placeholder_segment['name'] = self.translator.translate("transport_creator", "nearby_station_no_exact_pos") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_noacc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_noacc: s_id = s_id near by platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: # other station placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_noacc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log("%s - %s: tc1_noacc-tc1_noacc: s_id != s_id different platform (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc1-tc2 elif last_arrival['transportation_class'] == 1 and departure['transportation_class'] == 2: # station has entrances placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" if departure['accuracy'] == True: if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1-tc2+entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s - %s: tc1-tc2+entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc1-tc2 no_entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log("%s - %s: tc1-tc2 no_entr (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc2-tc1 elif last_arrival['transportation_class'] == 2 and departure['transportation_class'] == 1: # exact position of station known placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" if departure['accuracy'] == True: if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc2-tc1+exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_2'] self.route_logger.append_to_log("%s - %s: tc2-tc1+exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_2'])) else: if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc2-tc1 not_exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log("%s - %s: tc2-tc1 not_exact (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # tc2-tc2 elif last_arrival['transportation_class'] == 2 and departure['transportation_class'] == 2: if last_arrival['station_id'] == departure['station_id']: placeholder_segment['name'] = self.translator.translate("transport_creator", "within_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.short_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc2-tc2: same station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_3'] self.route_logger.append_to_log("%s - %s: tc2-tc2: same station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_3'])) else: placeholder_segment['name'] = self.translator.translate("transport_creator", "different_station") placeholder_segment['sub_type'] = self.translator.translate("highway", "footway") if time_for_change < self.long_change_interval: cost += self.costs['change_not_enough_time'] self.route_logger.append_to_log("%s - %s: tc2-tc2: diff station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_not_enough_time'])) else: cost += self.costs['change_4'] self.route_logger.append_to_log("%s - %s: tc2-tc2: diff station id (+%d)" % (last_arrival['name'], departure['name'], self.costs['change_4'])) # something went wrong with the transportation class else: print "parsing error" # raise route_parsing_exception("blub") # add segment and arrival route.append(placeholder_segment) # add departure, transport_segment and arrival route.append(departure) route.append(transport_segment) route.append(arrival) # adding the last footway segment placeholder_segment = {"name":"", "type":"footway", "sub_type":"", "distance":0, "bearing":0} if "$Individual" in legs[-1].getClass().getName(): placeholder_segment['distance'] = geometry.distance_between_two_points( geometry.convert_coordinate_to_float(legs[-1].departure.lat), geometry.convert_coordinate_to_float(legs[-1].departure.lon), dest_point['lat'], dest_point['lon'] ) placeholder_segment['bearing'] = geometry.bearing_between_two_points( geometry.convert_coordinate_to_float(legs[-1].departure.lat), geometry.convert_coordinate_to_float(legs[-1].departure.lon), dest_point['lat'], dest_point['lon'] ) else: placeholder_segment['distance'] = geometry.distance_between_two_points( geometry.convert_coordinate_to_float(legs[-1].arrival.lat), geometry.convert_coordinate_to_float(legs[-1].arrival.lon), dest_point['lat'], dest_point['lon'] ) placeholder_segment['bearing'] = geometry.bearing_between_two_points( geometry.convert_coordinate_to_float(legs[-1].arrival.lat), geometry.convert_coordinate_to_float(legs[-1].arrival.lon), dest_point['lat'], dest_point['lon'] ) if placeholder_segment['distance'] > 50: walking_distance += placeholder_segment['distance'] placeholder_segment['name'] = self.translator.translate("transport_creator", "footway_place_holder") placeholder_segment['sub_type'] = "footway_place_holder" route.append(placeholder_segment) route.append(dest_point) # add walking distance to cost value cost += (walking_distance / self.costs['walk_dist_meters']) + 1 self.route_logger.append_to_log("Fußweg insgesamt = %d, %d Punkte" % (walking_distance, (walking_distance/self.costs['walk_dist_meters'])+1)) # time calculation departure_time = 0 arrival_time = 0 number_of_trips = 0 transportation_vehicles = [] for part in route: if part['type'] == "transport": number_of_trips += 1 transportation_vehicles.append(part['line']) arrival_time = part['arrival_time_millis'] if departure_time == 0: departure_time = part['departure_time_millis'] minutes_till_departure = (departure_time - int(time.time()*1000)) / 60000 trip_length = (arrival_time - departure_time) / 60000 cost += (minutes_till_departure / self.costs['min_departure']) + 1 cost += (trip_length / self.costs['min_trip_length']) + 1 self.route_logger.append_to_log("%d Minuten bis Abfahrt, %d Punkte" % (minutes_till_departure, (minutes_till_departure/self.costs['min_departure'])+1)) self.route_logger.append_to_log("%d Minuten Dauer, %d Punkte" % (trip_length, (trip_length/self.costs['min_trip_length'])+1)) # create and return transport route object if cost < 100: route_description = self.translator.translate("transport_creator", "transport_route_description") \ % (minutes_till_departure, trip_length, (number_of_trips-1), ' '.join(transportation_vehicles), walking_distance) else: route_description = self.translator.translate("transport_creator", "transport_route_description_no_time") \ % (minutes_till_departure, trip_length, (number_of_trips-1), ' '.join(transportation_vehicles), walking_distance) return RouteTransportCreator.TransportRouteObject(route, cost, route_description, departure_time, ','.join(transportation_vehicles))
def create_intersection(self, osm_id, lat, lon, name, tags, number_of_streets, number_of_streets_with_name, number_of_traffic_signals): intersection_table = Config().get_param("intersection_table") intersection_table_data = Config().get_param("intersection_data_table") intersection = {} if type(osm_id) is not int or type(lat) is not float or type( lon) is not float or type(name) is not str or type( tags) is not dict or type( number_of_streets) is not int or type( number_of_streets_with_name) is not int or type( number_of_traffic_signals) is not int: return intersection intersection = self.create_way_point(osm_id, lat, lon, tags) if intersection == {}: return intersection # traffic lights intersection['pedestrian_crossing_list'] = [] if number_of_traffic_signals > 0: result = DBControl().fetch_data( "SELECT id, ST_X(geom) as lon, ST_Y(geom) as lat, crossing_street_name, tags \ from pedestrian_crossings where intersection_id = %d" % osm_id) for row in result: signal = self.create_poi(0, int(row['id']), row['lat'], row['lon'], self.parse_hstore_column(row['tags']), 0, 0) if row['crossing_street_name'] != None: signal['name'] += ": %s" % row['crossing_street_name'] intersection['pedestrian_crossing_list'].append(signal) # intersection specific properties intersection['name'] = "" for street in name.split(","): translated_street = self.translator.translate( "highway", street.strip()) if translated_street == street.strip(): translated_street = self.translator.translate( "railway", street.strip()) intersection['name'] += "%s, " % translated_street intersection['name'] = intersection['name'].strip(",") intersection[ 'number_of_streets_with_name'] = number_of_streets_with_name intersection['type'] = "intersection" intersection['sub_type'] = self.translator.translate( "crossing", "unknown") if tags.has_key("crossing"): intersection['sub_type'] = self.translator.translate( "crossing", tags['crossing']) elif tags.has_key("highway") and tags['highway'] == "crossing" \ and tags.has_key("crossing_ref") and tags['crossing_ref'] in ["pelican", "toucan", "zebra"]: intersection['sub_type'] = self.translator.translate( "crossing", tags['crossing_ref']) elif tags.has_key("highway") and tags['highway'] == "traffic_signals": intersection['sub_type'] = self.translator.translate( "highway", "traffic_signals") elif tags.has_key("railway") and tags['railway'] == "crossing": intersection['sub_type'] = self.translator.translate( "railway", "crossing") elif intersection['pedestrian_crossing_list'].__len__() > 0: intersection['sub_type'] = self.translator.translate( "crossing", "traffic_signals") # streets intersection['sub_points'] = [] result = DBControl().fetch_data("\ SELECT way_id, node_id, direction, way_tags, node_tags, \ ST_X(geom) as lon, ST_Y(geom) as lat \ from %s where id = %d" % (intersection_table_data, osm_id)) for street in result: sub_point = self.create_way_point( street['node_id'], street['lat'], street['lon'], self.parse_hstore_column(street['node_tags'])) if street['direction'] == "B": way_segment = self.create_way_segment( street['way_id'], self.parse_hstore_column(street['way_tags']), True) else: way_segment = self.create_way_segment( street['way_id'], self.parse_hstore_column(street['way_tags']), False) for key in way_segment: sub_point[key] = way_segment[key] sub_point[ 'intersection_bearing'] = geometry.bearing_between_two_points( intersection['lat'], intersection['lon'], sub_point['lat'], sub_point['lon']) intersection['sub_points'].append(sub_point) return intersection