working on instructions

pages/01-main.py

@@ -71,7 +71,7 @@ from data_vizui import EarthEngineDataVizUI
 from map_visuals import MapVizUI
 from export_ui import ExportUI
 from ee_cnn import CNN 
-
+import instructions
 running = solara.reactive(False)
 status_message = solara.reactive("Ready to start.")
 timer_value = solara.reactive(0)
@@ -223,8 +223,7 @@ def CombinedThread(running, timer_value,t1, elapsed_time, status_message, availa
     result = solara.use_thread(thread_function, dependencies=[running.value])
 
 
-
-
+    
 
 
 @solara.component
@@ -251,7 +250,7 @@ def Page():
                         ]),
                         v.ExpansionPanel(children=[
                             v.ExpansionPanelHeader(children=['How To Duplicate Space']),
-                            v.ExpansionPanelContent(children=[' How to Duplicate and run on huggingface or  git clone and run local. Earth Engine Account Requirements and Creating a Service Key.'])
+                            v.ExpansionPanelContent(children=[instructions.EEInstructions(), instructions.HFInstructions(), instructions.AltInstructions()])
                             ]),
                             v.ExpansionPanel(children=[
                                 v.ExpansionPanelHeader(children=['References']),
@@ -338,7 +337,7 @@ Adjustable x-axis and categories''')
                                             'cursor': 'pointer',
                                             'transition': 'background-color 0.3s ease'
                                         })
-        solara.Warning('Caution the option "Earth Engine Imagery" for A WORLD Region takes approx. 4 Min and blocks any other functionality until completed.')
+        solara.Warning('Caution the option "Earth Engine Image" for A WORLD Region takes approx. 4 Min and blocks any other functionality until completed.')
         map_vis = MapVizUI(model_data.value, data_flag.value, coordinates=vis_coordinates.value,country=vis_country.value)
     
 

public/instructions.py

@@ -0,0 +1,61 @@
+import reacton.ipyvuetify as v
+import solara
+
+image1 = solara.Image('public\dots.png')
+image2 = solara.Image('public\dup_space.png')
+image3 = solara.Image('public\secrets.png')
+
+@solara.component
+def EEInstructions():
+    Text = solara.Markdown(''' 
+Adapted from: <a href="https://developers.google.com/earth-engine/guides/service_account#create-a-service-account" target="_blank">https://developers.google.com/earth-engine/guides/service_account#create-a-service-account</a>                           
+### 1. Register a Google account with Earth Engine here:
+                           
+<a href="https://code.earthengine.google.com/register" target="_blank">https://code.earthengine.google.com/register</a>
+                           
+### 2. Create a service account:
+First, <a href="https://developers.google.com/earth-engine/cloud/earthengine_cloud_project_setup#create-a-cloud-project" target="_blank">create a Google Cloud project</a> if you have not already done so.
+
+You can manage the service accounts for your Cloud project by going to the Cloud Console menu (blue square w/ three stacked white bars) and selecting IAM & Admin > <a href="https://console.cloud.google.com/projectselector2/iam-admin/serviceaccounts?supportedpurview=project" target="_blank">Service accounts</a>. (Choose the project if prompted.)
+
+To create a new service account, click the<a href="https://console.cloud.google.com/projectselector2/iam-admin/serviceaccounts/create?supportedpurview=project" target="_blank">+ CREATE SERVICE ACCOUNT</a>  link.
+
+### 3. Create a private key for the service account:
+Once you have a service account, click the menu for that account (three dots stacked), then Create key > JSON. Download the JSON key file.
+
+''')
+    v.ExpansionPanels(children=[
+                    v.ExpansionPanel(children=[
+                        v.ExpansionPanelHeader(children=['Earth Engine Requirements']),
+                        v.ExpansionPanelContent(children=[Text
+    ])
+                            ])])
+
+@solara.component
+def HFInstructions():
+    
+    Text = solara.Markdown(f'### 1. First Click on the the three dots:{image1}2. Second Click on Duplicate Space{image2}3. Input Secrets - You should have your Earth Engine json details ready, a word of caution when copying and pasting check that the spacing is correct and has only one tab space{image3}')
+    
+ 
+
+    v.ExpansionPanels(children=[
+                    v.ExpansionPanel(children=[
+                        v.ExpansionPanelHeader(children=['Hugging Face Requirements']),
+                        v.ExpansionPanelContent(children=[Text
+    ])
+                            ])])
+@solara.component
+def AltInstructions():
+    Text = solara.Markdown(''' 
+### 1. Earth Engine
+Explain still need EE account, can modify code to accept authenticate instead
+                           
+### 2. pip install 
+### 3. Colab Notebook
+''')
+    v.ExpansionPanels(children=[
+                    v.ExpansionPanel(children=[
+                        v.ExpansionPanelHeader(children=['Alternatives to Hugging Face']),
+                        v.ExpansionPanelContent(children=[Text
+    ])
+                            ])])

public/map_visuals.py

@@ -14,8 +14,9 @@ from matplotlib.figure import Figure
 from datasets import load_dataset
 from matplotlib.colors import ListedColormap, BoundaryNorm
 import ipywidgets as widgets
-
+import requests
 import solara
+import geedim as gd
 
 class MapVizUI:
     def __init__(self, dataframe, data_flag, coordinates=None, country=None):
@@ -321,8 +322,7 @@ class MapVizUI:
             
 
             elif viz_type == 'Earth Engine Image':
-                print(viz_type)
-                print(selected_option)
+                solara.SpinnerSolara(size="100px")
                 if selected_option == 'All Days' or selected_option == 'Date Range':
                     # Group by latitude and longitude and calculate the mean for each group
                     filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
@@ -511,150 +511,153 @@ class MapVizUI:
                 ax.set_title('Contour Plot of PM2.5 values', fontdict= {'fontsize':40,'fontweight': 'bold'})
                 
                 display(solara.FigureMatplotlib(fig, dependencies= None, format= 'svg'))
+    
+
+        
 
-    @solara.component
-    def MapVizUILayout(self):
 
-        with solara.Column() as main:                    
         
-                    self.DateDropdown(self)
-                    self.StartDateDropdown(self)
-                    self.EndDateDropdown(self)
-                    self.VizTypeDropdown(self)
-                    self.ValueTypeDropdown(self)
-                    self.HourDropdown(self)
-                    self.GeneratePlotButton(self)
-                    display(self.output)
+    def csv_download(self):
+        compression_opts = dict(method='zip', archive_name='model_results.csv')
+        model_results =  self.dataframe.to_csv('model_results.csv',index = True, compression=compression_opts)
+        solara.FileDownload(model_results, mime_type="application/zip") 
+       
+    '''def tiff_download(self):
 
-                         
-        return main
 
-    def display(self):
-        return self.MapVizUILayout(self)
+        # Filter the dataframe based on user's selection
+        if self.selected_date.value == 'All Days':
+            filtered_df = self.dataframe
+        elif self.selected_date.value == 'Date Range': 
+            start_date = pd.to_datetime(self.startday_options.value)
+            end_date = pd.to_datetime(self.endday_options.value)
+            mask = (self.dataframe.index.date >= start_date) & (self.dataframe.index.date <= end_date)
+            filtered_df = self.dataframe[mask]
+        elif self.selected_date.value == 'Single Day':
+            selected_date = pd.to_datetime(self.endday_options.value)
+            filtered_df = self.dataframe[self.dataframe.index.date == selected_date.date()]
 
-'''def update_data(self):
-    selected_option = self.selected_date.value
-    viz_type = self.selected_viz_type.value
-    
 
-    # Filter the dataframe based on user's selection
-    if selected_option == 'All Days':
-        filtered_df = self.dataframe
-        set_filtered_data(filtered_df)
-        
-    elif selected_option == 'Date Range': 
-        start_date = pd.to_datetime(self.startday_options.value)
-        end_date = pd.to_datetime(self.endday_options.value)
-        mask = (self.dataframe.index.date >= start_date) & (self.dataframe.index.date <= end_date)
-        filtered_df = self.dataframe[mask]
-        set_filtered_data(filtered_df)
-        
-    elif selected_option == 'Single Day':
-        selected_date = pd.to_datetime(self.endday_options.value)
-        filtered_df = self.dataframe[self.dataframe.index.date == selected_date]
-        set_filtered_data(filtered_df)
-        
-    
-    if viz_type == ' Contour Map':
-        if selected_option in ['All Days', 'Date Range']:
-            if self.selected_vtype.value == '24 Hour Average':
-                # Group by latitude and longitude and calculate the mean for each group
-                filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
-                set_filtered_data(filtered_df)
-                
-            else:
-                hour = int(self.self.hour_options.value[:2])  # Extract the hour value from the string
-                filtered_df = filtered_df[filtered_df.index.hour == hour]
-                set_filtered_data(filtered_df)
-                
 
-        elif selected_option == 'Single Day':
-            if self.selected_vtype.value == '24 Hour Average':
+
+        if self.selected_date.value == 'All Days' or self.selected_date.value == 'Date Range':
+            # Group by latitude and longitude and calculate the mean for each group
+            filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
+        elif self.selected_date.value == 'Single Day':
+            if self.selected_vtype.value != '24 Hour Average':
+                hour_minute = self.hour_options.value.split(':')  # This will give ['17', '30'] for '17:30'
+                hour = int(hour_minute[0])  # Extract the hour value
+                minute = int(hour_minute[1])  # Extract the minute value
+                filtered_df = filtered_df[(filtered_df.index.hour == hour) & (filtered_df.index.minute == minute)]
+            else:
                 # Group by latitude and longitude and calculate the mean for the whole day
                 filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
-                set_filtered_data(filtered_df)
+
                 
-            else:
-                hour = int(self.self.hour_options.value[:2])  # Extract the hour value from the string
-                filtered_df = filtered_df[filtered_df.index.hour == hour]
-                set_filtered_data(filtered_df)
+        # Check if filtered_df is empty
+        if filtered_df.empty:
+            print("No data available for the selected criteria.")
+            return
+
+        filtered_df.rename(columns={"PM2.5": "PM25"}, inplace=True)
+        if 'Hour' in filtered_df.columns:
+            filtered_df = filtered_df.drop(columns=['Hour'])
+
+
+
+
+        # Calculate the extent of the data
+        min_lat, max_lat = filtered_df['lat'].min(), filtered_df['lat'].max()
+        min_lon, max_lon = filtered_df['lon'].min(), filtered_df['lon'].max()
+        # Predefined latitude and longitude bands
+        lat_bands = [[-90, 0], [0, 90]]
+        lon_bands = [[-180, -108], [-108, -36], [-36, 36], [36, 108], [108, 180]]
+
+        # Create subsets based on the predefined bands
+        subsets = []
+        for lat_band in lat_bands:
+            for lon_band in lon_bands:
+                subset = filtered_df[
+                    (filtered_df['lat'] >= lat_band[0]) & (filtered_df['lat'] <= lat_band[1]) &
+                    (filtered_df['lon'] >= lon_band[0]) & (filtered_df['lon'] <= lon_band[1])
+                ]
+                subsets.append(subset)
+
+
+
+        # Initialize an empty ImageCollection
+        image_collection = ee.ImageCollection([])
+        
+        # Process each subset
+        for idx, subset in enumerate(subsets):
+            
+            print(f'Processing subset {idx+1}...')
+
+            if not subset.empty:
+                # Convert the DataFrame subset to an Earth Engine FeatureCollection
+                ee_fc = geemap.df_to_ee(subset, latitude='lat', longitude='lon')
+                # Convert the FeatureCollection to an Image for V8
+                v8_image = ee.Image(ee_fc.reduceToImage(['PM25'], ee.Reducer.first()))               
+
+
+                # Define a crsTransform for the desired pixel size
+                pixel_size = .63
+                crs_transform = [pixel_size, 0, min_lon, 0, -pixel_size, max_lat]
                 
+                # Reproject the image
+                v8_image_pixels = v8_image.reproject(crs='EPSG:4326', crsTransform=crs_transform)
+                
+                # Add the image to the ImageCollection
+                image_collection = image_collection.merge(ee.ImageCollection([v8_image_pixels]))
+                
+
         
+
         
-    elif viz_type == 'Heat map':
-            if selected_option in ['All Days', 'Date Range']:
-                # Group by latitude and longitude and calculate the mean for each group
-                filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
-                set_filtered_data(filtered_df)
+        if not self.world:
+            # Reduce the ImageCollection to a single image
+            combined_image = image_collection.mosaic()
+           # Define a custom region of interest (as an example)
+            region = ee.Geometry.Rectangle([min_lon, min_lat, max_lon, max_lat])
+
+            geemap.download_ee_image(
+                image=combined_image,
+                filename='model_result.tiff',
+                overwrite=True,
+                crs='EPSG:4326',
+                crs_transform=crs_transform,
+                region=region,
+                scale=30
+            )
+
+        else:
+            
+            # Generate a download URL
+            geemap.download_ee_image_collection(
+                collection=image_collection,
+                out_dir='C:/Users/bsf31/Documents/post-meds/huggingface/USRA-STI/public',
+                overwrite=True
+            )'''
+
+
+    @solara.component
+    def MapVizUILayout(self):
+
+        with solara.Column() as main:
+            self.DateDropdown(self)
+            self.StartDateDropdown(self)
+            self.EndDateDropdown(self)
+            self.VizTypeDropdown(self)
+            self.ValueTypeDropdown(self)
+            self.HourDropdown(self)
+            self.GeneratePlotButton(self)
+            display(self.output)
+            with solara.Row():
                 
-            elif selected_option == 'Single Day':
-                if self.selected_vtype.value != '24 Hour Average':
-                    hour = int(self.self.hour_options.value[:2])  # Extract the hour value from the string
-                    filtered_df = filtered_df[filtered_df.index.hour == hour]
-                    set_filtered_data(filtered_df)
-                    
-                else:
-                    # Group by latitude and longitude and calculate the mean for the whole day
-                    filtered_df = filtered_df.groupby(['lat', 'lon'])['PM2.5'].mean().reset_index()
-                    set_filtered_data(filtered_df)
-                    
-        filtered_data, set_filtered_data = solara.use_state(self.dataframe)  # Initially, it's the whole dataframe
-        flag = solara.use_reactive(False)
-            filtered_df.rename(columns={"PM2.5": "PM25"}, inplace=True)
-            set_filtered_data(filtered_df)
-             with solara.Card('Maps'):
-                        with solara.Row():
-                            with solara.lab.Tabs():
-                                        with solara.lab.Tab('Contour Plot'):
-                                            with solara.Card(elevation=10, margin= 10):
-                                                
-
-
-                                                # Extract lats, lons, and values AFTER filtering
-                                                lats = filtered_data['lat'].values
-                                                lons = filtered_data['lon'].values
-                                                values = filtered_data['PM2.5'].values
-                                                # Custom color palette and breakpoints
-                                                palette = ['green', 'yellow', 'orange', 'red', 'purple', 'maroon', 'maroon']
-                                                aqi_breakpoints = [0, 50, 100, 150, 200, 300, 500]
-                                                plt.rcParams['font.size'] = 30
-                                                # Create a colormap and normalization based on your palette and breakpoints
-                                                cmap = ListedColormap(palette)
-                                                norm = BoundaryNorm(aqi_breakpoints, cmap.N)
-
-
-                                                # Create a figure and axis using the object-oriented interface
-                                                fig = Figure(figsize=(20, 10), dpi= 500, edgecolor='black', linewidth = 1, frameon= True)
-
-                                                ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree())
-
-                                                # Set the extent
-                                                ax.set_extent(self.get_map_extent())
-
-                                                # Add features to the map
-                                                ax.add_feature(cfeature.COASTLINE)
-                                                ax.add_feature(cfeature.BORDERS, linestyle=':')
-                                                ax.gridlines(draw_labels=True)
-
-                                                # Create the contour plot
-                                                contour = ax.tricontourf(lons, lats, values, transform=ccrs.PlateCarree(), cmap=cmap, norm = norm)
-
-                                                # Add a colorbar
-                                                cbar = fig.colorbar(contour, ax=ax, orientation='vertical', pad = 0.1, ticks=aqi_breakpoints)
-                                                cbar.set_label('PM2.5 Value')
-
-                                                # Set the title
-                                                ax.set_title('Contour Plot of PM2.5 values', fontdict= {'fontsize':40,'fontweight': 'bold'})
-                                                
-                                                solara.FigureMatplotlib(fig, dependencies= [filtered_data, flag.value])
-                                
-                                        with solara.lab.Tab('Heat Map'):
-                                            with solara.Card(elevation=10, margin= 10):
-                                                # Initialize a geemap Map
-                                                
-                                                self.Map.add_basemap('CartoDB.Voyager')
-                                                self.Map.set_zoom(1)
-                                                self.Map.add_heatmap(filtered_data, latitude= 'lat', longitude='lon', value= 'PM2.5', radius= 10)
-                                                #Map.layer_opacity("Heat map", opacity = .75)
-                                                
-                                                display(self.Map)  '''
+                solara.Button( 'Download CSV',on_click=self.csv_download, icon_name="mdi-cloud-download-outline", color="orange")
+                #solara.Button('Download TIFF', on_click=self.tiff_download,  outlined =True, icon_name="mdi-cloud-download-outline", color="orange")
+                         
+        return main
+
+    def display(self):
+        return self.MapVizUILayout(self)

requirements.txt

@@ -21,3 +21,4 @@ solara
 pydantic
 leafmap
 datasets
+geedim