def xyz_to_leaflet(): """Convert xyz tile services to ipyleaflet tile layers. Returns: dict: A dictionary of ipyleaflet tile layers. """ leaflet_dict = {} for key in xyz_tiles: name = xyz_tiles[key]["name"] url = xyz_tiles[key]["url"] attribution = xyz_tiles[key]["attribution"] leaflet_dict[key] = ipyleaflet.TileLayer(url=url, name=name, attribution=attribution, max_zoom=22) for key in wms_tiles: name = wms_tiles[key]["name"] url = wms_tiles[key]["url"] layers = wms_tiles[key]["layers"] fmt = wms_tiles[key]["format"] transparent = wms_tiles[key]["transparent"] attribution = wms_tiles[key]["attribution"] leaflet_dict[key] = ipyleaflet.WMSLayer( url=url, layers=layers, name=name, attribution=attribution, format=fmt, transparent=transparent, ) xyz_dict = get_xyz_dict() for item in xyz_dict: name = xyz_dict[item].name url = xyz_dict[item].build_url() attribution = xyz_dict[item].attribution if "max_zoom" in xyz_dict[item].keys(): max_zoom = xyz_dict[item]["max_zoom"] else: max_zoom = 22 leaflet_dict[name] = ipyleaflet.TileLayer(url=url, name=name, max_zoom=max_zoom, attribution=attribution) if os.environ.get("PLANET_API_KEY") is not None: planet_dict = planet_tiles(tile_format="ipyleaflet") leaflet_dict.update(planet_dict) return leaflet_dict
def add_tile_layer( self, url='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', name=None, attribution='', opacity=1.0, shown=True): """Adds a TileLayer to the map. Args: url (str, optional): The URL of the tile layer. Defaults to 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'. name (str, optional): The layer name to use for the layer. Defaults to None. attribution (str, optional): The attribution to use. Defaults to ''. opacity (float, optional): The opacity of the layer. Defaults to 1. shown (bool, optional): A flag indicating whether the layer should be on by default. Defaults to True. """ try: tile_layer = ipyleaflet.TileLayer(url=url, name=name, attribution=attribution, opacity=opacity, visible=shown) self.add_layer(tile_layer) except: print("Failed to add the specified TileLayer.")
def create(self): ''' create layer and throw on the map ''' url = self.get_url() self.map_layer = ipyl.TileLayer(url=url, name=self.name) self.map.add_layer(self.map_layer)
def display_composite_ipyleaflet(self, zoom=10): image = self.image.clip(ee.Geometry(self.polygon)) mapid = image.getMapId() tiles_url = self.ee_tiles.format(**mapid) tile_layer = ipyl.TileLayer(url=tiles_url, layers='collection', format='image/png', name=self.collection, opacity=1) polygon = ipyl.Polygon(locations=self.locations, color=self.color, fill_opacity=0., name='AoI') m = ipyl.Map(center=tuple(self.centroid), zoom=zoom) m.add_layer(tile_layer) m.add_layer(polygon) control = ipyl.LayersControl(position='topright') m.add_control(control) m.add_control(ipyl.FullScreenControl()) return m
def addFeatureLayer(self, feature, visParams=None, name=None, show=True, opacity=None, replace=True): """ Paint a Feature on the map, but the layer underneath is the actual added Feature """ visParams = visParams if visParams else {} if isinstance(feature, ee.Feature): ty = 'Feature' elif isinstance(feature, ee.FeatureCollection): ty = 'FeatureCollection' else: print('The object is not a Feature or FeatureCollection') return fill_color = visParams.get('fill_color', None) if 'outline_color' in visParams: out_color = visParams['outline_color'] elif 'border_color' in visParams: out_color = visParams['border_color'] else: out_color = 'black' outline = visParams.get('outline', 2) proxy_layer = paint(feature, out_color, fill_color, outline) thename = name if name else '{} {}'.format(ty, self.addedGeometries) img_params = {'bands':['vis-red', 'vis-green', 'vis-blue'], 'min': 0, 'max':255} # Check if layer exists if thename in self.EELayers.keys(): if not replace: print("{} with name '{}' exists already, please choose another name".format(ty, thename)) return else: # Get URL, attribution & vis params params = getImageTile(proxy_layer, img_params, show, opacity) # Remove Layer self.removeLayer(thename) else: # Get URL, attribution & vis params params = getImageTile(proxy_layer, img_params, show, opacity) layer = ipyleaflet.TileLayer(url=params['url'], attribution=params['attribution'], name=thename) self._add_EELayer(thename, {'type': ty, 'object': feature, 'visParams': visParams, 'layer': layer}) return thename
def click_event(target, m, current_band, df, sample_col, stretch_min, stretch_max, b1, b2, b3): pt_index = target['data']['index'] image_id = df['id'].values[pt_index] selected_image = ee.Image(sample_col.filterMetadata('system:index', 'equals', image_id).first()) tile_url = utils.GetTileLayerUrl(selected_image.visualize(min=stretch_min, max=stretch_max, bands= [b1, b2, b3])) m.add_layer(ipyleaflet.TileLayer(url=tile_url, name=image_id))
def qms_to_geemap(service_id): service_details = get_qms(service_id) name = service_details["name"] url = service_details["url"] attribution = service_details["copyright_text"] layer = ipyleaflet.TileLayer(url=url, name=name, attribution=attribution) return layer
def add_ee_layer(self, ee_object, vis_params={}, name=None, shown=True, opacity=1.0): """Adds a given EE object to the map as a layer. Args: ee_object (Collection|Feature|Image|MapId): The object to add to the map. vis_params (dict, optional): The visualization parameters. Defaults to {}. name (str, optional): The name of the layer. Defaults to 'Layer N'. shown (bool, optional): A flag indicating whether the layer should be on by default. Defaults to True. opacity (float, optional): The layer's opacity represented as a number between 0 and 1. Defaults to 1. """ image = None if name is None: layer_count = len(self.layers) name = 'Layer ' + str(layer_count + 1) if not isinstance(ee_object, ee.Image) and not isinstance(ee_object, ee.ImageCollection) and not isinstance(ee_object, ee.FeatureCollection) and not isinstance(ee_object, ee.Feature) and not isinstance(ee_object, ee.Geometry): err_str = "\n\nThe image argument in 'addLayer' function must be an instace of one of ee.Image, ee.Geometry, ee.Feature or ee.FeatureCollection." raise AttributeError(err_str) if isinstance(ee_object, ee.geometry.Geometry) or isinstance(ee_object, ee.feature.Feature) or isinstance(ee_object, ee.featurecollection.FeatureCollection): features = ee.FeatureCollection(ee_object) width = 2 if 'width' in vis_params: width = vis_params['width'] color = '000000' if 'color' in vis_params: color = vis_params['color'] image_fill = features.style( **{'fillColor': color}).updateMask(ee.Image.constant(0.5)) image_outline = features.style( **{'color': color, 'fillColor': '00000000', 'width': width}) image = image_fill.blend(image_outline) elif isinstance(ee_object, ee.image.Image): image = ee_object elif isinstance(ee_object, ee.imagecollection.ImageCollection): image = ee_object.mosaic() map_id_dict = ee.Image(image).getMapId(vis_params) tile_layer = ipyleaflet.TileLayer( url=map_id_dict['tile_fetcher'].url_format, attribution='Google Earth Engine', name=name, opacity=opacity, visible=shown ) self.ee_layers.append(ee_object) self.ee_layer_names.append(name) self.add_layer(tile_layer)
def addImage(self, image, visParams=None, name=None, show=True, opacity=None, replace=True): """ Add an ee.Image to the Map :param image: Image to add to Map :type image: ee.Image :param visParams: visualization parameters. Can have the following arguments: bands, min, max. :type visParams: dict :param name: name for the layer :type name: str :return: the name of the added layer :rtype: str """ # Check if layer exists if name in self.EELayers.keys(): if not replace: return self.getLayer(name) else: # Get URL, attribution & vis params params = getImageTile(image, visParams, show, opacity) # Remove Layer self.removeLayer(name) else: # Get URL, attribution & vis params params = getImageTile(image, visParams, show, opacity) layer = ipyleaflet.TileLayer(url=params['url'], attribution=params['attribution'], name=name) EELayer = { 'type': 'Image', 'object': image, 'visParams': params['visParams'], 'layer': layer } # self._add_EELayer(name, EELayer) # return name return EELayer
def click_event(self, target): pt_index = target['data']['index'] current_band = Plot_interface.band_list[Plot_interface.band_index1] image_id = Plot_interface.sample_df['id'].values[pt_index] selected_image = ee.Image( Plot_interface.sample_col.filterMetadata('system:index', 'equals', image_id).first()) tile_url = GetTileLayerUrl( selected_image.visualize(min=Plot_interface.stretch_min.value, max=Plot_interface.stretch_max.value, bands=[ Plot_interface.b1, Plot_interface.b2, Plot_interface.b3 ])) Plot_interface.m.add_layer( ipyleaflet.TileLayer(url=tile_url, name=image_id))
def click_event2(self, target): pt_index = target['data']['index'] current_band = Plot_interface.band_list[Plot_interface.band_index2] #Find clicked image. .values needed to access the nth element of that list instead of indexing by ID image_id = Plot_interface.click_df['id'].values[pt_index] selected_image = ee.Image( Plot_interface.click_col.filterMetadata('system:index', 'equals', image_id).first()) tile_url = GetTileLayerUrl( selected_image.visualize(min=Plot_interface.minv, max=Plot_interface.maxv, bands=[ Plot_interface.b1, Plot_interface.b2, Plot_interface.b3 ])) Plot_interface.m.add_layer( ipyleaflet.TileLayer(url=tile_url, name=image_id))
def addImage(image, name): # Check if layer exists if name in self.EELayers.keys(): print("Layer with name {} exists already, please choose" + "another name".format(name)) return params = get_image_tile(image, visParams, show, opacity) layer = ipyleaflet.TileLayer(url=params['url'], attribution=params['attribution'], name=name) self.add_layer(layer) self.EELayers[name] = { 'type': 'Image', 'object': image, 'visParams': visParams, 'layer': layer } return layer
def add_ee_layer(self, raw_img, vis=None, **kwargs): """Add a EE layer to the map. Parameters ---------- raw_img : ee.image.Image Image without visualisation parameters. vis : dict Visualisation parameters. Default is None. **kwargs : Extra parameters for ipyleaflet.TileLayer. """ if vis is not None: img = raw_img.visualize(**vis) else: img = raw_img self.add_layer( ipyleaflet.TileLayer(url=self._get_tileLayer_url(img), **kwargs)) self.ee_layers.append(raw_img)
def addBasemap(self, name, url, **kwargs): """ Add a basemap with the given URL """ layer = ipyleaflet.TileLayer(url=url, name=name, base=True, **kwargs) self.add_layer(layer)
def add_to_map( arr: xr.DataArray, map: ipyleaflet.Map, name: Optional[str] = None, range: Optional[Range] = None, cmap: Optional[Union[str, matplotlib.colors.Colormap]] = None, checkerboard: bool = True, interpolation: Literal["linear", "nearest"] = "linear", ) -> ipyleaflet.Layer: """ Add the `~xarray.DataArray` to an ipyleaflet :doc:`api_reference/map` as a new layer or replacing an existing one. By giving a name, you can change and re-run notebook cells without piling up extraneous layers on your map. As you pan around the map, the part of the array that's in view is computed on the fly by dask. This requires using a :doc:`dask distributed <distributed:index>` cluster. Parameters ---------- arr: `~xarray.DataArray` to visualize. Must have ``x`` and ``y``, and optionally ``band`` dims, and the ``epsg`` coordinate set. ``arr`` must have 1-3 bands. Single-band data can be colormapped; multi-band data will be displayed as RGB. For 2-band arrays, the first band will be duplicated into the third band's spot, then shown as RGB. map: ipyleaflet :doc:`api_reference/map` to show the array on. name: str Name of the layer. If there's already a layer with this name on the map, its URL will be updated. Otherwise, a new layer is added. If None (default), ``arr.name`` is used as the name. If a layer with this name already exists, it will be replaced. range: Min and max values in ``arr`` which will become black (0) and white (255) in the visualization. If None (default), it will automatically use the 2nd/98th percentile values of the *entire array* (unless it's a boolean array; then we just use 0-1). For large arrays, this can be very slow and expensive, and slow down tile rendering a lot, so passing an explicit range is usually a good idea. cmap: Colormap to use for single-band data. Can be a :doc:`matplotlib colormap name <gallery/color/colormap_reference>` as a string, or a `~matplotlib.colors.Colormap` object for custom colormapping. If None (default), the default matplotlib colormap (usually ``viridis``) will automatically be used for 1-band data. Setting a colormap for multi-band data is an error. checkerboard: Whether to show a checkerboard pattern for missing data (default), or leave it fully transparent. Note that only NaN is considered a missing value; any custom fill value should be converted to NaN before visualizing. interpolation: Interpolation method to use while reprojecting: ``"linear"`` or ``"nearest"`` (default ``"linear"``). Use ``"linear"`` for continuous data, such as imagery, SAR, DEMs, weather data, etc. Use ``"nearest"`` for discrete/categorical data, such as classification maps. Returns ------- ipyleaflet.Layer: The new or existing layer for visualizing this array. """ if name is None: name = str(arr.name) for lyr in map.layers: if lyr.name == name: break else: lyr = ipyleaflet.TileLayer(name=name, url="") map.add_layer(lyr) register( arr, map=map, layer=lyr, range=range, cmap=cmap, checkerboard=checkerboard, interpolation=interpolation, ) return lyr