initial_commit

app.py

@@ -0,0 +1,257 @@
+# Streamlit Deployment Script
+import cv2
+import numpy as np
+import streamlit as st
+import io
+import base64
+from PIL import Image
+import rembg  # Import rembg for background removal
+
+st.set_page_config(page_title="SpotRadar", layout="wide")
+
+st.title("SpotRadar Disease Detection App Phase 1 Demo by Manith Jayaba")
+st.write("Upload an image to detect and analyze disease spots")
+
+# Function to convert cv2 image to downloadable link
+def get_image_download_link(img, filename, text):
+    buffered = io.BytesIO()
+    img_pil = Image.fromarray(img)
+    img_pil.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode()
+    href = f'<a href="data:file/png;base64,{img_str}" download="{filename}">{text}</a>'
+    return href
+
+# Remove background from the image
+def remove_background(image):
+    try:
+        # Convert BGR to RGB for rembg
+        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Remove the background
+        output = rembg.remove(rgb_image)
+        
+        # Convert back to BGR for OpenCV processing
+        output_bgr = cv2.cvtColor(output, cv2.COLOR_RGBA2BGR)
+        
+        return output_bgr
+    except Exception as e:
+        st.error(f"Error in background removal: {e}")
+        return image
+
+# Preprocessing: Enhance contrast and reduce noise
+def preprocess_image(image, clip_limit=2.0, tile_size=8, blur_kernel_size=5):
+    try:
+        hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=(tile_size, tile_size))
+        h, s, v = cv2.split(hsv_image)
+        v = clahe.apply(v)
+        hsv_image = cv2.merge((h, s, v))
+        enhanced_image = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)
+        blurred_image = cv2.GaussianBlur(enhanced_image, (blur_kernel_size, blur_kernel_size), 0)
+        return blurred_image
+    except Exception as e:
+        st.error(f"Error in preprocessing: {e}")
+        return image
+
+# Detect disease marks using thresholding and edge detection
+def detect_disease_marks(image, threshold_block_size=11, threshold_c=2, canny_low=50, canny_high=150):
+    try:
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                     cv2.THRESH_BINARY_INV, threshold_block_size, threshold_c)
+        edges = cv2.Canny(gray, canny_low, canny_high)
+        combined = cv2.bitwise_or(thresh, edges)
+        kernel = np.ones((3, 3), np.uint8)
+        cleaned = cv2.morphologyEx(combined, cv2.MORPH_CLOSE, kernel)
+        return cleaned
+    except Exception as e:
+        st.error(f"Error in disease detection: {e}")
+        return np.zeros_like(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
+
+# Highlight detected marks and extract color/size info
+def highlight_disease(image, disease_mask):
+    try:
+        result = image.copy()
+        contours, _ = cv2.findContours(disease_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Lists to store disease spot info
+        spot_info = []
+        
+        # Total image area for percentage calculation
+        total_pixels = disease_mask.size
+        
+        for i, contour in enumerate(contours):
+            # Calculate area (size in pixels)
+            area = cv2.contourArea(contour)
+            
+            # Calculate individual spot coverage percentage
+            spot_percentage = (area / total_pixels) * 100
+            
+            # Create a mask for this specific contour
+            spot_mask = np.zeros_like(disease_mask)
+            cv2.drawContours(spot_mask, [contour], -1, 255, thickness=cv2.FILLED)
+            
+            # Extract average color from the original image within the contour
+            mean_color = cv2.mean(image, mask=spot_mask)[:3]  # BGR values
+            mean_color_rgb = (mean_color[2], mean_color[1], mean_color[0])  # Convert to RGB
+            
+            # Store spot info
+            spot_info.append({
+                'spot_number': i + 1,
+                'size_pixels': area,
+                'color_rgb': mean_color_rgb,
+                'coverage_percentage': spot_percentage  # Add individual coverage
+            })
+            
+            # Draw contour and label on the image
+            cv2.drawContours(result, [contour], -1, (0, 0, 255), 2)
+            # Add spot number near the contour
+            M = cv2.moments(contour)
+            if M["m00"] != 0:
+                cX = int(M["m10"] / M["m00"])
+                cY = int(M["m01"] / M["m00"])
+                cv2.putText(result, str(i + 1), (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 
+                           0.5, (255, 255, 255), 1, cv2.LINE_AA)
+        
+        # Optional: Semi-transparent overlay
+        mask_colored = np.zeros_like(image)
+        mask_colored[disease_mask == 255] = [0, 0, 255]
+        result = cv2.addWeighted(result, 0.8, mask_colored, 0.2, 0)
+        
+        return result, spot_info
+    except Exception as e:
+        st.error(f"Error in highlighting: {e}")
+        return image, []
+
+# Calculate total disease coverage
+def calculate_disease_coverage(disease_mask):
+    total_pixels = disease_mask.size
+    disease_pixels = np.count_nonzero(disease_mask)
+    percentage = (disease_pixels / total_pixels) * 100
+    return percentage
+
+# Sidebar for parameters
+with st.sidebar:
+    st.header("Parameters")
+    
+    # Preprocessing parameters
+    st.subheader("Preprocessing")
+    clip_limit = st.slider("CLAHE Clip Limit", 0.5, 5.0, 2.0, 0.1)
+    tile_size = st.slider("CLAHE Tile Size", 2, 16, 8, 1)
+    blur_kernel = st.slider("Blur Kernel Size", 1, 11, 5, 2)
+    
+    # Disease detection parameters
+    st.subheader("Disease Detection")
+    threshold_block_size = st.slider("Threshold Block Size", 3, 21, 11, 2)
+    threshold_c = st.slider("Threshold C Value", 0, 10, 2, 1)
+    canny_low = st.slider("Canny Low Threshold", 10, 100, 50, 5)
+    canny_high = st.slider("Canny High Threshold", 100, 300, 150, 5)
+    
+    # Background removal option
+    remove_bg = st.checkbox("Remove Background", True)
+
+# File uploader
+uploaded_file = st.file_uploader("Choose an image file", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # Convert uploaded file to OpenCV image
+    file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+    image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+    
+    # Create a placeholder for the processed images
+    result_placeholder = st.empty()
+    
+    # Process button
+    if st.button("Process Image"):
+        with st.spinner("Processing image..."):
+            # Remove background if option is selected
+            if remove_bg:
+                no_bg_image = remove_background(image)
+                process_image = no_bg_image
+            else:
+                no_bg_image = image
+                process_image = image
+            
+            # Continue with the normal processing
+            processed_image = preprocess_image(process_image, clip_limit, tile_size, blur_kernel)
+            disease_mask = detect_disease_marks(processed_image, threshold_block_size, threshold_c, canny_low, canny_high)
+            result_image, spot_info = highlight_disease(process_image, disease_mask)
+            
+            # Calculate total disease coverage
+            disease_percentage = calculate_disease_coverage(disease_mask)
+            
+            # Display results in columns
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("Original Image")
+                st.image(cv2.cvtColor(image, cv2.COLOR_BGR2RGB), use_container_width=True)
+                
+                if remove_bg:
+                    st.subheader("Background Removed")
+                    st.image(cv2.cvtColor(no_bg_image, cv2.COLOR_BGR2RGB), use_container_width=True)
+            
+            with col2:
+                st.subheader("Disease Mask")
+                st.image(disease_mask, use_container_width=True)
+                
+                st.subheader(f"Detected Disease Marks (Coverage: {disease_percentage:.2f}%)")
+                st.image(cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB), use_container_width=True)
+                
+                # Download link for the result image
+                st.markdown(
+                    get_image_download_link(
+                        cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB),
+                        "disease_detection_result.png",
+                        "Download Processed Image"
+                    ),
+                    unsafe_allow_html=True
+                )
+            
+            # Display spot information
+            st.subheader("Disease Spot Analysis")
+            
+            if not spot_info:
+                st.info("No disease spots detected.")
+            else:
+                # Sort spot_info by coverage_percentage in descending order
+                spot_info_sorted = sorted(spot_info, key=lambda x: x['coverage_percentage'], reverse=True)
+                
+                # Create a table for spot info
+                spot_data = []
+                for i, spot in enumerate(spot_info_sorted):
+                    spot_data.append({
+                        "Rank": i + 1,
+                        "Spot Number": spot['spot_number'],
+                        "Size (pixels)": f"{spot['size_pixels']:.1f}",
+                        "Coverage (%)": f"{spot['coverage_percentage']:.2f}%",
+                        "Color (RGB)": f"({int(spot['color_rgb'][0])}, {int(spot['color_rgb'][1])}, {int(spot['color_rgb'][2])})"
+                    })
+                
+                st.table(spot_data)
+                
+                # Summary statistics
+                st.subheader("Summary Statistics")
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric("Total Spots", len(spot_info))
+                
+                with col2:
+                    st.metric("Total Coverage", f"{disease_percentage:.2f}%")
+                
+                with col3:
+                    avg_size = sum(spot['size_pixels'] for spot in spot_info) / len(spot_info)
+                    st.metric("Average Spot Size", f"{avg_size:.1f} px")
+else:
+    st.info("Please upload an image to begin analysis.")
+    
+    # Sample image display
+    st.subheader("How it works")
+    st.write("""
+    1. Upload a plant image
+    2. Adjust parameters if needed
+    3. Click 'Process Image'
+    4. View disease detection results and analysis
+    5. Download the processed image
+    """)

requirements.txt

@@ -0,0 +1,6 @@
+opencv-python
+numpy
+matplotlib
+rembg
+onnxruntime
+streamlit