def find_segment(trip_record, session, test_pair=None):
if test_pair:
me_loc = test_pair
else:
me_loc = (trip_record.location_lat, trip_record.location_lng)
trip = session.query(db.TripRecord, db.Trip).join(
db.Trip).filter(db.Trip.id == trip_record.trip_id).first()[1]
origin_station = session.query(
db.Station).filter(db.Station.id == trip.origin_station_id).first()
destination_station = session.query(db.Station).filter(
db.Station.id == trip.destination_station_id).first()
# print "origin_station: %s" % origin_station
# print "destination_station: %s" % destination_station
all_stations = session.query(db.Station).filter(
db.Station.route_id == origin_station.route_id).all()
closest_station = None
closest_distance_so_far = 100
for station in all_stations:
station_loc = (station.location_lat, station.location_lng)
miles = dist(me_loc, station_loc).miles
if miles < closest_distance_so_far:
closest_station = station
closest_distance_so_far = miles
surrounding_stations = surrounding_station(session, closest_station)
surround_station_1 = surrounding_stations[1]
surround_station_2 = surrounding_stations[0]
# print("surround_station_1: {}".format(surround_station_1.loc()))
# print("surround_station_2: {}".format(surround_station_2.loc()))
if dist(surround_station_1.loc(), destination_station.loc()).miles < dist(
surround_station_2.loc(), destination_station.loc()).miles:
surround_station_ahead = surround_station_1
surround_station_behind = surround_station_2
else:
surround_station_ahead = surround_station_2
surround_station_behind = surround_station_1
if dist(me_loc, destination_station.loc()).miles < dist(
closest_station.loc(), destination_station.loc()).miles:
return closest_station, surround_station_ahead
else:
return surround_station_behind, closest_station
def score(dish, user, user_location, params):
prefered_foodtypes = user.preferedFoodTypes
restaurant = dish.restaurant
hist = sum(prefered_foodtypes[t.name] for t in dish.foodType.all())
if restaurant.acceptance is not None:
acceptance = restaurant.acceptance/params["avg_accept"]
else:
acceptance = params["min_accept"]/params["avg_accept"]
if restaurant.rejectance is not None:
rejectance = restaurant.rejectance/params["avg_reject"]
else:
rejectance = params["max_reject"]/params["avg_reject"]
if restaurant.delay is not None:
delays = restaurant.delay/params["avg_delay"]
else:
delays = params["max_delay"]/params["avg_delay"]
if restaurant.ordersNumber:
ordersNumber = restaurant.ordersNumber/params["avg_orders"]
else:
ordersNumber = params["min_orders"]/params["avg_orders"]
if user_location:
distance = dist((restaurant.latitude, restaurant.longitude), (user_location["latitude"], user_location["longitude"])).km
else:
distance = 0
return hist + acceptance + ordersNumber - rejectance - 0.5 * delays - distance
def set_linkDelay(self):
SPEED_OF_LIGHT = 299792458 # meter per second
PROPAGATION_FACTOR = 0.77 # https://en.wikipedia.org/wiki/Propagation_delay
for e in self.net_x.edges(data=True):
link_delay = e[2].get("LinkDelay", None)
# As edges are undirectional, only LinkFwdCap determines the available data rate
# link_fwd_cap = e[2].get("LinkFwdCap", 1000)
delay = 3
if link_delay is None:
n1 = self.net_x.nodes(data=True)[e[0]]
n2 = self.net_x.nodes(data=True)[e[1]]
n1_lat, n1_long = n1.get("Latitude",
None), n1.get("Longitude", None)
n2_lat, n2_long = n2.get("Latitude",
None), n2.get("Longitude", None)
if not (n1_lat is None or n1_long is None or n2_lat is None
or n2_long is None):
distance = dist((n1_lat, n1_long),
(n2_lat, n2_long)).meters # in meters
# round delay to int using np.around for consistency with emulator
delay = int(
np.around((distance / SPEED_OF_LIGHT * 1000) *
PROPAGATION_FACTOR)) # in milliseconds
else:
delay = link_delay
e[2]["LinkDelay"] = delay
def trip_movement(session, trip, stamp, delta):
'''
Answers the question: between stamp and stamp-delta, how far did trip move?
:param session: The database session to operate with
:param trip: The trip in question
:param stamp: A timestamp
:param delta: A time delta (say, 5 minutes)
:return: Movement in feet
'''
stamp_prev = stamp - delta
stamp_record = session.query(db.TripRecord)\
.filter(db.TripRecord.trip_id == trip.id)\
.filter(db.TripRecord.stamp < stamp)\
.order_by(db.TripRecord.stamp.desc())\
.limit(1)\
.first()
stamp_prev_record = session.query(db.TripRecord)\
.filter(db.TripRecord.trip_id == trip.id)\
.filter(db.TripRecord.stamp < stamp_prev)\
.filter(db.TripRecord.stamp > stamp_prev - datetime.timedelta(minutes=3))\
.order_by(db.TripRecord.stamp.desc())\
.limit(1)\
.first()
if not stamp_prev_record:
return -1
stamp_record_loc = (stamp_record.location_lat, stamp_record.location_lng)
stamp_prev_record_loc = (stamp_prev_record.location_lat,
stamp_prev_record.location_lng)
return dist(stamp_record_loc, stamp_prev_record_loc).feet
def trip_movement(session, trip, stamp, delta):
'''
Answers the question: between stamp and stamp-delta, how far did trip move?
:param session: The database session to operate with
:param trip: The trip in question
:param stamp: A timestamp
:param delta: A time delta (say, 5 minutes)
:return: Movement in feet
'''
stamp_prev = stamp - delta
stamp_record = session.query(db.TripRecord)\
.filter(db.TripRecord.trip_id == trip.id)\
.filter(db.TripRecord.stamp < stamp)\
.order_by(db.TripRecord.stamp.desc())\
.limit(1)\
.first()
stamp_prev_record = session.query(db.TripRecord)\
.filter(db.TripRecord.trip_id == trip.id)\
.filter(db.TripRecord.stamp < stamp_prev)\
.filter(db.TripRecord.stamp > stamp_prev - datetime.timedelta(minutes=3))\
.order_by(db.TripRecord.stamp.desc())\
.limit(1)\
.first()
if not stamp_prev_record:
return -1
stamp_record_loc = (stamp_record.location_lat, stamp_record.location_lng)
stamp_prev_record_loc = (stamp_prev_record.location_lat, stamp_prev_record.location_lng)
return dist(stamp_record_loc, stamp_prev_record_loc).feet
def near(request, pk):
limit = 5
user = User.objects.get(pk=pk)
lat = user.location["latitude"]
lng = user.location["longitude"]
restaurants = sorted(Restaurant.objects.all(),
key=lambda r: dist((r.chef.latitude, r.chef.longitude), (lat, lng)).km)[:limit]
return response(restaurants, 'restaurant', request)
def trip_length(longitude, latitude):
# caution: vincenty(dist) function takes a (latitude, longitude) pair!
xy = np.array([latitude, longitude]).T.reshape(-1, 2)
total_length = 0.
for start, stop, in zip(xy[:-1], xy[1:]):
total_length += dist(start, stop).km
return total_length
def find_segment(trip_record, session, test_pair=None):
if test_pair:
me_loc = test_pair
else:
me_loc = (trip_record.location_lat, trip_record.location_lng)
trip = session.query(db.TripRecord, db.Trip).join(db.Trip).filter(db.Trip.id == trip_record.trip_id).first()[1]
origin_station = session.query(db.Station).filter(db.Station.id == trip.origin_station_id).first()
destination_station = session.query(db.Station).filter(db.Station.id == trip.destination_station_id).first()
# print "origin_station: %s" % origin_station
# print "destination_station: %s" % destination_station
all_stations = session.query(db.Station).filter(db.Station.route_id == origin_station.route_id).all()
closest_station = None
closest_distance_so_far = 100
for station in all_stations:
station_loc = (station.location_lat, station.location_lng)
miles = dist(me_loc, station_loc).miles
if miles < closest_distance_so_far:
closest_station = station
closest_distance_so_far = miles
surrounding_stations = surrounding_station(session, closest_station)
surround_station_1 = surrounding_stations[1]
surround_station_2 = surrounding_stations[0]
# print("surround_station_1: {}".format(surround_station_1.loc()))
# print("surround_station_2: {}".format(surround_station_2.loc()))
if dist(surround_station_1.loc(), destination_station.loc()).miles < dist(surround_station_2.loc(),
destination_station.loc()).miles:
surround_station_ahead = surround_station_1
surround_station_behind = surround_station_2
else:
surround_station_ahead = surround_station_2
surround_station_behind = surround_station_1
if dist(me_loc, destination_station.loc()).miles < dist(closest_station.loc(), destination_station.loc()).miles:
return closest_station, surround_station_ahead
else:
return surround_station_behind, closest_station
def main():
w, c = login.doInteractiveLogin()
conf = c._config['location_explorer']
if 'max_place_count' in conf:
max_place_count = conf['max_place_count']
else:
max_place_count = -1
if 'search_center' in conf:
search_cond = True
search_center = conf['search_center']
search_radius = conf['search_radius']
else:
search_cond = False
if 'archive_size' in conf:
archive_size = conf['archive_size']
else:
archive_size = None
output_filename = conf['output_filename']
origin = conf['origin']
archive_count = 0
location_count = 0
places = []
queue = [(0, (origin, ''))]
processed = {origin}
while queue and (max_place_count == -1 or len(places) < max_place_count):
nx = heapq.heappop(queue)[1]
pid = nx[0]
location_count += 1
print('processing %d location %s...' % (location_count, pid))
loc = w.getPlaceById(pid)
if search_cond and \
dist(tuple(search_center), (loc.latitude, loc.longitude)).meters > \
search_radius:
continue
places.append(loc)
if archive_size and len(places) >= archive_size:
writeOut(output_filename, archive_count, places)
places = []
archive_count += 1
for p in loc.queryNearby():
if p['id'] in processed: continue
processed.add(p['id'])
heapq.heappush(queue, ( \
-p['weibo_count'], \
( p['id'], p['name'] ) \
))
writeOut(output_filename, archive_count, places, queue)
print('total %d locations found' % location_count)
def buscar_cercanas(n, coord, estaciones):
nombres_cercanas = distancias = []
for i in estaciones:
# Calcular la distancia entre la estación y el punto de interés
distancia = dist((estaciones[i]['Lat'], estaciones[i]['Long']), coord).km
# Si encontramos una mejora estación o no hemos llegado a n estaciones
if distancia < max(distancias) or len(nombres_cercanas) < n:
# Si ya tenemos una lista de n estaciones, quitar la estación la más lejana
if len(nombres_cercanas) >= n:
índice = distancias.index(max(distancias))
nombres_cercanas.pop(índice)
distancias.pop(índice)
# Añadir la nueva estación
distancias.append(distancia)
nombres_cercanas.append(estaciones[i]['Estación'])
# Leer los datos de las n estaciones más cercanas
estaciones_cercanas = []
for i in nombres_cercanas:
estaciones_cercanas.append(
cargar_estación(os.path.join('Proyectos', 'Clima', i, '.csv'), generar=False)[0]
)
return estaciones_cercanas
lat_lon[place] = (loc.latitude, loc.longitude)
#print("okay")
#getting your location based on ip address
g = geocoder.ip('me')
c = geolocator.reverse((g.latlng))
print("your location: " + str(c.raw['address']['country']))
loc = geolocator.geocode(c.raw['address']['country'])
my_loc = tuple(g.latlng)
#calculating nearest country in wikipedia page to your country
print("calculating nearest country in wikipedia page to your country")
distances = {}
for loc, coord in lat_lon.items():
sleep(1)
distance = dist(coord, my_loc).km
distances[loc] = distance
x = min(distances.values())
your_place = ""
for name, d in distances.items():
if d == x:
print("nearest country: ", name)
your_location = name.replace(" ", "_")
your_place = name
for d in data:
t2 = arrow.get(d[3])
if t2 > t1.ceil("day"):
id += 1
print("found night {}".format(id))
p = kml.Placemark(ns, "%s" % id, "nuit_%s" % id, "nuit numéro %s" % id)
p.geometry = Point(lon, lat)
docNights.append(p)
t1 = t2
lat = d[1]
lon = d[2]
lat = data[0][1]
lon = data[0][2]
id = 0
for d in data:
# print(dist((d[2],d[1]),(lon,lat)).kilometers)
if dist((d[2], d[1]), (lon, lat)).kilometers > 10:
p = kml.Placemark(ns, "%s" % id, "km_%s" % id, "borne numéro %s" % id)
p.geometry = Point(lon, lat)
docRoute.append(p)
lat = d[1]
lon = d[2]
fid = open("{}_nights.kml".format(args.title), "w")
fid.write(rootNights.to_string(prettyprint=True))
fid.close()
fid = open("{}_route.kml".format(args.title), "w")
fid.write(rootRoute.to_string(prettyprint=True))
fid.close()
def read_network(file, node_cap=None, link_cap=None):
"""
Read the GraphML file and return list of nodes and edges.
"""
SPEED_OF_LIGHT = 299792458 # meter per second
PROPAGATION_FACTOR = 0.77 # https://en.wikipedia.org/wiki/Propagation_delay
if not file.endswith(".graphml"):
raise ValueError("{} is not a GraphML file".format(file))
graphml_network = nx.read_graphml(file, node_type=int)
networkx_network = nx.Graph()
# Setting the nodes of the NetworkX Graph
for n in graphml_network.nodes(data=True):
node_id = "pop{}".format(n[0])
cap = n[1].get("NodeCap", None)
if cap is None:
cap = node_cap
log.warning(
"NodeCap not set in the GraphML file, now using default NodeCap for node: {}"
.format(n))
node_type = n[1].get("NodeType", "Normal")
node_name = n[1].get("label", None)
if cap is None:
raise ValueError(
"No NodeCap. set for node{} in file {} (as cmd argument or in graphml)"
.format(n, file))
# Adding a Node in the NetworkX Graph
# {"id": node_id, "name": node_name, "type": node_type, "cap": cpu})
# Type of node. For now it is either "Normal" or "Ingress"
# Init 'remaining_resources' to the node capacity
networkx_network.add_node(node_id,
name=node_name,
type=node_type,
cap=cap,
available_sf={},
remaining_cap=cap)
# set links
# calculate link delay based on geo positions of nodes;
for e in graphml_network.edges(data=True):
# Check whether LinkDelay value is set, otherwise default to None
source = "pop{}".format(e[0])
target = "pop{}".format(e[1])
link_delay = e[2].get("LinkDelay", None)
# As edges are undirectional, only LinkFwdCap determines the available data rate
link_fwd_cap = e[2].get("LinkFwdCap", link_cap)
if e[2].get("LinkFwdCap") is None:
log.warning(
"Link {} has no capacity defined in graphml file. So, Using the default capacity"
.format(e))
# Setting a default delay of 3 incase no delay specified in GraphML file
# and we are unable to set it based on Geo location
delay = 3
if link_delay is None:
n1 = graphml_network.nodes(data=True)[e[0]]
n2 = graphml_network.nodes(data=True)[e[1]]
n1_lat, n1_long = n1.get("Latitude",
None), n1.get("Longitude", None)
n2_lat, n2_long = n2.get("Latitude",
None), n2.get("Longitude", None)
if n1_lat is None or n1_long is None or n2_lat is None or n2_long is None:
log.warning(
"Link Delay not set in the GraphML file and unable to calc based on Geo Location,"
"Now using default delay for edge: ({},{})".format(
source, target))
else:
distance = dist((n1_lat, n1_long),
(n2_lat, n2_long)).meters # in meters
# round delay to int using np.around for consistency with emulator
delay = int(
np.around((distance / SPEED_OF_LIGHT * 1000) *
PROPAGATION_FACTOR)) # in milliseconds
else:
delay = link_delay
# Adding the undirected edges for each link defined in the network.
# delay = edge delay , cap = edge capacity
networkx_network.add_edge(source,
target,
delay=delay,
cap=link_fwd_cap,
remaining_cap=link_fwd_cap)
# setting the weight property for each edge in the NetworkX Graph
# weight attribute is used to find the shortest paths
for edge in networkx_network.edges.values():
edge['weight'] = weight(edge['cap'], edge['delay'])
# Setting the all-pairs shortest path in the NetworkX network as a graph attribute
shortest_paths(networkx_network)
# Filter ingress nodes
ing_nodes = []
for node in networkx_network.nodes.items():
if node[1]["type"] == "Ingress":
ing_nodes.append(node)
return networkx_network, ing_nodes
root = kml.KML()
ns = '{http://www.opengis.net/kml/2.2}'
# Create a KML Document and add it to the KML root object
doc = kml.Document(ns, '1', 'test document', 'test gps data extraction')
root.append(doc)
# Create a KML Folder and nest it in the first Folder
f = kml.Folder(ns, 'nested-fid', 'nested f name', 'nested f description')
doc.append(f)
lon1 = data[0][2]
lat1 = data[0][1]
p = kml.Placemark(ns, "0","%s"%data[0][3], 'description')
p.geometry = Point(lon1,lat1)
f.append(p)
for d in data:
lon2 = d[2]
lat2 = d[1]
print(dist((lon1,lat1),(lon2,lat2)).kilometers)
if dist((lon1,lat1),(lon2,lat2)).kilometers>10:
p = kml.Placemark(ns, "%s"%d[0],"%s"%d[3], 'description')
p.geometry = Point(lon2,lat2)
f.append(p)
lon1=lon2
lat1=lat2
fid = open("/tmp/test.kml","w")
fid.write(root.to_string(prettyprint=True))
fid.close()
def inic(símismo, datos):
if datos: # Si se especificaron datos, leerlos
datos_crudos = símismo.leer_documento(datos)
for núm, nombre in enumerate(datos_crudos['Parcela']):
nueva_parcela = Parcela(
nombre=nombre,
directorio=símismo.directorio,
suelos_común=símismo.dic['suelos_común'],
variedades_común=símismo.dic['variedades_común'],
redes_común=símismo.dic['redes_común'])
def leer_vars(obj):
for var in obj:
if type(var) is dict:
leer_vars(obj[var])
if var in datos_crudos:
try:
valor = float(datos_crudos[var][núm])
except ValueError:
valor = datos_crudos[var][núm]
obj[var] = valor
leer_vars(nueva_parcela.dic)
símismo.parcelas[nombre] = nueva_parcela
if símismo.dic[
'redes_común']: # Si compartemos redes, buscar la red en el lugar común
símismo.red = Red(nombre=símismo.dic['RedAE'])
else: # Si no compartemos, buscarla en el directorio del paisaje actual
if os.path.isfile(
os.path.join(símismo.directorio, símismo.nombre + '.red')):
símismo.red = Red(nombre=símismo.dic['RedAE'])
else: # Si no lo encontramos allí, hacer una copia local de la versión en el lugar común
dirección = os.path.join('Proyectos', 'Personales', 'Redes',
símismo.nombre + '.red')
if os.path.isfile(dirección):
with open(dirección) as d:
doc = d.readlines()
with open(
os.path.join(símismo.directorio,
símismo.nombre + '.red'), 'w') as d:
d.write(doc)
else:
print('No se encontró la red agroecológica %s.' %
(símismo.nombre + '.red'))
# Poner los suelos, variedades, y redes a la parcela
for itema in símismo.parcelas.items():
parcela = itema[1] # Sacar el objeto representando la parcela
if símismo.dic['suelos_común']:
# Si todavía no hemos creado un objeto para el suelo en cuestión:
if parcela.dic['Suelo'] not in símismo.suelos:
símismo.suelos[parcela.dic['Suelo']] = Suelo(
nombre=parcela.dic['Suelo'],
directorio=símismo.directorio)
# Establecer una referencia entre el suelo apropiade del diccionario de suelos y el suelo de la parcela
parcela.suelo = símismo.suelos[parcela.dic['Suelo']]
# Las variedades
if símismo.dic['variedades_común']:
# Si todavía no hemos creado un objeto para la variedad en cuestión:
if parcela.dic['Variedad'] not in símismo.variedades:
símismo.variedades[parcela.dic['Variedad']] = Variedad(
nombre=parcela.dic['Variedad'],
directorio=símismo.directorio)
# Establecer una referencia entre la variedad del diccionario de variedades y la variedad de la parcela
parcela.variedad = símismo.variedades[parcela.dic['Variedad']]
# El clima
meteo_temp = Diario(coord=(parcela.dic['Lat'],
parcela.dic['Long']))
meteo_temp.buscar(símismo.dic['fecha_inic'],
símismo.dic['fecha_fin'])
# Si todavía no hemos creado un objeto para la meteorología en cuestión:
if meteo_temp.nombre not in símismo.meteos:
símismo.meteos[meteo_temp.nombre] = Diario(
nombre=parcela.dic['Variedad'])
parcela.meteo = símismo.meteos[meteo_temp.nombre]
# Las redes agroecológicas
parcela.red = símismo.red
# Calcular distancias entre parcelas
for otro_itema in símismo.parcelas.items():
otra_parcela = otro_itema[1]
símismo.distancias[itema[0]][otro_itema[1]] = dist(
(parcela.dic["Lat"], parcela.dic["Long"]),
(otra_parcela.dic["Lat"], otra_parcela.dic["Long"]))