def draw_interactive_map(): """ Draws interactive map to be able to draw/define a region of interest """ wms_drillholes = WMSLayer( url='http://geo.loop-gis.org/geoserver/loop/wms?', layers='loop:collar_4326', format='image/png', transparent=True, attribution='Drilhole collar from GSWA', name='drillhole collars' ) wms_geol = WMSLayer( url='http://geo.loop-gis.org/geoserver/loop/wms?', layers='loop:2_5m_interpgeop15_4326', format='image/png', transparent=True, opacity=0.4, attribution='Geology data from GSWA', name='geology' ) m =Map(basemap=basemaps.OpenTopoMap, center=(-29,116.5), zoom=8,scroll_wheel_zoom=True) m.add_layer(wms_geol) m.add_layer(wms_drillholes) m.add_control(LayersControl()) dc = DrawControl(rectangle={'shapeOptions': {'color': '#0000FF'}}) m.add_control(dc) m
def run(): global m, dc, 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) # mb = TileLayer(url="https://api.mapbox.com/styles/v1/mapbox/satellite-streets-v9/tiles/256/{z}/{x}/{y}?access_token=pk.eyJ1IjoibWNhbnR5IiwiYSI6ImNpcjRsMmJxazAwM3hoeW05aDA1cmNkNzMifQ.d2UbIugbQFk2lnU8uHwCsQ", # attribution = "<a href='https://www.mapbox.com/about/maps/'>Mapbox</a> © <a href='http://www.openstreetmap.org/copyright'>OpenStreetMap</a> <strong><a href='https://www.mapbox.com/map-feedback/' target='_blank'>Improve this map</a></strong>" ) # sm_control = SplitMapControl(left_layer=osm,right_layer=ewi) 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 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, **kwargs): super(Map, self).__init__(**kwargs) self.bapwidget = kwargs.get('bapwidget') self.map = ui.Map() lc = LayersControl() self.map.add_control(lc) self.name = Text(description='Name', value='BAP_composite') self.make_name_button = Button(description='Make name') self.visualization = Select(description='VisParams', options=['NSR', 'RGB'], value='NSR') self.add_map_button = Button( description='Add using map bounds', tooltip='Add composite to Map using Map bounds') self.add_site_button = Button( description='Add using Site', tooltip='Add composite to Map using the Site') self.add_map_button.on_click(self.addMapComposite) self.add_site_button.on_click(self.addSiteComposite) self.make_name_button.on_click(self.makeName) # Tabs self.tabs = Tab([ VBox([ HBox([self.name, self.make_name_button]), self.visualization, self.add_map_button, self.add_site_button ]), self.map.inspector_wid, self.map.layers_widget ]) self.tabs.set_title(0, 'Composite') self.tabs.set_title(1, 'Inspector') self.tabs.set_title(2, 'Layers') self.children = [self.map, self.tabs]
def display_da(da, cm): """ Description: Display a colored xarray.DataArray on a map and allow the user to select a point ----- Input: da: xarray.DataArray cm: matplotlib colormap Output: m: map to interact with dc: draw control Usage: View, interact and point a location to be used later on """ # Check inputs assert 'dataarray.DataArray' in str( type(da)), "da must be an xarray.DataArray" # convert DataArray to png64 imgurl = da_to_png64(da, cm) # Display latitude = (da.latitude.values.min(), da.latitude.values.max()) longitude = (da.longitude.values.min(), da.longitude.values.max()) margin = -0.5 zoom_bias = 0 lat_zoom_level = _degree_to_zoom_level(margin=margin, * latitude) + zoom_bias lon_zoom_level = _degree_to_zoom_level(margin=margin, * longitude) + zoom_bias zoom = min(lat_zoom_level, lon_zoom_level) - 1 center = [np.mean(latitude), np.mean(longitude)] m = Map(center=center, zoom=zoom) # http://leaflet-extras.github.io/leaflet-providers/preview/ esri = basemap_to_tiles(basemaps.Esri.WorldImagery) m.add_layer(esri) io = ImageOverlay(name='DataArray', url=imgurl, bounds=[(latitude[0], longitude[0]), (latitude[1], longitude[1])]) m.add_layer(io) dc = DrawControl(circlemarker={'color': 'yellow'}, polygon={}, polyline={}) m.add_control(dc) m.add_control(LayersControl()) return m, dc, io
def rasters_on_map(rasters_list, out_dir, overlay_names_list, geojson_data=None): """ displays a raster on a ipyleaflet map :param rasters_list: rasters to display (rasterio image) :param out_dir: path to the output directory (preview writing) :param overlay_names_list: name of the overlays for the map """ # - get bounding box raster = rasters_list[0] epsg4326 = {'init': 'EPSG:4326'} bounds = transform_bounds(raster.crs, epsg4326, *raster.bounds) center = [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2] # - get centered map m = Map(center=(center[-1], center[0]), zoom=10) # - plot quicklook for raster, overlay_name in zip(rasters_list, overlay_names_list): bounds = transform_bounds(raster.crs, epsg4326, *raster.bounds) quicklook_url = os.path.join( out_dir, "PREVIEW_{}.JPG".format(datetime.datetime.now())) write_quicklook(raster, quicklook_url) quicklook = ImageOverlay(url=quicklook_url, bounds=((bounds[1], bounds[0]), (bounds[3], bounds[2])), name=overlay_name) m.add_layer(quicklook) m.add_control(LayersControl()) m.add_control(FullScreenControl()) # - add geojson data if geojson_data is not None: geo_json = GeoJSON(data=geojson_data, style={ 'color': 'green', 'opacity': 1, 'weight': 1.9, 'dashArray': '9', 'fillOpacity': 0.1 }) m.add_layer(geo_json) # - add draw control dc = DrawControl() m.add_control(dc) return m, dc
def run(): global m, dc, center center = list(reversed(poly.centroid().coordinates().getInfo())) m = Map(center=center, zoom=10, layout={'height': '400px'}) osm = basemap_to_tiles(basemaps.OpenStreetMap.HOT) mb = TileLayer( url= "https://api.mapbox.com/styles/v1/mapbox/satellite-streets-v9/tiles/256/{z}/{x}/{y}?access_token=pk.eyJ1IjoibWNhbnR5IiwiYSI6ImNpcjRsMmJxazAwM3hoeW05aDA1cmNkNzMifQ.d2UbIugbQFk2lnU8uHwCsQ" ) sm_control = SplitMapControl(left_layer=osm, right_layer=mb) m.add_control(dc) m.add_control(sm_control) m.add_control(LayersControl()) display(m) display(box)
def __init__(self, **kwargs): if "center" not in kwargs: kwargs["center"] = [40, -100] if "zoom" not in kwargs: kwargs["zoom"] = 4 if "scroll_wheel_zoom" not in kwargs: kwargs["scroll_wheel_zoom"] = True super().__init__(**kwargs) if "height" not in kwargs: self.layout.height = "600px" else: self.layout.height = kwargs["height"] self.add_control(FullScreenControl()) self.add_control(LayersControl(position="topright")) self.add_control(DrawControl(position="topleft")) self.add_control(MeasureControl()) self.add_control(ScaleControl(position="bottomleft")) main_toolbar(self) if "google_map" not in kwargs: layer = TileLayer( url="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", attribution="Google", name="Google Maps", ) self.add_layer(layer) else: if kwargs["google_map"] == "ROADMAP": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", attribution="Google", name="Google Maps", ) self.add_layer(layer) elif kwargs["google_map"] == "HYBRID": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}", attribution="Google", name="Google Satellite", ) self.add_layer(layer)
def flight_map(self, center=None, basemap=None, zoom=8): """Display interactive map of the flight path. (Jupyter notebook only.) Parameters ---------- center: tuple, optional (latitude, longitude) center of the map. The default is the average of the flight's lat/lon bounding box. basemap: str, or list or tuple of str, optional Name of the base map available in ipyleaflet. Default: ``('Esri.WorldImagery', 'OpenTopoMap')``. zoom: int, optional Map zoom level. Default is 8. """ if not display_map: raise RuntimeError('Cannot display map') if basemap is None: basemap = ('Esri.WorldImagery', 'OpenTopoMap') elif isinstance(basemap, str): basemap = (basemap, ) elif not isinstance(basemap, (list, tuple)): raise TypeError('basemap is not a str, list, or tuple') base_layers = list() for layer in basemap: name_parts = layer.split('.') base_layer = basemaps for p in name_parts: base_layer = base_layer[p] if not isinstance(base_layer, dict): raise TypeError('base layer not a dict') base_layers.append(basemap_to_tiles(base_layer)) data = self._flight flight_lat = data['latitude'] flight_lon = data['longitude'] if center is None: center = (flight_lat.mean(), flight_lon.mean()) flight_path = Polyline( locations=[np.column_stack((flight_lat, flight_lon)).tolist()], color='blue', fill=False, name='Flight path') flight_map = Map(center=center, zoom=int(zoom)) for _ in base_layers: flight_map.add_layer(_) flight_map.add_layer(flight_path) flight_map.add_control(FullScreenControl()) flight_map.add_control(LayersControl()) display(flight_map)
def addImageLayer(inMap, filename, spatial_extent, name): im = PIL.Image.open(filename) f = BytesIO() im.save(f, 'png') data = b64encode(f.getvalue()) data = data.decode('ascii') imgurl = 'data:image/png;base64,' + data image = ImageOverlay(url=imgurl, bounds=((spatial_extent['south'], spatial_extent['east']), (spatial_extent['north'], spatial_extent['west'])), name=name) layers_control = LayersControl(position='topright') inMap.map.add_layer(image) return
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)
def __init__(self, **kwargs): """Map class """ if "center" not in kwargs: kwargs["center"] = [40, -100] if "zoom" not in kwargs: kwargs['zoom'] = 4 if "scroll_wheel_zoom" not in kwargs: kwargs["scroll_wheel_zoom"] = True super().__init__(**kwargs) if "height" not in kwargs: self.layout.height = "600px" else: self.layout.height = kwargs['height'] self.add_control(FullScreenControl()) self.add_control(LayersControl(position="bottomright")) self.add_control(DrawControl(position="topleft")) self.add_control(MeasureControl()) self.add_control(ScaleControl(position="bottomleft")) main_toolbar(self) if "google_map" not in kwargs or kwargs["google_map"] == "ROADMAP": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", attribution="Google", name="Google Maps") self.add_layer(layer) elif kwargs["google_map"] == "HYBRID": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}", attribution="Google", name="Google Satellite") self.add_layer(layer) if 'in_csv' in kwargs: in_csv = kwargs['in_csv'] x = kwargs['x'] y = kwargs['y'] header = kwargs['header'] self.add_points_from_csv(in_csv, x, y, header)
def draw_map(): """ Description: Create an empty map to be used to draw a polygon or rectangle ----- Input: None Output: m: empty map ti interact with dc: draw control Usage: Draw a polygon or a rectangle """ # Location center = [47, 8] zoom = 7 m = Map(center=center, zoom=zoom) # Layers # http://leaflet-extras.github.io/leaflet-providers/preview/ esri = basemap_to_tiles(basemaps.Esri.WorldImagery) m.add_layer(esri) terrain = basemap_to_tiles(basemaps.Stamen.Terrain) m.add_layer(terrain) mapnik = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik) m.add_layer(mapnik) m.add_control(LayersControl()) # Controls dc = DrawControl(rectangle={'shapeOptions': {'color': '#0000FF'}}, polygon={'shapeOptions': {'color': '#0000FF'}}, marker={}, polyline={}, circle={}, circlemarker={} ) m.add_control(dc) return m, dc
def add_map(self, layers=None): _layers = [Graticule()] if layers is not None: _layers += layers return Map(layers=_layers, controls=(FullScreenControl(), StatusBarControl(), LayersControl(collapsed=False, position="topright")), crs="CAR", center=(0, 0), min_zoom=-5, max_zoom=+5, interpolation="nearest", zoom=0, scroll_wheel_zoom=True, fade_animation=False, world_copy_jump=True, style=MapStyle(cursor="default"), default_style=MapStyle(cursor="default"), dragging_style=MapStyle(cursor="default"))
def get_ipy(wards, wardcentres, const, constcentres, x="ratio"): from ipyleaflet import Map, Marker, GeoJSON, basemaps, GeoData, LayersControl from pymapbox.utils import geojson m = Map() m.center = [52.1917, -1.7083] m.zoom = 10 m.scroll_wheel_zoom = True x, cats, colorset, wards = get_cats(x, wards) # create style columns wards["fillcolor"] = wards[x].map(dict(zip(cats, colorset))) wards = wards[["geometry", "wardname", "fillcolor"]] wardcentres = wardcentres[["wardname", "geometry"]] def wardstyle(row): return dict(fillColor=row["properties"]["fillcolor"], fillOpacity=1) layer = GeoJSON( name="constituencies", data=geojson(const), style=dict(fillColor="#00000000", weight=3), ) m.add_layer(layer) layer = GeoJSON( name="wards", data=geojson(wards), style_callback=wardstyle, style=dict(weight=1), ) m.add_layer(layer) m.add_control(LayersControl()) return m
def __init__(self, basemaps=[], dc=False, vinspector=False, gee=True, **kwargs): self.world_copy_jump = True # Init the map super().__init__( ee_initialize= False, # we take care of the initialization on our side add_google_map=False, center=[0, 0], zoom=2, **kwargs) # init ee self.ee = gee if gee: su.init_ee() # init the rasters self.loaded_rasters = {} # add the basemaps self.clear_layers() if len(basemaps): [self.add_basemap(basemap) for basemap in set(basemaps)] else: self.add_basemap('CartoDB.DarkMatter') # add the base controls self.clear_controls() self.add_control(ZoomControl(position='topright')) self.add_control(LayersControl(position='topright')) self.add_control(AttributionControl(position='bottomleft')) self.add_control(ScaleControl(position='bottomleft', imperial=False)) # change the prefix for control in self.controls: if type(control) == AttributionControl: control.prefix = "SEPAL" # specific drawing control self.set_drawing_controls(dc) # Add value inspector self.w_vinspector = widgets.Checkbox( value=False, description='Inspect values', indent=False, layout=widgets.Layout(width='18ex')) if vinspector: self.add_control( WidgetControl(widget=self.w_vinspector, position='topright')) link((self.w_vinspector, 'value'), (self, 'vinspector')) # Create output space for raster interaction self.output_r = widgets.Output(layout={'border': '1px solid black'}) self.output_control_r = WidgetControl(widget=self.output_r, position='bottomright') self.add_control(self.output_control_r) # define interaction with rasters self.on_interaction(self._raster_interaction)
def __init__(self, basemaps=[], add_google_map=None, **kwargs): """ Initialize Sepal Map. Args: basemap (str): Select one of the Sepal Base Maps available. """ basemap = dict( url='http://c.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png', max_zoom=20, attribution= '© <a href="http://www.openstreetmap.org/copyright">\ OpenStreetMap</a> © <a href="http://cartodb.com/attributions">\ CartoDB</a>', name='CartoDB.DarkMatter') basemap = basemap_to_tiles(basemap) if not add_google_map: add_google_map = False super().__init__(**kwargs, add_google_map=add_google_map, basemap=basemap) if basemaps: for basemap in basemaps: self.add_basemap(basemap) self.center = [0, 0] self.zoom = 2 super().clear_controls() self.add_control(ZoomControl(position='topright')) self.add_control(LayersControl(position='topright')) self.add_control(AttributionControl(position='bottomleft')) self.add_control(ScaleControl(position='bottomleft', imperial=False)) # Create output space for raster interaction output_r = widgets.Output(layout={'border': '1px solid black'}) output_control_r = WidgetControl(widget=output_r, position='bottomright') self.add_control(output_control_r) self.loaded_rasters = {} # Define a behavior when ispector checked and map clicked def raster_interaction(**kwargs): if kwargs.get('type') == 'click' and self.inspector_checked: latlon = kwargs.get('coordinates') self.default_style = {'cursor': 'wait'} local_rasters = [ lr.name for lr in self.layers if isinstance(lr, LocalTileLayer) ] if local_rasters: with output_r: output_r.clear_output(wait=True) for lr_name in local_rasters: lr = self.loaded_rasters[lr_name] lat, lon = latlon # Verify if the selected latlon is the image bounds if any([ lat < lr.bottom, lat > lr.top, lon < lr.left, lon > lr.right ]): print('Location out of raster bounds') else: #row in pixel coordinates y = int(((lr.top - lat) / abs(lr.y_res))) #column in pixel coordinates x = int(((lon - lr.left) / abs(lr.x_res))) #get height and width h, w = lr.data.shape value = lr.data[y][x] print(f'{lr_name}') print( f'Lat: {round(lat,4)}, Lon: {round(lon,4)}' ) print(f'x:{x}, y:{y}') print(f'Pixel value: {value}') else: with output_r: output_r.clear_output() self.default_style = {'cursor': 'crosshair'} self.on_interaction(raster_interaction)
def show_datasets( dss, mode='leaflet', dst=None, layer_name='Datasets', style={}, simplify=True, tolerance=0.001, # ~100m at equator **kw): """ Display dataset footprints on a Leaflet map. :param mode: leaflet|geojson, geojson only works in JupyterLab, leave it as default :param dst: leaflet map to "show" datasets on, default -- create new one :param layer_name: name to give to the layer :param style: GeoJSON style dictionary - weight - color/fillColor - opacity/fillOpacity - full list of options here: https://leafletjs.com/reference-1.5.0.html#path-option :param simplify: simplify geometries before adding them to map :param tolerance: tolerance in degrees for geometry simplification, default 0.001 ~ 111 meters at equator **kw: Arguments to pass to leaflet.Map(..) constructor """ if mode not in ('leaflet', 'geojson'): raise ValueError('Invalid value for mode, expected: leaflet|geojson') polygons, bbox = dss_to_geojson(dss, bbox=True, simplify=simplify, tolerance=tolerance) if mode == 'geojson': from IPython.display import GeoJSON return GeoJSON(polygons) if mode == 'leaflet': from ipyleaflet import Map, GeoJSON, FullScreenControl, LayersControl if dst is None: center = kw.pop('center', None) zoom = kw.pop('zoom', None) if center is None: center = (bbox.bottom + bbox.top) * 0.5, (bbox.right + bbox.left) * 0.5 if zoom is None: zoom = zoom_from_bbox(bbox) height = kw.pop('height', '600px') width = kw.pop('width', None) m = Map(center=center, zoom=zoom, **kw) m.layout.height = height m.layout.width = width m.add_control(FullScreenControl()) m.add_control(LayersControl()) else: m = dst gg = GeoJSON(data={ 'type': 'FeatureCollection', 'features': polygons }, style=style, hover_style={'color': 'tomato'}, name=layer_name) m.add_layer(gg) if dst is None: return m else: return gg
def draw_map(lat_ext=None, lon_ext=None): """ Description: Create an empty map with a blue rectangle of given <lat_ext>, <lon_ext> to be used to manually draw a polygon or rectangle ----- Input: lat_ext: latitude extent lon_ext: longitude extent Output: m: empty map ti interact with dc: draw control Usage: Draw a polygon or a rectangle """ # check options combination assert not((lat_ext is None) or (lon_ext is None)), \ 'lat_ext and lon_ext are required' assert lat_ext[0] < lat_ext[1], 'lat_ext values are in the wrong order' assert lon_ext[0] < lon_ext[1], 'lon_ext values are in the wrong order' # Location center = [np.mean(lat_ext), np.mean(lon_ext)] # source: https://sdc.unepgrid.ch:8080/edit/utils/data_cube_utilities/dc_display_map.py margin = -0.5 zoom_bias = 0 lat_zoom_level = _degree_to_zoom_level(margin=margin, *lat_ext) + zoom_bias lon_zoom_level = _degree_to_zoom_level(margin=margin, *lon_ext) + zoom_bias zoom = min(lat_zoom_level, lon_zoom_level) m = Map(center=center, zoom=zoom, scroll_wheel_zoom=True) # Layers # http://leaflet-extras.github.io/leaflet-providers/preview/ esri = basemap_to_tiles(basemaps.Esri.WorldImagery) m.add_layer(esri) terrain = basemap_to_tiles(basemaps.Stamen.Terrain) m.add_layer(terrain) mapnik = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik) m.add_layer(mapnik) rectangle = Rectangle(bounds=((lat_ext[0], lon_ext[0]), (lat_ext[1], lon_ext[1])), color='red', weight=2, fill=False) m.add_layer(rectangle) m.add_control(LayersControl()) # Controls dc = DrawControl(rectangle={'shapeOptions': { 'color': '#0000FF' }}, polygon={'shapeOptions': { 'color': '#0000FF' }}, marker={}, polyline={}, circle={}, circlemarker={}) m.add_control(dc) return m, dc
def __init__(self): self.out = widgets.Output(layout={'border': '1px solid black'}) self.iceflow = IceflowClient() self.last_orders = None self.current_projection = 'north' self.clear = True self.controls = [] self.credentials = None self.start_date = datetime(1993, 1, 1) self.end_date = datetime.now() slider_dates = [(date.strftime(' %Y-%m-%d '), date) for date in pd.date_range(datetime(1993, 1, 1), datetime.now(), freq='D')] slider_index = (0, len(slider_dates) - 1) self.username = widgets.Text( value='', description='User:'******'Your NASA EarthData username ', disabled=False ) self.password = widgets.Password( value='', placeholder='Enter password', description='Password:'******'', description='Email:', placeholder='Your EarthData e-mail', disabled=False ) self.credentials_button = widgets.Button(description='Set Credentials', ) self.projection = widgets.Dropdown( options=['global', 'south', 'north'], description='Hemisphere:', disabled=False, value='north' ) self.dataset = widgets.SelectMultiple( options=['ATM1B', 'GLAH06', 'ILVIS2'], value=['ATM1B'], rows=4, description='Datasets', disabled=False ) self.itrf = widgets.Dropdown( options=[None, 'ITRF2000', 'ITRF2008', 'ITRF2014'], disabled=False, description='ITRF:', layout={'width': 'max-content', 'display': 'flex', 'description_width': 'initial'} ) self.epoch = widgets.Text( value='', description='Epoch:', placeholder='i.e. 2008.1', disabled=False ) self.is2 = widgets.Dropdown( options=['None', 'ATL03', 'ATL06', 'ATL07', 'ATL08'], description='ICESat 2:', disabled=False, ) self.dates_range = widgets.SelectionRangeSlider( options=slider_dates, index=slider_index, continuous_update=False, description='Date Range', orientation='horizontal', layout={'width': '90%'}) self.granule_count = widgets.Button(description="Get Raw Granule Count", display='flex', flex_flow='column', align_items='stretch', ) self.granule_count.style.button_color = 'lightgreen' self.granule_count.layout.width = 'auto' self.print_parameters = widgets.Button(description="Print Current Parameters", display='flex', flex_flow='column', align_items='stretch', ) self.print_parameters.style.button_color = 'lightgreen' self.print_parameters.layout.width = 'auto' self.post_order = widgets.Button(description="Place Data Order", display='flex', flex_flow='column', align_items='stretch', ) self.post_order.style.button_color = 'lightblue' self.post_order.layout.width = 'auto' self.check_order_status = widgets.Button(description="Order status", display='flex', flex_flow='column', align_items='stretch', ) self.check_order_status.style.button_color = 'lightblue' self.check_order_status.layout.width = 'auto' self.download_button = widgets.Button(description="Download completed orders", display='flex', flex_flow='column', align_items='stretch', ) self.download_button.style.button_color = 'lightblue' self.download_button.layout.width = 'auto' self.selection_buttons = widgets.HBox([self.granule_count, self.print_parameters, self.post_order, self.check_order_status, self.download_button]) self.selection_controls = widgets.VBox([self.projection, self.dataset, self.itrf, self.epoch, self.is2, self.dates_range, self.selection_buttons]) self.controls.append(self.selection_controls) self.layers_control = LayersControl(position='topright') # Map Components place_marker = Marker(icon=AwesomeIcon(name="check", marker_color='green', icon_color='darkgreen')) self.search_control = SearchControl( position="topleft", url='https://nominatim.openstreetmap.org/search?format=json&q={s}', zoom=5, marker=place_marker ) self.dc = DrawControl( circlemarker={}, polyline={}, rectangle={ "shapeOptions": { "fillColor": "#cc00cc", "color": "#cc00cc", "fillOpacity": 0.5 } }) self.file_upload = widgets.FileUpload( accept='.json,.geojson,.shp', multiple=False # True to accept multiple files upload else False ) # Now we are going to link the controls to the relevant events self.dates_range.observe(self.dates_changed, 'value') self.projection.observe(self.hemisphere_change) self.credentials_button.on_click(self.set_credentials) self.granule_count.on_click(self.query_cmr) self.print_parameters.on_click(self.get_parameters) self.post_order.on_click(self.place_data_orders) self.check_order_status.on_click(self.order_statuses) self.download_button.on_click(self.download_orders)
layer_type='marker', filter_on='document', color='red') well_layer_no_docs = create_layer(wells, 'wells with docs', label_col='wlbWell', secondary_label_col='document', layer_type='marker', filter_on='document', inverse=True, color='lightGray') marker_cluster = MarkerCluster(markers=well_layer.layers, name='Wells with Docs') marker_cluster2 = MarkerCluster(markers=well_layer_no_docs.layers, name='Wells without Docs') # marker_cluster.add_layer(well_layer) m.add_layer(structure_layer_docs) m.add_layer(structure_layer) m.add_layer(fields_layer_docs) m.add_layer(fields_layer) m.add_layer(subareas_layer) m.add_layer(subareas_layer_docs) m.add_layer(facilities_layer_docs) m.add_layer(facilities_layer) m.add_layer(discoveries_layer_docs) m.add_layer(discoveries_layer) m.add_layer(marker_cluster) m.add_layer(marker_cluster2) m.add_control(LayersControl()) m.add_control(FullScreenControl()) comments = [] for i in check_cols: comments.append(create_layer(final_dataframe[final_dataframe[i] != "Empty"], i, label_col='wlbWellbor', secondary_label_col=i, layer_type='marker', color='green')) m.add_layer(comments[-1]) m
def plot_routing_product_with_ipyleaflet(path_to_product_folder, version_number=''): product_folder = path_to_product_folder if version_number != '': version_number = '_' + version_number path_subbasin = os.path.join(product_folder, 'finalcat_info' + version_number + '.shp') path_river = os.path.join(product_folder, 'finalcat_info_riv' + version_number + '.shp') path_cllake = os.path.join(product_folder, 'sl_connected_lake' + version_number + '.shp') path_ncllake = os.path.join( product_folder, 'sl_non_connected_lake' + version_number + '.shp') subbasin = geopandas.read_file(path_subbasin) river = geopandas.read_file(path_river) subbasin = subbasin.to_crs("EPSG:4326") river = river.to_crs("EPSG:4326") if os.path.exists(path_cllake): cllake = geopandas.read_file(path_cllake) cllake = cllake.to_crs("EPSG:4326") if os.path.exists(path_ncllake): ncllake = geopandas.read_file(path_ncllake) ncllake = ncllake.to_crs("EPSG:4326") cx = subbasin['centroid_x'].mean() cy = subbasin['centroid_y'].mean() m = Map(center=(cy, cx), zoom=9, basemap=basemaps.Esri.WorldTopoMap) subnolake = subbasin[subbasin['Lake_Cat'] == 0].copy(deep=True) sub_nolake_map = GeoData(geo_dataframe=subnolake, style={ 'color': '#6E6E6E', 'fillColor': '#89CD66', 'opacity': 1, 'weight': 1, 'dashArray': '2', 'fillOpacity': 1 }, name='Subbasin without lakes') subcllake = subbasin[subbasin['Lake_Cat'] == 1].copy(deep=True) if len(subcllake) > 0: sub_cllake_map = GeoData(geo_dataframe=subcllake, style={ 'color': '#6E6E6E', 'fillColor': '#CDE389', 'opacity': 1, 'weight': 1, 'dashArray': '2', 'fillOpacity': 1 }, name='Subbasin with connected lakes') subncllake = subbasin[subbasin['Lake_Cat'] == 2].copy(deep=True) if len(subncllake) > 0: sub_ncllake_map = GeoData(geo_dataframe=subncllake, style={ 'color': '#6E6E6E', 'fillColor': '#F5F57A', 'opacity': 1, 'weight': 1, 'dashArray': '2', 'fillOpacity': 1 }, name='Subbasin with connected lakes') river_map = GeoData(geo_dataframe=river, style={ 'color': '#0070FF', 'fillColor': '#0070FF', 'opacity': 1, 'weight': 2, 'dashArray': '2', 'fillOpacity': 1 }, name='River') if os.path.exists(path_cllake): cllake_map = GeoData(geo_dataframe=cllake, style={ 'color': '#6E6E6E', 'fillColor': '#0070FF', 'opacity': 1, 'weight': 1, 'dashArray': '2', 'fillOpacity': 1 }, name='Non connected lakes') if os.path.exists(path_ncllake): ncllake_map = GeoData(geo_dataframe=ncllake, style={ 'color': '#6E6E6E', 'fillColor': '#0070FF', 'opacity': 0, 'weight': 1, 'dashArray': '2', 'fillOpacity': 1 }, name='Connected lakes') m.add_layer(sub_nolake_map) if len(subcllake) > 0: m.add_layer(sub_cllake_map) if len(subncllake) > 0: m.add_layer(sub_ncllake_map) m.add_layer(river_map) if os.path.exists(path_cllake): m.add_layer(cllake_map) if os.path.exists(path_ncllake): m.add_layer(ncllake_map) m.add_control(LayersControl()) m.layout.height = "700px" return m
def __init__(self, **kwargs): if "center" not in kwargs: kwargs["center"] = [40, -100] if "zoom" not in kwargs: kwargs["zoom"] = 4 if "scroll_wheel_zoom" not in kwargs: kwargs["scroll_wheel_zoom"] = True super().__init__(**kwargs) if "height" not in kwargs: self.layout.height = "600px" else: self.layout.height = kwargs["height"] self.add_control(FullScreenControl()) self.add_control(LayersControl(position="topright")) self.add_control(DrawControl(position="topleft")) self.add_control(MeasureControl()) self.add_control(ScaleControl(position="bottomleft")) self.toolbar = None # tools = { # "folder-open": { # "name": "open_data", # "tooltip": "Open local vector/raster data" # }, # "map": { # "name": "basemap", # "tooltip": "Change basemap" # }, # "gears": { # "name": "whitebox", # "tooltip": "WhiteboxTools for local geoprocessing" # }, # "filter": { # "name": "query", # "tooltip": "Attribute selection" # }, # } # icons = list(tools.keys()) # tooltips = [item["tooltip"] for item in list(tools.values())] # icon_width = "32px" # icon_height = "32px" # n_cols = 3 # n_rows = math.ceil(len(icons) / n_cols) # toolbar_grid = ipywidgets.GridBox( # children=[ # ipywidgets.ToggleButton( # layout=ipywidgets.Layout( # width="auto", height="auto", padding="0px 0px 0px 4px" # ), # button_style="primary", # icon=icons[i], # tooltip=tooltips[i], # ) # for i in range(len(icons)) # ], # layout=ipywidgets.Layout( # width="107px", # grid_template_columns=(icon_width + " ") * n_cols, # grid_template_rows=(icon_height + " ") * n_rows, # grid_gap="1px 1px", # padding="5px", # ), # ) # self.toolbar = toolbar_grid if "google_map" not in kwargs: layer = TileLayer( url="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", attribution="Google", name="Google Maps", ) self.add_layer(layer) else: if kwargs["google_map"] == "ROADMAP": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}", attribution="Google", name="Google Maps", ) self.add_layer(layer) elif kwargs["google_map"] == "HYBRID": layer = TileLayer( url="https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}", attribution="Google", name="Google Satellite") self.add_layer(layer) if "basemap" not in kwargs: layer = basemap_to_tiles(basemaps.OpenStreetMap.Mapnik) self.add_layer(layer) else: layer = basemap_to_tiles(kwargs["basemap"]) self.add_layer(layer) main_toolbar(self)