def add_route_to_map(route, some_map, color='blue'):
"""
Add a route from the HERE REST API to the given map.
This includes markers for all points where a maneuver is needed, like 'turn left'.
And it includes a path with lat/lons from start to end and little circle markers
around them.
"""
path_positions = list(chunks(route[0]['shape'], 2))
maneuvers = {(man['position']['latitude'], man['position']['longitude']):
man['instruction']
for man in route[0]['leg'][0]['maneuver']}
polyline = Polyline(locations=path_positions, color=color, fill=False)
some_map += polyline
for lat, lon in path_positions:
if (lat, lon) in maneuvers:
some_map += CircleMarker(location=(lat, lon), radius=2)
marker = Marker(location=(lat, lon), draggable=False)
message1 = HTML()
message1.value = maneuvers[(lat, lon)]
marker.popup = message1
some_map += marker
else:
some_map += CircleMarker(location=(lat, lon), radius=3)
def create_marker(row):
lat_lon = (row["latitude"], row["longitude"])
return CircleMarker(location=lat_lon,
draggable=False,
fill_color="#055a8c",
fill_opacity=0.35,
radius=1,
stroke=False)
def accept_button_click_handler(button,
scale=30,
mapobj=None,
watershed_dict=None,
wbt=None,
ee=None,
outputdir=None,
info_panel=None):
button.disabled = True
center = (watershed_dict['pour_point'].loc[0, 'y'],
watershed_dict['pour_point'].loc[0, 'x'])
mapobj.zoom = 12
mapobj.center = center
circle = CircleMarker(location=center,
radius=50,
fill_color="blue",
stroke=False,
name='Buffer')
remove_existing_layer(mapobj, circle.name)
mapobj.add_layer(circle)
info_panel.layout.visibility = 'visible'
info_panel.value = '...fetching DEM'
dem_path = downloadDEM(x=center[1],
y=center[0],
outputdir=outputdir,
ee=ee,
scale=scale)
info_panel.value = '...delineating watershed'
watershed_full_workflow(wbt,
point=watershed_dict['pour_point'].loc[0,
'geometry'],
demfilename=dem_path[0],
outputdir=outputdir)
info_panel.value = '...extracting watershed'
watershed_gdf = generate_watershed_polygon(outputdir)
watershed_dict["watershed_geometry"] = watershed_gdf
watershed_dict["centroid"] = watershed_gdf.centroid
wshd_layer = GeoData(geo_dataframe=watershed_gdf, name='watershed')
button.button_style = "success"
button.icon = "check"
remove_existing_layer(mapobj, wshd_layer.name)
mapobj.add_layer(wshd_layer)
info_panel.value = f'''
def plot_cell_links(self, only_valid=True):
valid_data = self.__filter_valid(only_valid)
# filter only cell_types
cell_info = valid_data[(valid_data.type == "CELL")
& (valid_data.linked == 1)]
unique_cells = cell_info.address.unique()
all_locations_np = np.array(cell_info.filter(['latitude',
'longitude']))
center = all_locations_np.mean(axis=0)
m = Map(center=center.tolist(), zoom=15)
cmap = plt.cm.get_cmap('Set1') # PiYG
for i, u in enumerate(unique_cells):
m_points = cell_info[cell_info.address == u]
m_color = mpl.colors.rgb2hex(cmap(i))
route, _ = self.__get_polyline(m_points, color=m_color)
m.add_layer(route)
# Get the cell-station
mcc, mnc, lat, cid = self.__dissect_cell_address(u)
try:
cell_pos = self.__get_cell_pos(mcc, mnc, lat, cid)
m.add_layer(
Marker(
location=cell_pos,
title=f"MCC: {mcc} MNC: {mnc}\n LAT: {lat} CID: {cid}")
)
m.add_layer(
CircleMarker(
location=cell_pos,
draggable=False,
color=m_color,
radius=5,
fill=False,
))
except KeyError:
print(f"Cannot add cell")
return m, unique_cells
def create_layer(geo_table,
name,
label_col=None,
secondary_label_col=None,
layer_type=None,
inverse=False,
**kwargs):
if 'color' in kwargs:
color = kwargs['color']
else:
color = 'orange'
output = LayerGroup(name=name)
geo_table = clean_table(geo_table)
if 'filter_on' in kwargs.keys():
filter_col = kwargs['filter_on']
if inverse:
geo_table = geo_table[geo_table[filter_col].isna()]
else:
geo_table = geo_table[~geo_table[filter_col].isna()]
if layer_type is None:
raise (ValueError('must provide a type of layer to make with table!'))
for _, row in geo_table.iterrows():
if layer_type == 'polygon':
y = list(row.geometry.exterior.coords.xy[1])
x = list(row.geometry.exterior.coords.xy[0])
locations = [(y, x) for y, x in zip(y, x)]
temp_layer = Polygon(
locations=locations,
color=color,
fill_color=color,
opacity=0.8,
)
elif layer_type == 'marker':
temp_layer = CircleMarker(
location=(row.geometry.y, row.geometry.x),
color=color,
radius=5,
fill_color=color,
)
if label_col is not None:
if secondary_label_col is not None:
extra_labels = row[secondary_label_col]
if extra_labels is None:
extra_labels = ''
else:
extra_labels = extra_labels.split(',')
size = len(extra_labels)
if size > 6:
size = 6
extra_labels = extra_labels[:size]
extra_labels.append('truncated')
extra_labels = '\n'.join(extra_labels[:size])
else:
extra_labels = ''
message = HTML()
message.value = extra_labels
message.description = row[label_col]
temp_layer.popup = message
temp_layer.popup_max_width = 800
output.add_layer(temp_layer)
geo_table.to_file(name + '.shp')
return output
marks=[]
pold=points[0]
for point in points:
d= point.distance_3d(pold)
distance_parcourue+= d
dists.append(distance_parcourue)
pold= point
if distance_parcourue >= next:
next += delta
marks.append(Marker(location=(point.latitude,point.longitude)))
# Des marqueurs pour le début et la fin du parcours :
circle_marker1 = CircleMarker(
location = (points[-1].latitude,points[-1].longitude),
radius = 7,color = "red",fill_color = "white")
circle_marker2 = CircleMarker(
location = (points[0].latitude,points[0].longitude),
radius = 7,color = "green",fill_color = "green")
marks+=[circle_marker1,circle_marker2]
# Placer les marqueurs sur la carte:
marker_cluster = MarkerCluster(
markers=marks
)
m.add_layer(marker_cluster);
print("Distance totale parcourue :",distance_parcourue,"mêtres.")
def draw_map(routes):
tiles = create_dummy()
m = Map(layers=(basemap_to_tiles(tiles, "2017-04-08"), ),
zoom=12,
layout=Layout(width='100%', height='600px'))
tiles30 = create_dummy()
tiles30[
"url"] = 'https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.hangneigung-ueber_30/default/current/3857/{z}/{x}/{y}.png'
tiles["opacity"] = .0
layer = basemap_to_tiles(tiles30, "adad")
layer.opacity = 0.2
m.add_layer(layer)
tiles30 = create_dummy()
tiles30[
"url"] = 'https://wmts.geo.admin.ch/1.0.0/ch.swisstopo-karto.skitouren/default/current/3857/{z}/{x}/{y}.png'
tiles["opacity"] = .0
layer = basemap_to_tiles(tiles30, "adad")
layer.opacity = 0.9
m.add_layer(layer)
# layer = ipyl.GeoJSON(data=geojson, hover_style={'fillColor': 'red'})
# def hover_handler(event=None, id=None, properties=None):
# label.value = properties['geounit']
# layer.on_hover(hover_handler)
draw_control = DrawControl()
draw_control.polyline = {
"shapeOptions": {
"color": "#6bc2e5",
"weight": 8,
"opacity": 1.0
}
}
draw_control.polygon = {
"shapeOptions": {
"fillColor": "#6be5c3",
"color": "#6be5c3",
"fillOpacity": 1.0
},
"drawError": {
"color": "#dd253b",
"message": "Oups!"
},
"allowIntersection": False
}
draw_control.circle = {
"shapeOptions": {
"fillColor": "#efed69",
"color": "#efed69",
"fillOpacity": 1.0
}
}
draw_control.rectangle = {
"shapeOptions": {
"fillColor": "#fca45d",
"color": "#fca45d",
"fillOpacity": 1.0
}
}
def on_draw(x, geo_json, action):
route = routes[0]
cs_ch = []
for ps in geo_json["geometry"]["coordinates"]:
p = Point(ps[0], ps[1])
p = transform(wgs2ch, p)
cs_ch.append([p.x, p.y])
geo_json["geometry"]["coordinates"] = cs_ch
route.geo_path = geo_json
draw_control.on_draw(on_draw)
m.add_control(draw_control)
for route in routes:
if route.geo_path is not None:
geo_json = copy.deepcopy(route.geo_path)
cs_ch = []
for ps in geo_json["geometry"]["coordinates"]:
p = Point(ps[0], ps[1])
p = transform(ch2wgs, p)
cs_ch.append([p.x, p.y])
geo_json["geometry"]["coordinates"] = cs_ch
geo_json = GeoJSON(data=geo_json)
m.add_layer(geo_json)
points = []
labels = []
points += [transform(ch2wgs, w.point) for w in route.get_waypoints()]
labels += [route.get_name() for p in route.get_waypoints()]
for p, label in zip(points, labels):
marker = CircleMarker()
marker.location = (p.y, p.x)
marker.color = "blue"
marker.title = label
m.add_layer(marker)
points = []
labels = []
points += [
transform(ch2wgs, stop.point) for stop in route.get_pt_stops()
]
labels += [route.get_name() for p in route.get_pt_stops()]
for p, label in zip(points, labels):
marker = CircleMarker()
marker.location = (p.y, p.x)
marker.color = "red"
marker.title = label
m.add_layer(marker)
p = points[0]
m.center = (p.y, p.x)
return m