DEV Community: geedevsnairobi

A Standard Exploration of Google Earth Engine Feature Collections

geedevsnairobi — Thu, 23 Nov 2023 18:22:02 +0000

In Google Earth Engine, a Feature is an object with a geometry property storing a Geometry object and a properties property storing a dictionary of other properties.
A FeatureCollection is a Groups of combined related features.
FeatureCollection objects contains features. Naturally, FeatureCollections contain geometry and properties, and can also contain other collections.

GeoJSON is a data format for encoding a range of geospatial data structures. It supports Point, Polygon, LineString, MultiLineString and MultiPolygon geometries.

As a Google Earth Engine Developer you might wish to combine features. The feature combining operation, allows for additional geospatial operations on the entire set such as filtering, sorting and rendering.
Individual geometries can also be turned into a FeatureCollection a single Feature.

Ways to Create a FeatureCollection in GEE
1.Geometry Points
A FeatureCollection can be created using individual geometries. The geometries can be turned into can a FeatureCollection of just one Feature. An example is the code below.

// Make a feature with some properties.
var feature = ee.Feature(ee.Geometry.Point([37.393616042129715, -0.012801305697836253]))
  .set('County', 'Meru').set('Meru1', 'Settings');

*2. GeometryPolygons *
Another way to create a FeatureCollection in GEE is using GeometryPolygons. This technique calls for drawing a Polygon on the map then convert the polygon into a Geometry using the ee.Geometry.Polygon with Geometries put in a dictionary format. The code prints the geometry properties using the print() function the adds the polygon into a map using the Map.addLayer() method.

The code below plots th polygon of Nairobi county..

// Creating Nairobi Polygon with Geometries
var Nairobi = 
ee.Geometry.Polygon(
        [[[36.668518385879715, -1.2396225227250073],
          [36.695984206192215, -1.354380436474334],
          [36.822326979629715, -1.3928215346108865],
          [36.915710768692215, -1.359872059659389],
          [36.978882155410965, -1.313192869399109],
          [36.976135573379715, -1.2829882209698302],
          [37.028320631973465, -1.2994635284940157],
          [37.075012526504715, -1.3077011420427207],
          [37.105224928848465, -1.2610209794600944],
          [37.061279616348465, -1.2061020716359079],
          [36.998108229629715, -1.2390535525537143],
          [36.970642409317215, -1.2170859434783168],
          [36.918457350723465, -1.2115940131238145],
          [36.885498366348465, -1.1841341953591218],
          [36.836059889785965, -1.2061020716359079],
          [36.792114577285965, -1.1951181554616812],
          [36.745422682754715, -1.228069770585397],
          [36.701477370254715, -1.2610209794600944]]]);
print (Nairobi)
Map.addLayer(Nairobi)

Featurecollection can be added to a map directly with Map.addLayer() function.
By default, map visualization displays the vectors with a solid black lines and semi-opaque black fill. However, it is possible to render the vectors in a color by specifying the .color parameter.

3. Using Shapefile
A shapefile is a simple, non-topological format for storing the geometric location and attribute information of geographic features. Within a shapefile geographic features can be represented by lines, points, or polygons/areas. The workspace containing shapefiles may also contain dBASE tables, which can store additional attributes that can be joined to a shapefile's features.
A geographic location-based shapefile can be imported into Earth Engine and be used as a FeatureCollection. Boundary or administrative shapefile is a good example to demonstrate how to use shapefile as shapefile. Global Administrative Areas (GADM) 3.6 vector dataset series which includes distinct datasets representing administrative boundaries for all countries in the world. The code below demonstrates how to import FAO’s - GADM 3.6 - Country boundaries (level 0) into Google Earth Engine and use it as a FeatureCollection. The Country boundaries are positioned at level 0 in the GADM 3.6 dataset. In this regard, our code below will focus on Kenya.

///////////////////Creating FeatureCollection from Dataset /////////////
var admin0 = ee.FeatureCollection('FAO/GAUL_SIMPLIFIED_500m/2015/level2');
var Kenya = admin0.filter(ee.Filter.eq('ADM0_NAME', 'Kenya'));
print(Kenya)
Map.centerObject(Kenya)
Map.addLayer(Kenya)

Visualizing FeatureCollections
Once all the operations are completed, it is time to visualize our FeatureCollection. Like images, geometries and features, FeatureCollections can be visualized on a map using the Map.addLayer() function. While images are visualized based on the pixel values, feature collections use feature properties/attributes. Vector layers are added on map by assigning a value to the red, green and blue channels for individual pixel on the screen based on the geometry and attributes of the features.

The following functions are used to visualize a vector on map:

Map.addLayer: As with raster layers, you can add a FeatureCollection to the Map by specifying visualization parameters. This method supports only one visualization parameter: color. All features are rendered with the specified color.
draw: This function supports the parameters pointRadius and strokeWidth in addition to color. It renders all features of the layer with the specified parameters.
paint: This is a more powerful function that can render each feature with a different color and width based on the values in the specified property.
style: This is the most versatile function. It can apply a different style to each feature, including color, pointSize, pointShape, width, fillColor, and lineType.

Filtering a FeatureCollection
FeatureCollection filtering techniques resembles that used in ImageCollections. We can filter by Date(), Bounds() among other filtering techniques. While filtering, we use the featureCollection.filter() method.

The code below shows how to apply the filtering technique

/////////////////////Filtering FeatureCollection///////////////
// Load watersheds from a data table.
var sheds = ee.FeatureCollection('USGS/WBD/2017/HUC06')
//  Convert 'areasqkm' property from string to number.
  .map(function(feature){
    var num = ee.Number.parse(feature.get('areasqkm'));
    return feature.set('areasqkm', num);
  });

// Define a region roughly covering the continental US.
var continentalUS = ee.Geometry.Rectangle(-127.18, 19.39, -62.75, 51.29);

// Filter the table geographically: only watersheds in the continental US.
var filtered = sheds.filterBounds(continentalUS);

// Check the number of watersheds after filtering for location.
print('Count after filter:', filtered.size());

// Filter to get only larger continental US watersheds.
var largeSheds = filtered.filter(ee.Filter.gt('areasqkm', 25000));
// Check the number of watersheds after filtering for size and location.
print('Count after filtering by size:', largeSheds.size());

Extracting Metadata from a FeatureCollection
It is possible to extract information from a FeatureCollection like count of features, statistical description, or even perform mathematical computations on a FeatureCollection.
Let’s say we want to extract for information/metadata from a FeatureCollection using a code in Earth Engine..

//////////////////////Extracting FeatureCollection Metadata/////////////
// Load watersheds from a data table.
var Kenya = admin0.filter(ee.Filter.eq('ADM0_NAME', 'Kenya'));
var sheds = ee.FeatureCollection('USGS/WBD/2017/HUC06')
  // Filter to the continental US.
  //.filterBounds(RoI)
  .filterBounds(ee.Geometry.Rectangle(-127.18, 19.39, -62.75, 51.29))
  // Convert 'areasqkm' property from string to number.
  .map(function(feature){
    var num = ee.Number.parse(feature.get('Areasqkm'));
    return feature.set('Areasqkm', num);
  });

// Display the table and print its first element.
Map.addLayer(sheds, {}, 'watersheds');
print('First watershed', sheds.first());

// Print the number of watersheds.
print('Count:', sheds.size());

// Print stats for an area property.
print('Area statistic:', sheds.aggregate_stats('Areasqkm'));

We have done some of the critical operations required on a FeatureCollection and I believe this helps..any question or comment regarding this topic can be shared in the commend section..

Getting Started With Google Earth Engine Functions

geedevsnairobi — Tue, 21 Nov 2023 06:38:36 +0000

Image Credits

Introduction

Welcome to GEE Functions in Javascript API.
In Google Earth engine in one way or another you will find yourself using functions either built-in or user-defined.
In this article we will be delving into using both and explore the examples in each of them.

What’s a Function?

A function is a set of instructions to perform a specific task. In Google Earth Engine,functions are blocks of code that perform specific operations on geospatial data.They
enable users to process and analyze large-scale earth observation datasets for tasks like image processing, data extraction and spatial analysis.

Code:
This refers to a set of instructions written in a programming language (in this case, JavaScript) that tells the computer what operations to perform.
Function:
A function is a block of code that performs a specific task. It takes input(s),processes them, and returns an output.
Name_of_function:
This is a user-defined name given to the function. It helps identify and call the function in the code.
Input parameters:
These are the values or data that you provide to the function for it to work on. They act as "inputs" to the function.
Call the function:
This is where you actually use the function in your code. You provide the required input parameters and execute the function.

Example:
(Input an image of the code)

// Define the function
function addNumbers(parameter_1, parameter_2){
return parameter_1 + parameter_2;
}
// Call the function
let result = addNumbers(5, 3);
console.log(result); // Output: 8

In the above example:

Function: addNumbers is the name of the function.
Name_of_function: addNumbers
Input parameters: parameter_1 and parameter_2 are the input parameters. In this case, they are the numbers you want to add.
Call the function: let result = addNumbers(5, 3); is where we use the function. We pass 5 and 3 as inputs, and it returns 8, which is stored in the result variable.

Lets dive into variables in functions!!

Global & Local Variables

A local variable is a variable that is declared inside of a function. Unlike a global variable,a local variable may only be used inside of the function it is declared in.A variable defined outside a function is a “global variable” and is visible everywhere, including
inside functions.

We use “Return” to save the output as a global variable.

(Input Image of the same)

function calculate_divide (num1, num2) {
var diivide = ee.Number(num2).add(ee.Number(num2)); // code that calculates the
divide_test
print(&quot;Local variable, Sum, = &quot;, diivide);
return diivide; // here we use return
}

Now call and save the output of the function.

// Save it as a variable, Sum_test.
var divide_test = calculate_divide(5, 2);
//function call
print(The global variable, divide_test, = ,divide_test);

diivide is a local variable, only meaningful within the calculate_divide function. It cannot be accessed outside of this function.
divide_test is a global variable, accessible throughout the entire code. It holds the value returned by calculate_divide and can be used anywhere in the code.

In-built Functions
Inbuilt functions are pre-existing functions provided by the programming language to perform commonly used operations, making it easier and more efficient for programmers to write code.
(Input Image of code)

///-------------INBUILT FUNCTIONS--------------
// This generates a list of numbers from 1 to 10.
var myList = ee.List.sequence(1, 10);
// The map() operation takes a function that works on each element independently
// and returns a value. You define a function that can be applied to the input.
var computeSquares = function(number) {
// We define the operation using the EE API.
return ee.Number(number).pow(2);
};
// Apply your function to each item in the list by using the map() function.
var squares = myList.map(computeSquares);
print(squares); // [1, 4, 9, 16, 25, 36, 49, 64, 81]

(var myList = ee.List.sequence(1, 10);) ; This line creates a list of numbers from 1 to
10. When you run this code, it gives an output of [1,2,3,4,5,6,7,8,9,10]
var computeSquares = function(number) {
// We define the operation using the EE API.
return ee.Number(number).pow(2);
};

In the code above, we define a function named computeSquares. This function takes one parameter number. Inside the function, it uses the Earth Engine API (ee.Number(number).pow(2)) to perform an operation. It takes the input number, converts it to an Earth Engine Number, and then raises it to the power of 2, effectively squaring it.

For example,
If you call computeSquares(4), it will return 16, because 4 squared is 16.

// Apply your function to each item in the list by using the map() function.
var squares = myList.map(computeSquares);
print(squares); // [1, 4, 9, 16, 25, 36, 49, 64, 81]

myList: This is the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] that we generated using ee.List.sequence(1, 10).
computeSquares: This is the function we defined earlier. It takes a number as an input and returns its square.
myList.map(computeSquares): This applies the computeSquares function to each element in myList, resulting in a new list where each element is the square of the corresponding element in myList.
print(squares): This prints the resulting list, which contains the squares of the numbers in myList.

The output of the above code is:

[1, 4, 9, 16, 25, 36, 49, 64, 81]

Final Example

// example of mapping function over a colloection
var s2 = ee.ImageCollection(COPERNICUS/S2_HARMONIZED)
.filter(ee.Filter.lt(CLOUDY_PIXEL_PERCENTAGE, 30))
.filter(ee.Filter.date(2023-01-01, 2023-03-01)
.filter(ee.Filter.bounds(geometry))
.median()
.clip(geometry)
function addIndices(image) {
var ndvi = image.normalizedDifference([B8, B4]).rename(ndvi);
var ndwi = image.normalizedDifference([B3,B8).rename(ndwi);
return image.addBands(ndvi).addBands(ndwi);
}
// Map the function over the collection
// var data = s2.map(addIndices);
print(data)
Step 1: Loading and Filtering an Image Collection
var s2 = ee.ImageCollection(COPERNICUS/S2_HARMONIZED)
.filter(ee.Filter.lt(CLOUDY_PIXEL_PERCENTAGE 30))

.filter(ee.Filter.date(2023-01-01, 2023-03-01))
.filter(ee.Filter.bounds(geometry))
.median()
.clip(geometry)

The code above starts by loading an Image Collection from the Copernicus Sentinel-2 dataset. An Image Collection is a group of images that share a common purpose or source.

It applies a series of filters:
● filter(ee.Filter.lt(CLOUDY_PIXEL_PERCENTAGE, 30)): Filters out images with
a cloudy pixel percentage greater than 30%.
● filter(ee.Filter.date(2023-01-01, 2023-03-01)): Selects images within the date range of January 1, 2023, to March 1, 2023.
● filter(ee.Filter.bounds(geometry)): Filters based on a specific geographic area defined by the geometry variable.
● .median(): Computes the median pixel value across all the filtered images.This creates a single composite image.
● .clip(geometry): Clips the resulting composite image to the boundaries defined by the geometry variable. This ensures that the image only covers a specific geographic area.

Step 2: Defining a Function

function addIndices(image) {
var ndvi = image.normalizedDifference([B8,B4]).rename(ndvi);
var ndwi = image.normalizedDifference([B3,B8]).rename(ndwi;
return image.addBands(ndvi).addBands(ndwi);
}

This code defines a function named addIndices. A function is like a set of instructions that can be reused.
● function addIndices(image): This line declares a function named addIndices
that takes a parameter image as input. The image variable represents one image from the Image Collection.
● var ndvi = image.normalizedDifference([B8,B4).rename(ndvi);: Inside the
function, it calculates the NDVI (Normalized Difference Vegetation Index) and NDWI (Normalized Difference Water Index) for the input image.
● return image.addBands(ndvi).addBands(ndwi);: It adds the computed NDVI and NDWI bands to the input image and returns the modified image.

In summary, the code essentially loads a filtered composite image from the Sentinel-2 dataset, then defines a function (addIndices) to calculate vegetation and water indices. This function will be applied to the s2 image.

Thanks for reading and Happy Learning. Come back later for more content on Geospatial Data Science & Remote Sensing.Cheers!!!

Image Compositing, Masking, Mosaicking, Projection, Visualization and Earth Engine Image Exporting

geedevsnairobi — Sun, 29 Oct 2023 11:20:13 +0000

This week's focus will be a deep dive into exploring imageCollections.

The learning objectives of this article are:

Image Compositing
Image Masking and mosaicking
Image Projection and Reprojection
ImageCollection visualization
ImageCollection Exporting to Google Drive

Like any other data science project, our first step is to define our region of interest. On defining the area of interest, we will set the map output at the center. For this project, our objective is to create a composite for Nairobi region in Kenya. We will then use Landsat 8 USGS Landsat 8 Collection 2 Tier 1 TOA Reflectance. Let us load Landsat 8 from the Earth Engine Data Catalogue. We will search Landsat 8, USGS Landsat 8 Collection 2 Tier 1 TOA Reflectance through the search bar then click import. The below image details will appear. The image contains multiple properties which can be explored for easy image preprocessing. At this page, we can import again at the lower button to load the data into Earth Engine code editor.

When we import the image, it will appear at the top of Earth Engine code editor under the imports as a variable with a default name imageCollection for the case of Image Collections. If
To produce filter imageCollection we will narrow to the year of 2016 by filtering by dates with use of the ee.ImageCollection.filterDate function then filter by region of interest using ee.ImageCollection.filterBounds functions.

Let us try to access Landsat-8 into Earth Engine editor

var Landsat8 = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
                .filterDate('2016-01-01', '2016-12-31')
                .filterBounds(roi);
var dataset = Landsat8.select(['B4', 'B3', 'B2']);

When the image is loaded it is important to position the image at the center of the Earth Engine interface by issuing coordinates for our region of interest and a zoom level. To center our image, we use Map.setCenter function. We then add Map.addLayer function to visualize the image at the center of the Earth Engine Interface.

ImageCollection Compositing

Image compositing is the technique in Google Earth Engine used to combine spatially overlapping images into a single image based on an aggregation function like Mean, Median etc.
For example, we can create an image composite by applying a selection criterion to each pixel based on all pixels in the stack. The images could be taken at different times.
Here we use the .median() function to create a composite where each pixel value is the median of all pixels from the stack.

If we want to create an image composite, ee.ImageCollection class is an handy function. It allows image collection manipulation and processing of large image collections. Let us try to create an image composite with ee.ImageCollection.median().
Other functions which can used to create an image composite could be ee.ImageCollection.qualityMosaic(), and ee.ImageCollection.mosaic().

Let us try compositing our imagecollection by mean function.

// Image compositing
var compositing = dataset.median();
Map.addLayer(compositing, visParams, 'This is an Image Composite');

Image Mosaicking

Besides image compositing we can also perform image mosaicking which is the process of assembling spatial image datasets to produce a single spatially continuous image. During mosaicking process, each pixel in the output image is taken from a different input image. Mosaicking process is often used to fill in a gap of data – used when there is missing data in some of the input images and there is a need for a complete image.

var mosaicking = dataset.mosaic();
// Display the median imageColle after mosaicing.
Map.addLayer(mosaicking, visParams, 'This is mosaiced Image');

Earth Engine Reducers

Earth Engine Reducers are objects used aggregate data over time, bands, space, and arrays.
When computing an imageCollection ee.Reducer class specifies the technique of data aggregation. Let us say you want to perform simple statistics, you can use the aggregation functions such as (min, mean, max, median, and standard deviation). It is important to note that, reducers take input dataset to produce a single output. Reducers result to a single image upon successful completion of pixel computations.

var Landsat8 = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
                .filterDate('2016-01-01', '2016-12-31')
                .filterBounds(roi);             
var dataset = Landsat8.select(['B4', 'B3', 'B2']);              
// Define visualization parameters
var visParams = {
bands: ['B4', 'B3', 'B2'], 
min: 0.0,
max: 0.4};
Map.setCenter(36.90966120185066,-1.2781566341946728, 6);
Map.addLayer(dataset, visParams, 'Image before reduction is done');

There are different ways to reduce an image. I will share some code here for more exploration

// Get the median,mean,max,min,sum,product over time, in each band, in each pixel.
var median = dataset.median();
Map.addLayer(median, visParams, ' Median Reduction');

var mean = dataset.mean();
Map.addLayer(mean, visParams, ' mean Reduction');

var max = dataset.max();
Map.addLayer(max, visParams, ' Max Reduction');

var min = dataset.min();
Map.addLayer(min, visParams, ' min Reduction');

var sum = dataset.sum();
Map.addLayer(sum, visParams, ' sun Reduction');

var product = dataset.product();
Map.addLayer(product, visParams, ' product Reduction');

ImageCollection Projection & Re-projection

Unless you need to perform a specific computation, there is no need to specify a new projection.

There is no need to worry about map projection when working in Google Earth Engine because the computation scale is a pull function. Inputs are asked during projection process and the outputs can be determined from functions like (crs). A projection propagates back via sequence of operations.

ImageCollection Visualization

ImageCollection Visualization is the activity of displaying the prepared image on the map to extract insightful information or exportinting it to drive, assets, or Google cloud for extended analysis. When an image is processed it cannot appear automatically on the map, as a result we need to write some code to display our processed image. Image Compositing can be visualized as either an animation or a series of thumbnails. We need to add ImageCollection layer to the map panel then read it using Map.addLayer method. In it we have to define the visualization parameters, bands, minimum and maximum values, color palette and opacity for better image visualization. In case you add a new map layer without any additional parameters, the code editor assigns the first three bands to red, green and blue, respectively. To achieve a good visualization effect it is advisable you provide image visualization parameters to Map.addLayer() method.

Earth Engine ImageCollection Exporting

Image you have prepared your image and it is now time to export it for further analysis with external softwares. Exporting Images can take different forms in Earth Engine, firstly could export in form of a GeoTIFF or TFRecord format. Other exportable items from Earth Engine include map tiles, tables and video.

Places to export these earth engine items;

Export to Google Drive
Export to Google Cloud Storage
Export to a new Earth Engine asset.

The first step in image exporting process is defining the data to be exported. Next is to define the projection parameters. In this case, we use the crs parameter to specify the coordinate system and the crsTransform parameter to precisely specify the pixel grid. When done it is time to export an image to Drive account, using the Export.image.toDrive()function.

// Export the image, specifying the CRS, transform, and region.
Export.image.toDrive({
  image: landsat,
  description: 'imageToDriveExample_transform',
  crs: projection.crs,
  crsTransform: projection.transform,
  region: geometry
});

On running the above code snippet an export task is created in the Code Editor Task tab. Go to this tab and click Run button to start it. When completed, the image will be created in your Google Drive account within the specified folder and fileFormat.

Using Earth Engine asset ID to access ImageCollection in Earth Engine IDE for filtering

geedevsnairobi — Sun, 29 Oct 2023 10:18:26 +0000

Google Earth Engine – a geospatial cloud platform for planetary-scale geospatial analysis with extensive computational capabilities brings an array of high-impact societal challenges including drought, disaster, deforestation, water pollution monitoring, food security, climate monitoring and environmental protection. An exciting feature of Earth Engine is the ability to host petabytes of raster data - Images then processes them within the cloud platform without downloading the enormous remote – sensing to your computer.

imageCollection defines a stack of similar image objects.

It is like saying, Image + Image = imageCollection

Today we will focus on writing codes related to imageCollection in the Earth Engine Code Editor.
We will;

Access raster image collections from Earth Engine data catalog
Filter them temporally - by a date
Filter spatially – by region or bound
Filter clouds
Explore some image processing functions like .max

Our true Hypothesis is that before getting into writing everybody has a verified Google Earth Engine Account. If not refer to our previous article on how to get you ready.

Accessing ImageCollection from Earth Engine catalog

This is the first step, done using the Image’s Earth Engine ID. Another approach to use ImageCollection is by creating ImageCollection from lists of images. It is possible also to create new imageCollections by merging existing collections. The print function will print Image information on the console. However, the console printout cannot print more than 5000 elements. Anytime you print a large collection will be correspondingly slower or result to the below error..

At this time we are going to start by loading our imagineCollection from Google Earth Engine.

Loading the image collection using the `ImageCollection` constructor

var sent2Coll = ee.ImageCollection('COPERNICUS/S2_SR')
                //Filter dates
                  .filterDate('2010-01-01', '2016-12-31');
// print the output
print(sent2Coll);

Imagine you are a seasoned Pro, and you wanted to Do it yourself – create your own imageCollection. Earth Engine has this ee.ImageCollection.fromImages() enabling function. Please try the below code in your Earth Engine Code Editor to test it.

Create a collection with fromImages() function in the earth engine.

var collFromImages = ee.ImageCollection.fromImages(
  [ee.Image(3), ee.Image(4), ee.Image(5), ee.Image(6)]);  
print('collFromImages: ', collFromImages);

Another exciting hack is creating arbitrary constant images using the Image constructor. This is very useful when wanting to test a hypothesis or creating a data model to validate results from a comparing method or procedure. Let us say you’re a research fellow at World Resource Institute, and you want to create a land cover classification and cloud-free imageCollection..the following code would be handy to while trying to crack codes at Carbon lab,

Create imageCollection from Images This approach works best when we want to create arbitrary constant images with help of an Image constructor

var image1 = ee.Image([1, 2,3])
var image2 = ee.Image([1, 2,3])
var image3 = ee.Image([1, 2,3])

Earth Engine ImageCollection Filtering Techniques

Up to this point, we have our data ready in the EE IDE ready to start our preprocessing steps – Filtering, and performing mathematical functions. As illustrated in the Image Filtering section, Earth Engine provides a range of convenient approaches to filter image collections. We will quickly start with filtering our image collection and getting the first image out of the collection. In this case .first() will be useful. Just see how to implement it.

Filter first image in ImageCollection

The .first method helps us get the first image in the image collection stack.

  var firstImage = sentinel2Collection.first()
  print(firstImage)

Filter by bounds

Filter bounds function is essential when we want to concentrate our focus in the area of interest.

  var second = sentinel2Collection.bound()
  print(second)

Filter Clouds in ImageCollection

Imagine working on a project which is going to positively impact people living in severely cloud-affected region. How would you ensure reliability, effectiveness and efficiency of your project? Cloud coverage is a major challenge in space-borne optical remote sensing as it hampers real-time monitoring of the earth’s surface. The code below will show you how to remove clouds from an ImageCollection. The resulting image is artifact-free

Earth observation projects face the data generating process challenge. As a result, developers, and researchers ought to deal with clouds while conducting land cover, or even vegetation analysis for better results.

Earth Engine provides an array of techniques for filtering image collections. Some of the frequently used filtering techniques are; imageCollection.filterDate(), and imageCollection.filterBounds(). For general purpose filtering, use imageCollection.filter() with an ee.Filter as an argument.
both convenience methods and filter() to identify and remove images with high cloud cover from an ImageCollection.
Let us try to filter by date, then bounds then ensure we filter to remove all clouds - to remove all clouds we use the ee.Filter.eq method then assign cloud_cover as 0.

var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA')
  .filterDate('2016-01-01', '2018-01-01')  
  .filter(ee.Filter.calendarRange(11, 2, 'month'))  
  .filterBounds(ee.Geometry.Point(25.8544, -18.08874));  

// Filter the collection by the CLOUD_COVER property.
var filtered = collection.filter(ee.Filter.eq('CLOUD_COVER', 0));

Exploring ImageCollection Properties and Metadata

We can get to know more details of an ImageCollection by exploring its details. While data information provided in data catalog is essential, some Earth Engine functions could be handy in deeper image exploration. Let us say for example we want to print image objects to explore band names, projection information, properties, and other metadata.

Let us try to print metadata of our image

// Load an image.
var image = ee.Image('COPERNICUS/S2_SR');

// Display all metadata.
print('This is Image metadata:', image);

We could get a list of all metadata properties using the following code.

var properties = image.propertyNames();
print('Metadata properties:', properties);

Count the images in an ImageCollection Stack Let us, try to count the number of images - the .size method used in the below code prints the total number of the images contained in the ImageCollection stack.

print(sentinel2Collection.size());

Like any other data science project, while working with in geospatial data analysis we can do statistical computations within Earth Engine Code Editor. The interesting part of it is that it does not infer image pixels based on statistical models but utilizes the posteriori information measured.

The .aggregate_stats function in image filtering process help us to understand basic statistical information about the imageCollection. Information about standard deviation, can be understood when we use the .aggregate_stats function.

Let us try it

// get statistics for a image coll
var Stats = dataset.aggregate_stats('SUN_ELEVATION');
print(Stats);

Imagine during your imageCollection preparation you wanted to get its mean value, the .mean method would be helpful at this point.

I would like we try it,

// var mean = dataset.mean(); 
// print(mean);

--- and we are done for today. I will appreciate hearing from you. You can share your recommendations, suggestions or enquiries for better articles in the future.

Writer Nicholas Musau

Creating an Earth Engine Cloud Project

geedevsnairobi — Sun, 15 Oct 2023 09:39:28 +0000

Image credits
Google Earth Engine is a Geospatial cloud platform that enable monitoring users to monitor and measure earth and environmental changes at a planetary scale. It hosts 70 plus petabytes of historic and present earth observation data in its’ data catalog. The cloud platform offers intrinsically-parallel computation access to thousands of cloud computers. Even though the initial intent was to enhance the scientists’ operational deployment methods, while strengthening public institutions and NGOs’ ability to understand, manage and report on natural resources, Earth Engine is gradually getting adoption in various industries and commercial operations. Earth Engine cloud platform supports crucial geospatial data preprocessing techniques like:

Generation of on-demand of spatial and temporal mosaics
Fast calculation and computation of a range of spectral indices
Computation of best-pixels composites- removal of image clouds and gaps in imageries
Machine learning operations in the cloud IDE on satellite imageries
Creating of publishable geospatial Apps

Earth Engine is integrated with Google Cloud Platform through the Earth Engine REST API. Users make calls to the Earth Engine through a cloud project. It is imperative to register Earth Engine projects to facilitate accessing of Earth Engine API which;

Enables usage of satellite data in the data catalog
Monitoring of EE apps at project level
Manage assets and permissions in the platform
Monitor success rate of requests send to Earth Engine service – this helps to debug and optimize Earth Engine powered workflows
Facilitates permissions to configured applications
Manages project groups or collaborators

Let’s Get started

The first step is to go directly to this page. To make EE calls with Google Cloud Project (GCP), you’ll need to have a Google Account, Google Cloud Project then enable Earth Engine API to that project.

Enabling a Cloud Project with Earth Engine helps to;

Use the REST API
Use a service account for authentication
Create an App Engine app that uses Earth Engine
Use a Client ID to uniquely identify an App and pass user credentials

The first step is to click on Create a Cloud project button if you did not have it before, then follow the steps to have a successful cloud project.
Next is to click the button Enable the Earth Engine API for your created project

The next step is to go to Enable Engine API, the photo below shows you how to go about it,

Up to this point we've created a Google Cloud Project and Enabled our Earth Engine API.

Next is to create an Earth Engine Project, go to this link for easy access of the page. For learning purposes we'll register the noncommercial option, then in the step select Unpaid usage. We have to select our project type. Since we are getting started, we have to Create a new Google Cloud Project then continue to summary.

The next step is to enter our project name, then go to confirm page which upon clicking will prompt us to land on the Google Earth Engine IDE. At this point we're good to get started in working on other Earth Engine projects.

Article Writer: Nicholas Musau

Introduction to GEE, CLIMATE Engine, and Satellite Data

geedevsnairobi — Fri, 28 Apr 2023 05:49:52 +0000

Earth data
Google Earth engine
Climate Engine

Earthdata:

Is the home for full and open access to NASA's Earth science data collections, accelerating scientific advancement for societal benefit.

Google Earth Engine:

Is a geospatial processing service. With Earth Engine, you can perform geospatial processing at scale, powered by the Google Cloud Platform. The purpose of Earth Engine is to: Provide an interactive platform for geospatial algorithm development at scale.

Climate Engine:

The Climate Engine enables users to quickly process and visualize satellite earth observations and gridded weather data for environmental monitoring and to improve early warning of drought, wildfire, and crop-failure risk. Instead of processing entire archives, focus on data discovery and answers.

The figure above shows the remote sensing workflow that one needs to follow for their end-to-end projects and illustrates that we can download data all at once and then focus on the type of problem we are trying to solve in data science.

GEE has alot of datasets ranging from using satellites like Landsat, Copernicus, NOOA, and MODIS.among these the data is either updated daily as for modis,others maybe weekly while others are monthly.
According the GEOFORGOOD2019 we have 290 public datasets which means 5 million images.

The image represents the ease of use of the platforms to perform geospatial calculations. Javascript editor is the fastest in computation as it is cloud-based. Python comes second and we need to prefer Google Colab as its the second in the hierarchy.

As we have many images over the years it would be important as a geospatial data scientist to make sure you filter your images to only the required period, in this case, we use “filterdate” , command as shown below.

Again we can reduce images either by mean or median which would work well if you have a large coverage area.

We can also have optical or synthetic images
Synthetic Imaging is the creation of two-dimensional optical images by means of mathematical modeling computations of compiled data rather than by the more traditional photographic process of using light waves focused through cameras or other optical instruments.

GEE API & Machine Learning

We have different classifiers to do classification, regression, and clustering EE. Here is the list.

If you are using tensorflow for either academic or commercial use you will have to pay or rather it will come at a cost since it uses GCP assets.

Google Eart Engine Experts

Who is a GEE expert?
Google Developers Expert is a person recognized by Google as having exemplary expertise in web technologies or Google Developers product.
Google usually has different categories of experts from Android, web,machine learning,GEE etc.
The list below shows the first GEE experts in 2022.

Process Of Becoming a GEE Expert

Nomination by anyone in the Google team.
Screening
Interviews
Announcement

Credits Keiko Nomura, PhD ,Director Of Science Applications, SpatiaFi

Thank you!

Getting Started with Google Earth Engine

geedevsnairobi — Fri, 28 Apr 2023 05:15:58 +0000

Google Earth Engine (EE) is a planetary cloud platform which supports data catalogue and the online IDE. It runs on Google’s cloud infrastructure and boasts a petabyte-scale database. The Earth Engine's public data catalog provides more than 40 years of historical imagery and scientific datasets, including satellite data like Landsat, Sentinel-2, and MODIS, as well as geophysical, weather, climate, and demographic data.

EE is a useful Earth Observation cloud platform using Geospatial Data to Fight Climate Change which can help us;

Monitor area of water body, vegetation, and other land uses
Monitor the atmosphere
Correlate area with production in agriculture

Google Earth Engine present the following benefits that makes it easy for use.

Completely cloud-native (No image download, no HPC)
JavaScript and Python
Easy web app
Intergradation with external API and visualization with Kepler.gl
Petabyte worth of datasets
Free for non-profit Two Dataset Types: Image VS Image Collection

Things which do not change much over time e.g. elevation
Things that change e.g. temperature, precipitation

Loading image in GEE Code Editor in JavaScript
We declare var name then use the ee.Image an object used to represent an Earth Engine Image followed by the Image itself.

var elevation_dataset = ee.Image("NASA/NASADEM_HGT/001")

More detailed

// Import the dataset and select the elevation band.
var dataset = ee.Image('NASA/NASADEM_HGT/001');
var elevation = dataset.select('elevation');

// Add a white background image to the map.
var background = ee.Image(1);
Map.addLayer(background, {min: 0, max: 1});

// Set elevation visualization properties.
var elevationVis = {
  min: 0,
  max: 2000,
};
// Set elevation <= 0 as transparent and add to the map.
Map.addLayer(elevation.updateMask(elevation.gt(0)), elevationVis, 'Elevation');
Map.setCenter(17.93, 7.71, 2);

Alternatively when loading Image Collection we use the ImageCollection object.

An ImageCollection is a stack or sequence of images. An ImageCollection can be loaded by pasting an Earth Engine asset ID into the ImageCollection constructor found in ImageCollection IDs in the data catalog. For example, to load the Sentinel-2 surface reflectance collection:

var sentinelCollection=ee.ImageCollection('COPERNICUS/S2_SR');

More detailed

var ImageColl = ee.ImageCollection('MODIS/006/MOD13A1')
                                  // Filter by dates
                  .filter(ee.Filter.date('2015-03-01', '2020-03-31'))
                  .select('NDVI') //select the NDVI
                  .mean()         //create a composite of mean
                  .clip(Roi);     //clip the map to region of interest

var ndviParams = {min: -2000, max: 10000, palette: [
    'FFFFFF', 'CE7E45', 'DF923D', 'F1B555', 'FCD163', '99B718', '74A901',
    '66A000', '529400', '3E8601', '207401', '056201', '004C00', '023B01',
    '012E01', '011D01', '011301'
  ]};
                                  // zoom the map at the center 
Map.centerObject(Roi, 7)
                                  // create the layers to be printed 
Map.addLayer(ImageColl,ndviParams,'NDVI2')

Reducing an ImageCollection

Reducers in EE are used to aggregate data over time, space, and other data structures. To composite images in an ImageCollection, use imageCollection.reduce(). This will composite all the images in the collection to a single image representing. They belong to the ee.Reducer class. Specifically, the output is computed pixel-wise, such that each pixel in the output is composed of the median value of all the images in the collection at that location. To get other statistics, such as min, max, standard deviation, mean, sum, variance, or even an arbitrary percentile, of the images. The appropriate reducer should be selected and applied appropriately.
Reducers take an input dataset and produce a single output. When a single input reducer is applied to a multi-band image, Earth Engine automatically replicates the reducer and applies it separately to each band. As a result, the output image has the same number of bands as the input image; each band in the output is the reduction of pixels from the corresponding band in the input data. Some reducers take tuples of input datasets. These reducers will not be automatically replicated for each band. For example, ee.Reducer.LinearRegression() takes multiple predictor datasets (representing independent variables in the regression) in a particular order.
Learn more about Reducers from Reducer Overview page and Image Reduction approaches

There two types of reducers

Vertical Reduce (over time)
Horizontal Reduce on Image (over space)

Google Earth Engine integration with Kepler.gl

This integration facilitates and presents EE scalability with external platforms. Kepler is a Python library for visualizing geospatial data in Jupyter notebooks. Kepler.gl is a high-performance web-based tool created by the Uber’s Visualization Team for visual exploration of large scale geospatial datasets. It is used to render large-scale interactive maps. EE Python API and Kepler.gl works best for deployment and non-geospatial scientists.

Google Earth Engine comes with some challenges.

To search for locations with similar metadata:
How to divide the globe into small grid tiles?
How to handle the enormous computing requirement?
How to save the tile results?

GEE COMMUNITY INTRO

geedevsnairobi — Sun, 15 Jan 2023 09:28:51 +0000

Welcome to gee community Nairobi.
Our goal is to help you get everything in remote sensing.

DEV Community: geedevsnairobi

A Standard Exploration of Google Earth Engine Feature Collections

Getting Started With Google Earth Engine Functions

Introduction

What’s a Function?

Global & Local Variables

Image Compositing, Masking, Mosaicking, Projection, Visualization and Earth Engine Image Exporting

ImageCollection Compositing

Image Mosaicking

Earth Engine Reducers

ImageCollection Projection & Re-projection

ImageCollection Visualization

Earth Engine ImageCollection Exporting

Using Earth Engine asset ID to access ImageCollection in Earth Engine IDE for filtering

Accessing ImageCollection from Earth Engine catalog

Earth Engine ImageCollection Filtering Techniques

Exploring ImageCollection Properties and Metadata

Creating an Earth Engine Cloud Project

Let’s Get started

Introduction to GEE, CLIMATE Engine, and Satellite Data

Contents

Earthdata:

Google Earth Engine:

Climate Engine:

GEE API & Machine Learning

Google Eart Engine Experts

Process Of Becoming a GEE Expert

Getting Started with Google Earth Engine

Reducing an ImageCollection

Google Earth Engine integration with Kepler.gl

Google Earth Engine comes with some challenges.

GEE COMMUNITY INTRO