Update app.py

app.py

@@ -10,19 +10,33 @@ import plotly.graph_objects as go
 from datetime import datetime, timedelta
 import json
 from io import StringIO
+import streamlit.components.v1 as components
+import base64
 
 # Page configuration
 st.set_page_config(layout="wide", page_title="Pakistan Climate & Disaster Monitor")
 
 class DataCollector:
-    @staticmethod
-    def fetch_usgs_earthquake_data():
-        """Fetch earthquake data from USGS website (free, no API key needed)"""
+    def __init__(self):
+        self.cities = {
+            'Islamabad': {'lat': 33.7294, 'lon': 73.0931},
+            'Karachi': {'lat': 24.8607, 'lon': 67.0011},
+            'Lahore': {'lat': 31.5204, 'lon': 74.3587},
+            'Peshawar': {'lat': 34.0151, 'lon': 71.5249},
+            'Quetta': {'lat': 30.1798, 'lon': 66.9750},
+            'Multan': {'lat': 30.1575, 'lon': 71.5249},
+            'Faisalabad': {'lat': 31.4504, 'lon': 73.1350},
+            'Rawalpindi': {'lat': 33.6007, 'lon': 73.0679},
+            'Gwadar': {'lat': 25.1216, 'lon': 62.3254},
+            'Hyderabad': {'lat': 25.3960, 'lon': 68.3578}
+        }
+
+    def fetch_usgs_earthquake_data(self):
+        """Fetch earthquake data from USGS website"""
         url = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_month.geojson"
         try:
             response = requests.get(url)
             data = response.json()
-            # Filter for Pakistan region
             pakistan_data = {
                 "type": "FeatureCollection",
                 "features": [
@@ -36,149 +50,253 @@ class DataCollector:
             st.error(f"Error fetching earthquake data: {e}")
             return None
 
-    @staticmethod
-    def fetch_weather_data():
-        """Fetch weather data from OpenMeteo (free, no API required)"""
-        # Multiple cities in Pakistan
-        cities = {
-            'Islamabad': {'lat': 33.7294, 'lon': 73.0931},
-            'Karachi': {'lat': 24.8607, 'lon': 67.0011},
-            'Lahore': {'lat': 31.5204, 'lon': 74.3587},
-            'Peshawar': {'lat': 34.0151, 'lon': 71.5249},
-            'Quetta': {'lat': 30.1798, 'lon': 66.9750}
-        }
-        
+    def fetch_weather_data(self):
+        """Fetch weather data from OpenMeteo"""
         weather_data = []
-        for city, coords in cities.items():
-            url = f"https://api.open-meteo.com/v1/forecast?latitude={coords['lat']}&longitude={coords['lon']}&daily=temperature_2m_max,temperature_2m_min,precipitation_sum&timezone=auto"
+        for city, coords in self.cities.items():
+            url = f"https://api.open-meteo.com/v1/forecast?latitude={coords['lat']}&longitude={coords['lon']}&hourly=temperature_2m,relativehumidity_2m,precipitation,windspeed_10m&daily=temperature_2m_max,temperature_2m_min,precipitation_sum&timezone=auto"
             try:
                 response = requests.get(url)
                 data = response.json()
-                df = pd.DataFrame({
-                    'Date': pd.to_datetime(data['daily']['time']),
-                    'Temperature_Max': data['daily']['temperature_2m_max'],
-                    'Temperature_Min': data['daily']['temperature_2m_min'],
-                    'Precipitation': data['daily']['precipitation_sum'],
-                    'City': city
+                
+                # Hourly data
+                hourly_df = pd.DataFrame({
+                    'datetime': pd.to_datetime(data['hourly']['time']),
+                    'temperature': data['hourly']['temperature_2m'],
+                    'humidity': data['hourly']['relativehumidity_2m'],
+                    'precipitation': data['hourly']['precipitation'],
+                    'wind_speed': data['hourly']['windspeed_10m']
+                })
+                
+                # Daily data
+                daily_df = pd.DataFrame({
+                    'date': pd.to_datetime(data['daily']['time']),
+                    'temp_max': data['daily']['temperature_2m_max'],
+                    'temp_min': data['daily']['temperature_2m_min'],
+                    'precipitation_sum': data['daily']['precipitation_sum']
+                })
+                
+                weather_data.append({
+                    'city': city,
+                    'hourly': hourly_df,
+                    'daily': daily_df,
+                    'coords': coords
                 })
-                weather_data.append(df)
             except Exception as e:
-                st.error(f"Error fetching data for {city}: {e}")
+                st.error(f"Error fetching weather data for {city}: {e}")
                 continue
         
-        if weather_data:
-            return pd.concat(weather_data, ignore_index=True)
-        return None
+        return weather_data if weather_data else None
 
-    @staticmethod
-    def fetch_air_quality_data():
-        """Fetch air quality data from OpenMeteo Air Quality API (free)"""
-        cities = {
-            'Islamabad': {'lat': 33.7294, 'lon': 73.0931},
-            'Karachi': {'lat': 24.8607, 'lon': 67.0011},
-            'Lahore': {'lat': 31.5204, 'lon': 74.3587}
-        }
-        
+    def fetch_air_quality_data(self):
+        """Fetch air quality data from OpenMeteo"""
         aqi_data = []
-        for city, coords in cities.items():
-            url = f"https://air-quality-api.open-meteo.com/v1/air-quality?latitude={coords['lat']}&longitude={coords['lon']}&hourly=pm10,pm2_5,carbon_monoxide&timezone=auto"
+        for city, coords in self.cities.items():
+            url = f"https://air-quality-api.open-meteo.com/v1/air-quality?latitude={coords['lat']}&longitude={coords['lon']}&hourly=pm10,pm2_5,carbon_monoxide,nitrogen_dioxide,ozone&timezone=auto"
             try:
                 response = requests.get(url)
                 data = response.json()
                 df = pd.DataFrame({
-                    'Time': pd.to_datetime(data['hourly']['time']),
+                    'datetime': pd.to_datetime(data['hourly']['time']),
                     'PM10': data['hourly']['pm10'],
                     'PM2.5': data['hourly']['pm2_5'],
                     'CO': data['hourly']['carbon_monoxide'],
-                    'City': city
+                    'NO2': data['hourly']['nitrogen_dioxide'],
+                    'O3': data['hourly']['ozone'],
+                    'city': city
                 })
                 aqi_data.append(df)
             except Exception as e:
                 st.error(f"Error fetching AQI data for {city}: {e}")
                 continue
         
-        if aqi_data:
-            return pd.concat(aqi_data, ignore_index=True)
-        return None
+        return pd.concat(aqi_data, ignore_index=True) if aqi_data else None
 
-def show_climate_analysis():
-    st.header("Climate Analysis")
+def create_cesium_component():
+    """Create Cesium 3D map component"""
+    cesium_html = """
+    <div id="cesiumContainer" style="width: 100%; height: 600px;"></div>
+    <script src="https://cesium.com/downloads/cesiumjs/releases/1.95/Build/Cesium/Cesium.js"></script>
+    <link href="https://cesium.com/downloads/cesiumjs/releases/1.95/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
+    <script>
+        Cesium.Ion.defaultAccessToken = 'your-access-token';
+        const viewer = new Cesium.Viewer('cesiumContainer', {
+            terrainProvider: Cesium.createWorldTerrain()
+        });
+        viewer.camera.flyTo({
+            destination: Cesium.Cartesian3.fromDegrees(69.3451, 30.3753, 1000000.0)
+        });
+    </script>
+    """
+    components.html(cesium_html, height=600)
+
+def download_csv(df, filename):
+    """Generate download link for CSV file"""
+    csv = df.to_csv(index=False)
+    b64 = base64.b64encode(csv.encode()).decode()
+    href = f'<a href="data:file/csv;base64,{b64}" download="{filename}.csv">Download {filename} Data</a>'
+    return href
+
+def show_weather_analysis(data_collector):
+    st.header("Weather Analysis")
     
-    data_collector = DataCollector()
     weather_data = data_collector.fetch_weather_data()
-    
-    if weather_data is not None:
-        # City selector
-        selected_city = st.selectbox("Select City", weather_data['City'].unique())
-        city_data = weather_data[weather_data['City'] == selected_city]
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Temperature trends
-            fig = px.line(city_data, 
-                         x='Date', 
-                         y=['Temperature_Max', 'Temperature_Min'],
-                         title=f'Temperature Trends - {selected_city}')
-            st.plotly_chart(fig)
-        
-        with col2:
-            # Precipitation patterns
-            fig = px.bar(city_data, 
-                        x='Date', 
-                        y='Precipitation',
+    if weather_data:
+        selected_city = st.selectbox(
+            "Select City",
+            options=[data['city'] for data in weather_data]
+        )
+        
+        city_data = next(data for data in weather_data if data['city'] == selected_city)
+        
+        # Add download button for data
+        st.markdown(download_csv(city_data['hourly'], f"{selected_city}_weather_data"), unsafe_allow_html=True)
+        
+        tabs = st.tabs(["Temperature", "Precipitation", "Wind", "Humidity"])
+        
+        with tabs[0]:
+            fig = px.line(city_data['hourly'], 
+                         x='datetime', 
+                         y='temperature',
+                         title=f'Temperature Trend - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[1]:
+            fig = px.bar(city_data['daily'], 
+                        x='date', 
+                        y='precipitation_sum',
                         title=f'Daily Precipitation - {selected_city}')
-            st.plotly_chart(fig)
-        
-        # Climate indicators
-        st.subheader("Current Climate Indicators")
-        latest_data = city_data.iloc[-1]
-        cols = st.columns(3)
-        
-        with cols[0]:
-            st.metric("Max Temperature", f"{latest_data['Temperature_Max']:.1f}°C")
-        with cols[1]:
-            st.metric("Min Temperature", f"{latest_data['Temperature_Min']:.1f}°C")
-        with cols[2]:
-            st.metric("Precipitation", f"{latest_data['Precipitation']:.1f}mm")
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[2]:
+            fig = px.line(city_data['hourly'], 
+                         x='datetime', 
+                         y='wind_speed',
+                         title=f'Wind Speed - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[3]:
+            fig = px.line(city_data['hourly'], 
+                         x='datetime', 
+                         y='humidity',
+                         title=f'Humidity - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
+
+def show_disaster_monitor(data_collector):
+    st.header("Disaster Monitoring")
+    
+    earthquake_data = data_collector.fetch_usgs_earthquake_data()
+    
+    if earthquake_data:
+        # 3D visualization using Cesium
+        st.subheader("3D Terrain View")
+        create_cesium_component()
+        
+        # Traditional map
+        st.subheader("Recent Earthquakes Map")
+        m = folium.Map(location=[30.3753, 69.3451], zoom_start=5)
+        
+        for eq in earthquake_data['features']:
+            coords = eq['geometry']['coordinates']
+            mag = eq['properties']['mag']
+            time = datetime.fromtimestamp(eq['properties']['time']/1000)
+            
+            folium.CircleMarker(
+                location=[coords[1], coords[0]],
+                radius=mag * 3,
+                color='red',
+                fill=True,
+                popup=f"Magnitude: {mag}<br>Time: {time}",
+            ).add_to(m)
+        
+        folium_static(m)
+        
+        # Earthquake data table
+        st.subheader("Recent Earthquakes")
+        eq_df = pd.DataFrame([
+            {
+                'Time': datetime.fromtimestamp(eq['properties']['time']/1000),
+                'Magnitude': eq['properties']['mag'],
+                'Location': eq['properties']['place'],
+                'Depth': eq['geometry']['coordinates'][2]
+            }
+            for eq in earthquake_data['features']
+        ])
+        st.dataframe(eq_df)
+        st.markdown(download_csv(eq_df, "earthquake_data"), unsafe_allow_html=True)
 
-def show_environmental_data():
+def show_environmental_data(data_collector):
     st.header("Environmental Data")
     
-    data_collector = DataCollector()
     aqi_data = data_collector.fetch_air_quality_data()
     
     if aqi_data is not None:
-        # City selector
-        selected_city = st.selectbox("Select City", aqi_data['City'].unique())
-        city_data = aqi_data[aqi_data['City'] == selected_city]
-        
-        # Latest 24 hours of data
-        recent_data = city_data.tail(24)
-        
-        # AQI time series
-        st.subheader("Air Quality Indicators")
-        metric = st.selectbox("Select Pollutant", ['PM10', 'PM2.5', 'CO'])
-        
-        fig = px.line(recent_data, 
-                     x='Time', 
-                     y=metric,
-                     title=f'{metric} Levels - {selected_city} (Last 24 Hours)')
-        st.plotly_chart(fig)
-        
-        # Current conditions
-        st.subheader("Current Air Quality")
-        latest_data = city_data.iloc[-1]
-        cols = st.columns(3)
-        
-        with cols[0]:
-            st.metric("PM10", f"{latest_data['PM10']:.1f} µg/m³")
-        with cols[1]:
-            st.metric("PM2.5", f"{latest_data['PM2.5']:.1f} µg/m³")
-        with cols[2]:
-            st.metric("Carbon Monoxide", f"{latest_data['CO']:.1f} µg/m³")
+        selected_city = st.selectbox("Select City", aqi_data['city'].unique())
+        city_data = aqi_data[aqi_data['city'] == selected_city].copy()
+        
+        # Add download button
+        st.markdown(download_csv(city_data, f"{selected_city}_air_quality_data"), unsafe_allow_html=True)
+        
+        # Air Quality Index calculation
+        city_data['AQI'] = (
+            city_data['PM2.5'] * 0.3 +
+            city_data['PM10'] * 0.2 +
+            city_data['NO2'] * 0.2 +
+            city_data['O3'] * 0.2 +
+            city_data['CO'] * 0.1
+        )
+        
+        tabs = st.tabs(["Overall AQI", "Pollutants", "Trends"])
+        
+        with tabs[0]:
+            current_aqi = city_data['AQI'].iloc[-1]
+            st.metric(
+                "Current Air Quality Index",
+                f"{current_aqi:.1f}",
+                delta=f"{current_aqi - city_data['AQI'].iloc[-2]:.1f}"
+            )
+            
+            fig = px.line(city_data, x='datetime', y='AQI',
+                         title=f'Air Quality Index - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[1]:
+            pollutants = ['PM2.5', 'PM10', 'CO', 'NO2', 'O3']
+            selected_pollutant = st.selectbox("Select Pollutant", pollutants)
+            
+            fig = px.line(city_data, x='datetime', y=selected_pollutant,
+                         title=f'{selected_pollutant} Levels - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[2]:
+            # 24-hour moving average
+            city_data['AQI_MA'] = city_data['AQI'].rolling(24).mean()
+            
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(x=city_data['datetime'], y=city_data['AQI'],
+                                   name='Raw AQI'))
+            fig.add_trace(go.Scatter(x=city_data['datetime'], y=city_data['AQI_MA'],
+                                   name='24-hour Moving Average'))
+            fig.update_layout(title=f'AQI Trends - {selected_city}')
+            st.plotly_chart(fig, use_container_width=True)
 
-# [Previous show_disaster_monitor and show_risk_assessment functions remain the same]
+def main():
+    st.title("Pakistan Climate & Disaster Monitoring System")
+    
+    data_collector = DataCollector()
+    
+    # Sidebar navigation
+    page = st.sidebar.selectbox(
+        "Select Module",
+        ["Weather Analysis", "Disaster Monitor", "Environmental Data"]
+    )
+    
+    if page == "Weather Analysis":
+        show_weather_analysis(data_collector)
+    elif page == "Disaster Monitor":
+        show_disaster_monitor(data_collector)
+    elif page == "Environmental Data":
+        show_environmental_data(data_collector)
 
 if __name__ == "__main__":
-    create_dashboard()
+    main()