Update part2_visualization.py

part2_visualization.py

@@ -3,10 +3,9 @@
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import folium
+from folium import plugins
 import numpy as np
-import ee
-import geemap
-from branca.colormap import LinearColormap
+import branca.colormap as cm
 
 class VisualizationHandler:
     def __init__(self, optimal_conditions):
@@ -25,17 +24,56 @@ class VisualizationHandler:
     def create_interactive_plots(self, df):
         """Create enhanced interactive Plotly visualizations"""
         fig = make_subplots(
-            rows=3, cols=1,
+            rows=4, cols=1,  # Added one more row for NDVI
             subplot_titles=(
                 '<b>Temperature (°C)</b>',
                 '<b>Humidity (%)</b>',
-                '<b>Rainfall (mm/day)</b>'
+                '<b>Rainfall (mm/day)</b>',
+                '<b>Vegetation Index (NDVI)</b>'
             ),
-            vertical_spacing=0.12,
-            row_heights=[0.33, 0.33, 0.33]
+            vertical_spacing=0.08,
+            row_heights=[0.25, 0.25, 0.25, 0.25]
         )
         
-        # Temperature plot with forecast types
+        # Add standard weather plots
+        self.add_weather_plots(fig, df)
+        
+        # Add NDVI plot
+        self.add_ndvi_plot(fig, df)
+        
+        # Update layout
+        fig.update_layout(
+            height=1000,  # Increased height for additional plot
+            showlegend=True,
+            title={
+                'text': "Enhanced Tobacco Growing Conditions Analysis",
+                'y':0.95,
+                'x':0.5,
+                'xanchor': 'center',
+                'yanchor': 'top',
+                'font': dict(size=20)
+            },
+            paper_bgcolor='white',
+            plot_bgcolor='rgba(0,0,0,0.05)',
+            font=dict(size=12),
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            ),
+            margin=dict(l=60, r=30, t=100, b=60)
+        )
+
+        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
+        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
+        
+        return fig
+
+    def add_weather_plots(self, fig, df):
+        """Add weather-related plots"""
+        # Temperature plot
         for data_type, color in [('historical', 'royalblue'), 
                                ('forecast_5day', 'firebrick'),
                                ('forecast_extended', 'rgba(255, 165, 0, 0.5)')]:
@@ -64,7 +102,7 @@ class VisualizationHandler:
             row=1, col=1
         )
 
-        # Humidity plot with forecast types
+        # Humidity plot
         for data_type, color in [('historical', 'royalblue'), 
                                ('forecast_5day', 'firebrick'),
                                ('forecast_extended', 'rgba(255, 165, 0, 0.5)')]:
@@ -93,7 +131,7 @@ class VisualizationHandler:
             row=2, col=1
         )
 
-        # Rainfall plot with forecast types
+        # Rainfall plot
         for data_type, color in [('historical', 'royalblue'), 
                                ('forecast_5day', 'firebrick'),
                                ('forecast_extended', 'rgba(255, 165, 0, 0.5)')]:
@@ -109,151 +147,124 @@ class VisualizationHandler:
                     row=3, col=1
                 )
 
-        # Add optimal ranges
-        for row, (param, limits) in enumerate([
-            ('temperature', self.optimal_conditions['temperature']),
-            ('humidity', self.optimal_conditions['humidity']),
-            ('rainfall', self.optimal_conditions['rainfall'])
-        ], 1):
-            fig.add_hline(y=limits['min'], line_dash="dash", line_color="green",
-                         annotation_text="Min Optimal", row=row, col=1)
-            fig.add_hline(y=limits['max'], line_dash="dash", line_color="green",
-                         annotation_text="Max Optimal", row=row, col=1)
+    def add_ndvi_plot(self, fig, df):
+        """Add NDVI plot"""
+        # Historical NDVI
+        mask = df['type'] == 'historical'
+        if any(mask):
+            fig.add_trace(
+                go.Scatter(
+                    x=df[mask]['date'],
+                    y=df[mask]['estimated_ndvi'],
+                    name='Historical NDVI',
+                    line=dict(color='green', width=2),
+                    mode='lines'
+                ),
+                row=4, col=1
+            )
 
-        # Add seasonal indicators
-        seasons = df['season'].unique()
-        season_colors = {
-            'Spring': 'rgba(0,255,0,0.1)',
-            'Summer': 'rgba(255,255,0,0.1)',
-            'Fall': 'rgba(255,165,0,0.1)',
-            'Winter': 'rgba(0,0,255,0.1)'
-        }
-        
-        for season in seasons:
-            season_data = df[df['season'] == season]
-            if not season_data.empty:
-                fig.add_vrect(
-                    x0=season_data['date'].iloc[0],
-                    x1=season_data['date'].iloc[-1],
-                    fillcolor=season_colors[season],
-                    layer="below",
-                    line_width=0,
-                    row="all"
-                )
+        # Forecast NDVI
+        mask = df['type'].isin(['forecast_5day', 'forecast_extended'])
+        if any(mask):
+            fig.add_trace(
+                go.Scatter(
+                    x=df[mask]['date'],
+                    y=df[mask]['estimated_ndvi'],
+                    name='Forecast NDVI',
+                    line=dict(color='orange', width=2, dash='dot'),
+                    mode='lines'
+                ),
+                row=4, col=1
+            )
 
-        # Update layout
-        fig.update_layout(
-            height=800,
-            showlegend=True,
-            paper_bgcolor='white',
-            plot_bgcolor='rgba(0,0,0,0.05)',
-            font=dict(size=12),
-            legend=dict(
-                orientation="h",
-                yanchor="bottom",
-                y=1.02,
-                xanchor="right",
-                x=1
-            ),
-            margin=dict(l=60, r=30, t=100, b=60)
-        )
+        # Add optimal NDVI range
+        fig.add_hline(y=self.optimal_conditions['ndvi']['min'], 
+                     line_dash="dash", line_color="green",
+                     annotation_text="Min Optimal NDVI", 
+                     row=4, col=1)
+        fig.add_hline(y=self.optimal_conditions['ndvi']['max'], 
+                     line_dash="dash", line_color="green",
+                     annotation_text="Max Optimal NDVI", 
+                     row=4, col=1)
 
-        fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
-        fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='rgba(0,0,0,0.1)')
+    def create_enhanced_map(self, lat, lon, score, ndvi_value):
+        """Create an interactive map with both weather and vegetation analysis"""
+        m = folium.Map(location=[lat, lon], zoom_start=13)
         
-        return fig
-
-    def create_enhanced_map(self, lat, lon, weather_score, ndvi_data=None):
-        """Create an interactive map with both weather and NDVI data"""
-        try:
-            # Create base map
-            m = folium.Map(location=[lat, lon], zoom_start=15)
-            
-            # If NDVI data is available, add it to the map
-            if ndvi_data and 'image' in ndvi_data:
-                try:
-                    # Get NDVI visualization parameters
-                    vis_params = {
-                        'min': -0.2,
-                        'max': 0.8,
-                        'palette': self.ndvi_colors
-                    }
-                    
-                    # Add NDVI layer
-                    map_id_dict = ndvi_data['image'].getMapId(vis_params)
-                    folium.TileLayer(
-                        tiles=map_id_dict['tile_fetcher'].url_format,
-                        attr='NDVI Data',
-                        overlay=True,
-                        name='NDVI Layer'
-                    ).add_to(m)
-
-                    # Add NDVI legend
-                    colormap = LinearColormap(
-                        colors=self.ndvi_colors,
-                        vmin=-0.2,
-                        vmax=0.8,
-                        caption='NDVI Values'
-                    )
-                    colormap.add_to(m)
-
-                except Exception as e:
-                    print(f"Error adding NDVI layer: {e}")
-
-            # Calculate combined score if NDVI data is available
-            if ndvi_data and 'stats' in ndvi_data:
-                ndvi_score = (ndvi_data['stats'].get('NDVI_mean', 0) + 1) / 2
-                combined_score = (weather_score * 0.6 + ndvi_score * 0.4)
-            else:
-                combined_score = weather_score
-
-            # Color based on combined score
-            if combined_score >= 0.8:
-                color = 'green'
-            elif combined_score >= 0.6:
-                color = 'yellow'
-            elif combined_score >= 0.4:
-                color = 'orange'
-            else:
-                color = 'red'
-
-            # Add analysis circles
+        # Add base marker
+        folium.Marker(
+            [lat, lon],
+            popup='Analysis Location',
+            icon=folium.Icon(color='red', icon='info-sign')
+        ).add_to(m)
+        
+        # Create NDVI colormap
+        ndvi_colormap = cm.LinearColormap(
+            colors=self.ndvi_colors,
+            vmin=-1,
+            vmax=1,
+            caption='NDVI Values'
+        )
+        
+        # Add NDVI-based circle
+        ndvi_color = ndvi_colormap(ndvi_value)
+        folium.Circle(
+            radius=2000,
+            location=[lat, lon],
+            popup=f'NDVI: {ndvi_value:.2f}',
+            color=ndvi_color,
+            fill=True,
+            fillOpacity=0.4
+        ).add_to(m)
+        
+        # Add score-based circles
+        score_color = self.get_score_color(score)
+        for radius in [500, 1000, 1500]:
             folium.Circle(
-                radius=2000,
+                radius=radius,
                 location=[lat, lon],
-                popup=f'Combined Score: {combined_score:.2f}<br>Weather Score: {weather_score:.2f}',
-                color=color,
-                fill=True,
-                fillOpacity=0.4
+                color=score_color,
+                popup=f'Growing Score: {score:.2f}',
+                fill=False,
+                weight=2
             ).add_to(m)
+        
+        # Add measurement tools
+        plugins.MeasureControl(position='topright').add_to(m)
+        
+        # Add fullscreen option
+        plugins.Fullscreen().add_to(m)
+        
+        # Add mini map
+        minimap = plugins.MiniMap()
+        m.add_child(minimap)
+        
+        # Add layer control
+        folium.LayerControl().add_to(m)
+        
+        # Add colormap to map
+        m.add_child(ndvi_colormap)
+        
+        return m._repr_html_()
 
-            # Add smaller analysis zones
-            for radius in [1000, 1500]:
-                folium.Circle(
-                    radius=radius,
-                    location=[lat, lon],
-                    color=color,
-                    fill=False,
-                    weight=1
-                ).add_to(m)
-
-            # Add layer control
-            folium.LayerControl().add_to(m)
-
-            return m._repr_html_()
-
-        except Exception as e:
-            print(f"Error creating enhanced map: {e}")
-            return None
+    def get_score_color(self, score):
+        """Get color based on score"""
+        if score >= 0.8:
+            return 'green'
+        elif score >= 0.6:
+            return 'yellow'
+        elif score >= 0.4:
+            return 'orange'
+        return 'red'
 
-    def create_gauge_chart(self, score, title="Growing Conditions Score"):
+    def create_gauge_chart(self, score):
         """Create an enhanced gauge chart for the overall score"""
         fig = go.Figure(go.Indicator(
             mode="gauge+number+delta",
             value=score,
             domain={'x': [0, 1], 'y': [0, 1]},
             title={
-                'text': title,
+                'text': "Growing Conditions Score",
                 'font': {'size': 24}
             },
             delta={
@@ -288,35 +299,4 @@ class VisualizationHandler:
             font={'color': "darkblue", 'family': "Arial"}
         )
         
-        return fig
-
-    def create_ndvi_report(self, ndvi_data):
-        """Create a detailed NDVI analysis report"""
-        if not ndvi_data or 'stats' not in ndvi_data:
-            return None
-
-        stats = ndvi_data['stats']
-        mean_ndvi = stats.get('NDVI_mean', 0)
-        
-        # Create analysis text
-        if mean_ndvi < 0:
-            vegetation_status = "Very low vegetation - likely bare soil or water"
-        elif mean_ndvi < 0.2:
-            vegetation_status = "Low vegetation - sparse cover or stressed vegetation"
-        elif mean_ndvi < 0.4:
-            vegetation_status = "Moderate vegetation - typical for agricultural areas"
-        elif mean_ndvi < 0.6:
-            vegetation_status = "High vegetation - healthy crops or natural vegetation"
-        else:
-            vegetation_status = "Very high vegetation - dense, healthy vegetation"
-
-        report = {
-            'mean_ndvi': mean_ndvi,
-            'std_dev': stats.get('NDVI_stdDev', 0),
-            'min_ndvi': stats.get('NDVI_min', 0),
-            'max_ndvi': stats.get('NDVI_max', 0),
-            'vegetation_status': vegetation_status,
-            'optimal_range': self.optimal_conditions['ndvi']
-        }
-        
-        return report
+        return fig