app.py

import streamlit as st
import requests
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
from io import BytesIO
from datetime import datetime, timedelta

# URL pour les images solaires
SOLAR_IMAGE_URL = "https://sdo.gsfc.nasa.gov/assets/img/latest/latest_4096_HMIIC.jpg"
STORM_IMAGE_URL = "https://sdo.gsfc.nasa.gov/assets/img/latest/latest_4096_0335.jpg"

# Fonction pour récupérer une image solaire
def get_solar_image(url):
    response = requests.get(url)
    image = Image.open(BytesIO(response.content))
    return image

# Fonction pour analyser l'image et identifier les taches solaires
def analyze_solar_image(image):
    image_gray = image.convert('L')
    image_array = np.array(image_gray)
    threshold = 100
    sun_pixels = image_array < threshold  # Pixels sombres
    sun_activity = np.sum(sun_pixels)  # Compte des pixels sombres
    return sun_activity, sun_pixels

# Estimation de l'indice KP
def estimate_kp_index(sun_activity):
    kp_index = min(8, sun_activity // 10000)  # Exemple simple, ajustez selon vos besoins
    return kp_index

# Fonction pour estimer la latitude
def estimate_latitude(kp_index):
    if kp_index < 4:
        return "Rarement visible (au-dessus de 60° de latitude)"
    elif kp_index < 6:
        return "Visible parfois (entre 60° et 65° de latitude)"
    elif kp_index < 8:
        return "Visible souvent (entre 65° et 70° de latitude)"
    else:
        return "Visible fréquemment (entre 70° et 75° de latitude)"

# Fonction pour estimer le temps d'impact
def estimate_impact_time(distance):
    speed_of_solar_wind = 400  # Vitesse moyenne en km/s
    time_seconds = distance / speed_of_solar_wind
    return datetime.now() + timedelta(seconds=time_seconds)

# Fonction pour estimer la latitude d'impact
def estimate_impact_latitude(sun_activity, kp_index):
    base_latitude = 60  # Latitude de base pour l'activité aurorale
    intensity_factor = kp_index * 1.5  # Facteur d'intensité basé sur KP
    estimated_latitude = base_latitude + intensity_factor
    return estimated_latitude

# Fonction pour estimer la probabilité d'aurores boréales
def calculate_probabilities(sun_activity, kp_index):
    probabilities = []
    for intensity in range(1, 5):  # Simule 4 tempêtes
        distance = 150 + intensity * 50  # Distance aléatoire
        probability = (sun_activity / 10000) * (intensity / 4) * 100
        impact_time = estimate_impact_time(distance)
        impact_latitude = estimate_impact_latitude(sun_activity, kp_index)
        probabilities.append({'intensity': intensity, 'distance': distance, 'probability': probability,
                              'impact_time': impact_time, 'impact_latitude': impact_latitude})
    return probabilities

# Fonction pour afficher les résultats
def display_results(kp_index, probabilities):
    st.write(f"Indice KP estimé : {kp_index}")
    latitude_estimation = estimate_latitude(kp_index)
    st.write(f"Estimation de la latitude pour les aurores boréales : {latitude_estimation}")

    st.write("Probabilités d'apparition d'aurores boréales :")
    highest_probability_storm = (None, 0)  # Stocke la tempête avec la probabilité la plus élevée

    for storm in probabilities:
        st.write(f"Tempête (Intensité: {storm['intensity']}, Distance: {storm['distance']} km) - Probabilité: {storm['probability']:.2f}%")
        st.write(f"Heure d'impact estimée : {storm['impact_time']}")
        st.write(f"Latitude d'impact estimée : {storm['impact_latitude']:.2f}°")
        
        if storm['probability'] > highest_probability_storm[1]:
            highest_probability_storm = (storm, storm['probability'])

    if highest_probability_storm[0] is not None:
        st.write("Tempête avec la probabilité la plus élevée :")
        st.write(f"Intensité: {highest_probability_storm[0]['intensity']}, Distance: {highest_probability_storm[0]['distance']} km - Probabilité: {highest_probability_storm[1]:.2f}%")
        st.write(f"Heure d'impact estimée : {highest_probability_storm[0]['impact_time']}")
        st.write(f"Latitude d'impact estimée : {highest_probability_storm[0]['impact_latitude']:.2f}°")


# Affichage Streamlit
st.title("Prédiction des Aurores Boréales")

# Bouton pour exécuter l'analyse
if st.button("Exécuter l'analyse"):
    # Étape 1 : Récupérer l'image solaire
    solar_image = get_solar_image(SOLAR_IMAGE_URL)
    st.image(solar_image, caption="Image actuelle du Soleil", use_column_width=True)

    # Étape 2 : Analyse des taches solaires
    sun_activity, sun_pixels = analyze_solar_image(solar_image)
    kp_index = estimate_kp_index(sun_activity)
    
    # Étape 3 : Calculer les probabilités d'aurores boréales
    probabilities = calculate_probabilities(sun_activity, kp_index)
    
    # Étape 4 : Afficher les résultats
    display_results(kp_index, probabilities)