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 drawPOIS(POIS, zoom=12):
centerLat, centerLog = 0, 0
# taking the average of all latitude and longitude of all the POIs
# to get the center of the map
for poi in POIS:
centerLat += poi.coordinates[0]
centerLog += poi.coordinates[1]
centerLat /= len(POIS)
centerLog /= len(POIS)
center = (centerLog, centerLat)
m = Map(center=center, zoom=zoom, close_popup_on_click=False)
# creating the popup messages on the markers
# with the name of the POI
for poi in POIS:
name = poi.address.split(",")[0]
marker = Marker(location=poi.coordinates[::-1])
text = HTML()
text.value = f"{name}"
marker.popup = text
m.add_layer(marker)
return m
def build_map(self, click_handler):
mean_lat = self.x_data[self.lat_key].values.mean()
mean_lng = self.x_data[self.lon_key].values.mean()
# create the map
m = Map(center=(mean_lat, mean_lng), zoom=4, basemap=basemaps.Stamen.Terrain)
m.layout.height = '600px'
# show trace
markers = []
for k in self.marker_info:
lat, lon = k
message = HTML()
message.description = "Station ID"
message.value = str(self.marker_info[k])
message.placeholder = ""
marker = Marker(location=(lat, lon))
marker.on_click(click_handler)
marker.popup = message
markers.append(marker)
marker_cluster = MarkerCluster(
markers=markers
)
# not sure whether we could register once instead of each marker:
# marker_cluster.on_click(click_handler)
m.add_layer(marker_cluster)
# m.add_control(FullScreenControl())
return m
def print_geojson(geojson, limit=100):
center = None
j = json.load(StringIO(geojson))
layer_group = LayerGroup()
features = j['features']
if limit is not None:
features = features[0:limit]
for f in features:
location = (f['geometry']['coordinates'][1],
f['geometry']['coordinates'][0])
marker = Marker(location=location)
marker.popup = HTML(str(f['properties']))
layer_group.add_layer(marker)
if not center:
center = location
if not center:
center = (0, 0)
m = Map(layers=(basemap_to_tiles(basemaps.OpenStreetMap.Mapnik), ),
center=center,
zoom=8)
m.add_layer(layer_group)
return m
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 _handle_map_click(self, **kwargs):
if kwargs.get("type") == "click":
loc = kwargs.get("coordinates")
marker = Marker(location=loc)
marker.on_move(partial(self._handle_marker_move, marker=marker))
self.domain_coords.append(loc)
self.marker_locs[marker] = loc
self.m.add_layer(marker)
self._update_domain_render()
def _addWaypoint(self):
# Waypoint
self._waypointMarker = Marker(location=self._startLocation,
draggable=False)
self._waypointMarker.observe(self._on_location_changed, 'location')
self._m.add_layer(self._waypointMarker)
# Waypoint Popup Message
self._waypointMessage = HTML()
self._waypointMarker.popup = self._waypointMessage
def show_stations_on_map(self,list_inc,list_process,list_filters,
opt_params):
""" Returns an interactive map of source and stations, use only in
Jupyter Notebooks.
Inputs:
| list_inc: list of incidents
| list_process: list of processes, one list per incident
| list filters: list of filters defined for stations
| opt_params: optional parameters (dictionary)
Optional parameters:
"""
records = self._extract_records(list_inc, list_process, list_filters)
if not records:
LOGGER.warning("There are no records to satisfy the provided"
" filters.")
return
m = Map(
basemap=basemap_to_tiles(basemaps.Esri.WorldImagery, "2020-04-08"),
center = (Station.pr_source_loc[0],Station.pr_source_loc[1]),
zoom = 8,
close_popup_on_click=True
)
for i in records:
if not i[0]:
continue
lat = i[0].station.lat
lon = i[0].station.lon
marker = Marker(location=(lat, lon), draggable=False,
icon=AwesomeIcon(name="map-pin", marker_color='green',
icon_color='darkgreen'), opacity=0.8)
m.add_layer(marker)
message = HTML()
message.value = i[0].station.inc_st_name[list_inc[0]]
marker.popup = message
m.add_layer(Marker(icon=AwesomeIcon(name="star",
marker_color='red', icon_color='darkred'),
location=(Station.pr_source_loc[0],Station.pr_source_loc[1]),
draggable=False))
return m
def plot_gps_clusters(ds, user_id:str, zoom=5):
"""
Plots GPS coordinates
Args:
ds (DataStream): datastream object
user_id (str): uuid of a user
zoom: min 0 and max 100, zoom map
"""
pdf = ds_to_pdf(ds, user_id)
marker_list = []
center = None
for index, row in pdf.iterrows():
if center is None:
center = [row["latitude"], row["longitude"]]
marker_list.append(Marker(location=(row["latitude"], row["longitude"])))
m = Map(center=(center), zoom=zoom)
marker_cluster = MarkerCluster(
markers=(marker_list)
)
m.add_layer(marker_cluster)
return m
def get_choice(self, x):
self.show_menu = False
self.s.close()
self.m.remove_layer(self.p)
self.p = None
choice = x['new']
if choice == 'Show flow':
self.show_flow = True
elif choice == 'Hide flow':
self.show_flow = False
self.m.remove_layer(self.io)
self.io = None
elif choice == 'Delineate watershed':
self.show_flow = False
self.m.remove_layer(self.io)
self.io = None
self.label.value = 'Delineating watershed, please wait...'
delineate(*self.coord)
self.label.value = 'Watershed delineated'
ds_mask = xr.open_zarr('tmp/ds_mask/0').compute()
mask = ds_mask['mask'].values
polygon = get_polygon(mask, ds_mask.lat.values[0] + 0.5 / 1200,
ds_mask.lon.values[0] - 0.5 / 1200)
self.m.add_layer(polygon)
self.label.value = 'Watershed displayed'
elif choice == 'Set marker':
if self.marker is not None:
self.m.remove_layer(self.marker)
self.marker = Marker(location=self.coord)
self.m.add_layer(self.marker)
elif choice == 'Close':
pass
def __init__(self):
self.url_wms = 'http://wms.geosampa.prefeitura.sp.gov.br/geoserver/geoportal/wms'
self.wms = WebMapService(self.url_wms, version='1.3.0')
self.coords_wgs84 = [-23.545567989349365, -46.6351979970932]
self.center = self.coords_wgs84
self.mapa_base = WMSLayer(
url = self.url_wms,
layers = 'MapaBase_Politico',
format = 'image/png',
transparent = True,
attribution = 'GeoSampa'
)
self.lotes = WMSLayer(
url = 'http://wms.geosampa.prefeitura.sp.gov.br/geoserver/geoportal/wms',
layers = 'lote_cidadao',
format = 'image/png',
transparent = True,
attribution = 'GeoSampa'
)
self.transformer = Transformer.from_crs(31983, 4326)
self.marker = Marker(location=self.center, draggable=True)
self.shape = ''
def point_leaflet(point: PointMixin, **kwargs) -> Marker:
default = dict()
if hasattr(point, "name"):
default["title"] = point.name
kwargs = {**default, **kwargs}
return Marker(location=(point.latitude, point.longitude), **kwargs)
def layer(self):
icon = AwesomeIcon(name='camera',
marker_color='blue',
icon_color='white')
return Marker(icon=icon,
location=(self.location.latitude,
self.location.longitude),
draggable=False)
def load_data(self):
# Put a marker on the map for each station
for i, station in enumerate(tqdm(self.stations)):
marker = Marker(location=(float(get_station_attr(station, 'lat')),
float(get_station_attr(station, 'lon'))),
draggable=False)
self.markers[i] = marker
marker_cluster = MarkerCluster(markers=self.markers)
self.map.add_layer(marker_cluster)
def createLeafletMarker(m, mission, MapGliderLocation, popup=None):
icon1 = AwesomeIcon(name='paper-plane-o',
marker_color='red',
icono_color='black',
icon_size=(2, 2),
spin=False)
marker = Marker(
icon=icon1,
name=mission,
location=(MapGliderLocation[-1][0], MapGliderLocation[-1][1] - 0.001),
draggable=False,
opacity=0.3,
rise_on_hover=True,
)
if popup:
marker.popup = widgets.HTML('<h1><u>{}</u></h1>'.format(mission))
m.add_layer(marker)
return m
def showonmap(self):
try:
from ipyleaflet import Map, Marker
except ModuleNotFoundError:
print('Non riesco ad importare i moduli.')
poi = (self.data['Location']['Y'],self.data['Location']['X'])
m = Map(center=poi, zoom=15)
marker = Marker(location=poi, draggable=True)
m.add_layer(marker);
display(m)
def base_map(area, source):
from ipyleaflet import Map, Marker
center, zoom = centroid(area, source)
m = Map(center=center, zoom=zoom)
base_map.map_marker = Marker(location=m.center)
m += base_map.map_marker
return m
def Location(self):
# Import pra tratamento das coordenadas
self.results = geocoder.geocode(u'Brussels, Belgium')
self.center = (self.results[0]['geometry']['lat'],
self.results[0]['geometry']['lng'])
map = Map(center=self.center, zoom=6)
self.marker = Marker(location=self.center, draggable=False)
map.add_layer(self.marker)
map
def update_contours(self, ps, ts):
for p, p0 in zip(ps, self.ps0):
p0.locations = p.locations
[self.remove_layer(tk) for tk in self.contour_labels]
self.contour_labels = []
for ti in ts:
i = DivIcon(html=ti._text + ' m')
tsm = Marker(location=[ti._x, ti._y], icon=i)
self.add_layer(tsm)
self.contour_labels.append(tsm)
def Give_Marker_Cluster(df):
markers = []
for i in df.index:
x = df.loc[i][df.columns[0]]
y = df.loc[i][df.columns[1]]
name = str(i)
markers.append(
Marker(location=(x, y),
draggable=False,
title=str(round(x, 3)) + str(round(y, 3))))
return MarkerCluster(markers=(markers))
def point_leaflet(point: "PointMixin", **kwargs) -> Marker:
"""Returns a Leaflet layer to be directly added to a Map.
.. warning::
This is only available if the Leaflet `plugin <plugins.html>`_ is
activated. (true by default)
The elements passed as kwargs as passed as is to the Marker constructor.
"""
default = dict()
if hasattr(point, "name"):
default["title"] = point.name
kwargs = {**default, **kwargs}
marker = Marker(location=(point.latitude, point.longitude), **kwargs)
label = HTML()
label.value = repr(point)
marker.popup = label
return marker
def drawRoute(route, zoom=12):
# getting the center of the route
m = Map(center=route[len(route) // 2], zoom=zoom)
# mark the source node coordinates
src_marker = Marker(location=route[0], draggable=False)
m.add_layer(src_marker)
# mark the destination node coordinates
dest_marker = Marker(location=route[len(route) - 1], draggable=False)
m.add_layer(dest_marker)
# draw AntPath between every two consecutive nodes
for u, v in zip(route[0:], route[1:]):
step = map(list, [u, v])
step_path = AntPath(locations=[*step],
dash_array=[1, 10],
delay=1000,
color='black',
pulse_color='red')
m.add_layer(step_path)
return m
def build_map(self, click_handler: Callable[[Dict[str, Any]],
None]) -> Map:
mean_lat = self.x_data[self.lat_key].values.mean()
mean_lng = self.x_data[self.lon_key].values.mean()
# create the map
m = Map(center=(mean_lat, mean_lng),
zoom=4,
basemap=basemaps.Stamen.Terrain)
m.layout.height = '1200px'
# show trace
markers = []
for k in self.marker_info:
message = self.create_popup(k)
marker = Marker(location=k, draggable=False)
marker.on_click(click_handler)
marker.popup = message
markers.append(marker)
marker_cluster = MarkerCluster(markers=markers)
# not sure whether we could register once instead of each marker:
# marker_cluster.on_click(click_handler)
m.add_layer(marker_cluster)
# m.add_control(FullScreenControl())
return m
def Give_Colored_Marker(df, Station, icone):
"""
Cette fonction permet de produire tous les marquers associés au station fourni dans le Graph.
On s'appuye sur le DataFrame donné pour trouver les stations,leur nom et leurs coordonées
"""
markers = []
for indice in Station:
markers.append(
Marker(location=(df.loc[indice].latitude,
df.loc[indice].longitude),
draggable=False,
title=df.loc[indice].Station_Name,
icon=icone))
return tuple(markers)
def Give_Marker_Cluster(df):
"""
Cette fonction permet de produire une clustered Marquer afin d'affichier l'ensemble des stations
du DataFrame.
Les stations se regroupent en fonction du zoom
"""
markers = []
for i in df.index:
x = df.loc[i].latitude
y = df.loc[i].longitude
name = df.loc[i].Station_Name
markers.append(Marker(location=(x, y), draggable=False, title=name))
return MarkerCluster(markers=(markers))
def _create_markers(self, sequence: list) -> List[Marker]:
"""
Creates markers in the needed structure/object.
:param sequence: list [int]
:return: list [Marker]
"""
markers = []
for s in sequence:
markers.append(
Marker(location=(self.dataframe["Breitengrad"][s],
self.dataframe["Längengrad"][s]),
title=self.dataframe["msg Standort"][s],
draggable=False))
return markers
def add_points_from_csv(self,
in_csv,
x="longitude",
y="latitude",
label=None,
layer_name="Marker cluster"):
# COME BACK TO THIS: https://carpentries-incubator.github.io/jupyter_maps/03-vector/index.html
# TO-DO: ADD POP UPS
points = csv_to_geojson(in_csv=in_csv, x=x, y=y)
markers = [
Marker(location=record['geometry']['coordinates'])
for record in points['features']
]
marker_cluster = MarkerCluster(markers=markers, name=layer_name)
self.add_layer(marker_cluster)
def plot_locations(alamat):
# location address
location = geocoder.osm(alamat)
# latitude and longitude of location
latlng = [location.lat, location.lng]
# create map
plot_locations_map = Map(center=latlng, zoom=16)
# marker
marker = Marker(location=latlng, title=str(alamat))
plot_locations_map.add_layer(marker)
# display map
display(plot_locations_map)
def _addControls(self):
# Add Controls
self._m.add_control(
MeasureControl(position='bottomleft',
active_color='orange',
primary_length_unit='kilometers'))
self._m.add_control(FullScreenControl())
self._m.add_control(ScaleControl(position='bottomleft'))
searchMarker = Marker(icon=AwesomeIcon(
name="check", marker_color='green', icon_color='darkred'))
self._m.add_control(
SearchControl(
position="topleft",
url=
'https://nominatim.openstreetmap.org/search?format=json&q={s}',
zoom=self._zoom,
marker=searchMarker))
def Give_Marker(df, G):
"""
Cette fonction permet de produire tous les marquers associés au station fourni dans le Graph.
On s'appuye sur le DataFrame donné pour trouver les stations,leur nom et leurs coordonées
"""
markers = []
for indice in list(G.nodes):
###############ICI MA MODIF NICO###################################
#if indice in df.index:
###############ICI MA MODIF NICO###################################
markers.append(
Marker(location=(df.loc[indice].latitude,
df.loc[indice].longitude),
draggable=False,
title=df.loc[indice].Station_Name))
return tuple(markers)
def Give_Colored_Marker(df, color='blue', type='d'):
if type == 'b':
name = 'fa-podcast'
elif type == 'd':
name = 'fa-user-circle-o'
else:
name = 'fa-user-circle-o'
icon1 = AwesomeIcon(name=name, marker_color=color, spin=False)
markers = []
for i in df.index:
x = df.loc[i][df.columns[0]]
y = df.loc[i][df.columns[1]]
name = str(i)
markers.append(
Marker(icon=icon1, location=(x, y), draggable=False, title=name))
return markers