Google Earth Engine – Interpreting Scale Using Hansen Data

google-earth-enginescale

I previously posted about this same problem as Iterating over years for features in feature collection using Google Earth Engine?

I realized recently that the results that I was getting based on the solution were actually incorrect as I had misread what the variables mean. In fact, it is impossible to get the 'gain' in trees per year so I'm not really sure what the values the code computed were.

Anyhow, I've rewritten the code, and it seems to work in theory, but I am having difficulty with one aspect of it. In particular, I understand that the resolution of the Hansen data is 30 meters per pixel. For this reason, I followed the tutorial for the data and tried to set scale: 30 in my image reduction. However, this causes the console to time out, even though I set maxPixels: 1e9.

When I increase the scale to 100 or greater, it works fine. However, I have been reading about scale here: https://developers.google.com/earth-engine/scale and I still don't have a clear idea what exactly it means for the interpretability of my results. Ideally, I am trying to use the data to be able to talk about square meters of loss in forest, as they do in the tutorial: https://developers.google.com/earth-engine/tutorial_forest_03

Is it okay for me to set scale to higher than scale:30, and what will that mean for interpreting the computation?

Best Answer

As described here, use Export to overcome time out errors. If you are using a higher scale, the aggregated data will be resampled as necessary to perform the computation at the specified scale. However, the pyramiding policy of the 'loss' and 'gain' bands is mean, which means that two 0s and two 1s becomes a 1, introducing a slight positive bias. If you can get away with an export instead of reduced scale, that is the recommended approach.

Related Solutions

Google Earth Engine – Best Practices for Scale Parameters in GEE

If the goal is to match the intended computation scale and the native pixel resolution as implied in the Earth Engine scale documentation, one can determine the scale from the input image by checking its native pixel resolution using .projection().nominalScale()

In the case of your example, the native resolution is ~926.6 Not 1000, and this is probably the reason behind the different outcomes

Taking a simplified version of your example, one can see how determining the scale as 1000 instead of the native resolution could go wrong for counting four pixels

As an attempt to examine one possible way of how the counting went wrong (I stand to be corrected if the computation behave in the same way), one can create two grids by setting the scale; once to be determined by the image projection by default, and then to be forced as 1000. In the case of 1000, the grid alignment seems to be centered leaving pixel fractions all around the covered pixel!

   // testing polygon
var AUS = ee.Geometry.Polygon([[[143.46647287429622,-19.542272752714126]
,[143.49968935073665,-19.542272752714126]
,[143.49968935073665,-19.524557657732945]
,[143.46647287429622,-19.524557657732945]
,[143.46647287429622,-19.542272752714126]]]);

Map.addLayer(AUS,{},'testing polygon', 0)
Map.centerObject(AUS);

// Adding data
var dataset = ee.ImageCollection('FIRMS').select('T21').filterDate('2019-01-01', '2019-01-02');
var firms_toBands = dataset.toBands()

var Vis = {min: 50,max: 200,palette: ['b27b18', 'red']};
Map.addLayer(firms_toBands,Vis,'firms_toBands')


// Get projection and actual scale
print('crs', firms_toBands.projection());
print('Image Scale', firms_toBands.projection().nominalScale());

// pixel count for 1000, defaut and actual scale
var CountPx = function(scale){
              var count = firms_toBands.reduceRegion({
               geometry: AUS,
               reducer: ee.Reducer.count(),
               scale: scale});
  return count.get((firms_toBands.bandNames()).get(0))};

print('defined scale = 1000', CountPx(1000))
print('default scale', CountPx())
print('actual band scale = ~926.6', CountPx(firms_toBands.projection().nominalScale()))


// using the image projection to make  grids:
// 1. defined scale 1000 
var Definedgrid = (ee.Feature(AUS)).geometry().coveringGrid(firms_toBands.projection(),1000);
Map.addLayer(Definedgrid,{},'Definedgrid 1000m',0)
// 2. default (scale determined from projection)
var Defaultgrid = (ee.Feature(AUS)).geometry().coveringGrid(firms_toBands.projection());
Map.addLayer(Defaultgrid,{},'Defaultgrid')

Link for the code

Related Question