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}