import os import sys import time import io import json from pathlib import Path from utils import print_with_line_number # Add the parent directory to the Python path parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(parent_dir) import ee # Add Google Service account credential. Authenticates to the Earth Engine servers. credentials = ee.ServiceAccountCredentials(os.environ.get("SERVICE_EMAIL"), key_data=os.environ.get("SERVICE_JSON")) import math from typing import Optional from shiny import App, render, ui, reactive, Inputs, Outputs, Session, req import ipyleaflet as L from ipywidgets import Layout from htmltools import css import numpy as np import pandas as pd # from PIL import Image from shinywidgets import output_widget, reactive_read, register_widget from geopy.geocoders import Nominatim import json import requests import traceback from datetime import datetime, date from typing import List from timezonefinder import TimezoneFinder # Library for ANN model loading import tensorflow import joblib # Sentinel 2 Bands # Sentinel-2 carries the Multispectral Imager (MSI). This sensor delivers 13 spectral bands ranging from 10 to 60-meter pixel size. # Its blue (B2), green (B3), red (B4), and near-infrared (B8) channels have a 10-meter resolution. # Next, its red edge (B5), near-infrared NIR (B6, B7, and B8A), and short-wave infrared SWIR (B11 and B12) have a ground sampling distance of 20 meters. # Finally, its coastal aerosol (B1) and cirrus band (B10) have a 60-meter pixel size. # Band Resolution Central Wavelength Description # B1 60 m 443 nm Ultra Blue (Coastal and Aerosol) # B2 10 m 490 nm Blue # B3 10 m 560 nm Green # B4 10 m 665 nm Red # B5 20 m 705 nm Visible and Near Infrared (VNIR) # B6 20 m 740 nm Visible and Near Infrared (VNIR) # B7 20 m 783 nm Visible and Near Infrared (VNIR) # B8 10 m 842 nm Visible and Near Infrared (VNIR) # B8a 20 m 865 nm Visible and Near Infrared (VNIR) # B9 60 m 940 nm Short Wave Infrared (SWIR) # B10 60 m 1375 nm Short Wave Infrared (SWIR) - excluded # B11 20 m 1610 nm Short Wave Infrared (SWIR) # B12 20 m 2190 nm Short Wave Infrared (SWIR) tf = TimezoneFinder() # You can use different URLs to load remote sensing image data from various sources # In this example, we use image data from Google Earth Engine GEEurl = 'https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/{mapid}/tiles/{z}/{x}/{y}?token={token}' GEEmap_id = '' # Replace with your Google Earth Engine Map ID GEEtoken = '' # Replace with your Google Earth Engine Token # Custom Loss Function with Covariance Penalty def custom_loss(lam, cov_real_data): def loss(y_true, y_pred): mse_loss = tensorflow.reduce_mean(tensorflow.square(y_true - y_pred)) cov_pred = tensorflow.linalg.matmul(tensorflow.transpose(y_pred - tensorflow.reduce_mean(y_pred, axis=0)), (y_pred - tensorflow.reduce_mean(y_pred, axis=0))) / tensorflow.cast(tensorflow.shape(y_pred)[0], tensorflow.float32) cov_penalty = tensorflow.reduce_sum(tensorflow.square(cov_pred - cov_real_data)) return mse_loss + lam * cov_penalty return loss def load_model_and_preprocessors(model_path, cov_real_data_path, scaler_X_path, scaler_y_path): # Load the covariance matrix cov_real_data = np.load(cov_real_data_path) # Load the trained model model = tensorflow.keras.models.load_model(model_path, custom_objects={'loss': custom_loss(1e-6, cov_real_data)}) # Load the input data scaler scaler_X = joblib.load(scaler_X_path) # Load the output data scaler scaler_Y = joblib.load(scaler_y_path) return model, scaler_X, scaler_Y # Load ANN model and preprocessors model, loaded_scaler_X, loaded_scaler_Y = load_model_and_preprocessors( "ANN_assests/model", "ANN_assests/cov_real_data.npy", "ANN_assests/scaler_X.pkl", "ANN_assests/scaler_y.pkl" ) # Create labels labels = ['Longitude', 'Latitude', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B11', 'B12', 'N', 'Cab', 'Ccx', 'Cw', 'Cm'] X_labels = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B11', 'B12'] output_labels = ["N", "Cab", "Ccx", "Cw", "Cm"] layer_names = ["structure parameter", "Chlorophylla+b content (µg/cm2)", "Carotenoids content (µg/cm2)", "Equivalent Water content (cm)", "Leaf Mass per Area (g/cm2)"] data_to_map = { "structure parameter": "N", "Chlorophylla+b content (µg/cm2)": "Cab", "Carotenoids content (µg/cm2)": "Ccx", "Equivalent Water content (cm)": "Cw", "Leaf Mass per Area (g/cm2)": "Cm" } # gradient_settings = { # "structure parameter": {0.2: 'rgba(0, 0, 255, 1.0)', 0.6: 'rgba(0, 255, 255, 1.0)', 1.0: 'rgba(0, 255, 0, 1.0)'}, # "Chlorophylla+b content (µg/cm2)": {0.2: 'rgba(0, 128, 0, 1.0)', 0.6: 'rgba(127, 255, 0, 1.0)', 1.0: 'rgba(255, 255, 0, 1.0)'}, # "Carotenoids content (µg/cm2)": {0.2: 'rgba(255, 69, 0, 1.0)', 0.6: 'rgba(255, 0, 0, 1.0)', 1.0: 'rgba(139, 0, 0, 1.0)'}, # "Equivalent Water content (cm)": {0.2: 'rgba(0, 0, 139, 1.0)', 0.6: 'rgba(65, 105, 225, 1.0)', 1.0: 'rgba(0, 191, 255, 1.0)'}, # "Leaf Mass per Area (g/cm2)": {0.2: 'rgba(75, 0, 130, 1.0)', 0.6: 'rgba(148, 0, 211, 1.0)', 1.0: 'rgba(255, 20, 147, 1.0)'} # } gradient_parula = { 0.0: 'rgba(128, 0, 128, 1.0)', # purple 0.2: 'rgba(0, 0, 255, 1.0)', # blue 0.4: 'rgba(0, 255, 255, 1.0)', # cyan 0.5: 'rgba(0, 250, 154, 1.0)', # mediumspringgreen 0.6: 'rgba(50, 205, 50, 1.0)', # lime 0.7: 'rgba(173, 255, 47, 1.0)', # greenyellow 0.8: 'rgba(255, 255, 0, 1.0)', # yellow 0.9: 'rgba(255, 165, 0, 1.0)', # orange 1.0: 'rgba(255, 0, 0, 1.0)' # red } gradient_settings = { "structure parameter": gradient_parula, "Chlorophylla+b content (µg/cm2)": gradient_parula, "Carotenoids content (µg/cm2)": gradient_parula, "Equivalent Water content (cm)": gradient_parula, "Leaf Mass per Area (g/cm2)": gradient_parula } print_with_line_number("Finish loading the ANN model!") def runModel(input_data, scaler_X, scaler_Y, ANNmodel): # Preprocess the Input Data # Scale the input features using the previously saved scaler for X input_data_scaled = scaler_X.transform(input_data) # Use the Model for Prediction # Predict the output values (N, Cab, Ccx, Cw, Cm) for each pixel block output_data_scaled = ANNmodel.predict(input_data_scaled) # Post-process the Output Data # Inverse scale the output data using the previously saved scaler for Y output_data = scaler_Y.inverse_transform(output_data_scaled) # Organize the Output Results and Coordinates # Create datasets for each output label and one for coordinates # Each dataset contains corresponding data for all pixel blocks datasets = {} for i, label in enumerate(output_labels): datasets[label] = output_data[:, i] # Print the results for verification for label, data in datasets.items(): print(label, data) return datasets gpsurl = 'https://www.googleapis.com/geolocation/v1/geolocate?key=' + os.environ.get("GMAP_TOKEN") def getGPS(): GPSurl = gpsurl data = {'homeMobileCountryCode': 310, 'homeMobileNetworkCode': 410, 'considerIp': 'True'} response = requests.post(GPSurl, data=json.dumps(data)) result = json.loads(response.content) return result def get_location(lat, lon): geolocator = Nominatim(timeout=120, user_agent="when-to-fly") location = geolocator.reverse(f"{lat},{lon}") return location.address app_ui = ui.page_fluid( ui.div( ui.strong("Tips:"), ui.br(), ui.span("1.Click the polygon icon on the map to draw a polygon, the circular icon to mark a location, the line icon to measure distance, and the icon in the top right corner of the map to select the layers you want to display."), ui.br(), ui.span("2.After selecting an area, click the 'Analyze' button to analyze the leaf-level feature data for that area. The results are presented as heat maps, with brighter areas indicating values closer to the maximum."), ui.br(), ui.span("3.Currently, the analysis does not support multiple polygons. The application will only recognize the last polygoned area."), ui.br(), ui.span("4.After analyzing the data of the drawn area, the webpage may experience slower loading speeds and delays. Please be patient and wait after performing an operation."), ui.br(), ui.strong("If you are unable to zoom in or out of the map using the mouse scroll wheel, please use the slide bar provided above to zoom directly.", style="color: green;"), ui.br(), ui.strong("We strongly recommend that you use a smaller scale to view the heat map (17 or 18 zoom level), as it will retain more details.", style="color: red;"), ui.br(), ui.strong("Please do not use the computer's touchscreen to zoom in on the map, as this can cause errors.", style="color: red;") ), ui.layout_sidebar( ui.panel_sidebar( ui.div( ui.div( ui.input_date("date", "Date:"), ui.input_slider("zoom", "Map zoom level", value=12, min=1, max=18), ), ui.div( ui.input_numeric("lat", "Latitude", value=38.53667742), ui.input_numeric("long", "Longitude", value=-121.75387309), ), style=css(display="flex", justify_content="center", align_items="center", gap="1rem"), ), ), ui.panel_main( ui.div( ui.output_text("N_range"), ui.output_text("Cab_range"), ui.output_text("Ccx_range"), ui.output_text("Cw_range"), ui.output_text("Cm_range"), style=css(display="flex", justify_content="center", align_items="center", gap="2rem"), ), ui.img(src="legend.png"), ), ), output_widget("map"), ui.strong("Must analyze (to renew the image information) before downloading any file.", style="color: green;"), ui.div( ui.input_action_button("analyze", "Analyze", class_="btn-success"), ui.download_button("download_polygon", "Download spectral data as tif", class_="btn-success"), ui.download_button("download_output", "Download spectral and output data as csv", class_="btn-success"), style=css(display="flex", justify_content="center", align_items="center", gap="2rem"), ), ) # re-run when a user using the application def server(input, output, session): # Initialize Earth Engine ee.Initialize(credentials) global address_line, polygoned_image, output_df address_line = None polygoned_image = None polygon_data = reactive.Value([]) output_df = pd.DataFrame() N = reactive.Value("structure parameter") Cab = reactive.Value("Chlorophylla+b content (µg/cm2)") Ccx = reactive.Value("Carotenoids content (µg/cm2)") Cw = reactive.Value("Equivalent Water content (cm)") Cm = reactive.Value("Leaf Mass per Area (g/cm2)") m = ui.modal( "Please wait for progress...", easy_close=False, size="s", footer=None, fade=True ) @output @render.text def N_range(): return N.get() @output @render.text def Cab_range(): return Cab.get() @output @render.text def Ccx_range(): return Ccx.get() @output @render.text def Cw_range(): return Cw.get() @output @render.text def Cm_range(): return Cm.get() def handle_draw(self, action, geo_json): print("运行handle_draw") if geo_json['type'] == 'Feature': # Check if the drawn shape is a polygon if geo_json['geometry']['type'] == 'Polygon': # Get the coordinates of the polygon's vertices coordinates = geo_json['geometry']['coordinates'][0] # Extract latitude and longitude values from each vertex # For GeoJSON, coordinates are represented as [longitude, latitude] # (note the reverse order compared to traditional [latitude, longitude]) polygon_data.set([(lon, lat) for lon, lat in coordinates]) # Process the polygon_data as per your requirement # For example, print the coordinates print("Polygon Vertex Coordinates:") for lon, lat in polygon_data.get(): print(f"Latitude: {lat}, Longitude: {lon}") ui.modal_show(m) # Check API status asset_roots = ee.data.getAssetRoots() if asset_roots: print("API is connected and working.") else: print("API is not connected or not working.") try: # Get the user's current geoinformation current_gps = getGPS() print_with_line_number(current_gps) current_location = get_location(current_gps['location']['lat'], current_gps['location']['lng']) print_with_line_number(current_location) ui.update_text(id="address", label="Data for", value=current_location) # Initialize and display when the session starts (1) map = L.Map(center=(current_gps['location']['lat'], current_gps['location']['lng']), zoom=12, scroll_wheel_zoom=True) map.layout = Layout(height='600px') @reactive.isolate() def update_text_inputs(lat: Optional[float], long: Optional[float]) -> None: req(lat is not None, long is not None) lat = round(lat, 8) long = round(long, 8) if lat != input.lat(): input.lat.freeze() ui.update_text("lat", value=lat) if long != input.long(): input.long.freeze() ui.update_text("long", value=long) map.add_layer(L.TileLayer(url='https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}', name='Natural Map')) # Add a distance scale map.add_control(L.leaflet.ScaleControl(position="bottomleft")) layer_control = L.LayersControl(position='topright') map.add_control(layer_control) # Add the DrawControl widget to the map draw_control = L.DrawControl( polygon = { "shapeOptions": { "fillColor": "transparent", "fillOpacity": 0.0 } } ) map.add_control(draw_control) # Attach the handle_draw function to the on_draw event draw_control.on_draw(handle_draw) register_widget("map", map) ui.modal_remove() except Exception as e: ui.modal_remove() error_modal = ui.modal( str(e), title="An Error occured. Please refresh", easy_close=True, size="xl", footer=None, fade=True ) # print_with_line_number("Show error modal") ui.modal_show(error_modal) traceback.print_exc() # When the slider changes, update the map's zoom attribute (2) @reactive.Effect def _(): map.zoom = input.zoom() # When zooming directly on the map, update the slider's value (2 and 3) @reactive.Effect def _(): ui.update_slider("zoom", value=reactive_read(map, "zoom")) @reactive.Effect def location(): """Returns tuple of (lat,long) floats--or throws silent error if no lat/long is selected""" # Require lat/long to be populated before we can proceed req(input.lat() is not None, input.long() is not None) try: long = input.long() # Wrap longitudes so they're within [-180, 180] long = (long + 180) % 360 - 180 if round(map.center[0], 8) == input.lat() and round(map.center[1], 8) == long: return map.center = (input.lat(), long) except ValueError as e: error_modal = ui.modal( str(e), title="Invalid latitude/longitude specification. Please refresh", easy_close=True, size="xl", footer=None, fade=True ) # print_with_line_number("Show error modal") ui.modal_show(error_modal) traceback.print_exc() # Everytime the map's bounds change, update the output message (3) # rerun when a user do some reactive changes. @reactive.Effect def map_bounds(): center = reactive_read(map, "center") if len(center) == 0: return lon = (center[1] + 180) % 360 - 180 update_text_inputs(center[0], lon) def update_or_create_heatmaps(output_datasets, scale): """ Check if a heatmap layer exists for each dataset in output_datasets. If it exists, update the heatmap, otherwise create a new heatmap. Parameters: output_datasets (list of dict): The datasets for creating/updating heatmaps """ # Iterate over each dataset in output_datasets existing_layers = {layer.name: layer for layer in map.layers} print_with_line_number(existing_layers) for layer_name in layer_names: # Check if a heatmap layer with this name already exists if layer_name in existing_layers: print("deleting ", layer_name) map.remove_layer(existing_layers[layer_name]) heatmap_data = [] data_values = output_datasets[data_to_map[layer_name]] q03 = np.percentile(data_values, 3) q97 = np.percentile(data_values, 97) min_value = min(data_values) if min_value < 0: min_value = 0 max_value = max(data_values) if (data_to_map[layer_name] == "N"): N.set(layer_name + ": " + str(min_value) + " ~ " + str(max_value)) elif (data_to_map[layer_name] == "Cab"): Cab.set(layer_name + ": " + str(min_value) + " ~ " + str(max_value)) elif (data_to_map[layer_name] == "Ccx"): Ccx.set(layer_name + ": " + str(min_value) + " ~ " + str(max_value)) elif (data_to_map[layer_name] == "Cw"): Cw.set(layer_name + ": " + str(min_value) + " ~ " + str(max_value)) else: Cm.set(layer_name + ": " + str(min_value) + " ~ " + str(max_value)) for coord, n in zip(output_datasets["Coordinates"], data_values): # normalized_value = (n - min_value) / (max_value - min_value) if n <= q03: normalized_value = 0 elif n >= q97: normalized_value = 1 else: normalized_value = (n - q03) / (q97 - q03) heatmap_data.append([coord[1], coord[0], normalized_value]) # Generate new heatmap for this dataset heatmap = L.Heatmap( locations=heatmap_data, radius=scale * 1.4, gradient=gradient_settings[layer_name], max=1, blur=scale / 2, name=layer_name ) # Add the new heatmap layer to the map map.add_layer(heatmap) @reactive.Effect @reactive.event(input.analyze, ignore_none=True, ignore_init=True) def _(): global output_df if not polygon_data.get(): return ui.modal_show(m) global polygoned_image polygon = ee.Geometry.Polygon(polygon_data.get()) print("Polygon Data: " , polygon_data.get()) print("Polygon: " , polygon) # Define Sentinel-2 image collection ("2021-01-01", "2021-12-31") current_date = input.date() today = ee.Date(input.date().strftime('%Y-%m-%d')) start_date = today.advance(-15, 'day') print("Start Date: ", start_date.format('YYYY-MM-dd').getInfo(), "| End Date: ", today.format('YYYY-MM-dd').getInfo()) sentinel2 = ee.ImageCollection("COPERNICUS/S2_SR")\ .filterDate(start_date, today)\ .filterBounds(polygon)\ .sort('CLOUDY_PIXEL_PERCENTAGE', True) # .first() # Retrieve the first image from the ImageCollection # sentinel2 = sentinel2.sort('CLOUDY_PIXEL_PERCENTAGE', True) polygoned_image = sentinel2.first() # Make sure the polygoned_image is available if not polygoned_image: print("No image available for download.") return retry = 5 while(sentinel2.size().getInfo() == 0): if(retry == 0): ui.update_date("date", label="Date:", value=current_date) ui.modal_remove() error_modal = ui.modal( "Please do not choose a date that is too far in the future. This application will search for remote sensing data within the two weeks prior to the selected date.", title="Something wrong happened, try \"Analyze\" again ", easy_close=True, size="xl", footer=None, fade=True ) ui.modal_show(error_modal) print("fail to fecth image.") return print("wait for fetching.") time.sleep(2) retry -= 1 print_with_line_number("Type of sentinel2: " + str(type(sentinel2))) print("Counts of Fetched image: ", sentinel2.size().getInfo()) # Clip the image to the extent of the polygon clipped_image = polygoned_image.clip(polygon) # Get meta data about the image object # bands = clipped_image.bandNames().getInfo() # print_with_line_number(bands) # Calculate suitable pixel number. GEE service allow fecthing 5000 pixels at most for one call. So we use the "polygoned area / 4999" to decide a rational pixel scale. scale=1 polygon_area = polygon.area().getInfo() num = math.ceil(polygon_area / scale / scale) if (num > 4999): per_area = math.ceil(polygon_area / 4998) scale = math.ceil(math.pow(per_area, 1.0/2)) print("polygon_area(m2): ", polygon_area, "scale: ", scale) # Fetch reflectance of B1-B12 spectral_values = clipped_image.select('B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B8A', 'B9', 'B11', 'B12').sample( region=polygon, scale=scale, numPixels=4999, geometries=True ) print_with_line_number("Pre-process the bands data.") # print_with_line_number(type(spectral_values)) spectral_values = spectral_values.getInfo() # print_with_line_number(type(spectral_values)) spectral_values_json = json.dumps(spectral_values) # print(spectral_values_json) spectral_values_dict = json.loads(spectral_values_json) features = spectral_values_dict['features'] print_with_line_number("Extract the center coordinates and values of B1-B12 for each pixel block") coords = [] input_data = [] for feature in features: coords.append(feature['geometry']['coordinates']) props = feature['properties'] input_data.append([props[b] for b in X_labels]) # Convert to NumPy arrays coords = np.array(coords) # print("coords: ", coords) input_data = np.array(input_data) # print("input_bands: ", input_data) output_datasets = runModel(input_data, loaded_scaler_X, loaded_scaler_Y, model) # Combine all data data_combined = np.column_stack((coords, input_data, output_datasets['N'], output_datasets['Cab'], output_datasets['Ccx'], output_datasets['Cw'], output_datasets['Cm'])) # Convert to DataFrame output_df = pd.DataFrame(data_combined, columns=labels) print_with_line_number("Add a dataset for the coordinates") output_datasets['Coordinates'] = coords update_or_create_heatmaps(output_datasets, scale) register_widget("map", map) ui.modal_remove() @reactive.Effect def _(): print("Current navbar page: ", input.navbar_id()) @session.download( filename=lambda: f"image-{input.date().isoformat()}-{np.random.randint(100, 999)}.tif" ) async def download_polygon(): # # Replace this with your ee.Image object # image_id = "COPERNICUS/S2_SR/20230728T184921_20230728T190044_T10SFH" # image = ee.Image(image_id) # Make sure the polygoned_image is available if not polygoned_image: print("No image available for download.") return # Clip the image to the extent of the polygon clipped_image = polygoned_image.clip(ee.Geometry.Polygon(polygon_data.get())) print("clipped_image: ", clipped_image) # Define export parameters download_params = { 'scale': 10, 'region': polygon_data.get(), # ee.Geometry object defining the region to export 'format': 'GeoTIFF', } # Generate download URL for the GeoTIFF image download_url = clipped_image.getDownloadURL(download_params) # Send a request to download the image response = requests.get(download_url) # Create a BytesIO buffer with io.BytesIO() as buf: # Write the image content to the buffer buf.write(response.content) buf.seek(0) # Move the buffer's position to the beginning # Yield the buffer's content as a downloadable file yield buf.getvalue() print("Image downloaded successfully!") @session.download( filename=lambda: f"data-{input.date().isoformat()}-{np.random.randint(100, 999)}.csv" ) def download_output(): global output_df # Check if data is available if output_df.empty: print("No data available for download.") return # Convert dataframe to CSV and encode to bytes csv_data = output_df.to_csv(index=False).encode() # Create a StringIO buffer for textual data with io.BytesIO() as buf: buf.write(csv_data) # Reset the buffer's position to the beginning buf.seek(0) # Create and return a streaming response yield buf.getvalue() print("Data downloaded successfully!") static_dir = Path(__file__).parent / "assets" app = App(app_ui, server, static_assets=static_dir)