Google Earth Engine – Calculating Equation from Two Collection Images

google-earth-enginegoogle-earth-engine-javascript-apiimage

I've got stuck when I'm trying to calculate MNDISI with MODIS. FYI, to calculate MNDISI, that should use LST collection image and SR collection image, so I'm trying to combine MODIS Surface Reflectance (MODIS/006/MOD11A1) and MODIS LST (MODIS/006/MOD09GA).

But I've got an error with the command:

Number (Error) reduce.mean: Error in map(ID=2020_01_01): Image.select:
Pattern 'LST_Day_1km' did not match any bands.

var jawa = ee.FeatureCollection("projects/ee-tugasakhirkkh/assets/Daerah_Penelitian");
Map.centerObject(jawa,7);

//Define Research Time
  var start = ee.Date('2020-01-01');
  var end = ee.Date('2020-12-31');
  
//Convert Kelvin to Celcius
  function celcius(img){
    return img.multiply(0.02).subtract(273.15)
              .copyProperties(img,['system:time_start']);
  }
//LST Terra MODIS 
  var terra_kelvin = ee.ImageCollection('MODIS/006/MOD11A1')
                       .select('LST_Day_1km')
                       .filterDate(start,end);
  var terra_LST = terra_kelvin.map(celcius);
  print(terra_LST);
  
var modisProjection = terra_LST.first().projection();
print('MODIS LST Projection:', modisProjection.nominalScale());

//Downsetting Function
function reduceres(image){
  return image.reduceResolution({
    reducer : ee.Reducer.mean(),
    maxPixels : 1024
  })
  .reproject({
    crs : modisProjection
  });
}

//MNDISI Function
function MNDISIModis(a){
  var green = a.select('sur_refl_b04'); 
  var swir = a.select('sur_refl_b05');
  var nir = a.select('sur_refl_b02');
  var b = 3;
  var lst = a.select('LST_Day_1km');
  var mndwi = (green.subtract(swir)).divide(green.add(swir)).rename('mndwi');
  var mndisi = (lst.subtract((mndwi.add(nir).add(swir)).divide(b))).divide(lst.add((mndwi.add(nir).add(swir)).divide(b))).rename('mndisi');
  return a.addBands(mndisi).copyProperties(a,['system:time_start']);
}

//MNDISI Terra
var terra_SR = ee.ImageCollection("MODIS/006/MOD09GA")
                .filterDate(start,end)
                .map(MNDISIModis)
                .map(reduceres)
                .map(function(img){
                        return img.addBands(terra_LST.filter(ee.Filter.eq('system:index',img.get('system:index'))))
                     })
    
var terraMNDISI = terra_SR.select('MNDISI').mean();
var terraMNDISI_clip = terraMNDISI.clip(jawa);

//Check the Resolution
var terra_proj = terraMNDISI_clip.projection();
print('MODIS MNDISI Projection:', terra_proj.nominalScale());

var param = {
  min: -1.0,
  max: 1.0,
  palette: [
    'FFFFFF', 'CE7E45', 'DF923D', 'F1B555', 'FCD163', '99B718', '74A901',
    '66A000', '529400', '3E8601', '207401', '056201', '004C00', '023B01',
    '012E01', '011D01', '011301'
  ],
};

Map.addLayer(terraMNDISI_clip,param,'Average MNDISI in 2020');

//Create Legend
//CreatePalette
function makeColorBarParams(palette) {
  return {
    bbox: [0, 0, 1, 0.1],
    dimensions: '200x20',
    format: 'png',
    min: 0,
    max: 1,
    palette: palette,
  };
}

//Create ColorBar
var colorBar = ui.Thumbnail({
  image: ee.Image.pixelLonLat().select(0),
  params: makeColorBarParams(param.palette),
  style: {stretch: 'vertical', margin: '0px 8px', maxHeight: '24px'},
});

//Create Panels
var legendLabels = ui.Panel({
  widgets: [
    ui.Label(param.min, {margin: '4px 5px', textAlign: 'left'}),
    ui.Label(param.max, {margin: '4px 170px', textAlign: 'right'})
  ],
  layout: ui.Panel.Layout.flow('horizontal')
});

var legendTitle = ui.Label({
  value: 'Average MNDISI in 2020',
  style: {fontWeight: 'bold'}
});

//Show Legend
var legendPanel = ui.Panel([legendTitle, colorBar, legendLabels]);
Map.add(legendPanel);

I haven't found any related reference to help solve my problem and tried with other combinations but still can't solve the problem.

Best Answer

The problem is functions order. First, you add LST band, then you compute MNDISI.

Also, this chunk won't work:

.map(function(img){
    return img.addBands(terra_LST.filter(ee.Filter.eq('system:index',img.get('system:index'))))
    })

You are mapping addBands() function trying to add bands from an ee.ImageCollection, it should be ee.Image type. No worries, .first() does the trick.

I recommend you to include addBands() in MNDISI calculation, as:

//MNDISI Function
function MNDISIModis(a){
  var green = a.select('sur_refl_b04'); 
  var swir = a.select('sur_refl_b05');
  var nir = a.select('sur_refl_b02');
  var b = 3;
  var lst = terra_LST.filter(ee.Filter.eq('system:index',a.get('system:index'))).first().select('LST_Day_1km');
  var mndwi = (green.subtract(swir)).divide(green.add(swir)).rename('mndwi');
  var mndisi = (lst.subtract((mndwi.add(nir).add(swir)).divide(b))).divide(lst.add((mndwi.add(nir).add(swir)).divide(b))).rename('mndisi');
  return a.addBands(mndisi).copyProperties(a,['system:time_start']);
}

Related Solutions

Google Earth Engine – Calculating Mean EVI for Multiple Polygons Across Image Collection

You should definitely try to export the result, which will likely solve the time out problem. Below is a toy example that replicates your two region reduction options and demonstrates exporting the tables as CSV files to your Google Drive account. A few things to note:

There is no need to clip each image by NU009, the region reducing functions will do this for you based on the provided argument to the geometry parameter. Additionally, if you are clipping an image by a featureCollection, be sure to use: clipToCollection() instead of clip().
The two options you are considering produce quite different results. Consider what kind of table output you want. The first calculates the mean of EVI of the aggregate pixels interesting the features of the featureCollection and the second calculates mean EVI per image per feature.
It is worth trying to export the results using the native 30m resolution and all of the features you currently have in the featureCollection and run it with the profiler (Crtl+Alt+Enter) so you can track what functions are using a lot of memory.
The toy example script uses only 5 months of imagery from one path/row and there are about 39 features. These attributes allow it to run quickly in the browser and export in about 1 minute. A larger time series with more features (and/or more complexity) may not process fast enough to print results to the Code Editor console (times out after 5 minutes) and may take much longer to export.

Code Editor script

/**
 * @license
 * Copyright 2019 Google LLC.
 * SPDX-License-Identifier: Apache-2.0
 * 
 * @description
 * An example of reducing all the elements of an imageCollection by all
 * the elements of a featureCollection and exporting the results to
 * Google Drive.
 */

// Import US counties and protected areas featureCollections. 
var counties = ee.FeatureCollection('TIGER/2018/Counties');
var protectedAreas = ee.FeatureCollection("WCMC/WDPA/current/polygons");

// Create a featureCollection that is all of the protected areas interesting
// Santa Clara County, CA, USA.
var scCounty = counties.filter(ee.Filter.eq('NAME', 'Santa Clara'));
var polys_filtered = protectedAreas.filterBounds(scCounty);

// Import a Landsat EVI collection and filter it by geographic extent and date
// range.
var l8 = ee.ImageCollection('LANDSAT/LC08/C01/T1_8DAY_EVI')
  .filterBounds(polys_filtered)
  .filterDate('2018-01-01','2018-06-01');



// Below are two options for summarizing a time series of EVI for the protected
// areas interesting Santa Clara County.

// #############################################################################
// ### REDUCE AGGREGATE REGIONS OPTION ###
// #############################################################################

// Merge the geometries of the 'polys_filtered' featureCollection into a single
// multiPolygon geometry.
var geom = polys_filtered.geometry();

// Define a function that will calculate mean EVI of all pixels within the
// multiPolygon geometry defined by the 'polys_filtered' featureCollection.
var reduceRegion = function(image) {
  // This regionReduction returns a dictionary; in this case a single key-value
  // pair for the mean summary of EVI.
  var meanEVI = image.reduceRegion({
    reducer: ee.Reducer.mean(),
    geometry: geom,
    scale: 30,
    bestEffort: true});
  // Along with mean EVI for the region (renamed), add some info about the image
  // that mean EVI is based on (the image ID and the image date). Define these
  // attributes in a dictionary.
  var props = {
    'meanEVI': meanEVI.get('EVI'),
    'imgID': image.id(),
    'date': image.date().format('YYYY-MM-dd')};
  // Return the information as a feature, so that the result of mapping this
  // function over a collection will be another collection that can be cast as
  // a featureCollection, which can be exported to Google Drive. Use the 'geom'
  // to defined the feature's geometry, and the 'props' dictionary to define the
  // properties of the feature.
  return ee.Feature(geom, props);
};

// Map the above function over the Landsat EVI imageCollection to calculate mean
// EVI per image for the region expressed by the merged geometries of all the
// features in the 'polys_filtered' featureCollection. Cast the result as a
// featureCollection.
var l8_reduceRegion = ee.FeatureCollection(l8.map(reduceRegion));

// Export the featureCollection (table) as a CSV file to your Google Drive
// account. The resulting table will have as many rows as there are images and
// three columns for the 'props' set above as well as some system properties
// added by default. The table will be written to the Google Drive account
// associated with your Earth Engine account and will be placed in a folder
// called 'reduce_region_test' and named 'l8_reduceRegion' - both provided as
// parameter arguments.
Export.table.toDrive({
  collection: l8_reduceRegion,
  description: 'l8_reduceRegion',
  folder: 'reduce_region_test',
  fileFormat: 'CSV'});

// Plot the table as a time series chart. X is the date, Y is mean EVI. There is
// only one series because all of the features' geometries are merged.
print(ui.Chart.feature.byFeature(l8_reduceRegion, 'date', 'meanEVI'));



// #############################################################################
// ### REDUCE BY INDIVIDUAL REGIONS OPTION ###
// #############################################################################

// Define a function to be mapped over the EVI image collection that calculates
// mean EVI per image for all polygons in the 'polys_filtered' featureCollection
// using the 'reduceRegions' method.
var reduceRegions = function(image) {
  var meanEVI = image.reduceRegions({
    collection: polys_filtered,
    reducer: ee.Reducer.mean(),
    scale: 30});
  // Return the featureCollection with the EVI mean summary per feature, but
  // first...
  return meanEVI
    // ...remove any features that have a null value for any property.
    .filter(ee.Filter.notNull(['mean']))
    // ...map over the featureCollection to edit properties of each feature.
    .map(function(feature) {
      // Return the feature, but first...
      return feature
        // ...select only two properties of interest; there are about 30
        // (all of the properties of the original feature plus mean EVI), not all
        // are necessary in this case. Also rename the 'mean' property returned
        // be default from the above reduceRegions function to 'meanEVI'.
        .select(['mean', 'WDPAID'], ['meanEVI', 'WDPAID'])
        // ..add an image ID and date property of the image being reduced.
        .set({
          'imgID': image.id(),
          'date': image.date().format('YYYY-MM-dd')
      });
  });
};

// Apply the above defined function to all images. The result will be a
// collection of featureCollections. Each collection contains all of the
// 'polys_filtered' features with a set of properties that describe the mean
// EVI for each feature along with an image ID from which EVI is based on
// and the date of the image.
var l8_reduceRegions = l8.map(reduceRegions)
  // Flatten the collection of featureCollections into a single featureCollection.
  .flatten();

// Export the featureCollection (table) as a CSV file to your Google Drive account.
// See the above note on 'Export.table.toDrive' for more information.
Export.table.toDrive({
  collection: l8_reduceRegions,
  description: 'l8_reduceRegions',
  folder: 'reduce_region_test',
  fileFormat: 'CSV'
});

// Plot the table as a time series chart. X is the date, Y is mean EVI. There
// are same many series as there are features in the 'polys_filtered' feature
// featureCollection.
print(ui.Chart.feature.groups(l8_reduceRegions, 'date', 'meanEVI', 'WDPAID'));

Best Answer

Related Solutions

Google Earth Engine – Calculating Mean EVI for Multiple Polygons Across Image Collection

Related Question