Update src/streamlit_app.py

src/streamlit_app.py

@@ -13,28 +13,566 @@ forums](https://discuss.streamlit.io).
 In the meantime, below is an example of what you can do with just a few lines of code:
 """
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+"""
+Streamlit Web Application for Mango Disease Detection
+Supports image upload, batch processing, and real-time webcam detection
+"""
+
+import streamlit as st
+import os
+import sys
+import tempfile
+import zipfile
+import shutil
+from datetime import datetime
+import cv2
+import numpy as np
+import time
+import threading
+from queue import Queue
+import base64
+from PIL import Image
+import io
+
+# Import the semantic detection system (assuming it's available)
+try:
+    from semantic_disease_analyzer import SemanticDiseaseAnalyzer
+    ANALYZER_AVAILABLE = True
+except ImportError:
+    ANALYZER_AVAILABLE = False
+    st.error("semantic_disease_analyzer module not found. Please ensure it's in your Python path.")
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="Mango Disease Detection",
+    page_icon="🥭",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+class StreamlitMangoDetector:
+    """Streamlit interface for mango disease detection"""
+    
+    def __init__(self):
+        if ANALYZER_AVAILABLE:
+            if 'analyzer' not in st.session_state:
+                with st.spinner("Initializing semantic disease detection system..."):
+                    try:
+                        st.session_state.analyzer = SemanticDiseaseAnalyzer()
+                        st.success("System ready for inference!")
+                    except Exception as e:
+                        st.error(f"Error initializing system: {e}")
+                        st.session_state.analyzer = None
+            self.analyzer = st.session_state.analyzer
+        else:
+            self.analyzer = None
+    
+    def detect_diseases_image(self, image_array, filename="uploaded_image"):
+        """Run disease detection on an image array"""
+        if not self.analyzer:
+            return None
+        
+        try:
+            # Create temporary file path without keeping it open
+            temp_dir = tempfile.gettempdir()
+            temp_filename = f"temp_mango_{int(time.time() * 1000000)}.jpg"
+            temp_path = os.path.join(temp_dir, temp_filename)
+            
+            # Convert to PIL Image
+            if len(image_array.shape) == 3:
+                image = Image.fromarray(image_array)
+            else:
+                image = Image.fromarray(image_array, mode='L')
+            
+            # Handle different image modes for JPEG conversion
+            if image.mode in ('RGBA', 'LA', 'P'):
+                # Convert RGBA/LA/P to RGB by creating white background
+                if image.mode == 'P':
+                    image = image.convert('RGBA')
+                
+                # Create white background
+                background = Image.new('RGB', image.size, (255, 255, 255))
+                if image.mode == 'RGBA':
+                    background.paste(image, mask=image.split()[-1])  # Use alpha channel as mask
+                else:  # LA mode
+                    background.paste(image, mask=image.split()[-1])
+                image = background
+            elif image.mode not in ('RGB', 'L'):
+                # Convert other modes to RGB
+                image = image.convert('RGB')
+            
+            # Save image to temporary path
+            image.save(temp_path, 'JPEG', quality=95)
+            
+            # Explicitly close the image to release file handles
+            image.close()
+            
+            # Run detection
+            results = self.analyzer.analyze_image_semantically(
+                temp_path, save_results=False
+            )
+            
+            # Clean up - try multiple times if needed (Windows file locking issue)
+            max_attempts = 3
+            for attempt in range(max_attempts):
+                try:
+                    if os.path.exists(temp_path):
+                        os.remove(temp_path)
+                    break
+                except (PermissionError, OSError) as e:
+                    if attempt == max_attempts - 1:
+                        st.warning(f"Could not delete temporary file: {temp_path}")
+                    else:
+                        time.sleep(0.1)  # Brief pause before retry
+            
+            return results
+            
+        except Exception as e:
+            # Cleanup on error
+            try:
+                if 'temp_path' in locals() and os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except:
+                pass
+            st.error(f"Detection error: {e}")
+            return None
+    
+    def format_results_for_display(self, results):
+        """Format detection results for Streamlit display"""
+        if not results:
+            return "No results available"
+        
+        # Basic detection info
+        disease_level = results.get('disease_level', 'Unknown')
+        severity = results.get('severity_percentage', 0)
+        num_regions = results.get('num_diseased_regions', 0)
+        
+        # Status indicators
+        status_colors = {
+            'Healthy': 'green',
+            'Early Disease': 'orange', 
+            'Moderate Disease': 'red',
+            'Severe Disease': 'red',
+            'Critical Disease': 'darkred'
+        }
+        
+        status_color = status_colors.get(disease_level, 'gray')
+        
+        # Create formatted output
+        output = f"""
+        ### Detection Results
+        
+        **Status:** <span style="color: {status_color}; font-weight: bold;">{disease_level}</span>
+        
+        **Severity:** {severity:.2f}%
+        
+        **Diseased Regions:** {num_regions}
+        """
+        
+        # Add semantic analysis if available
+        semantic_info = results.get('semantic_info', {})
+        if semantic_info:
+            diseases = semantic_info.get('diseases', [])
+            if diseases:
+                output += "\n**Detected Diseases:**\n"
+                for disease in diseases:
+                    output += f"- {disease['label']}\n"
+            
+            # Economic impact
+            economic_impact = semantic_info.get('economic_impact')
+            if economic_impact:
+                marketability = economic_impact.get('marketability_score', 0)
+                output += f"\n**Marketability Score:** {marketability:.0f}%"
+        
+        # Treatment recommendations
+        inferences = results.get('ontology_inferences', [])
+        treatments = [inf for inf in inferences if any(word in inf.lower() 
+                     for word in ['apply', 'improve', 'remove', 'use', 'avoid', 'reduce'])]
+        
+        if treatments:
+            output += "\n\n**Treatment Recommendations:**\n"
+            for treatment in treatments[:3]:  # Show top 3
+                output += f"- {treatment}\n"
+        
+        # Quality assessment
+        if severity < 2:
+            quality = "Premium Quality"
+            recommendation = "Suitable for premium market sale"
+        elif severity < 8:
+            quality = "Good Quality"
+            recommendation = "Monitor for disease progression"
+        elif severity < 20:
+            quality = "Fair Quality"
+            recommendation = "Consider treatment or reduced price sale"
+        elif severity < 40:
+            quality = "Poor Quality"
+            recommendation = "Not suitable for fresh market, consider processing"
+        else:
+            quality = "Reject"
+            recommendation = "Discard to prevent contamination"
+        
+        output += f"\n**Quality Grade:** {quality}\n"
+        output += f"**Recommendation:** {recommendation}"
+        
+        return output
+
+def main():
+    """Main Streamlit application"""
+    
+    # Header
+    st.title("Mango Disease Detection System")
+    st.markdown("### AI-Powered Semantic Disease Analysis")
+    
+    if not ANALYZER_AVAILABLE:
+        st.error("Cannot proceed without the semantic_disease_analyzer module.")
+        st.stop()
+    
+    # Initialize detector
+    detector = StreamlitMangoDetector()
+    
+    if not detector.analyzer:
+        st.error("Failed to initialize the detection system.")
+        st.stop()
+    
+    # Sidebar for mode selection
+    st.sidebar.title("Detection Mode")
+    mode = st.sidebar.selectbox(
+        "Choose detection mode:",
+        ["Single Image", "Batch Processing", "Webcam Detection", "About"]
+    )
+    
+    if mode == "Single Image":
+        single_image_mode(detector)
+    elif mode == "Batch Processing":
+        batch_processing_mode(detector)
+    elif mode == "Webcam Detection":
+        webcam_mode(detector)
+    elif mode == "About":
+        about_page()
+
+def single_image_mode(detector):
+    """Single image upload and detection"""
+    st.header("Single Image Detection")
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("Upload Image")
+        uploaded_file = st.file_uploader(
+            "Choose a mango image...",
+            type=['jpg', 'jpeg', 'png', 'bmp', 'tiff', 'webp'],
+            help="Upload an image of a mango for disease detection"
+        )
+        
+        if uploaded_file is not None:
+            # Display uploaded image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_column_width=True)
+            
+            # Convert to array
+            image_array = np.array(image)
+            
+            # Detection button
+            if st.button("Analyze Disease", type="primary"):
+                with st.spinner("Analyzing image..."):
+                    results = detector.detect_diseases_image(image_array, uploaded_file.name)
+                
+                if results:
+                    # Store results in session state
+                    st.session_state.current_results = results
+                    st.success("Analysis complete!")
+                else:
+                    st.error("Analysis failed!")
+    
+    with col2:
+        st.subheader("Detection Results")
+        
+        if 'current_results' in st.session_state and st.session_state.current_results:
+            results = st.session_state.current_results
+            
+            # Display processed image if available
+            if 'output_image' in results:
+                output_image = results['output_image']
+                st.image(output_image, caption="Detection Results", use_column_width=True)
+                
+                # Download button for processed image
+                is_success, im_buf_arr = cv2.imencode(".jpg", output_image)
+                if is_success:
+                    byte_im = im_buf_arr.tobytes()
+                    st.download_button(
+                        label="Download Result",
+                        data=byte_im,
+                        file_name=f"detection_result_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg",
+                        mime="image/jpeg"
+                    )
+            
+            # Display formatted results
+            formatted_results = detector.format_results_for_display(results)
+            st.markdown(formatted_results, unsafe_allow_html=True)
+            
+            # Raw results expander
+            with st.expander("View Raw Results"):
+                st.json(results)
+        else:
+            st.info("Upload an image and click 'Analyze Disease' to see results here.")
+
+def batch_processing_mode(detector):
+    """Batch processing for multiple images"""
+    st.header("Batch Processing")
+    
+    st.info("Upload multiple images in a ZIP file for batch processing.")
+    
+    uploaded_zip = st.file_uploader(
+        "Upload ZIP file containing images:",
+        type=['zip'],
+        help="ZIP file should contain .jpg, .jpeg, .png, .bmp, .tiff, or .webp images"
+    )
+    
+    if uploaded_zip is not None:
+        if st.button("Process Batch", type="primary"):
+            process_batch(detector, uploaded_zip)
+
+def process_batch(detector, uploaded_zip):
+    """Process batch of images from ZIP file"""
+    try:
+        # Create temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Extract ZIP file
+            zip_path = os.path.join(temp_dir, "upload.zip")
+            with open(zip_path, "wb") as f:
+                f.write(uploaded_zip.getbuffer())
+            
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            # Find image files
+            image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp']
+            image_files = []
+            
+            for root, dirs, files in os.walk(temp_dir):
+                for file in files:
+                    if any(file.lower().endswith(ext) for ext in image_extensions):
+                        image_files.append(os.path.join(root, file))
+            
+            if not image_files:
+                st.error("No valid image files found in the ZIP archive.")
+                return
+            
+            st.info(f"Found {len(image_files)} images to process.")
+            
+            # Process images
+            results_list = []
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            for i, image_path in enumerate(image_files):
+                status_text.text(f"Processing {os.path.basename(image_path)}...")
+                
+                try:
+                    # Load and process image with proper file handling
+                    with Image.open(image_path) as img:
+                        # Convert image to array
+                        image_array = np.array(img)
+                    
+                    results = detector.detect_diseases_image(image_array, os.path.basename(image_path))
+                    
+                    if results:
+                        results['filename'] = os.path.basename(image_path)
+                        results_list.append(results)
+                    else:
+                        st.warning(f"Failed to process: {os.path.basename(image_path)}")
+                
+                except Exception as e:
+                    st.warning(f"Error processing {os.path.basename(image_path)}: {str(e)}")
+                
+                progress_bar.progress((i + 1) / len(image_files))
+            
+            status_text.text("Batch processing complete!")
+            
+            # Display results summary
+            display_batch_results(results_list)
+            
+    except Exception as e:
+        st.error(f"Error processing batch: {e}")
+
+def display_batch_results(results_list):
+    """Display batch processing results"""
+    st.subheader("Batch Results Summary")
+    
+    if not results_list:
+        st.warning("No successful detections in batch.")
+        return
+    
+    # Create summary statistics
+    healthy_count = sum(1 for r in results_list if r.get('disease_level') == 'Healthy')
+    diseased_count = len(results_list) - healthy_count
+    avg_severity = np.mean([r.get('severity_percentage', 0) for r in results_list])
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Total Images", len(results_list))
+    
+    with col2:
+        st.metric("Healthy", healthy_count, delta=f"{healthy_count/len(results_list)*100:.1f}%")
+    
+    with col3:
+        st.metric("Diseased", diseased_count, delta=f"{diseased_count/len(results_list)*100:.1f}%")
+    
+    with col4:
+        st.metric("Avg Severity", f"{avg_severity:.1f}%")
+    
+    # Detailed results table
+    st.subheader("Detailed Results")
+    
+    # Create results dataframe
+    table_data = []
+    for result in results_list:
+        table_data.append({
+            'Filename': result.get('filename', 'Unknown'),
+            'Status': result.get('disease_level', 'Unknown'),
+            'Severity (%)': f"{result.get('severity_percentage', 0):.1f}",
+            'Diseased Regions': result.get('num_diseased_regions', 0),
+            'Quality': get_quality_grade(result.get('severity_percentage', 0))
+        })
+    
+    st.dataframe(table_data, use_container_width=True)
+    
+    # Download results as CSV
+    if st.button("Download Results CSV"):
+        import pandas as pd
+        df = pd.DataFrame(table_data)
+        csv = df.to_csv(index=False)
+        st.download_button(
+            label="Download CSV",
+            data=csv,
+            file_name=f"batch_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+            mime="text/csv"
+        )
+
+def get_quality_grade(severity):
+    """Get quality grade based on severity"""
+    if severity < 2:
+        return "Premium"
+    elif severity < 8:
+        return "Good"
+    elif severity < 20:
+        return "Fair"
+    elif severity < 40:
+        return "Poor"
+    else:
+        return "Reject"
+
+def webcam_mode(detector):
+    """Real-time webcam detection"""
+    st.header("Real-time Webcam Detection")
+    
+    st.warning("Webcam detection requires additional setup and may not work in all deployment environments.")
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("Camera Controls")
+        
+        if st.button("Start Webcam"):
+            st.info("Webcam functionality would require additional WebRTC setup for Streamlit deployment.")
+            st.code("""
+            # For local development, you could use:
+            import cv2
+            
+            cap = cv2.VideoCapture(0)
+            
+            # This would need proper WebRTC integration
+            # for Streamlit deployment
+            """)
+        
+        # Camera settings
+        st.selectbox("Camera Quality", ["High (720p)", "Medium (480p)", "Low (360p)"])
+        st.slider("Detection Frequency", 1, 30, 5, help="Analyze every Nth frame")
+    
+    with col2:
+        st.subheader("Live Detection")
+        st.info("Live webcam feed would appear here with real-time disease detection overlay.")
+        
+        # Placeholder for webcam feed
+        st.image("https://via.placeholder.com/640x480/cccccc/666666?text=Webcam+Feed+Placeholder", 
+                caption="Live Camera Feed")
+
+def about_page():
+    """About page with system information"""
+    st.header("About Mango Disease Detection System")
+    
+    st.markdown("""
+    ### System Overview
+    
+    This AI-powered system uses computer vision and semantic analysis to detect diseases in mango fruits. 
+    The system combines:
+    
+    - **Computer Vision**: Deep learning models for image analysis
+    - **Semantic Reasoning**: Ontology-based knowledge inference
+    - **Real-time Processing**: Fast detection suitable for commercial use
+    
+    ### Detection Capabilities
+    
+    The system can detect and classify:
+    - **Healthy mangoes**: No visible disease symptoms
+    - **Early disease**: Minor symptoms requiring monitoring
+    - **Moderate/Severe disease**: Clear symptoms requiring treatment
+    - **Critical disease**: Severe damage requiring disposal
+    
+    ### Analysis Features
+    
+    - **Disease Classification**: Specific disease type identification
+    - **Severity Assessment**: Quantitative severity percentage
+    - **Economic Impact**: Marketability scoring
+    - **Treatment Recommendations**: AI-generated suggestions
+    - **Quality Grading**: Commercial quality assessment
+    
+    ### Usage Modes
+    
+    1. **Single Image**: Upload individual images for analysis
+    2. **Batch Processing**: Process multiple images in ZIP format
+    3. **Real-time Detection**: Live webcam analysis (requires setup)
+    
+    ### Technical Details
+    
+    - Built with Streamlit for web interface
+    - Semantic analysis using OWL-RL reasoning
+    - Computer vision with deep learning models
+    - Supports common image formats (JPG, PNG, BMP, TIFF)
+    
+    ### Usage Tips
+    
+    - Use high-quality, well-lit images for best results
+    - Ensure mango is clearly visible in the frame
+    - Multiple angles can provide more comprehensive analysis
+    - Regular monitoring helps track disease progression
+    
+    ---
+    
+    *For technical support or questions about the detection algorithms, 
+    please refer to the system documentation.*
+    """)
+    
+    # System status
+    st.subheader("System Status")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if ANALYZER_AVAILABLE:
+            st.success("Analyzer Available")
+        else:
+            st.error("Analyzer Unavailable")
+    
+    with col2:
+        st.info(f"Session: {datetime.now().strftime('%Y-%m-%d %H:%M')}")
+    
+    with col3:
+        if 'analyzer' in st.session_state and st.session_state.analyzer:
+            st.success("System Ready")
+        else:
+            st.warning("System Not Ready")
+
+if __name__ == "__main__":
+    main()