def routeToCSV(lat1,lon1,lat2,lon2, transport):
"""Format a route (as list of nodes)"""
data = LoadOsm(transport)
node1 = data.findNode(lat1,lon1)
node2 = data.findNode(lat2,lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return("Fail")
output = ''
distance = 0
for i in route:
try:
old_node = new_node
new_node = data.rnodes[i]
distance+=geopy.distance.vincenty((new_node[0], new_node[1]), (old_node[0], old_node[1])).km
print(distance)
except UnboundLocalError:
new_node = data.rnodes[i]
"""output = output + "%d,%f,%f\n" % ( \
i,
node[0],
node[1])"""
return(distance)
def __init__(self, url, data):
self.ws = websocket.WebSocketApp(url)
# 存储所有cases
self.cases = CasesStorage()
self.route = Router()
self.data = data
self.url_map = self.route.url_map
self.last_message = None
def routeToGpx(lat1,
lon1,
lat2,
lon2,
transport,
description="",
style="track"):
"""Format a route (as list of nodes) into a GPX file"""
data = LoadOsm(transport)
node1 = data.findNode(lat1, lon1)
node2 = data.findNode(lat2, lon2)
print("Nodes: {}, {}".format(node1, node2))
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return
output = ''
output = output + "<?xml version='1.0'?>\n"
output = (output + "<gpx version='1.1' creator='pyroute' "
"xmlns='http://www.topografix.com/GPX/1/1' "
"xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
"xsi:schemaLocation='http://www.topografix.com/GPX/1/1 "
"http://www.topografix.com/GPX/1/1/gpx.xsd'>\n")
if (style == 'track'):
output = output + " <trk>\n"
output = output + " <name>%s</name>\n" % description
output = output + " <trkseg>\n"
count = 0
for i in route:
node = data.rnodes[i]
output = output + " <trkpt lat='%f' lon='%f'>\n" % (node[0],
node[1])
output = output + " </trkpt>\n"
count = count + 1
output = output + " </trkseg>\n </trk>\n</gpx>\n"
elif (style == 'route'):
output = output + " <rte>\n"
output = output + " <name>%s</name>\n" % description
count = 0
for i in route:
node = data.rnodes[i]
output = output + " <rtept lat='%f' lon='%f'>\n" % (node[0],
node[1])
output = output + " <name>%d</name>\n" % count
output = output + " </rtept>\n"
count = count + 1
output = output + " </rte>\n</gpx>\n"
return (output)
def __init__(self, catchall=True, autojson=True, config=None):
""" Create a new mole instance.
You usually don't do that. Use `mole.app.push()` instead.
"""
self.routes = [] # List of installed routes including metadata.
self.callbacks = {} # Cache for wrapped callbacks.
self.router = Router() # Maps to self.routes indices.
self.mounts = {}
self.error_handler = {}
self.catchall = catchall
self.config = config or {}
self.serve = True
self.castfilter = []
if autojson and json_dumps:
self.add_filter(dict, dict2json)
self.hooks = {'before_request': [], 'after_request': []}
def __init__(self, *args, **kwargs):
super(JsonProxyRestHandler, self).__init__(*args, **kwargs)
self.router = Router()
self.router.add(
Route('/search/jobs/<sid>/control', {"POST": self.job_control},
'job_control'))
self.router.add(
Route('/search/jobs/<sid>/<data_source>', {"GET": self.job_data},
'job_data'))
self.router.add(
Route('/search/jobs/<sid>', {
"GET": self.eai,
"DELETE": self.delete_job
}, 'job_info'))
self.router.add(
Route('/search/jobs', {
"GET": self.eai,
"POST": self.create_job
}, 'jobs'))
self.router.add(
Route('/search/parser', self.parse_query, 'parse_query'))
self.router.add(Route('/search/typeahead', self.typeahead,
'typeahead'))
self.router.add(
Route(
'/search/tags/<name>', {
"GET": self.eai,
"DELETE": self.modify_or_delete_tag,
"POST": self.modify_or_delete_tag
}, 'tag_info'))
self.router.add(
Route('/properties/<file>/<stanza>', self.properties_stanza,
'properties_stanza_info'))
self.router.add(
Route('/properties/<file>/<stanza>/<key>',
self.properties_stanza_key, 'properties_stanza_key'))
self.router.add(
Route('/receivers/simple', self.http_simple_input,
'http_simple_input'))
self.router.add(Route('/auth/login', {"POST": self.auth}, 'auth'))
self.router.add(Route('/<:.*>', self.eai, 'eai'))
def routeToCSV(lat1, lon1, lat2, lon2, transport):
"""Format a route (as list of nodes)"""
data = LoadOsm(transport)
node1 = data.findNode(lat1, lon1)
node2 = data.findNode(lat2, lon2)
router = Router(data)
result, route = router.doRoute(node1, node2)
if result != 'success':
return ("Fail")
output = ''
for i in route:
node = data.rnodes[i]
output = output + "%d,%f,%f\n" % ( \
i,
node[0],
node[1])
return (output)
def __init__(self, request, client_address, server):
routes = [{
'regexp': r'^/$',
'controller': HomeController,
'action': 'indexAction'
}, {
'regexp': r'^/content/',
'controller': ContentController,
'action': 'showAction'
}, {
'regexp': r'^/api/',
'controller': APIController,
'action': 'indexAction'
}]
self.__router = Router(self)
for route in routes:
self.__router.addRoute(route['regexp'], route['controller'],
route['action'])
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
from client import Client
from route import Router
cli = Client(__name__)
sk = Router()
storage = cli.storage
if __name__ == '__main__':
cli.run()
def route_geojson(input_f, output_f, mode='foot', local_planet=None):
osmdata = LoadOsm(mode)
if local_planet is not None:
osmdata.getArea = lambda lat, lon: None
osmdata.api = None
print('loading osm data (this may take a while)...')
osmdata.loadOsm(local_planet)
print('starting router...')
router = Router(osmdata)
print('processing shapes...')
# First load up the shapes
layer = geojson.load(input_f)
non_linestring = 0
not_two_points = 0
unsuccessful = 0
successful = 0
very_long = 0
first = True
output_f.write('{"crs": {"type": "name", "properties": '
'{"name": "urn:ogc:def:crs:OGC:1.3:CRS84"}}, '
'"type": "FeatureCollection", "features": [\n')
for feature in layer.features:
if feature.geometry.type != 'LineString':
# Not a LineString, skip!
non_linestring += 1
continue
geometry = list(feature.geometry.coordinates)
if len(geometry) != 2:
# LineString with other than two points, skip!
not_two_points += 1
continue
if pythagoras(*geometry[0] + geometry[1]) > 1.0:
very_long += 1
continue
# Now find a route. Data has x,y coordinates, but function is y,x, so
# reverse the parameters.
start = osmdata.findNode(*geometry[0][::-1])
end = osmdata.findNode(*geometry[1][::-1])
result, route = router.doRoute(start, end)
if result != 'success':
unsuccessful += 1
continue
routed_geometry = []
for node_id in route:
node = osmdata.rnodes[node_id]
routed_geometry.append((node[1], node[0]))
new_feature = geojson.Feature(
geometry=geojson.LineString(coordinates=routed_geometry),
properties=feature.properties,
id=feature.id,
)
if not first:
output_f.write(',\n')
first = False
geojson.dump(new_feature, output_f)
output_f.flush()
successful += 1
output_f.write('\n]}\n')
output_f.close()
print(
'%d LineStrings routed. Errors: %d non-linestring(s), '
'%d linestring(s) with !=2 points, %d very long, '
'%d unsuccessful routings' %
(successful, non_linestring, not_two_points, very_long, unsuccessful))
# these have to be loaded in later, because route depends on loadOsm
# which depends on the modified crimeweights dictionary
from route import Router
from loadOsm import *
# load in the given OSM file
data = LoadOsm(sys.argv[1])
start_node = data.findNode(start_lat, start_lon, 'foot')
end_node = data.findNode(end_lat, end_lon, 'foot')
print 'Node IDs: ', start_node, 'to', end_node
print
# do the routing
router = Router(data)
result, route = router.doRouteAsLL(start_node, end_node, 'foot')
abs_dist = dist_miles(router.coords(start_node), router.coords(end_node))
print "Your destination is {0:.3f} miles away.".format(abs_dist)
dist_input = raw_input(
'Please enter, in miles, the maximum distance you want to traverse (leave blank if unnecessary): '
)
max_dist = None
if dist_input == '':
print 'Not accounting for distance.'
elif abs_dist > float(dist_input):
print 'Input distance less than absolute distance between nodes. Ignoring distance input.'
else:
max_dist = float(dist_input)
router = Router([
{
'name': 'udpate_svn_and_import'
},
{
'name': 'move_new_data'
},
{
'name': 'make_reduced_data'
},
{
'name': 'pack_txt'
},
{
'name': 'sa_sweeps_tables'
},
{
'name': 'sa_time_tables_cpu',
'spin_flip_rate': 6.5e9
},
{
'name': 'dwave_anneal_time_table'
},
{
'name': 'scaling_ctq'
},
{
'name': 'scaling_dtq'
},
{
'name': 'scaling_dwave'
},
{
'name': 'make_backup_to_archive'
},
{
'name': 'make_backup_to_server'
},
])
