def add_map_point(data, zoom, m, kml, name):
# Make geojson from data
gjson = ipyleaflet.GeoJSON(data=data, name=name)
# Center map
m.center = gjson.data['coordinates'][::-1]
# Set map zoom
m.zoom = zoom
# Add geojson to map
m.add_layer(gjson)
# Make KML via earth engine functionality
geo_point = ee.Geometry.Point(
gjson.data['coordinates'][::-1]) # This may not work
geo_fc = ee.FeatureCollection(geo_point)
kmlstr = geo_fc.getDownloadURL("kml")
# Update KML widget
kml.value = "<a '_blank' rel='noopener noreferrer' href={}>KML Link</a>".format(
kmlstr)
# Add pixel bounds
_bounds = utils.get_bounds(geo_point, ee.Projection("EPSG:4326")).getInfo()
pixel_bounds = ipyleaflet.Polyline(locations=_bounds['coordinates'],
name="Pixel")
m.add_layer(pixel_bounds)
return
def click_add_filter_layer(change):
import itertools
import copy
data = copy.deepcopy(m.find_layer(dropdown_layer.value).data)
filter_data = [
record for record in data['features'] if record['properties'][
dropdown_layer_field.value] == dropdown_layer_field_value.value
]
data['features'] = filter_data
style = {
"stroke": True,
"color": "#000000",
"weight": 2,
"opacity": 1,
"fill": True,
"fillColor": "#0000ff",
"fillOpacity": 0.4,
}
geojson = ipyleaflet.GeoJSON(data=data,
style=style,
name="{} - {} - {} Layer".format(
dropdown_layer.value,
dropdown_layer_field.value,
dropdown_layer_field_value.value))
m.add_layer(geojson)
def add_geojson(self, in_geojson, style=None, layer_name="Untitled"):
import json
if isinstance(in_geojson, str):
if not os.path.exists(in_geojson):
raise FileNotFoundError(
"The provided GeoJSON file could not be found.")
with open(in_geojson) as f:
data = json.load(f)
elif isinstance(in_geojson, dict):
data = in_geojson
else:
raise TypeError("The input geojson must be a type of str or dict.")
if style is None:
style = {
"stroke": True,
"color": "#000000",
"weight": 2,
"opacity": 1,
"fill": True,
"fillColor": "#000000",
"fillOpacity": 0.4,
}
geo_json = ipyleaflet.GeoJSON(data=data, style=style, name=layer_name)
self.add_layer(geo_json)
def widget_search_button_handler(change):
global features, datasets, standard_name, dataset_id, constraints
search_min_time = pendulum.parse(widget_search_min_time.value)
search_max_time = pendulum.parse(widget_search_max_time.value)
# get standard_name from dropdown widget
standard_name = widget_std_names.value
# get updated datsets and map features
features, datasets = stdname2geojson(e, standard_name, cdm_data_type,
search_min_time, search_max_time)
# update map
feature_layer = ipyl.GeoJSON(data=features)
feature_layer.on_click(map_click_handler)
map.layers = [map.layers[0], feature_layer]
# widget_plot_start_time.value = widget_search_min_time.value
# widget_plot_stop_time.value = widget_search_max_time.value
# populate datasets widget with new info
dataset_id = datasets[0]
widget_dsnames.options = datasets
widget_dsnames.value = dataset_id
constraints = {'time>=': search_min_time, 'time<=': search_max_time}
print(dataset_id, standard_name, constraints)
update_timeseries_plot(dataset=dataset_id,
standard_name=standard_name,
constraints=constraints)
def __init__(
self,
disp: Displayable,
token: str,
name: str,
loop: asyncio.AbstractEventLoop,
cache_size=CACHE_SIZE,
debug: bool = DEBUG_SHOW,
):
self.disp = disp
self.token = token
self.loop = loop
self.tiles: cachetools.LRUCache[
Tuple[int, int, int],
TileManager.TileRef] = cachetools.LRUCache(maxsize=cache_size)
self.stats = ServerStats(name=name)
if debug:
self.debug_layer = ipyleaflet.GeoJSON(
data=dict(type="FeatureCollection", features=[]),
style_callback=lambda feature: dict(
color="yellow"
if feature["properties"]["speculative"] else "blue",
fillColor="black"
if feature["properties"]["cancelled"] else "green"
if feature["properties"]["done"] else "orange",
),
)
self._debugger_handle = loop.call_soon_threadsafe(
loop.create_task, self._update_debug_layer())
else:
self._debugger_handle = None
def render(self):
#print("Avant de descendre dans le decorateur etc")
geo_file,legend_file = self.get_step(variable= self.variable)
#print("On en revient ici")
geojson_layer = ipyl.GeoJSON(data=geo_file,hover_style={"opacity":1},name="AROME")
if hasattr(self,"geojson_layer"):
if self.geojson_layer in self.m.layers:
self.m.substitute_layer(self.geojson_layer,geojson_layer)
else:
#print("par ici?")
self.m.add_layer(geojson_layer)
else:
self.m.add_layer(geojson_layer)
self.geojson_layer = geojson_layer
self.geojson_layer.on_hover(self.update_html)
legend_file.seek(0)
self.legend.value =legend_file.read()
chor_layer = ipyl.Choropleth(geo_data=self.region_geo,
choro_data=self.da_aggregated.isel(step=self.step).to_pandas().to_dict(),
name="zonage sur temps sensible (WME)",
value_min = self.vmin,
value_max = self.vmax,
colormap=linear.RdBu_03)
if hasattr(self,"chor_layer"):
if self.chor_layer in self.m.layers:
#print("on passe la")
self.m.substitute_layer(self.chor_layer,chor_layer)
else:
#print("ici")
self.m.add_layer(chor_layer)
else:
#print('ou la')
self.m.add_layer(chor_layer)
self.chor_layer = chor_layer
self.chor_layer.on_hover(self.update_chor_html)
chor_layer2 = ipyl.Choropleth(geo_data=self.region_geo2,
choro_data=self.toto,
name="zonage sur homogeneous temps sensible criterion ("+self.distance_choice+")",
value_min = self.vmin,
value_max = self.vmax,
colormap=linear.RdBu_07)
if hasattr(self,"chor_layer2"):
if self.chor_layer2 in self.m.layers:
#print("et par la")
self.m.substitute_layer(self.chor_layer2,chor_layer2)
else:
#print('et ici')
self.m.add_layer(chor_layer2)
else:
#print('et ou la')
self.m.add_layer(chor_layer2)
self.chor_layer2 = chor_layer2
self.chor_layer2.on_hover(self.update_chor_html2)
def add_geojson(self, geojson, name='', popup=None):
g = leaflet.GeoJSON(data=geojson,
hover_style={'fillColor': '#00aaff'},
name=name)
if popup is not None:
g.popup = popup
self.map += g
def addGeometry(self,
geometry,
visParams=None,
name=None,
show=True,
opacity=None,
replace=True,
inspect={
'data': None,
'reducer': None,
'scale': None
}):
""" Add a Geometry to the Map
:param geometry: the Geometry to add to Map
:type geometry: ee.Geometry
:param visParams:
:type visParams: dict
:param name: name for the layer
:type name: str
:param inspect: when adding a geometry or a feature you can pop up data
from a desired layer. Params are:
:data: the EEObject where to get the data from
:reducer: the reducer to use
:scale: the scale to reduce
:type inspect: dict
:return: the name of the added layer
:rtype: str
"""
thename = name if name else 'Geometry {}'.format(self.addedGeometries)
# Check if layer exists
if thename in self.EELayers.keys():
if not replace:
print(
"Layer with name '{}' exists already, please choose another name"
.format(thename))
return
else:
self.removeLayer(thename)
params = getGeojsonTile(geometry, thename, inspect)
layer = ipyleaflet.GeoJSON(data=params['geojson'],
name=thename,
popup=HTML(params['pop']))
self._add_EELayer(
thename, {
'type': 'Geometry',
'object': geometry,
'visParams': None,
'layer': layer
})
return thename
def render(self, resp: requests.models.Response) -> ipyleaflet.Map:
"Return an ipyleaflet map with the GeoJSON object rendered on it, or None."
obj = resp.json()
if obj.get('type', None) != 'FeatureCollection':
return None
bbox = geojson_bbox(obj)
mins, maxs = bbox
center = list(reversed(bbox_center(*bbox)))
z = zoom_for_bbox(*(mins + maxs))
m = ipyleaflet.Map(center=center, zoom=z + 1)
m.add_layer(layer=ipyleaflet.GeoJSON(data=obj))
self.data = m
return m
def map_point(self):
gjson = ipyleaflet.GeoJSON(
data=Plot_interface.navigate.fc_df['geometry'][
Plot_interface.current_id],
name="Sample point")
Plot_interface.m.center = gjson.data['coordinates'][::-1]
Plot_interface.m.zoom = 12
Plot_interface.m.add_layer(gjson)
kmlstr = ee.FeatureCollection(
ee.Geometry.Point(Plot_interface.navigate.fc_df['geometry'][
Plot_interface.current_id]['coordinates'])).getDownloadURL(
"kml")
Plot_interface.kml_link.value = "<a '_blank' rel='noopener noreferrer' href={}>KML Link</a>".format(
kmlstr)
def enable_ts_collection(b):
if b.new:
# TODO: Create geoJSON and test with that class?
if isinstance(measures.click_geojson, dict):
measures.box_geojson = ipyleaflet.GeoJSON(data=measures.click_trainbox.getInfo(),
style={'color': 'black'},
name='TS train box')
measures.m.add_layer(measures.box_geojson)
measures.reset_everything()
else:
measures.click_train.set_trait('value', False)
else:
if isinstance(measures.click_geojson, dict):
# TODO: zoom to the clicked point
measures.m.remove_layer(measures.box_geojson)
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
def add_geojson(self, in_geojson, style=None, layer_name="Untitled"):
"""adds a Geojson to the map
Args:
in_geojson (str): The file path of the input Geojson
style (dict, optional): The style of the Geojson layer. Defaults to None.
layer_name (str, optional): The layer name for the Geojson layer. Defaults to "Untitled".
Raises:
FileNotFoundError: If the provided file path does not exsit.
TypeError: If the input Geojson is not a str or dict.
"""
import json
if layer_name == "Untitled":
layer_name = "Untitled " + random_string()
if isinstance(in_geojson, str):
if not os.path.exists(in_geojson):
raise FileNotFoundError(
"The provided GeoJSON file could not be found.")
with open(in_geojson) as f:
data = json.load(f)
elif isinstance(in_geojson, dict):
data = in_geojson
else:
raise TypeError("The input geojson must be a type of str or dict.")
if style is None:
style = {
"stroke": True,
"color": "#000000",
"weight": 2,
"opacity": 1,
"fill": True,
"fillColor": "#0000ff",
"fillOpacity": 0.4,
}
geo_json = ipyleaflet.GeoJSON(data=data,
style=style,
layer_name=layer_name)
self.add_layer(geo_json)
def render(self):
# On change AROME
geo_file,legend_file = self.get_step(variable= self.variable)
geojson_layer = ipyl.GeoJSON(data=geo_file,hover_style={"opacity":1},name="AROME")
if hasattr(self,"geojson_layer"):
if self.geojson_layer in self.m.layers:
self.m.substitute_layer(self.geojson_layer,geojson_layer)
else:
self.m.add_layer(geojson_layer)
else:
self.m.add_layer(geojson_layer)
self.geojson_layer = geojson_layer
self.geojson_layer.on_hover(self.update_html)
legend_file.seek(0)
self.legend.value =legend_file.read()
self.update_HSS_area()
self.update_homo_area()
def __init__(self, geo_json, column_names, **kwargs):
# self._control = None
super(VizMapGeoJSONLeaflet, self).__init__(**kwargs)
self.map = ipyleaflet.Map(center=[40.72866940630964, -73.80228996276857], zoom=10)
self.control = VizMapGeoJSONLeaflet.Control(self, column_names)
self.regions_layer = ipyleaflet.LayerGroup()
# self.index_mapping = {}
self.output = widgets.Output()
for i, feature in enumerate(geo_json["features"]):
if feature["geometry"]["type"] == "Polygon":
feature["geometry"]["type"] = "MultiPolygon"
feature["geometry"]["coordinates"] = [feature["geometry"]["coordinates"]]
polygon = ipyleaflet.GeoJSON(data=feature, hover_style={'fillColor': 'red', 'fillOpacity': 0.6})
self.regions_layer.add_layer(polygon)
# self.index_mapping[feature['properties'][index_key]] = i
@self.output.capture()
# @vaex.jupyter.debounced(DEBOUNCE_SLICE)
def on_hover(index=i, **properties):
# index_value = properties[index_key]
# index = self.index_mapping[index_value]
self.state.x_slice = index#event['data']['index']
self.reset_slice()
# self.set_transparancy(self.state.x_slice)
#print(viz_state.grid.sum())
polygon.on_hover(on_hover)
# @self.output.capture()
# def on_click(index=i, **properties):
# if self.state.x_slice :
# self.state.x_slice = None
# else:
# self.state.x_slice = None
# self.reset_slice()
# # self.set_transparancy(self.state.x_slice)
# #print(viz_state.grid.sum())
# polygon.on_click(on_click)
self.map.add_layer(self.regions_layer)
# self.state.observe(self.update_bars, ['grid', 'grid_sliced'])
# self.observe(self.update_bars, ['normalize'])
# self.regions_layer.on_hover(on_hover)
# self.reset_opacities()
# self.create_viz()
self.widget = widgets.HBox([self.control, widgets.VBox([self.map, self.output])])
def addGeoJson(geometry, name):
# Check if layer exists
if name in self.EELayers.keys():
print("Layer with name {} exists already, please choose" +
"another name".format(name))
return
params = get_geojson_tile(geometry, inspect)
layer = ipyleaflet.GeoJSON(data=params['geojson'],
name=name,
popup=HTML(params['pop']))
self.add_layer(layer)
self.EELayers[name] = {
'type': 'Geometry',
'object': geometry,
'visParams': None,
'layer': layer
}
return layer
def widget_search_button_handler(change):
"""The widget_search_button_handler function updates the map when the
Update Search button is selected"""
from erddap_app.layout import (
e,
map,
server,
widget_dsnames,
widget_search_max_time,
widget_search_min_time,
widget_std_names,
)
min_time = pendulum.parse(widget_search_min_time.value)
max_time = pendulum.parse(widget_search_max_time.value)
standard_name = widget_std_names.value
features, datasets = stdname2geojson(
e,
standard_name,
server.get("cdm_data_type"),
min_time,
max_time,
server.get("skip_datasets"),
)
feature_layer = ipyl.GeoJSON(data=features)
constraints = {"time>=": min_time, "time<=": max_time}
# feature_layer.on_click(map_click_handler)
map.layers = [map.layers[0], feature_layer]
dataset_id = datasets[0]
widget_dsnames.options = datasets
widget_dsnames.value = dataset_id
update_timeseries_plot(
e,
dataset=dataset_id,
standard_name=standard_name,
constraints=constraints,
)
def add_map_point(data, zoom, m, kml, name):
# Make geojson from data
gjson = ipyleaflet.GeoJSON(data=data, name=name)
# Center map
m.center = gjson.data['coordinates'][::-1]
# Set map zoom
m.zoom = zoom
# Add geojson to map
m.add_layer(gjson)
# Make KML via earth engine functionality
geo_point = ee.Geometry.Point(gjson.data['coordinates'][::-1]) # This may not work
geo_fc = ee.FeatureCollection(geo_point)
kmlstr = geo_fc.getDownloadURL("kml")
# Update KML widget
kml.value = "<a '_blank' rel='noopener noreferrer' href={}>KML Link</a>".format(kmlstr)
return
def plot_datasets(server, e):
"""This defines the initial ipyleaflet map"""
map = ipyl.Map(
center=server.get("center"),
zoom=server.get("zoom"),
layout=dict(width="750px", height="350px"),
)
features, datasets = stdname2geojson(
e,
server.get("standard_name"),
server.get("cdm_data_type"),
server.get("min_time"),
server.get("max_time"),
server.get("skip_datasets"),
)
feature_layer = ipyl.GeoJSON(data=features)
# feature_layer.on_click(map_click_handler(e=e))
map.layers = [map.layers[0], feature_layer]
return map, feature_layer, datasets
parse_dates=True,
skiprows=[1])
return df, var
# This defines the initial `ipyleaflet` map
# In[31]:
map = ipyl.Map(center=center,
zoom=zoom,
layout=dict(width='750px', height='350px'))
features, datasets = stdname2geojson(e, standard_name, cdm_data_type,
search_min_time, search_max_time)
dataset_id = datasets[0]
feature_layer = ipyl.GeoJSON(data=features)
feature_layer.on_click(map_click_handler)
map.layers = [map.layers[0], feature_layer]
# In[32]:
widget_dsnames = ipyw.Dropdown(options=datasets, value=dataset_id)
# This defines the intitial `bqplot` time series plot
# In[33]:
dt_x = bq.DateScale()
sc_y = bq.LinearScale()
constraints = {'time>=': search_min_time, 'time<=': search_max_time}
