Lab 9 - Thresholds

Background: Continuous vs. Categorical Data

Boolean Operators for Categorization

We will use Google Earth Engine to implement thresholds and categorize NDVI values. Logical operators like 'greater than' (gt), 'less than' (lt), and 'equal to' (eq) will be employed to separate the NDVI image into two categories: "no vegetation" or "vegetation."

Part 1: Creating an NDVI Image

Let's create a Sentinel-2 map of NDVI near Seattle, Washington, USA. Enter the code below in a new script.

// Create an NDVI image using Sentinel 2.
var seaPoint = ee.Geometry.Point(-122.2040, 47.6221);
var seaImage = ee.ImageCollection('COPERNICUS/S2')
    .filterBounds(seaPoint)
    .filterDate('2020-08-15', '2020-10-01')
    .first();

var seaNDVI = seaImage.normalizedDifference(['B8', 'B4']);

// And map it.
Map.centerObject(seaPoint, 10);
var vegPalette = ['red', 'white', 'green'];
Map.addLayer(seaNDVI,
    {
        min: -1,
        max: 1,
        palette: vegPalette
    },
    'NDVI Seattle');

Understanding the code:

• This is the same NDVI calculation from Lab 8
• Sentinel-2: B8 = NIR, B4 = Red
• NDVI ranges from -1 (water) to +1 (dense vegetation)

Inspect the image. We can see that vegetated areas are darker green while non-vegetated locations are white and water is pink. If we use the Inspector to query our image, we can see that parks and other forested areas have an NDVI of about 0.5. Thus, it would make sense to define areas with NDVI values greater than 0.5 as forested, and those below that threshold as not forested.

Part 2: Implementing a Threshold

Now let's define that value as a threshold and use it to threshold our vegetated areas.

// Implement a threshold.
var seaVeg = seaNDVI.gt(0.5);

// Map the threshold.
Map.addLayer(seaVeg,
    {
        min: 0,
        max: 1,
        palette: ['white', 'green']
    },
    'Non-forest vs. Forest');

Understanding .gt():

• Tests each pixel: "Is this value greater than 0.5?"
• Returns 1 if true (green in our palette)
• Returns 0 if false (white in our palette)
• The result is a binary image with only two values

Use the Inspector tool to explore this new layer. If you click on a green location, that NDVI should be greater than 0.5. If you click on a white pixel, the NDVI value should be equal to or less than 0.5.

Other operators in this Boolean family include:

• .lt() - Less than
• .lte() - Less than or equal to
• .eq() - Equal to
• .neq() - Not equal to
• .gte() - Greater than or equal to

Part 3: Using .where() for Multiple Classes

A binary map classifying NDVI is very useful. However, there are situations where you may want to split your image into more than two bins. Earth Engine provides the where method that conditionally evaluates to true or false within each pixel depending on the outcome of a test.

Let's split the image into three classes: water, non-forested, and forested areas using thresholds of -0.1 and 0.5:

// Implement .where.
// Create a starting image with all values = 1.
var seaWhere = ee.Image(1)
    // Use clip to constrain the size of the new image.
    .clip(seaNDVI.geometry());

// Make all NDVI values less than -0.1 equal 0.
seaWhere = seaWhere.where(seaNDVI.lte(-0.1), 0);

// Make all NDVI values greater than 0.5 equal 2.
seaWhere = seaWhere.where(seaNDVI.gte(0.5), 2);

// Map our layer that has been divided into three classes.
Map.addLayer(seaWhere,
    {
        min: 0,
        max: 2,
        palette: ['blue', 'white', 'green']
    },
    'Water, Non-forest, Forest');

Understanding the logic:

• Start with all pixels = 1 (this will become "non-forest")
• Set pixels with NDVI ≤ -0.1 to 0 (water)
• Set pixels with NDVI ≥ 0.5 to 2 (forest)
• Remaining pixels stay at 1 (non-forest)

Part 4: Remapping Values

The remap method takes specific values in an image and assigns them different values. This is particularly useful for categorical datasets when you need to standardize class codes.

// Implement remapping.
// Remap the values from the seaWhere layer.
var seaRemap = seaWhere.remap([0, 1, 2], // Existing values.
    [9, 11, 10]); // Remapped values.

Map.addLayer(seaRemap,
    {
        min: 9,
        max: 11,
        palette: ['blue', 'green', 'white']
    },
    'Remapped Values');

Understanding remap():

• First array: original values to find
• Second array: new values to assign
• 0 → 9, 1 → 11, 2 → 10

Use the inspector to compare values between our original seaWhere (displayed as Water, Non-Forest, Forest) and the seaRemap, marked as "Remapped Values." Click on a forested area to see that the Remapped Values should be 10, instead of 2.