def polygon_map(area, source): from ipyleaflet import Map, DrawControl center, zoom = centroid(area, source) m = Map(center=center, zoom=zoom) draw_control = DrawControl() draw_control.polygon = { "shapeOptions": { "fillColor": "#6be5c3", "color": "#6be5c3", "fillOpacity": 1.0 }, "drawError": { "color": "#dd253b", "message": "Oups!" }, "allowIntersection": False } polygon_map.feature_collection = { 'type': 'FeatureCollection', 'features': [] } def handle_draw(self, action, geo_json): """Do something with the GeoJSON when it's drawn on the map""" polygon_map.feature_collection['features'].append(geo_json) draw_control.on_draw(handle_draw) m.add_control(draw_control) return m
def run(): global m,center # center = list(reversed(poly.centroid().coordinates().getInfo())) center = [51.0,6.4] osm = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik) ews = basemap_to_tiles(basemaps.Esri.WorldStreetMap) ewi = basemap_to_tiles(basemaps.Esri.WorldImagery) dc = DrawControl(polyline={},circlemarker={}) dc.rectangle = {"shapeOptions": {"fillColor": "#0000ff","color": "#0000ff","fillOpacity": 0.05}} dc.polygon = {"shapeOptions": {"fillColor": "#0000ff","color": "#0000ff","fillOpacity": 0.05}} dc.on_draw(handle_draw) lc = LayersControl(position='topright') fs = FullScreenControl(position='topleft') mc = MeasureControl(position='topright',primary_length_unit = 'kilometers') m = Map(center=center, zoom=11, layout={'height':'500px'},layers=(ewi,ews,osm),controls=(mc,dc,lc,fs)) # m = Map(center=center, zoom=11, layout={'height':'500px'},controls=(lc,dc,fs,mc,sm_control)) with w_out: w_out.clear_output() print('Algorithm output') display(m) return box
def __init__(self, bbox, zoom=8, resolution=10): center = (bbox.min_y + bbox.max_y) / 2, (bbox.min_x + bbox.max_x) / 2 self.map = Map(center=center, zoom=zoom, scroll_wheel_zoom=True) self.resolution = resolution control = DrawControl() control.rectangle = { "shapeOptions": { "fillColor": "#fabd14", "color": "#fa6814", "fillOpacity": 0.2 } } #Disable the rest of draw options control.polyline = {} control.circle = {} control.circlemarker = {} control.polygon = {} control.edit = False control.remove = False control.on_draw(self._handle_draw) self.map.add_control(control) self.bbox = None self.size = None self.rectangle = None self.add_rectangle(bbox.min_x, bbox.min_y, bbox.max_x, bbox.max_y)
class Grass2Leaflet(object): def __init__(self, grassimg): self.grassimg = grassimg self.draw_control = None self.zoom = 15 self.center = self.centermap() self.m = Map(default_tiles=TileLayer(opacity=1.0), center=self.center, zoom=self.zoom) def centermap(self): centerlat = [] centerlon = [] for i in self.grassimg: centerlat.append(self.grassimg[i]['C'][0]) centerlon.append(self.grassimg[i]['C'][1]) center = (sum(centerlat) / float(len(centerlat)), sum(centerlon) / float(len(centerlon))) return center def imgoverlays(self): self.leafletimg = OrderedDict() for i in self.grassimg: layer = ImageOverlay(url=self.grassimg[i]['raster'], bounds=(self.grassimg[i]['LL'], self.grassimg[i]['UR'])) self.leafletimg[i] = layer def render(self, draw_control=None): self.imgoverlays() self.dc = None options = ['None'] self.m.add_layer(self.leafletimg[list(self.grassimg.keys())[-1]]) if len(self.grassimg) >= 2: self.maplist = widgets.Dropdown( options=options + list(self.grassimg.keys()), value=list(self.grassimg.keys())[-1], description='Select Layer:', ) self.maplist.observe(self.on_value_change, names='value') display(self.maplist) if draw_control: self.dc = DrawControl() self.dc.on_draw(handle_draw) self.m.add_control(self.dc) display(self.m) return {'map': self.m, 'drawer': self.dc} def on_value_change(self, layername): self.m.clear_layers() self.m.add_layer(TileLayer(opacity=1.0)) if self.maplist.value != 'None': self.m.add_layer(self.leafletimg[layername['new']]) def main(self): self.imgoverlays() self.render()
def __create_draw_control(self): dc = DrawControl(rectangle={'shapeOptions': {'color': '#0000FF'}}, circle={}, circlemarker={}, polyline={}, marker={}, polygon={}) dc.edit = False dc.remove = False # handle drawing and deletion of annotations and corresponding classes def handle_draw(target, action, geo_json): # print(target) # print(action) # print(geo_json) if action == 'created' and geo_json['geometry']['type'] == 'Polygon': coordinates = geo_json['geometry']['coordinates'][0] #print(coordinates) #print(self.__map) #print(coordinates) hs = [c[1] for c in coordinates] ws = [c[0] for c in coordinates] min_h, max_h = min(hs), max(hs) min_w, max_w = min(ws), max(ws) # coordinates only inside image hh, ww, offset_h, offset_w = self.__img_coords[2:] max_h = max(0, min(hh + offset_h, max_h)) max_w = max(0, min(ww + offset_w, max_w)) min_h = max(offset_h, min(hh + offset_h, min_h)) min_w = max(offset_w, min(ww + offset_w, min_w)) # remove draw dc.clear() if max_h - min_h < 1 or max_w - min_w < 1: print(labels_str.warn_skip_wrong ) return # print(min_h, max_h, min_w, max_w) # create rectangle layer and remove drawn geojson rectangle = self.__create_rectangle(((min_h, min_w), (max_h, max_w))) self.__current_image_annotations.append(rectangle) self.__current_class_for_ann.append(None) self.__map.add_layer(rectangle) # automatically select last annotation self.__selected_ann = len(self.__current_image_annotations)-1 self.__reset_colors_bboxes() self.__selected_class = None self.__reset_classes_btns() self.__delete_button.disabled = False # print('Adding ann at index:',len(self.current_image_annotations)-1, # ' with class', self.current_class_for_ann[-1]) dc.on_draw(handle_draw) self.__map.add_control(dc)
def __init__(self, center, zoom): self.map = Map(center=center, zoom=zoom, scroll_wheel_zoom=True, interpolation='nearest') self.bbox = [] self.point_coords = [] self.figure = None self.figure_widget = None feature_collection = {'type': 'FeatureCollection', 'features': []} draw = DrawControl( circlemarker={}, polyline={}, polygon={}, marker={"shapeOptions": { "original": {}, "editing": {}, }}, rectangle={"shapeOptions": { "original": {}, "editing": {}, }}) self.map.add_control(draw) def handle_draw(target, action, geo_json): feature_collection['features'] = [] feature_collection['features'].append(geo_json) if feature_collection['features'][0]['geometry'][ 'type'] == 'Point': self.point_coords = feature_collection['features'][0][ 'geometry']['coordinates'] else: coords = feature_collection['features'][0]['geometry'][ 'coordinates'][0] polygon = shapely.geometry.Polygon(coords) self.bbox = polygon.bounds layers_control = LayersControl(position='topright') self.map.add_control(layers_control) self.map.add_control(FullScreenControl()) self.map.add_layer(basemap_to_tiles(basemaps.Esri.WorldImagery)) draw.on_draw(handle_draw)
class App(): """ """ settings = {"enabled_grid": "B"} def __init__(self, session=None): self.session = session self.use_grid = self.settings["enabled_grid"] # generate map grid polygon layers self.grid_layers = LayerGroup() self.grid_dict = {} for feat in above_grid["features"]: level = feat["properties"]["grid_level"] if level == self.use_grid: Cell_object = Cell(feat) #Cell_object.layer.on_click() grid_id = Cell_object.id self.grid_dict[grid_id] = Cell_object self.grid_layers.add_layer(self.grid_dict[grid_id].layer) # make an attribute that will hold selected layer self.selected_layer = LayerGroup() self.map = Map(layers=( esri, self.grid_layers, self.selected_layer, ), center=(65, -100), zoom=3, width="auto", height="auto", scroll_wheel_zoom=True) # map draw controls self.draw_control = DrawControl() self.draw_control.polyline = {} self.draw_control.circle = {} self.draw_control.circlemarker = {} self.draw_control.remove = False self.draw_control.edit = False self.draw_control.polygon = {**draw_style} self.draw_control.rectangle = {**draw_style} self.draw_control.on_draw(self.update_selected_cells) self.map.add_control(self.draw_control) # output display self.output = Output(layout=Layout(width="auto", height="auto")) # make the widget layout self.ui = VBox( [ #header, #HBox([instruct, geojson_text]), self.map, self.output ], layout=Layout(width="auto")) # display ui display(self.ui) def update_selected_cells(self, *args, **kwargs): """ """ # clear all draw and selection layers self.draw_control.clear() # -------------------------------------------------------------------- # update active cells and make a big merged polgyon for selection # make shapely geom from geojson drawn_json = kwargs["geo_json"] shapely_geom = shape(drawn_json["geometry"]) cells = self.grid_dict # iterate over cells and collect intersecting cells on = [] for id, cell in cells.items(): if shapely_geom.intersects(cell.shape): on.append(cell.shape) # this is blatant abuse of try/except; fix it try: # get the union of all of the cells that are toggled on union = cascaded_union(on) centroid = union.centroid # make layer that represents selected cells and add to selected_layer self.selected_layer.clear_layers() x, y = union.exterior.coords.xy self.selected_layer.add_layer(Polygon(locations=list(zip(y, x)))) self.map.center = (centroid.y, centroid.x) # -------------------------------------------------------------- # find all CMR collections that intersect with merged cells geom selected = [] for index, collection in above_results_df.iterrows(): box = collection.boxes shapely_box = CMR_box_to_Shapely_box(box[0]) # intersect: use shapely_geom if strictly using drawn poly intersect_bool = shapely_box.intersects(union) if intersect_bool: selected.append(index) self.coll = above_results_df.iloc[selected] self.tab = qgrid.show_grid( self.coll[["dataset_id", "time_start", "time_end", "boxes"]], grid_options={ 'forceFitColumns': False, 'minColumnWidth': "0", 'maxColumnWidth': "400" }, show_toolbar=False) self.output.clear_output() with self.output: display(self.tab) #display(self.coll[[ # "dataset_id", "time_start", "time_end", "boxes"]]) except: pass
def sel_params_form(processing_parameters: ProcessingParameters, identifier='identifier', name='name', mock=False): debug_view = get_debug_view() fetch_inputs_func = fetch_inputs if mock: @debug_view.capture(clear_output=True) def fetch_inputs_mock(input_request: InputRequest, message_func) -> ProcessingRequest: debug_view.value = '' time.sleep(2) input_identifiers = { input_type: [f'iid-{i}' for i in range(10)] for input_type in input_request.input_types } processing_request_data = input_request.as_dict() processing_request_data.update( dict(inputIdentifiers=input_identifiers)) return ProcessingRequest(processing_request_data) fetch_inputs_func = fetch_inputs_mock form_item_layout = widgets.Layout( display='flex', flex_flow='row', justify_content='space-between', ) var_checks_layout = widgets.Layout( display='flex', flex_flow='row', justify_content='center', ) variable_names = [] for variable_id in processing_parameters.variables.ids: variable_names.append( processing_parameters.variables.get(variable_id).name) forward_model_names = [] for model_id in processing_parameters.forward_models.ids: forward_model_names.append( processing_parameters.forward_models.get(model_id).name) variable_boxes_dict = _get_checkboxes_dict( processing_parameters.variables.ids, variable_names) forward_model_boxes_dict = _get_checkboxes_dict( processing_parameters.forward_models.ids, forward_model_names) request_validation = widgets.HTML( value=html_element('h3', att=dict(style='color:red'), value='No variable or forward model selected')) non_disabled_forward_models = [] available_forward_models_per_type = {} forward_models_per_variable = {} forward_model_select_buttons = {} for fm_id in processing_parameters.forward_models.ids: non_disabled_forward_models.append(fm_id) fm = processing_parameters.forward_models.get(fm_id) if not fm.input_type in available_forward_models_per_type: available_forward_models_per_type[fm.input_type] = [] available_forward_models_per_type[fm.input_type].append(fm_id) for variable in fm.variables: if not variable in forward_models_per_variable: forward_models_per_variable[variable] = [] forward_models_per_variable[variable].append(fm_id) selected_forward_models = [] selected_variables = [] selected_forward_model_per_type = {} for it in processing_parameters.input_types.ids: selected_forward_model_per_type[it] = None def _fm_variables(fm_id: str): return processing_parameters.forward_models.get(fm_id).variables def _fm_input_type(fm_id: str): return processing_parameters.forward_models.get(fm_id).input_type def _recommend(id: str): if id in processing_parameters.variables.ids: _recommend_box(variable_boxes_dict[id]) elif id in processing_parameters.forward_models.ids: if id not in non_disabled_forward_models: non_disabled_forward_models.append(id) _recommend_box(forward_model_boxes_dict[id]) def _recommend_box(box: LabeledCheckbox): box.enabled = True box.color = "green" box.font_weight = "bold" def _disable(id: str): if id in processing_parameters.variables.ids: _disable_box(variable_boxes_dict[id]) elif id in processing_parameters.forward_models.ids: if id in non_disabled_forward_models: non_disabled_forward_models.remove(id) _disable_box(forward_model_boxes_dict[id]) def _disable_box(box: LabeledCheckbox): box.enabled = False box.font_weight = "normal" def _display_normally(id: str): if id in processing_parameters.variables.ids: _display_normally_box(variable_boxes_dict[id]) elif id in processing_parameters.forward_models.ids: if id not in non_disabled_forward_models: non_disabled_forward_models.append(id) _display_normally_box(forward_model_boxes_dict[id]) def _display_normally_box(box: LabeledCheckbox): box.enabled = True box.color = "black" box.font_weight = "bold" def _request_status() -> str: if len(selected_variables) == 0 and len(selected_forward_models) == 0: return 'No variable or forward model selected' elif len(selected_variables) == 0: return 'No variable selected' elif len(selected_forward_models) == 0: return 'No forward model selected' else: for selected_variable in selected_variables: forward_model_available = False for variable_fm in forward_models_per_variable[ selected_variable]: if variable_fm in selected_forward_models: forward_model_available = True break if not forward_model_available: return f"Variable '{selected_variable}' cannot be derived with any of the selected forward models." for selected_forward_model in selected_forward_models: at_least_one_variable_selected = False for variable in processing_parameters.forward_models.get( selected_forward_model).variables: if variable in selected_variables: at_least_one_variable_selected = True break if not at_least_one_variable_selected: return f"Selection is valid, " \ f"but no variable is selected for forward model '{selected_forward_model}'." return 'Selection is valid' def _validate_selection(): color = 'red' request_status = _request_status() if request_status.startswith('Selection is valid'): if request_status == 'Selection is valid': color = 'green' else: color = 'orange' request_status = _format_request_status(request_status) request_validation.value = html_element( 'h3', att=dict(style=f'color:{color}'), value=request_status) def _format_request_status(request_status: str) -> str: if not request_status.startswith('Selection is valid'): return request_status forward_model_lines = [] for forward_model_id in selected_forward_models: fm_selected_variables = [] fm_variables = processing_parameters.forward_models.get( forward_model_id).variables for fm_variable in fm_variables: if fm_variable in selected_variables: fm_selected_variables.append(f"'{fm_variable}'") if len(fm_selected_variables) > 0: fm_selected_variables = ', '.join(fm_selected_variables) forward_model_lines.append( f"With model '{forward_model_id}': Compute {fm_selected_variables}" ) else: forward_model_lines.append( f"Model '{forward_model_id}' " f"is selected, but does not compute any variables") forward_model_lines = '<br>'.join(forward_model_lines) message = f"{request_status}:<br>{forward_model_lines}" return message def _handle_variable_selection(change: dict): if change['name'] is not '_property_lock': return variable_id = change['owner'].label_text if change['new']['selected']: selected_variables.append(variable_id) else: selected_variables.remove(variable_id) _update_forward_models_after_variable_change(variable_id, True) _validate_selection() def _update_forward_models_after_variable_change( variable_id: str, examine_secondary_models: bool = False): already_examined_types = [] for potential_forward_model in forward_models_per_variable[ variable_id]: fm_type = _fm_input_type(potential_forward_model) if (selected_forward_model_per_type[fm_type] ) is not None or fm_type in already_examined_types: continue _validate_forward_models_of_type(fm_type) _validate_variables_of_forward_models_of_type(fm_type) if examine_secondary_models: _validate_forward_models_of_variables_of_forward_models_of_type( fm_type) already_examined_types.append(fm_type) def _validate_forward_models_of_type(fm_type: str): for fm_of_same_type in available_forward_models_per_type[fm_type]: if selected_forward_model_per_type[fm_type] == fm_of_same_type: _recommend(fm_of_same_type) continue if selected_forward_model_per_type[fm_type] is not None: _disable(fm_of_same_type) continue fm_of_same_type_variables = _fm_variables(fm_of_same_type) at_least_one_variable_selected = False for fm_of_same_type_variable in fm_of_same_type_variables: if fm_of_same_type_variable in selected_variables: afms_for_st_variable = _available_forward_models_for_variable( fm_of_same_type_variable) if len(afms_for_st_variable) == 1 and _fm_input_type( afms_for_st_variable[0]) == fm_type: _recommend(fm_of_same_type) for other_fm_of_same_type in available_forward_models_per_type[ fm_type]: if other_fm_of_same_type != fm_of_same_type: _disable(other_fm_of_same_type) return at_least_one_variable_selected = True if at_least_one_variable_selected: _recommend(fm_of_same_type) else: _display_normally(fm_of_same_type) def _validate_variables_of_forward_models_of_type(fm_type: str): for fm_of_same_type in available_forward_models_per_type[fm_type]: fm_of_same_type_variables = _fm_variables(fm_of_same_type) for fm_of_same_type_variable in fm_of_same_type_variables: _validate_variable(fm_of_same_type_variable) def _validate_forward_models_of_variables_of_forward_models_of_type( fm_type: str): for fm_of_same_type in available_forward_models_per_type[fm_type]: fm_of_same_type_variables = _fm_variables(fm_of_same_type) for fm_of_same_type_variable in fm_of_same_type_variables: afms_for_same_type_variable = _available_forward_models_for_variable( fm_of_same_type_variable) if _fm_input_type(afms_for_same_type_variable[0]) != fm_type: _validate_forward_models_of_type( _fm_input_type(afms_for_same_type_variable[0])) _validate_variables_of_forward_models_of_type( _fm_input_type(afms_for_same_type_variable[0])) def _available_forward_models_for_variable(variable_id: str) -> List[str]: available_forward_models_for_variable = [] for model_id in forward_models_per_variable[variable_id]: if model_id in non_disabled_forward_models: available_forward_models_for_variable.append(model_id) return available_forward_models_for_variable def _validate_variable(variable: str): if variable in selected_variables: _recommend(variable) return available_forward_models_for_variable = _available_forward_models_for_variable( variable) if len(available_forward_models_for_variable) == 0: _disable(variable) return for available_forward_model_for_variable in available_forward_models_for_variable: if available_forward_model_for_variable in selected_forward_models: _recommend(variable) return _display_normally(variable) @debug_view.capture(clear_output=True) def _handle_forward_model_selection(change: dict): if change['name'] is not '_property_lock': return if 'selected' not in change['new']: return selected_fm_id = change['owner'].label_text selected_fm_it = _fm_input_type(selected_fm_id) if change['new']['selected']: selected_forward_models.append(selected_fm_id) selected_forward_model_per_type[selected_fm_it] = selected_fm_id forward_model_select_buttons[selected_fm_id].disabled = False else: selected_forward_models.remove(selected_fm_id) selected_forward_model_per_type[selected_fm_it] = None forward_model_select_buttons[selected_fm_id].disabled = True _validate_forward_models_of_type(selected_fm_it) _validate_variables_of_forward_models_of_type(selected_fm_it) _validate_selection() _update_preprocessing_states() _setup_user_priors() def _clear_variable_selection(b): for variable_id in variable_boxes_dict: if variable_id in selected_variables: selected_variables.remove(variable_id) variable_boxes_dict[variable_id].selected = False _validate_variable(variable_id) _update_forward_models_after_variable_change(variable_id) _validate_selection() def _clear_forward_model_selection(b): affected_input_types = [] for forward_model_id in forward_model_boxes_dict: if forward_model_id in selected_forward_models: selected_forward_models.remove(forward_model_id) forward_model_type = _fm_input_type(forward_model_id) selected_forward_model_per_type[forward_model_type] = None if forward_model_type not in affected_input_types: affected_input_types.append(forward_model_type) forward_model_boxes_dict[forward_model_id].selected = False for input_type in affected_input_types: _validate_forward_models_of_type(input_type) _validate_variables_of_forward_models_of_type(input_type) _update_preprocessing_states() _validate_selection() _setup_user_priors() def _select_all_variables_for_forward_model(forward_model_id: str): fm_variables = _fm_variables(forward_model_id) for variable_id in fm_variables: if variable_id not in selected_variables: selected_variables.append(variable_id) variable_boxes_dict[variable_id].selected = True _update_forward_models_after_variable_change(variable_id) _validate_selection() # noinspection PyTypeChecker variables_box = _wrap_variable_checkboxes_in_widget( variable_boxes_dict.values(), 4, _handle_variable_selection) clear_variable_selection_button = widgets.Button( description="Clear Variable Selection", layout=widgets.Layout(left='60%', width='35%')) clear_variable_selection_button.on_click(_clear_variable_selection) forward_model_variables = {} for fm_id in processing_parameters.forward_models.ids: forward_model_variables[ fm_id] = processing_parameters.forward_models.get(fm_id).variables forward_model_select_buttons[fm_id] = _get_select_button( _select_all_variables_for_forward_model, fm_id) # noinspection PyTypeChecker forward_models_box = _wrap_forward_model_checkboxes_in_widget( forward_model_boxes_dict.values(), forward_model_select_buttons, _handle_forward_model_selection, forward_model_variables) clear_model_selection_button = widgets.Button( description="Clear Forward Model Selection", layout=widgets.Layout(left='60%', width='35%')) clear_model_selection_button.on_click(_clear_forward_model_selection) user_priors_box = widgets.Box(children=[], layout=widgets.Layout(overflow='hidden', display='flex')) user_priors_component = widgets.VBox(children=[ widgets.HTML( value=html_element('h2', value='User Priors')), user_priors_box ]) user_priors_dict = {} def _handle_user_prior_change(user_prior_dict): for user_prior in user_prior_dict: user_priors_dict[user_prior] = user_prior_dict[user_prior] @debug_view.capture(clear_output=True) def _setup_user_priors(): possible_user_priors = [] s2_output_variables = [] if selected_forward_model_per_type['Sentinel-2'] is not None: selected_forward_model = \ processing_parameters.forward_models.get(selected_forward_model_per_type['Sentinel-2']) for prior in selected_forward_model.requiredPriors: if prior not in possible_user_priors: possible_user_priors.append(prior) s2_output_variables = selected_forward_model.variables if selected_forward_model_per_type['Sentinel-1'] is not None: selected_forward_model = \ processing_parameters.forward_models.get(selected_forward_model_per_type['Sentinel-1']) for prior in selected_forward_model.requiredPriors: if prior not in possible_user_priors and prior not in s2_output_variables: possible_user_priors.append(prior) user_prior_components = [] for possible_user_prior_id in possible_user_priors: prior = processing_parameters.variables.get(possible_user_prior_id) if not prior.may_be_user_prior: continue mu = None unc = None if possible_user_prior_id in user_priors_dict: if 'mu' in user_priors_dict[possible_user_prior_id]: mu = user_priors_dict[possible_user_prior_id]['mu'] if 'unc' in user_priors_dict[possible_user_prior_id]: unc = user_priors_dict[possible_user_prior_id]['unc'] user_prior_components.append( user_prior_component(prior.id, prior.unit, _handle_user_prior_change, mu, unc)) user_priors_box.children = [ _wrap_user_priors_in_widget(user_prior_components) ] @debug_view.capture(clear_output=True) def _must_preprocess(it: str) -> bool: must_preprocess = it in selected_forward_model_per_type and selected_forward_model_per_type[ it] is not None if not must_preprocess: for post_processor_name in post_processor_checkbox_dict: if post_processor_checkbox_dict[post_processor_name].selected: post_processor = processing_parameters.post_processors.get( post_processor_name) if it in post_processor.input_types: must_preprocess = True break return must_preprocess def _update_preprocessing_states(): preprocess_s1_temporal_filter.disabled = not _must_preprocess( 'Sentinel-1') preprocess_s2_only_roi_checkbox.enabled = _must_preprocess( 'Sentinel-2') preprocess_s1_temporal_filter = widgets.BoundedIntText(value=5, min=2, max=15, step=1, disabled=True) preprocess_s2_only_roi_checkbox = LabeledCheckbox( selected=False, label_text='Only preprocess Region of Interest', tooltip='Only preprocess Region of Interest', enabled=False, layout=widgets.Layout(display='flex', width='30%')) global _NUM_REQUESTS _NUM_REQUESTS += 1 request_name = widgets.Text(name) python_var_name = widgets.Text(identifier) start_date = widgets.DatePicker( value=datetime.datetime(year=2018, month=5, day=10)) end_date = widgets.DatePicker( value=datetime.datetime(year=2018, month=5, day=15)) time_steps = Spinner(value=5, min=1) time_steps_unit = widgets.Dropdown(options=['days', 'weeks'], value='days', disabled=False) map_background_layer = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik) geometry_layer = GeoJSON() leaflet_map = Map(layers=(map_background_layer, geometry_layer), center=[52., 10.], zoom=4) draw_control = DrawControl() draw_control.polyline = {} draw_control.polygon = {} draw_control.circlemarker = {} draw_control.rectangle = {'shapeOptions': {}} draw_control.edit = False draw_control.remove = False @debug_view.capture(clear_output=True) def _handle_draw(self, action, geo_json): self.clear() leaflet_map.remove_layer(leaflet_map.layers[1]) geometry_layer = GeoJSON(data=geo_json['geometry']) leaflet_map.add_layer(geometry_layer) roi_shape = shape(leaflet_map.layers[1].data) roi_area.value = roi_shape.wkt roi_validation.value = html_element( 'h3', att=dict(style=f'color:green'), value='Region of Interest defined.') draw_control.on_draw(_handle_draw) leaflet_map.add_control(draw_control) roi_area = widgets.Textarea( layout=widgets.Layout(flex='1 10 90%', align_items='stretch')) roi_map_button = widgets.Button(description="Map region", layout=widgets.Layout(flex='0 1 10%')) def _update_roi_status_for_error(message: str): roi_data = leaflet_map.layers[1].data if not roi_data: roi_validation.value = html_element('h3', att=dict(style=f'color:red'), value=message) return roi_validation.value = html_element( 'h3', att=dict(style=f'color:orange'), value=f'{message} Keep previously defined Region of Interest.') selected_indicators = [] indicator_check_boxes = [] for indicator_id in processing_parameters.indicators.ids: indicator = processing_parameters.indicators.get(indicator_id) indicator_check_box = LabeledCheckbox(selected=False, label_text=indicator_id, tooltip=indicator.description, enabled=True) indicator_check_boxes.append(indicator_check_box) @debug_view.capture(clear_output=True) def _handle_indicator_selection(change: dict): if change['name'] is not '_property_lock' or not 'selected' in change[ 'new']: return indicator_id = change['owner'].label_text if change['new']['selected']: selected_indicators.append(indicator_id) else: selected_indicators.remove(indicator_id) for inner_post_processor_name in post_processor_checkbox_dict: inner_post_processor = processing_parameters.post_processors.get( inner_post_processor_name) post_processor_selected = False for post_processor_indicator in inner_post_processor.indicators: if post_processor_indicator in selected_indicators: post_processor_selected = True break if post_processor_checkbox_dict[ inner_post_processor_name].selected != post_processor_selected: post_processor_checkbox_dict[ inner_post_processor_name].selected = post_processor_selected _update_preprocessing_states() indicators_box = _wrap_variable_checkboxes_in_widget( indicator_check_boxes, 3, _handle_indicator_selection) post_processor_checkbox_dict = {} post_processor_checkboxes = [] for post_processor_name in processing_parameters.post_processors.names: post_processor = processing_parameters.post_processors.get( post_processor_name) post_processor_checkbox = LabeledCheckbox( selected=False, label_text=post_processor_name, tooltip=post_processor.description, enabled=False) post_processor_checkboxes.append(post_processor_checkbox) post_processor_checkbox_dict[ post_processor_name] = post_processor_checkbox post_processors_box = _wrap_variable_checkboxes_in_widget( post_processor_checkboxes, 2, None) @debug_view.capture(clear_output=True) def _handle_roi_map_button_clicked(*args, **kwargs): try: geom = loads(roi_area.value) if type(geom) is not Polygon: _update_roi_status_for_error( 'User-provided Region of Interest is not of type Polygon.') return geojson_feature = geojson.Feature(geometry=geom, properties={}) draw_control.clear() leaflet_map.remove_layer(leaflet_map.layers[1]) geometry_layer = GeoJSON(data=geojson_feature['geometry']) leaflet_map.add_layer(geometry_layer) center_lon, center_lat = geom.centroid.coords.xy leaflet_map.center = [center_lat[0], center_lon[0]] @debug_view.capture(clear_output=False) def _adjust_zoom_level(event): if event['name'] == 'bounds' and leaflet_map.zoom < 18: southwest, northeast = leaflet_map.bounds map_bounds = Polygon([(southwest[1], southwest[0]), (southwest[1], northeast[0]), (northeast[1], northeast[0]), (northeast[1], southwest[0]), (southwest[1], southwest[0])]) if map_bounds.covers(geom): leaflet_map.zoom = leaflet_map.zoom + 1 elif leaflet_map.zoom > 1: leaflet_map.zoom = leaflet_map.zoom - 1 leaflet_map.unobserve(_adjust_zoom_level) leaflet_map.zoom = 1 leaflet_map.observe(_adjust_zoom_level) if geom.is_valid: roi_validation.value = html_element( 'h3', att=dict(style=f'color:green'), value='Region of Interest defined.') else: roi_validation.value = html_element( 'h3', att=dict(style=f'color:orange'), value='User-provided Region of Interest is invalid.') except WKTReadingError: _update_roi_status_for_error( 'User-provided Region of Interest cannot be read.') roi_map_button.on_click(_handle_roi_map_button_clicked) spatial_resolution = Spinner(value=100, min=1, step=1) roi_validation = widgets.HTML( value=html_element('h3', att=dict(style='color:red'), value='No region of interest defined')) info = InfoComponent() def new_input_request(): request_status = _request_status() if request_status != 'Selection is valid': info.output_error(request_status) return input_types = [] for input_type in selected_forward_model_per_type: if selected_forward_model_per_type[input_type] is not None: input_types.append(input_type) roi_data = leaflet_map.layers[1].data if not roi_data: info.output_error('Error: No Region of Interest specified') return roi = shape(roi_data) if not roi.is_valid: info.output_error('Error: Region of Interest is invalid') return request_models = [] required_priors = [] for model_id in selected_forward_models: request_model = processing_parameters.forward_models.get(model_id) request_variables = [] for variable_id in request_model.variables: if variable_id in selected_variables: request_variables.append(variable_id) request_model_dict = dict( name=model_id, type=request_model.type, modelDataType=request_model.input_type, requiredPriors=request_model.requiredPriors, outputParameters=request_variables) for required_model_prior in request_model.requiredPriors: if not required_model_prior in required_priors: required_priors.append(required_model_prior) request_models.append(request_model_dict) user_priors_for_request_list = [] for user_prior in user_priors_dict: if user_prior in required_priors: user_priors_for_request_dict = {'name': user_prior} if 'mu' in user_priors_dict: user_priors_for_request_dict['mu'] = user_priors_dict['mu'] if 'unc' in user_priors_dict: user_priors_for_request_dict['unc'] = user_priors_dict[ 'unc'] user_priors_for_request_list.append( user_priors_for_request_dict) temporalFilter = None if not preprocess_s1_temporal_filter.disabled: temporalFilter = preprocess_s1_temporal_filter.value computeOnlyRoi = None if preprocess_s2_only_roi_checkbox.enabled: computeOnlyRoi = preprocess_s2_only_roi_checkbox.selected postProcessors = [] if len(selected_indicators) > 0: postProcessors = [] for post_processor_name in processing_parameters.post_processors.names: post_processor = processing_parameters.post_processors.get( post_processor_name) selected_pp_indicators = [] for indicator in post_processor.indicators: if indicator in selected_indicators: selected_pp_indicators.append(indicator) if len(selected_pp_indicators) > 0: post_processor_dict = dict( name=post_processor_name, type=post_processor.type, inputTypes=post_processor.input_types, indicatorNames=selected_pp_indicators, variableNames=selected_variables) postProcessors.append(post_processor_dict) return InputRequest( dict(name=request_name.value, timeRange=[ datetime.datetime.strftime(start_date.value, "%Y-%m-%d"), datetime.datetime.strftime(end_date.value, "%Y-%m-%d") ], timeStep=time_steps.value, timeStepUnit=time_steps_unit.value, roi=f"{roi.wkt}", spatialResolution=spatial_resolution.value, inputTypes=input_types, forwardModels=request_models, userPriors=user_priors_for_request_list, s1TemporalFilter=temporalFilter, s2ComputeRoi=computeOnlyRoi, postProcessors=postProcessors)) # noinspection PyUnusedLocal @debug_view.capture(clear_output=True) def handle_new_button_clicked(*args, **kwargs): req_var_name = python_var_name.value or 'req' if req_var_name and not req_var_name.isidentifier(): info.output_error( f'Error: invalid Python identifier: {req_var_name}') return inputs_request = new_input_request() if inputs_request is None: return info.output_message('Fetching results...') processing_request = fetch_inputs_func(inputs_request, info.message_func) if processing_request is None: return input_identifiers = processing_request.inputs data_rows = [] for input_type, input_ids in input_identifiers.as_dict().items(): data_rows.append([input_type, len(input_ids)]) result_html = html_table( data_rows, header_row=['Input Type', 'Number of inputs found']) # insert shall variable_id whose value is processing_request # users can later call the GUI with that object to edit it if req_var_name: shell = IPython.get_ipython() shell.push({req_var_name: processing_request}, interactive=True) var_name_html = html_element( 'p', value=f'Note: a new processing request has been ' f'stored in variable <code>{req_var_name}</code>.') result_html = html_element('div', value=result_html + var_name_html) info.output_html(result_html) # noinspection PyUnusedLocal @debug_view.capture(clear_output=True) def handle_submit_button_clicked(*args, **kwargs): req_var_name = python_var_name.value or 'job' if req_var_name and not req_var_name.isidentifier(): info.output_error( f'Error: invalid Python identifier: {req_var_name}') return inputs_request = new_input_request() info.output_message('Submitting processing request...') job = submit_processing_request(inputs_request, message_func=info.message_func, mock=mock) if job is not None: shell = IPython.get_ipython() shell.push({req_var_name: job}, interactive=True) result_html = html_element( 'p', value=f'Note: a new job is currently being executed and is ' f'stored in variable_id <code>{req_var_name}</code>.') info.output_html(result_html) # TODO: make GUI form look nice new_button = widgets.Button(description="New Request", icon="search") new_button.on_click(handle_new_button_clicked) submit_button = widgets.Button(description="Submit Request", icon="upload") submit_button.on_click(handle_submit_button_clicked) form_items = [ widgets.Box( [widgets.HTML(value=html_element('h2', value='Output Variables'))], layout=form_item_layout), widgets.Box([variables_box], layout=var_checks_layout), widgets.Box([clear_variable_selection_button], layout=form_item_layout), widgets.Box( [widgets.HTML(value=html_element('h2', value='Forward Models'))], layout=form_item_layout), widgets.Box([forward_models_box], layout=var_checks_layout), widgets.Box([clear_model_selection_button], layout=form_item_layout), widgets.Box([request_validation], layout=form_item_layout), widgets.Box([ widgets.HTML( value=html_element('h2', value='Sentinel-1 Pre-Processing')) ], layout=form_item_layout), widgets.Box([ widgets.Label(value='Temporal Filter'), preprocess_s1_temporal_filter ], layout=form_item_layout), widgets.Box([ widgets.HTML( value=html_element('h2', value='Sentinel-2 Pre-Processing')) ], layout=form_item_layout), preprocess_s2_only_roi_checkbox, widgets.Box([user_priors_component], layout=form_item_layout), widgets.Box([ widgets.HTML( value=html_element('h2', value='Time Period of Interest')) ], layout=form_item_layout), widgets.Box([widgets.Label(value='Start date'), start_date], layout=form_item_layout), widgets.Box([widgets.Label(value='End date'), end_date], layout=form_item_layout), widgets.Box([ widgets.Label(value='Time steps'), widgets.Box([time_steps, time_steps_unit]) ], layout=form_item_layout), widgets.Box([ widgets.HTML(value=html_element('h2', value='Region of Interest')) ], layout=form_item_layout), widgets.Box([roi_area, roi_map_button], layout=form_item_layout), widgets.Box([leaflet_map], layout=form_item_layout), widgets.Box( [widgets.Label(value='Resolution (m)'), spatial_resolution], layout=form_item_layout), widgets.Box([roi_validation], layout=form_item_layout), widgets.Box( [widgets.HTML(value=html_element('h2', value='Post-Processing'))], layout=form_item_layout), widgets.Label(value='Indicators', layout=form_item_layout), widgets.Box([indicators_box], layout=var_checks_layout), widgets.Label(value='Post Processors', layout=form_item_layout), widgets.Box([post_processors_box], layout=var_checks_layout), widgets.Box([widgets.Label(value='Request/job name'), request_name], layout=form_item_layout), widgets.Box( [widgets.Label(value='Python identifier'), python_var_name], layout=form_item_layout), widgets.Box([ widgets.Label(value=''), widgets.Box([new_button, submit_button]) ], layout=form_item_layout), widgets.Box([info.as_widget()], layout=form_item_layout) ] form = widgets.Box(form_items, layout=widgets.Layout(display='flex', flex_flow='column', border='solid 1px lightgray', align_items='stretch', width='100%')) return form
'fillOpacity': 0.1 } } control.rectangle['shapeOptions'].update({ 'color': '#ffffff', 'weight': 4, 'opacity': 0.5, 'stroke': True }) # remove default polyline and circlemarker control.polyline = {} control.circlemarker = {} # specify clear function control.on_draw(rid) # add draw control chart.add_control(control) # force a rectange onto the map force(south, north, west, east) # display chart chart # ### Setting the Date Range # Set the date range below. Leaving the beginning date blank will default to Earth Day 1995. Leaving the ending date blank will default to today's date. # In[103]:
def clickablemap(center=[48.790153, 2.327395], zoom=13, layout=ipywidgets.Layout(width='100%', height='500px')): # look at: http://leaflet.github.io/Leaflet.draw/docs/examples/basic.html import json from ipyleaflet import (Map, Rectangle, Polygon, TileLayer, ImageOverlay, DrawControl, GeoJSON) #%matplotlib inline # %matplotlib notebook # google tileserver # https://stackoverflow.com/questions/9394190/leaflet-map-api-with-google-satellite-layer mosaicsTilesURL = 'https://mt1.google.com/vt/lyrs=s,h&x={x}&y={y}&z={z}' # Hybrid: s,h; Satellite: s; Streets: m; Terrain: p; # Map Settings # Define colors colors = {'blue': "#009da5"} # Define initial map center lat/long #center = [48.790153, 2.327395] # Define initial map zoom level #zoom = 13 # Create the map m = Map(center=center, zoom=zoom, scroll_wheel_zoom=True, layout=layout) # using custom basemap m.clear_layers() m.add_layer(TileLayer(url=mosaicsTilesURL)) # Define the draw tool type options polygon = {'shapeOptions': {'color': colors['blue']}} rectangle = {'shapeOptions': {'color': colors['blue']}} ## Create the draw controls ## @see https://github.com/ellisonbg/ipyleaflet/blob/master/ipyleaflet/leaflet.py#L293 #dc = DrawControl( # polygon = polygon, # rectangle = rectangle #) dc = DrawControl( polygon={'shapeOptions': { 'color': '#0000FF' }}, polyline={'shapeOptions': { 'color': '#0000FF' }}, circle={'shapeOptions': { 'color': '#0000FF' }}, rectangle={'shapeOptions': { 'color': '#0000FF' }}, ) # Initialize an action counter variable m.actionCount = 0 m.AOIs = [] # Register the draw controls handler def handle_draw(self, action, geo_json): # Increment the action counter #global actionCount m.actionCount += 1 # Remove the `style` property from the GeoJSON geo_json['properties'] = {} # Convert geo_json output to a string and prettify (indent & replace ' with ") geojsonStr = json.dumps(geo_json, indent=2).replace("'", '"') m.AOIs.append(json.loads(geojsonStr)) # Attach the draw handler to the draw controls `on_draw` event dc.on_draw(handle_draw) m.add_control(dc) # add a custom function to create and add a Rectangle layer # (LESS USEFUL THAN add_geojson) def add_rect(*args, **kwargs): r = Rectangle(*args, **kwargs) return m.add_layer(r) m.add_rectangle = add_rect # add a custom function to create and add a Polygon layer def add_geojson(*args, **kwargs): # ugly workaround to call without data=aoi if 'data' not in kwargs: kwargs['data'] = args[0] args2 = [i for i in args[1:-1]] else: args2 = args r = GeoJSON(*args2, **kwargs) return m.add_layer(r) m.add_GeoJSON = add_geojson # Display return m
class LeafletMap(HasTraits): """A xarray.DataArray extension for tiled map plotting, based on (ipy)leaflet. """ map_ready = Bool(False) @observe('map_ready') def _map_ready_changed(self, change): self._start() def __init__(self, da): self._da = da self._da_selected = None def plot(self, m, x_dim='x', y_dim='y', fit_bounds=True, rgb_dim=None, transform0=None, transform1=passthrough, transform2=coarsen(), transform3=passthrough, colormap=None, persist=True, dynamic=False, tile_dir=None, tile_height=256, tile_width=256, resampling=Resampling.nearest, debug_output=None): """Display an array as an interactive map. Assumes that the pixels are given on a regular grid (fixed spacing in x and y). Parameters ---------- m : ipyleaflet.Map The map on while to show the layer. y_dim : str, optional Name of the y dimension/coordinate (default: 'y'). x_dim : str, optional Name of the x dimension/coordinate (default: 'x'). rgb_dim : str, optional Name of the RGB dimension/coordinate (default: None). transform0 : function, optional Transformation over the whole DataArray. transform1 : function, optional Transformation over the visible DataArray. transform2 : function, optional Transformation over a tile before reprojection. transform3 : function, optional Transformation over a tile before saving to PNG. colormap : function, optional The colormap function to use for the tile PNG (default: matplotlib.pyplot.cm.inferno). persist : bool, optional Whether to keep the tile files (True) or not (False). dynamic : bool, optional Whether the map is dynamic (True) or not (False). If True then the tiles will refreshed each time the map is dragged or zoomed. tile_dir : str, optional The path to the tile directory (must be absolute). tile_height : int, optional The heiht of a tile in pixels (default: 256). tile_width : int, optional The width of a tile in pixels (default: 256). resampling : int, optional The resampling method to use, see rasterio.warp.reproject (default: Resampling.nearest). Returns ------- l : ipyleaflet.LocalTileLayer A handler to the layer that is added to the map. """ if debug_output is None: self.debug_output = Output() else: self.debug_output = debug_output with self.debug_output: if 'proj4def' in m.crs: # it's a custom projection if dynamic: raise RuntimeError('Dynamic maps are only supported for Web Mercator (EPSG:3857), not {}'.format(m.crs)) self.dst_crs = m.crs['proj4def'] self.web_mercator = False self.custom_proj = True elif m.crs['name'].startswith('EPSG'): epsg = m.crs['name'][4:] if dynamic and epsg != '3857': raise RuntimeError('Dynamic maps are only supported for Web Mercator (EPSG:3857), not {}'.format(m.crs)) self.dst_crs = 'EPSG:' + epsg self.web_mercator = epsg == '3857' self.custom_proj = False else: raise RuntimeError('Unsupported map projection: {}'.format(m.crs)) self.nodata = self._da.rio.nodata var_dims = self._da.dims expected_dims = [y_dim, x_dim] if rgb_dim is not None: expected_dims.append(rgb_dim) if set(var_dims) != set(expected_dims): raise ValueError( "Invalid dimensions in DataArray: " "should include only {}, found {}." .format(tuple(expected_dims), var_dims) ) if rgb_dim is not None and colormap is not None: raise ValueError( "Cannot have a RGB dimension and a " "colormap at the same time." ) elif rgb_dim is None: if colormap is None: colormap = plt.cm.inferno if transform0 is None: transform0 = normalize else: # there is a RGB dimension if transform0 is None: transform0 = passthrough self.resampling = resampling self.tile_dir = tile_dir self.persist = persist self.attrs = self._da.attrs self.m = m self.dynamic = dynamic self.tile_width = tile_width self.tile_height = tile_height self.transform0 = transform0 self.transform1 = transform1 self.transform2 = transform2 self.transform3 = transform3 self.colormap = colormap if self.dynamic: self.persist = False self.tile_dir = None self._da = self._da.rename({y_dim: 'y', x_dim: 'x'}) if rgb_dim is None: self.is_rgb = False else: self.is_rgb = True self._da = self._da.rename({rgb_dim: 'rgb'}) # ensure latitudes are descending if np.any(np.diff(self._da.y.values) >= 0): self._da = self._da.sel(y=slice(None, None, -1)) # infer grid specifications (assume a rectangular grid) y = self._da.y.values x = self._da.x.values self.x_left = float(x.min()) self.x_right = float(x.max()) self.y_lower = float(y.min()) self.y_upper = float(y.max()) self.dx = float((self.x_right - self.x_left) / (x.size - 1)) self.dy = float((self.y_upper - self.y_lower) / (y.size - 1)) if fit_bounds: asyncio.ensure_future(self.async_fit_bounds()) else: asyncio.ensure_future(self.async_wait_for_bounds()) self.l = LocalTileLayer() if self._da.name is not None: self.l.name = self._da.name self._da_notransform = self._da self.spinner = Spinner() self.spinner.radius = 5 self.spinner.length = 3 self.spinner.width = 5 self.spinner.lines = 8 self.spinner.color = '#000000' self.spinner.layout.height = '30px' self.spinner.layout.width = '30px' self.spinner_control = WidgetControl(widget=self.spinner, position='bottomright') return self.l def select(self, draw_control=None): with self.debug_output: if draw_control is None: self._draw_control = DrawControl() self._draw_control.polygon = {} self._draw_control.polyline = {} self._draw_control.circlemarker = {} self._draw_control.rectangle = { 'shapeOptions': { 'fillOpacity': 0.5 } } else: self._draw_control = draw_control self._draw_control.on_draw(self._get_selection) self.m.add_control(self._draw_control) def unselect(self): with self.debug_output: self.m.remove_control(self._draw_control) def get_selection(self): return self._da_selected def _get_selection(self, *args, **kwargs): with self.debug_output: if self._draw_control.last_draw['geometry'] is not None: lonlat = self._draw_control.last_draw['geometry']['coordinates'][0] lats = [ll[1] for ll in lonlat] lons = [ll[0] for ll in lonlat] lt0, lt1 = min(lats), max(lats) ln0, ln1 = min(lons), max(lons) self._da_selected = self._da_notransform.sel(y=slice(lt1, lt0), x=slice(ln0, ln1)) def _start(self): with self.debug_output: self.m.add_control(self.spinner_control) self._da, self.transform0_args = get_transform(self.transform0(self._da, debug_output=self.debug_output)) self.url = self.m.window_url if self.url.endswith('/lab'): # we are in JupyterLab self.base_url = self.url[:-4] else: if '/notebooks/' in self.url: # we are in classical Notebook i = self.url.rfind('/notebooks/') self.base_url = self.url[:i] elif '/voila/' in self.url: # we are in Voila i = self.url.rfind('/voila/') self.base_url = self.url[:i] if self.tile_dir is None: self.tile_temp_dir = TemporaryDirectory(prefix='xarray_leaflet_') self.tile_path = self.tile_temp_dir.name else: self.tile_path = self.tile_dir self.url = self.base_url + '/xarray_leaflet' + self.tile_path + '/{z}/{x}/{y}.png' self.l.path = self.url self.m.remove_control(self.spinner_control) self._get_tiles() self.m.observe(self._get_tiles, names='pixel_bounds') if not self.dynamic: self.m.add_layer(self.l) def _get_tiles(self, change=None): with self.debug_output: self.m.add_control(self.spinner_control) if self.dynamic: self.tile_temp_dir.cleanup() self.tile_temp_dir = TemporaryDirectory(prefix='xarray_leaflet_') new_tile_path = self.tile_temp_dir.name new_url = self.base_url + '/xarray_leaflet' + new_tile_path + '/{z}/{x}/{y}.png' if self.l in self.m.layers: self.m.remove_layer(self.l) (left, top), (right, bottom) = self.m.pixel_bounds (south, west), (north, east) = self.m.bounds z = int(self.m.zoom) # TODO: support non-integer zoom levels? if self.custom_proj: resolution = self.m.crs['resolutions'][z] if self.web_mercator: tiles = list(mercantile.tiles(west, south, east, north, z)) else: x0, x1 = int(left) // self.tile_width, int(right) // self.tile_width + 1 y0, y1 = int(top) // self.tile_height, int(bottom) // self.tile_height + 1 tiles = [mercantile.Tile(x, y, z) for x in range(x0, x1) for y in range(y0, y1)] if self.dynamic: # dynamic maps are redrawn at each interaction with the map # so we can take exactly the corresponding slice in the original data da_visible = self._da.sel(y=slice(north, south), x=slice(west, east)) elif self.web_mercator: # for static web mercator maps we can't redraw a tile once it has been (partly) displayed, # so we must slice the original data on tile boundaries bbox = get_bbox_tiles(tiles) # take one more source data point to avoid glitches da_visible = self._da.sel(y=slice(bbox.north + self.dy, bbox.south - self.dy), x=slice(bbox.west - self.dx, bbox.east + self.dx)) else: # it's a custom projection or not web mercator, the visible tiles don't translate easily # to a slice of the original data, so we keep everything # TODO: slice the data for EPSG3395, EPSG4326, Earth, Base and Simple da_visible = self._da # check if we have some data to show if 0 not in da_visible.shape: da_visible, transform1_args = get_transform(self.transform1(da_visible, *self.transform0_args, debug_output=self.debug_output)) if self.dynamic: self.tile_path = new_tile_path self.url = new_url for tile in tiles: x, y, z = tile path = f'{self.tile_path}/{z}/{x}/{y}.png' # if static map, check if we already have the tile # if dynamic map, new tiles are always created if self.dynamic or not os.path.exists(path): if self.web_mercator: bbox = mercantile.bounds(tile) xy_bbox = mercantile.xy_bounds(tile) x_pix = (xy_bbox.right - xy_bbox.left) / self.tile_width y_pix = (xy_bbox.top - xy_bbox.bottom) / self.tile_height # take one more source data point to avoid glitches da_tile = da_visible.sel(y=slice(bbox.north + self.dy, bbox.south - self.dy), x=slice(bbox.west - self.dx, bbox.east + self.dx)) else: da_tile = da_visible # check if we have data for this tile if 0 in da_tile.shape: write_image(path, None, self.persist) else: da_tile.attrs = self.attrs da_tile, transform2_args = get_transform(self.transform2(da_tile, tile_width=self.tile_width, tile_height=self.tile_height, debug_output=self.debug_output), *transform1_args) # reproject each RGB component if needed # TODO: must be doable with xarray.apply_ufunc if self.is_rgb: das = [da_tile.isel(rgb=i) for i in range(3)] else: das = [da_tile] for i in range(len(das)): das[i] = das[i].rio.write_nodata(self.nodata) if self.custom_proj: das[i] = reproject_custom(das[i], self.dst_crs, x, y, z, resolution, resolution, self.tile_width, self.tile_height, self.resampling) else: das[i] = reproject_not_custom(das[i], self.dst_crs, xy_bbox.left, xy_bbox.top, x_pix, y_pix, self.tile_width, self.tile_height, self.resampling) das[i], transform3_args = get_transform(self.transform3(das[i], *transform2_args, debug_output=self.debug_output)) if self.is_rgb: alpha = np.where(das[0]==self._da.rio.nodata, 0, 255) das.append(alpha) da_tile = np.stack(das, axis=2) write_image(path, da_tile, self.persist) else: da_tile = self.colormap(das[0]) write_image(path, da_tile*255, self.persist) if self.dynamic: self.l.path = self.url self.m.add_layer(self.l) self.l.redraw() self.m.remove_control(self.spinner_control) async def async_wait_for_bounds(self): with self.debug_output: if len(self.m.bounds) == 0: await wait_for_change(self.m, 'bounds') self.map_ready = True async def async_fit_bounds(self): with self.debug_output: center = self.y_lower + (self.y_upper - self.y_lower) / 2, self.x_left + (self.x_right - self.x_left) / 2 if center != self.m.center: self.m.center = center await wait_for_change(self.m, 'bounds') zoomed_out = False # zoom out while True: if self.m.zoom <= 1: break print('Zooming out') (south, west), (north, east) = self.m.bounds if south > self.y_lower or north < self.y_upper or west > self.x_left or east < self.x_right: self.m.zoom = self.m.zoom - 1 await wait_for_change(self.m, 'bounds') zoomed_out = True else: break if not zoomed_out: # zoom in while True: print('Zooming in') (south, west), (north, east) = self.m.bounds if south < self.y_lower and north > self.y_upper and west < self.x_left and east > self.x_right: self.m.zoom = self.m.zoom + 1 await wait_for_change(self.m, 'bounds') else: self.m.zoom = self.m.zoom - 1 await wait_for_change(self.m, 'bounds') break self.map_ready = True
class Grass2Leaflet(object): def __init__(self, grassimg): self.grassimg = grassimg self.draw_control = None self.zoom = 15 self.center = self.centermap() self.m = Map(default_tiles=TileLayer(opacity=1.0), center=self.center, zoom=self.zoom) def centermap(self): centerlat = [] centerlon = [] for i in self.grassimg: centerlat.append(self.grassimg[i]['C'][0]) centerlon.append(self.grassimg[i]['C'][1]) center = (sum(centerlat) / float(len(centerlat)), sum(centerlon) / float(len(centerlon))) return center def imgoverlays(self): self.leafletimg = OrderedDict() for i in self.grassimg: layer = ImageOverlay(url=self.grassimg[i]['raster'], bounds=(self.grassimg[i]['LL'], self.grassimg[i]['UR'])) self.leafletimg[i] = layer def render(self, draw_control=None, caption=None): self.out = widgets.Output() self.imgoverlays() self.dc = None options = ['None'] self.m.add_layer(self.leafletimg[list(self.grassimg.keys())[-1]]) if len(self.grassimg) >= 2: self.maplist = widgets.Dropdown( options=options + list(self.grassimg.keys()), value=list(self.grassimg.keys())[-1], description='Select Layer:', ) self.maplist.observe(self.on_value_change, names='value') display(self.maplist) if draw_control: self.dc = DrawControl() self.dc.on_draw(handle_draw) self.m.add_control(self.dc) display(self.m) self.lastdraw = widgets.Button( description='Print last draw', disabled=False, button_style='', # 'success', 'info', 'warning', 'danger' or '' tooltip='Print last draw', #icon='check' ) self.lastdraw.on_click(self.on_button_clicked1) if not draw_control: self.lastdraw.disabled = True display(widgets.HBox([self.lastdraw, self.out])) if caption: display( HTML("<center><b>Figure %s:</b> %s<center>" % (caption[0], caption[1]))) return {'map': self.m, 'drawer': self.dc} def on_value_change(self, layername): self.m.clear_layers() self.m.add_layer(TileLayer(opacity=1.0)) if self.maplist.value != 'None': self.m.add_layer(self.leafletimg[layername['new']]) def on_button_clicked1(self, b): with self.out: clear_output() display(self.dc.last_draw) new_draw = GeoJSON(data=self.dc.last_draw) self.m.add_layer(new_draw) #display(dir(self.dc.layer)) def handle_draw_output(self, json): display(json.dumps(geo_json)) def main(self): self.imgoverlays() self.render()
def button_clicked(change): if change["new"] == "Apply": if len(color.value) != 7: color.value = "#3388ff" draw_control = DrawControl( marker={"shapeOptions": {"color": color.value}}, rectangle={"shapeOptions": {"color": color.value}}, polygon={"shapeOptions": {"color": color.value}}, circlemarker={}, polyline={}, edit=False, remove=False, ) controls = [] old_draw_control = None for control in m.controls: if isinstance(control, DrawControl): controls.append(draw_control) old_draw_control = control else: controls.append(control) m.controls = tuple(controls) old_draw_control.close() m.draw_control = draw_control train_props = {} if prop_text1.value != "" and value_text1.value != "": train_props[prop_text1.value] = int(value_text1.value) if prop_text2.value != "" and value_text2.value != "": train_props[prop_text2.value] = value_text2.value if color.value != "": train_props["color"] = color.value # Handles draw events def handle_draw(target, action, geo_json): from .geemap import ee_tile_layer try: geom = geojson_to_ee(geo_json, False) m.user_roi = geom if len(train_props) > 0: feature = ee.Feature(geom, train_props) else: feature = ee.Feature(geom) m.draw_last_json = geo_json m.draw_last_feature = feature if action == "deleted" and len(m.draw_features) > 0: m.draw_features.remove(feature) m.draw_count -= 1 else: m.draw_features.append(feature) m.draw_count += 1 collection = ee.FeatureCollection(m.draw_features) m.user_rois = collection ee_draw_layer = ee_tile_layer( collection, {"color": "blue"}, "Drawn Features", False, 0.5 ) draw_layer_index = m.find_layer_index("Drawn Features") if draw_layer_index == -1: m.add_layer(ee_draw_layer) m.draw_layer = ee_draw_layer else: m.substitute_layer(m.draw_layer, ee_draw_layer) m.draw_layer = ee_draw_layer except Exception as e: m.draw_count = 0 m.draw_features = [] m.draw_last_feature = None m.draw_layer = None m.user_roi = None m.roi_start = False m.roi_end = False print("There was an error creating Earth Engine Feature.") raise Exception(e) draw_control.on_draw(handle_draw) elif change["new"] == "Clear": prop_text1.value = "" value_text1.value = "" prop_text2.value = "" value_text2.value = "" color.value = "#3388ff" elif change["new"] == "Close": m.toolbar_reset() if m.training_ctrl is not None and m.training_ctrl in m.controls: m.remove_control(m.training_ctrl) full_widget.close() buttons.value = None
def run_agriculture_app(ds): """ Plots an interactive map of the agriculture case-study area and allows the user to draw polygons. This returns a plot of the average NDVI value in the polygon area. Last modified: May 2019 Author: Caitlin Adams (FrontierSI) inputs ds - data set containing combined, masked data from Sentinel-2a and -2b. Must also have an attribute containing the NDVI value for each pixel """ # Suppress warnings warnings.filterwarnings('ignore') # Update plotting functionality through rcParams mpl.rcParams.update({'figure.autolayout': True}) # Define the bounding box that will be overlayed on the interactive map # The bounds are hard-coded to match those from the loaded data geom_obj = { "type": "Feature", "properties": { "style": { "stroke": True, "color": 'red', "weight": 4, "opacity": 0.8, "fill": True, "fillColor": False, "fillOpacity": 0, "showArea": True, "clickable": True } }, "geometry": { "type": "Polygon", "coordinates": [ [ [152.395805, -24.995971], [152.395805, -24.974997], [152.429994, -24.974997], [152.429994, -24.995971], [152.395805, -24.995971] ] ] } } # Create a map geometry from the geom_obj dictionary # center specifies where the background map view should focus on # zoom specifies how zoomed in the background map should be loadeddata_geometry = ogr.CreateGeometryFromJson(str(geom_obj['geometry'])) loadeddata_center = [ loadeddata_geometry.Centroid().GetY(), loadeddata_geometry.Centroid().GetX() ] loadeddata_zoom = 14 # define the study area map studyarea_map = Map( center=loadeddata_center, zoom=loadeddata_zoom, basemap=basemaps.Esri.WorldImagery ) # define the drawing controls studyarea_drawctrl = DrawControl( polygon={"shapeOptions": {"fillOpacity": 0}}, marker={}, circle={}, circlemarker={}, polyline={}, ) # add drawing controls and data bound geometry to the map studyarea_map.add_control(studyarea_drawctrl) studyarea_map.add_layer(GeoJSON(data=geom_obj)) # Index to count drawn polygons polygon_number = 0 # Define widgets to interact with instruction = widgets.Output(layout={'border': '1px solid black'}) with instruction: print("Draw a polygon within the red box to view a plot of " "average NDVI over time in that area.") info = widgets.Output(layout={'border': '1px solid black'}) with info: print("Plot status:") fig_display = widgets.Output(layout=widgets.Layout( width="50%", # proportion of horizontal space taken by plot )) with fig_display: plt.ioff() fig, ax = plt.subplots(figsize=(8, 6)) ax.set_ylim([-1, 1]) colour_list = plt.rcParams['axes.prop_cycle'].by_key()['color'] # Function to execute each time something is drawn on the map def handle_draw(self, action, geo_json): nonlocal polygon_number # Execute behaviour based on what the user draws if geo_json['geometry']['type'] == 'Polygon': info.clear_output(wait=True) # wait=True reduces flicker effect with info: print("Plot status: polygon sucessfully added to plot.") # Convert the drawn geometry to pixel coordinates geom_selectedarea = transform_from_wgs_poly( geo_json['geometry'], EPSGa=3577 # hard-coded to be same as case-study data ) # Construct a mask to only select pixels within the drawn polygon mask = rasterio.features.geometry_mask( [geom_selectedarea for geoms in [geom_selectedarea]], out_shape=ds.geobox.shape, transform=ds.geobox.affine, all_touched=False, invert=True ) masked_ds = ds.ndvi.where(mask) masked_ds_mean = masked_ds.mean(dim=['x', 'y'], skipna=True) colour = colour_list[polygon_number % len(colour_list)] # Add a layer to the map to make the most recently drawn polygon # the same colour as the line on the plot studyarea_map.add_layer( GeoJSON( data=geo_json, style={ 'color': colour, 'opacity': 1, 'weight': 4.5, 'fillOpacity': 0.0 } ) ) # add new data to the plot xr.plot.plot( masked_ds_mean, marker='*', color=colour, ax=ax ) # reset titles back to custom ax.set_title("Average NDVI from Sentinel-2") ax.set_xlabel("Date") ax.set_ylabel("NDVI") # refresh display fig_display.clear_output(wait=True) # wait=True reduces flicker effect with fig_display: display(fig) # Iterate the polygon number before drawing another polygon polygon_number = polygon_number + 1 else: info.clear_output(wait=True) with info: print("Plot status: this drawing tool is not currently " "supported. Please use the polygon tool.") # call to say activate handle_draw function on draw studyarea_drawctrl.on_draw(handle_draw) with fig_display: # TODO: update with user friendly something display(widgets.HTML("")) # Construct UI: # +-----------------------+ # | instruction | # +-----------+-----------+ # | map | plot | # | | | # +-----------+-----------+ # | info | # +-----------------------+ ui = widgets.VBox([instruction, widgets.HBox([studyarea_map, fig_display]), info]) display(ui)
class Dashboard: def __init__(self, m, notif, dem2d, dem3d): self.map = m self.notif = notif self.dem2d = dem2d self.dem3d = dem3d self.tile_dir = 'dem_tiles' self.spin = Spinner() self.spin.class_name = 'dem3d_spinner' def start(self): self.draw_control = DrawControl() self.draw_control.polygon = {} self.draw_control.polyline = {} self.draw_control.circlemarker = {} self.draw_control.rectangle = {'shapeOptions': {'fillOpacity': 0.5}} self.draw_control.on_draw(self.show_dem) self.map.add_control(self.draw_control) def show_dem(self, *args, **kwargs): self.dem2d.clear_output() self.dem3d.clear_output() with self.dem2d: display(self.spin) with self.dem3d: display(self.spin) lonlat = self.draw_control.last_draw['geometry']['coordinates'][0] lats = [ll[1] for ll in lonlat] lons = [ll[0] for ll in lonlat] lt0, lt1 = min(lats), max(lats) ln0, ln1 = min(lons), max(lons) os.makedirs(self.tile_dir, exist_ok=True) with open(self.tile_dir + '.json') as f: tiles = json.loads(f.read()) lat = lat0 = floor(lt0 / 5) * 5 lon = lon0 = floor(ln0 / 5) * 5 lat1 = ceil(lt1 / 5) * 5 lon1 = ceil(ln1 / 5) * 5 ny = int(round((lat1 - lat0) / (5 / 6000))) nx = int(round((lon1 - lon0) / (5 / 6000))) zarr_path = os.path.join(self.tile_dir + '.zarr') if os.path.exists(zarr_path): shutil.rmtree(zarr_path) z = zarr.open(zarr_path, mode='w', shape=(ny, nx), chunks=(6000, 6000), dtype='float32') done = False tasks = [] with concurrent.futures.ThreadPoolExecutor() as executor: while not done: tasks.append( executor.submit(self.create_zarr_chunk, lat, lon, tiles, lat0, lat1, lon0, lon1, z)) lon += 5 if lon >= ln1: lon = lon0 lat += 5 if lat >= lt1: done = True for task in tasks: task.result() y = np.arange(lat0, lat1, 5 / 6000) x = np.arange(lon0, lon1, 5 / 6000) dem = xr.DataArray(z, coords=[y, x], dims=['y', 'x']).sel(y=slice(lt0, lt1), x=slice(ln0, ln1)) self.download_link(dem) self.show_dem2d(dem) self.show_dem3d(dem) def download_link(self, dem): lon, lat = np.meshgrid(np.radians(dem.x), np.radians(dem.y), sparse=True) r = 6371e3 f = np.where(np.isnan(dem.values), 0, dem.values) + r nr, nc = len(dem.y), len(dem.x) self.vertices = np.empty((nr, nc, 3), dtype='float32') self.vertices[:, :, 0] = f * np.cos(lat) * np.cos(lon) self.vertices[:, :, 1] = f * np.cos(lat) * np.sin(lon) self.vertices[:, :, 2] = f * np.sin(lat) self.vertices = self.vertices.reshape(nr * nc, 3) # rotate so that z goes through the middle of the selection r1 = R.from_rotvec(np.radians(np.array([0, 0, -(np.mean(dem.x) + 90)]))) r2 = R.from_rotvec(np.radians(np.array([np.mean(dem.y) - 90, 0, 0]))) self.vertices = r2.apply(r1.apply(self.vertices)) self.vertices[:, 2] -= r self.alt = self.vertices[:, 2].reshape(nr, nc) self.notif.clear_output() np.savez('dem.npz', dem=self.vertices) local_file = FileLink('dem.npz', result_html_prefix="Click here to download: ") with self.notif: display(local_file) def show_dem2d(self, dem): fig = dem.plot.imshow(vmin=np.nanmin(dem), vmax=np.nanmax(dem)) self.dem2d.clear_output() with self.dem2d: display(fig) plt.show() def show_dem3d(self, dem): nr, nc = len(dem.y), len(dem.x) triangle_indices = np.empty((nr - 1, nc - 1, 2, 3), dtype='uint32') r = np.arange(nr * nc, dtype='uint32').reshape(nr, nc) triangle_indices[:, :, 0, 0] = r[:-1, :-1] triangle_indices[:, :, 1, 0] = r[:-1, 1:] triangle_indices[:, :, 0, 1] = r[:-1, 1:] triangle_indices[:, :, 1, 1] = r[1:, 1:] triangle_indices[:, :, :, 2] = r[1:, :-1, None] triangle_indices.shape = (-1, 3) height_component = Component(name='value', array=self.alt) mesh = PolyMesh(vertices=self.vertices, triangle_indices=triangle_indices, data={'height': [height_component]}) colored_mesh = IsoColor(mesh, input='height', min=np.min(self.alt), max=np.max(self.alt)) warped_mesh = Warp(colored_mesh, input=(0, 0, ('height', 'value')), factor=0) warp_slider = FloatSlider(min=0, max=10, value=0, description='Vertical exaggeration', style={'description_width': 'initial'}) jslink((warped_mesh, 'factor'), (warp_slider, 'value')) self.dem3d.clear_output() with self.dem3d: display(VBox((Scene([warped_mesh]), warp_slider))) def create_zarr_chunk(self, lat, lon, tiles, lat0, lat1, lon0, lon1, z): if lat < 0: fname = 's' else: fname = 'n' fname += str(abs(lat)).zfill(2) if lon < 0: fname += 'w' else: fname += 'e' fname += str(abs(lon)).zfill(3) fname += '_con_grid.zip' url = '' for continent in tiles: if fname in tiles[continent][1]: url = tiles[continent][0] + fname break if url: filename = os.path.basename(url) name = filename[:filename.find('_grid')] adffile = os.path.join(self.tile_dir, name, name, 'w001001.adf') zipfname = os.path.join(self.tile_dir, filename) if not os.path.exists(adffile): r = requests.get(url, stream=True) with open(zipfname, 'wb') as f: total_length = int(r.headers.get('content-length')) self.notif.clear_output() with self.notif: for chunk in tqdm(r.iter_content(chunk_size=1024), total=ceil(total_length / 1024)): if chunk: f.write(chunk) f.flush() zip = zipfile.ZipFile(zipfname) zip.extractall(self.tile_dir) dem = gdal.Open(adffile) geo = dem.GetGeoTransform() ySize, xSize = dem.RasterYSize, dem.RasterXSize dem = dem.ReadAsArray() # data is padded into a 6000x6000 array (some tiles may be smaller) array_5x5 = np.full((6000, 6000), -32768, dtype='int16') y0 = int(round((geo[3] - lat - 5) / geo[5])) y1 = 6000 - int(round((lat - (geo[3] + geo[5] * ySize)) / geo[5])) x0 = int(round((geo[0] - lon) / geo[1])) x1 = 6000 - int( round(((lon + 5) - (geo[0] + geo[1] * xSize)) / geo[1])) array_5x5[y0:y1, x0:x1] = dem array_5x5 = np.where(array_5x5 == -32768, np.nan, array_5x5.astype('float32')) y0 = z.shape[0] + (lat - lat1) // 5 * 6000 y1 = y0 + 6000 x0 = (lon - lon0) // 5 * 6000 x1 = x0 + 6000 z[y0:y1, x0:x1] = array_5x5[::-1]
def run_miningrehab_app(ds): """ Plots an interactive map of the mining case-study area and allows the user to draw polygons. This returns plots of the fractional cover value of bare soil, green vegetation and brown vegetation in the polygon area. Last modified: January 2020 inputs ds - data set containing masked Fractional Cover data from Landsat 8 """ # Suppress warnings warnings.filterwarnings("ignore") # Update plotting functionality through rcParams mpl.rcParams.update({"figure.autolayout": True}) # Define the bounding box that will be overlayed on the interactive map # The bounds are hard-coded to match those from the loaded data geom_obj = { "type": "Feature", "properties": { "style": { "stroke": True, "color": "red", "weight": 4, "opacity": 0.8, "fill": True, "fillColor": False, "fillOpacity": 0, "showArea": True, "clickable": True, } }, "geometry": { "type": "Polygon", "coordinates": [[ [116.630731, -34.434517], [116.630731, -34.426512], [116.648123, -34.426512], [116.648123, -34.434517], [116.630731, -34.434517], ]], }, } # Create a map geometry from the geom_obj dictionary # center specifies where the background map view should focus on # zoom specifies how zoomed in the background map should be loadeddata_geometry = ogr.CreateGeometryFromJson(str(geom_obj["geometry"])) loadeddata_center = [ loadeddata_geometry.Centroid().GetY(), loadeddata_geometry.Centroid().GetX(), ] loadeddata_zoom = 15 # define the study area map studyarea_map = Map( layout=widgets.Layout(width="480px", height="600px"), center=loadeddata_center, zoom=loadeddata_zoom, basemap=basemaps.Esri.WorldImagery, ) # define the drawing controls studyarea_drawctrl = DrawControl( polygon={"shapeOptions": { "fillOpacity": 0 }}, marker={}, circle={}, circlemarker={}, polyline={}, ) # add drawing controls and data bound geometry to the map studyarea_map.add_control(studyarea_drawctrl) studyarea_map.add_layer(GeoJSON(data=geom_obj)) # Index to count drawn polygons polygon_number = 0 # Define widgets to interact with instruction = widgets.Output(layout={"border": "1px solid black"}) with instruction: print("Draw a polygon within the red box to view plots of " "the fractional cover values of bare, green and " "non-green cover for the area over time.") info = widgets.Output(layout={"border": "1px solid black"}) with info: print("Plot status:") fig_display = widgets.Output(layout=widgets.Layout( width="50%" # proportion of horizontal space taken by plot )) with fig_display: plt.ioff() fig, ax = plt.subplots(3, 1, figsize=(9, 9)) for axis in ax: axis.set_ylim([0, 1]) colour_list = plt.rcParams["axes.prop_cycle"].by_key()["color"] # Function to execute each time something is drawn on the map def handle_draw(self, action, geo_json): nonlocal polygon_number # info.clear_output(wait=True) # wait=True reduces flicker effect # with info: # print("Plot status: entered handle draw") # Execute behaviour based on what the user draws if geo_json["geometry"]["type"] == "Polygon": # Convert the drawn geometry to pixel coordinates geom_selectedarea = transform_geojson_wgs_to_epsg( geo_json, EPSG=3577 # hard-coded to be same as case-study data ) # Construct a mask to only select pixels within the drawn polygon mask = rasterio.features.geometry_mask( [geom_selectedarea for geoms in [geom_selectedarea]], out_shape=ds.geobox.shape, transform=ds.geobox.affine, all_touched=False, invert=True, ) masked_ds = ds.where(mask) masked_ds_mean = masked_ds.mean(dim=["x", "y"], skipna=True) colour = colour_list[polygon_number % len(colour_list)] # Add a layer to the map to make the most recently drawn polygon # the same colour as the line on the plot studyarea_map.add_layer( GeoJSON( data=geo_json, style={ "color": colour, "opacity": 1, "weight": 4.5, "fillOpacity": 0.0, }, )) # Add Fractional cover plots to app masked_ds_mean.BS.interpolate_na( dim="time", method="nearest").plot.line("-", ax=ax[0]) masked_ds_mean.PV.interpolate_na( dim="time", method="nearest").plot.line("-", ax=ax[1]) masked_ds_mean.NPV.interpolate_na( dim="time", method="nearest").plot.line("-", ax=ax[2]) # reset titles back to custom ax[0].set_ylabel("Bare cover") ax[1].set_ylabel("Green cover") ax[2].set_ylabel("Non-green cover") # refresh display fig_display.clear_output( wait=True) # wait=True reduces flicker effect with fig_display: display(fig) # Update plot info info.clear_output(wait=True) # wait=True reduces flicker effect with info: print("Plot status: polygon added to plot") # Iterate the polygon number before drawing another polygon polygon_number = polygon_number + 1 else: info.clear_output(wait=True) with info: print("Plot status: this drawing tool is not currently " "supported. Please use the polygon tool.") # call to say activate handle_draw function on draw studyarea_drawctrl.on_draw(handle_draw) with fig_display: # TODO: update with user friendly something display(widgets.HTML("")) # Construct UI: # +-----------------------+ # | instruction | # +-----------+-----------+ # | map | plot | # | | | # +-----------+-----------+ # | info | # +-----------------------+ ui = widgets.VBox( [instruction, widgets.HBox([studyarea_map, fig_display]), info]) display(ui)
def run_valuation_app(): """ Description of function to come """ # Suppress warnings warnings.filterwarnings('ignore') # Update plotting functionality through rcParams mpl.rcParams.update({'figure.autolayout': True}) #Start the datacube dc = datacube.Datacube(app='dem') # Set the parameters to load the backgroun map # center specifies where the background map view should focus on # zoom specifies how zoomed in the background map should be loadeddata_center = [-33.419474, 149.577299] loadeddata_zoom = 12 # define the background map studyarea_map = Map(center=loadeddata_center, zoom=loadeddata_zoom, basemap=basemaps.OpenStreetMap.Mapnik) # define the drawing controls studyarea_drawctrl = DrawControl( polygon={"shapeOptions": { "fillOpacity": 0 }}, marker={}, circle={}, circlemarker={}, polyline={}, ) # add drawing controls and data bound geometry to the map studyarea_map.add_control(studyarea_drawctrl) #studyarea_map.add_layer(GeoJSON(data=geom_obj)) # Index to count drawn polygons polygon_number = 0 # Define widgets to interact with instruction = widgets.Output(layout={'border': '1px solid black'}) with instruction: print("Draw a polygon within the red box to estimate " "the number of pixels in the polygon.") info = widgets.Output(layout={'border': '1px solid black'}) with info: print("Plot status:") fig_display = widgets.Output(layout=widgets.Layout( width="50%", # proportion of horizontal space taken by plot )) with fig_display: plt.ioff() fig, ax = plt.subplots(figsize=(8, 6)) colour_list = plt.rcParams['axes.prop_cycle'].by_key()['color'] # Function to execute each time something is drawn on the map def handle_draw(self, action, geo_json): nonlocal polygon_number # Execute behaviour based on what the user draws if geo_json['geometry']['type'] == 'Polygon': # Convert the drawn geometry to pixel coordinates geom_selectedarea_flat, geom_selectedarea = transform_from_wgs_poly( geo_json['geometry'], EPSGa=3577 # hard-coded to be same as case-study data ) geom_envelope = geom_selectedarea_flat.GetEnvelope() minX, maxX, minY, maxY = geom_envelope # Insert dc.load for dem and dlcdnsw x_range = (minX, maxX) y_range = (minY, maxY) inputcrs = "EPSG:3577" dem_res = (-5, 5) # dlcd_res is unused as the same res must be used when loading # multiple products (to support the cross count process). The # smallest cell size is used as this will provide the greatest # accuracy. dlcd_res = (-100, 100) # unused slope_cat = get_slope_raster(dc, x_range, y_range, inputcrs, dem_res, geom_selectedarea) dlcd = get_dlcd_raster(dc, x_range, y_range, inputcrs, dem_res, geom_selectedarea) stacked = xr.merge([dlcd, slope_cat]) cross_counts = unique_counts(stacked) slope_cat_count = slope_cat.to_dataframe( ).slope_category.value_counts().rename('counts').to_frame() slope_cat_count.index.name = 'index' slope_cat_table = pd.read_csv('slope_cat.csv') slope_coverage = pd.merge(slope_cat_count, slope_cat_table, how="left", left_on=['index'], right_on=['id']) # Compute the total number of pixels in the masked data set pix_dlcd = dlcd.count().compute().item() # Convert dlcd to pandas and get value counts for each class pd_dlcd = dlcd.to_dataframe() pd_dlcd_classcount = pd_dlcd.dlcd.value_counts().reset_index( name='counts') # Convert slope_cat to pandas and get value counts for each category # pd_slope_cat_count = slope_cat.to_dataframe().band1.value_counts() # Load DLCD land cover look-up table dlcd_lookup = pd.read_csv("dlcd.csv") # Join dlcd counts against landcover look up table pd_dlcd_coverage = pd.merge(pd_dlcd_classcount, dlcd_lookup, how="left", left_on=['index'], right_on=['id']) # Format the counts table to keep necessary items pd_dlcd_coverage['area(km^2)'] = pd_dlcd_coverage['counts'] * ( dem_res[1] / 1000.)**2 pd_dlcd_coverage['percentage_area'] = pd_dlcd_coverage[ 'counts'] / pd_dlcd_coverage['counts'].sum() * 100 pd_dlcd_output = pd_dlcd_coverage[[ 'Name', 'area(km^2)', 'percentage_area' ]] # manipulate cross counts into format suitable for presentation as # a table pd_cross_counts = cross_counts.to_dataframe() pd_cross_counts.sort_values(by='count', ascending=False, inplace=True) # join DLCD lookup table for DLCD class names pd_cross_counts = pd.merge(pd_cross_counts, dlcd_lookup, how='left', left_on=['dlcd'], right_on=['id']) pd_cross_counts = pd_cross_counts.rename(columns={ 'dlcd': 'dlcd_id', 'Name': 'DLCD' }) # join slope category definition table for slope class names pd_cross_counts = pd.merge(pd_cross_counts, slope_cat_table, how='left', left_on=['slope_category'], right_on=['id']) pd_cross_counts['slope'] = (pd_cross_counts[[ 'label', 'range' ]].apply(lambda x: '{} {}'.format(x[0], x[1]), axis=1)) # Format the counts table to keep necessary items pd_cross_counts['area(km^2)'] = (pd_cross_counts['count'] * (dem_res[1] / 1000.)**2) pd_cross_counts['percentage_area'] = ( pd_cross_counts['count'] / pd_cross_counts['count'].sum() * 100) pd_cross_counts_output = (pd_cross_counts[[ 'DLCD', 'slope', 'area(km^2)', 'percentage_area' ]]) # display(pd_cross_counts) colour = colour_list[polygon_number % len(colour_list)] # Add a layer to the map to make the most recently drawn polygon # the same colour as the line on the plot studyarea_map.add_layer( GeoJSON(data=geo_json, style={ 'color': colour, 'opacity': 1, 'weight': 4.5, 'fillOpacity': 0.0 })) # Make the DLDC Summary plot ax.clear() pd_dlcd_output.plot.bar(x='Name', y='percentage_area', rot=45, ax=ax, legend=False, color=colour) ax.set_xlabel("Land Cover Class") ax.set_ylabel("Percentage Coverage Of Polygon") # refresh display fig_display.clear_output( wait=True) # wait=True reduces flicker effect with fig_display: display(fig) info.clear_output(wait=True) # wait=True reduces flicker effect with info: # use to_string function to avoid truncation of results print(pd_cross_counts_output.to_string()) # Iterate the polygon number before drawing another polygon polygon_number = polygon_number + 1 else: info.clear_output(wait=True) with info: print("Plot status: this drawing tool is not currently " "supported. Please use the polygon tool.") # call to say activate handle_draw function on draw studyarea_drawctrl.on_draw(handle_draw) with fig_display: # TODO: update with user friendly something display(widgets.HTML("")) # Construct UI: # +-----------------------+ # | instruction | # +-----------+-----------+ # | map | # | | # +-----------+-----------+ # | info | # +-----------------------+ ui = widgets.VBox( [instruction, widgets.HBox([studyarea_map, fig_display]), info]) display(ui)
def run_crophealth_app(ds, lat, lon, buffer): """ Plots an interactive map of the crop health case-study area and allows the user to draw polygons. This returns a plot of the average NDVI value in the polygon area. Last modified: January 2020 Parameters ---------- ds: xarray.Dataset data set containing combined, masked data Masked values are set to 'nan' lat: float The central latitude corresponding to the area of loaded ds lon: float The central longitude corresponding to the area of loaded ds buffer: The number of square degrees to load around the central latitude and longitude. For reasonable loading times, set this as `0.1` or lower. """ # Suppress warnings warnings.filterwarnings('ignore') # Update plotting functionality through rcParams mpl.rcParams.update({'figure.autolayout': True}) # Define polygon bounds latitude = (lat - buffer, lat + buffer) longitude = (lon - buffer, lon + buffer) # Define the bounding box that will be overlayed on the interactive map # The bounds are hard-coded to match those from the loaded data geom_obj = { "type": "Feature", "properties": { "style": { "stroke": True, "color": 'red', "weight": 4, "opacity": 0.8, "fill": True, "fillColor": False, "fillOpacity": 0, "showArea": True, "clickable": True } }, "geometry": { "type": "Polygon", "coordinates": [ [ [ longitude[0], latitude[0] ], [ longitude[1], latitude[0] ], [ longitude[1], latitude[1] ], [ longitude[0], latitude[1] ], [ longitude[0], latitude[0] ] ] ] } } # Create a map geometry from the geom_obj dictionary # center specifies where the background map view should focus on # zoom specifies how zoomed in the background map should be loadeddata_geometry = ogr.CreateGeometryFromJson(str(geom_obj['geometry'])) loadeddata_center = [ loadeddata_geometry.Centroid().GetY(), loadeddata_geometry.Centroid().GetX() ] loadeddata_zoom = 16 # define the study area map studyarea_map = Map( center=loadeddata_center, zoom=loadeddata_zoom, basemap=basemaps.Esri.WorldImagery ) # define the drawing controls studyarea_drawctrl = DrawControl( polygon={"shapeOptions": {"fillOpacity": 0}}, marker={}, circle={}, circlemarker={}, polyline={}, ) # add drawing controls and data bound geometry to the map studyarea_map.add_control(studyarea_drawctrl) studyarea_map.add_layer(GeoJSON(data=geom_obj)) # Index to count drawn polygons polygon_number = 0 # Define widgets to interact with instruction = widgets.Output(layout={'border': '1px solid black'}) with instruction: print("Draw a polygon within the red box to view a plot of " "average NDVI over time in that area.") info = widgets.Output(layout={'border': '1px solid black'}) with info: print("Plot status:") fig_display = widgets.Output(layout=widgets.Layout( width="50%", # proportion of horizontal space taken by plot )) with fig_display: plt.ioff() fig, ax = plt.subplots(figsize=(8, 6)) ax.set_ylim([0, 1]) colour_list = plt.rcParams['axes.prop_cycle'].by_key()['color'] # Function to execute each time something is drawn on the map def handle_draw(self, action, geo_json): nonlocal polygon_number # Execute behaviour based on what the user draws if geo_json['geometry']['type'] == 'Polygon': info.clear_output(wait=True) # wait=True reduces flicker effect # Save geojson polygon to io temporary file to be rasterized later jsonData = json.dumps(geo_json) binaryData = jsonData.encode() io = BytesIO(binaryData) io.seek(0) # Read the polygon as a geopandas dataframe gdf = gpd.read_file(io) gdf.crs = "EPSG:4326" # Convert the drawn geometry to pixel coordinates xr_poly = xr_rasterize(gdf, ds.NDVI.isel(time=0), crs='EPSG:6933') # Construct a mask to only select pixels within the drawn polygon masked_ds = ds.NDVI.where(xr_poly) masked_ds_mean = masked_ds.mean(dim=['x', 'y'], skipna=True) colour = colour_list[polygon_number % len(colour_list)] # Add a layer to the map to make the most recently drawn polygon # the same colour as the line on the plot studyarea_map.add_layer( GeoJSON( data=geo_json, style={ 'color': colour, 'opacity': 1, 'weight': 4.5, 'fillOpacity': 0.0 } ) ) # add new data to the plot xr.plot.plot( masked_ds_mean, marker='*', color=colour, ax=ax ) # reset titles back to custom ax.set_title("Average NDVI from Landsat 8") ax.set_xlabel("Date") ax.set_ylabel("NDVI") # refresh display fig_display.clear_output(wait=True) # wait=True reduces flicker effect with fig_display: display(fig) with info: print("Plot status: polygon sucessfully added to plot.") # Iterate the polygon number before drawing another polygon polygon_number = polygon_number + 1 else: info.clear_output(wait=True) with info: print("Plot status: this drawing tool is not currently " "supported. Please use the polygon tool.") # call to say activate handle_draw function on draw studyarea_drawctrl.on_draw(handle_draw) with fig_display: # TODO: update with user friendly something display(widgets.HTML("")) # Construct UI: # +-----------------------+ # | instruction | # +-----------+-----------+ # | map | plot | # | | | # +-----------+-----------+ # | info | # +-----------------------+ ui = widgets.VBox([instruction, widgets.HBox([studyarea_map, fig_display]), info]) display(ui)
tiffFiles_path = os.path.join(orig_path, "tiffFiles") os.chdir(tiffFiles_path) jsonFile = cityName + ".geojson" geojson_exists = False if (os.path.exists(os.path.join(os.getcwd(), jsonFile))): actionCount += 1 with open(os.path.join(os.getcwd(), jsonFile)) as f: AOIs[actionCount] = json.load(f) print("GEOJSON ALREADY CREATED - MOVE TO NEXT CELL\n") geojson_exists = True else: # Attach the draw handler to the draw controls `on_draw` event print("Draw area of interest on map and a geojson will be generated\n") os.chdir(orig_path) dc.on_draw(handle_draw) m.add_control(dc) geojson_exists = False m # # Querying the Planet API. # * First we'll grab our geojson area of interest (AOI) and use it to construct a query. # * We'll then build a search to search that area looking for PSScene3Band # * We have lots of products: RapidEye, PlanetScope (PS) 3 and 4 band, LandSat, and Sentinel are all possible. # * Once we have our query, we'll do the search. We will then iterate over the results, slurp up the data, and put them in a pandas data frame for easy sorting. # * We'll print the first few so we're sure it works. # In[73]: import datetime os.chdir(orig_path)
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