def plotHeatmap(locations: [tuple],
heatmapName: str,
worldMap: lf.Map = None,
center: tuple = (0, 0),
**kwargs) -> lf.Map:
''' Plot the given lat lon locations as a heatmap layer on a world map object
@center: the center coordinate when creating the world map object
@locations: list of latitude & longitude pair
@worldMap: ipyleaflet Map object. If this is specified, the new heatmap will be addded
to this object. Else a new Map object will be created
@heatmapName: name of the heatmap layer
Returns: a newly created Map object or the passed in worldMap object.
'''
# Create map if it's not passed in to the function
if (worldMap is None):
baseMap = lf.basemaps.CartoDB.DarkMatter # lf.basemaps.Esri.WorldTopoMap
worldMap = lf.Map(basemap=baseMap, center=center, zoom=10)
worldMap.add_control(lf.FullScreenControl())
worldMap.add_control(lf.LayersControl(position='topright'))
# Remove existing heatmap layer that has the same name
removeLayerByType(worldMap, heatmapName, lf.Heatmap)
# Add the heatmap layer to the world map object
heatmap = lf.Heatmap(locations=locations,
radius=20,
name=heatmapName,
**kwargs)
worldMap.add_layer(heatmap)
return worldMap
def add_base_controls(self):
'''
add some basic interactive map controls
'''
zc = ipyl.ZoomControl(position='topright')
self.map.add_control(zc)
sc = ipyl.ScaleControl(position='bottomleft')
self.map.add_control(sc)
fsc = ipyl.FullScreenControl(position='topright')
self.map.add_control(fsc)
dc = ipyl.DrawControl(position='topright')
dc.marker = {}
dc.rectangle = {}
dc.circle = {}
dc.polyline = {}
dc.circlemarker = {}
dc.polygon = {
'shapeOptions': {
'color': '#81d8d0',
'fill_color': '#81d8d0',
'weight': 4,
'opacity': 1.0,
'fill_opacity': 0.7
}
}
self.map.add_control(dc)
def display_composite_ipyleaflet(self, zoom=10):
image = self.image.clip(ee.Geometry(self.polygon))
mapid = image.getMapId()
tiles_url = self.ee_tiles.format(**mapid)
tile_layer = ipyl.TileLayer(url=tiles_url,
layers='collection',
format='image/png',
name=self.collection,
opacity=1)
polygon = ipyl.Polygon(locations=self.locations,
color=self.color,
fill_opacity=0.,
name='AoI')
m = ipyl.Map(center=tuple(self.centroid), zoom=zoom)
m.add_layer(tile_layer)
m.add_layer(polygon)
control = ipyl.LayersControl(position='topright')
m.add_control(control)
m.add_control(ipyl.FullScreenControl())
return m
def create_map_widgets(self, title_list, map, inventory_df):
"""Create and add map widgets into map.
Args:
title_list (list): A list of the file names in the folder.
"""
map_dropdown = ipywgt.Dropdown(description='Outputfile - 1',
options=title_list,
width=500)
file_control1 = ipylft.WidgetControl(widget=map_dropdown,
position='bottomleft')
# use the following line when it needs to have another dropdown
# dropdown2 = ipywgt.Dropdown(description = 'Outputfile - 2', options = title_list2, width=500)
# file_control2 = ipylft.WidgetControl(widget=dropdown2, position='bottomleft')
button = ipywgt.Button(description='Generate Map', button_style='info')
button.on_click(self.on_button_clicked)
map_control = ipylft.WidgetControl(widget=button,
position='bottomleft')
map.add_control(ipylft.LayersControl(position='topright',
style='info'))
map.add_control(ipylft.FullScreenControl(position='topright'))
map.add_control(map_control)
# map.add_control(file_control2) # use the line when it needs to have extra dropdown
map.add_control(file_control1)
# set global for button click
self.map_dropdown = map_dropdown
self.inventory_df = inventory_df
self.inventory_json = json.loads(inventory_df.to_json())
return map
def show(self, tabs=True, layer_control=True, draw_control=False,
fullscreen=True):
""" Show the Map on the Notebook """
if not self.is_shown:
if layer_control:
# Layers Control
lc = ipyleaflet.LayersControl()
self.add_control(lc)
if draw_control:
# Draw Control
dc = ipyleaflet.DrawControl(edit=False)
dc.on_draw(self.handle_draw)
self.add_control(dc)
if fullscreen:
# Control
full_control = ipyleaflet.FullScreenControl()
self.add_control(full_control)
if tabs:
display(self, self.tab_widget)
else:
display(self)
else:
if tabs:
display(self, self.tab_widget)
else:
display(self)
self.is_shown = True
# Start with crosshair cursor
self.default_style = {'cursor': 'crosshair'}
def display_animation(self, url):
m = ipyl.Map(center=tuple(self.centroid), zoom=12)
video = ipyl.VideoOverlay(url=url,
bounds=tuple(list(map(tuple, self.bounds))))
m.add_layer(video)
m.add_control(ipyl.FullScreenControl())
return m
def __init__(self,
map=None,
layer_controller_list=None,
position_controller=None):
if map is None:
map = Map()
map.add_control(ipyleaflet.FullScreenControl())
if layer_controller_list is None:
from .layer_controller import LayerControllerList
layer_controller_list = LayerControllerList(map)
if position_controller is None:
position_controller = PositionController(map)
self.map = map
self.controller_list = layer_controller_list
self.position_controller = position_controller
def on_clear():
for layer in self.map.layers:
try:
layer.forget_errors()
except AttributeError:
pass
self.errors = ClearableOutput(
map.error_log,
on_clear=on_clear,
layout=widgets.Layout(max_height="20rem", flex="0 0 auto"),
)
self.autoscale_outputs = widgets.VBox(
[
x.autoscale_progress for x in reversed(self.map.layers)
if isinstance(x, WorkflowsLayer)
],
layout=widgets.Layout(flex="0 0 auto", max_height="16rem"),
)
super(MapApp, self).__init__(
[
map,
self.errors,
map.output_log,
self.autoscale_outputs,
position_controller,
layer_controller_list,
],
layout=app_layout,
)
map.observe(self._update_autoscale_progress, names=["layers"])
def __init__(self, distance_choice="agat"):
self.m = ipyl.Map(center=(45, 0), zoom=7, layout={"height": "500px"})
# Date
date_picker = widg.DatePicker(value=dt.datetime(2020, 1, 26))
self._date = date_picker.value
date_picker.observe(self.change_date, "value")
self.step = 0
self.distance_choice = distance_choice
variable_picker = widg.Dropdown(
value="WWMF", options=["WWMF", "WME", "W1", "PRECIP", "T"])
variable_picker.observe(self.variable_change, "value")
dept_picker = widg.Dropdown(value="41",
options={
"Finistère": "29",
"Isère": "38",
"Hérault": "34",
"Loire-et-cher": "41"
})
dept_picker.observe(self.change_dept, "value")
self.dept = dept_picker.value
self._variable = variable_picker.value
# Open dataset and mask
self.open_file()
# Add other widgets
self.legend = widg.Image(layout=widg.Layout(height="430px"))
self.html1 = HTML('''
<h4>Type de temps</h4>
Hover over a pixel
''')
self.html1.layout.margin = '0px 20px 20px 20px'
# Add controls
control1 = WidgetControl(widget=self.html1, position='bottomright')
self.m.add_control(control1)
self.m.add_control(ipyl.LayersControl())
slider = widg.IntSlider(min=0,
max=len(self.da.step) - 1,
step=1,
value=0,
description="step")
slider.observe(self.change_step, 'value')
self.m.add_control(
ipyl.WidgetControl(widget=widg.VBox(
[date_picker, slider, variable_picker, dept_picker]),
position="topright"))
self.m.add_control(ipyl.FullScreenControl())
self.render()
super().__init__([self.m, self.legend])
def __init__(self,
center,
width=None,
height=None,
zoom=None,
fullscreen_widget=False):
"""Return a instance of a Map."""
if width is None:
width = ConfigManager.get_maps('width')
if height is None:
height = ConfigManager.get_maps('height')
if zoom is None:
zoom = 15
layout = ipywidgets.Layout(width=f'{width}px', height=f'{height}px')
self.map = ipyleaflet.Map(center=center, zoom=zoom, layout=layout)
self.map.add_control(ipyleaflet.ScaleControl(position='bottomleft'))
if fullscreen_widget:
self.map.add_control(ipyleaflet.FullScreenControl())
def create_map_widgets(self, m, outfiles):
self.dropdown1 = ipywgt.Dropdown(description='Outputfile - 1',
options=outfiles,
width=500)
file_control1 = ipylft.WidgetControl(widget=self.dropdown1,
position='bottomleft')
# self.dropdown2 = ipywgt.Dropdown(description = 'Outputfile - 2', options = outfiles, width=500)
# file_control2 = ipylft.WidgetControl(widget=self.dropdown2, position='bottomleft')
button = ipywgt.Button(description='Generate Map', button_style='info')
button.on_click(self.on_button_clicked)
generatemap_control = ipylft.WidgetControl(widget=button,
position='bottomleft')
m.add_control(ipylft.LayersControl(position='topright', style='info'))
m.add_control(ipylft.FullScreenControl(position='topright'))
m.add_control(generatemap_control)
# m.add_control(file_control2)
m.add_control(file_control1)
def plotLeaflet(geoJson: dict,
idToValue: dict,
worldMap: lf.Map = None,
includeEmpty: bool = True,
labelFormat: str = "Id={0} - Value={1}",
mapArgs: dict = {},
heatmapArgs: dict = {}) -> lf.Map:
''' Plot the choropleth on the map using the ipyleaflet library
@idToValue: a dictionary containing mappings of ids to their associated values
@worldMap: ipyleaflet Map object. If this is specified, the new heatmap will be addded
to this object. Else a new Map object will be created
@includeEmpty: true if we want to display the regions that have value 0. False otherwise
@labelFormat: the string format of the text that is displayed when the mouse hovers over a polygon.
The format must contain exactly 2 placeholders.
Returns: map object
'''
updatedIdToValue = __syncIdToValueDict(geoJson, idToValue)
# If we don't display empty regions, we need to
# create a new geo JSON that does NOT contain the
# ids that have 0 value
if (not includeEmpty):
origGeoJson = geoJson
geoJson = {"type": "FeatureCollection", "features": []}
for idValue, value in updatedIdToValue.items():
if (value > 0):
feature = getFeatureById(origGeoJson, idValue)
geoJson["features"].append(feature)
# Create the world map object if not specified
if (worldMap is None):
#basemap=lf.basemaps.CartoDB.DarkMatter, center=center, zoom=10
worldMap = lf.Map(**mapArgs)
worldMap.add_control(lf.FullScreenControl())
worldMap.add_control(lf.LayersControl(position="topright"))
# Default heatmap arguments
minVal, maxVal = min(updatedIdToValue.values()), max(
updatedIdToValue.values())
defaultHeatmapArgs = {
"key_on": "id",
"border_color": "black",
"value_min": minVal,
"value_max": maxVal,
"style": {
'fillOpacity': 0.8,
'dashArray': '5, 5'
},
"hover_style": {
'fillColor': 'purple',
'dashArray': '0',
'fillOpacity': 0.5
},
"name": "Choropleth",
"colormap": linear.OrRd_06
}
# Make a copy of the heatmapArgs, because we would add the default arguments
# to this dict if the default arguments are not specified by the caller. Making
# a copy prevents modifying the passed in dict object
heatmapArgs = dict(heatmapArgs)
for k, v in defaultHeatmapArgs.items():
if (k not in heatmapArgs):
heatmapArgs[k] = v
# Create the choropleth layer
choroplethLayer = lf.Choropleth(geo_data=geoJson,
choro_data=updatedIdToValue,
**heatmapArgs)
# Create a label widget to display the currently hovered polygon id &
# the value associated with that id
labelWidget = widgets.Label(value="")
widgetControl = lf.WidgetControl(widget=labelWidget,
position="bottomright")
worldMap.add_control(widgetControl)
def mouseout(*args, **kwargs):
''' Set the label value to empty string when the mouse exits a region '''
labelWidget.value = ""
def hover(*args, **kwargs):
''' Set the label to the id & its associated value '''
idValue = kwargs["id"]
labelWidget.value = labelFormat.format(idValue,
updatedIdToValue[idValue])
# Register callbacks
choroplethLayer.on_mouseout(mouseout)
choroplethLayer.on_hover(hover)
# Remove existing choropleth layer that has the same name
choroplethName = heatmapArgs["name"] if ("name" in heatmapArgs) else ""
removeLayerByType(worldMap, choroplethName, lf.Choropleth)
worldMap.add_layer(choroplethLayer)
return worldMap
def show(self, **kwargs):
"""
Generate and return the map object for displaying the map
Parameters
-----------
None
Returns
----------
map:ipyleaflet.Map
"""
self.map = ipyleaflet.Map(
layers=(ipyleaflet.basemap_to_tiles(
ipyleaflet.basemaps.CartoDB.Positron),),
**kwargs
)
choro_layer = ipyleaflet.Choropleth(
name=self.dataset,
geo_data=self.geo_data,
choro_data=self.choro_data[self.selectedAttr][self.selectedYear],
colormap=linear.YlOrRd_04,
style={
'opacity': 1,
'weight': 1.9,
'dashArray': '9',
'fillOpacity': 0.5}
)
def handle_click(**kwargs):
if kwargs['event'] == 'click':
clickedFips = kwargs['properties']['GEOID']
clickedName = self.fipsLookUp[clickedFips]
dataBox.value = f"{clickedName} : {self.choro_data[self.selectedAttr][self.selectedYear][clickedFips]:,}"
self.clickedID = clickedFips
choro_layer.on_click(handle_click)
# Year select
def handle_year_change(change):
new_year = str(change.new)
choro_layer.choro_data = self.choro_data[self.selectedAttr][new_year]
if self.clickedID:
clickedName = self.fipsLookUp[self.clickedID]
dataBox.value = f"{clickedName} : {self.choro_data[self.selectedAttr][new_year][self.clickedID]:,}"
self.selectedYear = new_year
yearList = self.availableYearDict[self.selectedAttr]
yearListNum = list(map(int, yearList))
minYear = min(yearListNum)
maxYear = max(yearListNum)
yearSlider, yearWidget = self.yearSlider(minYear, maxYear, maxYear)
yearSlider.observe(handle_year_change, 'value')
dataBox, dataWidget = self.dataBox()
def handle_attr_change(change):
new_attr = change.new
choro_layer.choro_data = self.choro_data[new_attr][self.selectedYear]
if self.clickedID:
clickedName = self.fipsLookUp[self.clickedID]
dataBox.value = f"{clickedName} : {self.choro_data[new_attr][self.selectedYear][self.clickedID]:,}"
self.selectedAttr = new_attr
attrDropdown, attrDropdownWidget = self.attrDropdown()
attrDropdown.observe(handle_attr_change, "value")
# Add to map
self.map.add_layer(choro_layer)
self.map.add_control(ipyleaflet.LayersControl())
self.map.add_control(ipyleaflet.FullScreenControl())
self.map.add_control(attrDropdownWidget)
self.map.add_control(yearWidget)
self.map.add_control(dataWidget)
return self.map
def plot_geo_data_cluster(data, geom_column, title_columns):
def date_filter(df, date_range, timestamp_column: str):
dates = pd.to_datetime(df[timestamp_column]).apply(pd.Timestamp.date)
return df[(date_range[0] <= dates) & (dates <= date_range[1])]
def toggle_tweets_table_visibility(change):
app_state['is_in_bounds'] = None
if change['old'] and not change['new']:
tweets_table.value, app_state['is_in_bounds'] = '', None
else:
update_range()
def update_range(*_):
def in_bounds(loc):
return all(bounds[0] < loc) and all(loc < bounds[1])
if len(m.bounds) == 0:
return
bounds = np.array(m.bounds)
locs = app_state['filtered_data'][geom_column].apply(_wkb_hex_to_point)
is_in_bounds = locs.apply(in_bounds)
if app_state['is_in_bounds'] is None or not np.array_equal(
is_in_bounds, app_state['is_in_bounds']):
if is_in_bounds.sum() > 0:
ts_plot = _get_ts_count_plot(
app_state['full_data'],
app_state['filtered_data'][is_in_bounds],
app_state['timestamp_column'])
time_slider_box.children = [
ts_plot, *time_slider_box.children[1:]
]
if tweets_table_cb.value:
tweets_table.value = app_state['filtered_data'].loc[
is_in_bounds,
title_columns].reset_index(drop=True).to_html(
formatters={'media': _to_html},
escape=False,
na_rep='',
index=False)
else:
tweets_table.value = ''
tweets_table_cb.description = 'Show {} Tweets'.format(
is_in_bounds.sum())
app_state['is_in_bounds'] = is_in_bounds
def change_date_range(change):
def filter_markers(marker_cluster: ipyleaflet.MarkerCluster, min_date,
max_date):
marker_cluster.markers = [
m for m in app_state['markers']
if min_date <= m.timestamp.date() <= max_date
]
filtered_data = date_filter(
app_state['full_data'],
change['new'],
timestamp_column=app_state['timestamp_column'])
app_state['filtered_data'] = filtered_data
heatmap.locations = list(
filtered_data[geom_column].apply(_wkb_hex_to_point).values)
filter_markers(marker_clusters, *change['new'])
update_range()
m = ipyleaflet.Map(center=(51, 10),
zoom=4,
scroll_wheel_zoom=True,
zoom_control=False)
m.layout.height = '900px'
app_state = dict(is_in_bounds=None,
full_data=data.dropna(subset=[geom_column]),
filtered_data=data.dropna(subset=[geom_column]),
timestamp_column=_get_timestap_column(data))
info_box_default_text = 'Hover over a marker'
info_box = widgets.HTML(info_box_default_text,
layout=Layout(margin='10px',
overflow='scroll_hidden'))
m.add_control(
ipyleaflet.WidgetControl(widget=widgets.HBox(
[info_box], layout=Layout(max_height='300px')),
position='topright'))
loading_wrapper = _loading_wrapper_factory(info_box, info_box_default_text)
tweets_table = widgets.HTML(layout=widgets.Layout(
overflow='scroll_hidden'))
tweets_table_box = widgets.HBox([tweets_table],
layout=Layout(max_height='500px',
overflow_y='auto',
max_width='900px'))
tweets_table_cb = widgets.Checkbox(value=False)
tweets_table_cb.observe(toggle_tweets_table_visibility,
type='change',
names=('value', ))
tweets_box = widgets.VBox([tweets_table_cb, tweets_table_box])
m.add_control(
ipyleaflet.WidgetControl(widget=tweets_box, position='bottomleft'))
time_slider = get_time_slider(app_state['full_data'])
time_slider.observe(loading_wrapper(change_date_range),
type='change',
names=('value', ))
time_slider.layout.margin, time_slider.description = '0px 5px 0px 5px', ''
ts_plot = _get_ts_count_plot(data, app_state['filtered_data'],
app_state['timestamp_column'])
time_slider_box = widgets.VBox([ts_plot, time_slider])
m.add_control(
ipyleaflet.WidgetControl(widget=time_slider_box, position='topleft'))
marker_clusters = get_marker_cluster(
app_state['filtered_data'],
geom_column,
title_columns=title_columns,
info_box=info_box,
timestamp_column=app_state['timestamp_column'])
app_state['markers'] = marker_clusters.markers
heatmap_locations = list(app_state['filtered_data'][geom_column].apply(
_wkb_hex_to_point).values)
heatmap = ipyleaflet.Heatmap(name='Heatmap',
min_opacity=.1,
blur=20,
radius=20,
max_zoom=12,
locations=heatmap_locations)
m.add_layer(heatmap)
m.add_layer(marker_clusters)
change_date_range(dict(new=time_slider.value))
m.add_control(ipyleaflet.LayersControl())
m.add_control(ipyleaflet.FullScreenControl())
m.observe(update_range)
display(m)
def __init__(self,
map=None,
layer_controller_list=None,
map_controller=None):
if map is None:
map = Map()
map.add_control(ipyleaflet.FullScreenControl())
map.add_control(ipyleaflet.ScaleControl(position="bottomleft"))
map.add_control(
ipyleaflet.SearchControl(
position="topleft",
url=
"https://nominatim.openstreetmap.org/search?format=json&q={s}",
))
if layer_controller_list is None:
from .layer_controller import LayerControllerList
layer_controller_list = LayerControllerList(map)
if map_controller is None:
map_controller = MapController(map)
self.map = map
self.controller_list = layer_controller_list
widgets.link(
(self, "control_tile_layers"),
(layer_controller_list, "control_tile_layers"),
)
widgets.link(
(self, "control_other_layers"),
(layer_controller_list, "control_other_layers"),
)
self.map_controller = map_controller
def on_clear():
for layer in self.map.layers:
try:
layer.forget_logs()
except AttributeError:
pass
self.clearable_logs = ClearableOutput(
map.logs,
on_clear=on_clear,
layout=widgets.Layout(max_height="20rem", flex="0 0 auto"),
)
self.autoscale_outputs = widgets.VBox(
[
x.autoscale_progress for x in reversed(self.map.layers)
if isinstance(x, WorkflowsLayer)
],
layout=widgets.Layout(flex="0 0 auto", max_height="16rem"),
)
super(MapApp, self).__init__(
[
map,
self.clearable_logs,
map.output_log,
self.autoscale_outputs,
map_controller,
layer_controller_list,
],
layout=app_layout,
)
map.observe(self._update_autoscale_progress, names=["layers"])
def add_fullscreen_control(map):
"use map (ipyleaflet.Map object), add fullscreen control and return object"
map.add_control(ipyleaflet.FullScreenControl())
return map
def _build_ui(self,
product_names,
time,
zoom=None,
center=None,
height=None,
width=None):
import ipyleaflet as L
from ipywidgets import widgets as w
pp = {"zoom": zoom or 1}
if center is not None:
pp["center"] = center
m = L.Map(**pp, scroll_wheel_zoom=True)
m.add_control(L.FullScreenControl())
prod_select = w.Dropdown(
options=product_names,
layout=w.Layout(
flex="0 1 auto",
width="10em",
),
)
date_txt = w.Text(
value=time,
layout=w.Layout(
flex="0 1 auto",
width="6em",
),
)
info_lbl = w.Label(
value="",
layout=w.Layout(flex="1 0 auto",
# border='1px solid white',
),
)
btn_bwd = w.Button(
icon="step-backward",
layout=w.Layout(
flex="0 1 auto",
width="3em",
),
)
btn_fwd = w.Button(
icon="step-forward",
layout=w.Layout(
flex="0 1 auto",
width="3em",
),
)
btn_show = w.Button(
description="show",
layout=w.Layout(
flex="0 1 auto",
width="6em",
),
style=dict(
# button_color='green'
),
)
ctrls = w.HBox(
[
prod_select,
w.Label("Time Period"),
date_txt,
btn_bwd,
btn_fwd,
info_lbl,
btn_show,
],
layout=w.Layout(
# border='1px solid tomato',
),
)
# m.add_control(L.WidgetControl(widget=ctrls, position='topright'))
ui = w.VBox(
[ctrls, m],
layout=w.Layout(
width=width,
height=height,
# border='2px solid plum',
),
)
state = SimpleNamespace(time=time,
product=product_names[0],
count=0,
bounds=None)
ui_state = SimpleNamespace(ui=ui, info=info_lbl, map=m)
def bounds_handler(event):
(lat1, lon1), (lat2, lon2) = event["new"]
lon1 = max(lon1, -180)
lon2 = min(lon2, +180)
lat1 = max(lat1, -90)
lat2 = min(lat2, +90)
state.bounds = dict(lat=(lat1, lat2), lon=(lon1, lon2))
self.on_bounds(state.bounds)
def on_date_change(txt):
state.time = txt.value
self.on_date(state.time)
def on_product_change(e):
state.product = e["new"]
self.on_product(state.product)
def on_show(b):
state.time = date_txt.value
self.on_show()
def time_advance(step):
date_txt.value = _dt_step(date_txt.value, step)
on_date_change(date_txt)
date_txt.on_submit(on_date_change)
prod_select.observe(on_product_change, ["value"])
m.observe(bounds_handler, ("bounds", ))
btn_show.on_click(on_show)
btn_fwd.on_click(lambda b: time_advance(1))
btn_bwd.on_click(lambda b: time_advance(-1))
return state, ui_state
def plot_geo_shapes_vis(data, nuts_shapes, nuts_ids_columns, color_column,
timestamp_column):
def plot_cbar(name, logarithmic=False):
vmin, vmax = app_state['vmin'], app_state['vmax']
if vmin == vmax or any(pd.isna([vmin, vmax])):
return
fig, ax = plt.subplots(figsize=(.3, 10))
norm = matplotlib.colors.LogNorm(
vmin, vmax) if logarithmic else matplotlib.colors.Normalize(
vmin, vmax)
cbar = matplotlib.colorbar.ColorbarBase(ax,
cmap=plt.get_cmap(name),
norm=norm,
orientation='vertical')
return cbar
def change_date_range(change):
data = _date_filter(app_state['data'],
change['new'],
timestamp_column=timestamp_column).dropna(
subset=nuts_ids_columns, how='all')
merged_dfs = [
merge_df(data=data,
nuts_shapes=nuts_shapes,
nuts_ids_column=nuts_ids_column,
color_column=color_column,
level=level_selector.value,
levels=app_state['nuts_levels'])
for nuts_ids_column in nuts_ids_columns
]
app_state['vmax'] = np.max(
[df[color_column].max() for df in merged_dfs])
interactive_output(
plot_cbar, dict(name=cmap_selector, logarithmic=logarithmic_cbox))
m.layers = [l for l in m.layers if type(l) != ipyleaflet.LayerGroup]
for merged_df, nuts_ids_column in zip(merged_dfs, nuts_ids_columns):
table_columns = [
'_timestamp', 'text_translated', 'num_persons', 'mode',
*[col for col in nuts_ids_columns if col != nuts_ids_column]
]
layer = get_shapes_heatmap(data=merged_df,
nuts_ids_column=nuts_ids_column,
color_column=color_column,
info_widget_html=info_widget,
vmin=app_state['vmin'],
vmax=app_state['vmax'],
full_data=app_state['full_data'],
time_hist=time_hist,
date_limits=change['new'],
tweets_table=tweets_table,
cmap=app_state['cmap'],
table_columns=table_columns,
logarithmic=app_state['logarithmic'])
m.add_layer(layer)
if 'full_groups' not in app_state:
app_state['full_groups'] = [
l.layers for l in m.layers if type(l) is ipyleaflet.LayerGroup
]
cbar_widget.children = [
interactive_output(
plot_cbar,
dict(name=cmap_selector, logarithmic=logarithmic_cbox))
]
def change_level_layers(change={}):
def change_layers(layer_group: ipyleaflet.LayerGroup,
all_layers: list):
new_layers = [
l for l in all_layers if l.data['features'][0]['properties']
['LEVL_CODE'] == app_state['level']
]
layer_group.layers = new_layers if app_state[
'level'] != 'all' else all_layers
layer_groups = [
l for l in m.layers if type(l) is ipyleaflet.LayerGroup
]
if 'new' in change:
app_state['level'] = change['new']
for layer_group, full_group in zip(layer_groups,
app_state['full_groups']):
change_layers(layer_group, full_group)
def change_colormap():
cmap, logarithmic = app_state['cmap'], app_state['logarithmic']
def update_layer(l):
val = l.data['features'][0]['properties'][color_column]
color = get_color(val,
cmap=cmap,
vmin=app_state['vmin'],
vmax=app_state['vmax'],
logarithmic=logarithmic)
l.style.update({'fillColor': color, 'color': color})
l.hover_style.update({'fillColor': color, 'color': color})
new_layer = ipyleaflet.GeoJSON(data=l.data,
style=l.style,
hover_style=l.hover_style)
new_layer._hover_callbacks = l._hover_callbacks
new_layer._click_callbacks = l._click_callbacks
return new_layer
app_state['full_groups'] = [[update_layer(l) for l in layers]
for layers in app_state['full_groups']]
change_level_layers()
def change_colormap_name(change):
app_state['cmap'] = change['new']
change_colormap()
def change_colormap_log(change):
app_state['logarithmic'] = change['new']
change_colormap()
def add_widget(widget, pos, margin='0px 0px 0px 0px'):
widget.layout.margin = margin
widget_control = ipyleaflet.WidgetControl(widget=widget, position=pos)
m.add_control(widget_control)
def on_zoom(change, offset=-5):
if m.zoom != app_state['zoom']:
app_state['zoom'] = m.zoom
if level_on_zoom.value:
min_level, max_level = np.min(
app_state['nuts_levels']), np.max(app_state['nuts_levels'])
level = min(max_level, max(min_level, m.zoom + offset))
app_state['level'] = level
level_selector.value = level
app_state = dict(zoom=4,
data=data.dropna(subset=nuts_ids_columns, how='all'),
cmap='viridis',
logarithmic=False,
vmin=1,
vmax=1,
full_data=data.copy(),
level='all',
nuts_levels=sorted(nuts_shapes['LEVL_CODE'].unique()))
m = ipyleaflet.Map(center=(51, 10),
zoom=app_state['zoom'],
scroll_wheel_zoom=True,
zoom_control=False)
m.layout.height = '900px'
info_widget_default_text = 'Hover over a Region<br>Click it to see tweets'
info_widget = widgets.HTML(info_widget_default_text)
add_widget(info_widget, pos='topright', margin='0px 5px 0px 5px')
loading_wrapper = _loading_wrapper_factory(info_widget,
info_widget_default_text)
time_hist = widgets.HBox([])
add_widget(time_hist, pos='bottomleft')
tweets_table = widgets.HTML(layout=widgets.Layout(
overflow='scroll_hidden'))
tweets_box = widgets.HBox([tweets_table],
layout=Layout(max_height='400px',
overflow_y='auto',
max_width='900px'))
add_widget(tweets_box, pos='bottomleft')
time_slider = get_time_slider(app_state['data'])
time_slider.observe(loading_wrapper(change_date_range),
type='change',
names=('value', ))
add_widget(time_slider, 'topleft', margin='0px 5px 0px 5px')
level_selector = widgets.Dropdown(
options=['all', *app_state['nuts_levels']],
description='NUTS levels',
layout=Layout(max_width='180px'))
level_selector.observe(handler=loading_wrapper(change_level_layers),
type='change',
names=('value', ))
level_on_zoom = widgets.Checkbox(value=True,
description='with zoom',
layout=Layout(max_width='180px'))
level_control = widgets.VBox([level_selector, level_on_zoom])
cmap_selector = widgets.Dropdown(
options=['viridis', 'inferno', 'magma', 'winter', 'cool'],
description='colormap',
layout=Layout(max_width='180px'))
logarithmic_cbox = widgets.Checkbox(description='logarithmic',
layout=Layout(max_width='180px'))
cmap_control = widgets.VBox([cmap_selector, logarithmic_cbox])
cmap_selector.observe(handler=loading_wrapper(change_colormap_name),
type='change',
names=('value', ))
logarithmic_cbox.observe(handler=loading_wrapper(change_colormap_log),
type='change',
names=('value', ))
add_widget(widgets.HBox([level_control, cmap_control]),
pos='topleft',
margin='5px 5px 0px 5px')
cbar_widget = widgets.HBox([
interactive_output(
plot_cbar, dict(name=cmap_selector, logarithmic=logarithmic_cbox))
])
add_widget(cbar_widget, pos='bottomright')
m.add_control(ipyleaflet.LayersControl())
m.add_control(ipyleaflet.FullScreenControl())
m.observe(handler=on_zoom)
change_date_range(dict(new=time_slider.value))
display(m)
def controls_on_Map(self):
control_layer = ipyleaflet.LayersControl(position='topright')
self.m01.add_control(control_layer)
control_fullscreen = ipyleaflet.FullScreenControl()
self.m01.add_control(control_fullscreen)
self.control_draw = ipyleaflet.DrawControl()
self.m01.add_control(self.control_draw)
control_scale = ipyleaflet.ScaleControl(position='bottomleft')
self.m01.add_control(control_scale)
slider_heatmap_radius = ipywidgets.IntSlider(description='Radius',
min=1,
max=50,
value=15)
ipywidgets.jslink((slider_heatmap_radius, 'value'),
(self.heatmap_all, 'radius'))
widget_control01 = ipyleaflet.WidgetControl(
widget=slider_heatmap_radius, position='bottomright')
self.m01.add_control(widget_control01)
self.date_slider = ipywidgets.SelectionSlider(options=pd.date_range(
start='2000-01-01', end='2020-01-01', freq='M').to_numpy())
self.date_slider.observe(self.date_location, names='value')
ipywidgets.jslink((slider_heatmap_radius, 'value'),
(self.heatmap_byLast, 'radius'))
widget_control02 = ipyleaflet.WidgetControl(widget=self.date_slider,
position='topright')
self.m01.add_control(widget_control02)
self.control_selectDownload = ipywidgets.Dropdown(
options=['Watershed', 'All', 'byDate'],
value=None,
description='Select type:')
self.control_selectDownload.observe(self.dropdown_shapefile,
names='value')
self.control_selectDownload.observe(self.shapefile_buttom,
names='value')
box_layout = ipywidgets.Layout(display='flex',
flex_flow='column',
align_items='stretch',
width='100%')
self.control_pathDownload = ipywidgets.Text(
placeholder='Write your PATH to Download HERE.')
vbox01 = ipywidgets.VBox(
[self.control_selectDownload, self.control_pathDownload])
self.control_buttonDownload = ipywidgets.Button(description='Download')
self.control_loadingDownload = ipywidgets.FloatProgress(min=0,
max=1,
value=0)
self.control_choiceDownload = ipywidgets.RadioButtons(
options=['Rain', 'Flow'])
hbox01 = ipywidgets.HBox(
[self.control_choiceDownload, self.control_buttonDownload],
layout=box_layout)
vbox02 = ipywidgets.VBox(
[vbox01, hbox01, self.control_loadingDownload], layout=box_layout)
widget_control03 = ipyleaflet.WidgetControl(widget=vbox02,
position='bottomright')
self.m01.add_control(widget_control03)
# control_progressDownload = ipywidgets.FloatProgress()
self.control_shapefileButtom = ipywidgets.Button(
description='Visualizar')
