Merge pull request #5 from buuck/develop

app.py

@@ -9,6 +9,7 @@ import gradio as gr
 import pandas as pd
 import plotly.graph_objects as go
 import yaml
+import numpy as np
 from google.oauth2 import service_account
 
 
@@ -25,7 +26,6 @@ ROI_RADIUS = 20000
 GEE_SERVICE_ACCOUNT = (
     "climatebase-july-2023@ee-geospatialml-aquarry.iam.gserviceaccount.com"
 )
-GEE_SERVICE_ACCOUNT_CREDENTIALS_FILE = "ee_service_account.json"
 INDICES_FILE = "indices.yaml"
 START_YEAR = 2015
 END_YEAR = 2022
@@ -202,13 +202,13 @@ def set_up_duckdb():
     return con
 
 
-def authenticate_gee(gee_service_account, gee_service_account_credentials_file):
+def authenticate_ee(ee_service_account):
     """
     Huggingface Spaces does not support secret files, therefore authenticate with an environment variable containing the JSON.
     """
-    logging.info("authenticate_gee")
+    logging.info("authenticate_ee")
     credentials = ee.ServiceAccountCredentials(
-        gee_service_account, key_data=os.environ["ee_service_account"]
+        ee_service_account, key_data=os.environ["ee_service_account"]
     )
     ee.Initialize(credentials)
 
@@ -240,51 +240,93 @@ def create_dataframe(years, project_name):
         dfs.append(df)
     return pd.concat(dfs)
 
+# h/t: https://community.plotly.com/t/dynamic-zoom-for-mapbox/32658/12
+def get_plotting_zoom_level_and_center_coordinates_from_lonlat_tuples(longitudes=None, latitudes=None):
+    """Function documentation:\n
+    Basic framework adopted from Krichardson under the following thread:
+    https://community.plotly.com/t/dynamic-zoom-for-mapbox/32658/7
 
-# def preview_table():
-#     con.sql("FROM bioindicator;").show()
+    # NOTE:
+    # THIS IS A TEMPORARY SOLUTION UNTIL THE DASH TEAM IMPLEMENTS DYNAMIC ZOOM
+    # in their plotly-functions associated with mapbox, such as go.Densitymapbox() etc.
 
-# if __name__ == '__main__':
-
-
-# Map = geemap.Map()
-
-
-# # Create a cloud-free composite with custom parameters for cloud score threshold and percentile.
-# composite_cloudfree = ee.Algorithms.Landsat.simpleComposite(**{
-#   'collection': collection,
-#   'percentile': 75,
-#   'cloudScoreRange': 5
-# })
-
-# Map.addLayer(composite_cloudfree, {'bands': ['B4', 'B3', 'B2'], 'max': 128}, 'Custom TOA composite')
-# Map.centerObject(roi, 14)
-
-
-# ig = IndexGenerator(centroid=LOCATION, year=2015, indices_file=INDICES_FILE, project_name='Test Project', map=Map)
-# dataset = ig.generate_index(indices['Air'])
-
-# minMax = dataset.clip(roi).reduceRegion(
-#   geometry = roi,
-#   reducer = ee.Reducer.minMax(),
-#   scale= 3000,
-#   maxPixels= 10e3,
-# )
+    Returns the appropriate zoom-level for these plotly-mapbox-graphics along with
+    the center coordinate tuple of all provided coordinate tuples.
+    """
 
+    # Check whether both latitudes and longitudes have been passed,
+    # or if the list lenghts don't match
+    if ((latitudes is None or longitudes is None)
+            or (len(latitudes) != len(longitudes))):
+        # Otherwise, return the default values of 0 zoom and the coordinate origin as center point
+        return 0, (0, 0)
+
+    # Get the boundary-box 
+    b_box = {} 
+    b_box['height'] = latitudes.max()-latitudes.min()
+    b_box['width'] = longitudes.max()-longitudes.min()
+    b_box['center']= (np.mean(longitudes), np.mean(latitudes))
+
+    # get the area of the bounding box in order to calculate a zoom-level
+    area = b_box['height'] * b_box['width']
+
+    # * 1D-linear interpolation with numpy:
+    # - Pass the area as the only x-value and not as a list, in order to return a scalar as well
+    # - The x-points "xp" should be in parts in comparable order of magnitude of the given area
+    # - The zpom-levels are adapted to the areas, i.e. start with the smallest area possible of 0
+    # which leads to the highest possible zoom value 20, and so forth decreasing with increasing areas
+    # as these variables are antiproportional
+    zoom = np.interp(x=area,
+                     xp=[0, 5**-10, 4**-10, 3**-10, 2**-10, 1**-10, 1**-5],
+                     fp=[20, 15,    14,     13,     12,     7,      5])
+
+    # Finally, return the zoom level and the associated boundary-box center coordinates
+    return zoom, b_box['center']
+
+def show_project_map(project_name):
+    prepared_statement = \
+        con.execute("SELECT geometry FROM project WHERE name = ? LIMIT 1",
+                    [project_name]).fetchall()
+    features = \
+        json.loads(prepared_statement[0][0].replace("\'", "\""))['features']
+    geometry = features[0]['geometry']
+    longitudes = np.array(geometry["coordinates"])[0, :, 0]
+    latitudes = np.array(geometry["coordinates"])[0, :, 1]
+    zoom, bbox_center = get_plotting_zoom_level_and_center_coordinates_from_lonlat_tuples(longitudes, latitudes)
+    fig = go.Figure(go.Scattermapbox(
+        mode = "markers",
+        lon = [bbox_center[0]], lat = [bbox_center[1]],
+        marker = {'size': 20, 'color': ["cyan"]}))
+
+    fig.update_layout(
+        mapbox = {
+            'style': "stamen-terrain",
+            'center': { 'lon': bbox_center[0], 'lat': bbox_center[1]},
+            'zoom': zoom, 'layers': [{
+                'source': {
+                    'type': "FeatureCollection",
+                    'features': [{
+                        'type': "Feature",
+                        'geometry': geometry
+                    }]
+                },
+                'type': "fill", 'below': "traces", 'color': "royalblue"}]},
+        margin = {'l':0, 'r':0, 'b':0, 't':0})
+    
+    return fig
 
 # minMax.getInfo()
 def calculate_biodiversity_score(start_year, end_year, project_name):
     years = []
     for year in range(start_year, end_year):
-        row_exists = con.sql(
-            f"SELECT COUNT(1) FROM bioindicator WHERE (year = {year} AND project_name = '{project_name}')"
-        ).fetchall()[0][0]
+        row_exists = \
+            con.execute("SELECT COUNT(1) FROM bioindicator WHERE (year = ? AND project_name = ?)",
+                        [year, project_name]).fetchall()[0][0]
         if not row_exists:
             years.append(year)
 
     if len(years) > 0:
         df = create_dataframe(years, project_name)
-        # con.sql('FROM df LIMIT 5').show()
 
         # Write score table to `_temptable`
         con.sql(
@@ -296,84 +338,54 @@ def calculate_biodiversity_score(start_year, end_year, project_name):
             """
             USE climatebase;
             CREATE TABLE IF NOT EXISTS bioindicator (year BIGINT, project_name VARCHAR(255), value DOUBLE, area DOUBLE, score DOUBLE, CONSTRAINT unique_year_project_name UNIQUE (year, project_name));
+        """)
+        # UPSERT project record
+        con.sql(
+            """
+            INSERT INTO bioindicator FROM _temptable
+            ON CONFLICT (year, project_name) DO UPDATE SET value = excluded.value;
         """
         )
-
-    return con.sql(
-        f"SELECT * FROM bioindicator WHERE (year > {start_year} AND year <= {end_year} AND project_name = '{project_name}')"
-    ).df()
-
-
-def view_all():
-    logging.info("view_all")
-    return con.sql(f"SELECT * FROM bioindicator").df()
-
-
-def push_to_md():
-    # UPSERT project record
-    con.sql(
-        """
-        INSERT INTO bioindicator FROM _temptable
-        ON CONFLICT (year, project_name) DO UPDATE SET value = excluded.value;
-    """
-    )
-    logging.info("upsert records into motherduck")
-
+        logging.info("upsert records into motherduck")
+    scores = \
+        con.execute("SELECT * FROM bioindicator WHERE (year >= ? AND year <= ? AND project_name = ?)",
+                    [start_year, end_year, project_name]).df()
+    return scores
 
 def motherduck_list_projects(author_id):
-    return con.sql(
-        f"""
-        SELECT DISTINCT name FROM project WHERE authorId = '{author_id}'
-    """
-    ).df()
+    return \
+        con.execute("SELECT DISTINCT name FROM project WHERE authorId = ? AND geometry != 'null'", [author_id]).df()
 
 
 with gr.Blocks() as demo:
     # Environment setup
-    authenticate_gee(GEE_SERVICE_ACCOUNT, GEE_SERVICE_ACCOUNT_CREDENTIALS_FILE)
+    authenticate_ee(GEE_SERVICE_ACCOUNT)
     con = set_up_duckdb()
-
-    # Create circle buffer over point
-    roi = ee.Geometry.Point(*LOCATION).buffer(ROI_RADIUS)
-
-    # # Load a raw Landsat ImageCollection for a single year.
-    # start_date = str(datetime.date(YEAR, 1, 1))
-    # end_date = str(datetime.date(YEAR, 12, 31))
-    # collection = (
-    #     ee.ImageCollection('LANDSAT/LC08/C02/T1')
-    #     .filterDate(start_date, end_date)
-    #     .filterBounds(roi)
-    # )
-
-    # indices = load_indices(INDICES_FILE)
-    # push_to_md(START_YEAR, END_YEAR, 'Test Project')
     with gr.Column():
-        # map = gr.Plot().style()
+        m1 = gr.Plot()
         with gr.Row():
+            project_name = gr.Dropdown([], label="Project", value="Select project")
             start_year = gr.Number(value=2017, label="Start Year", precision=0)
             end_year = gr.Number(value=2022, label="End Year", precision=0)
-            # project_name = gr.Textbox(label="Project Name")
-            project_name = gr.Dropdown([], label="Project", value="Select project")
-        # boroughs = gr.CheckboxGroup(choices=["Queens", "Brooklyn", "Manhattan", "Bronx", "Staten Island"], value=["Queens", "Brooklyn"], label="Select Methodology:")
-        # btn = gr.Button(value="Update Filter")
         with gr.Row():
+            view_btn = gr.Button(value="Show project map")
             calc_btn = gr.Button(value="Calculate!")
-            view_btn = gr.Button(value="View all")
-            save_btn = gr.Button(value="Save")
+            # save_btn = gr.Button(value="Save")
         results_df = gr.Dataframe(
             headers=["Year", "Project Name", "Score"],
             datatype=["number", "str", "number"],
             label="Biodiversity scores by year",
         )
-    # demo.load(filter_map, [min_price, max_price, boroughs], map)
-    # btn.click(filter_map, [min_price, max_price, boroughs], map)
     calc_btn.click(
         calculate_biodiversity_score,
         inputs=[start_year, end_year, project_name],
         outputs=results_df,
     )
-    view_btn.click(view_all, outputs=results_df)
-    save_btn.click(push_to_md)
+    view_btn.click(
+        fn=show_project_map,
+        inputs=[project_name],
+        outputs=[m1],
+        )
 
     def update_project_dropdown_list(url_params):
         username = url_params.get("username", "default")
@@ -398,5 +410,4 @@ with gr.Blocks() as demo:
         queue=False,
     )
 
-
-demo.launch()
+demo.launch()