Update gee_utils.py

gee_utils.py

@@ -3,78 +3,115 @@ import os
 import json
 import base64
 
+# ── Chemins et constantes ────────────────────────────────────────────────────
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+GEE_PROJECT  = os.environ.get("GEE_PROJECT",  "ee-zanakone")
+GEE_SA_EMAIL = os.environ.get("GEE_SA_EMAIL",  "pipeline-agb@ee-zanakone.iam.gserviceaccount.com")
+GEE_KEY_PATH = os.path.join(BASE_DIR, "cle_service_gee.json")
+
+# ── Initialisation ───────────────────────────────────────────────────────────
 def init_gee():
-    key_b64 = os.environ.get("GEE_PRIVATE_KEY")
-    sa_email = os.environ.get("GEE_SERVICE_ACCOUNT")
-    
-    key_json = json.loads(base64.b64decode(key_b64).decode())
-    credentials = ee.ServiceAccountCredentials(sa_email, key_data=json.dumps(key_json))
-    ee.Initialize(credentials)
+    """
+    Priorité :
+      1. Fichier JSON local  (développement local)
+      2. Secret HF base64    (production Hugging Face)
+    """
+
+    # --- 1. Fichier local présent ? ---
+    if os.path.exists(GEE_KEY_PATH):
+        print(f"🔑 Clé GEE chargée depuis fichier local : {GEE_KEY_PATH}")
+        credentials = ee.ServiceAccountCredentials(
+            email=GEE_SA_EMAIL,
+            key_file=GEE_KEY_PATH
+        )
+
+    # --- 2. Secret HF (base64) ---
+    else:
+        key_b64 = os.environ.get("GEE_KEY_JSON")
+        if not key_b64:
+            raise EnvironmentError(
+                "❌ Aucune clé GEE trouvée.\n"
+                f"   - En local  : placez 'cle_service_gee.json' dans {BASE_DIR}\n"
+                "   - Sur HF    : ajoutez le secret GEE_KEY_JSON (base64)"
+            )
+        print("🔑 Clé GEE chargée depuis secret Hugging Face")
+        try:
+            key_dict = json.loads(base64.b64decode(key_b64.strip()).decode("utf-8"))
+        except Exception as e:
+            raise ValueError(f"❌ Décodage base64 échoué : {e}")
 
+        credentials = ee.ServiceAccountCredentials(
+            email=GEE_SA_EMAIL,
+            key_data=json.dumps(key_dict)
+        )
+
+    # --- Initialisation avec projet ---
+    try:
+        ee.Initialize(credentials, project=GEE_PROJECT)
+        print(f"✅ GEE initialisé — projet : {GEE_PROJECT}")
+    except Exception as e:
+        raise ConnectionError(f"❌ ee.Initialize() échoué : {e}")
+
+
+# ── Fonctions d'analyse ──────────────────────────────────────────────────────
 def get_sentinel2_image(lat, lng, buffer_m, year):
-    """Récupère la meilleure image Sentinel-2 pour une année donnée."""
-    point = ee.Geometry.Point([lng, lat])
+    point  = ee.Geometry.Point([lng, lat])
     region = point.buffer(buffer_m)
-    
-    start = f"{year}-01-01"
-    end   = f"{year}-12-31"
-    
-    collection = (
+
+    image = (
         ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
         .filterBounds(region)
-        .filterDate(start, end)
+        .filterDate(f"{year}-01-01", f"{year}-12-31")
         .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 20))
         .sort("CLOUDY_PIXEL_PERCENTAGE")
+        .first()
+        .clip(region)
     )
-    
-    image = collection.first().clip(region)
     return image, region
 
+
 def compute_ndvi(image):
-    ndvi = image.normalizedDifference(["B8", "B4"]).rename("NDVI")
-    return ndvi
+    return image.normalizedDifference(["B8", "B4"]).rename("NDVI")
+
 
 def compute_ndwi(image):
-    ndwi = image.normalizedDifference(["B3", "B8"]).rename("NDWI")
-    return ndwi
+    return image.normalizedDifference(["B3", "B8"]).rename("NDWI")
+
 
 def get_ndvi_stats(ndvi, region):
     stats = ndvi.reduceRegion(
-        reducer=ee.Reducer.mean().combine(
-            ee.Reducer.min(), sharedInputs=True
-        ).combine(
-            ee.Reducer.max(), sharedInputs=True
-        ),
+        reducer=ee.Reducer.mean().combine(ee.Reducer.min(), sharedInputs=True)
+                                 .combine(ee.Reducer.max(), sharedInputs=True),
         geometry=region,
         scale=10,
         maxPixels=1e9
     ).getInfo()
-    return stats
+    return {
+        "mean": round(stats.get("NDVI_mean") or 0, 3),
+        "min":  round(stats.get("NDVI_min")  or 0, 3),
+        "max":  round(stats.get("NDVI_max")  or 0, 3),
+    }
+
 
 def classify_land(image, region):
-    """Classification simple : végétation, urbain, eau, sol nu, agriculture."""
-    ndvi = compute_ndvi(image)
-    ndwi = compute_ndwi(image)
-    
-    vegetation = ndvi.gt(0.4)
-    agriculture = ndvi.gt(0.2).And(ndvi.lte(0.4))
-    water       = ndwi.gt(0.0)
-    urban       = image.select("B11").gt(2000).And(ndvi.lt(0.2))
-    bare        = ndvi.lt(0.2).And(water.Not()).And(urban.Not())
-    
-    classified = (
-        water.multiply(1)
-        .add(vegetation.multiply(2))
-        .add(agriculture.multiply(3))
-        .add(urban.multiply(4))
-        .add(bare.multiply(5))
-    )
-    
+    ndvi  = compute_ndvi(image)
+    ndwi  = compute_ndwi(image)
     total = region.area().getInfo()
+
+    masks = {
+        "eau":         ndwi.gt(0.0),
+        "végétation":  ndvi.gt(0.4),
+        "agriculture": ndvi.gt(0.2).And(ndvi.lte(0.4)),
+        "urbain":      image.select("B11").gt(2000).And(ndvi.lt(0.2)),
+        "sol nu":      ndvi.lt(0.2).And(ndwi.lte(0.0)).And(image.select("B11").lte(2000)),
+    }
+
     areas = {}
-    for name, mask in [("eau",1),("végétation",2),("agriculture",3),("urbain",4),("sol nu",5)]:
-        px = classified.eq(mask).multiply(ee.Image.pixelArea())
+    for name, mask in masks.items():
+        px   = mask.multiply(ee.Image.pixelArea())
         area = px.reduceRegion(ee.Reducer.sum(), region, 10, maxPixels=1e9).getInfo()
-        areas[name] = round((area.get("constant", 0) / total) * 100, 1)
-    
+        val  = area.get("NDVI") or area.get("B11") or area.get("nd") or 0
+        areas[name] = round((val / total) * 100, 1)
+
     return areas