class RouteServer(Servable):
def __init__(self, graphdb_filename, vertex_events, edge_events, vertex_reverse_geocoders):
if os.path.exists("%s.gbin" % graphdb_filename):
self.graph = Graph()
self.graph.deserialize(graphdb_filename, os.path.exists("%s.gmm" % graphdb_filename))
else:
graphdb = GraphDatabase( graphdb_filename )
self.graph = graphdb.incarnate()
self.vertex_events = vertex_events
self.edge_events = edge_events
self.vertex_reverse_geocoders = vertex_reverse_geocoders
def bounds(self, jsoncallback=None):
"""returns bounding box that encompases the bounding box from all member reverse geocoders"""
l, b, r, t = None, None, None, None
for reverse_geocoder in self.vertex_reverse_geocoders:
gl, gb, gr, gt = reverse_geocoder.bounds()
l = min(l,gl) if l else gl
b = min(b,gb) if b else gb
r = max(r,gr) if r else gr
t = max(t,gt) if t else gt
if jsoncallback is None:
return json.dumps([l,b,r,t])
else:
return "%s(%s)"%(jsoncallback,json.dumps([l,b,r,t]))
def vertices(self):
return "\n".join( [vv.label for vv in self.graph.vertices] )
vertices.mime = "text/plain"
def get_vertex_id_raw( self, lat, lon ):
for reverse_geocoder in self.vertex_reverse_geocoders:
ret = reverse_geocoder( lat, lon )
if ret is not None:
return ret
return None
def get_vertex_id( self, lat, lon ):
return json.dumps( self.get_vertex_id_raw( lat, lon ) )
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)} )
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))
