clean

biomap/app.py

@@ -9,14 +9,13 @@ from plot_functions import segment_region
 from functools import partial
 import gradio as gr
 import logging
+import sys
 
 import geopandas as gpd
 mapbox_access_token = "pk.eyJ1IjoiamVyZW15LWVraW1ldHJpY3MiLCJhIjoiY2xrNjBwNGU2MDRhMjNqbWw0YTJrbnpvNCJ9.poVyIzhJuJmD6ffrL9lm2w"
 geo_df = gpd.read_file(gpd.datasets.get_path('naturalearth_cities'))
 
 def get_geomap(long, lat ):
-    
-
     fig = go.Figure(go.Scattermapbox(
             lat=geo_df.geometry.y,
             lon=geo_df.geometry.x,
@@ -53,17 +52,19 @@ def get_geomap(long, lat ):
 
 
 if __name__ == "__main__":
-    
-    
-    logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.INFO)
+    file_handler = logging.FileHandler(filename='biomap.log')
+    stdout_handler = logging.StreamHandler(stream=sys.stdout)
+    handlers = [file_handler, stdout_handler]
+
+    logging.basicConfig(handlers=handlers, encoding='utf-8', level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
     # Initialize hydra with configs
-    #hydra.initialize(config_path="configs", job_name="corine")
+    hydra.initialize(config_path="configs", job_name="corine")
     cfg = hydra.compose(config_name="my_train_config.yml")
     logging.info(f"config : {cfg}")
-    # Load the model
 
     nbclasses = cfg.dir_dataset_n_classes
     model = LitUnsupervisedSegmenter(nbclasses, cfg)
+    model = model.cpu()
     logging.info(f"Model Initialiazed")
     
     model_path = "biomap/checkpoint/model/model.pt"
@@ -71,15 +72,19 @@ if __name__ == "__main__":
     logging.info(f"Model weights Loaded")
     model.load_state_dict(saved_state_dict)
     logging.info(f"Model Loaded")
-# css=".VIDEO video{height: 100%;width:50%;margin:auto};.VIDEO{height: 50%;};.svelte-1vnmhm4{height:auto}"
-    with gr.Blocks() as demo:
-        gr.Markdown("Estimate Biodiversity in the world.")
+    with gr.Blocks(title="Biomap by Ekimetrics") as demo:
+        gr.Markdown("<h1><center>🐢 Biomap by Ekimetrics 🐢</center></h1>")
+        gr.Markdown("<h4><center>Estimate Biodiversity score in the world by using segmentation of land.</center></h4>")
+        gr.Markdown("Land use is divided into 6 differents classes :Each class is assigned a GBS score from 0 to 1")
+        gr.Markdown("Buildings : 0.1 | Infrastructure : 0.1 | Cultivation : 0.4 | Wetland : 0.9 | Water : 0.9 | Natural green : 1 ")
+        gr.Markdown("The score is then average on the full image.")
         with gr.Tab("Single Image"):
             with gr.Row():
-                input_map = gr.Plot().style()  
+                input_map = gr.Plot() 
                 with gr.Column():
-                    input_latitude = gr.Number(label="lattitude", value=2.98)
-                    input_longitude = gr.Number(label="longitude", value=48.81)
+                    with gr.Row():
+                        input_latitude = gr.Number(label="lattitude", value=2.98)
+                        input_longitude = gr.Number(label="longitude", value=48.81)
                     input_date = gr.Textbox(label="start_date", value="2020-03-20")
 
             single_button = gr.Button("Predict")
@@ -90,15 +95,17 @@ if __name__ == "__main__":
 
         with gr.Tab("TimeLapse"):
             with gr.Row():
-                input_map_2 = gr.Plot().style() 
-            with gr.Row():
-                timelapse_input_latitude = gr.Number(value=2.98, label="Latitude")
-                timelapse_input_longitude = gr.Number(value=48.81, label="Longitude")
-                timelapse_start_date = gr.Textbox(value='2020-05-01', label="Start Date")
-                timelapse_end_date = gr.Textbox(value='2020-06-30', label="End Date")
-            segmentation = gr.CheckboxGroup(choices=['month', 'year', '2months'], value=['month'], label="Select Segmentation Level:")
+                input_map_2 = gr.Plot()
+                with gr.Column():
+                    with gr.Row():
+                        timelapse_input_latitude = gr.Number(value=2.98, label="Latitude")
+                        timelapse_input_longitude = gr.Number(value=48.81, label="Longitude")
+                    with gr.Row():
+                        timelapse_start_date = gr.Dropdown(choices=[2017,2018,2019,2020,2021,2022,2023], value=2020, label="Start Date")
+                        timelapse_end_date = gr.Dropdown(choices=[2017,2018,2019,2020,2021,2022,2023], value=2021, label="End Date")
+                    segmentation = gr.Dropdown(choices=['month', 'year', '2months'], value='year', label="Interval of time between two segmentation")
             timelapse_button = gr.Button(value="Predict")     
-            map = gr.Plot().style()
+            map = gr.Plot()
         
         demo.load(get_geomap, [input_latitude, input_longitude], input_map)
         single_button.click(get_geomap, [input_latitude, input_longitude], input_map)
@@ -106,5 +113,5 @@ if __name__ == "__main__":
 
         demo.load(get_geomap, [timelapse_input_latitude, timelapse_input_longitude], input_map_2)
         timelapse_button.click(get_geomap, [timelapse_input_latitude, timelapse_input_longitude], input_map_2)
-        timelapse_button.click(segment_region, inputs=[timelapse_input_latitude, timelapse_input_longitude, timelapse_start_date, timelapse_end_date,segmentation], outputs=[map])
+        timelapse_button.click(partial(inference_on_location, model), inputs=[timelapse_input_latitude, timelapse_input_longitude, timelapse_start_date, timelapse_end_date,segmentation], outputs=[map])
     demo.launch()

biomap/helper.py

@@ -1,29 +1,16 @@
 import torch.multiprocessing
 import torchvision.transforms as T
 import numpy as np
-from utils import transform_to_pil, create_video
-from utils_gee import extract_img, transform_ee_img
+from utils import transform_to_pil, compute_biodiv_score, plot_imgs_labels
+from utils_gee import get_image
 from dateutil.relativedelta import relativedelta
 import datetime
-from dateutil.relativedelta import relativedelta
-import cv2
-
+import matplotlib as mpl
 from joblib import Parallel, cpu_count, delayed
+import logging
+from inference import inference
 
-def get_image(location, d1, d2):
-    print(f"getting image for {d1} to {d2}")
-    try:
-        img = extract_img(location, d1, d2)
-        img_test = transform_ee_img(
-            img, max=0.3
-        )
-        return img_test
-    except Exception as err:
-        print(err)
-        return 
-        
-
-def inference_on_location(model, latitude = 2.98, longitude = 48.81, start_date=2020, end_date=2022):
+def inference_on_location(model, latitude=2.98, longitude=48.81, start_date=2020, end_date=2022, how="year"):
     """Performe an inference on the latitude and longitude between the start date and the end date
 
     Args:
@@ -36,64 +23,44 @@ def inference_on_location(model, latitude = 2.98, longitude = 48.81, start_date=
     Returns:            
         img, labeled_img,biodiv_score: the original landscape, the labeled landscape and the biodiversity score and the landscape
     """
-    assert end_date > start_date, "end date must be stricly higher than start date"
+    logging.info("Running Inference on location")
+    logging.info(f"latitude : {latitude} & longitude : {longitude}")
+    logging.info(f"start date : {start_date} & end_date : {end_date}")
+    logging.info(f"Prediction on intervale : {how}")
+    if how == "month":
+        delta_month = 1
+    elif how == "2months":
+        delta_month = 2
+    elif how == "year":
+        delta_month = 11
+    else:
+        raise ValueError("Wrong interval")
+
+    assert int(end_date) > int(start_date), "end date must be stricly higher than start date"
     location = [float(latitude), float(longitude)]
     
     # Extract img numpy from earth engine and transform it to PIL img
     dates = [datetime.datetime(start_date, 1, 1, 0, 0, 0)]
-    while dates[-1] < datetime.datetime(end_date, 1, 1, 0, 0, 0):
-        dates.append(dates[-1] + relativedelta(months=1))
+    while dates[-1] < datetime.datetime(int(end_date), 1, 1, 0, 0, 0):
+        dates.append(dates[-1] + relativedelta(months=delta_month))
     
     dates = [d.strftime("%Y-%m-%d") for d in dates]
 
     all_image = Parallel(n_jobs=cpu_count(), prefer="threads")(delayed(get_image)(location, d1,d2) for d1, d2 in zip(dates[:-1],dates[1:]))
-    all_image = [image for image in all_image if image is not None]
+    outputs = inference(np.array(all_image), model)
 
+    logging.info("Calculating Biodiversity Scores...")
+    scores, scores_details = map(list, zip(*[compute_biodiv_score(output["linear_preds"].detach().numpy()) for output in outputs]))
+    logging.info(f"Calculated Biodiversity Score : {scores}")
+
+    imgs, labels, labeled_imgs = map(list, zip(*[transform_to_pil(output) for output in outputs]))
     
-        
-
-    # tensorize & normalize img
-    preprocess = T.Compose(
-        [
-            T.ToPILImage(),
-            T.Resize((320, 320)),
-            #    T.CenterCrop(224),
-            T.ToTensor(),
-            T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        ]
-    )
-
-    # Preprocess opened img
-    x = torch.stack([preprocess(imag) for imag in all_image]).cpu()
-
-    # launch inference on cpu
-    # x = torch.unsqueeze(x, dim=0).cpu()
-    model = model.cpu()
-
-    with torch.no_grad():
-        feats, code = model.net(x)
-        linear_pred = model.linear_probe(x, code)
-        linear_pred = linear_pred.argmax(1)
-        outputs = [{
-            "img": torch.unsqueeze(img, dim=0).detach().cpu(),
-            "linear_preds": torch.unsqueeze(linear_pred, dim=0).detach().cpu(),
-        } for img, linear_pred in zip(x, linear_pred)]
-    all_img = []
-    all_label = []
-    all_labeled_img = []
-    for output in outputs:
-        img, label, labeled_img = transform_to_pil(output)
-        all_img.append(img)
-        all_label.append(label)
-        all_labeled_img.append(labeled_img)
-
-    all_labeled_img = [np.array(pil_image)[:, :, ::-1] for pil_image in all_labeled_img]
-    create_video(all_labeled_img, output_path='output/output.mp4')
-    
-    # all_labeled_img = [np.array(pil_image)[:, :, ::-1] for pil_image in all_img]
-    # create_video(all_labeled_img, output_path='raw.mp4')
-    
-    return 'output.mp4'
+    images = [np.asarray(img) for img in imgs]
+    labeled_imgs = [np.asarray(img) for img in labeled_imgs]
+    fig = plot_imgs_labels(dates, images, labeled_imgs, scores_details, scores)
+    # fig.save("test.png")
+    return fig
+
 
 def inference_on_location_and_month(model, latitude = 2.98, longitude = 48.81, start_date = '2020-03-20'):
     """Performe an inference on the latitude and longitude between the start date and the end date
@@ -108,59 +75,36 @@ def inference_on_location_and_month(model, latitude = 2.98, longitude = 48.81, s
     Returns:
         img, labeled_img,biodiv_score: the original landscape, the labeled landscape and the biodiversity score and the landscape
     """
+    logging.info("Running Inference on location and month")
+    logging.info(f"latitude : {latitude} & longitude : {longitude}")
     location = [float(latitude), float(longitude)]
     
     # Extract img numpy from earth engine and transform it to PIL img
     end_date = datetime.datetime.strptime(start_date, "%Y-%m-%d") + relativedelta(months=1)
     end_date = datetime.datetime.strftime(end_date, "%Y-%m-%d")
-    img = extract_img(location, start_date, end_date)
-    img_test = transform_ee_img(
-        img, max=0.3
-    )  # max value is the value from numpy file that will be equal to 255
-
-    # tensorize & normalize img
-    preprocess = T.Compose(
-        [
-            T.ToPILImage(),
-            T.Resize((320, 320)),
-            #    T.CenterCrop(224),
-            T.ToTensor(),
-            T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        ]
-    )
-
-    # Preprocess opened img
-    x = preprocess(img_test)
-
-    # launch inference on cpu
-    x = torch.unsqueeze(x, dim=0).cpu()
-    model = model.cpu()
-
-    with torch.no_grad():
-        feats, code = model.net(x)
-        linear_pred = model.linear_probe(x, code)
-        linear_pred = linear_pred.argmax(1)
-        output = {
-            "img": x[: model.cfg.n_images].detach().cpu(),
-            "linear_preds": linear_pred[: model.cfg.n_images].detach().cpu(),
-        }
-    nb_values = []
-    for i in range(7):
-        nb_values.append(np.count_nonzero(output['linear_preds'][0] == i+1))
-    scores_init = [2,3,4,3,1,4,0]
-    score = sum(x * y for x, y in zip(scores_init, nb_values)) / sum(nb_values) / max(scores_init)
-
-    img, label, labeled_img = transform_to_pil(output)
-    return img, labeled_img,score
+
+    logging.info("Getting Image...")
+    img_test = get_image(location, start_date, end_date)
+    outputs = inference(np.array([img_test]), model)
+
+    logging.info("Calculating Biodiversity Score...")
+    score, score_details = compute_biodiv_score(outputs[0]["linear_preds"].detach().numpy())
+    logging.info(f"Calculated Biodiversity Score : {score}")
+    img, label, labeled_img = transform_to_pil(outputs[0])
+
+    return img, labeled_img, score
 
 
 if __name__ == "__main__":
     import logging
     import hydra
-
-
+    import sys
     from model import LitUnsupervisedSegmenter
-    logging.basicConfig(filename='example.log', encoding='utf-8', level=logging.INFO)
+    file_handler = logging.FileHandler(filename='biomap.log')
+    stdout_handler = logging.StreamHandler(stream=sys.stdout)
+    handlers = [file_handler, stdout_handler]
+
+    logging.basicConfig(handlers=handlers, encoding='utf-8', level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
     # Initialize hydra with configs
     hydra.initialize(config_path="configs", job_name="corine")
     cfg = hydra.compose(config_name="my_train_config.yml")
@@ -171,9 +115,12 @@ if __name__ == "__main__":
     model = LitUnsupervisedSegmenter(nbclasses, cfg)
     logging.info(f"Model Initialiazed")
     
-    model_path = "checkpoint/model/model.pt"
+    model_path = "biomap/checkpoint/model/model.pt"
     saved_state_dict = torch.load(model_path, map_location=torch.device("cpu"))
     logging.info(f"Model weights Loaded")
     model.load_state_dict(saved_state_dict)
+
     logging.info(f"Model Loaded")
+    # inference_on_location_and_month(model)
     inference_on_location(model)
+

biomap/inference.py

@@ -2,9 +2,7 @@ import torch.multiprocessing
 import torchvision.transforms as T
 from utils import transform_to_pil
 
-def inference(image, model):
-    # tensorize & normalize img
-    preprocess = T.Compose(
+preprocess = T.Compose(
         [
             T.ToPILImage(),
             T.Resize((320, 320)),
@@ -14,24 +12,18 @@ def inference(image, model):
         ]
     )
 
-    # Preprocess opened img
-    x = preprocess(image)
-
-    # launch inference on cpu
-    x = torch.unsqueeze(x, dim=0).cpu()
-    model = model.cpu()
+def inference(images, model):
+    x = torch.stack([preprocess(image) for image in images]).cpu()
 
     with torch.no_grad():
-        feats, code = model.net(x)
+        _, code = model.net(x)
         linear_pred = model.linear_probe(x, code)
         linear_pred = linear_pred.argmax(1)
-        output = {
-            "img": x[: model.cfg.n_images].detach().cpu(),
-            "linear_preds": linear_pred[: model.cfg.n_images].detach().cpu(),
-        }
-
-    img, label, labeled_img = transform_to_pil(output)
-    return img, labeled_img, label
+        outputs = [{
+            "img": x[i].detach().cpu(),
+            "linear_preds": linear_pred[i].detach().cpu(),
+        } for i in range(x.shape[0])]
+    return outputs
 
 
 if __name__ == "__main__":
@@ -55,7 +47,7 @@ if __name__ == "__main__":
     cfg = hydra.compose(config_name="my_train_config.yml")
 
     # Load the model
-    model_path = "checkpoint/model/model.pt"
+    model_path = "biomap/checkpoint/model/model.pt"
     saved_state_dict = torch.load(model_path, map_location=torch.device("cpu"))
 
     nbclasses = cfg.dir_dataset_n_classes
@@ -65,197 +57,7 @@ if __name__ == "__main__":
     model.load_state_dict(saved_state_dict)
     print("model loaded")
     # img.save("output/image.png")
-    img, labeled_img, label = inference(image, model)
-    img.save("output/img.png")
-    label.save("output/label.png")
-    labeled_img.save("output/labeled_img.png")
-
-
-
-
-# def get_list_date(start_date, end_date):
-#     """Get all the date between the start date and the end date
-
-#     Args:
-#         start_date (str): start date at the format '%Y-%m-%d'
-#         end_date (str): end date at the format '%Y-%m-%d'
-
-#     Returns:
-#         list[str]: all the date between the start date and the end date
-#     """
-#     start_date = datetime.datetime.strptime(start_date, "%Y-%m-%d").date()
-#     end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d").date()
-#     list_date = [start_date]
-#     date = start_date
-#     while date < end_date:
-#         date = date + datetime.timedelta(days=1)
-#         list_date.append(date)
-#     list_date.append(end_date)
-#     list_date2 = [x.strftime("%Y-%m-%d") for x in list_date]
-#     return list_date2
-
-
-# def get_length_interval(start_date, end_date):
-#     """Return how many days there is between the start date and the end date
-
-#     Args:
-#         start_date (str): start date at the format '%Y-%m-%d'
-#         end_date (str): end date at the format '%Y-%m-%d'
-
-#     Returns:
-#         int : number of days between start date and the end date
-#     """
-#     try:
-#         return len(get_list_date(start_date, end_date))
-#     except ValueError:
-#         return 0
-
-
-# def infer_unique_date(latitude, longitude, date, model=model):
-#     """Perform an inference on a latitude and a longitude at a specific date
-
-#     Args:
-#         latitude (float): the latitude of the landscape
-#         longitude (float): the longitude of the landscape
-#         date (str): date for the inference at the format '%Y-%m-%d'
-#         model (_type_, optional): _description_. Defaults to model.
-
-#     Returns:
-#         img, labeled_img,biodiv_score: the original landscape, the labeled landscape and the biodiversity score and the landscape
-#     """
-#     start_date = date
-#     end_date = date
-#     location = [float(latitude), float(longitude)]
-#     # Extract img numpy from earth engine and transform it to PIL img
-#     img = extract_img(location, start_date, end_date)
-#     img_test = transform_ee_img(
-#         img, max=0.3
-#     )  # max value is the value from numpy file that will be equal to 255
-
-#     # tensorize & normalize img
-#     preprocess = T.Compose(
-#         [
-#             T.ToPILImage(),
-#             T.Resize((320, 320)),
-#             #    T.CenterCrop(224),
-#             T.ToTensor(),
-#             T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-#         ]
-#     )
-
-#     # Preprocess opened img
-#     x = preprocess(img_test)
-
-#     # launch inference on cpu
-#     x = torch.unsqueeze(x, dim=0).cpu()
-#     model = model.cpu()
-
-#     with torch.no_grad():
-#         feats, code = model.net(x)
-#         linear_pred = model.linear_probe(x, code)
-#         linear_pred = linear_pred.argmax(1)
-#         output = {
-#             "img": x[: model.cfg.n_images].detach().cpu(),
-#             "linear_preds": linear_pred[: model.cfg.n_images].detach().cpu(),
-#         }
-
-#     img, label, labeled_img = transform_to_pil(output)
-#     biodiv_score = compute_biodiv_score(labeled_img)
-#     return img, labeled_img, biodiv_score
-
-
-# def get_img_array(start_date, end_date, latitude, longitude, model=model):
-#     list_date = get_list_date(start_date, end_date)
-#     list_img = []
-#     for date in list_date:
-#         list_img.append(img)
-#     return list_img
-
-
-# def variable_outputs(start_date, end_date, latitude, longitude, day, model=model):
-#     """Perform an inference on the day number day starting from the start at the latitude and longitude selected
-
-#     Args:
-#         latitude (float): the latitude of the landscape
-#         longitude (float): the longitude of the landscape
-#         start_date (str): the start date for our inference
-#         end_date (str): the end date for our inference
-#         model (_type_, optional): _description_. Defaults to model.
-
-#     Returns:
-#         img,labeled_img,biodiv_score: the original landscape, the labeled landscape and the biodiversity score and the landscape at the selected, longitude, latitude and date
-#     """
-#     list_date = get_list_date(start_date, end_date)
-#     k = int(day)
-#     date = list_date[k]
-#     img, labeled_img, biodiv_score = infer_unique_date(
-#         latitude, longitude, date, model=model
-#     )
-#     return img, labeled_img, biodiv_score
-
-
-# def variable_outputs2(
-#     start_date, end_date, latitude, longitude, day_number, model=model
-# ):
-#     """Perform an inference on the day number day starting from the start at the latitude and longitude selected
-
-#     Args:
-#         latitude (float): the latitude of the landscape
-#         longitude (float): the longitude of the landscape
-#         start_date (str): the start date for our inference
-#         end_date (str): the end date for our inference
-#         model (_type_, optional): _description_. Defaults to model.
-
-#     Returns:
-#         list[img,labeled_img,biodiv_score]: the original landscape, the labeled landscape and the biodiversity score and the landscape at the selected, longitude, latitude and date
-#     """
-#     list_date = get_list_date(start_date, end_date)
-#     k = int(day_number)
-#     date = list_date[k]
-#     img, labeled_img, biodiv_score = infer_unique_date(
-#         latitude, longitude, date, model=model
-#     )
-#     return [img, labeled_img, biodiv_score]
-
-
-# def gif_maker(img_array):
-#     output_file = "test2.mkv"
-#     image_test = img_array[0]
-#     size = (320, 320)
-#     print(size)
-#     out = cv2.VideoWriter(
-#         output_file, cv2.VideoWriter_fourcc(*"avc1"), 15, frameSize=size
-#     )
-#     for i in range(len(img_array)):
-#         image = img_array[i]
-#         pix = np.array(image.getdata())
-#         out.write(pix)
-#     out.release()
-#     return output_file
-
-
-# def infer_multiple_date(start_date, end_date, latitude, longitude, model=model):
-#     """Perform an inference on all the dates between the start date and the end date at the latitude and longitude
-
-#     Args:
-#         latitude (float): the latitude of the landscape
-#         longitude (float): the longitude of the landscape
-#         start_date (str): the start date for our inference
-#         end_date (str): the end date for our inference
-#         model (_type_, optional): _description_. Defaults to model.
+    inference([image], model)
 
-#     Returns:
-#         list_img,list_labeled_img,list_biodiv_score: list of the original landscape, the labeled landscape and the biodiversity score and the landscape
-#     """
-#     list_date = get_list_date(start_date, end_date)
-#     list_img = []
-#     list_labeled_img = []
-#     list_biodiv_score = []
-#     for date in list_date:
-#         img, labeled_img, biodiv_score = infer_unique_date(
-#             latitude, longitude, date, model=model
-#         )
-#         list_img.append(img)
-#         list_labeled_img.append(labeled_img)
-#         list_biodiv_score.append(biodiv_score)
-#     return gif_maker(list_img), gif_maker(list_labeled_img), list_biodiv_score[0]
+    inference([image,image], model)
+    

biomap/plot_functions.py

@@ -1,17 +1,10 @@
 from PIL import Image
 
-import hydra
 import matplotlib as mpl
 from utils import prep_for_plot
 
 import torch.multiprocessing
 import torchvision.transforms as T
-# import matplotlib.pyplot as plt
-from model import LitUnsupervisedSegmenter
-colors = ('red', 'palegreen', 'green', 'steelblue', 'blue', 'yellow', 'lightgrey')
-class_names = ('Buildings', 'Cultivation', 'Natural green', 'Wetland', 'Water', 'Infrastructure', 'Background')
-cmap = mpl.colors.ListedColormap(colors)
-#from train_segmentation import LitUnsupervisedSegmenter, cmap
 
 from utils_gee import extract_img, transform_ee_img
 
@@ -20,85 +13,20 @@ import plotly.express as px
 import numpy as np
 from plotly.subplots import make_subplots
 
-import os    
+import os   
 os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
 
-
 colors = ('red', 'palegreen', 'green', 'steelblue', 'blue', 'yellow', 'lightgrey')
 class_names = ('Buildings', 'Cultivation', 'Natural green', 'Wetland', 'Water', 'Infrastructure', 'Background')
-scores_init = [2,3,4,3,1,4,0]
-
-# Import model configs
-hydra.initialize(config_path="configs",  job_name="corine")
-cfg = hydra.compose(config_name="my_train_config.yml")
-
-nbclasses = cfg.dir_dataset_n_classes
-
-# Load Model
-model_path = "biomap/checkpoint/model/model.pt"
-saved_state_dict = torch.load(model_path,map_location=torch.device('cpu'))
-
-model = LitUnsupervisedSegmenter(nbclasses, cfg)
-model.load_state_dict(saved_state_dict)
-
-from PIL import Image
-
-import hydra
-
-from utils import prep_for_plot
-
-import torch.multiprocessing
-import torchvision.transforms as T
-# import matplotlib.pyplot as plt   
-
-from model import LitUnsupervisedSegmenter
-
-from utils_gee import extract_img, transform_ee_img
-
-import plotly.graph_objects as go
-import plotly.express as px
-import numpy as np
-from plotly.subplots import make_subplots
-
-import os    
-os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-
+cmap = mpl.colors.ListedColormap(colors)
 
 colors = ('red', 'palegreen', 'green', 'steelblue', 'blue', 'yellow', 'lightgrey')
-cmap = mpl.colors.ListedColormap(colors)
 class_names = ('Buildings', 'Cultivation', 'Natural green', 'Wetland', 'Water', 'Infrastructure', 'Background')
-scores_init = [2,3,4,3,1,4,0]
-
-# Import model configs
-#hydra.initialize(config_path="configs",  job_name="corine")
-cfg = hydra.compose(config_name="my_train_config.yml")
-
-nbclasses = cfg.dir_dataset_n_classes
-
-# Load Model
-model_path = "biomap/checkpoint/model/model.pt"
-saved_state_dict = torch.load(model_path,map_location=torch.device('cpu'))
-
-model = LitUnsupervisedSegmenter(nbclasses, cfg)
-model.load_state_dict(saved_state_dict)
-
-
-#normalize img
-preprocess = T.Compose([
-   T.ToPILImage(),
-   T.Resize((320,320)),
-#    T.CenterCrop(224),
-   T.ToTensor(),
-   T.Normalize(
-       mean=[0.485, 0.456, 0.406],
-       std=[0.229, 0.224, 0.225]
-   )
-])
+scores_init = [1,2,4,3,4,1,0]
 
 # Function that look for img on EE and segment it
 # -- 3 ways possible to avoid cloudy environment -- monthly / bi-monthly / yearly meaned img
-
-def segment_loc(location, month, year, how = "month", month_end = '12', year_end = None) :
+def segment_loc(model, location, month, year, how = "month", month_end = '12', year_end = None) :
     if how == 'month':
         img = extract_img(location, year +'-'+ month +'-01', year +'-'+ month +'-28')
     elif how == 'year' :
@@ -106,7 +34,6 @@ def segment_loc(location, month, year, how = "month", month_end = '12', year_end
             img = extract_img(location, year +'-'+ month +'-01', year +'-'+ month_end +'-28', width = 0.04 , len = 0.04)
         else : 
             img = extract_img(location, year +'-'+ month +'-01', year_end +'-'+ month_end +'-28', width = 0.04 , len = 0.04)
-            
     
     img_test= transform_ee_img(img, max = 0.25)
 
@@ -177,38 +104,8 @@ def segment_group(location, start_date, end_date, how = 'month') :
              
     return outputs
 
-
-# Function that transforms an output to PIL images
-
-def transform_to_pil(outputs,alpha=0.3):
-    # Transform img with torch
-    img = torch.moveaxis(prep_for_plot(outputs['img'][0]),-1,0)
-    img=T.ToPILImage()(img)
-    
-    # Transform label by saving it then open it
-    # label = outputs['linear_preds'][0]
-    # plt.imsave('label.png',label,cmap=cmap)
-    # label = Image.open('label.png')
-
-    cmaplist = np.array([np.array(cmap(i)) for i in range(cmap.N)])
-    labels = np.array(outputs['linear_preds'][0])-1
-    label = T.ToPILImage()((cmaplist[labels]*255).astype(np.uint8))
-    
-
-    # Overlay labels with img wit alpha
-    background = img.convert("RGBA")
-    overlay = label.convert("RGBA")
-    
-    labeled_img = Image.blend(background, overlay, alpha)
-
-    return img, label, labeled_img
-
-
-
-# Function that extract labeled_img(PIL) and nb_values(number of pixels for each class) and the score for each observation
-
 def values_from_output(output):
-    imgs = transform_to_pil(output,alpha = 0.3)
+    imgs = transform_to_pil(output, alpha = 0.3)
     
     img = imgs[0]
     img = np.array(img.convert('RGB'))
@@ -436,7 +333,7 @@ preprocess = T.Compose([
 # Function that look for img on EE and segment it
 # -- 3 ways possible to avoid cloudy environment -- monthly / bi-monthly / yearly meaned img
 
-def segment_loc(location, month, year, how = "month", month_end = '12', year_end = None) :
+def segment_loc(model,location, month, year, how = "month", month_end = '12', year_end = None) :
     if how == 'month':
         img = extract_img(location, year +'-'+ month +'-01', year +'-'+ month +'-28')
     elif how == 'year' :
@@ -583,180 +480,6 @@ def values_from_outputs(outputs) :
 
 
 
-def plot_imgs_labels(months, imgs, imgs_label, nb_values, scores) :       
-
-    fig2 = px.imshow(np.array(imgs), animation_frame=0, binary_string=True)
-    fig3 = px.imshow(np.array(imgs_label), animation_frame=0, binary_string=True)
-    
-    # Scores 
-    scatters = []
-    temp = []
-    for score in scores :
-        temp_score = []
-        temp_date = []
-        #score = scores[i]
-        temp.append(score)
-        n = len(temp)
-        text_temp = ["" for i in temp]
-        text_temp[-1] = str(round(score,2))
-        scatters.append(go.Scatter(x=[0,1], y=temp, mode="lines+markers+text", marker_color="black", text = text_temp, textposition="top center"))
-        print(text_temp)
-
-    # Scores 
-    fig = make_subplots(
-        rows=1, cols=4,
-        specs=[[{"type": "image"},{"type": "image"}, {"type": "pie"}, {"type": "scatter"}]],
-        subplot_titles=("Localisation visualization", "Labeled visualisation", "Segments repartition", "Biodiversity scores")
-    )
-
-    fig.add_trace(fig2["frames"][0]["data"][0], row=1, col=1)
-    fig.add_trace(fig3["frames"][0]["data"][0], row=1, col=2)
-
-    fig.add_trace(go.Pie(labels = class_names,
-                values = nb_values[0],
-                marker_colors = colors, 
-                name="Segment repartition",
-                textposition='inside',
-                texttemplate = "%{percent:.0%}",
-                textfont_size=14
-                ),
-                row=1, col=3)
-
-
-    fig.add_trace(scatters[0], row=1, col=4)
-    fig.update_traces(showlegend=False, selector=dict(type='scatter'))
-    #fig.update_traces(, selector=dict(type='scatter'))
-    # fig.add_annotation(text='score:' + str(scores[0]), 
-    #                 showarrow=False,
-    #                 row=2, col=2)
-
-
-    number_frames = len(imgs)
-    frames = [dict(
-                name = k,
-                data = [ fig2["frames"][k]["data"][0],
-                        fig3["frames"][k]["data"][0],
-                        go.Pie(labels = class_names,
-                                values = nb_values[k],
-                                marker_colors = colors, 
-                                name="Segment repartition",
-                                textposition='inside',
-                                texttemplate = "%{percent:.0%}",
-                                textfont_size=14
-                                ),
-                        scatters[k]
-                        ],
-                traces=[0, 1,2,3] # the elements of the list [0,1,2] give info on the traces in fig.data
-                                        # that are updated by the above three go.Scatter instances
-                ) for k in range(number_frames)]
-
-    updatemenus = [dict(type='buttons',
-                        buttons=[dict(label='Play',
-                                    method='animate',
-                                    args=[[f'{k}' for k in range(number_frames)], 
-                                            dict(frame=dict(duration=500, redraw=False), 
-                                                transition=dict(duration=0),
-                                                easing='linear',
-                                                fromcurrent=True,
-                                                mode='immediate'
-                                                                    )])],
-                        direction= 'left', 
-                        pad=dict(r= 10, t=85), 
-                        showactive =True, x= 0.1, y= 0.13, xanchor= 'right', yanchor= 'top')
-                ]
-
-    sliders = [{'yanchor': 'top',
-                'xanchor': 'left', 
-                'currentvalue': {'font': {'size': 16}, 'prefix': 'Frame: ', 'visible': False, 'xanchor': 'right'},
-                'transition': {'duration': 500.0, 'easing': 'linear'},
-                'pad': {'b': 10, 't': 50}, 
-                'len': 0.9, 'x': 0.1, 'y': 0, 
-                'steps': [{'args': [[k], {'frame': {'duration': 500.0, 'easing': 'linear', 'redraw': False},
-                                        'transition': {'duration': 0, 'easing': 'linear'}}], 
-                        'label': months[k], 'method': 'animate'} for k in range(number_frames)       
-                        ]}]
-
-
-    fig.update(frames=frames)
-
-    for i,fr in enumerate(fig["frames"]):
-        fr.update(
-            layout={
-                "xaxis": {
-                            "range": [0,imgs[0].shape[1]+i/100000]
-                        },
-                "yaxis": {
-                            "range": [imgs[0].shape[0]+i/100000,0]
-                        },
-            })
-        
-        fr.update(layout_title_text= months[i])
-
-
-    fig.update(layout_title_text= months[0])
-    fig.update(
-            layout={
-                "xaxis": {
-                            "range": [0,imgs[0].shape[1]+i/100000],
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at x=0
-                            'visible': False,  # numbers below
-                        },
-
-                "yaxis": {
-                            "range": [imgs[0].shape[0]+i/100000,0],
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at y=0
-                            'visible': False,},
-                            
-                "xaxis2": {
-                            "range": [0,imgs[0].shape[1]+i/100000],
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at x=0
-                            'visible': False,  # numbers below
-                        },
-
-                "yaxis2": {
-                            "range": [imgs[0].shape[0]+i/100000,0],
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at y=0
-                            'visible': False,},
-                            
-                
-                "xaxis3": {
-                            "range": [0,len(scores)+1],
-                            'autorange': False, # thin lines in the background
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at y=0
-                            'visible': False    
-                        },
-                
-                "yaxis3": {
-                            "range": [0,1.5],
-                            'autorange': False,
-                            'showgrid': False, # thin lines in the background
-                            'zeroline': False, # thick line at y=0
-                            'visible': False # thin lines in the background
-                         }   
-            }
-            )
-
-
-    fig.update_layout(updatemenus=updatemenus,
-                    sliders=sliders,
-                    legend=dict(
-                        yanchor= 'top',
-                        xanchor= 'left', 
-                        orientation="h")
-    )
-
-
-    fig.update_layout(margin=dict(b=0, r=0))
-    
-    # fig.show() #in jupyter notebook
-    
-    return fig
-
 
 
 # Last function (global one)
@@ -770,6 +493,7 @@ def segment_region(latitude, longitude, start_date, end_date, how = 'month'):
 
     #extract the intersting values from image
     months, imgs, imgs_label, nb_values, scores = values_from_outputs(outputs)
+    print(months, imgs, imgs_label, nb_values, scores)
 
 
     #Create the figure

biomap/utils.py

@@ -18,22 +18,47 @@ from torchvision import models
 from torchvision import transforms as T
 from torch.utils.tensorboard.summary import hparams
 import matplotlib as mpl
-torch.multiprocessing.set_sharing_strategy("file_system")
+from PIL import Image
+
+import matplotlib as mpl
+
+import torch.multiprocessing
+import torchvision.transforms as T
+
+import plotly.graph_objects as go
+import plotly.express as px
+import numpy as np
+from plotly.subplots import make_subplots
+
+import os   
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
+
 colors = ("red", "palegreen", "green", "steelblue", "blue", "yellow", "lightgrey")
-class_names = (
-    "Buildings",
-    "Cultivation",
-    "Natural green",
-    "Wetland",
-    "Water",
-    "Infrastructure",
-    "Background",
-)
-bounds = list(np.arange(len(class_names) + 1) + 1)
+class_names = ('Buildings', 'Cultivation', 'Natural green', 'Wetland', 'Water', 'Infrastructure', 'Background')
+mapping_class = {
+    "Buildings": 1,
+    "Cultivation": 2,
+    "Natural green": 3,
+    "Wetland": 4,
+    "Water": 5,
+    "Infrastructure": 6,
+    "Background": 0,
+}
+
+score_attribution = {
+    "Buildings" : 0.,
+    "Cultivation": 0.3,
+    "Natural green": 1.,
+    "Wetland": 0.9,
+    "Water": 0.9,
+    "Infrastructure": 0.,
+    "Background": 0.
+}
+bounds = list(np.arange(len(mapping_class.keys()) + 1) + 1)
 cmap = mpl.colors.ListedColormap(colors)
 norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
 
-def compute_biodiv_score(image):
+def compute_biodiv_score(class_image):
     """Compute the biodiversity score of an image
 
     Args:
@@ -42,49 +67,204 @@ def compute_biodiv_score(image):
     Returns:
         biodiversity_score: the biodiversity score associated to the landscape of the image
     """
-    pix = np.array(image.getdata())
-    return np.mean(pix)
-
-import cv2
-def create_video(array_images, output_path="output.mp4"):
-    height, width, layers = array_images[0].shape
-    size = (width,height)
+    score_matrice = class_image.copy().astype(int)
+    for key in mapping_class.keys():
+        score_matrice = np.where(score_matrice==mapping_class[key], score_attribution[key], score_matrice)
+    number_of_pixel = np.prod(list(score_matrice.shape))
+    score = np.sum(score_matrice)/number_of_pixel
+    score_details = {
+        key: np.sum(np.where(class_image == mapping_class[key], 1, 0))
+        for key in mapping_class.keys()
+        if key not in ["background"]
+    }
+    return score, score_details
+
+def plot_imgs_labels(months, imgs, imgs_label, nb_values, scores) :       
+
+    fig2 = px.imshow(np.array(imgs), animation_frame=0, binary_string=True)
+    fig3 = px.imshow(np.array(imgs_label), animation_frame=0, binary_string=True)
     
-    fourcc = cv2.VideoWriter_fourcc(*'VP90')
-    out = cv2.VideoWriter('output.mp4', fourcc, 2, size)
- 
-    for i in range(len(array_images)):
-        out.write(array_images[i])
-    out.release()
-    return out
-
-
+    # Scores 
+    scatters = [
+        go.Scatter(
+            x=months[:i+1], 
+            y=scores[:i+1], 
+            mode="lines+markers+text",  
+            marker_color="black",  
+            text = [f"{score:.4f}" for score in scores[:i+1]], 
+            textposition="top center"
+        ) for i in range(len(scores))
+    ]
+    # scatters = [go.Scatter(y=scores[:i], mode="lines+markers+text", marker_color="black", text = scores[:i], textposition="top center") for i in range(len(scores))]
+
+
+    # Scores 
+    fig = make_subplots(
+        rows=1, cols=4,
+        specs=[[{"type": "image"},{"type": "image"}, {"type": "pie"}, {"type": "scatter"}]],
+        subplot_titles=("Localisation visualization", "Labeled visualisation", "Segments repartition", "Biodiversity scores")
+    )
+
+    fig.add_trace(fig2["frames"][0]["data"][0], row=1, col=1)
+    fig.add_trace(fig3["frames"][0]["data"][0], row=1, col=2)
+
+    fig.add_trace(go.Pie(labels = class_names,
+                values = [nb_values[0][key] for key in mapping_class.keys()],
+                marker_colors = colors, 
+                name="Segment repartition",
+                textposition='inside',
+                texttemplate = "%{percent:.0%}",
+                textfont_size=14
+                ),
+                row=1, col=3)
+
+
+    fig.add_trace(scatters[0], row=1, col=4)
+    fig.update_traces(selector=dict(type='scatter'))
+
+    number_frames = len(imgs)
+    frames = [dict(
+                name = k,
+                data = [ fig2["frames"][k]["data"][0],
+                        fig3["frames"][k]["data"][0],
+                        go.Pie(labels = class_names,
+                                values = [nb_values[k][key] for key in mapping_class.keys()],
+                                marker_colors = colors, 
+                                name="Segment repartition",
+                                textposition='inside',
+                                texttemplate = "%{percent:.0%}",
+                                textfont_size=14
+                                ),
+                        scatters[k]
+                        ],
+                traces=[0, 1,2,3] # the elements of the list [0,1,2] give info on the traces in fig.data
+                                        # that are updated by the above three go.Scatter instances
+                ) for k in range(number_frames)]
+
+    updatemenus = [dict(type='buttons',
+                        buttons=[dict(label='Play',
+                                    method='animate',
+                                    args=[[f'{k}' for k in range(number_frames)], 
+                                            dict(frame=dict(duration=500, redraw=False), 
+                                                transition=dict(duration=0),
+                                                easing='linear',
+                                                fromcurrent=True,
+                                                mode='immediate'
+                                                                    )])],
+                        direction= 'left', 
+                        pad=dict(r= 10, t=85), 
+                        showactive =True, x= 0.1, y= 0.13, xanchor= 'right', yanchor= 'top')
+                ]
+
+    sliders = [{'yanchor': 'top',
+                'xanchor': 'left', 
+                'currentvalue': {'font': {'size': 16}, 'prefix': 'Frame: ', 'visible': False, 'xanchor': 'right'},
+                'transition': {'duration': 500.0, 'easing': 'linear'},
+                'pad': {'b': 10, 't': 50}, 
+                'len': 0.9, 'x': 0.1, 'y': 0, 
+                'steps': [{'args': [[k], {'frame': {'duration': 500.0, 'easing': 'linear', 'redraw': False},
+                                        'transition': {'duration': 0, 'easing': 'linear'}}], 
+                        'label': months[k], 'method': 'animate'} for k in range(number_frames)       
+                        ]}]
+
+
+    fig.update(frames=frames)
+
+    for i,fr in enumerate(fig["frames"]):
+        fr.update(
+            layout={
+                "xaxis": {
+                            "range": [0,imgs[0].shape[1]+i/100000]
+                        },
+                "yaxis": {
+                            "range": [imgs[0].shape[0]+i/100000,0]
+                        },
+            })
+        
+        fr.update(layout_title_text= months[i])
+
+
+    fig.update(layout_title_text= months[0])
+    fig.update(
+            layout={
+                "xaxis": {
+                            "range": [0,imgs[0].shape[1]+i/100000],
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at x=0
+                            'visible': False,  # numbers below
+                        },
+
+                "yaxis": {
+                            "range": [imgs[0].shape[0]+i/100000,0],
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at y=0
+                            'visible': False,},
+                            
+                "xaxis2": {
+                            "range": [0,imgs[0].shape[1]+i/100000],
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at x=0
+                            'visible': False,  # numbers below
+                        },
+
+                "yaxis2": {
+                            "range": [imgs[0].shape[0]+i/100000,0],
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at y=0
+                            'visible': False,},
+                            
+                
+                "xaxis3": {
+                            "range": [0,len(scores)+1],
+                            'autorange': False, # thin lines in the background
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at y=0
+                            'visible': False    
+                        },
+                
+                "yaxis3": {
+                            "range": [0,1.5],
+                            'autorange': False,
+                            'showgrid': False, # thin lines in the background
+                            'zeroline': False, # thick line at y=0
+                            'visible': False # thin lines in the background
+                         }   
+            }
+            )
+
+
+    fig.update_layout(updatemenus=updatemenus,
+                    sliders=sliders,
+                    legend=dict(
+                        yanchor= 'top',
+                        xanchor= 'left', 
+                        orientation="h")
+    )
+
+
+
+    fig.update_layout(margin=dict(b=0, r=0))
+    return fig
+
+
+
+
+def transform_to_pil(output, alpha=0.3):
+    # Transform img with torch
+    img = torch.moveaxis(prep_for_plot(output['img']),-1,0)
+    img=T.ToPILImage()(img)
 
-def transform_to_pil(outputs, alpha=0.3):
-    """Turn an ouput into a PIL
+    cmaplist = np.array([np.array(cmap(i)) for i in range(cmap.N)])
+    labels = np.array(output['linear_preds'])-1
+    label = T.ToPILImage()((cmaplist[labels]*255).astype(np.uint8))
 
-    Args:
-        outputs (_type_): _description_
-        alpha (float, optional): _description_. Defaults to 0.3.
-
-    Returns:
-        _type_: _description_
-    """
-    
-    # Transform img with torch
-    img = torch.moveaxis(prep_for_plot(outputs["img"][0]), -1, 0)
-    img = T.ToPILImage()(img)
-    # Transform label by saving it then open it
-    label = outputs["linear_preds"][0].numpy()
-    # image_label = Image.fromarray(label, mode="P")
-    plt.imsave("label.png", label, cmap=cmap)
-    image_label = Image.open("label.png")
     # Overlay labels with img wit alpha
     background = img.convert("RGBA")
-    overlay = image_label.convert("RGBA")
+    overlay = label.convert("RGBA")
+    
     labeled_img = Image.blend(background, overlay, alpha)
-    labeled_img = labeled_img.convert("RGB")
-    return img, image_label, labeled_img
+
+    return img, label, labeled_img
 
 
 def prep_for_plot(img, rescale=True, resize=None):

biomap/utils_gee.py

@@ -3,12 +3,23 @@ import requests
 import ee
 import numpy as np
 import matplotlib.pyplot as plt
+import os
+from pathlib import Path
+import logging
 
 #Initialize
 service_account = 'cvimg-355@cvimg-377115.iam.gserviceaccount.com'
-credentials = ee.ServiceAccountCredentials(service_account, 'biomap/.private-key.json')
+credentials = ee.ServiceAccountCredentials(service_account, os.path.join(os.path.dirname(__file__), '.private-key.json'))
 ee.Initialize(credentials)
 
+def get_image(location, d1, d2):
+    logging.info(f"getting image for {d1} to {d2} at location {location}")
+    img = extract_img(location, d1, d2)
+    img_test = transform_ee_img(
+        img, max=0.3
+    )
+    return img_test
+
 #delete clouds
 def maskS2clouds(image):
         qa = image.select('QA60');
@@ -150,8 +161,6 @@ def transform_ee_img(img, min = 0, max=0.3):
     Returns:
         img_test: a PIL image 
     """
-    img_test=img
-    img_test=np.minimum(img_test*255/max,np.ones(img.shape)*255)
-    img_test=np.uint8((np.rint(img_test)).astype(int))
-    plt.imshow(img_test)
-    return img_test
+    img=np.minimum(img*255/max,np.ones(img.shape)*255)
+    img=np.uint8((np.rint(img)).astype(int))
+    return img

pyproject.toml

@@ -23,6 +23,8 @@ ee-extra = "0.0.15"
 gradio = "^3.27.0"
 opencv-python = "^4.7.0"
 plotly = "^5.14.1"
+geomap = "^0.2.1"
+joblib = "^1.3.1"
 
 [tool.poetry.dev-dependencies]