[GIS] Exporting feature collection in Google Earth Engine

exportgoogle-earth-enginenlcd

I am working out the area (in hectares) of a land cover class in the counties of California using google earth engine. So far, I have created a featurecollection that works, but when I try to use the export to table function I get the following error:

Error: Feature, argument 'metadata': Invalid type. Expected: Dictionary. Actual: FeatureCollection.

I don't mind if the export is CSV or SHP – whichever is easiest as I will then analyze my data in R/arcpy.

My code is as follows:

print('starting...');
// Load a FeatureCollection of US Counties.
var Counties = ee.FeatureCollection("TIGER/2016/Counties");

//Imports NLCD Land Cover Data
var LandCover = ee.Image('USGS/NLCD/NLCD2011')

var cali = Counties.filter(ee.Filter.eq('STATEFP','06'));
Map.addLayer(cali, {}, 'cali');

// Clip the image to the polygon geometry
var LandCover = LandCover.clip(cali);


// Extract the landcover band
var landcover = LandCover.select('landcover');
Map.addLayer(landcover, {}, 'landcover');

// create masks for each class, then covert into area by multiplying by pixel
// area and dividing by class #, then sum reduce over the counties
// then export each as a table (if you can aggregate into one table)
// https://gis.stackexchange.com/questions/230774/extracting-land-cover-type-in-google-earth-engine

var lc11 = landcover.eq(52);
var mask11 = landcover.mask(lc11);
var pixarea = ee.Image.pixelArea();

var pix2area11 = mask11.select('landcover').multiply(pixarea.select('area')).divide(520000);

Map.addLayer(pix2area11, {}, 'pix2area11');

pix2area11 = pix2area11.select('landcover');
var area11 = pix2area11.reduceRegions({
  collection: cali,
  reducer: ee.Reducer.sum(),
  scale: 30,
});
// Print the first feature, to illustrate the result.
print(ee.Feature(area11.first()));

// Translate feature collection to table with necessary identifiers

area11 = area11.select(['sum', 'COUNTYFP', 'STATEFP']);


print(area11);
Map.addLayer(area11, {}, 'area11');

// Make a feature without geometry and set the properties to the dictionary of area11.
var feature = ee.Feature(null, area11);

// Wrap the Feature in a FeatureCollection for export.
var featureCollection = ee.FeatureCollection([feature]);

// Export the FeatureCollection.
Export.table.toDrive({
  collection: featureCollection,
  description: 'area11',
  fileFormat: 'CSV'
});
// https://developers.google.com/earth-engine/exporting

print('done');

Best Answer

The second argument of ee.Feature must be

properties (Object, optional): A dictionary of metadata properties. If the first parameter is a Feature (instead of a geometry), this is unused.

but you are using a ee.Feature instead of an Object (dictionary). What I understand is that you want to get rid of the geometry and only export the properties. Otherwise you could just export area11.

For exporting the collection without the geometries you can do:

// Wrap the Feature in a FeatureCollection for export.
var featureCollection = area11.map(function(feat){
  var nullfeat = ee.Feature(null)
  return nullfeat.copyProperties(feat)
})

Related Solutions

Google Earth Engine – Iterating Over Years for Feature Collection

You are filtering year in the correct way. This is how I'd do it:

//Load and filter the Hansen data
var gfc2014 = ee.Image('UMD/hansen/global_forest_change_2015')
              .select(['treecover2000','loss','gain','lossyear']);

// list for filter iteration
var years = ee.List.sequence(1, 14)

// turn your scale into a var in case you want to change it
var scale = gfc2014.projection().nominalScale()

//add country districts as a feature collection
var distr = ee.FeatureCollection('ft:1U7sXFHXtxQ--g7XMeXlvPhNXPBcDtPg8Yzr2pvsg', 'geometry');

//look at tree cover, find the area
var treeCover = gfc2014.select(['treecover2000']);

// most recent version of Hansen's data has the treecover2000 layer
// ranging from 0-100. It needs to be divided by 100 if ones wants
// to calculate the areas in ha and not hundreds of ha. If not, the
// layers areaLoss/areaGain are not comparable to the areaCover. Thus
treeCover = treeCover.divide(100); // Thanks to Bruno

var areaCover = treeCover.multiply(ee.Image.pixelArea())
                .divide(10000).select([0],["areacover"])

// total loss area
var loss = gfc2014.select(['loss']);
var areaLoss = loss.gt(0).multiply(ee.Image.pixelArea()).multiply(treeCover)
               .divide(10000).select([0],["arealoss"]);

// total gain area
var gain = gfc2014.select(['gain'])
var areaGain = gain.gt(0).multiply(ee.Image.pixelArea()).multiply(treeCover)
               .divide(10000).select([0],["areagain"]);

// final image
var total = gfc2014.addBands(areaCover)
            .addBands(areaLoss)
            .addBands(areaGain)

Map.addLayer(total,{},"total")

// Map cover area per feature
var districtSums = areaCover.reduceRegions({
  collection: distr,
  reducer: ee.Reducer.sum(),
  scale: scale,
});


var addVar = function(feature) {

  // function to iterate over the sequence of years
  var addVarYear = function(year, feat) {
    // cast var
    year = ee.Number(year).toInt()
    feat = ee.Feature(feat)

    // actual year to write as property
    var actual_year = ee.Number(2000).add(year)

    // filter year:
    // 1st: get mask
    var filtered = total.select("lossyear").eq(year)
    // 2nd: apply mask
    filtered = total.updateMask(filtered)

    // reduce variables over the feature
    var reduc = filtered.reduceRegion({
      geometry: feature.geometry(),
      reducer: ee.Reducer.sum(),
      scale: scale,
      maxPixels: 1e13
    })

    // get results
    var loss = ee.Number(reduc.get("arealoss"))
    var gain = ee.Number(reduc.get("areagain"))

    // set names
    var nameloss = ee.String("loss_").cat(actual_year)
    var namegain = ee.String("gain_").cat(actual_year)

    // alternative 1: set property only if change greater than 0
    var cond = loss.gt(0).or(gain.gt(0))
    return ee.Algorithms.If(cond, 
                            feat.set(nameloss, loss, namegain, gain),
                            feat)

    // alternative 2: always set property
    // set properties to the feature
    // return feat.set(nameloss, loss, namegain, gain)
  }

  // iterate over the sequence
  var newfeat = ee.Feature(years.iterate(addVarYear, feature))

  // return feature with new properties
  return newfeat
}

// Map over the FeatureCollection
var areas = districtSums.map(addVar);

Map.addLayer(areas, {}, "areas")

In that script you get 3 fields: loss_{year}, gain_{year}, sum But if you want better 4 fields: loss, gain, year, sum; change for:

return ee.Algorithms.If(cond, 
                        feat.set("loss", loss, "gain", gain, "year", actual_year), 
                        feat)

You could also compute percentage and set it to the features.

Edit: Thank to @Bruno_Conte_Leite, who made me reconsider my answer, I have made some updates, the one suggested by Bruno and others.

Scale: I suggest to keep the original scale of Hansen data.
treeCover: most recent version of Hansen's data has the treecover2000 layer ranging from 0-100. It needs to be divided by 100 if ones wants to calculate the areas in ha and not hundreds of ha. (Bruno)
areaLoss and areaGain: Added .multiply(treeCover) otherwise the area would be of the whole pixel and not of the indicated percentage
maxPixels: I added maxPixels: 1e13 in the reduction

Landsat – How to Apply a Cloud Filter to Landsat8 Collection in Google Earth Engine

You need to check how Image.reduceRegion works. From documentation:

reduceRegion(reducer, geometry, scale, crs, crsTransform, bestEffort, maxPixels, tileScale)

Apply a reducer to all the pixels in a specific region. Either the reducer must have the same number of inputs as the input image has bands, or it must have a single input and will be repeated for each band. Returns a dictionary of the reducer's outputs.

Arguments:

this:image (Image): The image to reduce.

reducer (Reducer): The reducer to apply.

geometry (Geometry, default: null): The region over which to reduce data. Defaults to the footprint of the image's first band.

...

maxPixels (Long, default: 10000000): The maximum number of pixels to reduce.

Change this argument to avoid this error message:

var cloudiness = cloud.reduceRegion({
reducer: 'mean', 
geometry: S_sudan, 
scale: 30,
maxPixels: 1e10
});

Best Answer

Related Solutions

Google Earth Engine – Iterating Over Years for Feature Collection

Landsat – How to Apply a Cloud Filter to Landsat8 Collection in Google Earth Engine

Related Question