import ee from ee_plugin import Map # Example of FeatureCollection.reduceToImage() # Define a feature collection with a value we want to average. fc = ee.FeatureCollection([ ee.Feature( ee.Geometry.Rectangle( -122.4550, 37.8035, -122.4781, 37.7935), {'value': 0}), ee.Feature( ee.Geometry.Polygon([ [-122.4427, 37.8027], [-122.4587, 37.7987], [-122.4440, 37.7934]]), {'value': 1}) ]) # Reduce the collection to an image, where each pixel # is the mean of the 'value' property in all features # intersecting that pixel. image_reduced = fc.reduceToImage(['value'], 'mean') Map.setCenter(-122.4561, 37.7983, 14) Map.addLayer(image_reduced, { 'min': 0, 'max': 1, 'palette': ['008800', '00FF00']}, "Image")
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/FeatureCollection/select_by_location.py import ee from ee_plugin import Map HUC10 = ee.FeatureCollection("USGS/WBD/2017/HUC10") HUC08 = ee.FeatureCollection('USGS/WBD/2017/HUC08') roi = HUC08.filter(ee.Filter.eq('name', 'Pipestem')) Map.centerObject(roi, 10) Map.addLayer(ee.Image().paint(roi, 0, 3), {}, 'HUC08') # select polygons intersecting the roi roi2 = HUC10.filter( ee.Filter.contains(**{ 'leftValue': roi.geometry(), 'rightField': '.geo' })) Map.addLayer(ee.Image().paint(roi2, 0, 2), {'palette': 'blue'}, 'HUC10') # roi3 = HUC10.filter(ee.Filter.stringContains(**{'leftField': 'huc10', 'rightValue': '10160002'})) # # print(roi3) # Map.addLayer(roi3)
from ee_plugin import Map # Feature buffer example. # Display the area within 2 kilometers of San Francisco BART stations. # Instantiate a FeatureCollection of BART locations in Downtown San Francisco # (points). stations = [ ee.Feature(ee.Geometry.Point(-122.42, 37.77), {'name': '16th St. Mission (16TH)'}), ee.Feature(ee.Geometry.Point(-122.42, 37.75), {'name': '24th St. Mission (24TH)'}), ee.Feature(ee.Geometry.Point(-122.41, 37.78), {'name': 'Civic Center/UN Plaza (CIVC)'}) ] bartStations = ee.FeatureCollection(stations) # Map a function over the collection to buffer each feature. def func_dky(f): return f.buffer(2000, 100) # Note that the errorMargin is set to 100. buffered = bartStations.map(func_dky) Map.addLayer(buffered, {'color': '800080'}) Map.setCenter(-122.4, 37.7, 11)
import ee from ee_plugin import Map # Collection.distance example. # Computes the distance to the nearest feature in a collection. # Construct a FeatureCollection from a list of geometries. fc = ee.FeatureCollection([ ee.Geometry.Point(-72.94411, 41.32902), ee.Geometry.Point(-72.94411, 41.33402), ee.Geometry.Point(-72.94411, 41.33902), # The geometries do not need to be the same type. ee.Geometry.LineString(-72.93411, 41.30902, -72.93411, 41.31902, -72.94411, 41.31902) ]) # Compute distance from the dfeatures, to a max of 1000 meters. distance = fc.distance(1000, 100) Map.setCenter(-72.94, 41.32, 13) Map.addLayer(distance, { 'min': 0, 'max': 1000, 'palette': ['yellow', 'red'] }, 'distance') Map.addLayer(fc, {}, 'Features')
# Filter to only include images intersecting Colorado or Utah. polygon = ee.Geometry.Polygon({ 'coords': [[ [-109.05, 37.0], [-102.05, 37.0], [-102.05, 41.0], # Colorado [-109.05, 41.0], [-111.05, 41.0], [-111.05, 42.0], # Utah [-114.05, 42.0], [-114.05, 37.0], [-109.05, 37.0] ]], 'geodesic': False }) # Create a Landsat 7 composite for Spring of 2000, and filter by # the bounds of the FeatureCollection. collection = ee.ImageCollection('LANDSAT/LE07/C01/T1') \ .filterDate('2000-04-01', '2000-07-01') \ .filterBounds(polygon) # Compute the median in each band, in each pixel. median = collection.median() # Select the red, green and blue bands. result = median.select('B3', 'B2', 'B1') Map.addLayer(result, {'gain': [1.4, 1.4, 1.1]}) Map.setCenter(-110, 40, 5)
import ee from ee_plugin import Map # Load and filter the Sentinel-2 image collection. collection = ee.ImageCollection('COPERNICUS/S2') \ .filterDate('2016-01-01', '2016-12-31') \ .filterBounds(ee.Geometry.Point([-81.31, 29.90])) # Reduce the collection. extrema = collection.reduce(ee.Reducer.minMax()) # print(extrema.getInfo()) min_image = extrema.select(0) max_image = extrema.select(1) Map.setCenter(-81.31, 29.90, 10) Map.addLayer(min_image, {}, 'Min image') Map.addLayer(max_image, {}, 'Max image')
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Datasets/Vectors/us_census_roads.py import ee from ee_plugin import Map fc = ee.FeatureCollection('TIGER/2016/Roads') Map.setCenter(-73.9596, 40.7688, 12) Map.addLayer(fc, {}, 'Census roads')
import ee from ee_plugin import Map # Load a cloudy Landsat 8 image. image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20130603') Map.addLayer(image, { 'bands': ['B5', 'B4', 'B3'], 'min': 0, 'max': 0.5 }, 'original image') # Load another image to replace the cloudy pixels. replacement = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20130416') # Compute a cloud score band. cloud = ee.Algorithms.Landsat.simpleCloudScore(image).select('cloud') # Set cloudy pixels to the other image. replaced = image.where(cloud.gt(10), replacement) # Display the result. Map.centerObject(image, 9) Map.addLayer(replaced, { 'bands': ['B5', 'B4', 'B3'], 'min': 0, 'max': 0.5 }, 'clouds replaced')
import ee from ee_plugin import Map # Load a Landsat 8 image. image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_044034_20140318') # Compute the EVI using an expression. evi = image.expression( '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', { 'NIR': image.select('B5'), 'RED': image.select('B4'), 'BLUE': image.select('B2') }) Map.centerObject(image, 9) Map.addLayer(evi, { 'min': -1, 'max': 1, 'palette': ['FF0000', '00FF00'] }, "EVI")
import ee from ee_plugin import Map fromFT = ee.FeatureCollection('ft:1CLldB-ULPyULBT2mxoRNv7enckVF0gCQoD2oH7XP') polys = fromFT.geometry() centroid = polys.centroid() lng, lat = centroid.getInfo()['coordinates'] print("lng = {}, lat = {}".format(lng, lat)) Map.setCenter(lng, lat, 10) Map.addLayer(fromFT) taskParams = { 'driveFolder': 'image', 'fileFormat': 'KML' # CSV, KMZ, GeoJSON } # export all features in a FeatureCollection as one file task = ee.batch.Export.table(fromFT, 'export_fc', taskParams) task.start() # # export each feature in a FeatureCollection as an individual file # count = fromFT.size().getInfo() # for i in range(2, 2 + count): # fc = fromFT.filter(ee.Filter.eq('system:index', str(i))) # task = ee.batch.Export.table(fc, 'watershed-' + str(i), taskParams) # task.start()
import ee from ee_plugin import Map # Load a FeatureCollection from a table dataset: 'RESOLVE' ecoregions. ecoregions = ee.FeatureCollection('RESOLVE/ECOREGIONS/2017') # Display as default and with a custom color. Map.addLayer(ecoregions, {}, 'default display', False) Map.addLayer(ecoregions, {'color': 'FF0000'}, 'colored', False) Map.addLayer(ecoregions.draw(**{ 'color': '006600', 'strokeWidth': 5 }), {}, 'drawn', False) # Create an empty image into which to paint the features, cast to byte. empty = ee.Image().byte() # Paint all the polygon edges with the same number and 'width', display. outline = empty.paint(**{ 'featureCollection': ecoregions, 'color': 1, 'width': 3 }) Map.addLayer(outline, {'palette': 'FF0000'}, 'edges')
import ee from ee_plugin import Map dataset = ee.Image('JRC/GSW1_1/GlobalSurfaceWater') occurrence = dataset.select('occurrence') occurrenceVis = { 'min': 0.0, 'max': 100.0, 'palette': ['ffffff', 'ffbbbb', '0000ff'] } Map.setCenter(59.414, 45.182, 6) Map.addLayer(occurrence, occurrenceVis, 'Occurrence')
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/FeatureCollection/clipping.py import ee from ee_plugin import Map roi = ee.Geometry.Polygon( [[[-73.99891354682285, 40.74560250077625], [-73.99891354682285, 40.74053023068626], [-73.98749806525547, 40.74053023068626], [-73.98749806525547, 40.74560250077625]]]) fc = ee.FeatureCollection('TIGER/2016/Roads').filterBounds(roi) clipped = fc.map(lambda f: f.intersection(roi)) Map.centerObject(ee.FeatureCollection(roi), 17) Map.addLayer(ee.Image().paint(roi, 0, 2), {'palette': 'yellow'}, 'ROI') # Map.setCenter(-73.9596, 40.7688, 12) Map.addLayer(ee.Image().paint(clipped, 0, 3), {'palette': 'red'}, 'clipped') Map.addLayer(fc, {}, 'Census roads', False)
# Load a Landsat 8 image and display the thermal band. image = ee.Image('LANDSAT/LC8_L1T_TOA/LC80440342014077LGN00').clip(geometry) Map.setCenter(-121.51385307312012, 37.61767615130697, 14) # SF Bay #Map.addLayer(image, {'bands': ['B10'], 'min': 270, 'max': 310}, 'LST') #print(image) # Threshold the thermal band to find "hot" objects. hotspots = image.select('B10').gt(303) # Mask "cold" pixels. hotspots = hotspots.mask(hotspots) #Map.addLayer(hotspots, {'palette': 'FF0000'}, 'hotspots') # Compute the number of pixels in each patch. patchsize = hotspots.connectedPixelCount(100, False) Map.addLayer(patchsize, {}, 'patch size') largePatches = patchsize.gt(4) largePatches = largePatches.updateMask(largePatches) Map.addLayer(largePatches, {}, 'patch size>4') pixelAreaAllPatches = hotspots.multiply(ee.Image.pixelArea()) pixelAreaLargePatch = largePatches.multiply(ee.Image.pixelArea()) areaAllPathces = pixelAreaAllPatches.reduceRegion(**{ 'reducer': ee.Reducer.sum(), 'geometry': geometry }) areaLargePatch = pixelAreaLargePatch.reduceRegion(**{ 'reducer': ee.Reducer.sum(), 'geometry': geometry })
# sliceVisibilityThreshold: 0 # Don't group small slices. # }) # print(transition_summary_chart) ############################### # Initialize Map Location ############################### # Uncomment one of the following statements to center the map on # a particular location. # Map.setCenter(-90.162, 29.8597, 10) # New Orleans, USA # Map.setCenter(-114.9774, 31.9254, 10) # Mouth of the Colorado River, Mexico # Map.setCenter(-111.1871, 37.0963, 11) # Lake Powell, USA # Map.setCenter(149.412, -35.0789, 11) # Lake George, Australia Map.setCenter(105.26, 11.2134, 9) # Mekong River Basin, SouthEast Asia # Map.setCenter(90.6743, 22.7382, 10) # Meghna River, Bangladesh # Map.setCenter(81.2714, 16.5079, 11) # Godavari River Basin Irrigation Project, India # Map.setCenter(14.7035, 52.0985, 12) # River Oder, Germany & Poland # Map.setCenter(-59.1696, -33.8111, 9) # Buenos Aires, Argentina # Map.setCenter(-74.4557, -8.4289, 11) # Ucayali River, Peru ############################### # Map Layers ############################### Map.addLayer(water_mask, VIS_WATER_MASK, '90% occurrence water mask', False) Map.addLayer(occurrence.updateMask(occurrence.divide(100)), VIS_OCCURRENCE, "Water Occurrence (1984-2015)", False) Map.addLayer(change, VIS_CHANGE, 'occurrence change intensity', False) Map.addLayer(transition, {}, 'Transition classes (1984-2018)')
import ee from ee_plugin import Map # Load a pre-computed Landsat composite for input. input = ee.Image('LANDSAT/LE7_TOA_1YEAR/2001') # Define a region in which to generate a sample of the input. region = ee.Geometry.Rectangle(29.7, 30, 32.5, 31.7) # Display the sample region. Map.setCenter(31.5, 31.0, 8) Map.addLayer(ee.Image().paint(region, 0, 2), {}, 'region') # Make the training dataset. training = input.sample(**{'region': region, 'scale': 30, 'numPixels': 5000}) # Instantiate the clusterer and train it. clusterer = ee.Clusterer.wekaKMeans(15).train(training) # Cluster the input using the trained clusterer. result = input.cluster(clusterer) # Display the clusters with random colors. Map.addLayer(result.randomVisualizer(), {}, 'clusters')
# %% ''' ## Add Earth Engine Python script ''' # %% import ee from ee_plugin import Map states = ee.FeatureCollection('TIGER/2018/States') # print(states.first().getInfo()) # Select states with land area between 200,000 km2 and 300,000 km2 selected = states.filter( ee.Filter.rangeContains("ALAND", 200000000000, 300000000000)) Map.centerObject(selected, 6) Map.addLayer(ee.Image().paint(selected, 0, 2), {'palette': 'yellow'}, 'Selected') # %% ''' ## Display Earth Engine data layers ''' # %% Map.setControlVisibility(layerControl=True, fullscreenControl=True, latLngPopup=True) Map
import ee from ee_plugin import Map collection = ee.ImageCollection('USDA/NAIP/DOQQ') fromFT = ee.FeatureCollection('ft:1CLldB-ULPyULBT2mxoRNv7enckVF0gCQoD2oH7XP') polys = fromFT.geometry() centroid = polys.centroid() lng, lat = centroid.getInfo()['coordinates'] print("lng = {}, lat = {}".format(lng, lat)) # lat = 46.80514 # lng = -99.22023 lng_lat = ee.Geometry.Point(lng, lat) # naip = collection.filterBounds(lng_lat) naip = collection.filterBounds(polys) naip_2015 = naip.filterDate('2015-01-01', '2015-12-31') ppr = naip_2015.mosaic().clip(polys) # print(naip_2015.size().getInfo()) vis = {'bands': ['N', 'R', 'G']} Map.setCenter(lng, lat, 10) # Map.addLayer(naip_2015,vis) Map.addLayer(ppr, vis) # Map.addLayer(fromFT) # image = ee.Image('USDA/NAIP/DOQQ/m_4609915_sw_14_1_20100629') # Map.setCenter(lng, lat, 12) # Map.addLayer(image,vis)
############################### # Create a water mask layer, and set the image mask so that non-water areas # are opaque. water_mask = occurrence.gt(90).selfMask() ############################### # Initialize Map Location ############################### # Uncomment one of the following statements to center the map. # Map.setCenter(-90.162, 29.8597, 10) # New Orleans, USA # Map.setCenter(-114.9774, 31.9254, 10) # Mouth of the Colorado River, Mexico # Map.setCenter(-111.1871, 37.0963, 11) # Lake Powell, USA # Map.setCenter(149.412, -35.0789, 11) # Lake George, Australia # Map.setCenter(105.26, 11.2134, 9) # Mekong River Basin, SouthEast Asia # Map.setCenter(90.6743, 22.7382, 10) # Meghna River, Bangladesh # Map.setCenter(81.2714, 16.5079, 11) # Godavari River Basin Irrigation Project, India # Map.setCenter(14.7035, 52.0985, 12) # River Oder, Germany & Poland # Map.setCenter(-59.1696, -33.8111, 9) # Buenos Aires, Argentina Map.setCenter(-74.4557, -8.4289, 11) # Ucayali River, Peru ############################### # Map Layers ############################### Map.addLayer(occurrence.updateMask(occurrence.divide(100)), VIS_OCCURRENCE, "Water Occurrence (1984-2018)") Map.addLayer(water_mask, VIS_WATER_MASK, '90% occurrence water mask', False)
# get standard deviation def stdValue(img, scale=30): std_value = img.reduceRegion(**{ 'reducer': ee.Reducer.stdDev(), 'geometry': img.geometry(), 'scale': scale, '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
# Get the sample from the polygons FeatureCollection. 'collection': polygons, # Keep this list of properties from the polygons. 'properties': ['class'], # Set the scale to get Landsat pixels in the polygons. 'scale': 30 }) # Create an SVM classifier with custom parameters. classifier = ee.Classifier.svm(**{ 'kernelType': 'RBF', 'gamma': 0.5, 'cost': 10 }) # Train the classifier. trained = classifier.train(training, 'class', bands) # Classify the image. classified = image.classify(trained) # Display the classification result and the input image. Map.setCenter(-62.836, -9.2399, 9) Map.addLayer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 0.5, 'gamma': 2}) Map.addLayer(polygons, {}, 'training polygons') Map.addLayer(classified, { 'min': 0, 'max': 1, 'palette': ['red', 'green'] }, 'deforestation')
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)
# An example finding linear features using the HoughTransform. # Load an image and compute NDVI. image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_033032_20170719') ndvi = image.normalizedDifference(['B5', 'B4']) # Apply a Canny edge detector. canny = ee.Algorithms.CannyEdgeDetector({ 'image': ndvi, 'threshold': 0.4 }).multiply(255) # Apply the Hough transform. h = ee.Algorithms.HoughTransform({ 'image': canny, 'gridSize': 256, 'inputThreshold': 50, 'lineThreshold': 100 }) # Display. Map.setCenter(-103.80140, 40.21729, 13) Map.addLayer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 0.3}, 'source_image') Map.addLayer(canny.updateMask(canny), { 'min': 0, 'max': 1, 'palette': 'blue' }, 'canny') Map.addLayer(h.updateMask(h), {'min': 0, 'max': 1, 'palette': 'red'}, 'hough')
import ee from ee_plugin import Map # dataset = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017') # styleParams = { # 'fillColor': 'b5ffb4', # 'color': '00909F', # 'width': 3.0, # } # countries = dataset.style(**styleParams) # Map.addLayer(countries, {}, 'USDOS/LSIB_SIMPLE/2017') dataset = ee.FeatureCollection('USDOS/LSIB/2013') visParams = { 'palette': ['f5ff64', 'b5ffb4', 'beeaff', 'ffc0e8', '8e8dff', 'adadad'], 'min': 0.0, 'max': 894.0, 'opacity': 0.8, } image = ee.Image().float().paint(dataset, 'iso_num') Map.addLayer(image, visParams, 'USDOS/LSIB/2013') # Map.addLayer(dataset, {}, 'for Inspector', False)
import ee from ee_plugin import Map # Image.ConnectedPixelCount example. # Split pixels of band 01 into "bright" (arbitrarily defined as # reflectance > 0.3) and "dim". Highlight small (<30 pixels) # standalone islands of "bright" or "dim" type. img = ee.Image('MODIS/006/MOD09GA/2012_03_09') \ .select('sur_refl_b01') \ .multiply(0.0001) # Create a threshold image. bright = img.gt(0.3) # Compute connected pixel counts; stop searching for connected pixels # once the size of the connected neightborhood reaches 30 pixels, and # use 8-connected rules. conn = bright.connectedPixelCount({ 'maxSize': 30, 'eightConnected': True }) # Make a binary image of small clusters. smallClusters = conn.lt(30) Map.setCenter(-107.24304, 35.78663, 8) Map.addLayer(img, {'min': 0, 'max': 1}, 'original') Map.addLayer(smallClusters.updateMask(smallClusters), {'min': 0, 'max': 1, 'palette': 'FF0000'}, 'cc')
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Visualization/ndvi_symbology.py import ee from ee_plugin import Map # This function gets NDVI from Landsat 5 imagery. def getNDVI(image): return image.normalizedDifference(['B4', 'B3']) image1 = ee.Image('LANDSAT/LT05/C01/T1_TOA/LT05_044034_19900604') # Compute NDVI from the scene. ndvi1 = getNDVI(image1) ndviParams = { 'palette': [ '#d73027', '#f46d43', '#fdae61', '#fee08b', '#d9ef8b', '#a6d96a', '#66bd63', '#1a9850' ] } Map.centerObject(image1, 10) Map.addLayer(ndvi1, ndviParams, 'NDVI')
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)
from ee_plugin import Map import ee image = ee.ImageCollection('COPERNICUS/S2') \ .filterDate('2018-01-01', '2018-01-02').median() \ .divide(10000).visualize(**{'bands': ['B12', 'B8', 'B4'], 'min': 0.05, 'max': 0.5}) Map.addLayer(image, {}, 'Sentinel-2 images January, 2018')
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Datasets/us_cropland.py # Metadata: https://developers.google.com/earth-engine/datasets/catalog/USDA_NASS_CDL import ee from ee_plugin import Map dataset = ee.ImageCollection('USDA/NASS/CDL') \ .filter(ee.Filter.date('2017-01-01', '2018-12-31')) \ .first() cropLandcover = dataset.select('cropland') Map.setCenter(-100.55, 40.71, 4) Map.addLayer(cropLandcover, {}, 'Crop Landcover')
import ee from ee_plugin import Map # This example demonstrates the use of the Landsat 8 QA band to mask clouds. # Function to mask clouds using the quality band of Landsat 8. # maskL8 = function(image) { def maskL8(image): qa = image.select('BQA') #/ Check that the cloud bit is off. # See https:#www.usgs.gov/land-resources/nli/landsat/landsat-collection-1-level-1-quality-assessment-band mask = qa.bitwiseAnd(1 << 4).eq(0) return image.updateMask(mask) # } # Map the function over one year of Landsat 8 TOA data and take the median. composite = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA') \ .filterDate('2016-01-01', '2016-12-31') \ .map(maskL8) \ .median() # Display the results in a cloudy place. Map.setCenter(114.1689, 22.2986, 12) Map.addLayer(composite, {'bands': ['B4', 'B3', 'B2'], 'max': 0.3}, "Image")