def path(self, slon, slat, dlon, dlat, time):
u_obj = []
#Creates the union of all used objectives
for p in paths_array:
for o in p['objectives'] :
if not o in u_obj:
u_obj.append( o )
u_obj = self.sort_objectives( u_obj )
p = tuple()
c = self.analyse_date( time )
#Call martins with the sorted objectives
for y in paths_array:
s = self.g.match( y['starting_layer']['name'], float(slon), float(slat))
d = self.g.match( y['destination_layer']['name'], float(dlon), float(dlat))
tmp = y['objectives']
tmp = self.sort_objectives( tmp )
t = len( tmp )
print c['seconds'], c['days']
if t == 0:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days']),[],u_obj )
elif t == 1:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0] ), [ tmp[0] ], u_obj )
elif t == 2:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0], tmp[1] ), [ tmp[0], tmp[1] ], u_obj )
elif t >= 3:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0], tmp[1], tmp[2] ), [ tmp[0], tmp[1], tmp[2] ], u_obj )
#Creates the array containing the user-oriented string for each objective
str_obj = ['Duration']
for j in u_obj:
if j == mumoro.dist:
str_obj.append( 'Distance' )
elif j == mumoro.cost:
str_obj.append( 'Cost' )
elif j == mumoro.elevation:
str_obj.append( 'Elevation ' )
elif j == mumoro.co2:
str_obj.append( 'CO2 Emission' )
elif j == mumoro.mode_change:
str_obj.append( 'Mode Change' )
elif j == mumoro.line_change:
str_obj.append( 'Line Change' )
cherrypy.response.headers['Content-Type']= 'application/json'
if len(p) == 0:
return json.dumps({'error': 'Impossible de calculer un itinéraire'})
print "Len of routes " + str( len( p ) )
print "len of first route " + str (len (p[0].nodes))
# print "route " + p[0].nodes[0]
ret = {
'objectives': str_obj,
'paths': []
}
for path in p:
p_str = {
'cost': [],
'type': 'FeatureCollection',
'crs': {
'type': 'EPSG',
'properties': {
'code': 4326,
'coordinate_order': [1,0]
}
}
}
for c in path.cost:
p_str['cost'].append(c)
features = []
markers = []
last_marker = None
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
last_node_id = path.nodes[0]
last_coord = self.g.coordinates(last_node_id)
last_layer = self.g.layer_object(last_node_id)
last_node = last_layer.node(last_node_id)
last_layer_name = last_coord[3]
for node_id in path.nodes:
coord = self.g.coordinates(node_id)
layer_name = coord[3]
layer = self.g.layer_object(node_id)
node = layer.node(node_id)
if(last_layer_name != layer_name):
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_layer.layer_name()}
# print "moo", last_node.route
feature['properties']['icon'] = last_layer.icon(last_node)
feature['properties']['color'] = last_layer.color(last_node)
features.append(feature)
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
connection = {
'type': 'feature',
'geometry': {
'type': 'Linestring',
'coordinates': [[last_coord[0], last_coord[1]], [coord[0], coord[1]]]
},
'properties': {'layer': 'connection'}
}
features.append(connection)
if last_layer.mode == mumoro.PublicTransport and last_layer != None:
# complete last marker
last_marker["properties"]["dest_stop_area"] = last_layer.stop_area(last_node.original_id).name
elif last_layer.mode == mumoro.Bike and last_layer != None:
bike_station = last_layer.bike_station(last_node)
if bike_station:
last_marker["properties"]["dest_station_name"] = bike_station.name
if layer.mode == mumoro.PublicTransport:
last_marker = {"type":"Feature",
"geometry":{"type":"Point",
"coordinates": [coord[0],
coord[1]]},
"properties": { "line": node.route,
"layer": "marker",
"headsign": node.headsign,
"marker_icon":
layer.marker_icon(node),
"line_icon":
layer.icon(node),
"line_name":
layer.line(node).long_name,
"stop_area":
layer.
stop_area(node.
original_id).
name,
"type": "bus_departure"}}
markers.append(last_marker)
elif layer.mode == mumoro.Bike:
bike_station = layer.bike_station(node)
if bike_station:
last_marker = {"type":"Feature",
"geometry":{"type":"Point",
"coordinates": [coord[0],
coord[1]]},
"properties": { "layer": "marker",
"marker_icon":
layer.marker_icon(node),
"bikes_av": bike_station.av_bikes,
"slots_av": bike_station.av_slots,
"station_name": bike_station.name,
"type": "bike_departure"}}
markers.append(last_marker)
last_layer_name = layer_name
last_layer = layer
last_node = node
last_node_id = node_id
last_coord = coord
coordinates.append([coord[0], coord[1]])
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_layer.layer_name()}
feature['properties']['icon'] = last_layer.icon(last_node)
feature['properties']['color'] = last_layer.color(last_node)
features.append(feature)
features.extend(markers)
p_str['features'] = features
ret['paths'].append(p_str)
return json.dumps(ret)
def path(self, slon, slat, dlon, dlat, time):
u_obj = []
#Creates the union of all used objectives
for p in paths_array:
for o in p['objectives'] :
if not o in u_obj:
u_obj.append( o )
u_obj = self.sort_objectives( u_obj )
p = tuple()
c = self.analyse_date( time )
#Call martins with the sorted objectives
for y in paths_array:
s = self.g.match( y['starting_layer']['name'], float(slon), float(slat))
d = self.g.match( y['destination_layer']['name'], float(dlon), float(dlat))
obj = y['objectives']
eps = y['epsilon']
nb_obj = len( obj )
print c['seconds'], c['days']
if eps == None:
if nb_obj == 0:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days']),[],u_obj )
elif nb_obj == 1:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0] ), [ obj[0] ], u_obj )
elif nb_obj == 2:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0], obj[1] ), [ obj[0], obj[1] ], u_obj )
elif nb_obj >= 3:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0], obj[1], obj[2] ), [ obj[0], obj[1], obj[2] ], u_obj )
else:
if nb_obj == 0:
p = p + mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'])
elif nb_obj == 1:
p = p + self.normalise_paths(mumoro.relaxed_martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0], eps[0]) , [ obj[0] ], u_obj )
elif nb_obj == 2:
p = p + self.normalise_paths(mumoro.relaxed_martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0], eps[0], obj[1], eps[1] ), [ obj[0], obj[1] ], u_obj )
elif nb_obj >= 3:
p = p + self.normalise_paths(mumoro.relaxed_martins(s, d, self.g.graph,c['seconds'], c['days'], obj[0], eps[0], obj[1], eps[1], obj[2], eps[2] ), [ obj[0], obj[1], obj[2] ], u_obj )
print "Longueur de p : ", len(p)
#Creates the array containing the user-oriented string for each objective
str_obj = ['Duration']
for j in u_obj:
if j == mumoro.dist:
str_obj.append( 'Distance' )
elif j == mumoro.cost:
str_obj.append( 'Cost' )
elif j == mumoro.elevation:
str_obj.append( 'Elevation ' )
elif j == mumoro.co2:
str_obj.append( 'CO2 Emission' )
elif j == mumoro.mode_change:
str_obj.append( 'Mode Change' )
elif j == mumoro.line_change:
str_obj.append( 'Line Change' )
elif j == mumoro.penibility:
str_obj.append( 'Penibility' )
cherrypy.response.headers['Content-Type']= 'application/json'
if len(p) == 0:
return json.dumps({'error': 'Impossible de calculer un itinéraire'})
ret = {'objectives': str_obj,
'paths': []}
def layer_split(l,x):
if(len(l[-1]) == 0):
l[-1].append(x)
elif(l[-1][-1][1] == x[1]):
if (l[-1][-1][1].mode == mumoro.PublicTransport and
l[-1][-1][0].route != x[0].route):
l.append([x])
else:
l[-1].append(x)
else:
l.append([x])
return l
for path in p:
p_str = {
'cost': [],
'type': 'FeatureCollection',
'crs': {
'type': 'EPSG',
'properties': {
'code': 4326,
'coordinate_order': [1,0]
}
}
}
for cost in path.cost:
p_str['cost'].append(cost)
it = reduce(layer_split,
[[self.g.layer_object(node_id).node(node_id),
self.g.layer_object(node_id),
node_id] for node_id in path.nodes],
[[]])
features = [{'type': 'feature',
'geometry': {'type': 'Linestring',
'coordinates': [[node[0].lon, node[0].lat] for node in seq]},
'properties': {'layer': seq[0][1].layer_name(),
'icon': seq[0][1].icon(seq[0][0]),
'color': seq[0][1].color(seq[0][0])}}
for seq in it]
# Si l'itinéraire inclus un trajet en bus, on va calculer les
# horaires
if (reduce(lambda v,seq: v or seq[0][1].mode == mumoro.PublicTransport,
it, False)):
it_times = reduce(lambda v,seq:
v + [self.g.get_duration(v[-1][-1],
[n[2] for n in seq],
c['days'])],
it,
[[c['seconds']]])
it_times.pop(0)
features.extend([ {"type":"Feature",
"geometry":{"type":"Point",
"coordinates": [seq[0][0].lon,
seq[0][0].lat]},
"properties": { "line": seq[0][0].route,
"layer": "marker",
"headsign": seq[0][0].headsign,
"marker_icon":
seq[0][1].marker_icon(seq[0][0]),
"line_icon":
seq[0][1].icon(seq[0][0]),
"start_time": it_time[0],
"arrival_time": it_time[1],
"line_name":
seq[0][1].line(seq[0][0]).long_name,
"stop_area":
seq[0][1].
stop_area(seq[0][0].original_id).name,
"dest_stop_area": seq[-1][1].stop_area(seq[-1][0].original_id).name,
"type": "bus_departure"}} for seq,it_time in zip(it,it_times) if seq[0][1].mode == mumoro.PublicTransport])
features.extend([{"type":"Feature",
"geometry":{"type":"Point",
"coordinates": [seq[0][0].lon,
seq[0][0].lat]},
"properties": { "layer": "marker",
"marker_icon": seq[0][1].marker_icon(seq[0][0]),
"bikes_av": seq[0][1].bike_station(seq[0][0]).av_bikes,
"slots_av": seq[0][1].bike_station(seq[0][0]).av_slots,
"station_name": seq[0][1].bike_station(seq[0][0]).name,
"dest_station_name": seq[-1][1].bike_station(seq[-1][0]).name,
"type": "bike_departure"}} for seq in it if seq[0][1].mode == mumoro.Bike])
p_str['features'] = features
ret['paths'].append(p_str)
return json.dumps(ret)
def path(self, slon, slat, dlon, dlat, time):
u_obj = []
#Creates the union of all used objectives
for p in paths_array:
for o in p['objectives']:
if not o in u_obj:
u_obj.append(o)
u_obj = self.sort_objectives(u_obj)
p = tuple()
c = self.analyse_date(time)
#Call martins with the sorted objectives
for y in paths_array:
s = self.g.match(y['starting_layer']['name'], float(slon),
float(slat))
d = self.g.match(y['destination_layer']['name'], float(dlon),
float(dlat))
tmp = y['objectives']
tmp = self.sort_objectives(tmp)
t = len(tmp)
print c['seconds'], c['days']
if t == 0:
p = p + self.normalise_paths(
mumoro.martins(s, d, self.g.graph, c['seconds'],
c['days']), [], u_obj)
elif t == 1:
p = p + self.normalise_paths(
mumoro.martins(s, d, self.g.graph, c['seconds'], c['days'],
tmp[0]), [tmp[0]], u_obj)
elif t == 2:
p = p + self.normalise_paths(
mumoro.martins(s, d, self.g.graph, c['seconds'], c['days'],
tmp[0], tmp[1]), [tmp[0], tmp[1]], u_obj)
elif t >= 3:
p = p + self.normalise_paths(
mumoro.martins(s, d, self.g.graph, c['seconds'], c['days'],
tmp[0], tmp[1], tmp[2]),
[tmp[0], tmp[1], tmp[2]], u_obj)
#Creates the array containing the user-oriented string for each objective
str_obj = ['Duration']
for j in u_obj:
if j == mumoro.dist:
str_obj.append('Distance')
elif j == mumoro.cost:
str_obj.append('Cost')
elif j == mumoro.elevation:
str_obj.append('Elevation ')
elif j == mumoro.co2:
str_obj.append('CO2 Emission')
elif j == mumoro.mode_change:
str_obj.append('Mode Change')
elif j == mumoro.line_change:
str_obj.append('Line Change')
cherrypy.response.headers['Content-Type'] = 'application/json'
if len(p) == 0:
return json.dumps({'error': 'No route found'})
print "Len of routes " + str(len(p))
ret = {'objectives': str_obj, 'paths': []}
for path in p:
p_str = {
'cost': [],
'type': 'FeatureCollection',
'crs': {
'type': 'EPSG',
'properties': {
'code': 4326,
'coordinate_order': [1, 0]
}
}
}
for c in path.cost:
p_str['cost'].append(c)
features = []
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
last_node = path.nodes[0]
last_coord = self.g.coordinates(last_node)
for node in path.nodes:
coord = self.g.coordinates(node)
if (last_coord[3] != coord[3]):
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_coord[3]}
features.append(feature)
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
connection = {
'type': 'feature',
'geometry': {
'type':
'Linestring',
'coordinates': [[last_coord[0], last_coord[1]],
[coord[0], coord[1]]]
},
'properties': {
'layer': 'connection'
}
}
features.append(connection)
last_node = node
last_coord = coord
coordinates.append([coord[0], coord[1]])
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_coord[3]}
features.append(feature)
p_str['features'] = features
ret['paths'].append(p_str)
return json.dumps(ret)
def path(self, slon, slat, dlon, dlat, time):
u_obj = []
#Creates the union of all used objectives
for p in paths_array:
for o in p['objectives'] :
if not o in u_obj:
u_obj.append( o )
u_obj = self.sort_objectives( u_obj )
p = tuple()
c = self.analyse_date( time )
#Call martins with the sorted objectives
for y in paths_array:
s = self.g.match( y['starting_layer']['name'], float(slon), float(slat))
d = self.g.match( y['destination_layer']['name'], float(dlon), float(dlat))
tmp = y['objectives']
tmp = self.sort_objectives( tmp )
t = len( tmp )
print c['seconds'], c['days']
if t == 0:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days']),[],u_obj )
elif t == 1:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0] ), [ tmp[0] ], u_obj )
elif t == 2:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0], tmp[1] ), [ tmp[0], tmp[1] ], u_obj )
elif t >= 3:
p = p + self.normalise_paths( mumoro.martins(s, d, self.g.graph,c['seconds'], c['days'], tmp[0], tmp[1], tmp[2] ), [ tmp[0], tmp[1], tmp[2] ], u_obj )
#Creates the array containing the user-oriented string for each objective
str_obj = ['Duration']
for j in u_obj:
if j == mumoro.dist:
str_obj.append( 'Distance' )
elif j == mumoro.cost:
str_obj.append( 'Cost' )
elif j == mumoro.elevation:
str_obj.append( 'Elevation ' )
elif j == mumoro.co2:
str_obj.append( 'CO2 Emission' )
elif j == mumoro.mode_change:
str_obj.append( 'Mode Change' )
elif j == mumoro.line_change:
str_obj.append( 'Line Change' )
cherrypy.response.headers['Content-Type']= 'application/json'
if len(p) == 0:
return json.dumps({'error': 'No route found'})
print "Len of routes " + str( len( p ) )
ret = {
'objectives': str_obj,
'paths': []
}
for path in p:
p_str = {
'cost': [],
'type': 'FeatureCollection',
'crs': {
'type': 'EPSG',
'properties': {
'code': 4326,
'coordinate_order': [1,0]
}
}
}
for c in path.cost:
p_str['cost'].append(c)
features = []
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
last_node = path.nodes[0]
last_coord = self.g.coordinates(last_node)
for node in path.nodes:
coord = self.g.coordinates(node)
if(last_coord[3] != coord[3]):
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_coord[3]}
features.append(feature)
feature = {'type': 'feature'}
geometry = {'type': 'Linestring'}
coordinates = []
connection = {
'type': 'feature',
'geometry': {
'type': 'Linestring',
'coordinates': [[last_coord[0], last_coord[1]], [coord[0], coord[1]]]
},
'properties': {'layer': 'connection'}
}
features.append(connection);
last_node = node
last_coord = coord
coordinates.append([coord[0], coord[1]])
geometry['coordinates'] = coordinates
feature['geometry'] = geometry
feature['properties'] = {'layer': last_coord[3]}
features.append(feature)
p_str['features'] = features
ret['paths'].append(p_str)
return json.dumps(ret)
