Forem: geedevsnairobi

Getting Started With Google Earth Engine Functions

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

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!!!

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.

Forem: geedevsnairobi

Getting Started With Google Earth Engine Functions

Introduction

What’s a Function?

Global & Local Variables

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