Update app.R

app.R

@@ -321,115 +321,140 @@ server <- function(input, output, session) {
         return()
       }
       
-      gee_project <- Sys.getenv("GEE_PROJECT", unset = NULL)
-      gee_email <- Sys.getenv("GEE_EMAIL", unset = NULL)
-      gee_key <- Sys.getenv("GEE_KEY", unset = NULL)
+      gee_project <- Sys.getenv("GEE_PROJECT")
+      gee_email <- Sys.getenv("GEE_EMAIL")
+      gee_key <- Sys.getenv("GEE_KEY")
       
-      py_run_string("
-import ee, pandas as pd, json
+      {
+        py_run_string("
+import ee
+import pandas as pd
+import json
+import os
 
 def _ee_init(project, email=None, key_data=None):
-    if email is None and key_data is None:
+    # Normalize empty strings to None
+    project = project or None
+    email = (email or None) if email else None
+    key_data = (key_data or None) if key_data else None
+
+    # Prefer service account if provided; otherwise try ADC (non-interactive)
+    if key_data:
+        # key_data must be a JSON string
+        key_json = key_data if isinstance(key_data, str) else json.dumps(key_data)
+        credentials = ee.ServiceAccountCredentials(email, key_data=key_json)
+        ee.Initialize(credentials=credentials, project=project)
+    else:
         try:
             ee.Initialize(project=project)
-        except:
-            ee.Authenticate()
-            ee.Initialize(project=project)
-    else:
-        key_dict = json.loads(key_data)
-        credentials = ee.ServiceAccountCredentials(email, key_data=key_dict)
-        ee.Initialize(credentials=credentials, project=project)
+        except Exception as e:
+            raise RuntimeError(
+                'No service-account key provided and ADC not available. '
+                'Set GOOGLE_APPLICATION_CREDENTIALS or provide GEE_EMAIL+GEE_KEY.'
+            ) from e
 
-def satellite_stats(points, start, end, scale=250):
+def satellite_stats(points, start, end, sample_scale=250):
+    # Build FeatureCollection from input points
     feats = [ee.Feature(ee.Geometry.Point([float(p['lon']), float(p['lat'])]),
                         {'rowid': str(p['rowid'])}) for p in points]
     fc = ee.FeatureCollection(feats)
 
+    # MODIS NDVI (scaled by 0.0001), mask to SummaryQA == 0
     def mask_modis(img):
         qa = img.select('SummaryQA')
-        mask = qa.eq(0)
-        return img.updateMask(mask).select('NDVI').multiply(0.0001).copyProperties(img, img.propertyNames())
+        return (img.updateMask(qa.eq(0))
+                   .select('NDVI').multiply(0.0001)
+                   .copyProperties(img, img.propertyNames()))
+
     modis = (ee.ImageCollection('MODIS/061/MOD13Q1')
              .filterDate(start, end)
              .map(mask_modis))
-    ndvi_mean = modis.select('NDVI').mean().rename('ndvi_mean')
-    ndvi_median = modis.reduce(ee.Reducer.median()).rename('ndvi_median')
-    ndvi_max = modis.select('NDVI').max().rename('ndvi_max')
 
-    dmsp = ee.ImageCollection('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS').select('stable_lights')
-    viirs = ee.ImageCollection('NOAA/VIIRS/DNB/MONTHLY_V1/VCMSLCFG').select('avg_rad')
+    ndvi_mean   = modis.select('NDVI').mean().rename('ndvi_mean')
+    ndvi_median = modis.select('NDVI').median().rename('ndvi_median')
+    ndvi_max    = modis.select('NDVI').max().rename('ndvi_max')
+
+    # Night lights: DMSP (pre-2014) and VIIRS (2012+)
+    dmsp  = ee.ImageCollection('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS').select('stable_lights')
+    #viirs = ee.ImageCollection('NOAA/VIIRS/DNB/MONTHLY_V1/VCMSLCFG').select('avg_rad') # old
+    viirs = ee.ImageCollection('NOAA/VIIRS/DNB/MONTHLY_V1/VCMCFG').select('avg_rad') # new 
 
-    dmsp_window = dmsp.filterDate(start, end)
+    dmsp_window  = dmsp.filterDate(start, end)
     viirs_window = viirs.filterDate(start, end)
 
-    overlap_start = ee.Date('2012-01-01')
-    overlap_end = ee.Date('2014-12-31')
-    dmsp_ov_img = dmsp.filterDate(overlap_start, overlap_end).mean()
+    # Overlap window for simple cross-calibration (DMSP↔VIIRS)
+    #overlap_start = ee.Date('2012-01-01') # old
+    overlap_start = ee.Date('2012-04-01') # new 
+    overlap_end   = ee.Date('2013-12-31')  # DMSP coverage effectively ends 2013
+
+    dmsp_ov_img  = dmsp.filterDate(overlap_start, overlap_end).mean()
     viirs_ov_img = viirs.filterDate(overlap_start, overlap_end).mean()
 
-    def _buffer_feat(f):
-        f = ee.Feature(f)
-        return f.buffer(5000)
-    fc_buffer = fc.map(_buffer_feat)
+    # Buffer features to form a region-of-interest for overlap means
+    fc_buffer   = fc.map(lambda f: ee.Feature(f).buffer(5000))
     region_geom = fc_buffer.geometry()
 
-    dmsp_ov_mean = ee.Number(dmsp_ov_img.reduceRegion(
-        reducer=ee.Reducer.mean(), geometry=region_geom, scale=5000, maxPixels=1e13
-    ).get('stable_lights'))
-    viirs_ov_mean = ee.Number(viirs_ov_img.reduceRegion(
-        reducer=ee.Reducer.mean(), geometry=region_geom, scale=5000, maxPixels=1e13
-    ).get('avg_rad'))
+    # Null-safe reducers via dictionaries + contains()
+    dmsp_ov_dict = ee.Dictionary(dmsp_ov_img.reduceRegion(
+        reducer=ee.Reducer.mean(), geometry=region_geom, scale=5000, maxPixels=1e13))
+    viirs_ov_dict = ee.Dictionary(viirs_ov_img.reduceRegion(
+        reducer=ee.Reducer.mean(), geometry=region_geom, scale=5000, maxPixels=1e13))
 
-    dmsp_global_mean = ee.Number(dmsp_ov_img.reduceRegion(
+    dmsp_global_mean = ee.Number(ee.Image(dmsp_ov_img).reduceRegion(
         reducer=ee.Reducer.mean(), geometry=ee.Geometry.Rectangle([-180, -90, 180, 90]),
-        scale=50000, maxPixels=1e13
-    ).get('stable_lights'))
-    viirs_global_mean = ee.Number(viirs_ov_img.reduceRegion(
+        scale=50000, maxPixels=1e13).get('stable_lights'))
+    viirs_global_mean = ee.Number(ee.Image(viirs_ov_img).reduceRegion(
         reducer=ee.Reducer.mean(), geometry=ee.Geometry.Rectangle([-180, -90, 180, 90]),
-        scale=50000, maxPixels=1e13
-    ).get('avg_rad'))
-
-    dmsp_use = ee.Algorithms.If(dmsp_ov_mean, dmsp_ov_mean, dmsp_global_mean)
-    viirs_use = ee.Algorithms.If(viirs_ov_mean, viirs_ov_mean, viirs_global_mean)
+        scale=50000, maxPixels=1e13).get('avg_rad'))
 
-    dmsp_use = ee.Number(dmsp_use)
-    viirs_use = ee.Number(viirs_use)
+    dmsp_has  = dmsp_ov_dict.contains('stable_lights')
+    viirs_has = viirs_ov_dict.contains('avg_rad')
 
-    scale = ee.Algorithms.If(dmsp_use.gt(0), viirs_use.divide(dmsp_use), 1)
-    scale = ee.Number(scale)
+    dmsp_use  = ee.Number(ee.Algorithms.If(dmsp_has,  dmsp_ov_dict.get('stable_lights'), dmsp_global_mean))
+    viirs_use = ee.Number(ee.Algorithms.If(viirs_has, viirs_ov_dict.get('avg_rad'),        viirs_global_mean))
 
-    def calib_img(img):
-        return img.multiply(scale).toFloat()
+    # Guard divide-by-zero; produce a VIIRS-per-DMSP scale factor (ratio)
+    k_viirs_per_dmsp = ee.Number(ee.Algorithms.If(dmsp_use.gt(0), viirs_use.divide(dmsp_use), 1))
 
-    dmsp_equiv = dmsp_window.map(lambda img: calib_img(img.select('stable_lights').rename('ntl')))
-    viirs_prep = viirs_window.map(lambda img: img.select('avg_rad').rename('ntl').toFloat())
+    # Build a merged NTL series in VIIRS-equivalent units
+    dmsp_equiv = dmsp_window.map(
+        lambda img: img.select('stable_lights').multiply(k_viirs_per_dmsp).rename('ntl').toFloat()
+    )
+    viirs_prep = viirs_window.map(
+        lambda img: img.select('avg_rad').rename('ntl').toFloat()
+    )
     ntl_window = dmsp_equiv.merge(viirs_prep)
 
-    ntl_mean = ntl_window.mean().rename('ntl_mean')
-    ntl_median = ntl_window.reduce(ee.Reducer.median()).rename('ntl_median')
-    ntl_max = ntl_window.max().rename('ntl_max')
+    ntl_mean   = ntl_window.mean().rename('ntl_mean')
+    ntl_median = ntl_window.median().rename('ntl_median')
+    ntl_max    = ntl_window.max().rename('ntl_max')
 
+    # Stack all bands
     stacked = (ndvi_mean
-              .addBands([ndvi_median, ndvi_max,
-                         ntl_mean, ntl_median, ntl_max]))
+               .addBands([ndvi_median, ndvi_max,
+                          ntl_mean, ntl_median, ntl_max]))
 
-    samples = stacked.sampleRegions(collection=fc, properties=['rowid'], scale=scale)
+    # IMPORTANT: use the intended pixel size (meters) for sampling
+    samples = stacked.sampleRegions(collection=fc, properties=['rowid'], scale=sample_scale)
+
+    # Bring results client-side
     info = samples.getInfo()
     rows = []
     for f in info.get('features', []):
         p = f.get('properties', {}) or {}
         rows.append({
-            'rowid': p.get('rowid'),
-            'ndvi_mean': p.get('ndvi_mean'),
+            'rowid':       p.get('rowid'),
+            'ndvi_mean':   p.get('ndvi_mean'),
             'ndvi_median': p.get('ndvi_median'),
-            'ndvi_max': p.get('ndvi_max'),
-            'ntl_mean': p.get('ntl_mean'),
-            'ntl_median': p.get('ntl_median'),
-            'ntl_max': p.get('ntl_max')
+            'ndvi_max':    p.get('ndvi_max'),
+            'ntl_mean':    p.get('ntl_mean'),
+            'ntl_median':  p.get('ntl_median'),
+            'ntl_max':     p.get('ntl_max')
         })
     return pd.DataFrame(rows)
 ")
-      
+      }
+
       py$`_ee_init`(project = gee_project, email = gee_email, key_data = gee_key)
       
       df$rowid <- seq_len(nrow(df))