How to avoid using .getInfo() in Google Earth Engine?

Question

Description: The code below contains a function that calculates the least required days for Sentinel 2 image collection to cover at least 99% of a given area of interest (aoi). In other words, Sentinel 2 can fully cover small areas with image collection filtered with 1 day only. If an area is relatively large then image collections need to be gathered from more than 1 day and then mosaiced.

Problem: The function works as expected ,however, it freezes the web browser because it uses .getInfo() command inside it. Specifically at var c = data1.size().getInfo() line located near the end of the code.

Requirement: I would like to find an alternative to this command, so that the function won't freeze the web browser. I believe the solution is by converting the whole function to server-side, but I couldn't achieve that.

Failed solutions:

• I've tried using .evaluate() instead of .getInfo() , and it didn't work.
• I've tried to reconstruct the whole function by using .map instead of while loop. It also didn't work.

The Code:

var Iraq = ee.FeatureCollection("users/Yousif_Almamalachy/Iraq_Governorates");
var Gov_name = 'ANBAR'
var aoi = Iraq.filter(ee.Filter.eq("NAME_GOVER", Gov_name));

print(CdaysCheck(aoi))

function CdaysCheck(aoii){
var stoper = false;
var i = 1;
while (i) {
  var sentinel = ee.ImageCollection("COPERNICUS/S2_SR");
  var aoi = aoii;
  
  
  var sStart_Date = ee.Date(Date.now()).advance(-1,'month')
  var eEnd_Date =  ee.Date(Date.now())
  var aAllowed_Cloud = 100
  var Minimum_Areal_Coverage = 0.99
  var cCoverage_Days = i
  var data = sentinel.filterBounds(aoi).filterDate(sStart_Date,eEnd_Date)
    .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', aAllowed_Cloud));
  var sscale=data.first().select('B1').projection().nominalScale().getInfo()
  var polygon_area;
  // if (definedmode.getValue() == 1)
      polygon_area = aoi.geometry().area().divide(1e6)
  // else{polygon_area = aoi.area().divide(1e6)}
  var minimum_area = ee.Number(polygon_area).multiply(Minimum_Areal_Coverage)
  
  // Get the dates of filtered images with less than specified cloud percentage
  var dates = data
      .map(function(image) {
        return ee.Feature(null, {'date': image.date().format('YYYY-MM-dd')})
      })
      //.distinct('date')
      .aggregate_array('date')

  // Filter Images that doesn't contain all bands
  var data = data.map(function(n) {
    return n.set('Num_of_bands',n.bandNames().length());
  })
  data = data.filterMetadata("Num_of_bands","equals",23);

  // Mosaic images of the same date and calculate its average cloud cover
  var dd = ee.ImageCollection(
    ee.List(dates.distinct()).map(function (n) {
    var date = ee.Date(n)
    var filtered = data.filterDate(date, date.advance(cCoverage_Days,'day')) 
    var image = ee.Image(filtered.mosaic())
    return image.set({'date':n})
  }));
  // Filter Images that doesn't cover polygon area (raster area calculation method)
  var data1 = dd.map(function(n) {
    var data = ee.Image(1).mask(n.select('B1'))
    var raster_area = data.multiply(ee.Image.pixelArea()).reduceRegion({
      reducer: ee.Reducer.sum(),
      geometry: aoi,
      scale: sscale,
      maxPixels: 1E13
    }).get('constant')
    raster_area=ee.Number(raster_area).divide(1e6)
    return n.set('Area_KM2',raster_area)
  })
  data1 = data1.filterMetadata("Area_KM2","greater_than",ee.Number(minimum_area));
  var c = data1.size().getInfo()
  if (c !== 0) 
    {break}
  i += 1
  }
  return ee.String(i.toString())
}

Answer 1

This kind of computation ('loop until condition') is never a good fit for Earth Engine and you should always figure out how to reframe the question such that you don't need it, rather than try to force it.

In this case, you can simply compute the coverage for N days (N= [1, 2, 3, 4, 5, ...]) and then find the first one that exceeds your coverage threshold with a filter. It's more computation, but much easier.

Also: as a simplifying hint, you can just get the mean() of the mask in the aoi to determine % coverage (masked pixels will be 0).

https://code.earthengine.google.com/1659bba88fcd562bb5faee3f28bfe51c

var Iraq = ee.FeatureCollection("users/Yousif_Almamalachy/Iraq_Governorates")
var Gov_name = 'ANBAR'
var aoi = Iraq.filter(ee.Filter.eq("NAME_GOVER", Gov_name))
  
var aAllowed_Cloud = 100
var Minimum_Areal_Coverage = 0.99
var start = ee.Date('2021-07-01')

var sentinel = ee.ImageCollection("COPERNICUS/S2_SR")
    .filterBounds(aoi)
    .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', aAllowed_Cloud))
    
var proj = sentinel.first().select('B1').projection()

// Returns a feature containing the percentage of unmasked pixels.
function coverage(days) {
  var end = start.advance(days, 'day')
  var mosaic = sentinel.filterDate(start, end).mosaic()
  var cover = mosaic.select(0).mask().reduceRegion({
    reducer: ee.Reducer.mean(),
    geometry: aoi, 
    crs: proj,
    maxPixels: 1e10
  }).values().get(0)
  
  return ee.Feature(null, {
    days: days,
    cover: cover
  })
}

var result = ee.FeatureCollection(ee.List.sequence(1, 15).map(coverage))
print(ui.Chart.feature.byFeature(result, 'days', 'cover'))
var minDays = result.filter(ee.Filter.gte('cover', Minimum_Areal_Coverage)).first().get('days')
print('Required days: ', minDays)

Answer 2

After a fruitful conversation with Noel Gorelick, I've managed to write a function parallel to the one in my question but completely done in server-side. This way I've avoided using .getInfo() as requested.

The basic idea here is to implement a loop that breaks at specific condition which can be easily done in client-side using break command. To do the same work on server-side, one must understand the fact that there is no code breaking in server-side. Instead, I used ee.List.iterate function with multiple ee.Algorithms.If functions to make the loop divert to a micro-loop (non-exhaustive one) when the condition is met as shown below:

var Iraq = ee.FeatureCollection("users/Yousif_Almamalachy/Iraq_Governorates");
var Gov_name = 'WASIT'
var aoi = Iraq.filter(ee.Filter.eq("NAME_GOVER", Gov_name));
///////////////////////////////////////////////
///////////////////////////////////////////////
///////////////////////////////////////////////
print(CdaysCheck(aoi))

function CdaysCheck(){
// This function calculates the minimal days required for sentinel 2 collection
// to cover at least 99% of a specific aoi (area of interest). 
// It generates a mosaic for every number of days (starting with 1 day)
// then it calculates it's aerial coverage with respect to aoi and test If it exceeds 99% or not.
// If not the number of days is incresed and the procedure is repeated. Otherwise the loop terminates.
  
var list = ee.List.sequence(1,5) //Iterate for 5 days.

//In each iteration if check1 function returns 0 then add 1 to the previous iteration and rerun check1
// Else if check1 returns 999 or any number other than 0 then return 999
/// 999 is used as a flag to terminate the iteration.
var addone = function(current,previous){
  previous = ee.List(previous)
  var pr = ee.Number(previous.get(-1))
  var cu = ee.Number(current)
  var cd = ee.Number(check1(pr,aoi))
  var n1 = ee.Algorithms.If(cd.eq(ee.Number(0)),pr.add(1),
           ee.Algorithms.If(cd.eq(ee.Number(999)),
           ee.Number(999),ee.Number(999)))
  return previous.add(ee.Number(n1))
}

var start = [1] //Start iteration at 1
var result = ee.List(list.iterate(addone,start))
result = ee.String(result.filter(ee.Filter.lt('item', 999)).get(-1)) 
return ee.String(result)
///////////////////////////////////////////////
///////////////////////////////////////////////
///////////////////////////////////////////////

function check1(i,aoii){
  
  // If i equals to 999 then don't go further... just return 999.
  // Else if i equals any number other than 999 or 0 then move forward with the continu function.
  return ee.Number(ee.Algorithms.If(ee.Number(i).neq(ee.Number(999)),
                   continu(ee.Number(i),aoii),ee.Number(999)))
                   

  function continu(i,aoii){
    var aa = i
    var sentinel = ee.ImageCollection("COPERNICUS/S2_SR");
    var aoi = aoii;
    
    var sStart_Date = ee.Date(Date.now()).advance(-30,'day')
    var eEnd_Date =  ee.Date(Date.now()).advance(-20,'day')
    var aAllowed_Cloud = 100
    var Minimum_Areal_Coverage = 0.99
    var cCoverage_Days = aa
    var data = sentinel.filterBounds(aoi).filterDate(sStart_Date,eEnd_Date)
      .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', aAllowed_Cloud));
    // var sscale=data.first().select('B1').projection().nominalScale().getInfo()
    var sscale= 10
    var polygon_area;
    // if (definedmode.getValue() == 1)
        polygon_area = aoi.geometry().area().divide(1e6)
    // else{polygon_area = aoi.area().divide(1e6)}
    var minimum_area = ee.Number(polygon_area).multiply(Minimum_Areal_Coverage)
    
    // Get the dates of filtered images with less than specified cloud percentage
    var dates = data
        .map(function(image) {
          return ee.Feature(null, {'date': image.date().format('YYYY-MM-dd')})
        })
        .aggregate_array('date')
  
    // Filter Images that doesn't contain all bands
    var data = data.map(function(n) {
      return n.set('Num_of_bands',n.bandNames().length());
    })
    data = data.filterMetadata("Num_of_bands","equals",23);
    
    // Mosaic images of the same date/date range and calculate the area of the mosaic
    // return the result as image collection 
    var dd = ee.ImageCollection(
      ee.List(dates.distinct()).map(function (n) {
      var date = ee.Date(n)
      var filtered = data.filterDate(date, date.advance(cCoverage_Days,'day')) 
      var image = ee.Image(filtered.mosaic())
      var data1 = ee.Image(1).mask(image.select('B1'))
      var raster_area = data1.multiply(ee.Image.pixelArea()).reduceRegion({
        reducer: ee.Reducer.sum(),
        geometry: aoi,
        scale: sscale,
        maxPixels: 1E13
      }).get('constant')
      raster_area=ee.Number(raster_area).divide(1e6)
      return image.set({'date':n,'Area_KM2':raster_area})
    }));
    
    // Filter Images that doesn't cover 99% of polygon area
    var data2 = dd.filterMetadata("Area_KM2","greater_than",ee.Number(minimum_area));
    var ii = ee.Number(ee.Algorithms.If(ee.Number(data2.size()).gt(0),ee.Number(i),ee.Number(0)))
    return ii //return the number of image collections that covers 99% of specified aoi (area of interest)
}
}
}