first commit

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+
+.streamlit/
+secrets.toml
+*.pdf
+*.toml
+dfr4/
+shapefiles/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ammar Nasr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,8 +1,8 @@
 ---
 title: Field Monitoring
-emoji: ⚡
-colorFrom: blue
-colorTo: gray
+emoji: 🧑‍🌾 🌴
+colorFrom: purple
+colorTo: red
 sdk: streamlit
 sdk_version: 1.33.0
 app_file: app.py
@@ -10,4 +10,79 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# agriAI
+
+Welcome to agriAI, an advanced field monitoring application designed to help farmers and agricultural researchers monitor and manage their fields more effectively. This project utilizes cutting-edge technologies to provide real-time insights into crop health, soil conditions, and environmental factors.
+
+## Features
+
+- **Real-Time Monitoring**: Track field conditions in real time to make informed decisions quickly.
+- **Data Analysis**: Leverage data collected from various sensors to analyze soil health and crop conditions.
+- **User Authentication**: Secure login and signup functionalities to ensure data privacy.
+- **Field Management**: Tools to add, edit, and monitor different fields.
+- **Responsive Design**: Accessible on various devices, ensuring functionality across platforms.
+
+## Getting Started
+
+These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
+
+### Prerequisites
+
+What you need to install the software:
+
+- Python 3.8+
+- pip
+- Virtualenv (optional, but recommended)
+
+### Installation
+
+Step-by-step guide to setting up a development environment:
+
+1. **Clone the repository**
+
+   ```bash
+   git clone https://github.com/ammarnasr/agriAI.git
+   cd agriAI
+   ```
+
+2. **Set up a Python virtual environment (Optional)**
+
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+   ```
+
+3. **Install the requirements**
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Run the application**
+
+   ```bash
+   streamlit run main.py
+   ```
+
+## Usage
+
+After installation, launch the application, and navigate to `http://localhost:8501` in your web browser to see the app in action.
+
+To log in or sign up, click the respective buttons on the main page. After authentication, use the sidebar to navigate between different functionalities like adding fields, editing them, or monitoring existing ones.
+
+## Contributing
+
+We welcome contributions to agriAI! If you have suggestions for improvements or bug fixes, please feel free to fork the repository and submit a pull request.
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b feature/fooBar`).
+3. Commit your changes (`git commit -am 'Add some fooBar'`).
+4. Push to the branch (`git push origin feature/fooBar`).
+5. Create a new Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+

app.py

@@ -0,0 +1,52 @@
+# main.py
+import streamlit as st
+import authentication 
+import streamlit as st
+from pag import add_field, edit, monitor
+ 
+# from pages import add_field, edit, moniter
+def authenticate_user():
+    st.title("Welcome to :orange[Field Monitoring App]")
+    st.markdown("""
+            <style>
+            .stSelectbox > div > div {cursor: pointer;}
+            </style>
+            """, unsafe_allow_html=True)
+    if not st.session_state.authenticated:
+        choice = st.selectbox("Interested? Sign up or log in if you have an account",options=["Home","Login","SignUp"])
+
+        if choice == "Home":
+          st.write("App Description")
+
+        elif choice == "Login":
+            authentication.login()
+        elif choice == "SignUp":
+            authentication.signup()
+
+    return False
+
+def main():
+    
+    if "authenticated" not in st.session_state:
+        st.session_state.authenticated = False
+
+    if st.session_state.authenticated:
+        st.sidebar.title(":blue[Field Management Options]")
+        options = st.sidebar.radio("Choose an option:", 
+                                   ("Add Field", "Edit Fields/Add Field Info", "Monitor"))
+        
+        if options == "Add Field":
+            st.title("Welcome to :orange[Field Monitoring App]")
+
+            add_field.add_drawing()
+            
+        elif options == "Edit Fields/Add Field Info":
+            st.title("Welcome to :orange[Field Monitoring App]")
+            edit.edit_fields()
+        elif options == "Monitor":
+            st.title("Welcome to :orange[Field Monitoring App]")
+            monitor.monitor_fields()
+    else:
+        authenticate_user()
+if __name__ == "__main__":
+    main()

authentication.py

@@ -0,0 +1,157 @@
+# authentication.py
+import streamlit as st
+import pandas as pd
+import sqlite3
+import time
+import re
+import hashlib
+import hmac
+
+
+def greeting(msg="Welcome"):
+    current_user = st.session_state['current_user']
+    st.write(f"{msg} {current_user}!")
+    return current_user
+
+
+def check_password():
+    """Returns `True` if the user had a correct password."""
+
+    def login_form():
+        """Form with widgets to collect user information"""
+        st.info("Demo credentials: dfr4 / 12345")
+        with st.form("Credentials"):
+            st.text_input("Username", key="username")
+            st.text_input("Password", type="password", key="password")
+            st.form_submit_button("Log in", on_click=password_entered)
+
+    def password_entered():
+        """Checks whether a password entered by the user is correct."""
+        st.session_state['current_user'] = st.session_state["username"]
+        if st.session_state["username"] in st.secrets[
+            "passwords" # here is where you should connect to the database
+        ] and hmac.compare_digest(
+            st.session_state["password"],
+            st.secrets.passwords[st.session_state["username"]],
+        ):
+            st.session_state["password_correct"] = True
+            del st.session_state["password"]  # Don't store the username or password.
+            del st.session_state["username"]
+        else:
+            st.session_state["password_correct"] = False
+
+    # Return True if the username + password is validated.
+    if st.session_state.get("password_correct", False):
+        return True
+
+    # Show inputs for username + password.
+    login_form()
+    if "password_correct" in st.session_state:
+        st.error("😕 User not known or password incorrect")
+    return False
+
+
+# Security
+def make_hashes(password):
+    return hashlib.sha256(str.encode(password)).hexdigest()
+
+def check_hashes(password, hashed_text):
+    if make_hashes(password) == hashed_text:
+        return hashed_text
+    return False
+
+# DB Management
+conn = sqlite3.connect('users.db', check_same_thread=False)
+c = conn.cursor()
+
+# DB Functions
+def create_usertable():
+    c.execute('''CREATE TABLE IF NOT EXISTS userstable (
+                 username TEXT UNIQUE, 
+                 email TEXT UNIQUE, 
+                 password TEXT)''')
+    conn.commit()
+
+def add_userdata(username, email, password):
+    c.execute('INSERT INTO userstable(username, email, password) VALUES (?, ?, ?)', (username, email, password))
+    conn.commit()
+
+def login_user(username, password):
+    c.execute('SELECT * FROM userstable WHERE username =? AND password = ?', (username, password))
+    data = c.fetchall()
+    return data
+
+def view_all_users():
+    c.execute('SELECT * FROM userstable')
+    data = c.fetchall()
+    return data
+
+def username_exists(username):
+    c.execute('SELECT * FROM userstable WHERE username = ?', (username,))
+    return c.fetchone() is not None
+
+def email_exists(email):
+    # c.execute('SELECT * FROM userstable WHERE email = ?', (email,))
+    # return c.fetchone() is not None
+    return False
+
+# Validators
+def is_valid_email(email):
+    regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    return re.fullmatch(regex, email)
+
+def is_strong_password(password):
+    regex = r'^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$'
+    return re.fullmatch(regex, password)
+
+# Signup Function
+def signup():
+    st.subheader("Create New Account")
+    new_user = st.text_input("Username")
+    Email_address = st.text_input("Email")
+    new_password = st.text_input("Password", type='password')
+    confirm_password = st.text_input("Confirm Password", type='password')
+
+    create = st.button("Signup")
+    if create:
+        if username_exists(new_user):
+            st.error("Username is already taken")
+        elif email_exists(Email_address):
+            st.error("Email is already registered")
+        elif not is_valid_email(Email_address):
+            st.error("Invalid email address")
+        elif not is_strong_password(new_password):
+            st.error("Password too weak. Must be 8 characters long and include numbers and letters.")
+        elif new_password != confirm_password:
+            st.error("Passwords do not match")
+        else:
+            add_userdata(new_user, Email_address, make_hashes(new_password))
+            st.success("You have successfully created a valid Account")
+            st.info("Go to Login Menu to login")
+            # Clearing the form
+            for field in ['new_user', 'Email_address', 'new_password', 'confirm_password']:
+                if field in st.session_state:
+                    st.session_state[field] = ''
+
+# Login Function
+def login():
+    username = st.text_input("User Name", key="username")
+    password = st.text_input("Password", type='password', key='password')
+
+    if st.button("Login"):
+        hashed_pswd = make_hashes(password)
+
+        result = login_user(username, hashed_pswd)
+        if result:
+            st.success("Logged In as {}".format(username))
+            st.session_state.authenticated = True
+            st.session_state['current_user'] = username
+            # Clear sensitive states
+            del st.session_state["password"]
+            del st.session_state["username"]
+            st.rerun()
+        else:
+            st.warning("Incorrect Username/Password")
+
+# Call create_usertable to ensure the table is created/updated when the script runs
+create_usertable()

data.geojson

@@ -0,0 +1,22 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {},
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [32.584179, 15.217575],
+            [32.726973, 13.546143],
+            [33.957199, 13.973163],
+            [34.286724, 14.739791],
+            [33.69358, 15.620197],
+            [32.584179, 15.217575]
+          ]
+        ]
+      }
+    }
+  ]
+}

fields.geojson

@@ -0,0 +1,7 @@
+{
+"type": "FeatureCollection",
+"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:OGC:1.3:CRS84" } },
+"features": [
+{ "type": "Feature", "properties": { "name": "tri", "area": 0.0, "crop": "", "sowing_date": "2024-03-16", "notes": "" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 14.70916, 33.008871 ], [ 14.078534, 32.687414 ], [ 14.078534, 33.948826 ], [ 14.70916, 33.008871 ] ] ] } }
+]
+}

main.py

@@ -0,0 +1,52 @@
+# main.py
+import streamlit as st
+import authentication 
+import streamlit as st
+from pag import add_field, edit, moniter
+ 
+# from pages import add_field, edit, moniter
+def authenticate_user():
+    st.title("Welcome to :orange[Field Monitoring App]")
+    st.markdown("""
+            <style>
+            .stSelectbox > div > div {cursor: pointer;}
+            </style>
+            """, unsafe_allow_html=True)
+    if not st.session_state.authenticated:
+        choice = st.selectbox("Interested? Sign up or log in if you have an account",options=["Home","Login","SignUp"])
+
+        if choice == "Home":
+          st.write("App Description")
+
+        elif choice == "Login":
+            authentication.login()
+        elif choice == "SignUp":
+            authentication.signup()
+
+    return False
+
+def main():
+    
+    if "authenticated" not in st.session_state:
+        st.session_state.authenticated = False
+
+    if st.session_state.authenticated:
+        st.sidebar.title("Navigation")
+        options = st.sidebar.radio("Choose an option:", 
+                                   ("Add Field", "Edit", "Monitor"))
+        
+        if options == "Add Field":
+            st.title("Welcome to :orange[Field Monitoring App]")
+
+            add_field.add_drawing()
+            
+        elif options == "Edit":
+            st.title("Welcome to :orange[Field Monitoring App]")
+            edit.edit_fields()
+        elif options == "Monitor":
+            st.title("Welcome to :orange[Field Monitoring App]")
+            moniter.monitor_fields()
+    else:
+        authenticate_user()
+if __name__ == "__main__":
+    main()

pag/add_field.py

@@ -0,0 +1,194 @@
+import utils
+import os
+import folium
+import pandas as pd
+import streamlit as st
+import geopandas as gpd
+from folium.plugins import Draw
+from shapely.geometry import Polygon
+from streamlit_folium import st_folium
+from authentication import greeting, check_password
+import shapely.ops as ops
+from functools import partial
+import pyproj
+
+def check_authentication():
+    if not check_password():
+        st.stop()
+
+
+
+
+
+def display_existing_fields(current_user):
+    with st.expander("Existing Fields", expanded=False):
+        if os.path.exists(f"fields_{current_user}.parquet"):
+            gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+            st.write(gdf)
+            mm = gdf.explore()
+            st_folium(mm)
+        else:
+            st.info("No Fields Added Yet!")
+
+def add_existing_fields_to_map(m, current_user):
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        fg = folium.FeatureGroup(name="Existing Fields", control=True).add_to(m)
+        gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+        for i, row in gdf.iterrows():
+            edges = row['geometry'].exterior.coords.xy
+            edges = [[i[1], i[0]] for i in zip(*edges)]
+            folium.Polygon(edges, color='blue', fill=True, fill_color='blue', fill_opacity=0.6).add_to(fg)
+    return m
+
+def get_center_of_existing_fields(current_user):
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+        edges = gdf['geometry'][0].exterior.coords.xy
+        edges = [[i[1], i[0]] for i in zip(*edges)]
+        edges_center = [sum([i[0] for i in edges]) / len(edges), sum([i[1] for i in edges]) / len(edges)]
+
+        return edges_center
+    return [15.572363674301132, 32.69167103104079]
+
+def display_map_and_drawing_controls(m, center_start):
+    zoom_start = 13
+    if st.session_state['active_drawing'] is None:
+        st.info("IMPORTANT: Click on the drawing to confirm the drawn field", icon="🚨")
+        sat_basemap = utils.basemaps['Google Satellite']
+        sat_basemap.add_to(m)
+        folium.LayerControl().add_to(m)
+        output = st_folium(m, center=center_start, zoom=zoom_start, key="new", width=800)
+        active_drawing = output['last_active_drawing']
+        st.session_state['active_drawing'] = active_drawing
+        return False
+    else:
+        st.info("Drawing Captured! Click on the button below to Clear Drawing and Draw Again")
+        active_drawing = st.session_state['active_drawing']
+        new_map = folium.Map(location=center_start, zoom_start=8)
+        edges = [[i[1], i[0]] for i in active_drawing['geometry']['coordinates'][0]]
+        edges_center = [sum([i[0] for i in edges]) / len(edges), sum([i[1] for i in edges]) / len(edges)]
+        folium.Polygon(edges, color='green', fill=True, fill_color='green', fill_opacity=0.6, name="New Field").add_to(new_map)
+        sat_basemap = utils.basemaps['Google Satellite']
+        sat_basemap.add_to(new_map)
+        folium.LayerControl().add_to(new_map)
+        st_folium(new_map, center=edges_center, zoom=zoom_start, key="drawn", width=800)
+        return True
+
+def handle_user_actions(active_drawing, current_user, intersects, within_area):
+    draw_again_col, add_field_info_col = st.columns([1, 1])
+    with draw_again_col:
+        draw_again = st.button("Draw Again", key="draw_again", help="Click to Clear Drawing and Draw Again",
+                               type="primary", use_container_width=True, disabled=st.session_state['active_drawing'] is None)
+        if draw_again:
+            st.session_state['active_drawing'] = None
+            st.rerun()
+    with add_field_info_col:
+        if st.session_state['active_drawing'] is None:
+            st.info("Drawing not captured yet!")
+        else:
+            field_name = st.text_input("Field Name*", help="Enter a distinct name for the field", key="field_name")
+            if field_name == "":
+                st.warning("Field Name cannot be empty!")
+            if os.path.exists(f"fields_{current_user}.parquet"):
+                gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+                if field_name in gdf['name'].tolist():
+                    st.warning("Field Name already exists. Please enter a different name!")
+            submit = st.button("Submit", key="submit", help="Click to Submit Field Information", type="primary",
+                               use_container_width=True,disabled=(st.session_state['active_drawing'] is None or field_name == "") or intersects or not within_area)
+            if submit:
+                save_field_information(active_drawing, field_name, current_user)
+                st.success("Field Information Submitted Successfully!")
+                st.session_state['active_drawing'] = None
+                st.rerun()
+
+def save_field_information(active_drawing, field_name, current_user):
+    edges = [[i[0], i[1]] for i in active_drawing['geometry']['coordinates'][0]]
+    geom = Polygon(edges)
+    field_dict = {
+        "name": field_name,
+        "geometry": geom
+    }
+    gdf = gpd.GeoDataFrame([field_dict], geometry='geometry')
+    gdf.crs = "EPSG:4326"
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        old_gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+        gdf = gpd.GeoDataFrame(pd.concat([old_gdf, gdf], ignore_index=True), crs="EPSG:4326")
+    gdf.to_parquet(f"fields_{current_user}.parquet")
+
+def initialize_active_drawing_state():
+    if 'active_drawing' not in st.session_state:
+        st.session_state['active_drawing'] = None
+    if 'current_user' not in st.session_state:
+        st.session_state['current_user'] = None
+    
+
+
+def check_intersection_with_existing_fields(active_drawing, current_user):
+    if active_drawing is None:
+        return False
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+        edges = [[i[0], i[1]] for i in active_drawing['geometry']['coordinates'][0]]
+        geom = Polygon(edges)
+        geom = gpd.GeoSeries([geom]*len(gdf), crs="EPSG:4326")
+        geom1 = geom.to_crs(gdf.crs)
+        geom2 = gdf.geometry.to_crs(gdf.crs)
+        if geom1.overlaps(geom2).any():
+            st.warning("Field intersects with existing fields. Please draw again!")
+            with st.expander("Intersecting Fields", expanded=False):
+                m = geom1.explore(name= "New Field", color="red")
+                m = gdf.explore(m=m, name="Existing Fields", color="blue")
+                st_folium(m)
+            return True
+    return False
+
+
+
+def check_polygon_area_within_range(active_drawing, min_area_km2=1, max_area_km2=10):
+    if active_drawing is None:
+        return
+    edges = [[i[0], i[1]] for i in active_drawing['geometry']['coordinates'][0]]
+    geom = Polygon(edges)
+    geom_area = ops.transform(
+    partial(
+        pyproj.transform,
+        pyproj.Proj(init='EPSG:4326'),
+        pyproj.Proj(proj='aea',lat_1=geom.bounds[1], lat_2=geom.bounds[3]))
+        , geom)
+    geom_area = geom_area.area / 10**6
+    if geom_area < min_area_km2:
+        st.warning(f"Field area is less than {min_area_km2} km2. Please draw again!")
+        return False
+    if geom_area > max_area_km2:
+        st.warning(f"Field area is more than {max_area_km2} km2. Please draw again!")
+        return False
+    return True
+
+
+def add_drawing():
+    initialize_active_drawing_state()
+    current_user = greeting("Drag and Zoom and draw your fields on the map, make sure to name them uniquely")
+    current_user = st.session_state['current_user']
+    display_existing_fields(current_user)
+
+    center_start = get_center_of_existing_fields(current_user)
+    zoom_start = 13
+    m = folium.Map(location=center_start, zoom_start=zoom_start)
+
+    draw_options = {'polyline': False, 'polygon': True, 'rectangle': True, 'circle': False, 'marker': False, 'circlemarker': False}
+    Draw(export=True, draw_options=draw_options).add_to(m)
+    m = add_existing_fields_to_map(m, current_user)
+
+
+
+    captured = display_map_and_drawing_controls(m, center_start)
+    if captured:
+        intersects = check_intersection_with_existing_fields(st.session_state['active_drawing'], current_user)
+        within_area = check_polygon_area_within_range(st.session_state['active_drawing'])
+        handle_user_actions(st.session_state['active_drawing'], current_user, intersects, within_area)
+    
+
+if __name__ == '__main__':
+    check_authentication()
+
+    add_drawing()

pag/edit.py

@@ -0,0 +1,110 @@
+import os
+import utils
+import streamlit as st
+import geopandas as gpd
+from streamlit_folium import st_folium, folium_static
+from authentication import greeting, check_password
+import folium
+import time
+def check_authentication():
+    if not check_password():
+        st.stop()
+
+
+def add_properties(df, col_name, value, field_name):
+    if col_name not in df.columns:
+        df[col_name] = None
+    df.loc[df['name'] == field_name, col_name] = value
+    return df
+
+def select_field(gdf):
+    names = gdf['name'].tolist()
+    names.append("Select Field")
+    field_name = st.selectbox("Select Field", options=names, key="field_name_edit", help="Select the field to edit", index=len(names)-1)
+    return field_name
+
+def read_crop_type():
+    crop_type = st.text_input("Field Crop*", help="Enter the crop type", key="field_crop", value='')
+    return crop_type
+
+def read_irrigation_type():
+    irrigation_type = st.selectbox("Field Type*", options=["Rainfed", "Irrigated", ""], key="field_type", help="Select the field type", index=2)
+    return irrigation_type
+
+def read_custom_property():
+    custom_property_name = st.text_input("Custom Property Name*", help="Enter the custom property name", key="custom_property_name", value='')
+    custom_property_value = st.text_input("Custom Property Value*", help="Enter the custom property value", key="custom_property_value", value='', disabled=custom_property_name == "" or custom_property_name == "")
+    return custom_property_name, custom_property_value
+
+
+
+
+
+def edit_fields():
+    current_user = greeting("Changed your mind? Edit , Add or Delete Fields easily")
+    file_path = f"fields_{current_user}.parquet"
+    if os.path.exists(file_path):
+        gdf = gpd.read_parquet(file_path)
+    else:
+        st.info("No Fields Added Yet!")
+        return
+    st.info("Hover over the field to show the properties or check the Existing Fields List below")
+    fields_map = gdf.explore()
+    sat_basemap = utils.basemaps['Google Satellite']
+    sat_basemap.add_to(fields_map)
+    folium.LayerControl().add_to(fields_map)
+    folium_static(fields_map, height=300, width=600)
+    
+    with st.expander("Existing Fields List", expanded=False):
+        st.write(gdf)
+
+    field_name = select_field(gdf)
+    if field_name == "Select Field":
+        st.info("No Field Selected Yet!")
+    
+    else:
+        delete_edit = st.radio("Delete or Edit Field?", options=["View", "Edit", "Delete"], key="delete_edit", help="Select the operation to perform")
+        if delete_edit == "View":
+            field = gdf[gdf['name'] == field_name]
+            st.write(field)
+        elif delete_edit == "Delete":
+            delete = st.button("Delete Field", key="delete", help="Click to Delete Field", type="primary", use_container_width=True)
+            if delete:
+                if len(gdf) == 1 and (gdf['name'] == field_name).all():  # Check if this is the only field left
+                    os.remove(file_path)  # Delete the .parquet file if it's the last field
+                    st.success("All fields deleted. The data file has been removed.")
+                    time.sleep(0.3)
+                    st.rerun()
+                else:
+                    gdf = gdf[gdf['name'] != field_name]
+                    gdf.to_parquet(file_path)
+                    st.success("Field Deleted Successfully!")
+                    time.sleep(0.3)
+                    st.rerun()
+        else:
+            no_input = True
+            crop_type = read_crop_type()
+            irrigation_type = read_irrigation_type()
+            custom_property_name, custom_property_value = read_custom_property()
+            if crop_type != "" or irrigation_type != "" or custom_property_value != "":
+                no_input = False
+
+            submit = st.button("Submit", key="submitProperties", help="Click to Submit Field Information", type="primary",
+                                use_container_width=True, disabled=no_input)
+            if submit:
+                if crop_type != "":
+                    gdf = add_properties(gdf, "crop", crop_type, field_name)
+                if irrigation_type != "":
+                    gdf = add_properties(gdf, "irrigation", irrigation_type, field_name)
+                if custom_property_name != "" and custom_property_value != "":
+                    gdf = add_properties(gdf, custom_property_name, custom_property_value, field_name)
+                gdf.to_parquet(f"fields_{current_user}.parquet")
+                # st.rerun()
+                st.success("Field Information Updated Successfully!")
+                st.info("Please Select View above to see the updated field information")
+
+
+if __name__ == '__main__':
+    check_authentication()
+
+    edit_fields()

pag/moniter.py

@@ -0,0 +1,561 @@
+import os
+import utils
+import streamlit as st
+import geopandas as gpd
+from streamlit_folium import st_folium, folium_static
+from authentication import greeting, check_password
+import folium
+from senHub import SenHub
+from datetime import datetime
+from sentinelhub import  SHConfig, MimeType
+import requests
+import process
+import joblib
+from zipfile import ZipFile
+import matplotlib.pyplot as plt
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+
+def check_authentication():
+    if not check_password():
+        st.stop()
+
+
+
+config = SHConfig()
+config.instance_id       = '6c220beb-90c4-4131-b658-10cddd8d97b9'
+config.sh_client_id      = '17e7c154-7f2d-4139-b1af-cef762385079'
+config.sh_client_secret  = 'KvbQMKZB85ZWEgWuxqiWIVEvTAQEfoF9'
+
+
+def select_field(gdf):
+    names = gdf['name'].tolist()
+    names.append("Select Field")
+    field_name = st.selectbox("Select Field", options=names, key="field_name_monitor", help="Select the field to edit", index=len(names)-1)
+    return field_name
+
+
+def calculate_bbox(df, field):
+    bbox = df.loc[df['name'] == field].bounds
+    r = bbox.iloc[0]
+    return [r.minx, r.miny, r.maxx, r.maxy]
+
+def get_available_dates_for_field(df, field, year, start_date='', end_date=''):
+    bbox = calculate_bbox(df, field)
+    token = SenHub(config).token
+    headers = utils.get_bearer_token_headers(token)
+    if start_date == '' or end_date == '':
+        start_date = f'{year}-01-01'
+        end_date = f'{year}-12-31'
+    data = f'{{ "collections": [ "sentinel-2-l2a" ], "datetime": "{start_date}T00:00:00Z/{end_date}T23:59:59Z", "bbox": {bbox}, "limit": 100, "distinct": "date" }}'
+    response = requests.post('https://services.sentinel-hub.com/api/v1/catalog/search', headers=headers, data=data)
+    try:
+        features = response.json()['features']
+    except:
+        print(response.json())
+        features = []
+    return features
+
+@st.cache_data
+def get_and_cache_available_dates(_df, field, year, start_date, end_date):
+    dates = get_available_dates_for_field(_df, field, year, start_date, end_date)
+    print(f'Caching Dates for {field}')
+    return dates
+
+
+
+
+def get_cuarted_df_for_field(df, field, date, metric, clientName):
+    curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+    if curated_date_path is not None:
+        curated_df = gpd.read_file(curated_date_path)
+    else:
+        process.Download_image_in_given_date(clientName, metric, df, field, date)
+        process.mask_downladed_image(clientName, metric, df, field, date)
+        process.convert_maske_image_to_geodataframe(clientName, metric, df, field, date, df.crs)
+        curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+        curated_df = gpd.read_file(curated_date_path)
+    return curated_df
+
+
+
+
+
+
+
+
+def get_cuarted_df_for_field(df, field, date, metric, clientName):
+    curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+    if curated_date_path is not None:
+        curated_df = gpd.read_file(curated_date_path)
+    else:
+        process.Download_image_in_given_date(clientName, metric, df, field, date)
+        process.mask_downladed_image(clientName, metric, df, field, date)
+        process.convert_maske_image_to_geodataframe(clientName, metric, df, field, date, df.crs)
+        curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+        curated_df = gpd.read_file(curated_date_path)
+    return curated_df
+
+def track(metric, field_name, src_df, client_name):
+
+    dates = []
+    date = -1
+    if 'dates' not in st.session_state:
+        st.session_state['dates'] = dates
+    else:
+        dates = st.session_state['dates']
+    if 'date' not in st.session_state:
+        st.session_state['date'] = date
+    else:
+        date = st.session_state['date']
+
+    # Give the user the option to select year, start date and end date
+    # with st.expander('Select Year, Start Date and End Date'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(22, 25)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}')
+        
+    #     # Set the min, max and default values for start and end dates
+    #     min_val = f'{year}-01-01'
+    #     max_val = f'{year}-12-31'
+    #     default_val = f'{year}-11-01'
+    #     min_val = datetime.strptime(min_val, '%Y-%m-%d')
+    #     max_val = datetime.strptime(max_val, '%Y-%m-%d')
+    #     default_val = datetime.strptime(default_val, '%Y-%m-%d')
+
+    #     # Get the start and end dates
+    #     start_date = st.date_input('Start Date', value=default_val, min_value=min_val, max_value=max_val, key=f'Start Date - {metric}')
+    #     end_date = st.date_input('End Date', value=max_val, min_value=min_val, max_value=max_val, key=f'End Date - {metric}')
+
+
+    # Get the dates with available data for that field when the user clicks the button
+    # get_dates_button = st.button(f'Get Dates for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                 key=f'Get Dates Button - {metric}',
+    #                                 help='Click to get the dates with available data for the selected field',
+    #                                 use_container_width=True, type='primary')
+    # if get_dates_button:
+    if True:
+        start_date = '2024-01-01'
+        today = datetime.today()
+        end_date = today.strftime('%Y-%m-%d')
+        year = '2024'
+
+        dates = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+        # Add None to the end of the list to be used as a default value
+        # dates.append(-1)
+        #sort the dates from earliest to today
+        dates = sorted(dates)
+
+        #Add the dates to the session state
+        st.session_state['dates'] = dates
+
+    # Display the dropdown menu
+    if len(dates) > 0:
+        date = st.selectbox('Select Observation Date: ', dates, index=len(dates)-1, key=f'Select Date Dropdown Menu - {metric}')
+        if date != -1:
+            st.write('You selected:', date)
+            #Add the date to the session state
+            st.session_state['date'] = date
+        else:
+            st.write('Please Select A Date')
+    else:
+        st.info('No dates available for the selected field and dates range, select a different range or click the button to fetch the dates again')
+
+
+    st.markdown('---')
+    st.header('Show Field Data')
+
+    # If a field and a date are selected, display the field data
+    if date != -1:   
+
+        # Get the field data at the selected date
+        with st.spinner('Loading Field Data...'):
+            # Get the metric data and cloud cover data for the selected field and date
+            metric_data = get_cuarted_df_for_field(src_df, field_name, date, metric, client_name)
+            cloud_cover_data = get_cuarted_df_for_field(src_df, field_name, date, 'CLP', client_name)
+            
+            #Merge the metric and cloud cover data on the geometry column
+            field_data = metric_data.merge(cloud_cover_data, on='geometry')
+
+        # Display the field data
+        st.write(f'Field Data for {field_name} (Field ID: {field_name}) on {date}')
+        st.write(field_data.head(2))
+
+        #Get Avarage Cloud Cover
+        avg_clp = field_data[f'CLP_{date}'].mean() *100
+
+        # If the avarage cloud cover is greater than 80%, display a warning message
+        if avg_clp > 80:
+            st.warning(f'⚠️ The Avarage Cloud Cover is {avg_clp}%')
+            st.info('Please Select A Different Date')
+
+        ## Generate the field data Map ##
+
+        #Title, Colormap and Legend
+        title = f'{metric} for selected field {field_name} (Field ID: {field_name}) in {date}'
+        cmap = 'RdYlGn'
+
+        # Create a map of the field data
+        field_data_map  = field_data.explore(
+            column=f'{metric}_{date}',
+            cmap=cmap,
+            legend=True,
+            vmin=0,
+            vmax=1,
+            marker_type='circle', marker_kwds={'radius':5.3, 'fill':True})
+        
+        # Add Google Satellite as a base map
+        google_map = utils.basemaps['Google Satellite']
+        google_map.add_to(field_data_map)
+
+        # Display the map
+        st_folium(field_data_map, width = 725, key=f'Field Data Map - {metric}')
+
+
+        #Dwonload Links
+
+        # If the field data is not empty, display the download links
+        if len(field_data) > 0:
+            # Create two columns for the download links
+            download_as_shp_col, download_as_tiff_col = st.columns(2)
+
+            # Create a shapefile of the field data and add a download link
+            with download_as_shp_col:
+
+                #Set the shapefile name and path based on the field id, metric and date
+                extension = 'shp'
+                shapefilename = f"{field_name}_{metric}_{date}.{extension}"
+                path = f'./shapefiles/{field_name}/{metric}/{extension}'
+
+                # Create the target directory if it doesn't exist
+                os.makedirs(path, exist_ok=True)
+                
+                # Save the field data as a shapefile
+                field_data.to_file(f'{path}/{shapefilename}')
+
+                # Create a zip file of the shapefile
+                files = []
+                for i in os.listdir(path):
+                    if os.path.isfile(os.path.join(path,i)):
+                        if i[0:len(shapefilename)] == shapefilename:
+                            files.append(os.path.join(path,i))
+                zipFileName = f'{path}/{field_name}_{metric}_{date}.zip'
+                zipObj = ZipFile(zipFileName, 'w')
+                for file in files:
+                    zipObj.write(file)
+                zipObj.close()
+
+                # Add a download link for the zip file
+                with open(zipFileName, 'rb') as f:
+                    st.download_button('Download as ShapeFile', f,file_name=zipFileName)
+
+            # Get the tiff file path and create a download link
+            with download_as_tiff_col:
+                #get the tiff file path
+                tiff_path = utils.get_masked_location_img_path(client_name, metric, date, field_name)
+                # Add a download link for the tiff file
+                donwnload_filename = f'{metric}_{field_name}_{date}.tiff'
+                with open(tiff_path, 'rb') as f:
+                    st.download_button('Download as Tiff File', f,file_name=donwnload_filename)
+
+    else:
+        st.info('Please Select A Field and A Date')
+    
+
+    # st.markdown('---')
+    # st.header('Show Historic Averages')
+
+
+    # #Let the user select the year, start date and end date
+    # with st.expander('Select Year, Start Date and End Date'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(22, 25)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}- Historic Averages')
+        
+    #     # Set the start and end dates to the first and last dates of the year
+    #     start_date = f'{year}-01-01'
+    #     end_date = f'{year}-12-31'
+
+    # # Get the dates for historic averages
+    # historic_avarages_dates_for_field = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+
+    # # Convert the dates to datetime objects and sort them ascendingly then convert them back to strings
+    # historic_avarages_dates_for_field = [datetime.strptime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+    # historic_avarages_dates_for_field.sort()
+    # historic_avarages_dates_for_field = [datetime.strftime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+
+    # # Get the number of dates
+    # num_historic_dates = len(historic_avarages_dates_for_field)
+    # st.write(f' Found {num_historic_dates} dates for field {field_name} in {year} (from {start_date} to {end_date})')
+
+    # # Display the historic averages when the user clicks the button
+    # display_historic_avgs_button = st.button(f'Display Historic Averages for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                             key=f'Display Historic Averages Button - {metric}',
+    #                                             help='Click to display the historic averages for the selected field',
+    #                                             use_container_width=True, type='primary')
+    
+    # # If the button is clicked, display the historic averages
+    # if display_historic_avgs_button:
+
+    #     #Initlize the historic averages cache dir and file path
+    #     historic_avarages_cache_dir = './historic_avarages_cache'
+    #     historic_avarages_cache_path = f'{historic_avarages_cache_dir}/historic_avarages_cache.joblib'
+    #     historic_avarages_cache_clp_path = f'{historic_avarages_cache_dir}/historic_avarages_cache_clp.joblib'
+
+    #     # Load the historic averages cache if it exists, else create it
+    #     if os.path.exists(historic_avarages_cache_path):
+    #         historic_avarages_cache = joblib.load(historic_avarages_cache_path)
+    #     else:
+    #         os.makedirs(historic_avarages_cache_dir, exist_ok=True)
+    #         joblib.dump({}, historic_avarages_cache_path)
+    #         historic_avarages_cache = joblib.load(historic_avarages_cache_path)
+    #     if os.path.exists(historic_avarages_cache_clp_path):
+    #         historic_avarages_cache_clp = joblib.load(historic_avarages_cache_clp_path)
+    #     else:
+    #         os.makedirs(historic_avarages_cache_dir, exist_ok=True)
+    #         joblib.dump({}, historic_avarages_cache_clp_path)
+    #         historic_avarages_cache_clp = joblib.load(historic_avarages_cache_clp_path)
+
+    #     found_in_cache = False
+    #     if client_name not in historic_avarages_cache:
+    #         historic_avarages_cache[client_name] = {}
+    #     if metric not in historic_avarages_cache[client_name]:
+    #         historic_avarages_cache[client_name][metric] = {}
+    #     if field_name not in historic_avarages_cache[client_name][metric]:
+    #         historic_avarages_cache[client_name][metric][field_name] = {}
+    #     if year not in historic_avarages_cache[client_name][metric][field_name]:
+    #         historic_avarages_cache[client_name][metric][field_name][year] = {}
+    #     if len(historic_avarages_cache[client_name][metric][field_name][year]) > 0:
+    #         found_in_cache = True
+
+
+    #     #Check if the field and year are in the cache_clp for the current metric and client
+    #     found_in_cache_clp = False
+    #     if client_name not in historic_avarages_cache_clp:
+    #         historic_avarages_cache_clp[client_name] = {}
+    #     if 'CLP' not in historic_avarages_cache_clp[client_name]:
+    #         historic_avarages_cache_clp[client_name]['CLP'] = {}
+    #     if field_name not in historic_avarages_cache_clp[client_name]['CLP']:
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name] = {}
+    #     if year not in historic_avarages_cache_clp[client_name]['CLP'][field_name]:
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name][year] = {}
+    #     if len(historic_avarages_cache_clp[client_name]['CLP'][field_name][year]) > 0:
+    #         found_in_cache_clp = True
+
+
+    #     # If Found in cache, get the historic averages from the cache
+    #     if found_in_cache and found_in_cache_clp:
+    #         st.info('Found Historic Averages in Cache')
+    #         historic_avarages = historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages']
+    #         historic_avarages_dates = historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages_dates']
+    #         historic_avarages_clp = historic_avarages_cache_clp[client_name]['CLP'][field_name][year]['historic_avarages_clp']
+
+    #     # Else, calculate the historic averages and add them to the cache
+    #     else:
+    #         st.info('Calculating Historic Averages...')
+
+
+    #         #Empty lists for the historic averages , dates and cloud cover
+    #         historic_avarages = []
+    #         historic_avarages_dates = []
+    #         historic_avarages_clp = []
+
+    #         # Get the historic averages
+    #         dates_for_field_bar = st.progress(0)
+    #         with st.spinner('Calculating Historic Averages...'):
+    #             with st.empty():
+    #                 for i in range(num_historic_dates):
+    #                     # Get the historic average for the current date
+    #                     current_date = historic_avarages_dates_for_field[i]
+    #                     current_df = get_cuarted_df_for_field(src_df, field_name, current_date, metric, client_name)
+    #                     current_df_clp = get_cuarted_df_for_field(src_df, field_name, current_date, 'CLP', client_name)
+    #                     current_avg = current_df[f'{metric}_{current_date}'].mean()
+    #                     current_avg_clp = current_df_clp[f'CLP_{current_date}'].mean()
+    #                     # Add the historic average and date to the lists
+    #                     historic_avarages.append(current_avg)
+    #                     historic_avarages_dates.append(current_date)
+    #                     historic_avarages_clp.append(current_avg_clp)
+    #                     # Update the progress bar
+    #                     dates_for_field_bar.progress((i + 1)/(num_historic_dates))
+
+    #                     # Create a plot of the historic averages with the cloud cover as dashed line and dates as x axis (rotated 90 degrees when needed)
+    #                     fig, ax = plt.subplots(figsize=(5, 3))
+
+    #                     # Set the x axis ticks and labels
+    #                     x = historic_avarages_dates
+    #                     x_ticks = [i for i in range(len(x))]
+    #                     ax.set_xticks(x_ticks)
+                        
+    #                     #Set rotation to 90 degrees if the number of dates is greater than 10
+    #                     rot = 0 if len(x) < 10 else 90
+    #                     ax.set_xticklabels(x, rotation=rot)
+
+    #                     # Set the y axis ticks and labels
+    #                     y1 = historic_avarages
+    #                     y2 = historic_avarages_clp
+    #                     y_ticks = [i/10 for i in range(11)]
+    #                     ax.set_yticks(y_ticks)
+    #                     ax.set_yticklabels(y_ticks)
+
+    #                     # Plot the historic averages and cloud cover
+    #                     ax.plot(x_ticks, y1, label=f'{metric} Historic Averages')
+    #                     ax.plot(x_ticks, y2, '--', label='Cloud Cover')
+    #                     ax.legend()
+
+    #                     # Set the title and axis labels
+    #                     ax.set_title(f'{metric} Historic Averages for {field_name} (Field ID: {field_name}) in {year}')
+    #                     ax.set_xlabel('Date')
+    #                     ax.set_ylabel(f'{metric} Historic Averages')
+
+    #                     # Display the plot
+    #                     st.pyplot(fig, use_container_width=True)
+
+    #         # Add the historic averages to the cache
+    #         historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages'] = historic_avarages
+    #         historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages_dates'] = historic_avarages_dates
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name][year]['historic_avarages_clp'] = historic_avarages_clp
+    #         # Save the cache
+    #         joblib.dump(historic_avarages_cache, historic_avarages_cache_path)
+    #         joblib.dump(historic_avarages_cache_clp, historic_avarages_cache_clp_path)
+    #         # Tell the user that the historic averages are saved in the cache
+    #         st.info('Historic Averages Saved in Cache')
+    #         st.write(f'Cache Path: {historic_avarages_cache_path}')
+    #         st.write(f'Cache CLP Path: {historic_avarages_cache_clp_path}')
+
+
+    #     # Display the historic averages in nice plotly plot
+    #     fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    #     # Add the historic averages to the plot
+    #     fig.add_trace(
+    #         go.Scatter(x=historic_avarages_dates, y=historic_avarages, name=f'{metric} Historic Averages'),
+    #         secondary_y=False,
+    #     )
+
+    #     # Add the cloud cover to the plot
+    #     fig.add_trace(
+    #         go.Scatter(x=historic_avarages_dates, y=historic_avarages_clp, name='Cloud Cover'),
+    #         secondary_y=True,
+    #     )
+
+    #     # Set the title and axis labels
+    #     fig.update_layout(title_text=f'{metric} Historic Averages for {field_name} (Field ID: {field_name}) in {year}')
+    #     fig.update_xaxes(title_text='Date')
+    #     fig.update_yaxes(title_text=f'{metric} Historic Averages', secondary_y=False)
+    #     fig.update_yaxes(title_text='Cloud Cover', secondary_y=True)
+
+    #     # Display the plot
+    #     st.plotly_chart(fig)            
+        
+
+    # st.markdown('---')
+    # st.header('Show Historic GIF')
+
+
+    # #Let the user select the year, start date and end date of the GIF
+    # with st.expander('Select Year, Start Date and End Date of the GIF'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(16, 23)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}- Historic Averages GIF')
+        
+    #     # Set the start and end dates to the first and last dates of the year
+    #     start_date = f'{year}-01-01'
+    #     end_date = f'{year}-12-31'
+
+    # # Get the dates for historic GIF
+    # historic_avarages_dates_for_field = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+
+    # # Convert the dates to datetime objects and sort them ascendingly then convert them back to strings
+    # historic_avarages_dates_for_field = [datetime.strptime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+    # historic_avarages_dates_for_field.sort()
+    # historic_avarages_dates_for_field = [datetime.strftime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+
+    # # Get the number of dates
+    # num_historic_dates = len(historic_avarages_dates_for_field)
+    # st.write(f' Found {num_historic_dates} dates for field {field_name} in {year} (from {start_date} to {end_date})')
+
+    # # Display the historic GIF when the user clicks the button
+    # display_historic_GIF_button = st.button(f'Display Historic GIF  for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                             key=f'Display Historic GIF Button - {metric}',
+    #                                             help='Click to display the historic GIF for the selected field',
+    #                                             use_container_width=True, type='primary')
+    
+    # # If the button is clicked, display the historic GIF
+    # if display_historic_GIF_button:
+
+    #     #Initlize the historic GIF imgs and dates
+    #     st.info('Generating Historic GIF...')
+    #     historic_imgs = []
+    #     historic_imgs_dates = []
+
+    #     # Gen the historic GIF
+    #     dates_for_field_bar = st.progress(0)
+    #     with st.spinner('Generating Historic GIF...'):
+    #         with st.empty():
+    #             for i in range(num_historic_dates):
+    #                 current_date = historic_avarages_dates_for_field[i]
+    #                 current_df = get_cuarted_df_for_field(src_df, field_name, current_date, metric, client_name)
+    #                 historic_imgs.append(current_df)
+    #                 historic_imgs_dates.append(current_date)
+    #                 dates_for_field_bar.progress((i + 1)/(num_historic_dates))
+
+    #                 # Create a fig of the historic Img 
+    #                 fig, ax = plt.subplots(figsize=(10, 5))
+
+    #                 # Get the current img
+    #                 current_df_lat_lon = utils.add_lat_lon_to_gdf_from_geometry(current_df)
+    #                 current_img = utils.gdf_column_to_one_band_array(current_df_lat_lon, f'{metric}_{current_date}')
+
+    #                 # Plot the historic Img
+    #                 title = f'{metric} for selected field {field_name} (Field ID: {field_name}) in {current_date}'
+    #                 ax.imshow(current_img)
+    #                 ax.set_title(title)
+
+    #                 # Display the plot
+    #                 st.pyplot(fig)
+
+    #     # Create the historic GIF
+    #     historic_GIF_name = f'{metric}_{field_name}_{year}.gif'
+    #     st.write('Creating Historic GIF...', historic_GIF_name)
+       
+
+def monitor_fields():
+    current_user = greeting("Let's take a look how these fields are doing")
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+    else:
+        st.info("No Fields Added Yet!")
+        return
+    # st.info("Hover over the field to show the properties or check the Existing Fields List below")
+    # fields_map = gdf.explore()
+    # sat_basemap = utils.basemaps['Google Satellite']
+    # sat_basemap.add_to(fields_map)
+    # folium.LayerControl().add_to(fields_map)
+    # # output = st_folium(fields_map, key="edit_map", height=300, width=600)
+    # folium_static(fields_map, height=300, width=600)
+    
+    with st.expander("Existing Fields List", expanded=False):
+        st.write(gdf)
+
+    field_name = select_field(gdf)
+    if field_name == "Select Field":
+        st.info("No Field Selected Yet!")
+    
+    else:
+        with st.expander("Metrics Explanation", expanded=False):
+            st.write("NDVI: Normalized Difference Vegetation Index, Mainly used to monitor the health of vegetation")
+            st.write("LAI: Leaf Area Index, Mainly used to monitor the productivity of vegetation")
+            st.write("CAB: Chlorophyll Absorption in the Blue band, Mainly used to monitor the chlorophyll content in vegetation")
+            st.write("NDMI: Normalized Difference Moisture Index, Mainly used to monitor the moisture content in vegetation")
+        st.success("More metrics and analysis features will be added soon")
+        metric = st.radio("Select Metric to Monitor", ["NDVI", "LAI", "CAB", "NDMI"], key="metric", index=0, help="Select the metric to monitor")
+        st.write(f"Monitoring {metric} for {field_name}")
+
+        track(metric, field_name, gdf, current_user)
+
+        
+
+
+if __name__ == '__main__':
+    check_authentication()
+    monitor_fields()

pag/monitor.py

@@ -0,0 +1,561 @@
+import os
+import utils
+import streamlit as st
+import geopandas as gpd
+from streamlit_folium import st_folium, folium_static
+from authentication import greeting, check_password
+import folium
+from senHub import SenHub
+from datetime import datetime
+from sentinelhub import  SHConfig, MimeType
+import requests
+import process
+import joblib
+from zipfile import ZipFile
+import matplotlib.pyplot as plt
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+
+def check_authentication():
+    if not check_password():
+        st.stop()
+
+
+
+config = SHConfig()
+config.instance_id       = '6c220beb-90c4-4131-b658-10cddd8d97b9'
+config.sh_client_id      = '17e7c154-7f2d-4139-b1af-cef762385079'
+config.sh_client_secret  = 'KvbQMKZB85ZWEgWuxqiWIVEvTAQEfoF9'
+
+
+def select_field(gdf):
+    names = gdf['name'].tolist()
+    names.append("Select Field")
+    field_name = st.selectbox("Select Field", options=names, key="field_name_monitor", help="Select the field to edit", index=len(names)-1)
+    return field_name
+
+
+def calculate_bbox(df, field):
+    bbox = df.loc[df['name'] == field].bounds
+    r = bbox.iloc[0]
+    return [r.minx, r.miny, r.maxx, r.maxy]
+
+def get_available_dates_for_field(df, field, year, start_date='', end_date=''):
+    bbox = calculate_bbox(df, field)
+    token = SenHub(config).token
+    headers = utils.get_bearer_token_headers(token)
+    if start_date == '' or end_date == '':
+        start_date = f'{year}-01-01'
+        end_date = f'{year}-12-31'
+    data = f'{{ "collections": [ "sentinel-2-l2a" ], "datetime": "{start_date}T00:00:00Z/{end_date}T23:59:59Z", "bbox": {bbox}, "limit": 100, "distinct": "date" }}'
+    response = requests.post('https://services.sentinel-hub.com/api/v1/catalog/search', headers=headers, data=data)
+    try:
+        features = response.json()['features']
+    except:
+        print(response.json())
+        features = []
+    return features
+
+@st.cache_data
+def get_and_cache_available_dates(_df, field, year, start_date, end_date):
+    dates = get_available_dates_for_field(_df, field, year, start_date, end_date)
+    print(f'Caching Dates for {field}')
+    return dates
+
+
+
+
+def get_cuarted_df_for_field(df, field, date, metric, clientName):
+    curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+    if curated_date_path is not None:
+        curated_df = gpd.read_file(curated_date_path)
+    else:
+        process.Download_image_in_given_date(clientName, metric, df, field, date)
+        process.mask_downladed_image(clientName, metric, df, field, date)
+        process.convert_maske_image_to_geodataframe(clientName, metric, df, field, date, df.crs)
+        curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+        curated_df = gpd.read_file(curated_date_path)
+    return curated_df
+
+
+
+
+
+
+
+
+def get_cuarted_df_for_field(df, field, date, metric, clientName):
+    curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+    if curated_date_path is not None:
+        curated_df = gpd.read_file(curated_date_path)
+    else:
+        process.Download_image_in_given_date(clientName, metric, df, field, date)
+        process.mask_downladed_image(clientName, metric, df, field, date)
+        process.convert_maske_image_to_geodataframe(clientName, metric, df, field, date, df.crs)
+        curated_date_path =  utils.get_curated_location_img_path(clientName, metric, date, field)
+        curated_df = gpd.read_file(curated_date_path)
+    return curated_df
+
+def track(metric, field_name, src_df, client_name):
+
+    dates = []
+    date = -1
+    if 'dates' not in st.session_state:
+        st.session_state['dates'] = dates
+    else:
+        dates = st.session_state['dates']
+    if 'date' not in st.session_state:
+        st.session_state['date'] = date
+    else:
+        date = st.session_state['date']
+
+    # Give the user the option to select year, start date and end date
+    # with st.expander('Select Year, Start Date and End Date'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(22, 25)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}')
+        
+    #     # Set the min, max and default values for start and end dates
+    #     min_val = f'{year}-01-01'
+    #     max_val = f'{year}-12-31'
+    #     default_val = f'{year}-11-01'
+    #     min_val = datetime.strptime(min_val, '%Y-%m-%d')
+    #     max_val = datetime.strptime(max_val, '%Y-%m-%d')
+    #     default_val = datetime.strptime(default_val, '%Y-%m-%d')
+
+    #     # Get the start and end dates
+    #     start_date = st.date_input('Start Date', value=default_val, min_value=min_val, max_value=max_val, key=f'Start Date - {metric}')
+    #     end_date = st.date_input('End Date', value=max_val, min_value=min_val, max_value=max_val, key=f'End Date - {metric}')
+
+
+    # Get the dates with available data for that field when the user clicks the button
+    # get_dates_button = st.button(f'Get Dates for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                 key=f'Get Dates Button - {metric}',
+    #                                 help='Click to get the dates with available data for the selected field',
+    #                                 use_container_width=True, type='primary')
+    # if get_dates_button:
+    if True:
+        start_date = '2024-01-01'
+        today = datetime.today()
+        end_date = today.strftime('%Y-%m-%d')
+        year = '2024'
+
+        dates = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+        # Add None to the end of the list to be used as a default value
+        # dates.append(-1)
+        #sort the dates from earliest to today
+        dates = sorted(dates)
+
+        #Add the dates to the session state
+        st.session_state['dates'] = dates
+
+    # Display the dropdown menu
+    if len(dates) > 0:
+        date = st.selectbox('Select Observation Date: ', dates, index=len(dates)-1, key=f'Select Date Dropdown Menu - {metric}')
+        if date != -1:
+            st.write('You selected:', date)
+            #Add the date to the session state
+            st.session_state['date'] = date
+        else:
+            st.write('Please Select A Date')
+    else:
+        st.info('No dates available for the selected field and dates range, select a different range or click the button to fetch the dates again')
+
+
+    st.markdown('---')
+    st.header('Show Field Data')
+
+    # If a field and a date are selected, display the field data
+    if date != -1:   
+
+        # Get the field data at the selected date
+        with st.spinner('Loading Field Data...'):
+            # Get the metric data and cloud cover data for the selected field and date
+            metric_data = get_cuarted_df_for_field(src_df, field_name, date, metric, client_name)
+            cloud_cover_data = get_cuarted_df_for_field(src_df, field_name, date, 'CLP', client_name)
+            
+            #Merge the metric and cloud cover data on the geometry column
+            field_data = metric_data.merge(cloud_cover_data, on='geometry')
+
+        # Display the field data
+        st.write(f'Field Data for {field_name} (Field ID: {field_name}) on {date}')
+        st.write(field_data.head(2))
+
+        #Get Avarage Cloud Cover
+        avg_clp = field_data[f'CLP_{date}'].mean() *100
+
+        # If the avarage cloud cover is greater than 80%, display a warning message
+        if avg_clp > 80:
+            st.warning(f'⚠️ The Avarage Cloud Cover is {avg_clp}%')
+            st.info('Please Select A Different Date')
+
+        ## Generate the field data Map ##
+
+        #Title, Colormap and Legend
+        title = f'{metric} for selected field {field_name} (Field ID: {field_name}) in {date}'
+        cmap = 'RdYlGn'
+
+        # Create a map of the field data
+        field_data_map  = field_data.explore(
+            column=f'{metric}_{date}',
+            cmap=cmap,
+            legend=True,
+            vmin=0,
+            vmax=1,
+            marker_type='circle', marker_kwds={'radius':5.3, 'fill':True})
+        
+        # Add Google Satellite as a base map
+        google_map = utils.basemaps['Google Satellite']
+        google_map.add_to(field_data_map)
+
+        # Display the map
+        st_folium(field_data_map, width = 725, key=f'Field Data Map - {metric}')
+
+
+        #Dwonload Links
+
+        # If the field data is not empty, display the download links
+        if len(field_data) > 0:
+            # Create two columns for the download links
+            download_as_shp_col, download_as_tiff_col = st.columns(2)
+
+            # Create a shapefile of the field data and add a download link
+            with download_as_shp_col:
+
+                #Set the shapefile name and path based on the field id, metric and date
+                extension = 'shp'
+                shapefilename = f"{field_name}_{metric}_{date}.{extension}"
+                path = f'./shapefiles/{field_name}/{metric}/{extension}'
+
+                # Create the target directory if it doesn't exist
+                os.makedirs(path, exist_ok=True)
+                
+                # Save the field data as a shapefile
+                field_data.to_file(f'{path}/{shapefilename}')
+
+                # Create a zip file of the shapefile
+                files = []
+                for i in os.listdir(path):
+                    if os.path.isfile(os.path.join(path,i)):
+                        if i[0:len(shapefilename)] == shapefilename:
+                            files.append(os.path.join(path,i))
+                zipFileName = f'{path}/{field_name}_{metric}_{date}.zip'
+                zipObj = ZipFile(zipFileName, 'w')
+                for file in files:
+                    zipObj.write(file)
+                zipObj.close()
+
+                # Add a download link for the zip file
+                with open(zipFileName, 'rb') as f:
+                    st.download_button('Download as ShapeFile', f,file_name=zipFileName)
+
+            # Get the tiff file path and create a download link
+            with download_as_tiff_col:
+                #get the tiff file path
+                tiff_path = utils.get_masked_location_img_path(client_name, metric, date, field_name)
+                # Add a download link for the tiff file
+                donwnload_filename = f'{metric}_{field_name}_{date}.tiff'
+                with open(tiff_path, 'rb') as f:
+                    st.download_button('Download as Tiff File', f,file_name=donwnload_filename)
+
+    else:
+        st.info('Please Select A Field and A Date')
+    
+
+    # st.markdown('---')
+    # st.header('Show Historic Averages')
+
+
+    # #Let the user select the year, start date and end date
+    # with st.expander('Select Year, Start Date and End Date'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(22, 25)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}- Historic Averages')
+        
+    #     # Set the start and end dates to the first and last dates of the year
+    #     start_date = f'{year}-01-01'
+    #     end_date = f'{year}-12-31'
+
+    # # Get the dates for historic averages
+    # historic_avarages_dates_for_field = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+
+    # # Convert the dates to datetime objects and sort them ascendingly then convert them back to strings
+    # historic_avarages_dates_for_field = [datetime.strptime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+    # historic_avarages_dates_for_field.sort()
+    # historic_avarages_dates_for_field = [datetime.strftime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+
+    # # Get the number of dates
+    # num_historic_dates = len(historic_avarages_dates_for_field)
+    # st.write(f' Found {num_historic_dates} dates for field {field_name} in {year} (from {start_date} to {end_date})')
+
+    # # Display the historic averages when the user clicks the button
+    # display_historic_avgs_button = st.button(f'Display Historic Averages for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                             key=f'Display Historic Averages Button - {metric}',
+    #                                             help='Click to display the historic averages for the selected field',
+    #                                             use_container_width=True, type='primary')
+    
+    # # If the button is clicked, display the historic averages
+    # if display_historic_avgs_button:
+
+    #     #Initlize the historic averages cache dir and file path
+    #     historic_avarages_cache_dir = './historic_avarages_cache'
+    #     historic_avarages_cache_path = f'{historic_avarages_cache_dir}/historic_avarages_cache.joblib'
+    #     historic_avarages_cache_clp_path = f'{historic_avarages_cache_dir}/historic_avarages_cache_clp.joblib'
+
+    #     # Load the historic averages cache if it exists, else create it
+    #     if os.path.exists(historic_avarages_cache_path):
+    #         historic_avarages_cache = joblib.load(historic_avarages_cache_path)
+    #     else:
+    #         os.makedirs(historic_avarages_cache_dir, exist_ok=True)
+    #         joblib.dump({}, historic_avarages_cache_path)
+    #         historic_avarages_cache = joblib.load(historic_avarages_cache_path)
+    #     if os.path.exists(historic_avarages_cache_clp_path):
+    #         historic_avarages_cache_clp = joblib.load(historic_avarages_cache_clp_path)
+    #     else:
+    #         os.makedirs(historic_avarages_cache_dir, exist_ok=True)
+    #         joblib.dump({}, historic_avarages_cache_clp_path)
+    #         historic_avarages_cache_clp = joblib.load(historic_avarages_cache_clp_path)
+
+    #     found_in_cache = False
+    #     if client_name not in historic_avarages_cache:
+    #         historic_avarages_cache[client_name] = {}
+    #     if metric not in historic_avarages_cache[client_name]:
+    #         historic_avarages_cache[client_name][metric] = {}
+    #     if field_name not in historic_avarages_cache[client_name][metric]:
+    #         historic_avarages_cache[client_name][metric][field_name] = {}
+    #     if year not in historic_avarages_cache[client_name][metric][field_name]:
+    #         historic_avarages_cache[client_name][metric][field_name][year] = {}
+    #     if len(historic_avarages_cache[client_name][metric][field_name][year]) > 0:
+    #         found_in_cache = True
+
+
+    #     #Check if the field and year are in the cache_clp for the current metric and client
+    #     found_in_cache_clp = False
+    #     if client_name not in historic_avarages_cache_clp:
+    #         historic_avarages_cache_clp[client_name] = {}
+    #     if 'CLP' not in historic_avarages_cache_clp[client_name]:
+    #         historic_avarages_cache_clp[client_name]['CLP'] = {}
+    #     if field_name not in historic_avarages_cache_clp[client_name]['CLP']:
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name] = {}
+    #     if year not in historic_avarages_cache_clp[client_name]['CLP'][field_name]:
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name][year] = {}
+    #     if len(historic_avarages_cache_clp[client_name]['CLP'][field_name][year]) > 0:
+    #         found_in_cache_clp = True
+
+
+    #     # If Found in cache, get the historic averages from the cache
+    #     if found_in_cache and found_in_cache_clp:
+    #         st.info('Found Historic Averages in Cache')
+    #         historic_avarages = historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages']
+    #         historic_avarages_dates = historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages_dates']
+    #         historic_avarages_clp = historic_avarages_cache_clp[client_name]['CLP'][field_name][year]['historic_avarages_clp']
+
+    #     # Else, calculate the historic averages and add them to the cache
+    #     else:
+    #         st.info('Calculating Historic Averages...')
+
+
+    #         #Empty lists for the historic averages , dates and cloud cover
+    #         historic_avarages = []
+    #         historic_avarages_dates = []
+    #         historic_avarages_clp = []
+
+    #         # Get the historic averages
+    #         dates_for_field_bar = st.progress(0)
+    #         with st.spinner('Calculating Historic Averages...'):
+    #             with st.empty():
+    #                 for i in range(num_historic_dates):
+    #                     # Get the historic average for the current date
+    #                     current_date = historic_avarages_dates_for_field[i]
+    #                     current_df = get_cuarted_df_for_field(src_df, field_name, current_date, metric, client_name)
+    #                     current_df_clp = get_cuarted_df_for_field(src_df, field_name, current_date, 'CLP', client_name)
+    #                     current_avg = current_df[f'{metric}_{current_date}'].mean()
+    #                     current_avg_clp = current_df_clp[f'CLP_{current_date}'].mean()
+    #                     # Add the historic average and date to the lists
+    #                     historic_avarages.append(current_avg)
+    #                     historic_avarages_dates.append(current_date)
+    #                     historic_avarages_clp.append(current_avg_clp)
+    #                     # Update the progress bar
+    #                     dates_for_field_bar.progress((i + 1)/(num_historic_dates))
+
+    #                     # Create a plot of the historic averages with the cloud cover as dashed line and dates as x axis (rotated 90 degrees when needed)
+    #                     fig, ax = plt.subplots(figsize=(5, 3))
+
+    #                     # Set the x axis ticks and labels
+    #                     x = historic_avarages_dates
+    #                     x_ticks = [i for i in range(len(x))]
+    #                     ax.set_xticks(x_ticks)
+                        
+    #                     #Set rotation to 90 degrees if the number of dates is greater than 10
+    #                     rot = 0 if len(x) < 10 else 90
+    #                     ax.set_xticklabels(x, rotation=rot)
+
+    #                     # Set the y axis ticks and labels
+    #                     y1 = historic_avarages
+    #                     y2 = historic_avarages_clp
+    #                     y_ticks = [i/10 for i in range(11)]
+    #                     ax.set_yticks(y_ticks)
+    #                     ax.set_yticklabels(y_ticks)
+
+    #                     # Plot the historic averages and cloud cover
+    #                     ax.plot(x_ticks, y1, label=f'{metric} Historic Averages')
+    #                     ax.plot(x_ticks, y2, '--', label='Cloud Cover')
+    #                     ax.legend()
+
+    #                     # Set the title and axis labels
+    #                     ax.set_title(f'{metric} Historic Averages for {field_name} (Field ID: {field_name}) in {year}')
+    #                     ax.set_xlabel('Date')
+    #                     ax.set_ylabel(f'{metric} Historic Averages')
+
+    #                     # Display the plot
+    #                     st.pyplot(fig, use_container_width=True)
+
+    #         # Add the historic averages to the cache
+    #         historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages'] = historic_avarages
+    #         historic_avarages_cache[client_name][metric][field_name][year]['historic_avarages_dates'] = historic_avarages_dates
+    #         historic_avarages_cache_clp[client_name]['CLP'][field_name][year]['historic_avarages_clp'] = historic_avarages_clp
+    #         # Save the cache
+    #         joblib.dump(historic_avarages_cache, historic_avarages_cache_path)
+    #         joblib.dump(historic_avarages_cache_clp, historic_avarages_cache_clp_path)
+    #         # Tell the user that the historic averages are saved in the cache
+    #         st.info('Historic Averages Saved in Cache')
+    #         st.write(f'Cache Path: {historic_avarages_cache_path}')
+    #         st.write(f'Cache CLP Path: {historic_avarages_cache_clp_path}')
+
+
+    #     # Display the historic averages in nice plotly plot
+    #     fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    #     # Add the historic averages to the plot
+    #     fig.add_trace(
+    #         go.Scatter(x=historic_avarages_dates, y=historic_avarages, name=f'{metric} Historic Averages'),
+    #         secondary_y=False,
+    #     )
+
+    #     # Add the cloud cover to the plot
+    #     fig.add_trace(
+    #         go.Scatter(x=historic_avarages_dates, y=historic_avarages_clp, name='Cloud Cover'),
+    #         secondary_y=True,
+    #     )
+
+    #     # Set the title and axis labels
+    #     fig.update_layout(title_text=f'{metric} Historic Averages for {field_name} (Field ID: {field_name}) in {year}')
+    #     fig.update_xaxes(title_text='Date')
+    #     fig.update_yaxes(title_text=f'{metric} Historic Averages', secondary_y=False)
+    #     fig.update_yaxes(title_text='Cloud Cover', secondary_y=True)
+
+    #     # Display the plot
+    #     st.plotly_chart(fig)            
+        
+
+    # st.markdown('---')
+    # st.header('Show Historic GIF')
+
+
+    # #Let the user select the year, start date and end date of the GIF
+    # with st.expander('Select Year, Start Date and End Date of the GIF'):
+    #     # Get the year
+    #     years = [f'20{i}' for i in range(16, 23)]
+    #     year = st.selectbox('Select Year: ', years, index=len(years)-2, key=f'Select Year Dropdown Menu - {metric}- Historic Averages GIF')
+        
+    #     # Set the start and end dates to the first and last dates of the year
+    #     start_date = f'{year}-01-01'
+    #     end_date = f'{year}-12-31'
+
+    # # Get the dates for historic GIF
+    # historic_avarages_dates_for_field = get_and_cache_available_dates(src_df, field_name, year, start_date, end_date)
+
+    # # Convert the dates to datetime objects and sort them ascendingly then convert them back to strings
+    # historic_avarages_dates_for_field = [datetime.strptime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+    # historic_avarages_dates_for_field.sort()
+    # historic_avarages_dates_for_field = [datetime.strftime(date, '%Y-%m-%d') for date in historic_avarages_dates_for_field]
+
+    # # Get the number of dates
+    # num_historic_dates = len(historic_avarages_dates_for_field)
+    # st.write(f' Found {num_historic_dates} dates for field {field_name} in {year} (from {start_date} to {end_date})')
+
+    # # Display the historic GIF when the user clicks the button
+    # display_historic_GIF_button = st.button(f'Display Historic GIF  for Field {field_name} (Field ID: {field_name}) in {year} (from {start_date} to {end_date})',
+    #                                             key=f'Display Historic GIF Button - {metric}',
+    #                                             help='Click to display the historic GIF for the selected field',
+    #                                             use_container_width=True, type='primary')
+    
+    # # If the button is clicked, display the historic GIF
+    # if display_historic_GIF_button:
+
+    #     #Initlize the historic GIF imgs and dates
+    #     st.info('Generating Historic GIF...')
+    #     historic_imgs = []
+    #     historic_imgs_dates = []
+
+    #     # Gen the historic GIF
+    #     dates_for_field_bar = st.progress(0)
+    #     with st.spinner('Generating Historic GIF...'):
+    #         with st.empty():
+    #             for i in range(num_historic_dates):
+    #                 current_date = historic_avarages_dates_for_field[i]
+    #                 current_df = get_cuarted_df_for_field(src_df, field_name, current_date, metric, client_name)
+    #                 historic_imgs.append(current_df)
+    #                 historic_imgs_dates.append(current_date)
+    #                 dates_for_field_bar.progress((i + 1)/(num_historic_dates))
+
+    #                 # Create a fig of the historic Img 
+    #                 fig, ax = plt.subplots(figsize=(10, 5))
+
+    #                 # Get the current img
+    #                 current_df_lat_lon = utils.add_lat_lon_to_gdf_from_geometry(current_df)
+    #                 current_img = utils.gdf_column_to_one_band_array(current_df_lat_lon, f'{metric}_{current_date}')
+
+    #                 # Plot the historic Img
+    #                 title = f'{metric} for selected field {field_name} (Field ID: {field_name}) in {current_date}'
+    #                 ax.imshow(current_img)
+    #                 ax.set_title(title)
+
+    #                 # Display the plot
+    #                 st.pyplot(fig)
+
+    #     # Create the historic GIF
+    #     historic_GIF_name = f'{metric}_{field_name}_{year}.gif'
+    #     st.write('Creating Historic GIF...', historic_GIF_name)
+       
+
+def monitor_fields():
+    current_user = greeting("Let's take a look how these fields are doing")
+    if os.path.exists(f"fields_{current_user}.parquet"):
+        gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
+    else:
+        st.info("No Fields Added Yet!")
+        return
+    # st.info("Hover over the field to show the properties or check the Existing Fields List below")
+    # fields_map = gdf.explore()
+    # sat_basemap = utils.basemaps['Google Satellite']
+    # sat_basemap.add_to(fields_map)
+    # folium.LayerControl().add_to(fields_map)
+    # # output = st_folium(fields_map, key="edit_map", height=300, width=600)
+    # folium_static(fields_map, height=300, width=600)
+    
+    with st.expander("Existing Fields List", expanded=False):
+        st.write(gdf)
+
+    field_name = select_field(gdf)
+    if field_name == "Select Field":
+        st.info("No Field Selected Yet!")
+    
+    else:
+        with st.expander("Metrics Explanation", expanded=False):
+            st.write("NDVI: Normalized Difference Vegetation Index, Mainly used to monitor the health of vegetation")
+            st.write("LAI: Leaf Area Index, Mainly used to monitor the productivity of vegetation")
+            st.write("CAB: Chlorophyll Absorption in the Blue band, Mainly used to monitor the chlorophyll content in vegetation")
+            # st.write("NDMI: Normalized Difference Moisture Index, Mainly used to monitor the moisture content in vegetation")
+        st.success("More metrics and analysis features will be added soon")
+        metric = st.radio("Select Metric to Monitor", ["NDVI", "LAI", "CAB"], key="metric", index=0, help="Select the metric to monitor")
+        st.write(f"Monitoring {metric} for {field_name}")
+
+        track(metric, field_name, gdf, current_user)
+
+        
+
+
+if __name__ == '__main__':
+    check_authentication()
+    monitor_fields()

playground.ipynb

@@ -0,0 +1,155 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import folium\n",
+    "from folium.plugins import Draw\n",
+    "\n",
+    "center_start = [15.572363674301132, 32.69167103104079]\n",
+    "zoom_start = 13\n",
+    "\n",
+    "\n",
+    "\n",
+    "m = folium.Map(location=center_start, zoom_start=zoom_start)\n",
+    "\n",
+    "\n",
+    "draw_options = {'polyline': False, 'polygon': True, 'rectangle': True, 'circle': True, 'marker': False, 'circlemarker': False}\n",
+    "Draw(export=True, draw_options=draw_options).add_to(m)\n",
+    "#\n",
+    "m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "28579648969.878418\n",
+      "28579.648969878417\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\Edin\\anaconda3\\envs\\amazon\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
+      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n",
+      "c:\\Users\\Edin\\anaconda3\\envs\\amazon\\lib\\site-packages\\shapely\\ops.py:276: FutureWarning: This function is deprecated. See: https://pyproj4.github.io/pyproj/stable/gotchas.html#upgrading-to-pyproj-2-from-pyproj-1\n",
+      "  shell = type(geom.exterior)(zip(*func(*zip(*geom.exterior.coords))))\n"
+     ]
+    }
+   ],
+   "source": [
+    "from shapely.geometry import Polygon\n",
+    "import shapely.ops as ops\n",
+    "from functools import partial\n",
+    "import pyproj\n",
+    "edges =            [\n",
+    "            [32.584179, 15.217575],\n",
+    "            [32.726973, 13.546143],\n",
+    "            [33.957199, 13.973163],\n",
+    "            [34.286724, 14.739791],\n",
+    "            [33.69358, 15.620197],\n",
+    "            [32.584179, 15.217575]\n",
+    "          ]\n",
+    "geom = Polygon(edges)\n",
+    "\n",
+    "geom_area = ops.transform(\n",
+    "    partial(\n",
+    "        pyproj.transform,\n",
+    "        pyproj.Proj(init='EPSG:4326'),\n",
+    "        pyproj.Proj(\n",
+    "            proj='aea',\n",
+    "            lat_1=geom.bounds[1],\n",
+    "            lat_2=geom.bounds[3]\n",
+    "        )\n",
+    "    ),\n",
+    "    geom)\n",
+    "\n",
+    "# Print the area in m^2\n",
+    "print(geom_area.area)\n",
+    "#print the area in km^2\n",
+    "print(geom_area.area/1000000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geom"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyproj    \n",
+    "import shapely\n",
+    "import shapely.ops as ops\n",
+    "from shapely.geometry.polygon import Polygon\n",
+    "from functools import partial\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "geom = Polygon([(0, 0), (0, 10), (10, 10), (10, 0), (0, 0)])\n",
+    "geom_area = ops.transform(\n",
+    "    partial(\n",
+    "        pyproj.transform,\n",
+    "        pyproj.Proj(init='EPSG:4326'),\n",
+    "        pyproj.Proj(\n",
+    "            proj='aea',\n",
+    "            lat_1=geom.bounds[1],\n",
+    "            lat_2=geom.bounds[3]\n",
+    "        )\n",
+    "    ),\n",
+    "    geom)\n",
+    "\n",
+    "# Print the area in m^2\n",
+    "print(geom_area.area)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "amazon",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

process.py

@@ -0,0 +1,45 @@
+import os
+import utils
+import rioxarray as rx
+from senHub import SenHub
+from sentinelhub import  SHConfig, MimeType
+
+
+config = SHConfig()
+config.instance_id       = '6c220beb-90c4-4131-b658-10cddd8d97b9'
+config.sh_client_id      = '17e7c154-7f2d-4139-b1af-cef762385079'
+config.sh_client_secret  = 'KvbQMKZB85ZWEgWuxqiWIVEvTAQEfoF9'
+
+def Download_image_in_given_date(clientName, metric, df, field, date, mime_type = MimeType.TIFF):
+    sen_obj = SenHub(config, mime_type = mime_type)
+    download_path = f'./{clientName}/raw/{metric}/{date}/field_{field}/'
+    bbox = utils.calculate_bbox(df, field)
+    evalscript = utils.Scripts[metric]
+    sen_obj.set_dir(download_path)
+    sen_obj.make_bbox(bbox)
+    sen_obj.make_request(evalscript, date)
+    data = sen_obj.download_data()
+    return data
+
+def mask_downladed_image(clientName, metric, df, field, date):
+    download_path = utils.get_downloaded_location_img_path(clientName, metric, date, field)
+    im = rx.open_rasterio(download_path)
+    field_vals = df.loc[df['name'] == field]
+    field_geom = field_vals.geometry 
+    crs = field_vals.crs
+    clipped = im.rio.clip(field_geom, crs, drop=True)
+    save_dir_path = f'./{clientName}/processed/{metric}/{date}/field_{field}/'
+    os.makedirs(save_dir_path, exist_ok=True)
+    save_tiff_path = save_dir_path + 'masked.tiff'
+    clipped.rio.to_raster(save_tiff_path)
+    return save_tiff_path
+
+def convert_maske_image_to_geodataframe(clientName, metric, df, field, date, crs):
+    imagePath = utils.get_masked_location_img_path(clientName, metric, date, field)
+    im = rx.open_rasterio(imagePath)
+    gdf = utils.tiff_to_geodataframe(im, metric, date, crs)
+    save_dir_path = f'./{clientName}/curated/{metric}/{date}/field_{field}/'
+    os.makedirs(save_dir_path, exist_ok=True)
+    save_geojson_path = save_dir_path + 'masked.geojson'
+    gdf.to_file(save_geojson_path, driver='GeoJSON')
+    return save_geojson_path

requirements.txt

@@ -0,0 +1,11 @@
+confuse==2.0.1
+folium==0.14.0
+geopandas==0.14.3
+mapclassify==2.5.0
+matplotlib==3.7.1
+plotly==5.14.1
+rioxarray==0.14.1
+sentinelhub==3.9.1
+shapely==2.0.3
+streamlit-folium==0.12.0 
+streamlit==1.29.0

scripts/cab.js

@@ -0,0 +1,175 @@
+ //VERSION=3 (auto-converted from 2)
+var degToRad = Math.PI / 180;
+
+function evaluatePixelOrig(samples) {
+  var sample = samples[0];
+  var b03_norm = normalize(sample.B03, 0, 0.253061520471542);
+  var b04_norm = normalize(sample.B04, 0, 0.290393577911328);
+  var b05_norm = normalize(sample.B05, 0, 0.305398915248555);
+  var b06_norm = normalize(sample.B06, 0.006637972542253, 0.608900395797889);
+  var b07_norm = normalize(sample.B07, 0.013972727018939, 0.753827384322927);
+  var b8a_norm = normalize(sample.B8A, 0.026690138082061, 0.782011770669178);
+  var b11_norm = normalize(sample.B11, 0.016388074192258, 0.493761397883092);
+  var b12_norm = normalize(sample.B12, 0, 0.493025984460231);
+  var viewZen_norm = normalize(Math.cos(sample.viewZenithMean * degToRad), 0.918595400582046, 1);
+  var sunZen_norm  = normalize(Math.cos(sample.sunZenithAngles * degToRad), 0.342022871159208, 0.936206429175402);
+  var relAzim_norm = Math.cos((sample.sunAzimuthAngles - sample.viewAzimuthMean) * degToRad)
+
+  var n1 = neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n2 = neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n3 = neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n4 = neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n5 = neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  
+  var l2 = layer2(n1, n2, n3, n4, n5);
+  
+  var cab = denormalize(l2, 0.007426692959872, 873.908222110306);
+  return {
+    default: [cab / 300]
+  }
+}
+
+function neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	  4.242299670155190
+	+ 0.400396555256580 * b03_norm
+	+ 0.607936279259404 * b04_norm
+	+ 0.137468650780226 * b05_norm
+	- 2.955866573461640 * b06_norm
+	- 3.186746687729570 * b07_norm
+	+ 2.206800751246430 * b8a_norm
+	- 0.313784336139636 * b11_norm
+	+ 0.256063547510639 * b12_norm
+	- 0.071613219805105 * viewZen_norm
+	+ 0.510113504210111 * sunZen_norm
+	+ 0.142813982138661 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	- 0.259569088225796
+	- 0.250781102414872 * b03_norm
+	+ 0.439086302920381 * b04_norm
+	- 1.160590937522300 * b05_norm
+	- 1.861935250269610 * b06_norm
+	+ 0.981359868451638 * b07_norm
+	+ 1.634230834254840 * b8a_norm
+	- 0.872527934645577 * b11_norm
+	+ 0.448240475035072 * b12_norm
+	+ 0.037078083501217 * viewZen_norm
+	+ 0.030044189670404 * sunZen_norm
+	+ 0.005956686619403 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	+ 3.130392627338360
+	+ 0.552080132568747 * b03_norm
+	- 0.502919673166901 * b04_norm
+	+ 6.105041924966230 * b05_norm
+	- 1.294386119140800 * b06_norm
+	- 1.059956388352800 * b07_norm
+	- 1.394092902418820 * b8a_norm
+	+ 0.324752732710706 * b11_norm
+	- 1.758871822827680 * b12_norm
+	- 0.036663679860328 * viewZen_norm
+	- 0.183105291400739 * sunZen_norm
+	- 0.038145312117381 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+    + 0.774423577181620
+	+ 0.211591184882422 * b03_norm
+	- 0.248788896074327 * b04_norm
+	+ 0.887151598039092 * b05_norm
+	+ 1.143675895571410 * b06_norm
+	- 0.753968830338323 * b07_norm
+	- 1.185456953076760 * b8a_norm
+	+ 0.541897860471577 * b11_norm
+	- 0.252685834607768 * b12_norm
+	- 0.023414901078143 * viewZen_norm
+	- 0.046022503549557 * sunZen_norm
+	- 0.006570284080657 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	+ 2.584276648534610
+	+ 0.254790234231378 * b03_norm
+	- 0.724968611431065 * b04_norm
+	+ 0.731872806026834 * b05_norm
+	+ 2.303453821021270 * b06_norm
+	- 0.849907966921912 * b07_norm
+	- 6.425315500537270 * b8a_norm
+	+ 2.238844558459030 * b11_norm
+	- 0.199937574297990 * b12_norm
+	+ 0.097303331714567 * viewZen_norm
+	+ 0.334528254938326 * sunZen_norm
+	+ 0.113075306591838 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function layer2(neuron1, neuron2, neuron3, neuron4, neuron5) {
+  var sum =
+	+ 0.463426463933822
+	- 0.352760040599190 * neuron1
+	- 0.603407399151276 * neuron2
+	+ 0.135099379384275 * neuron3
+	- 1.735673123851930 * neuron4
+	- 0.147546813318256 * neuron5;
+
+  return sum;
+}
+
+function normalize(unnormalized, min, max) {
+  return 2 * (unnormalized - min) / (max - min) - 1;
+}
+function denormalize(normalized, min, max) {
+  return 0.5 * (normalized + 1) * (max - min) + min;
+}
+function tansig(input) {
+  return 2 / (1 + Math.exp(-2 * input)) - 1; 
+}
+
+function setup() {
+  return {
+    input: [{
+      bands: [
+          "B03",
+          "B04",
+          "B05",
+          "B06",
+          "B07",
+          "B8A",
+          "B11",
+          "B12",
+          "viewZenithMean",
+          "viewAzimuthMean",
+          "sunZenithAngles",
+          "sunAzimuthAngles"
+      ]
+    }],
+    output: [
+        {
+          id: "default",
+          sampleType: "FLOAT32",
+          bands: 1
+        }
+    ]
+  }
+}
+
+function evaluatePixel(sample, scene, metadata, customData, outputMetadata) {
+  const result = evaluatePixelOrig([sample], [scene], metadata, customData, outputMetadata);
+  return result[Object.keys(result)[0]];
+}

scripts/clp.js

@@ -0,0 +1,16 @@
+     //VERSION=3
+     function setup(){
+        return{
+          input: ["CLP"],
+          output: [
+            {
+              sampleType: "FLOAT32",
+              bands: 1
+            }
+        ]
+        }
+      }
+      
+      function evaluatePixel(sample){
+        return [sample.CLP/255];
+      }

scripts/fcover.js

@@ -0,0 +1,171 @@
+ //VERSION=3
+
+
+function setup() {
+  return {
+    input: [{
+      bands: [
+        "B03",
+        "B04",
+        "B05",
+        "B06",
+        "B07",
+        "B8A",
+        "B11",
+        "B12",
+        "viewZenithMean",
+        "viewAzimuthMean",
+        "sunZenithAngles",
+        "sunAzimuthAngles"
+      ],
+        units: ["REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "DEGREES", "DEGREES", "DEGREES", "DEGREES"]
+    }],
+    output: [
+        {
+          id: "default",
+          sampleType: "FLOAT32",
+          bands: 1
+        }
+    ]
+  }
+}
+
+var degToRad = Math.PI / 180;
+
+function evaluatePixel(sample) {
+  var b03_norm = normalize(sample.B03, 0, 0.253061520472);
+  var b04_norm = normalize(sample.B04, 0, 0.290393577911);
+  var b05_norm = normalize(sample.B05, 0, 0.305398915249);
+  var b06_norm = normalize(sample.B06, 0.00663797254225, 0.608900395798);
+  var b07_norm = normalize(sample.B07, 0.0139727270189, 0.753827384323);
+  var b8a_norm = normalize(sample.B8A, 0.0266901380821, 0.782011770669);
+  var b11_norm = normalize(sample.B11, 0.0163880741923, 0.493761397883);
+  var b12_norm = normalize(sample.B12, 0, 0.49302598446);
+  var viewZen_norm = normalize(Math.cos(sample.viewZenithMean * degToRad), 0.918595400582, 0.999999999991);
+  var sunZen_norm  = normalize(Math.cos(sample.sunZenithAngles * degToRad), 0.342022871159, 0.936206429175);
+  var relAzim_norm = Math.cos((sample.sunAzimuthAngles - sample.viewAzimuthMean) * degToRad)
+
+  var n1 = neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n2 = neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n3 = neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n4 = neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  var n5 = neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+
+  var l2 = layer2(n1, n2, n3, n4, n5);
+
+  var fcover = denormalize(l2, 0.000181230723879, 0.999638214715);
+
+  return {default: [fcover]}
+}
+
+function neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	- 1.45261652206
+	- 0.156854264841 * b03_norm
+	+ 0.124234528462 * b04_norm
+	+ 0.235625516229 * b05_norm
+	- 1.8323910258 * b06_norm
+	- 0.217188969888 * b07_norm
+	+ 5.06933958064 * b8a_norm
+	- 0.887578008155 * b11_norm
+	- 1.0808468167 * b12_norm
+	- 0.0323167041864 * viewZen_norm
+	- 0.224476137359 * sunZen_norm
+	- 0.195523962947 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	- 1.70417477557
+	- 0.220824927842 * b03_norm
+	+ 1.28595395487 * b04_norm
+	+ 0.703139486363 * b05_norm
+	- 1.34481216665 * b06_norm
+	- 1.96881267559 * b07_norm
+	- 1.45444681639 * b8a_norm
+	+ 1.02737560043 * b11_norm
+	- 0.12494641532 * b12_norm
+	+ 0.0802762437265 * viewZen_norm
+	- 0.198705918577 * sunZen_norm
+	+ 0.108527100527 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	+ 1.02168965849
+	- 0.409688743281 * b03_norm
+	+ 1.08858884766 * b04_norm
+	+ 0.36284522554 * b05_norm
+	+ 0.0369390509705 * b06_norm
+	- 0.348012590003 * b07_norm
+	- 2.0035261881 * b8a_norm
+	+ 0.0410357601757 * b11_norm
+	+ 1.22373853174 * b12_norm
+	+ -0.0124082778287 * viewZen_norm
+	- 0.282223364524 * sunZen_norm
+	+ 0.0994993117557 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	- 0.498002810205
+	- 0.188970957866 * b03_norm
+	- 0.0358621840833 * b04_norm
+	+ 0.00551248528107 * b05_norm
+	+ 1.35391570802 * b06_norm
+	- 0.739689896116 * b07_norm
+	- 2.21719530107 * b8a_norm
+	+ 0.313216124198 * b11_norm
+	+ 1.5020168915 * b12_norm
+	+ 1.21530490195 * viewZen_norm
+	- 0.421938358618 * sunZen_norm
+	+ 1.48852484547 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+  var sum =
+	- 3.88922154789
+	+ 2.49293993709 * b03_norm
+	- 4.40511331388 * b04_norm
+	- 1.91062012624 * b05_norm
+	- 0.703174115575 * b06_norm
+	- 0.215104721138 * b07_norm
+	- 0.972151494818 * b8a_norm
+	- 0.930752241278 * b11_norm
+	+ 1.2143441876 * b12_norm
+	- 0.521665460192 * viewZen_norm
+	- 0.445755955598 * sunZen_norm
+	+ 0.344111873777 * relAzim_norm;
+
+  return tansig(sum);
+}
+
+function layer2(neuron1, neuron2, neuron3, neuron4, neuron5) {
+  var sum =
+	- 0.0967998147811
+	+ 0.23080586765 * neuron1
+	- 0.333655484884 * neuron2
+	- 0.499418292325 * neuron3
+	+ 0.0472484396749 * neuron4
+	- 0.0798516540739 * neuron5;
+
+  return sum;
+}
+
+function normalize(unnormalized, min, max) {
+  return 2 * (unnormalized - min) / (max - min) - 1;
+}
+function denormalize(normalized, min, max) {
+  return 0.5 * (normalized + 1) * (max - min) + min;
+}
+function tansig(input) {
+  return 2 / (1 + Math.exp(-2 * input)) - 1;
+}

scripts/lai.js

@@ -0,0 +1,179 @@
+//VERSION=3
+
+var degToRad = Math.PI / 180;
+
+function evaluatePixelOrig(samples) {
+    var sample = samples[0];
+    var b03_norm = normalize(sample.B03, 0, 0.253061520471542);
+    var b04_norm = normalize(sample.B04, 0, 0.290393577911328);
+    var b05_norm = normalize(sample.B05, 0, 0.305398915248555);
+    var b06_norm = normalize(sample.B06, 0.006637972542253, 0.608900395797889);
+    var b07_norm = normalize(sample.B07, 0.013972727018939, 0.753827384322927);
+    var b8a_norm = normalize(sample.B8A, 0.026690138082061, 0.782011770669178);
+    var b11_norm = normalize(sample.B11, 0.016388074192258, 0.493761397883092);
+    var b12_norm = normalize(sample.B12, 0, 0.493025984460231);
+    var viewZen_norm = normalize(Math.cos(sample.viewZenithMean * degToRad), 0.918595400582046, 1);
+    var sunZen_norm  = normalize(Math.cos(sample.sunZenithAngles * degToRad), 0.342022871159208, 0.936206429175402);
+    var relAzim_norm = Math.cos((sample.sunAzimuthAngles - sample.viewAzimuthMean) * degToRad)
+  
+    var n1 = neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n2 = neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n3 = neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n4 = neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n5 = neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  
+    var l2 = layer2(n1, n2, n3, n4, n5);
+  
+    var lai = denormalize(l2, 0.000319182538301, 14.4675094548151);
+    return {
+      default: [lai]
+    }
+}
+
+function neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+        + 4.96238030555279
+        - 0.023406878966470 * b03_norm
+        + 0.921655164636366 * b04_norm
+        + 0.135576544080099 * b05_norm
+        - 1.938331472397950 * b06_norm
+        - 3.342495816122680 * b07_norm
+        + 0.902277648009576 * b8a_norm
+        + 0.205363538258614 * b11_norm
+        - 0.040607844721716 * b12_norm
+        - 0.083196409727092 * viewZen_norm
+        + 0.260029270773809 * sunZen_norm
+        + 0.284761567218845 * relAzim_norm;
+
+    return tansig(sum);
+}
+
+function neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 1.416008443981500
+      - 0.132555480856684 * b03_norm
+      - 0.139574837333540 * b04_norm
+      - 1.014606016898920 * b05_norm
+      - 1.330890038649270 * b06_norm
+      + 0.031730624503341 * b07_norm
+      - 1.433583541317050 * b8a_norm
+      - 0.959637898574699 * b11_norm
+      + 1.133115706551000 * b12_norm
+      + 0.216603876541632 * viewZen_norm
+      + 0.410652303762839 * sunZen_norm
+      + 0.064760155543506 * relAzim_norm;
+  
+    return tansig(sum);
+}
+
+function neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+        + 1.075897047213310
+        + 0.086015977724868 * b03_norm
+        + 0.616648776881434 * b04_norm
+        + 0.678003876446556 * b05_norm
+        + 0.141102398644968 * b06_norm
+        - 0.096682206883546 * b07_norm
+        - 1.128832638862200 * b8a_norm
+        + 0.302189102741375 * b11_norm
+        + 0.434494937299725 * b12_norm
+        - 0.021903699490589 * viewZen_norm
+        - 0.228492476802263 * sunZen_norm
+        - 0.039460537589826 * relAzim_norm;
+
+    return tansig(sum);
+}
+  
+function neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 1.533988264655420
+      - 0.109366593670404 * b03_norm
+      - 0.071046262972729 * b04_norm
+      + 0.064582411478320 * b05_norm
+      + 2.906325236823160 * b06_norm
+      - 0.673873108979163 * b07_norm
+      - 3.838051868280840 * b8a_norm
+      + 1.695979344531530 * b11_norm
+      + 0.046950296081713 * b12_norm
+      - 0.049709652688365 * viewZen_norm
+      + 0.021829545430994 * sunZen_norm
+      + 0.057483827104091 * relAzim_norm;
+  
+    return tansig(sum);
+}
+  
+function neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 3.024115930757230
+      - 0.089939416159969 * b03_norm
+      + 0.175395483106147 * b04_norm
+      - 0.081847329172620 * b05_norm
+      + 2.219895367487790 * b06_norm
+      + 1.713873975136850 * b07_norm
+      + 0.713069186099534 * b8a_norm
+      + 0.138970813499201 * b11_norm
+      - 0.060771761518025 * b12_norm
+      + 0.124263341255473 * viewZen_norm
+      + 0.210086140404351 * sunZen_norm
+      - 0.183878138700341 * relAzim_norm;
+  
+    return tansig(sum);
+}
+  
+function layer2(neuron1, neuron2, neuron3, neuron4, neuron5) {
+    var sum =
+      + 1.096963107077220
+      - 1.500135489728730 * neuron1
+      - 0.096283269121503 * neuron2
+      - 0.194935930577094 * neuron3
+      - 0.352305895755591 * neuron4
+      + 0.075107415847473 * neuron5;
+  
+    return sum;
+}
+  
+function normalize(unnormalized, min, max) {
+    return 2 * (unnormalized - min) / (max - min) - 1;
+}
+
+function denormalize(normalized, min, max) {
+    return 0.5 * (normalized + 1) * (max - min) + min;
+}
+  
+function tansig(input) {
+    return 2 / (1 + Math.exp(-2 * input)) - 1; 
+}
+  
+function setup() {
+    return {
+      input: [{
+        bands: [
+            "B03",
+            "B04",
+            "B05",
+            "B06",
+            "B07",
+            "B8A",
+            "B11",
+            "B12",
+            "viewZenithMean",
+            "viewAzimuthMean",
+            "sunZenithAngles",
+            "sunAzimuthAngles"
+        ],
+        units: ["REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "DEGREES", "DEGREES", "DEGREES", "DEGREES"]
+      }],
+      output: [
+          {
+            id: "default",
+            sampleType: "FLOAT32",
+            bands: 1
+          }
+      ]
+    }
+}
+
+function evaluatePixel(sample, scene, metadata, customData, outputMetadata) {
+  const result = evaluatePixelOrig([sample], [scene], metadata, customData, outputMetadata);
+  return result[Object.keys(result)[0]];
+}

scripts/ndmi.js

@@ -0,0 +1,24 @@
+//VERSION=3
+const moistureRamps = [
+    [-0.8, 0x800000],
+    [-0.24, 0xff0000],
+    [-0.032, 0xffff00],
+    [0.032, 0x00ffff],
+    [0.24, 0x0000ff],
+    [0.8, 0x000080]
+ ];
+ 
+ const viz = new ColorRampVisualizer(moistureRamps);
+ 
+ function setup() {
+    return {
+       input: ["B8A", "B11", "dataMask"],
+       output: { bands: 4 }
+    };
+ }
+ 
+ function evaluatePixel(samples) {
+    let val = index(samples.B8A, samples.B11);
+    let imgVals = viz.process(val);
+    return imgVals.concat(samples.dataMask);
+ }

scripts/ndvi.js

@@ -0,0 +1,179 @@
+//VERSION=3
+
+var degToRad = Math.PI / 180;
+
+function evaluatePixelOrig(samples) {
+    var sample = samples[0];
+    var b03_norm = normalize(sample.B03, 0, 0.253061520471542);
+    var b04_norm = normalize(sample.B04, 0, 0.290393577911328);
+    var b05_norm = normalize(sample.B05, 0, 0.305398915248555);
+    var b06_norm = normalize(sample.B06, 0.006637972542253, 0.608900395797889);
+    var b07_norm = normalize(sample.B07, 0.013972727018939, 0.753827384322927);
+    var b8a_norm = normalize(sample.B8A, 0.026690138082061, 0.782011770669178);
+    var b11_norm = normalize(sample.B11, 0.016388074192258, 0.493761397883092);
+    var b12_norm = normalize(sample.B12, 0, 0.493025984460231);
+    var viewZen_norm = normalize(Math.cos(sample.viewZenithMean * degToRad), 0.918595400582046, 1);
+    var sunZen_norm  = normalize(Math.cos(sample.sunZenithAngles * degToRad), 0.342022871159208, 0.936206429175402);
+    var relAzim_norm = Math.cos((sample.sunAzimuthAngles - sample.viewAzimuthMean) * degToRad)
+  
+    var n1 = neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n2 = neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n3 = neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n4 = neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+    var n5 = neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm);
+  
+    var l2 = layer2(n1, n2, n3, n4, n5);
+  
+    var lai = denormalize(l2, 0.000319182538301, 14.4675094548151);
+    return {
+      default: [lai]
+    }
+}
+
+function neuron1(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+        + 4.96238030555279
+        - 0.023406878966470 * b03_norm
+        + 0.921655164636366 * b04_norm
+        + 0.135576544080099 * b05_norm
+        - 1.938331472397950 * b06_norm
+        - 3.342495816122680 * b07_norm
+        + 0.902277648009576 * b8a_norm
+        + 0.205363538258614 * b11_norm
+        - 0.040607844721716 * b12_norm
+        - 0.083196409727092 * viewZen_norm
+        + 0.260029270773809 * sunZen_norm
+        + 0.284761567218845 * relAzim_norm;
+
+    return tansig(sum);
+}
+
+function neuron2(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 1.416008443981500
+      - 0.132555480856684 * b03_norm
+      - 0.139574837333540 * b04_norm
+      - 1.014606016898920 * b05_norm
+      - 1.330890038649270 * b06_norm
+      + 0.031730624503341 * b07_norm
+      - 1.433583541317050 * b8a_norm
+      - 0.959637898574699 * b11_norm
+      + 1.133115706551000 * b12_norm
+      + 0.216603876541632 * viewZen_norm
+      + 0.410652303762839 * sunZen_norm
+      + 0.064760155543506 * relAzim_norm;
+  
+    return tansig(sum);
+}
+
+function neuron3(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+        + 1.075897047213310
+        + 0.086015977724868 * b03_norm
+        + 0.616648776881434 * b04_norm
+        + 0.678003876446556 * b05_norm
+        + 0.141102398644968 * b06_norm
+        - 0.096682206883546 * b07_norm
+        - 1.128832638862200 * b8a_norm
+        + 0.302189102741375 * b11_norm
+        + 0.434494937299725 * b12_norm
+        - 0.021903699490589 * viewZen_norm
+        - 0.228492476802263 * sunZen_norm
+        - 0.039460537589826 * relAzim_norm;
+
+    return tansig(sum);
+}
+  
+function neuron4(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 1.533988264655420
+      - 0.109366593670404 * b03_norm
+      - 0.071046262972729 * b04_norm
+      + 0.064582411478320 * b05_norm
+      + 2.906325236823160 * b06_norm
+      - 0.673873108979163 * b07_norm
+      - 3.838051868280840 * b8a_norm
+      + 1.695979344531530 * b11_norm
+      + 0.046950296081713 * b12_norm
+      - 0.049709652688365 * viewZen_norm
+      + 0.021829545430994 * sunZen_norm
+      + 0.057483827104091 * relAzim_norm;
+  
+    return tansig(sum);
+}
+  
+function neuron5(b03_norm,b04_norm,b05_norm,b06_norm,b07_norm,b8a_norm,b11_norm,b12_norm, viewZen_norm,sunZen_norm,relAzim_norm) {
+    var sum =
+      + 3.024115930757230
+      - 0.089939416159969 * b03_norm
+      + 0.175395483106147 * b04_norm
+      - 0.081847329172620 * b05_norm
+      + 2.219895367487790 * b06_norm
+      + 1.713873975136850 * b07_norm
+      + 0.713069186099534 * b8a_norm
+      + 0.138970813499201 * b11_norm
+      - 0.060771761518025 * b12_norm
+      + 0.124263341255473 * viewZen_norm
+      + 0.210086140404351 * sunZen_norm
+      - 0.183878138700341 * relAzim_norm;
+  
+    return tansig(sum);
+}
+  
+function layer2(neuron1, neuron2, neuron3, neuron4, neuron5) {
+    var sum =
+      + 1.096963107077220
+      - 1.500135489728730 * neuron1
+      - 0.096283269121503 * neuron2
+      - 0.194935930577094 * neuron3
+      - 0.352305895755591 * neuron4
+      + 0.075107415847473 * neuron5;
+  
+    return sum;
+}
+  
+function normalize(unnormalized, min, max) {
+    return 2 * (unnormalized - min) / (max - min) - 1;
+}
+
+function denormalize(normalized, min, max) {
+    return 0.5 * (normalized + 1) * (max - min) + min;
+}
+  
+function tansig(input) {
+    return 2 / (1 + Math.exp(-2 * input)) - 1; 
+}
+  
+function setup() {
+    return {
+      input: [{
+        bands: [
+            "B03",
+            "B04",
+            "B05",
+            "B06",
+            "B07",
+            "B8A",
+            "B11",
+            "B12",
+            "viewZenithMean",
+            "viewAzimuthMean",
+            "sunZenithAngles",
+            "sunAzimuthAngles"
+        ],
+        units: ["REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "DEGREES", "DEGREES", "DEGREES", "DEGREES"]
+      }],
+      output: [
+          {
+            id: "default",
+            sampleType: "FLOAT32",
+            bands: 1
+          }
+      ]
+    }
+}
+
+function evaluatePixel(sample, scene, metadata, customData, outputMetadata) {
+  const result = evaluatePixelOrig([sample], [scene], metadata, customData, outputMetadata);
+  return result[Object.keys(result)[0]];
+}

scripts/truecolor.js

@@ -0,0 +1,16 @@
+//VERSION=3
+
+function setup() {
+  return {
+      input: [{
+          bands: ["B02", "B03", "B04"]
+      }],
+      output: {
+          bands: 3
+      }
+  };
+}
+
+function evaluatePixel(sample) {
+  return [sample.B04, sample.B03, sample.B02];
+}

senHub.py

@@ -0,0 +1,98 @@
+from sentinelhub import (
+    MimeType,
+    CRS,
+    BBox,
+    SentinelHubRequest,
+    DataCollection,
+    bbox_to_dimensions,
+)
+from oauthlib.oauth2 import BackendApplicationClient
+from requests_oauthlib import OAuth2Session
+
+class SenHub:
+    ''' 
+    Class For handling requests to Senhub API.
+    '''
+    def __init__(self,config,  resolution = 10,
+                data_source = DataCollection.SENTINEL2_L1C,
+                identifier ='default', mime_type = MimeType.TIFF):
+        self.resolution = resolution
+        self.config = config
+        self.setInputParameters(data_source)
+        self.setOutputParameters(identifier, mime_type)
+        self.set_token()
+
+    def setInputParameters(self, data_source):
+        '''
+        Select Source Satellite 
+        '''
+        self.data_source = data_source
+    
+    def setOutputParameters(self,identifier, mime_type):
+        '''
+        Select The return Type of request format and identifier
+        '''
+        self.identifier = identifier
+        self.mime_type = mime_type
+
+    def set_token(self):
+        '''
+        Fetch Tooken from sentinelhub api to be used for available dates 
+        '''
+        client_id = self.config.sh_client_id
+        client_secret = self.config.sh_client_secret
+        client = BackendApplicationClient(client_id=client_id)
+        oauth = OAuth2Session(client=client)
+        token = oauth.fetch_token(token_url='https://services.sentinel-hub.com/oauth/token',client_secret=client_secret)
+        self.token =  token['access_token']
+
+    def get_input_data(self, date):
+        '''
+        Wrap input_data to provide to the sentinelhub API
+        '''
+        return SentinelHubRequest.input_data(data_collection=self.data_source, time_interval=(date, date))
+
+    def get_output_data(self):
+        '''
+        Wrap output_data to provide to the sentinelhub API
+        '''
+        return SentinelHubRequest.output_response(self.identifier, self.mime_type)
+        
+    def set_dir(self, dir_path):
+        '''
+        Set The Tragt Download Directory Path
+        '''
+        self.dir_path = dir_path
+
+    def make_bbox(self, bbox):
+        '''
+        Wrap bbox to provide to the sentinelhub API.
+        '''
+        self.bbox = BBox(bbox=bbox, crs=CRS.WGS84)
+        self.bbox_size = bbox_to_dimensions(self.bbox, resolution=self.resolution)
+                
+    def make_request(self, metric, date):
+        '''
+        Setup the Sentinal Hub Request
+        '''
+        input_data = self.get_input_data(date)
+        output_data = self.get_output_data()
+        self.request = SentinelHubRequest(
+            data_folder=self.dir_path,
+            evalscript=metric,
+            input_data=[input_data],
+            responses=[output_data],
+            bbox=self.bbox,
+            size=self.bbox_size,
+            config=self.config,
+            )
+
+    def download_data(self, save=True , redownload=False):
+        '''
+        Make The Request and download the data
+        '''
+        return self.request.get_data(save_data=save, redownload=redownload)
+
+
+
+

test.py

@@ -0,0 +1,43 @@
+import streamlit as st
+
+# Set page configuration
+st.set_page_config(
+    page_title="Your App Title",
+    page_icon=":shark:",
+    layout="wide",  # Use "wide" for expanded layout
+    initial_sidebar_state="expanded",
+)
+
+# def local_css(file_name):
+#     with open(file_name) "r") as f:
+#         st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+# Write CSS to apply styles
+def custom_css():
+    st.markdown("""
+        <style>
+            html, body, [data-testid="stAppViewContainer"] {
+                background-color: #000000;  /* Black background */
+                color: #FFFFFF;  /* White text color */
+            }
+            .stTextInput > label, .stSelectbox > label, .stRadio > label, .stCheckbox > label {
+                color: #CCCCCC;  /* Lighter text for better contrast */
+            }
+            /* Additional styling can be added here */
+        </style>
+        """, unsafe_allow_html=True)
+
+# Load CSS file (if you have a CSS file you prefer to use)
+# local_css("styles.css")
+
+# Apply custom CSS
+custom_css()
+
+# Your app code
+st.title("Your Streamlit App")
+st.write("This is a sample app with a black background.")
+
+# Example of other components
+st.text_input("Enter some text")
+st.selectbox("Choose an option", ["Option 1", "Option 2", "Option 3"])
+st.checkbox("Check me out")

utils.py

@@ -0,0 +1,205 @@
+import os
+import folium
+import confuse
+import numpy as np
+from math import isnan
+import geopandas as gpd
+from shapely.geometry import Point
+from PIL import Image
+from tqdm import tqdm
+
+# Initialzie custom basemaps for folium
+basemaps = {
+    'Google Maps': folium.TileLayer(
+        tiles = 'https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}',
+        attr = 'Google',
+        name = 'Google Maps',
+        overlay = True,
+        control = True
+    ),
+    'Google Satellite': folium.TileLayer(
+        tiles = 'https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}',
+        attr = 'Google',
+        name = 'Google Satellite',
+        overlay = True,
+        control = True
+    ),
+    'Google Terrain': folium.TileLayer(
+        tiles = 'https://mt1.google.com/vt/lyrs=p&x={x}&y={y}&z={z}',
+        attr = 'Google',
+        name = 'Google Terrain',
+        overlay = True,
+        control = True
+    ),
+    'Google Satellite Hybrid': folium.TileLayer(
+        tiles = 'https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}',
+        attr = 'Google',
+        name = 'Google Satellite',
+        overlay = True,
+        control = True
+    ),
+    'Esri Satellite': folium.TileLayer(
+        tiles = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
+        attr = 'Esri',
+        name = 'Esri Satellite',
+        overlay = True,
+        control = True
+    ),
+    'openstreetmap': folium.TileLayer('openstreetmap'),
+    'cartodbdark_matter': folium.TileLayer('cartodbdark_matter')
+}
+
+
+# Dictionary of JavaScript files (More Readable)
+scripts_dir = './scripts/'
+scripts_files = [f for f in os.listdir(scripts_dir) if f.endswith('.js')]
+Scripts = {}
+for f in scripts_files:
+    key = f.split('.')[0].upper()
+    with open(scripts_dir + f) as f:
+        Scripts[key] = f.read()
+
+def calculate_bbox(df, field):
+    '''
+    Calculate the bounding box of a specfic field  ID in a  given data frame
+    '''
+    bbox = df.loc[df['name'] == field].bounds
+    r = bbox.iloc[0]
+    return [r.minx, r.miny, r.maxx, r.maxy]
+
+def tiff_to_geodataframe(im, metric, date, crs):
+    '''
+    Convert a tiff image to a geodataframe
+    '''
+    x_cords = im.coords['x'].values
+    y_cords = im.coords['y'].values
+    vals = im.values
+    dims = vals.shape
+    points = []
+    v_s = []
+    for lat in range(dims[1]):
+        y = y_cords[lat]
+        for lon in range(dims[2]):
+            x = x_cords[lon]
+            v = vals[:,lat,lon]
+            if isnan(v[0]):
+                continue
+            points.append(Point(x,y))
+            v_s.append(v.item())   
+    d = {f'{metric}_{date}': v_s, 'geometry': points} 
+    df = gpd.GeoDataFrame(d, crs = crs)
+    return df
+
+def get_bearer_token_headers(bearer_token):
+    '''
+    Get the bearer token headers to be used in the request to the SentinelHub API
+    '''
+    headers = {
+    'Content-Type': 'application/json',
+    'Authorization': 'Bearer '+ bearer_token,
+    }
+    return headers
+
+def get_downloaded_location_img_path(clientName, metric, date, field, extension='tiff'):
+    '''
+    Get the path of the downloaded image in TIFF based on the:
+    '''
+    date_dir = f'./{clientName}/raw/{metric}/{date}/field_{field}/'
+    print(f'True Color Date Dir: {date_dir}')
+    os.makedirs(date_dir, exist_ok=True)
+    intermediate_dirs = os.listdir(date_dir)
+    print(f'Intermediate Dirs: {intermediate_dirs}')
+    if len(intermediate_dirs) == 0:
+        return None
+    imagePath = f'{date_dir}{os.listdir(date_dir)[0]}/response.{extension}'
+    print(f'Image Path: {imagePath}')
+    if not os.path.exists(imagePath):
+        return None
+    print(f'Image Path: {imagePath}')
+    return imagePath
+
+def get_masked_location_img_path(clientName, metric, date, field):
+    '''
+    Get the path of the downloaded image after applying the mask in TIFF based on the:
+    '''
+    date_dir = f'./{clientName}/processed/{metric}/{date}/field_{field}/'
+    imagePath = date_dir + 'masked.tiff'
+    return imagePath
+
+def get_curated_location_img_path(clientName, metric, date, field):
+    '''
+    Get the path of the downloaded image after applying the mask and converting it to geojson formay based on the:
+    '''
+    date_dir = f'./{clientName}/curated/{metric}/{date}/field_{field}/'
+    imagePath = date_dir + 'masked.geojson'
+
+    if os.path.exists(imagePath):
+        return imagePath
+    else:
+        return None
+
+def parse_app_config(path=r'config-fgm-dev.yaml'):
+    config = confuse.Configuration('CropHealth', __name__)
+    config.set_file(path)
+    return config
+
+
+def fix_image(img):
+    def normalize(band):
+        band_min, band_max = (band.min(), band.max())
+        return ((band-band_min)/((band_max - band_min)))
+    def brighten(band):
+        alpha=3
+        beta=0
+        return np.clip(alpha*band+beta, 0,255)
+    def gammacorr(band):
+        gamma=0.9
+        return np.power(band, 1/gamma)
+    red   = img[:, :, 0]
+    green = img[:, :, 1]
+    blue  = img[:, :, 2]
+    red_b=brighten(red)
+    blue_b=brighten(blue)
+    green_b=brighten(green)
+    red_bg=gammacorr(red_b)
+    blue_bg=gammacorr(blue_b)
+    green_bg=gammacorr(green_b)
+    red_bgn = normalize(red_bg)
+    green_bgn = normalize(green_bg)
+    blue_bgn = normalize(blue_bg)
+    rgb_composite_bgn= np.dstack((red_b, green_b, blue_b))
+    return rgb_composite_bgn
+
+
+def creat_gif(dataset, gif_name, duration=50):
+    '''
+    Create a gif from a list of images
+    '''
+    imgs = [Image.fromarray((255*img).astype(np.uint8)) for img in dataset]
+    # duration is the number of milliseconds between frames; this is 40 frames per second
+    imgs[0].save(gif_name, save_all=True, append_images=imgs[1:], duration=duration, loop=1)
+
+
+def add_lat_lon_to_gdf_from_geometry(gdf):
+    gdf['Lat'] = gdf['geometry'].apply(lambda p: p.x)
+    gdf['Lon'] = gdf['geometry'].apply(lambda p: p.y)
+    return gdf
+
+def gdf_column_to_one_band_array(gdf, column_name):
+    gdf = gdf.sort_values(by=['Lat', 'Lon'])
+    gdf = gdf.reset_index(drop=True)
+    unique_lats_count = gdf['Lat'].nunique()
+    unique_lons_count = gdf['Lon'].nunique()
+    rows_arr = [[] for i in range(unique_lats_count)]
+    column_values = gdf[column_name].values
+    for i in tqdm(range(len(column_values))):
+        row_index = i // unique_lons_count
+        rows_arr[row_index].append(column_values[i])
+
+    max_row_length = max([len(row) for row in rows_arr])
+    for row in rows_arr:
+        while len(row) < max_row_length:
+            row.append(0)
+
+    rows_arr = np.array(rows_arr)
+    return rows_arr