New application

api.py

@@ -0,0 +1,84 @@
+from sentinelsat import SentinelAPI, read_geojson, geojson_to_wkt
+from datetime import datetime, timedelta,date
+import zipfile
+import rasterio
+from rasterio.plot import show
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import os
+from glob import glob
+from tqdm import tqdm
+#from haversine import haversine, Unit
+#from xml.etree import ElementTree as et
+import xmltodict
+import json
+import warnings
+import shutil
+from shapely.geometry import Point
+from shapely.geometry.polygon import Polygon
+warnings.filterwarnings('ignore')
+
+##
+def unzip():
+    files = glob('*.zip')
+    for file in files:
+         with zipfile.ZipFile(file, 'r') as zip_ref:
+            zip_ref.extractall()
+
+
+##
+def select_best_cloud_coverage_tile():
+    tile_names = {}
+    cld_prob = []
+    folders = glob('*.SAFE')
+    for fold in folders:
+        metadata_path = fold+"/MTD_MSIL2A.xml"
+        xml_file=open(metadata_path,"r")
+        xml_string=xml_file.read()
+        python_dict=xmltodict.parse(xml_string)
+        cld = float(python_dict["n1:Level-2A_User_Product"]["n1:Quality_Indicators_Info"]["Cloud_Coverage_Assessment"])
+        tile_names[cld] = fold
+        cld_prob.append(cld)
+    name = tile_names[min(cld_prob)]
+    dates = name.split('_')[2][:8]
+    acquisition_date = datetime.strptime(dates, "%Y%m%d")
+    today = datetime.now()
+    delta = (today - acquisition_date)
+    days_ago = delta.days
+    return name,min(cld_prob),days_ago
+
+##
+def find_good_tile(df, point):
+    for row in tqdm(df.itertuples(),total=len(df)):
+        tile_name = row.tiles
+        coordinate = row.coords
+        x = coordinate.replace(']','')
+        x = x.replace('[','')
+        x = x.replace("'",'')
+        tab = [[float(x.split(",")[i]),float(x.split(",")[i+1])] for i in range(0,len(x.split(",")),2)]
+        polygon = Polygon(tab)
+        result  = polygon.contains(point)
+        if result:
+            print(tile_name)
+            return tile_name
+        
+    return 404
+
+##
+def delete_tiles():
+        files = glob('*.zip')
+        folders1 = glob('*.SAFE')
+        folders2 = glob("*.tmp")
+        for f in files:
+            os.remove(f)
+        for fold in folders1:
+            shutil.rmtree(fold, ignore_errors=True)
+
+        for fold in folders2:
+            shutil.rmtree(fold, ignore_errors=True)
+
+
+
+

app.py

@@ -0,0 +1,108 @@
+import gradio as gr
+from api import *
+from processing import *
+import pandas as pd
+from indices import indices
+import xgboost as xgb
+import pickle
+import json
+import boto3
+from shapely.geometry import MultiPolygon,shape
+from shapely.geometry import Point
+from shapely.geometry.polygon import Polygon
+from glob import glob
+import wget
+
+
+def predict(lat, lon):
+    cord = [lon,lat]
+    lon = round(lon,4)
+    lat = round(lat,4)
+    x1 = [lon,lat]
+    x2 = [lat,lon]
+    with open("data/CIV_0.json","r") as file:
+        data = json.load(file)
+    # extract ivory coast polygone
+    features = [data['features'][0]['geometry']['coordinates'][0]+data['features'][0]['geometry']['coordinates'][1]+data['features'][0]['geometry']['coordinates'][2]]
+    data['features'][0]['geometry']['coordinates'] = features
+    ci_polygone = data['features'][0]['geometry']['coordinates'][0][0]  
+    point1 = Point(x1)
+    point2 = Point(x2)
+    polygon = Polygon(ci_polygone)
+    result = polygon.contains(point1)
+
+    if not result:
+        return "Choisissez une zone de la CI","","","",""
+    
+    else:
+        df = pd.read_csv("data/frame.csv")
+        name = find_good_tile(df,point2)
+        if name ==404:
+            reponse = "Sentinel-2 ne dispose pas de données ce sur ce lieu à ce jour"
+            return reponse,"","","",""
+        else:
+            path = "https://data354-public-assets.s3.eu-west-3.amazonaws.com/cisentineldata/"
+            url = path+name
+            wget.download(url)
+            unzip()
+            name,cld_prob,days_ago = select_best_cloud_coverage_tile()
+            bandes_path_10,bandes_path_20,bandes_path_60,tile_path,path_cld_20,path_cld_60 =paths(name)
+            # create image dataset
+            images_10 = extract_sub_image(bandes_path_10,tile_path,cord)
+
+            # bandes with 20m resolution
+            #path_cld_20
+            images_20 = extract_sub_image(bandes_path_20,tile_path,cord,20,1)
+
+            # bandes with 60m resolution
+            #path_cld_60
+            images_60 = extract_sub_image(bandes_path_60,tile_path,cord,60)
+            #
+            feature = images_10.tolist()+images_20.tolist()+images_60.tolist()
+            bands = ['B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B11', 'B12','B01','B09']
+            X = pd.DataFrame([feature],columns = bands)
+            # vegetation index calculation
+            X = indices(X)
+            # load the model from disk
+            filename = "data/finalized_model.sav"
+            loaded_model = pickle.load(open(filename, 'rb'))
+            # make prediction
+            biomass = loaded_model.predict(X)[0]
+            carbon = 0.55*biomass
+
+            # NDVI
+            ndvi_index = ndvi(cord,name)
+
+            # deleted download files
+            delete_tiles()
+
+            return str(cld_prob)+ " % cloud coverage", str(days_ago)+" days ago",str(biomass)+" Mg/ha", str(carbon)+" MgC/ha","NDVI: "+ str(ndvi_index)
+
+# Create title, description and article strings
+title = "🌴BEEPAS : Biomass estimation to Evaluate the Environmental Performance of Agroforestry Systems🌴"
+description = "This application estimates the biomass of certain areas using AI and satellite images (S2)."
+article = "Created by data354."
+
+# Create examples list from "examples/" directory
+#example_list = [["examples/" + example] for example in os.listdir("examples")]
+example_list = [[5.379913, -4.050445],[6.54644,-7.86156],[5.346938, -4.027849]]
+
+outputs = [
+    gr.Textbox(label="Cloud coverage"),
+    gr.Textbox(label="Number of days since sensing"),
+    gr.Textbox(label="Above ground biomass density(AGBD) Mg/ha"),
+    gr.Textbox(label="Carbon stock density MgC/ha "),
+    gr.Textbox(label="Mean NDVI"),]
+
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=["number", "number"],
+    outputs=outputs, #[ "text", "text","text","text","text"],
+    examples=example_list,
+    title=title,
+    description=description,
+    article=article,
+    )
+
+demo.launch(share=True)

indices.py

@@ -0,0 +1,157 @@
+import numpy as np
+
+def indices(X):
+    # Calculate vegetation indices
+    #S2REP
+    #OTHERS
+
+    X["MTCI"] = (X["B06"]-X["B05"])/(X["B05"]-X["B04"])
+    X["AWEInsh"] = 4.0*(X["B03"]-X["B11"])-0.25*X["B08"]+2.75*X["B12"]
+    X["NBSIMS"] = 0.36*(X["B03"]+X["B04"]+X["B08"]) - (((X["B02"]+X["B12"])/X["B03"])+X["B11"])
+    X["MuWIR"] = -4.0*((X["B02"]-X["B03"])/(X["B02"]+X["B03"]))+2.0*((X["B03"]-X["B08"])/(X["B03"]+X["B08"]))+2.0*((X["B03"]-X["B12"])/(X["B03"]+X["B12"]))-((X["B03"]-X["B11"])/(X["B03"]+X["B11"]))
+    X["VARI700"] = (X["B05"]-1.7*X["B04"]+0.7*X["B02"])/(X["B05"]+1.3*X["B04"]-1.3*X["B02"])
+
+    X["S2WI"] = (X["B05"]-X["B12"])/(X["B05"]+X["B12"])
+
+    X["NBAI"] = ((X["B12"]-X["B11"])/X["B03"])/((X["B12"]+X["B11"])/X["B03"])
+
+    X["TCARI"] = 3*((X["B05"]-X["B04"]))-0.2*(X["B05"]-X["B03"])*(X["B05"]/X["B04"])
+
+    X["WI2015"] = 1.7204+171*X["B03"]+3*X["B04"]-70*X["B08"]-45*X["B11"]-71*X["B12"]
+
+    X["BAIM"] = 1.0/((0.05-X["B08"])**2.0)+((0.2-X["B12"])**2.0)
+
+    X["NDDI"] = (( (X["B08"]-X["B04"])/(X["B08"]+X["B04"])-((X["B03"]-X["B08"])/(X["B03"]+X["B08"])))/((X["B08"]-X["B04"])/(X["B08"]+X["B04"]))+((X["B03"]-X["B08"])/(X["B03"]+X["B08"])))
+    X["BCC"] = X["B02"]/(X["B04"]+X["B03"]+X["B02"])
+
+    X["RCC"] = X["B04"]/(X["B04"]+X["B03"]+X["B02"])
+
+    X["IKAW"] = (X["B08"]-X["B02"])/(X["B08"]+X["B02"])
+
+    X["ARI"] = (1/X["B03"])-(1/X["B05"])
+
+    X["MIRBI"] = 10.0*X["B12"]-9.8*X["B11"]+2.0
+
+    X["NMDI2"] = (X["B08"]-(X["B11"]-X["B12"]))/(X["B08"]+(X["B11"]-X["B12"]))
+
+    X["TTVI"] = 0.5*((865.0-740.0)*(X["B8A"]-X["B06"]-(X["B07"]-X["B06"])*(783.0-740)))
+
+    X["NHFD"] = (X["B05"]-X["B01"])/(X["B05"]+X["B01"])
+
+    X["NDSWIR"] = (X["B11"]-X["B8A"])/(X["B11"]+X["B8A"])
+
+    X["NBRSWIR"] = (X["B12"]-X["B11"]-0.02)/(X["B12"]+X["B11"]+0.1)
+
+    X["NBR"] = (X["B12"]-X["B8A"])/(X["B12"]+X["B8A"])
+
+    X["NBRplus"] = (X["B12"]-X["B8A"]-X["B03"]-X["B02"])/(X["B12"]+X["B8A"]+X["B03"]+X["B02"])
+
+    X["NDWI2"] = (X["B02"]-X["B08"])/(X["B02"]+X["B08"])
+
+    X["NDWI2"] = (X["B01"]-X["B08"])/(X["B01"]+X["B08"])
+
+
+    X["S2REP"] = 705 + 35 * ((((X["B07"] + X["B04"])/2) - X["B05"])/(X["B06"] - X["B05"]))
+    #S2REP = 705 + 35 * ((((X[:, 6, :] + X[:, 3, :])/2) - X[:, 4, :])/(X[:, 5, :] - X[:, 4, :]))
+
+    X["CCCI"] = ((X["B08"] - X["B05"]) / (X["B08"] + X["B05"])) / ((X["B08"] - X["B04"]) / (X["B08"] + X["B04"]))
+    #CCCI = ((X[:, 7, :] - X[:, 4, :]) / (X[:, 7, :] + X[:, 4, :])) / ((X[:, 7, :] - X[:, 3, :]) / (X[:, 7, :] + X[:, 3, :]))
+
+    X["MCARI"] = ((X["B05"] - X["B04"]) - 2 * (X["B05"] - X["B03"])) * (X["B05"] / X["B04"])
+    #MCARI = ((X[:, 4, :] - X[:, 3, :]) - 2 * (X[:, 4, :] - X[:, 2, :])) * (X[:, 4, :] / X[:, 3, :])
+
+    X["TCARI"] = 3 * ((X["B05"] - X["B04"]) - 0.2 * (X["B05"] - X["B03"]) * (X["B05"] / X["B04"]))
+    #TCARI = 3 * ((X[:, 4, :] - X[:, 3, :]) - 0.2 * (X[:, 4, :] - X[:, 2, :]) * (X[:, 4, :] / X[:, 3, :]))
+
+    X["PVI"] = (X["B08"] - 0.3 * X["B04"] - 0.5) / ((1 + 0.3 * 2) ** (1/2.0))
+    #PVI = (X[:, 7, :] - 0.3 * X[:, 3, :] - 0.5) / ((1 + 0.3 * 2) ** (1/2.0))
+
+    X["ndvi"] = (X["B08"] - X["B04"]) / (X["B08"] + X["B04"])
+    #ndvi = (X[:, 7, :] - X[:, 3, :]) / (X[:, 7, :] + X[:, 3, :])
+
+    X["evi"] = 2.5 * (X["B08"] - X["B04"]) / (X["B08"] + 6 * X["B04"] - 7.5 * X["B02"] + 1)
+    #evi = 2.5 * (X[:, 7, :] - X[:, 3, :]) / (X[:, 7, :] + 6 * X[:, 3, :] - 7.5 * X[:, 1, :] + 1)
+
+    X["savi"] = (X["B08"] - X["B04"]) / (X["B08"] + X["B04"] + 0.5)
+    #savi = (X[:, 7, :] - X[:, 3, :]) / (X[:, 7, :] + X[:, 3, :] + 0.5)
+    X["mndwi"] = (X["B03"] - X["B08"]) / (X["B03"] + X["B08"])
+    #mndwi = (X[:, 2, :] - X[:, 7, :]) / (X[:, 2, :] + X[:, 7, :])
+
+
+    X["ARVI"] = (X["B08"] - (2 * X["B04"]) + X["B02"]) / (X["B08"] + (2 * X["B04"]) + X["B02"])
+    #ARVI =  (X[:, 7, :] - (2 * X[:, 3, :]) + X[:, 1, :]) / (X[:, 7, :] + (2 * X[:, 3, :]) + X[:, 1, :])
+
+    X["SIPI"] = (X["B08"] - X["B02"]) / (X["B08"] - X["B04"])
+    #SIPI = (X[:, 7, :] - X[:, 1, :]) / (X[:, 7, :] - X[:, 3, :])
+
+    X["RENDVI"] = (X["B06"] - X["B05"]) / (X["B06"] + X["B05"])
+    #RENDVI = (X[:, 5, :] - X[:, 4, :]) / (X[:, 5, :] + X[:, 4, :])
+
+    X["MRESR"] = (X["B06"] - X["B01"]) / (X["B05"] - X["B01"])
+    #MRESR = (X[:, 5, :] - X[:, 0, :]) / (X[:, 4, :] - X[:, 0, :])
+
+    # CANOLA
+    X["RYI"] = X["B03"] / X["B02"]
+    #RYI = X[:, 2, :] / X[:, 1, :]
+
+    X["NDYI"] = (X["B03"] - X["B02"]) / (X["B03"] + X["B02"])
+    #NDYI = (X[:, 2, :] - X[:, 1, :]) / (X[:, 2, :] + X[:, 1, :])
+
+    X["DYI"] = X["B03"] - X["B02"]
+    #DYI = X[:, 2, :] - X[:, 1, :]
+
+    X["ACI"] = X["B08"] * (X["B04"] + X["B03"])
+    #ACI = X[:, 7, :] * (X[:, 3, :] + X[:, 2, :])
+
+    # WEED
+    X["CVI"] = (X["B08"] / X["B03"]) * (X["B04"] / X["B03"])
+    #CVI = (X[:, 7, :] / X[:, 2, :]) * (X[:, 3, :] / X[:, 2, :])
+
+    X["AVI"] = (X["B08"] * (1 - X["B04"]) * (X["B08"] - X["B04"]))
+    #AVI = (X[:, 7, :] * (1 - X[:, 3, :]) * (X[:, 7, :] - X[:, 3, :]))
+
+    X["SI"] = ((1 - X["B02"]) * (1 - X["B03"]) * (1 - X["B04"]))
+    #SI= ((1 - X[:, 1, :]) * (1 - X[:, 2, :]) * (1 - X[:, 3, :]))
+
+    X["BSI"] = ((X["B11"] + X["B04"]) - (X["B08"] + X["B02"])) / ((X["B11"] + X["B04"]) + (X["B08"] + X["B02"]))
+    #BSI= ((X[:, 10, :] + X[:, 3, :]) - (X[:, 7, :] + X[:, 1, :])) / ((X[:, 10, :] + X[:, 3, :]) + (X[:, 7, :] + X[:, 1, :]))
+
+    # WINE GRAPES
+    X["MTCI"] = (X["B06"] - X["B05"])/(X["B05"] - X["B04"])
+    #MTCI = (X[:, 5, :] - X[:, 4, :])/(X[:, 4, :] - X[:, 3, :])
+
+    X["NPCRI"] = (X["B04"] - X["B02"]) / (X["B04"] + X["B02"])
+    #NPCRI = (X[:, 3, :] - X[:, 1, :]) / (X[:, 3, :] + X[:, 1, :])
+
+
+
+    # ROOIBOS
+    X["BAI"] = 1/((0.1 - X["B04"]) ** 2 + (0.06 - X["B08"]) ** 2)
+    #BAI = 1/((0.1 - X[:, 3, :]) ** 2 + (0.06 - X[:, 7, :]) ** 2)
+
+    #MTVI2 = list(1.5*(1.2 * (i - j) - 2.5 * (k - j))* ((2 * i + 1)**2-(6 * i - 5 * k ** (1/2.0)) - 0.5)**(1/2.0) for i, j, k in zip(X[:, 7, :], X[:, 2, :], X[:, 3, :]))
+    MTVI2 = list(1.5*(1.2 * (i - j) - 2.5 * (k - j))* ((2 * i + 1)**2-(6 * i - 5 * k ** (1/2.0)) - 0.5)**(1/2.0) for i, j, k in zip(X["B08"], X["B03"], X["B04"]))
+    X["MTVI2"] = np.array(MTVI2)
+
+    X["NDSI"] = (X["B03"] - X["B11"]) / (X["B03"] + X["B11"])
+    #NDSI = (X[:, 2, :] - X[:, 10, :]) / (X[:, 2, :] + X[:, 10, :])
+
+
+
+    # DRYNESS / DROUGHT
+    X["NDMI"] = (X["B08"] - X["B11"])/(X["B08"] + X["B11"])
+    #NDMI = (X[:, 7, :] - X[:, 10, :])/(X[:, 7, :] + X[:, 10, :])
+
+    TNDVI = [(x)**(1/2.0) for x in ((X["B08"] - X["B04"]) / (X["B08"] + X["B04"]) + 0.5)]
+    X["TNDVI"] = np.array(TNDVI)
+
+
+    # GENERAL
+    X["TVI"] = (120 * (X["B06"] - X["B03"]) - 200 * (X["B04"] - X["B03"])) / 2
+    #TVI = (120 * (X[:, 5, :] - X[:, 2, :]) - 200 * (X[:, 3, :] - X[:, 2, :])) / 2
+    X["EXG"] = 2 * X["B03"] - X["B04"] - X["B02"]
+    #EXG = 2 * X[:, 2, :] - X[:, 3, :] - X[:, 1, :]
+    X["PSRI"] = (X["B04"] - X["B02"]) / X["B06"]
+    #PSRI = (X[:, 3, :] - X[:, 1, :]) / X[:, 5, :]
+
+    return X

processing.py

@@ -0,0 +1,151 @@
+
+from PIL import Image
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from glob import glob
+import os
+import utm
+import rasterio
+from tqdm import tqdm
+#from xml.etree import ElementTree as et
+import xmltodict
+
+##
+def cloud_masking(image,cld):
+        cloud_mask = cld > 30
+        band_mean = image.mean()
+        image[cloud_mask] = band_mean
+        return image
+
+##
+def load_file(fp):
+    """Takes a PosixPath object or string filepath
+    and returns np array"""
+
+    return np.array(Image.open(fp.__str__()))
+
+def paths (name): 
+
+    fold_band_10 = glob(name+"/GRANULE/*/IMG_DATA/R10m")[0]
+    fold_band_20 = glob(name+"/GRANULE/*/IMG_DATA/R20m")[0]
+    fold_band_60 = glob(name+"/GRANULE/*/IMG_DATA/R60m")[0]
+    path = name+"/GRANULE/*/IMG_DATA/R10m"+"/*.jp2"
+    x = glob(path)
+    lists = x[0].split("/")[-1].split("_")
+    fixe = lists[0]+'_'+lists[1]
+
+    band_10 = ['B02', 'B03', 'B04','B08']
+    band_20 = ['B05', 'B06', 'B07','B8A','B11', 'B12']
+    band_60 = ['B01','B09']
+    images_name_10m = [fixe+"_"+band+"_10m.jp2" for band in band_10 ]
+    images_name_20m = [fixe+"_"+band+"_20m.jp2" for band in band_20 ]
+    images_name_60m = [fixe+"_"+band+"_60m.jp2" for band in band_60 ]
+    #
+    bandes_path_10 = [os.path.join(fold_band_10,img) for img in images_name_10m]
+    bandes_path_20 = [os.path.join(fold_band_20,img) for img in images_name_20m]
+    bandes_path_60 = [os.path.join(fold_band_60,img) for img in images_name_60m]
+    #
+    tile_path = name+"/INSPIRE.xml"
+    path_cld_20 = glob(name+"/GRANULE/*/QI_DATA/MSK_CLDPRB_20m.jp2")[0]
+    path_cld_60 = glob(name+"/GRANULE/*/QI_DATA/MSK_CLDPRB_60m.jp2")[0]
+
+    return bandes_path_10,bandes_path_20,bandes_path_60,tile_path,path_cld_20,path_cld_60
+
+##
+def coords_to_pixels(ref, utm, m=10):
+    """ Convert UTM coordinates to pixel coordinates"""
+
+    x = int((utm[0] - ref[0])/m)
+    y = int((ref[1] - utm[1])/m)
+
+    return x, y
+
+##
+def extract_sub_image(bandes_path,tile_path,area,resolution=10, d= 3, cld_path = None):
+    
+  xml_file=open(tile_path,"r")
+  xml_string=xml_file.read()
+  python_dict=xmltodict.parse(xml_string)
+  tile_coordonnates = python_dict["gmd:MD_Metadata"]["gmd:identificationInfo"]["gmd:MD_DataIdentification"]["gmd:abstract"]["gco:CharacterString"].split()
+
+  # S2 tile coordonnates
+  lat,lon = float(tile_coordonnates[0]),float(tile_coordonnates[1])
+  tile_coordonnate = [lat,lon]
+
+  refx, refy, _, _ = utm.from_latlon(tile_coordonnate[0], tile_coordonnate[1])
+  ax,ay,_,_ = utm.from_latlon(area[1],area[0]) # lat,lon
+  
+  ref = [refx, refy]
+  utm_cord = [ax,ay]
+  x,y = coords_to_pixels(ref,utm_cord,resolution)
+  
+  images = []
+  # sub_image_extraction
+  for band_path in tqdm(bandes_path, total=len(bandes_path)):
+    image = load_file(band_path).astype(np.float32)
+    if resolution==60:
+        sub_image = image[y,x]
+        images.append(sub_image)
+   
+    else:
+        sub_image = image[y-d:y+d,x-d:x+d]
+        images.append(sub_image)
+
+  images = np.array(images)
+        
+
+ # verify if the study are is cloudy
+  if cld_path is not None:
+    cld_mask = load_file(cld_path).astype(np.float32)
+    cld = cld_mask[y-d:y+d,x-d:x+d]
+    # cloud removing
+    images = cloud_masking(images,cld)
+
+  if resolution==60:
+      return images
+  else:
+      return images.mean((1,2))
+  
+
+def ndvi(area, tile_name):
+    """
+    polygone: (lon,lat) format
+    tile_name: name of tile with the most low cloud coverage
+    """
+    #Extract tile  coordonnates (lat,long)
+    tile_path = tile_name+"/INSPIRE.xml"
+    xml_file=open(tile_path,"r")
+    xml_string=xml_file.read()
+    python_dict=xmltodict.parse(xml_string)
+    tile_coordonnates = python_dict["gmd:MD_Metadata"]["gmd:identificationInfo"]["gmd:MD_DataIdentification"]["gmd:abstract"]["gco:CharacterString"].split()
+
+    # S2 tile coordonnates
+    lat,lon = float(tile_coordonnates[0]),float(tile_coordonnates[1])
+    tile_coordonnate = [lat,lon]
+
+    refx, refy, _, _ = utm.from_latlon(tile_coordonnate[0], tile_coordonnate[1])
+    ax,ay,_,_ = utm.from_latlon(area[1],area[0]) # lat,lon
+    
+    ref = [refx, refy]
+    utm_cord = [ax,ay]
+    x,y = coords_to_pixels(ref,utm_cord)
+
+    # read images
+    path_4 = tile_name+"/GRANULE/*/IMG_DATA/R10m/*_B04_10m.jp2"
+    path_8 = tile_name+"/GRANULE/*/IMG_DATA/R10m/*_B08_10m.jp2"
+    red_object = rasterio.open(glob(path_4)[0])
+    nir_object = rasterio.open(glob(path_8)[0])
+    red = red_object.read()
+    nir = nir_object.read()
+    red,nir = red[0],nir[0]
+    # extract area and remove unsigne
+    sub_red = red[y-3:y+3,x-3:x+3].astype(np.float16)
+    sub_nir = nir[y-3:y+3,x-3:x+3].astype(np.float16)
+    
+    # NDVI
+    ndvi_image = ((sub_nir - sub_red)/(sub_nir+sub_red))
+    ndvi_mean_value = ndvi_image.mean()
+    
+    return ndvi_mean_value
+      

requirements.txt

@@ -0,0 +1,13 @@
+DateTime==5.2
+geojson==3.0.1
+matplotlib==3.8.0
+numpy==1.26.0
+pandas==2.1.1
+Pillow==10.0.1
+scipy==1.11.2
+sentinelsat==1.2.1
+tqdm==4.66.1
+utm==0.7.0
+xgboost==2.0.0
+xmltodict==0.13.0
+rasterio