feat: new Earth Engine format and functions (DHIS2-16097)

src/earthengine/__tests__/ee_worker_utils.spec.js

@@ -2,14 +2,14 @@ import { hasClasses, getHistogramStatistics } from '../ee_worker_utils'
 
 const scale = 1000
 
-const legend = [
+const style = [
     {
-        id: 9,
+        value: 9,
         name: 'Savannas',
         color: '#d99125',
     },
     {
-        id: 13,
+        value: 13,
         name: 'Urban and built-up',
         color: '#cc0202',
     },
@@ -76,14 +76,14 @@ describe('earthengine', () => {
             data,
             scale,
             aggregationType,
-            legend,
+            style,
         })
 
         const itemA = result['O6uvpzGd5pu']
         const itemB = result['fdc6uOvgoji']
 
         expect(ids).toEqual(Object.keys(result))
-        expect(Object.keys(itemA).length).toBe(legend.length)
+        expect(Object.keys(itemA).length).toBe(style.length)
         expect(itemA['9']).toBe(toPercent(0))
         expect(itemA['13']).toBe(toPercent(7))
         expect(itemB['9']).toBe(toPercent(5))
@@ -97,7 +97,7 @@ describe('earthengine', () => {
             data,
             scale,
             aggregationType,
-            legend,
+            style,
         })
 
         const itemA = result['O6uvpzGd5pu']
@@ -116,7 +116,7 @@ describe('earthengine', () => {
             data,
             scale,
             aggregationType,
-            legend,
+            style,
         })
 
         const itemA = result['O6uvpzGd5pu']

src/earthengine/ee_worker.js

@@ -1,5 +1,6 @@
 import { expose } from 'comlink'
-import ee from './ee_api_js_worker' // https://github.com/google/earthengine-api/pull/173
+import { getBufferGeometry } from '../utils/buffers.js'
+import ee from './ee_api_js_worker.js' // https://github.com/google/earthengine-api/pull/173
 // import { ee } from '@google/earthengine/build/ee_api_js_debug' // Run "yarn add @google/earthengine"
 import {
     getInfo,
@@ -9,15 +10,26 @@ import {
     getClassifiedImage,
     getHistogramStatistics,
     getFeatureCollectionProperties,
-} from './ee_worker_utils'
-import { getBufferGeometry } from '../utils/buffers'
-
-// Why we need to "hack" the '@google/earthengine bundle:
-// https://groups.google.com/g/google-earth-engine-developers/c/nvlbqxrnzDk/m/QuyWxGt9AQAJ
-
-const FEATURE_STYLE = { color: 'FFA500', strokeWidth: 2 }
+    applyFilter,
+    applyMethods,
+    applyCloudMask,
+} from './ee_worker_utils.js'
+
+const IMAGE = 'Image'
+const IMAGE_COLLECTION = 'ImageCollection'
+const FEATURE_COLLECTION = 'FeatureCollection'
+
+// Options are defined here:
+// https://developers.google.com/earth-engine/apidocs/ee-featurecollection-draw
+const DEFAULT_FEATURE_STYLE = {
+    color: '#FFA500',
+    strokeWidth: 2,
+    pointRadius: 5,
+}
 const DEFAULT_TILE_SCALE = 1
 
+const DEFAULT_MASK_VALUE = 0
+
 class EarthEngineWorker {
     constructor(options = {}) {
         this.options = options
@@ -102,12 +114,23 @@ class EarthEngineWorker {
             return this.eeImage
         }
 
-        const { datasetId, filter, mosaic, band, bandReducer, mask, methods } =
-            this.options
+        const {
+            datasetId,
+            format,
+            filter,
+            periodReducer,
+            mosaic,
+            band,
+            bandReducer,
+            maskOperator,
+            methods,
+            style,
+            cloudScore,
+        } = this.options
 
         let eeImage
 
-        if (!filter) {
+        if (format === IMAGE) {
             // Single image
             eeImage = ee.Image(datasetId)
             this.eeScale = getScale(eeImage)
@@ -119,18 +142,26 @@ class EarthEngineWorker {
             this.eeScale = getScale(collection.first())
 
             // Apply array of filters (e.g. period)
-            filter.forEach(f => {
-                collection = collection.filter(
-                    ee.Filter[f.type].apply(this, f.arguments)
-                )
-            })
+            collection = applyFilter(collection, filter)
+
+            // Mask out clouds from satellite images
+            if (cloudScore) {
+                collection = applyCloudMask(collection, cloudScore)
+            }
 
-            eeImage = mosaic
-                ? collection.mosaic() // Composite all images inn a collection (e.g. per country)
-                : ee.Image(collection.first()) // There should only be one image after applying the filters
+            if (periodReducer) {
+                // Apply period reducer (e.g. going from daily to monthly)
+                eeImage = collection[periodReducer]()
+            } else if (mosaic) {
+                // Composite all images inn a collection (e.g. per country)
+                eeImage = collection.mosaic()
+            } else {
+                // There should only be one image after applying the filters
+                eeImage = ee.Image(collection.first())
+            }
         }
 
-        // // Select band (e.g. age group)
+        // Select band (e.g. age group)
         if (band) {
             eeImage = eeImage.select(band)
 
@@ -143,18 +174,14 @@ class EarthEngineWorker {
             }
         }
 
-        // Mask out 0-values
-        if (mask) {
-            eeImage = eeImage.updateMask(eeImage.gt(0))
-        }
-
         // Run methods on image
-        if (methods) {
-            Object.keys(methods).forEach(method => {
-                if (eeImage[method]) {
-                    eeImage = eeImage[method].apply(eeImage, methods[method])
-                }
-            })
+        eeImage = applyMethods(eeImage, methods)
+
+        // Use mask operator (e.g. mask out values below a certain threshold)
+        if (maskOperator && eeImage[maskOperator]) {
+            eeImage = eeImage.updateMask(
+                eeImage[maskOperator](style?.min || DEFAULT_MASK_VALUE)
+            )
         }
 
         this.eeImage = eeImage
@@ -164,38 +191,52 @@ class EarthEngineWorker {
 
     // Returns raster tile url for a classified image
     getTileUrl() {
-        const { format, data } = this.options
+        const { datasetId, format, data, filter, style } = this.options
 
-        return new Promise(resolve => {
-            if (format === 'FeatureCollection') {
-                const { datasetId } = this.options
+        return new Promise((resolve, reject) => {
+            switch (format) {
+                case FEATURE_COLLECTION: {
+                    let dataset = ee.FeatureCollection(datasetId)
 
-                let dataset = ee
-                    .FeatureCollection(datasetId)
-                    .draw(FEATURE_STYLE)
+                    dataset = applyFilter(dataset, filter).draw({
+                        ...DEFAULT_FEATURE_STYLE,
+                        ...style,
+                    })
 
-                if (data) {
-                    dataset = dataset.clipToCollection(
-                        this.getFeatureCollection()
+                    if (data) {
+                        dataset = dataset.clipToCollection(
+                            this.getFeatureCollection()
+                        )
+                    }
+
+                    dataset.getMap(null, response =>
+                        resolve(response.urlFormat)
                     )
+
+                    break
                 }
+                case IMAGE:
+                case IMAGE_COLLECTION: {
+                    // eslint-disable-next-line prefer-const
+                    let { eeImage, params } = getClassifiedImage(
+                        this.getImage(),
+                        this.options
+                    )
 
-                dataset.getMap(null, response => resolve(response.urlFormat))
-            } else {
-                let { eeImage, params } = getClassifiedImage(
-                    this.getImage(),
-                    this.options
-                )
+                    if (data) {
+                        eeImage = eeImage.clipToCollection(
+                            this.getFeatureCollection()
+                        )
+                    }
 
-                if (data) {
-                    eeImage = eeImage.clipToCollection(
-                        this.getFeatureCollection()
-                    )
-                }
+                    eeImage
+                        .visualize(params)
+                        .getMap(null, response => resolve(response.urlFormat))
 
-                eeImage
-                    .visualize(params)
-                    .getMap(null, response => resolve(response.urlFormat))
+                    break
+                }
+                default:
+                    reject(new Error('Unknown format'))
             }
         })
     }
@@ -219,11 +260,26 @@ class EarthEngineWorker {
 
         const featureCollection = ee
             .FeatureCollection(imageCollection)
-            .select(['system:time_start', 'system:time_end'], null, false)
+            .select(
+                ['system:time_start', 'system:time_end', 'year'],
+                null,
+                false
+            )
 
         return getInfo(featureCollection)
     }
 
+    // Returns min and max timestamp for an image collection
+    getTimeRange(eeId) {
+        const collection = ee.ImageCollection(eeId)
+
+        const range = collection.reduceColumns(ee.Reducer.minMax(), [
+            'system:time_start',
+        ])
+
+        return getInfo(range)
+    }
+
     // Returns aggregated values for org unit features
     async getAggregations(config) {
         if (config) {
@@ -233,20 +289,25 @@ class EarthEngineWorker {
             format,
             aggregationType,
             band,
-            legend,
+            useCentroid,
+            style,
             tileScale = DEFAULT_TILE_SCALE,
         } = this.options
         const singleAggregation = !Array.isArray(aggregationType)
         const useHistogram =
-            singleAggregation && hasClasses(aggregationType) && legend
+            singleAggregation &&
+            hasClasses(aggregationType) &&
+            Array.isArray(style)
         const image = await this.getImage()
         const scale = this.eeScale
-        const collection = this.getFeatureCollection() // TODO: Throw error if no feature collection
+        const collection = this.getFeatureCollection()
 
         if (collection) {
-            if (format === 'FeatureCollection') {
-                const { datasetId } = this.options
-                const dataset = ee.FeatureCollection(datasetId)
+            if (format === FEATURE_COLLECTION) {
+                const { datasetId, filter } = this.options
+                let dataset = ee.FeatureCollection(datasetId)
+
+                dataset = applyFilter(dataset, filter)
 
                 const aggFeatures = collection
                     .map(feature => {
@@ -279,11 +340,11 @@ class EarthEngineWorker {
                         data,
                         scale: scaleValue,
                         aggregationType,
-                        legend,
+                        style,
                     })
                 )
             } else if (!singleAggregation && aggregationType.length) {
-                const reducer = combineReducers(ee)(aggregationType)
+                const reducer = combineReducers(aggregationType, useCentroid)
                 const props = [...aggregationType]
 
                 let aggFeatures = image.reduceRegions({
@@ -315,13 +376,18 @@ class EarthEngineWorker {
                 aggFeatures = aggFeatures.select(props, null, false)
 
                 return getInfo(aggFeatures).then(getFeatureCollectionProperties)
-            } else throw new Error('Aggregation type is not valid')
-        } else throw new Error('Missing org unit features')
+            } else {
+                throw new Error('Aggregation type is not valid')
+            }
+        } else {
+            throw new Error('Missing org unit features')
+        }
     }
 }
 
 // Service Worker not supported in Safari
 if (typeof onconnect !== 'undefined') {
+    // eslint-disable-next-line no-undef
     onconnect = evt => expose(EarthEngineWorker, evt.ports[0])
 } else {
     expose(EarthEngineWorker)