Update part1_data.py

part1_data.py

@@ -8,6 +8,8 @@ import requests
 from geopy.geocoders import Nominatim
 from geopy.exc import GeocoderTimedOut
 from scipy import stats
+import ee
+import geemap
 
 # Get API key from environment variable
 OPENWEATHER_API_KEY = os.getenv('OPENWEATHER_API_KEY', 'default_key')
@@ -18,7 +20,8 @@ class TobaccoAnalyzer:
         self.optimal_conditions = {
             'temperature': {'min': 20, 'max': 30},
             'humidity': {'min': 60, 'max': 80},
-            'rainfall': {'min': 500/365, 'max': 1200/365}
+            'rainfall': {'min': 500/365, 'max': 1200/365},
+            'ndvi': {'min': 0.3, 'max': 0.8}  # Optimal NDVI range for tobacco
         }
         self.geolocator = Nominatim(user_agent="tobacco_analyzer")
         self.seasons = {
@@ -27,6 +30,13 @@ class TobaccoAnalyzer:
             7: 'Summer', 8: 'Summer', 9: 'Fall',
             10: 'Fall', 11: 'Fall', 12: 'Winter'
         }
+        # Initialize Earth Engine
+        try:
+            ee.Initialize()
+            self.ee_initialized = True
+        except Exception as e:
+            print(f"Error initializing Earth Engine: {e}")
+            self.ee_initialized = False
 
     def geocode_location(self, location_name):
         """Convert location name to coordinates"""
@@ -69,7 +79,6 @@ class TobaccoAnalyzer:
         # Get forecast data
         forecast_data = []
         try:
-            # Get 5-day forecast
             forecast_url = f"https://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={self.api_key}&units=metric"
             response = requests.get(forecast_url)
             if response.status_code == 200:
@@ -92,7 +101,6 @@ class TobaccoAnalyzer:
                 for day in range(1, forecast_days - 5):
                     date = last_date + timedelta(days=day)
                     
-                    # Calculate trends from historical data
                     if not historical_df.empty:
                         temp_trend = stats.linregress(range(len(historical_df)), historical_df['temperature'])[0]
                         humidity_trend = stats.linregress(range(len(historical_df)), historical_df['humidity'])[0]
@@ -100,7 +108,6 @@ class TobaccoAnalyzer:
                     else:
                         temp_trend = humidity_trend = rainfall_trend = 0
                     
-                    # Get recent averages
                     recent_temps = [d['temperature'] for d in forecast_data[-5:]]
                     recent_humidity = [d['humidity'] for d in forecast_data[-5:]]
                     recent_rainfall = [d['rainfall'] for d in forecast_data[-5:]]
@@ -133,6 +140,87 @@ class TobaccoAnalyzer:
         
         return all_data
 
+    def get_ndvi_data(self, lat, lon, radius=2000):
+        """Get NDVI data for location"""
+        try:
+            point = ee.Geometry.Point([lon, lat])
+            area = point.buffer(radius)
+
+            end_date = datetime.now()
+            start_date = end_date - timedelta(days=90)
+            
+            s2 = ee.ImageCollection('COPERNICUS/S2_SR') \
+                .filterDate(start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')) \
+                .filterBounds(area) \
+                .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 20))
+
+            def addNDVI(image):
+                ndvi = image.normalizedDifference(['B8', 'B4']).rename('NDVI')
+                return image.addBands(ndvi)
+
+            s2_ndvi = s2.map(addNDVI)
+            ndvi_image = s2_ndvi.select('NDVI').mean()
+
+            stats = ndvi_image.reduceRegion(
+                reducer=ee.Reducer.mean().combine(
+                    reducer2=ee.Reducer.stdDev(),
+                    sharedInputs=True
+                ).combine(
+                    reducer2=ee.Reducer.minMax(),
+                    sharedInputs=True
+                ),
+                geometry=area,
+                scale=10,
+                maxPixels=1e9
+            ).getInfo()
+
+            return {
+                'image': ndvi_image,
+                'stats': stats,
+                'area': area
+            }
+
+        except Exception as e:
+            print(f"Error fetching NDVI data: {e}")
+            return None
+
+    def analyze_location(self, location_name, historical_days=90, forecast_days=90):
+        """Comprehensive location analysis including weather and NDVI"""
+        try:
+            location_info = self.geocode_location(location_name)
+            if not location_info:
+                raise ValueError(f"Could not find coordinates for location: {location_name}")
+
+            lat = location_info['lat']
+            lon = location_info['lon']
+
+            weather_data = self.get_weather_data(lat, lon, historical_days, forecast_days)
+            weather_analysis = self.analyze_trends(weather_data)
+            weather_score = self.calculate_weather_score(weather_analysis)
+
+            ndvi_data = None
+            ndvi_score = None
+            if self.ee_initialized:
+                try:
+                    ndvi_data = self.get_ndvi_data(lat, lon)
+                    ndvi_score = self.calculate_ndvi_score(ndvi_data)
+                except Exception as e:
+                    print(f"Error getting NDVI data: {e}")
+
+            return {
+                'location': location_info,
+                'weather_data': weather_data,
+                'weather_analysis': weather_analysis,
+                'weather_score': weather_score,
+                'ndvi_data': ndvi_data,
+                'ndvi_score': ndvi_score,
+                'combined_score': self.calculate_combined_score(weather_score, ndvi_score)
+            }
+
+        except Exception as e:
+            print(f"Error in location analysis: {e}")
+            return None
+
     def analyze_trends(self, df):
         """Analyze weather trends and patterns"""
         historical = df[df['type'] == 'historical']
@@ -172,4 +260,75 @@ class TobaccoAnalyzer:
             }
         }
         
-        return analysis
+        return analysis
+
+    def calculate_ndvi_score(self, ndvi_data):
+        """Calculate a score based on NDVI data"""
+        if not ndvi_data or 'stats' not in ndvi_data:
+            return None
+
+        stats = ndvi_data['stats']
+        mean_ndvi = stats.get('NDVI_mean', 0)
+        
+        # Convert NDVI from -1:1 scale to 0:1 scale
+        score = (mean_ndvi + 1) / 2
+        
+        # Adjust score based on optimal NDVI ranges
+        if self.optimal_conditions['ndvi']['min'] <= mean_ndvi <= self.optimal_conditions['ndvi']['max']:
+            score *= 1.2  # Bonus for optimal range
+        elif mean_ndvi < 0:
+            score *= 0.5  # Penalty for very low vegetation
+
+        return min(1.0, max(0.0, score))
+
+    def calculate_weather_score(self, weather_analysis):
+        """Calculate weather suitability score"""
+        if not weather_analysis:
+            return None
+
+        historical = weather_analysis['historical']
+        
+        temp_mean = historical['temperature']['mean']
+        humidity_mean = historical['humidity']['mean']
+        rainfall_mean = historical['rainfall']['mean']
+        
+        temp_score = self.calculate_range_score(
+            temp_mean, 
+            self.optimal_conditions['temperature']['min'],
+            self.optimal_conditions['temperature']['max']
+        )
+        
+        humidity_score = self.calculate_range_score(
+            humidity_mean,
+            self.optimal_conditions['humidity']['min'],
+            self.optimal_conditions['humidity']['max']
+        )
+        
+        rainfall_score = self.calculate_range_score(
+            rainfall_mean,
+            self.optimal_conditions['rainfall']['min'],
+            self.optimal_conditions['rainfall']['max']
+        )
+        
+        return (temp_score * 0.4 + humidity_score * 0.3 + rainfall_score * 0.3)
+
+    def calculate_range_score(self, value, min_val, max_val):
+        """Calculate score based on optimal range"""
+        if min_val <= value <= max_val:
+            return 1.0
+        elif value < min_val:
+            return max(0, 1 - (min_val - value) / min_val)
+        else:
+            return max(0, 1 - (value - max_val) / max_val)
+
+    def calculate_combined_score(self, weather_score, ndvi_score):
+        """Calculate combined suitability score"""
+        if weather_score is None:
+            return None
+        if ndvi_score is None:
+            return weather_score
+            
+        weather_weight = 0.6
+        ndvi_weight = 0.4
+        
+        return (weather_score * weather_weight) + (ndvi_score * ndvi_weight)