def exportWithoutDate(layer, vizParams, output_name): if clipper != None: layer = clip_mask(layer) try: Map.centerObject(layer, 8) except: pass #Map.addLayer(layer, vizParams, '{}_{}'.format(prefix, output_name)) export(layer, "{}_{}".format(prefix, output_name))
def help_calculate(filter_data, date, vizParams, output_name, expression): data = filter_data if expression != None: layer = eval(expression) else: layer = data if clipper != None: layer = clip_mask(layer) try: Map.centerObject(layer, 8) except: pass #Map.addLayer(layer, vizParams, '{}_{}_{}'.format(prefix, date, output_name)) export(layer, "{}_{}_{}".format(prefix, date, output_name))
return image.addBands(ndvi).addBands(mndwi).addBands(evi).addBands(lswi) # Map the function over one year of data. L8sr = ee.ImageCollection('LANDSAT/LC08/C01/T1_SR') \ .filterDate('2019-01-01', '2019-12-31') \ .filter(ee.Filter.lt("CLOUD_COVER", 30)) \ .map(maskL8sr) L8sr = L8sr.median().clip(ThaiBinh) # Compute multiple indices L8col = compute_indices(L8sr) print(L8col) # Display the results. Map.centerObject(ThaiBinh, 9) Map.addLayer(L8sr, {'bands': ['B4', 'B3', 'B2'], 'min': 0, 'max': 0.3}) # Map.addLayer(image, imageVisParam, 'True colour image') classNames = Mangrove.merge(Shrimp).merge(Residence).merge(Water).merge( Agriculture).merge(Other).merge(Evergreen) #print(classNames) bands = L8col.bandNames() training = L8col.select(bands).sampleRegions({ 'collection': classNames, 'properties': ['landcover'], 'scale': 30 }) #print(training) classifier = ee.Classifier.randomForest(100).train({ 'features': training,
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Filter/filter_string_starts_with.py import ee from ee_plugin import Map states = ee.FeatureCollection('TIGER/2018/States') # Select states its name starting with 'Al' selected = states.filter(ee.Filter.stringStartsWith('NAME', 'Al')) Map.centerObject(selected, 6) Map.addLayer(ee.Image().paint(selected, 0, 2), {'palette': 'yellow'}, 'Selected')
import ee from ee_plugin import Map #Filtrar por Pais coleccionLimites = ee.FeatureCollection("USDOS/LSIB/2017") filtropais = coleccionLimites.filter(ee.Filter.eq('COUNTRY_NA', 'Mexico')) Map.centerObject(filtropais,6) #Importar Coleccion SENTINEL 5P sentinel5P = ee.ImageCollection("COPERNICUS/S5P/NRTI/L3_NO2") #Obtener Concentracion de NO2 NO2 = sentinel5P.filterDate("2019-08-01","2019-08-30").select("NO2_column_number_density")\ .max().clip( filtropais) Map.addLayer(NO2,{'min':0,'max':0.0002,'palette':['black', 'blue', 'purple', 'cyan', 'green', 'yellow', 'red']},"NO2")
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Visualization/landsat_symbology.py import ee from ee_plugin import Map geometry = ee.Geometry.Point([-122.30287513732901, 37.441115780341605]) landsat = ee.ImageCollection("LANDSAT/LC08/C01/T1") \ .filterDate('2016-01-01', '2017-01-01') \ .filterBounds(geometry) composite = ee.Algorithms.Landsat.simpleComposite(**{ 'collection': landsat, 'asFloat': True }) rgbVis = {'bands': ["B4", "B3", "B2"], 'min': 0, 'max': 0.3} nirVis = {'bands': ["B5", "B4", "B3"], 'min': 0, 'max': [0.5, 0.3, 0.3]} tempVis = { 'bands': ["B10"], 'min': 280, 'max': 310, 'palette': ["blue", "red", "orange", "yellow"] } Map.addLayer(composite, rgbVis, "RGB") Map.addLayer(composite, nirVis, "False Color") Map.addLayer(composite, tempVis, "Thermal") Map.centerObject(ee.FeatureCollection(geometry), 10)
waterSurface = ee.Image('JRC/GSW1_0/GlobalSurfaceWater') waterChange = waterSurface.select('transition') # Select Permanent Water Only: Permanent_Water = 1 # value 1 represents pixels of permenant water, no change waterMask = waterChange.eq( Permanent_Water) # Water mask boolean = 1 to detect whater bodies # Map.setCenter(24.43874, 61.58173, 10) # Map.addLayer(waterMask, {}, 'Water Mask') # Map.centerObject(masked) OnlyLakes = waterMask.updateMask(waterMask) roi = ee.Geometry.Polygon([[[22.049560546875, 61.171214253920965], [22.0330810546875, 60.833021871926185], [22.57415771484375, 60.83168327936567], [22.5714111328125, 61.171214253920965]]]) classes = OnlyLakes.reduceToVectors( **{ 'reducer': ee.Reducer.countEvery(), 'geometry': roi, 'scale': 30, 'maxPixels': 1e10 }) simpleClasses = classes.geometry().simplify(50) Map.centerObject(ee.FeatureCollection(roi), 10) Map.addLayer(ee.Image().paint(classes, 0, 2), {'palette': 'red'}, "original") Map.addLayer(ee.Image().paint(simpleClasses, 0, 2), {'palette': 'blue'}, "simplified")
import ee from ee_plugin import Map geometry = ee.Geometry.Point([5.7788, 52.7005]) # Get the VV collection. collectionVV = ee.ImageCollection('COPERNICUS/S1_GRD') \ .filter(ee.Filter.eq('instrumentMode', 'IW')) \ .filter(ee.Filter.listContains('transmitterReceiverPolarisation', 'VV')) \ .filter(ee.Filter.eq('orbitProperties_pass', 'DESCENDING')) \ .select(['VV']) # Create a 3 band stack by selecting from different periods (months) im1 = ee.Image(collectionVV.filterDate('2016-04-01', '2016-05-30').mean()) im2 = ee.Image(collectionVV.filterDate('2016-06-01', '2016-08-31').mean()) im3 = ee.Image(collectionVV.filterDate('2016-09-01', '2016-11-30').mean()) Map.centerObject(geometry, 13) Map.addLayer(im1.addBands(im2).addBands(im3), {'min': -25, 'max': 0}, 'VV stack') # Get the VH collection. collectionVH = ee.ImageCollection('COPERNICUS/S1_GRD') \ .filter(ee.Filter.eq('instrumentMode', 'IW')) \ .filter(ee.Filter.listContains('transmitterReceiverPolarisation', 'VH')) \ .select(['VH']) # Collection max. Zoom to Shanghai for an interesting visualization. Map.addLayer(collectionVH.max(), {'min': -25, 'max': 0}, 'max value', False)
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/FeatureCollection/select_by_strings.py import ee from ee_plugin import Map #!/usr/bin/env python """Select by strings """ # Select states with "A" in its name fc = ee.FeatureCollection('TIGER/2018/States') \ .filter(ee.Filter.stringContains('STUSPS', 'A')) image = ee.Image().paint(fc, 0, 2) Map.centerObject(fc, 6) Map.addLayer(image, {'palette': 'FF0000'}, '*A*') # Select states its name starting with 'A' fc = ee.FeatureCollection('TIGER/2018/States') \ .filter(ee.Filter.stringStartsWith('STUSPS', 'A')) image = ee.Image().paint(fc, 0, 2) Map.addLayer(image, {'palette': '0000FF'}, 'A*')
import ee from ee_plugin import Map # Load and display a Landsat TOA image. image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20140318') Map.addLayer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 0.3}, 'Landsat 8') # Create an arbitrary rectangle as a region and display it. region = ee.Geometry.Rectangle(-122.2806, 37.1209, -122.0554, 37.2413) Map.centerObject(ee.FeatureCollection(region), 13) Map.addLayer(ee.Image().paint(region, 0, 2), {}, 'Region') # Get a dictionary of means in the region. Keys are bandnames. mean = image.reduceRegion(**{ 'reducer': ee.Reducer.mean(), 'geometry': region, 'scale': 30 }) print(mean.getInfo())
def run(self): """Run method that performs all the real work""" #ee.Initialize() # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = Sentinel2DownloadDialog() # Add base map base_map = QgsProject.instance().mapLayersByName('Google Satellite') if len(base_map) == 0: urlWithParams = 'type=xyz&url=https://mt1.google.com/vt/lyrs%3Ds%26x%3D%7Bx%7D%26y%3D%7By%7D%26z%3D%7Bz%7D&zmax=19&zmin=0' rlayer = QgsRasterLayer(urlWithParams, 'Google Satellite', 'wms') if rlayer.isValid(): QgsProject.instance().addMapLayer(rlayer) else: self.iface.messageBar().pushMessage( "Không mở được bản đồ nền!", level=Qgis.Success, duration=5) self.laydanhsachtinh() self.dlg.comboTinh.currentIndexChanged.connect(self.laydanhsachhuyen) self.dlg.comboHuyen.currentIndexChanged.connect(self.laydanhsachxa) self.tohopmau() self.dlg.show() result = self.dlg.exec_() if result: #Get date batdau = self.dlg.dateBdau.date() ketthuc = self.dlg.dateKthuc.date() bd_date = str(batdau) kt_date = str(ketthuc) # Get info tinhchon = self.dlg.comboTinh.currentText() huyenchon = self.dlg.comboHuyen.currentText() xachon = self.dlg.comboXa.currentText() mtinh = int(self.laymacode()['tcode']) mhuyen = int(self.laymacode()['hcode']) mxa = int(self.laymacode()['xcode']) may = int(self.dlg.inputMay.text()) khoang = int(self.dlg.inputKhoang.text()) ngayBatdau = str(self.layngay(bd_date)) ngayKetthuc = str(self.layngay(kt_date)) hcxvn = ee.FeatureCollection("users/nguyenvanthi/RGX_WGS84") commune = hcxvn.filter(ee.Filter(ee.Filter.eq('MATINH', mtinh))) \ .filter(ee.Filter(ee.Filter.eq('MAHUYEN', mhuyen))) \ .filter(ee.Filter(ee.Filter.eq('MAXA', mxa))) #Get buffer sbuffer = int(self.dlg.inputBuffer.text()) if sbuffer == 0: commune_buffered = commune else: commune_buffered = commune.geometry().buffer(sbuffer) #Band combinations rgbMethod = self.dlg.comboRGB.currentIndex() if rgbMethod == 0: bands = ['B4', 'B3', 'B2'] # Natural Color elif rgbMethod == 1: bands = ['B8', 'B4', 'B3'] # Color Infrared elif rgbMethod == 2: bands = ['B12', 'B8A', 'B4'] # Short-wave Infrared elif rgbMethod == 3: bands = ['B11', 'B8', 'B2'] # Agriculture elif rgbMethod == 4: bands = ['B12', 'B11', 'B2'] # Geology else: bands = ['B4', 'B3', 'B1'] # Bathymetric S2_Collection = ee.ImageCollection("COPERNICUS/S2") \ .filterDate(ngayBatdau, ngayKetthuc).select(bands) \ .filterBounds(commune_buffered) \ .filterMetadata('CLOUDY_PIXEL_PERCENTAGE', "less_than", may) \ .sort('CLOUD_COVERAGE_ASSESSMENT', True) #Get the first image in the collection S2 = S2_Collection.first() vizParams = { 'bands': bands, 'min': 0, 'max': 2000, 'gamma': 0.8 } image_date1 = ee.Date( S2.get('system:time_start')).format('Y-M-d').getInfo() soluonganh = S2_Collection.size().getInfo() tmp = self.khoangngay(image_date1, khoang) S22 = ee.ImageCollection("COPERNICUS/S2").filterDate(tmp['bd'], tmp['kt']) \ .select(bands) \ .filterBounds(commune_buffered) \ .median()\ .clip(commune_buffered) Map.centerObject(commune, 14) Map.addLayer( S2.clip(commune_buffered), vizParams, "S2_" + str(xachon) + "_" + image_date1 + " (Ảnh đơn)") Map.addLayer( S22, vizParams, "S2_" + str(xachon) + "_" + image_date1 + " (Tập hợp)") Map.addLayer(commune_buffered, {'color': 'red'}, "RG_" + str(xachon), False, 0.2) ### Save image to Google Drive3 ### Message bar info self.iface.messageBar().pushMessage( "Mở thành công ảnh Sentiel-2 của " + xachon + " " + huyenchon + " " + tinhchon + "!", level=Qgis.Success, duration=10) pass
import ee from ee_plugin import Map roi = ee.FeatureCollection('TIGER/2018/States') \ .filter(ee.Filter.eq('STUSPS', 'ND')) dataset = ee.ImageCollection('USDA/NAIP/DOQQ') \ .filter(ee.Filter.date('2016-01-01', '2017-12-31'))\ .filterBounds(roi) TrueColor = dataset.select(['N', 'R', 'G']).mosaic() TrueColorVis = { 'min': 0.0, 'max': 255.0, } # Map.setCenter(-73.9958, 40.7278, 15) Map.centerObject(roi, 8) Map.addLayer(TrueColor, TrueColorVis, 'True Color')
forested = forested.map(lambda f: f.set('R', 0).set('G', 136).set('B', 55)) pond = fc.filter(ee.Filter.eq('WETLAND_TY', 'Freshwater Pond')) pond = pond.map(lambda f: f.set('R', 104).set('G', 140).set('B', 192)) lake = fc.filter(ee.Filter.eq('WETLAND_TY', 'Lake')) lake = lake.map(lambda f: f.set('R', 19).set('G', 0).set('B', 124)) riverine = fc.filter(ee.Filter.eq('WETLAND_TY', 'Riverine')) riverine = riverine.map( lambda f: f.set('R', 1).set('G', 144).set('B', 191)) fc = ee.FeatureCollection( emergent.merge(forested).merge(pond).merge(lake).merge(riverine)) base = ee.Image(0).mask(0).toInt8() img = base.paint(fc, 'R') \ .addBands(base.paint(fc, 'G') .addBands(base.paint(fc, 'B'))) return img fromFT = ee.FeatureCollection("users/wqs/Pipestem/Pipestem_HUC10") Map.addLayer(ee.Image().paint(fromFT, 0, 2), {}, 'Watershed') huc8_id = '10160002' nwi_asset_path = 'users/wqs/NWI-HU8/HU8_' + huc8_id + '_Wetlands' # NWI wetlands for the clicked watershed clicked_nwi_huc = ee.FeatureCollection(nwi_asset_path) nwi_color = nwi_add_color(clicked_nwi_huc) Map.centerObject(clicked_nwi_huc, 10) Map.addLayer(nwi_color, {'gamma': 0.3, 'opacity': 0.7}, 'NWI Wetlands Color')
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/FeatureCollection/merge_feature_collections.py import ee from ee_plugin import Map SD = ee.FeatureCollection('TIGER/2018/States') \ .filter(ee.Filter.eq('STUSPS', 'SD')) ND = ee.FeatureCollection('TIGER/2018/States') \ .filter(ee.Filter.eq('STUSPS', 'ND')) states = SD.merge(ND) Map.centerObject(states, 6) Map.addLayer(ee.Image().paint(states, 0, 2), {}, 'Dakotas') # print(states.size().getInfo())
import ee from ee_plugin import Map # Define an arbitrary region in which to compute random points. region = ee.Geometry.Rectangle(-119.224, 34.669, -99.536, 50.064) # Create 1000 random points in the region. randomPoints = ee.FeatureCollection.randomPoints(region) # Display the points. Map.centerObject(randomPoints) Map.addLayer(randomPoints, {}, 'random points')
'maxPixels': 1e9 }) return std_value dataset = ee.Image('USGS/NED') dem = dataset.select('elevation') # dem = ee.Image('srtm90_v4') vis_params = {'min': 0, 'max': 3000} Map.addLayer(dem, vis_params, 'NED', False) roi = ee.Geometry.Polygon( [[[-120.18204899532924, 38.53481618819663], [-120.18204899532924, 36.54889033300136], [-116.75431462032924, 36.54889033300136], [-116.75431462032924, 38.53481618819663]]]) image = dem.clip(roi) Map.centerObject(image, 9) Map.addLayer(image, vis_params, 'DEM') scale = image.projection().nominalScale() print("Resolution: ", scale.getInfo()) scale = 30 print("Minimum value: ", minValue(image, scale).get('elevation').getInfo()) print("Maximum value: ", maxValue(image, scale).get('elevation').getInfo()) print("Average value: ", meanValue(image, scale).get('elevation').getInfo()) print("Standard deviation: ", stdValue(image, scale).get('elevation').getInfo())
import ee from ee_plugin import Map point = ee.Geometry.Point([1.5, 1.5]) Map.addLayer(point, {'color': '1eff05'}, 'point') lineString = ee.Geometry.LineString([[-35, -10], [35, -10], [35, 10], [-35, 10]]) Map.addLayer(lineString, {'color': 'FF0000'}, 'lineString') linearRing = ee.Geometry.LinearRing([[-35, -10], [35, -10], [35, 10], [-35, 10], [-35, -10]]) Map.addLayer(linearRing, {'color': 'ee38ff'}, 'linearRing') rectangle = ee.Geometry.Rectangle([-40, -20, 40, 20]) Map.addLayer(rectangle, {'color': 'ffa05c'}, 'rectangle') polygon = ee.Geometry.Polygon([[[-5, 40], [65, 40], [65, 60], [-5, 60], [-5, 60]]]) planarPolygon = ee.Geometry(polygon, None, False) Map.addLayer(polygon, {'color': 'FF0000'}, 'geodesic polygon') Map.addLayer(planarPolygon, {'color': '000000'}, 'planar polygon') Map.centerObject(polygon)
.map(MaskL8sr)\ .map(L8_NDVI) #Get information on the returned images: Nbr of images returned per Collection, acquisition date, bands.... count_images_L8 = aft_L8.size() count_images_L5 = bef_L5.size() print("Your LANDSAT-8 query returned", count_images_L8.getInfo(), "images") print("Your LANDSAT-5 query returned", count_images_L5.getInfo(), "images") image = aft_L8.first() image_date = image.date().format('YYYY-MM-dd').getInfo() image_bands = image.bandNames().getInfo() print ("This image was acquired on", image_date, "and has the following bands:",image_bands) #Show a random Landsat-8 image from the collection Map.centerObject(AOI, 8) Map.addLayer (image.visualize(bands = ['B4', 'B3', 'B2'], min= 0, max= 3000, gamma= 1.4)) # Compute statisctis (mean, StDev) and NDVI change/anomalie bef_mean_NDVI = bef_L5.select ('L5_NDVI').mean() aft_mean_NDVI = aft_L8.select ('L8_NDVI').mean() bef_stDev_NDVI = bef_L5.select ('L5_NDVI').reduce (ee.Reducer.stdDev()) ndviChange = ((aft_mean_NDVI.subtract(bef_mean_NDVI))\ .divide(bef_mean_NDVI))\ .multiply(100)\ .rename('ndviChange')\ .clip(AOI); ndviAnomaly = ((aft_mean_NDVI.subtract(bef_mean_NDVI))\
# Define a palette for the IGBP classification. igbpPalette = [ 'aec3d4', # water '152106', '225129', '369b47', '30eb5b', '387242', # forest '6a2325', 'c3aa69', 'b76031', 'd9903d', '91af40', # shrub, grass '111149', # wetlands 'cdb33b', # croplands 'cc0013', # urban '33280d', # crop mosaic 'd7cdcc', # snow and ice 'f7e084', # barren '6f6f6f' # tundra ] # Display the input and the classification. Map.centerObject(roi, 10) Map.addLayer(input, {'bands': ['B3', 'B2', 'B1'], 'max': 0.4}, 'landsat') Map.addLayer(classified, { 'palette': igbpPalette, 'min': 0, 'max': 17 }, 'classification')
import ee from ee_plugin import Map # Load a raw Landsat scene and display it. raw = ee.Image('LANDSAT/LC08/C01/T1/LC08_044034_20140318') Map.centerObject(raw, 10) Map.addLayer(raw, { 'bands': ['B4', 'B3', 'B2'], 'min': 6000, 'max': 12000 }, 'raw') # Convert the raw data to radiance. radiance = ee.Algorithms.Landsat.calibratedRadiance(raw) Map.addLayer(radiance, {'bands': ['B4', 'B3', 'B2'], 'max': 90}, 'radiance') # Convert the raw data to top-of-atmosphere reflectance. toa = ee.Algorithms.Landsat.TOA(raw) Map.addLayer(toa, {'bands': ['B4', 'B3', 'B2'], 'max': 0.2}, 'toa reflectance')
import ee from ee_plugin import Map # Load a cloudy Landsat scene and display it. cloudy_scene = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20140926') Map.centerObject(cloudy_scene) Map.addLayer(cloudy_scene, { 'bands': ['B4', 'B3', 'B2'], 'max': 0.4 }, 'TOA', False) # Add a cloud score band. It is automatically called 'cloud'. scored = ee.Algorithms.Landsat.simpleCloudScore(cloudy_scene) # Create a mask from the cloud score and combine it with the image mask. mask = scored.select(['cloud']).lte(20) # Apply the mask to the image and display the result. masked = cloudy_scene.updateMask(mask) Map.addLayer(masked, {'bands': ['B4', 'B3', 'B2'], 'max': 0.4}, 'masked') # Load a Landsat 8 composite and set the SENSOR_ID property. mosaic = ee.Image(ee.ImageCollection('LANDSAT/LC8_L1T_8DAY_TOA').first()) \ .set('SENSOR_ID', 'OLI_TIRS') # Cloud score the mosaic and display the result. scored_mosaic = ee.Algorithms.Landsat.simpleCloudScore(mosaic) Map.addLayer(scored_mosaic, { 'bands': ['B4', 'B3', 'B2'], 'max': 0.4 }, 'TOA mosaic', False)
import ee from ee_plugin import Map # get a single feature countries = ee.FeatureCollection("USDOS/LSIB_SIMPLE/2017") country = countries.filter(ee.Filter.eq('country_na', 'Ukraine')) Map.addLayer(country, {'color': 'orange'}, 'feature collection layer') # TEST: center feature on a map Map.centerObject(country)
import ee from ee_plugin import Map # Center the map on an image. image = ee.Image('LANDSAT/LC08/C01/T1/LC08_044034_20130603') Map.addLayer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 20000}) Map.centerObject(image)
print(img2017) # NDVI can be calculated using expression # # NDVI for 2014 ndvi2014 = img2014.expression('(NIR - RED) / (NIR + RED)', { 'NIR': img2014.select('B4'), 'RED': img2014.select('B3') }) # NDVI can be calculated using math operation # # NDVI for 2017 ndvi2017 = img2017.select('B4').subtract(img2017.select('B3')) \ .divide(img2017.select('B4').add(img2017.select('B3'))) # Load the land mask from the SRTM DEM. landMask = ee.Image('CGIAR/SRTM90_V4').mask() # Analyzing the difference ndviChange = ndvi2017.subtract(ndvi2014) # Updating the land mask ndviUp = ndviChange.updateMask(landMask) # Ploting in map layer Map.centerObject(ndvi2017, 9) Map.addLayer(ndviUp, { 'min': -0.3, 'max': 0.3, 'palette': ['FFFFFF', '0000FF', 'FF0000'] }, "Changes of NDVI from 2014 to 2017")
def run(self): """Run method that performs all the real work""" def blankPaint(geometry): blank = ee.Image(0).mask(0) geometryDraw = blank.paint(geometry, '0000AA', 1) return geometryDraw # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = simex_pluginDialog() # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: uf = self.dlg.selectUF.currentText() path = self.dlg.path.toPlainText() row = self.dlg.row.toPlainText() cloud_cover = int(self.dlg.cloudcover.cleanText()) startdate = self.dlg.startdate.date().toString('yyyy-MM-dd') enddate = self.dlg.enddate.date().toString('yyyy-MM-dd') self.iface.messageBar().pushMessage('loading ...') geometry = path_row_am.filterMetadata('PATH', 'equals', int(path)).filterMetadata('ROW', 'equals', int(row)).geometry() countourGeometry = blankPaint(geometry) Map.centerObject(geometry, 100) progressMessageBar = iface.messageBar().createMessage("loading...") progress = QProgressBar() progress.setMaximum(10) progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter) progressMessageBar.layout().addWidget(progress) iface.messageBar().pushWidget(progressMessageBar, Qgis.Info) for i in range(10): time.sleep(1) progress.setValue(i + 1) parametrosColecaoL8 = { 'collectionid': 'LANDSAT/LC08/C01/T1_SR', 'geometry': geometry.centroid(), 'dateStart': ee.Date(startdate), 'dateEnd': ee.Date(enddate), 'cloud_cover': cloud_cover, } colecaoL8 = getCollection(parametrosColecaoL8).select(bandNames("l8")['bandNames'],bandNames("l8")['newNames'])\ .map(getSMA).map(getNDFI) #nImages = colecaoL8.size().getInfo() #colList = colecaoL8.toList(nImages) #idG = 1 listYears = list(range(int(startdate[:4]),int(enddate[:4])+1)) for item in listYears: #imgYear = ee.Image(colecaoL8.filterDate(str(item) + '-01-01',str(item+1) + '-01-01').sort('cloud_cover').first()) colYear = colecaoL8.filterDate(str(item) + '-01-01',str(item+1) + '-01-01').sort('cloud_cover').limit(3) colList = colYear.toList(5) idG = 1 while idG < 3: img = ee.Image(colList.get(idG)) try: dictionaryInfos = ee.Dictionary({'satellite_name':img.get('satellite_name'), 'date':img.get('date'), 'cloud_cover':img.get('cloud_cover')}).getInfo() if listYears.index(item) == len(listYears)-2: status = True else: status = False Map.addLayer(img, {'bands': ['swir2'],'gain' : [0.2],'gamma':0.6},\ 'B7_' + str(dictionaryInfos['date']).replace('-','_')+'_'+dictionaryInfos['satellite_name'],status) Map.addLayer(img,{"bands": ['ndfi'], "palette": ['ffffff', 'fffcff', 'fff9ff', 'fff7ff', 'fff4ff', 'fff2ff', 'ffefff', 'ffecff', 'ffeaff', 'ffe7ff', 'ffe5ff', 'ffe2ff', 'ffe0ff', 'ffddff', 'ffdaff', 'ffd8ff', 'ffd5ff', 'ffd3ff', 'ffd0ff', 'ffceff', 'ffcbff', 'ffc8ff', 'ffc6ff', 'ffc3ff', 'ffc1ff', 'ffbeff', 'ffbcff', 'ffb9ff', 'ffb6ff', 'ffb4ff', 'ffb1ff', 'ffafff', 'ffacff', 'ffaaff', 'ffa7ff', 'ffa4ff', 'ffa2ff', 'ff9fff', 'ff9dff', 'ff9aff', 'ff97ff', 'ff95ff', 'ff92ff', 'ff90ff', 'ff8dff', 'ff8bff', 'ff88ff', 'ff85ff', 'ff83ff', 'ff80ff', 'ff7eff', 'ff7bff', 'ff79ff', 'ff76ff', 'ff73ff', 'ff71ff', 'ff6eff', 'ff6cff', 'ff69ff', 'ff67ff', 'ff64ff', 'ff61ff', 'ff5fff', 'ff5cff', 'ff5aff', 'ff57ff', 'ff55ff', 'ff52ff', 'ff4fff', 'ff4dff', 'ff4aff', 'ff48ff', 'ff45ff', 'ff42ff', 'ff40ff', 'ff3dff', 'ff3bff', 'ff38ff', 'ff36ff', 'ff33ff', 'ff30ff', 'ff2eff', 'ff2bff', 'ff29ff', 'ff26ff', 'ff24ff', 'ff21ff', 'ff1eff', 'ff1cff', 'ff19ff', 'ff17ff', 'ff14ff', 'ff12ff', 'ff0fff', 'ff0cff', 'ff0aff', 'ff07ff', 'ff05ff', 'ff02ff', 'ff00ff', 'ff00ff', 'ff0af4', 'ff15e9', 'ff1fdf', 'ff2ad4', 'ff35c9', 'ff3fbf', 'ff4ab4', 'ff55aa', 'ff5f9f', 'ff6a94', 'ff748a', 'ff7f7f', 'ff8a74', 'ff946a', 'ff9f5f', 'ffaa55', 'ffb44a', 'ffbf3f', 'ffc935', 'ffd42a', 'ffdf1f', 'ffe915', 'fff40a', 'ffff00', 'ffff00', 'fffb00', 'fff700', 'fff300', 'fff000', 'ffec00', 'ffe800', 'ffe400', 'ffe100', 'ffdd00', 'ffd900', 'ffd500', 'ffd200', 'ffce00', 'ffca00', 'ffc600', 'ffc300', 'ffbf00', 'ffbb00', 'ffb700', 'ffb400', 'ffb000', 'ffac00', 'ffa800', 'ffa500', 'ffa500', 'f7a400', 'f0a300', 'e8a200', 'e1a200', 'd9a100', 'd2a000', 'ca9f00', 'c39f00', 'bb9e00', 'b49d00', 'ac9c00', 'a59c00', '9d9b00', '969a00', '8e9900', '879900', '7f9800', '789700', '709700', '699600', '619500', '5a9400', '529400', '4b9300', '439200', '349100', '2d9000', '258f00', '1e8e00', '168e00', '0f8d00', '078c00', '008c00', '008c00', '008700', '008300', '007f00', '007a00', '007600', '007200', '006e00', '006900', '006500', '006100', '005c00', '005800', '005400', '005000', '004c00'],\ "min":0,"max":200},'NDFI_' + str(dictionaryInfos['date']).replace('-','_')+'_'+dictionaryInfos['satellite_name'],status) except Exception as e: # print('Exception\n',str(e)) pass idG = idG + 1 for i in range(10): time.sleep(1) progress.setValue(i + 1) iface.messageBar().clearWidgets() Map.addLayer(countourGeometry,{ 'palette': '#000000', 'opacity': 0.8 },str(path) + '_' + str(row)) for item in auxLayers[dicAuxState[uf]][0]: outline = blankPaint(auxLayers[dicAuxState[uf]][item][1][1]) Map.addLayer(outline,auxLayers[dicAuxState[uf]][item][1][3],\ auxLayers[dicAuxState[uf]][item][1][2], False)
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/FeatureCollection/column_statistics.py import ee from ee_plugin import Map fromFT = ee.FeatureCollection("users/wqs/Pipestem/Pipestem_HUC10") geom = fromFT.geometry() Map.centerObject(fromFT) Map.addLayer(ee.Image().paint(geom, 0, 2), {}, 'Watersheds') print(fromFT.aggregate_stats('AreaSqKm')) total_area = fromFT.reduceColumns( **{ 'reducer': ee.Reducer.sum(), 'selectors': ['AreaSqKm'] # weightSelectors: ['weight'] }).getInfo() print("Total area: ", total_area)
} ano = '2018' limitCaatC5 = ee.FeatureCollection(param['assetlimit']) FeatColbacia = ee.FeatureCollection(param['assetBaciaC4']) Mosaicos = ee.ImageCollection(param['assetMosaic']).filter( ee.Filter.Or( ee.Filter.eq("biome", 'CAATINGA'), ee.Filter.eq("biome", 'CERRADO'), ee.Filter.eq("biome", 'MATAATLANTICA') ))\ .filterBounds(FeatColbacia).select(param['bandas'])\ .filter(ee.Filter.eq('year', int(ano))).mosaic()\ .clip(FeatColbacia).divide(10) imgMap5_0 = ee.Image(param['assetCol5']).clip(limitCaatC5).select('classification_' + ano) FeatBacias = ee.Image().byte().paint(FeatColbacia, 1, 1) Featlimit = ee.Image().byte().paint(limitCaatC5, 1, 2) # Map.addLayer(imgMap5_0, {min:1, max: 45, 'palette': paleta }, 'Col5') Map.addLayer(imgMap5_0.visualize(**visualizar['visclassC5'])) # Map.addLayer(Featlimit, {'palette': '0000FF','opacity': 0.75}, 'lCaatinga') # Map.addLayer(FeatBacias, {'palette': 'FF0000', 'opacity': 0.8}, 'Bacias') # Map.addLayer(Mosaicos.visualize(**visualizar['visMosaic'])) #Center to point Map.centerObject(limitCaatC5, 6)
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Tutorials/Medium/remove_colors.py import ee from ee_plugin import Map # Credits to: Keiko Nomura, Senior Analyst, Space Intelligence Ltd # Source: https://medium.com/google-earth/10-tips-for-becoming-an-earth-engine-expert-b11aad9e598b # GEE JS: https://code.earthengine.google.com/?scriptPath=users%2Fnkeikon%2Fmedium%3Aremove_colours point = ee.Geometry.Point([2.173487088281263, 41.38710609258852]) Map.centerObject(ee.FeatureCollection(point), 11) # Select the least cloudy image in 2019 image = ee.ImageCollection('COPERNICUS/S2_SR') \ .filter(ee.Filter.calendarRange(2019, 2019, 'year')) \ .filterBounds(point) \ .sort('CLOUDY_PIXEL_PERCENTAGE', True) \ .select(['B2', 'B3', 'B4', 'B8']) \ .first() # print('Image used', image) Map.addLayer(image, { 'bands': ['B4', 'B3', 'B2'], 'min': 0, 'max': 2500 }, 'RGB (True colours)') Map.addLayer(image, { 'bands': ['B3', 'B3', 'B3'], 'min': 0, 'max': 2500,
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Image/cell_statistics.py import ee from ee_plugin import Map # Load an image and select some bands of interest. image = ee.Image('LANDSAT/LC8_L1T/LC80440342014077LGN00') \ .select(['B4', 'B3', 'B2']) # Reduce the image to get a one-band maximum value image. maxValue = image.reduce(ee.Reducer.max()) # Display the result. Map.centerObject(image, 10) Map.addLayer(maxValue, {'max': 13000}, 'Maximum value image')
L8T1 = 'LANDSAT/LC08/C01/T1_SR' MODIS = 'MODIS/006/MOD09GA' S2 = 'COPERNICUS/S2_SR' #########################/ #set date range starta = '2019-03-01' enda = '2019-11-30' # Create a geodesic polygon containing Boulder, CO reqGeometry = ee.Geometry.Polygon([ [[43.36666667, 16.13333333], [45.91666667, 16.13333333], [45.91666667, 15.73333333], [43.36666667, 15.73333333], [43.36666667, 16.13333333]]]) # Display the polygon on the map Map.centerObject(reqGeometry) Map.addLayer(reqGeometry, {'color': 'FF0000'}, 'geodesic polygon') #/Make date sequence of 15 days start = ee.Date.fromYMD(2019,3,01) #change the second number to how many 15 dqay sequences fit into your date range - this will provide an error if there are too many. months = ee.List.sequence(0, 18*15, 15) def func_rlp(d): return start.advance(d, 'days') startDates = months.map(func_rlp)