Solar Powered AI Managed Aquaponics Farm Bot

import numpy as np
import pandas as pd
from typing import Dict, List, Tuple, Optional
import pickle
import logging
import time
from datetime import datetime
import RPi.GPIO as GPIO
import cv2
from picamera2 import Picamera2
import torch
import torchvision.transforms as transforms
from PIL import Image
import os
import threading
from queue import Queue

# [Previous imports and sensor code remain the same]

class AquaponicsCamera:
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        
        # Initialize cameras
        self.fish_camera = Picamera2(0)  # First camera for fish monitoring
        self.plant_camera = Picamera2(1)  # Second camera for plant monitoring
        
        # Configure cameras
        self.configure_cameras()
        
        # Initialize ML models
        self.fish_health_model = self.load_model('models/fish_health_model.pth')
        self.plant_health_model = self.load_model('models/plant_health_model.pth')
        
        # Image processing transforms
        self.transform = transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                               std=[0.229, 0.224, 0.225])
        ])
        
        # Initialize image queues for processing
        self.fish_image_queue = Queue(maxsize=10)
        self.plant_image_queue = Queue(maxsize=10)
        
        # Create storage directories
        os.makedirs('images/fish', exist_ok=True)
        os.makedirs('images/plants', exist_ok=True)
        
        # Start processing threads
        self.start_processing_threads()
        
    def configure_cameras(self):
        """Configure both cameras for optimal aquaponics monitoring"""
        # Fish camera configuration (optimized for underwater viewing)
        fish_config = self.fish_camera.create_still_configuration()
        fish_config["main"]["size"] = (1920, 1080)
        fish_config["transform"] = libcamera.Transform(hflip=1, vflip=1)
        self.fish_camera.configure(fish_config)
        
        # Plant camera configuration (optimized for plant monitoring)
        plant_config = self.plant_camera.create_still_configuration()
        plant_config["main"]["size"] = (1920, 1080)
        self.plant_camera.configure(plant_config)
        
    def start_processing_threads(self):
        """Start separate threads for processing fish and plant images"""
        self.processing_active = True
        
        self.fish_thread = threading.Thread(
            target=self.process_fish_images, 
            daemon=True
        )
        self.plant_thread = threading.Thread(
            target=self.process_plant_images,
            daemon=True
        )
        
        self.fish_thread.start()
        self.plant_thread.start()
        
    def capture_images(self) -> Tuple[np.ndarray, np.ndarray]:
        """Capture images from both cameras"""
        try:
            fish_image = self.fish_camera.capture_array()
            plant_image = self.plant_camera.capture_array()
            
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            
            # Save images
            cv2.imwrite(f'images/fish/fish_{timestamp}.jpg', fish_image)
            cv2.imwrite(f'images/plants/plant_{timestamp}.jpg', plant_image)
            
            # Add to processing queues
            self.fish_image_queue.put((fish_image, timestamp))
            self.plant_image_queue.put((plant_image, timestamp))
            
            return fish_image, plant_image
            
        except Exception as e:
            self.logger.error(f"Image capture error: {str(e)}")
            return None, None
            
    def load_model(self, model_path: str) -> Optional[torch.nn.Module]:
        """Load a PyTorch model for health detection"""
        try:
            model = torch.load(model_path)
            model.eval()
            return model
        except Exception as e:
            self.logger.error(f"Error loading model {model_path}: {str(e)}")
            return None
            
    def process_fish_images(self):
        """Process fish images for health monitoring"""
        while self.processing_active:
            try:
                if not self.fish_image_queue.empty():
                    image, timestamp = self.fish_image_queue.get()
                    
                    # Convert to PIL Image
                    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
                    
                    # Prepare image for model
                    input_tensor = self.transform(pil_image).unsqueeze(0)
                    
                    # Get predictions
                    with torch.no_grad():
                        predictions = self.fish_health_model(input_tensor)
                    
                    # Analyze fish health indicators
                    health_metrics = self.analyze_fish_health(predictions, image)
                    
                    self.logger.info(f"Fish health metrics: {health_metrics}")
                    
                time.sleep(1)  # Prevent busy waiting
                
            except Exception as e:
                self.logger.error(f"Fish image processing error: {str(e)}")
                
    def process_plant_images(self):
        """Process plant images for health monitoring"""
        while self.processing_active:
            try:
                if not self.plant_image_queue.empty():
                    image, timestamp = self.plant_image_queue.get()
                    
                    # Convert to PIL Image
                    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
                    
                    # Prepare image for model
                    input_tensor = self.transform(pil_image).unsqueeze(0)
                    
                    # Get predictions
                    with torch.no_grad():
                        predictions = self.plant_health_model(input_tensor)
                    
                    # Analyze plant health indicators
                    health_metrics = self.analyze_plant_health(predictions, image)
                    
                    self.logger.info(f"Plant health metrics: {health_metrics}")
                    
                time.sleep(1)  # Prevent busy waiting
                
            except Exception as e:
                self.logger.error(f"Plant image processing error: {str(e)}")
                
    def analyze_fish_health(self, predictions: torch.Tensor, image: np.ndarray) -> Dict[str, float]:
        """Analyze fish health based on ML predictions and image analysis"""
        # Convert predictions to health metrics
        health_metrics = {
            'activity_level': float(predictions[0]),
            'coloration': float(predictions[1]),
            'swimming_pattern': float(predictions[2]),
            'fish_count': self.count_fish(image),
            'unusual_behavior': float(predictions[3]),
            'overall_health': float(predictions[4])
        }
        
        return health_metrics
        
    def analyze_plant_health(self, predictions: torch.Tensor, image: np.ndarray) -> Dict[str, float]:
        """Analyze plant health based on ML predictions and image analysis"""
        # Convert predictions to health metrics
        health_metrics = {
            'leaf_color': float(predictions[0]),
            'growth_rate': float(predictions[1]),
            'pest_presence': float(predictions[2]),
            'leaf_damage': float(predictions[3]),
            'nutrient_deficiency': float(predictions[4]),
            'overall_health': float(predictions[5])
        }
        
        return health_metrics
        
    def count_fish(self, image: np.ndarray) -> int:
        """Count number of fish in image using computer vision"""
        try:
            # Convert to grayscale
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            
            # Apply background subtraction
            blurred = cv2.GaussianBlur(gray, (5, 5), 0)
            thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1]
            
            # Find contours
            contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
            
            # Filter contours by size to count only fish-sized objects
            fish_contours = [c for c in contours if 100 < cv2.contourArea(c) < 1000]
            
            return len(fish_contours)
            
        except Exception as e:
            self.logger.error(f"Fish counting error: {str(e)}")
            return 0
            
    def detect_plant_disease(self, image: np.ndarray) -> Dict[str, float]:
        """Detect plant diseases using computer vision"""
        try:
            # Convert to HSV color space for better disease detection
            hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
            
            # Define disease indicators (yellow/brown spots, wilting, etc.)
            disease_indicators = {
                'leaf_spots': self.detect_leaf_spots(hsv),
                'wilting': self.detect_wilting(hsv),
                'discoloration': self.detect_discoloration(hsv)
            }
            
            return disease_indicators
            
        except Exception as e:
            self.logger.error(f"Disease detection error: {str(e)}")
            return {}
            
    def cleanup(self):
        """Clean up camera resources"""
        self.processing_active = False
        self.fish_camera.close()
        self.plant_camera.close()

class AquaponicsController:
    def __init__(self, model_path: str = None):
        self.sensor = AquaponicsSensor()
        self.camera = AquaponicsCamera()
        self.model = self.load_model(model_path) if model_path else None
        self.history = []
        self.logger = logging.getLogger(__name__)
        
        # Enhanced optimal ranges including visual metrics
        self.optimal_ranges = {
            # [Previous sensor ranges remain the same]
            'fish_activity_level': (0.7, 1.0),
            'fish_coloration': (0.8, 1.0),
            'plant_health_index': (0.8, 1.0),
            'leaf_color_index': (0.7, 1.0)
        }
    
    def run_cycle(self, interval: int = 300):
        """Run main control cycle with visual monitoring"""
        try:
            while True:
                # Read sensor data
                sensor_data = self.sensor.read_sensors()
                
                # Capture and analyze images
                fish_image, plant_image = self.camera.capture_images()
                
                if sensor_data and fish_image is not None and plant_image is not None:
                    # Combine sensor and visual data
                    combined_data = {
                        **sensor_data,
                        **self.camera.analyze_fish_health(self.model(fish_image), fish_image),
                        **self.camera.analyze_plant_health(self.model(plant_image), plant_image)
                    }
                    
                    # Store in history
                    self.history.append(combined_data)
                    
                    # Get control adjustments
                    adjustments = self.predict_adjustments(combined_data)
                    
                    # Apply controls
                    self.apply_controls(adjustments)
                    
                    # Log state
                    self.logger.info(f"System state: {combined_data}")
                    
                time.sleep(interval)
                
        except KeyboardInterrupt:
            self.cleanup()
            
    def cleanup(self):
        """Cleanup all resources"""
        self.sensor.cleanup()
        self.camera.cleanup()
        GPIO.cleanup()
        self.save_history()
        self.logger.info("System shutdown completed")