def path_retro(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0): if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset wo = WalkOptions() wo.transfer_penalty = transfer_penalty wo.walking_speed = walking_speed spt = self.graph.shortest_path_tree_retro(origin, dest, State(1, currtime), wo) wo.destroy() vertices, edges = spt.path_retro(origin) ret = list( postprocess_path(vertices, edges, self.vertex_events, self.edge_events)) spt.destroy() return json.dumps(ret, indent=2, cls=SelfEncoderHelper)
def path(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0, hill_reluctance=1.5, turn_penalty=None, walking_reluctance=None, max_walk=None, jsoncallback=None): performance = {} if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset # time path query t0 = time.time() wo = WalkOptions() wo.transfer_penalty = transfer_penalty wo.walking_speed = walking_speed wo.hill_reluctance = hill_reluctance if turn_penalty is not None: wo.turn_penalty = turn_penalty if walking_reluctance is not None: wo.walking_reluctance = walking_reluctance if max_walk is not None: wo.max_walk = max_walk spt = self.graph.shortest_path_tree(origin, dest, State(1, currtime), wo) vertices, edges = spt.path(dest) performance['path_query_time'] = time.time() - t0 t0 = time.time() narrative = list( postprocess_path(vertices, edges, self.vertex_events, self.edge_events)) performance['narrative_postprocess_time'] = time.time() - t0 t0 = time.time() wo.destroy() spt.destroy() performance['cleanup_time'] = time.time() - t0 ret = {'narrative': narrative, 'performance': performance} if jsoncallback is None: return json.dumps(ret, indent=2, cls=SelfEncoderHelper) else: return "%s(%s)" % ( jsoncallback, json.dumps(ret, indent=2, cls=SelfEncoderHelper))
def path(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0, hill_reluctance=1.5, turn_penalty=None, walking_reluctance=None, max_walk=None, jsoncallback=None): performance = {} if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset # time path query t0 = time.time() wo = WalkOptions() wo.transfer_penalty=transfer_penalty wo.walking_speed=walking_speed wo.hill_reluctance=hill_reluctance if turn_penalty is not None: wo.turn_penalty = turn_penalty if walking_reluctance is not None: wo.walking_reluctance = walking_reluctance if max_walk is not None: wo.max_walk = max_walk spt = self.graph.shortest_path_tree( origin, dest, State(1,currtime), wo ) vertices, edges = spt.path( dest ) performance['path_query_time'] = time.time()-t0 t0 = time.time() narrative = list(postprocess_path(vertices, edges, self.vertex_events, self.edge_events)) performance['narrative_postprocess_time'] = time.time()-t0 t0 = time.time() wo.destroy() spt.destroy() performance['cleanup_time'] = time.time()-t0 ret = {'narrative':narrative, 'performance':performance} if jsoncallback is None: return json.dumps(ret, indent=2, cls=SelfEncoderHelper) else: return "%s(%s)"%(jsoncallback,json.dumps(ret, indent=2, cls=SelfEncoderHelper))
def get_cell_weights(self, cellIndex=0, dep_time=0): sys.stderr.write("get_cell_weights cell index: " + str(cellIndex) + "\n") # if the departure time is not specified, set it if (dep_time == 0): dep_time = int(time.time()) wo = WalkOptions() wo.transfer_penalty=60 wo.walking_speed=1.0 wo.walking_reluctance=1.0 wo.max_walk=10000 wo.walking_overage=0.1 core.shortestPathForKDTree(self.graph, State(self.graph.num_agencies,dep_time), wo, cellIndex) yield "Finished!"
def path_retro(self, origin, dest, currtime, transfer_penalty=0, walking_speed=1.0): wo = WalkOptions() wo.transfer_penalty = transfer_penalty wo.walking_speed = walking_speed spt = self.graph.shortest_path_tree_retro( origin, dest, State(1,currtime), wo ) wo.destroy() vertices, edges = spt.path_retro( origin ) ret = [] for i in range(len(edges)): edgetype = edges[i].payload.__class__ if edgetype in self.event_dispatch: ret.append( self.event_dispatch[ edges[i].payload.__class__ ]( vertices[i], edges[i], vertices[i+1] ) ) spt.destroy() return json.dumps(ret)
def path_retro(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0): if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset wo = WalkOptions() wo.transfer_penalty = transfer_penalty wo.walking_speed = walking_speed spt = self.graph.shortest_path_tree_retro( origin, dest, State(1,currtime), wo ) wo.destroy() vertices, edges = spt.path_retro( origin ) ret = list(postprocess_path(vertices, edges, self.vertex_events, self.edge_events)) spt.destroy() return json.dumps(ret, indent=2, cls=SelfEncoderHelper)
def path(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0, hill_reluctance=1.5, turn_penalty=None, walking_reluctance=None, max_walk=None, jsoncallback=None): performance = {} if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset # time path query t0 = time.time() wo = WalkOptions() wo.transfer_penalty=transfer_penalty wo.walking_speed=walking_speed wo.hill_reluctance=hill_reluctance if turn_penalty is not None: wo.turn_penalty = turn_penalty if walking_reluctance is not None: wo.walking_reluctance = walking_reluctance if max_walk is not None: wo.max_walk = max_walk spt = self.graph.shortest_path_tree( origin, dest, State(1,currtime), wo ) try: vertices, edges = spt.path( dest ) except Exception, e: return json.dumps( {'error':str(e)} )
def path(self, origin, dest, currtime=None, time_offset=None, transfer_penalty=0, walking_speed=1.0, hill_reluctance=1.5, turn_penalty=None, walking_reluctance=None, max_walk=None, jsoncallback=None): performance = {} if currtime is None: currtime = int(time.time()) if time_offset is not None: currtime += time_offset # time path query t0 = time.time() wo = WalkOptions() wo.transfer_penalty=transfer_penalty wo.walking_speed=walking_speed wo.hill_reluctance=hill_reluctance if turn_penalty is not None: wo.turn_penalty = turn_penalty if walking_reluctance is not None: wo.walking_reluctance = walking_reluctance if max_walk is not None: wo.max_walk = max_walk spt = self.graph.shortest_path_tree( origin, dest, State(1,currtime), wo, maxtime=4000000000, hoplimit=2000000, weightlimit=4000000000 ) try: vertices, edges = spt.path( dest ) except Exception, e: return json.dumps( {'error':str(e)} )
d0s = time.strftime('%a %b %d %Y', t0t) t0 = time.mktime(t0t) print 'search date: ', d0s print 'search time: ', time.ctime(t0), t0 gtfsdb = GTFSDatabase ('./trimet.gtfsdb') gdb = GraphDatabase ('./test.gdb' ) osmdb = OSMDB ('./testgrid.osmdb' ) g = gdb.incarnate () # FOOT - would be better if i could specify 0 boardings not 0 transfers wo = WalkOptions() wo.max_walk = 2000 wo.walking_overage = 0.0 wo.walking_speed = 1.0 # trimet uses 0.03 miles / 1 minute - but it uses straight line distance as well wo.transfer_penalty = 99999 wo.walking_reluctance = 1 wo.max_transfers = 0 # make much higher? wo.transfer_slack = 60 * 5 wo_foot = wo # TRANSIT wo = WalkOptions() wo.max_walk = 2000 wo.walking_overage = 0.0 wo.walking_speed = 1.0 # trimet uses 0.03 miles / 1 minute - but it uses straight line distance as well wo.transfer_penalty = 60 * 10 wo.walking_reluctance = 1.5 wo.max_transfers = 5 wo.transfer_slack = 60 * 4
t0s = "Tue Mar 09 08:50:00 2010" t0t = time.strptime(t0s) d0s = time.strftime('%a %b %d %Y', t0t) t0 = time.mktime(t0t) print d0s print time.ctime(t0), t0 gtfsdb = GTFSDatabase ('/home/andrew/data/pdx/trimet-2010-02-28.gtfsdb') gdb = GraphDatabase ('/home/andrew/data/pdx/trimet.gsdb' ) g = gdb.incarnate () wo = WalkOptions() wo.max_walk = 1600 wo.walking_overage = 0.0 wo.walking_speed = 1.0 # trimet uses 0.03 miles / 1 minute - but it uses straight line distance as well wo.transfer_penalty = 60 * 10 wo.walking_reluctance = 2 wo.max_transfers = 5 wo.transfer_slack = 60 * 4 while(True) : input = raw_input('o d t / wo > ').split(' ') if len(input) == 0 : sys.exit(0) elif input[0] == 'wo' : try : wo.max_walk = int(raw_input('wo.max_walk = ')) wo.walking_overage = float(raw_input('wo.walking_overage = ')) wo.walking_speed = float(raw_input('wo.walking_speed = ')) wo.transfer_penalty = int(raw_input('wo.transfer_penalty = ')) wo.walking_reluctance = float(raw_input('wo.walking_reluctance = ')) except :
stop_time = datetime.fromtimestamp(stop) start_time -= origin_walk_penalty finally: if tree: tree.destroy() return (start_time, stop_time) #narrative = list(postprocess_path(vertices, edges)) #return json.dumps({ 'narrative': narrative }, indent=3, cls=SelfEncoderHelper) walk_options = WalkOptions() walk_options.transfer_penalty = 0 walk_options.walking_speed = 1.0 walk_options.hill_reluctance = 1.5 #walk_options.turn_penalty = #walk_options.walking_reluctance = #walk_options.max_walk = # The full Metro King County boundaries #lon_start = -122.506729 #lon_stop = -121.785828 #lat_start = 47.9323654 #lat_stop = 47.1891136 # Seattle & the East side lat_start = 47.7 lat_stop = 47.5
gdb = GraphDatabase("../data/trimet-linked-20100117.gsdb") g = gdb.incarnate() station_labels = [s[0] for s in gtfsdb.stops()] origins = station_labels[:] destinations = station_labels[:] random.shuffle(origins) random.shuffle(destinations) pairs = zip(origins, destinations)[:SAMPLE_SIZE] wo = WalkOptions() wo.max_walk = 1000 # about 1/2 mile wo.walking_overage = 0.2 wo.walking_speed = 0.8 # trimet uses 0.03 miles / 1 minute wo.transfer_penalty = 0 wo.walking_reluctance = 1 residuals = [] magnitudes = [] normalize = 0 for o, d in pairs: og = gtfsdb.stop(o) dg = gtfsdb.stop(d) # print 'Origin (mds, gtfs)' # print o, og # print 'Destination (mds, gtfs)' # print d, dg print "from %s to %s (%f, %f) -> (%f, %f)" % (og[0], dg[0], og[2], og[3], dg[2], dg[3]) # replace
nodes['sta-' + id] = (lat, lon) os.environ['TZ'] = 'US/Pacific' time.tzset() t0s = "Tue Nov 16 07:50:30 2010" t0t = time.strptime(t0s) d0s = time.strftime('%a %b %d %Y', t0t) t0 = time.mktime(t0t) print 'search date: ', d0s print 'search time: ', time.ctime(t0), t0 wo = WalkOptions() wo.max_walk = 2000 wo.walking_overage = 0.0 wo.walking_speed = 1.0 wo.transfer_penalty = 60 * 6 wo.walking_reluctance = 1.0 wo.max_transfers = 4 orig = 'osm-37476896' #wes dest = 'sta-2575' #to eas assist_spt = ag.shortest_path_tree(dest, None, State(1, 0)) spt_a = g.shortest_path_tree_assist(assist_spt, orig, dest, State(1, t0), wo) spt_b = g.shortest_path_tree(orig, dest, State(1, t0), wo) for spt in [spt_a, spt_b]: print '-----search and path-----' print 'number of vertices in spt:', len(spt.vertices) p = spt.path(dest) if p == None: print "DESTINATION NOT REACHED." sys.exit(0)
def get_walk( lat1, lon1, lat2, lon2 ): vertex1 = get_nearest_vertex( lat1, lon1 ) vertex2 = get_nearest_vertex( lat2, lon2 ) wo = WalkOptions() wo.transfer_penalty = 0 wo.walking_speed = 1.0 wo.hill_reluctance = 1.5 try: spt = graph.shortest_path_tree( vertex1, vertex2, State(1, starttime), wo ) vertices, edges = spt.path( vertex2 ) except Exception: print "couldn't find a path between (%.4f,%4f) and (%.4f,%.4f)" % ( lat1, lon1, lat2, lon2) return None first_walk_time = None last_walk_time = None walk_streets = [] walk_points = [] walk_distance = 0 for edge1,vertex1,edge2,vertex2 in zip( [None]+edges, vertices, edges+[None], vertices[1:]+[None,None] ): edge1payload = edge1.payload if edge1 else None edge2payload = edge2.payload if edge2 else None if edge2 is not None and isinstance(edge2.payload, Street): # Add the street geometry for this edge to our walk_points geometry_chunk = osmdb.edge( edge2.payload.name )[5] if edge2.payload.reverse_of_source: walk_points.extend( reversed( geometry_chunk ) ) else: walk_points.extend( geometry_chunk ) # Add this edge's distance in meters to the walk_distance walk_distance += edge2.payload.length if edge1 and edge2 and isinstance(edge1.payload, Street) and edge1.payload.way != edge2.payload.way: # We hit a turn walk_streets.append(get_street_name_for_edge(edge2)) if (edge1 is None or not isinstance(edge1.payload, Street)) and (edge2 and isinstance(edge2.payload, Street)): # We started walking walk_streets.append(get_street_name_for_edge(edge2)) if first_walk_time is None: first_walk_time = vertex1.state.time if (edge1 and isinstance(edge1.payload, Street)) and (edge2 is None or not isinstance(edge2.payload, Street)): # We stopped walking last_walk_time = vertex1.state.time if first_walk_time is None or last_walk_time is None: walk_time = 0 else: walk_time = last_walk_time - first_walk_time ret = Walk() ret.time = walk_time ret.streets = walk_streets ret.points = walk_points ret.distance = walk_distance / 1609.344 # convert to miles return ret
def path_xml(self, origlon, origlat, destlon, destlat, dep_time=0, arr_time=0, max_results=1, timezone="", transfer_penalty=60, walking_speed=1.0, walking_reluctance=1.0, max_walk=10000, walking_overage=0.1, seqno=0, street_mode="walk", transit_mode="Both", less_walking="False", udid="", version="2.0", two_way_routing="True"): if (two_way_routing == "False"): self.two_way_routing = False # set hard bounds on max_results [0,25] if (max_results < 0): max_results = 0 elif (max_results > 25): max_results = 25 sys.stderr.write("[xml_path_entry_point," + str(time.time()) + "] \"origlon=" + str(origlon) + "&origlat=" + str(origlat) + "&destlon=" + str(destlon) + "&destlat=" + str(destlat) + "&dep_time=" + str(dep_time) + "&arr_time=" + str(arr_time) + "&timezone=" + str(timezone) + "&transfer_penalty=" + str(transfer_penalty) + "&walking_speed=" + str(walking_speed) + "&walking_reluctance=" + str(walking_reluctance) + "&max_walk=" + str(max_walk) + "&walking_overage=" + str(walking_overage) + "&seqno=" + str(seqno) + "&street_mode=\"" + str(street_mode) + "\"&less_walking=\"" + str(less_walking) + "\"&udid=\"" + str(udid) + "\"&version=" + str(version) + "\"\n") if (origlon <= ChicagoMap.bounding_lon_left or origlon >= ChicagoMap.bounding_lon_right or origlat <= ChicagoMap.bounding_lat_bottom or origlat >= ChicagoMap.bounding_lat_top or destlon <= ChicagoMap.bounding_lon_left or destlon >= ChicagoMap.bounding_lon_right or destlat <= ChicagoMap.bounding_lat_bottom or destlat >= ChicagoMap.bounding_lat_top): sys.stderr.write("[exit_outside_bounding_box," + str(time.time()) + "]\n") raise RoutingException #return '<?xml version="1.0"?><routes></routes>' # initialize spt to 'None' object spt = None # initialize walk options object wo = WalkOptions() # create database connections pgosmdb_conn = self.pgosmdb.create_pgosmdb_connection() pggtfsdb_conn = self.pggtfsdb.create_pggtfsdb_connection() try: # if the departure time is not specified, set it if (dep_time == 0): dep_time = int(time.time()) # if the timezone is not specified, default to "America/Chicago" if (timezone == ""): timezone = "America/Chicago" # get origin and destination nodes from osm map sys.stderr.write("[get_osm_vertex_from_coords," + str(time.time()) + "]\n") orig_osm, orig_osm_dist = self.pgosmdb.get_osm_vertex_from_coords(pgosmdb_conn, origlon, origlat) dest_osm, dest_osm_dist = self.pgosmdb.get_osm_vertex_from_coords(pgosmdb_conn, destlon, destlat) #print "\nOrigin OSM: " + str(orig_osm) + " (" + str(orig_osm_dist) + ")" #print "Destination OSM: " + str(dest_osm) + " (" + str(dest_osm_dist) + ")\n" # get origin and destination nodes from gtfs database sys.stderr.write("[get_station_vertex_from_coords," + str(time.time()) + "]\n") orig_sta, orig_sta_dist = self.pggtfsdb.get_station_vertex_from_coords(pggtfsdb_conn, origlon, origlat) dest_sta, dest_sta_dist = self.pggtfsdb.get_station_vertex_from_coords(pggtfsdb_conn, destlon, destlat) #print "Origin STA: " + str(orig_sta) + " (" + str(orig_sta_dist) + ")" #print "Destination STA: " + str(dest_sta) + " (" + str(dest_sta_dist) + ")\n" # get coordinates for origin node if (orig_osm_dist < orig_sta_dist): origin = orig_osm sys.stderr.write("[get_coords_for_osm_vertex," + str(time.time()) + "]\n") orig_node_lat, orig_node_lon = self.pgosmdb.get_coords_for_osm_vertex(pgosmdb_conn, origin) else: origin = orig_sta sys.stderr.write("[get_coords_for_station_vertex," + str(time.time()) + "]\n") orig_node_lat, orig_node_lon = self.pggtfsdb.get_coords_for_station_vertex(pggtfsdb_conn, origin) # get coordinates for destination node if (dest_osm_dist < dest_sta_dist): dest = dest_osm sys.stderr.write("[get_coords_for_osm_vertex," + str(time.time()) + "]\n") dest_node_lat, dest_node_lon = self.pgosmdb.get_coords_for_osm_vertex(pgosmdb_conn, dest) else: dest = dest_sta sys.stderr.write("[get_coords_for_station_vertex," + str(time.time()) + "]\n") dest_node_lat, dest_node_lon = self.pggtfsdb.get_coords_for_station_vertex(pggtfsdb_conn, dest) #print "Origin: " + str(origin) #print "Destination: " + str(dest) + "\n" #print "Origin coords: " + str(orig_node_lat) + ", " + str(orig_node_lon) #print "Destination coords: " + str(dest_node_lat) + ", " + str(dest_node_lon) # determine distance from actual origin/destination to osm nodes orig_distance = vincenty(float(origlat), float(origlon), orig_node_lat, orig_node_lon) dest_distance = vincenty(dest_node_lat, dest_node_lon, float(destlat), float(destlon)) #print "Origin distance: " + str(orig_distance) #print "Destination distance: " + str(dest_distance) # calculate time to origin and destination nodes (seconds) time_to_orig = int(round(float( float(orig_distance) / float(walking_speed) ))) time_to_dest = int(round(float( float(dest_distance) / float(walking_speed) ))) #print "Origin time: " + str(time_to_orig) #print "Destination time: " + str(time_to_dest) # adjust departure time by time needed to reach origin node dep_time = (dep_time + time_to_orig) # adjust arrival time by time needed to reach destination node if (arr_time != 0): arr_time = (arr_time - time_to_dest) #print "Adjusted departure time: " + str(dep_time) # set walk options wo.transfer_penalty=transfer_penalty wo.walking_speed=walking_speed wo.walking_reluctance=walking_reluctance wo.max_walk=max_walk wo.walking_overage=walking_overage # check for wheelchair street_mode if (street_mode == "wheelchair"): wo.with_wheelchair = int(True) wo.transfer_penalty = 180 else: wo.with_wheelchair = int(False) # check for bike street_mode if (street_mode == "bike"): wo.transfer_penalty = 120 # check for transit_mode if (transit_mode == "Both"): wo.transit_types = int(14) elif (transit_mode == "Bus"): wo.transit_types = int(8) elif (transit_mode == "Rail"): wo.transit_types = int(6) elif (transit_mode == "None"): wo.transit_types = int(0) # check for less_walking flag if (less_walking == "True"): wo.walking_reluctance *= 10.0 # create RouteInfo object route_info = RouteInfo() route_info.origlat = origlat route_info.origlon = origlon route_info.dep_time_diff = time_to_orig route_info.destlat = destlat route_info.destlon = destlon route_info.arr_time_diff = time_to_dest route_info.street_mode = street_mode yield "--multipart-path_xml-boundary1234\n"; # loop to create multiple responses for q in range(max_results): if (spt is not None): spt.destroy_no_hash() route_info.first_edge = True route_info.last_edge = False # initialize return string ret_string = 'Content-Type: text/xml\n\n<?xml version="1.0"?><routes>' if (arr_time == 0): (spt, edges, vertices) = self.shortest_path(origin,dest,dep_time,wo) else: (spt, edges, vertices) = self.shortest_path_retro(origin,dest,arr_time,wo) # if there are no edges or vertices (i.e., there is no path found) if ((edges is None) or (vertices is None)): raise RoutingException # create WalkPath object walk_path = WalkPath() walk_path.lastlat = origlat walk_path.lastlon = origlon walk_path.timezone = timezone # string to store returned route curr_route = "" route_info.actual_dep_time = vertices[0].payload.time - time_to_orig route_info.actual_arr_time = vertices[-1].payload.time + time_to_dest # iterate through all edges in the route sys.stderr.write("[edges_loop," + str(time.time()) + "]\n") # determine the number of edges edges_len = len(edges) for i in range(edges_len): if (i == (edges_len-1)): route_info.last_edge = True elif (i == (edges_len-2) and edges[i+1].payload.__class__ == graphserver.core.Link): route_info.last_edge = True elif (i == (edges_len-3) and edges[i+1].payload.__class__ == graphserver.core.Link and edges[i+2].payload.__class__ == graphserver.core.Link): route_info.last_edge = True edgetype = edges[i].payload.__class__ if edgetype in self.event_dispatch: (new_event, walk_path, route_info) = self.event_dispatch[ edges[i].payload.__class__ ]( vertices[i], edges[i], vertices[i+1], walk_path, route_info, pgosmdb_conn, pggtfsdb_conn) curr_route += new_event ret_string += '<route dep_time="' + str(route_info.actual_dep_time) + '" req_dep_time="' + str(dep_time - time_to_orig) + '" arr_time="' + str(route_info.actual_arr_time) + '" req_arr_time="' + str(arr_time) + '" origlat="' + str(origlat) + '" origlon="' + str(origlon) + '" destlat="' + str(destlat) + '" destlon="' + str(destlon) + '" timezone="' + timezone + '" total_time="' + str(route_info.actual_arr_time - route_info.actual_dep_time) + '" total_walk_distance="' + str(int(round(walk_path.total_distance)) + int(round(orig_distance)) + int(round(dest_distance))) + '" walking_speed="' + str(walking_speed) + '" seqno="' + str(seqno) + '" version="' + str(version) + '">' + curr_route + '</route>' # close return string if q == max_results: ret_string += '</routes>\n\n--multipart-path_xml-boundary1234--\n\n' else: ret_string += '</routes>\n\n--multipart-path_xml-boundary1234\n' sys.stderr.write("[xml_path_exit_point," + str(time.time()) + "]\n") # return routes xml yield xstr(str(ret_string)) if arr_time == 0: dep_time = route_info.actual_dep_time + time_to_orig + 60 else: arr_time = route_info.actual_arr_time - time_to_dest - 60 except RoutingException: if (spt is not None): spt.destroy_no_hash() yield '\n\n--multipart-path_xml-boundary1234\nContent-Type: text/xml\n\n<?xml version="1.0"?><routes></routes>--multipart-path_xml-boundary1234--\n\n ' finally: #yield '\n\n--multipart-path_xml-boundary1234--\n\n' # close database connections self.pgosmdb.close_pgosmdb_connection(pgosmdb_conn) self.pggtfsdb.close_pggtfsdb_connection(pggtfsdb_conn) # destroy WalkOptions object wo.destroy() # destroy shortest path tree if (spt is not None): spt.destroy_no_hash()
def getUrbanExplorerBlob(self, origlon, origlat, destlon, destlat, arrive_time, street_mode="walk", transit_mode="Both", less_walking="False", transfer_penalty=60, walking_speed=1.0, walking_reluctance=1.0, max_walk=10000, walking_overage=0.1,start_time=0,switch=1): # get origin and destination nodes from osm map sys.stderr.write("[get_osm_vertex_from_coords," + str(time.time()) + "]\n") orig_osm, orig_osm_dist = self.pgosmdb.get_osm_vertex_from_coords(origlon, origlat) dest_osm, dest_osm_dist = self.pgosmdb.get_osm_vertex_from_coords(destlon, destlat) # get origin and destination nodes from gtfs database sys.stderr.write("[get_station_vertex_from_coords," + str(time.time()) + "]\n") orig_sta, orig_sta_dist = self.pggtfsdb.get_station_vertex_from_coords(origlon, origlat) dest_sta, dest_sta_dist = self.pggtfsdb.get_station_vertex_from_coords(destlon, destlat) # get coordinates for origin node if (orig_osm_dist < orig_sta_dist): origin = orig_osm sys.stderr.write("[get_coords_for_osm_vertex," + str(time.time()) + "]\n") orig_node_lat, orig_node_lon = self.pgosmdb.get_coords_for_osm_vertex(origin) else: origin = orig_sta sys.stderr.write("[get_coords_for_station_vertex," + str(time.time()) + "]\n") orig_node_lat, orig_node_lon = self.pggtfsdb.get_coords_for_station_vertex(origin) # get coordinates for destination node if (dest_osm_dist < dest_sta_dist): dest = dest_osm sys.stderr.write("[get_coords_for_osm_vertex," + str(time.time()) + "]\n") dest_node_lat, dest_node_lon = self.pgosmdb.get_coords_for_osm_vertex(dest) else: dest = dest_sta sys.stderr.write("[get_coords_for_station_vertex," + str(time.time()) + "]\n") dest_node_lat, dest_node_lon = self.pggtfsdb.get_coords_for_station_vertex(dest) wo = WalkOptions() wo.transfer_penalty=transfer_penalty wo.walking_speed=walking_speed wo.walking_reluctance=walking_reluctance wo.max_walk=max_walk wo.walking_overage=walking_overage # check for wheelchair street_mode if (street_mode == "wheelchair"): wo.with_wheelchair = int(True) wo.transfer_penalty = 180 else: wo.with_wheelchair = int(False) # check for bike street_mode if (street_mode == "bike"): wo.transfer_penalty = 120 # check for transit_mode if (transit_mode == "Both"): wo.transit_types = int(14) elif (transit_mode == "Bus"): wo.transit_types = int(8) elif (transit_mode == "Rail"): wo.transit_types = int(6) elif (transit_mode == "None"): wo.transit_types = int(0) # check for less_walking flag if (less_walking == "True"): wo.walking_reluctance *= 10.0 if (start_time == 0): start_time = int(time.time()) if (switch == 1): graphserver.core.makeImage(self.graph.soul, origin, dest, State(self.graph.num_agencies,start_time), State(self.graph.num_agencies,arrive_time), wo) return open("explorerimages/blah.png", "rb").read() else: graphserver.core.makeUrbanExplorerBlob(self.graph.soul, origin, dest, State(self.graph.num_agencies,start_time), State(self.graph.num_agencies,arrive_time), wo) return open("explorerimages/blah2.png", "rb").read()
def run(self): self.gtfsdb = GTFSDatabase(self.gtfsdb) self.gdb = GraphDatabase(self.gdb) # Calculate an origin-destination matrix for the graph's stations print "Loading Graphserver DB..." self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Loading SQLite Graphserver graph...")) g = self.gdb.incarnate() # Set up distance-preserving projection system # Make a grid over the study area and save its geographic coordinates MARGIN = 8000 # meters beyond all stations, diagonally min_lon, min_lat, max_lon, max_lat = self.gtfsdb.extent() geod = pyproj.Geod(ellps="WGS84") min_lon, min_lat, arc_dist = geod.fwd(min_lon, min_lat, 180 + 45, MARGIN) max_lon, max_lat, arc_dist = geod.fwd(max_lon, max_lat, 45, MARGIN) proj = pyproj.Proj(proj="sinu", ellps="WGS84") min_x, min_y = proj(min_lon, min_lat) proj = pyproj.Proj( proj="sinu", ellps="WGS84", lon_0=min_lon, y_0=-min_y ) # why doesn't m parameter work for scaling by 100? grid_dim = array(proj(max_lon, max_lat), dtype=int32) / 100 max_x, max_y = grid_dim print "\nMaking grid with dimesions: ", max_x, max_y self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Making %i by %i grid..." % (max_x, max_y))) # later, use reshape/flat to switch between 1d and 2d array representation grid_latlon = empty((max_x, max_y, 2), dtype=float32) for y in range(0, max_y): self.emit(QtCore.SIGNAL("progress(int, int)"), y, max_y) for x in range(0, max_x): # inverse project meters to lat/lon grid_latlon[x, y] = proj(x * 100, y * 100, inverse=True) station_vertices = [v for v in g.vertices if v.label[0:4] == "sta-"] station_labels = [v.label for v in station_vertices] n_stations = len(station_vertices) print "Finding station coordinates..." self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Projecting station coordinates...")) station_coords = empty((n_stations, 2), dtype=float32) for i, label in enumerate(station_labels): stop_id, stop_name, lat, lon = self.gtfsdb.stop(label[4:]) station_coords[i] = proj(lon, lat) if i % 20 == 0: self.emit(QtCore.SIGNAL("progress(int, int)"), i, n_stations) station_coords /= 100 # ELIMINATE STATIONS WITH SAME INTEGRAL COORDINATES # self.emit( QtCore.SIGNAL( 'say(QString)' ), QtCore.QString( 'Eliminating equivalent stations...' ) ) # while len(station_coords) > 0 : # coord = # mask = station_coords != station_coords[i] # station_coords = station_coords[mask] # newer version follows # self.emit( QtCore.SIGNAL( 'say(QString)' ), QtCore.QString( 'Eliminating equivalent stations...' ) ) # station_labels = np.array(station_labels) # station_coords_new = [] # station_labels_new = [] # while len(station_coords) > 0 : # coord = np.round(station_coords[0]) # minIdx = np.argmin(np.sum(np.abs(station_coords - coord), axis=1)) # station_labels_new.append(station_labels[minIdx]) # station_coords_new.append(station_coords[minIdx]) # mask = np.any(np.round(station_coords) != coord, axis=1) # #print mask # #print len(station_coords) # #print coord # #print station_coords[np.logical_not(mask)] # station_coords = station_coords[mask][:] # station_labels = station_labels[mask][:] # self.emit( QtCore.SIGNAL( 'progress(int, int)' ), n_stations - len(station_coords_new), n_stations ) # # station_labels = station_labels_new # station_coords = station_coords_new # station_vertices = [g.get_vertex(slabel) for slabel in station_labels_new] # n_stations = len(station_labels) # print len(station_labels), len(station_coords), len(station_vertices) print "Making OD matrix..." os.environ["TZ"] = "US/Pacific" time.tzset() t0s = "Tue Mar 09 08:00:00 2010" t0t = time.strptime(t0s) d0s = time.strftime("%a %b %d %Y", t0t) t0 = int(time.mktime(t0t)) print "search date: ", d0s print "search time: ", time.ctime(t0), t0 wo = WalkOptions() wo.max_walk = 20000 wo.walking_overage = 0.1 wo.walking_speed = 1 # trimet uses 0.03 miles / 1 minute wo.transfer_penalty = 60 * 10 wo.walking_reluctance = 2 wo.max_transfers = 40 wo.transfer_slack = 60 * 4 matrix = zeros( (n_stations, n_stations), dtype=float ) # dtype could be uint16 except that there are inf's ---- why? colortable = [QtGui.QColor(i, i, i).rgb() for i in range(256)] colortable[254] = QtGui.QColor(050, 128, 050).rgb() colortable[255] = QtGui.QColor(255, 050, 050).rgb() matrixImage = QtGui.QImage(max_x, max_y, QtGui.QImage.Format_Indexed8) matrixImage.fill(0) matrixImage.setColorTable(colortable) for origin_idx in range(n_stations): sys.stdout.write("\rProcessing %i / %i ..." % (origin_idx, n_stations)) sys.stdout.flush() self.emit( QtCore.SIGNAL("say(QString)"), QtCore.QString("Making OD matrix (station %i/%i)..." % (origin_idx, n_stations)), ) self.emit(QtCore.SIGNAL("progress(int, int)"), origin_idx, n_stations) origin_label = station_labels[origin_idx] # g.spt_in_place(origin_label, None, State(1, t0), wo) spt = g.shortest_path_tree(origin_label, None, State(1, t0), wo) for dest_idx in range(n_stations): dest_label = station_labels[dest_idx] dest_vertex = spt.get_vertex(dest_label) # first board time should be subtracted here # if dest_vertex.payload is None : if dest_vertex is None: print "Unreachable vertex. Set to infinity.", dest_idx, dest_label delta_t = inf else: # delta_t = dest_vertex.best_state.time - t0 bs = dest_vertex.best_state delta_t = bs.time - t0 - bs.initial_wait if delta_t < 0: print "Negative trip time; set to 0." delta_t = 0 matrix[origin_idx, dest_idx] = delta_t # sys.stdout.write( '%i %i\n' % (delta_t, dest_vertex.payload.initial_wait) ) # sys.stdout.flush() # time.sleep(0.5) if dest_idx == origin_idx - 1: color = 254 elif dest_idx == origin_idx: color = 255 else: color = 253 - delta_t * 3 / 60 if color < 0: color = 0 coord = station_coords[dest_idx] x = coord[0] y = coord[1] if color >= 254: for x2 in range(x - 1, x + 2): for y2 in range(y - 1, y + 2): matrixImage.setPixel(x2, y2, color) else: matrixImage.setPixel(x, y, color) self.emit(QtCore.SIGNAL("display(QImage)"), matrixImage) spt.destroy() # time.sleep(1) print x * y, "points, done." self.emit(QtCore.SIGNAL("say(QString)"), QtCore.QString("Saving as gzipped numpy ndarrays...")) savez( "od_matrix.npz", station_labels=station_labels, station_coords=station_coords, grid_dim=grid_dim, grid_latlon=grid_latlon, matrix=matrix, )
start_time = datetime.fromtimestamp(start) stop_time = datetime.fromtimestamp(stop) start_time -= origin_walk_penalty finally: if tree: tree.destroy() return (start_time, stop_time) #narrative = list(postprocess_path(vertices, edges)) #return json.dumps({ 'narrative': narrative }, indent=3, cls=SelfEncoderHelper) walk_options = WalkOptions() walk_options.transfer_penalty = 0 walk_options.walking_speed = 1.0 walk_options.hill_reluctance = 1.5 #walk_options.turn_penalty = #walk_options.walking_reluctance = #walk_options.max_walk = # The full Metro King County boundaries #lon_start = -122.506729 #lon_stop = -121.785828 #lat_start = 47.9323654 #lat_stop = 47.1891136 # Seattle & the East side lat_start = 47.7 lat_stop = 47.5