Timofei Moiseev

GIS-Specialist, ecologist

Relative elevation model (REM) and Google Earth Engine

In this tutorial you convert a digital elevation model (DEM) along the Kamchatka river into a relative elevation model (REM) using Google Earth Engine. This manual includes imagery processing and interpolation with Inverse Distance Weighted (IDW) method. The first guide was created by Daniel Coe for QGIS, but it is the first one for Google Earth Engine.

The example dataset includes an ArcticDEM (digital terrain model) the Kamchatka River valley in Kamchatka peninsula and polyline shp-layer (Kamchatka channel) from OSM (OpenStreetMap). You can do the project in the Google Earth Engine, except for one step.

This step may be easier to make in QGIS, ArcGIS etc.

REM (Relative elevation model) is used in observation of terraces, floodplains, oxbow lakes etc. You can read more about REMs by this link. Usially, specialists operate the LiDAR imagery, but it requires financial costs. However, even without LiDAR imagery, we can get a good result using open data. SRTM is useless for this purpose due to low spatial resolution (~30 meters), but ArcticDEM fits well (~2 meters).

First of all, we should register account in Google Earth Engine. Next we load the floodplain contours of the Kamchatka River and the layer with points along the channel (chainwaterways) to the project. We cheated a little bit and preprocessed the channel line in QGIS - we splited the line into points with equal interval of 80 m (this is the approximate average width of the Kamchatka river channel)

// It's river-points dataset along channel

var points = ee.FeatureCollection('projects/ee-moiseevt115/assets/chainwaterways');

// Floodplain polygon was created using bufer along Kamchatka river channel

var floodplain = ee.FeatureCollection('projects/ee-moiseevt115/assets/kamcha');

In the next step, we add and clip raster from the Google Earth Engine database along the boundaries of the Kamchatka River floodplain and load it. It is made to reduce cloud computation. Thereby, the area includes the landforms of Kamchatka valley (floodplain, terraces, etc). Let's look at the result:

// Add ArcticDEMs raster from Google Earth Engine

var dataset = ee.Image('UMN/PGC/ArcticDEM/V3/2m_mosaic');

// Add visualisation to raster

var elevationVis = {

min: 0.0,

max: 150.0,

palette: ['0d13d8', '60e1ff', 'ffffff'],

};

// Clip raster by Kamchatka river polygon

var geometry = floodplain.geometry();

var demClip = dataset.clip(geometry);

Map.addLayer(demClip, elevationVis, 'demClip');

ArcticDEMs clipping by floodplain Kamchatka river

Let's add elevation values to the point layer (we want know the altitude values in each point). For this purpose we convert the ArcticDEM image to imageCollection and use getRegion() function to add the elevation values from the image. Next, we modify the list to FeatureCollection and upload the file to Google Drive for further processing.

// Create ImageCollection

var topo = ee.Image.cat(demClip)

var topoCol = ee.ImageCollection([topo]);

// Add elevation from Arctic DEM to points

var sample = topoCol.getRegion(points, 30);

var keys = ee.List(sample.get(0))

// Convert List to FeatureCollection

var featureCollection = ee.FeatureCollection(sample.slice(1).map(function(singleData) singleData = ee.List(singleData);

var dict = ee.Dictionary.fromLists(keys, singleData);

var point = ee.Geometry.Point([dict.get('longitude'), dict.get('latitude')]);

var elevation = ee.Date(dict.get('elevation'));

return ee.Feature(point, dict);

}));

// Downlowd points with elevation to Google Drive

Export.table.toDrive(featureCollection, "elevation_points")

Next we remove some points that have no elevation values as well as negative values. We did this in QGIS. It can probably be done in Google Earth Engine as well. After processing points, we uploaded the file to our project.

var elevation_points = ee.FeatureCollection('projects/ee-moiseevt115/assets/Point_elevation');

We calculate the mean and standard deviation to interpolate our points with IDW method.

// Calculate mean value

var meanstats = elevation_points.reduceColumns({

reducer: 'mean',

selectors: ['elevation']

});

// Calculate standart deviation value

var SDstats = elevation_points.reduceColumns({

reducer: 'stdDev',

selectors: ['elevation']

});

// Interpolate elevation_points

var InterpolatedElev = elevation_points.inverseDistance({

range: 10000,

propertyName: 'elevation',

mean: meanstats.get('mean'),

stdDev: SDstats.get('stdDev'),

});

In the next step we subtract InterpolatedElev from the image with elevation that we loaded previously (ArcticDEM image). Let's add a palette for beautiful visualization.

// Subtract Intepolate layer from Arctic DEM

var image1 = demClip.select('elevation')

var image2 = interpolatedElev.select('elevation');

var REM = image1.subtract(image2);

// Add visualisation to raster

var band_viz = {

min: 0,

max: 15,

palette: ['F0F921', 'FBB32F', 'EB7852', 'CB4678', '9A179B', '5B02A3', '0D0887']};

// Add layer to map

Map.addLayer(REM, band_viz, 'REM');

Finally, we obtain a REM raster with elevation relative to the Kamchatka riverbed. Also, we can download the raster to the desktop or cloud (e.g. Google Drive).

REM of Kamchatka river valley

ArcticDEM considers tree heights which can distort the result. Nevertheless, ArcticDEM is in open access, unlike Lidar imagery. Therefore, we got a satisfactory result, which is good fit for environmental science projects. Also we can process larger dataset then using QGIS.

Link to the project