Add disease detection app with RF-DETR and SAM2

app.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+CropDoctor - Plant Disease Detection
+Hugging Face Space Demo
+"""
+
+import gradio as gr
+import numpy as np
+from PIL import Image
+from pathlib import Path
+import torch
+
+# Model paths
+MODEL_DIR = Path("models")
+RFDETR_CHECKPOINT = MODEL_DIR / "rfdetr" / "checkpoint_best_total.pth"
+SAM2_CHECKPOINT = MODEL_DIR / "sam2" / "sam2.1_hiera_small.pt"
+
+# Lazy loaded components
+segmenter = None
+leaf_segmenter = None
+
+
+def load_models():
+    """Load models on first use."""
+    global segmenter, leaf_segmenter
+
+    if segmenter is not None:
+        return
+
+    print("Loading models...")
+
+    # Import here to avoid loading at startup
+    from src.sam3_segmentation import RFDETRSegmenter
+    from src.leaf_segmenter import SAM2LeafSegmenter
+
+    # Load RF-DETR for disease detection
+    segmenter = RFDETRSegmenter(
+        checkpoint_path=str(RFDETR_CHECKPOINT),
+        model_size="medium"
+    )
+
+    # Load SAM2 for leaf segmentation and mask refinement
+    leaf_segmenter = SAM2LeafSegmenter(
+        checkpoint_path=str(SAM2_CHECKPOINT)
+    )
+
+    print("Models loaded!")
+
+
+def detect_disease(
+    image: np.ndarray,
+    use_leaf_segmentation: bool = True,
+    confidence_threshold: float = 0.3
+) -> tuple:
+    """
+    Detect plant diseases in an image.
+
+    Args:
+        image: Input image
+        use_leaf_segmentation: Whether to isolate leaf first
+        confidence_threshold: Detection confidence threshold
+
+    Returns:
+        Tuple of (annotated_image, detection_info)
+    """
+    if image is None:
+        return None, "Please upload an image"
+
+    load_models()
+
+    # Convert to PIL
+    pil_image = Image.fromarray(image)
+    original_image = image.copy()
+
+    # Step 1: Leaf segmentation (optional)
+    segmented_image = None
+    leaf_mask = None
+    if use_leaf_segmentation:
+        segmented_pil, leaf_mask = leaf_segmenter.auto_segment_leaf(
+            pil_image, return_mask=True
+        )
+        segmented_image = np.array(segmented_pil)
+        detection_input = segmented_pil
+    else:
+        detection_input = pil_image
+
+    # Step 2: Disease detection with RF-DETR
+    prompts = ["diseased plant tissue", "leaf spot", "disease symptom"]
+    seg_result = segmenter.segment_with_concepts(
+        detection_input,
+        prompts,
+        confidence_threshold=confidence_threshold
+    )
+
+    num_detections = len(seg_result.boxes)
+
+    # Step 3: Refine boxes to masks with SAM2
+    if num_detections > 0:
+        refined_masks = leaf_segmenter.refine_boxes_to_masks(
+            detection_input,
+            seg_result.boxes
+        )
+    else:
+        refined_masks = np.zeros((0, image.shape[0], image.shape[1]), dtype=bool)
+
+    # Create visualization
+    from src.visualization import create_mask_overlay
+
+    if use_leaf_segmentation and segmented_image is not None:
+        base_image = segmented_image
+    else:
+        base_image = original_image
+
+    if num_detections > 0:
+        annotated = create_mask_overlay(base_image, refined_masks, alpha=0.5)
+    else:
+        annotated = base_image
+
+    # Format detection info
+    if num_detections == 0:
+        info = "### No disease detected\n\nThe leaf appears healthy or no disease symptoms were found."
+    else:
+        # Calculate affected area
+        total_mask = np.zeros(refined_masks[0].shape, dtype=bool)
+        for mask in refined_masks:
+            total_mask |= mask
+
+        if use_leaf_segmentation and leaf_mask is not None:
+            affected_percent = (total_mask & leaf_mask).sum() / max(leaf_mask.sum(), 1) * 100
+        else:
+            affected_percent = total_mask.sum() / (image.shape[0] * image.shape[1]) * 100
+
+        info = f"""### Disease Detected
+
+- **Regions found**: {num_detections}
+- **Affected area**: {affected_percent:.1f}%
+- **Confidence threshold**: {confidence_threshold:.0%}
+
+The colored overlays show detected disease regions.
+"""
+
+    return annotated, info
+
+
+def create_demo():
+    """Create Gradio interface."""
+
+    with gr.Blocks(title="CropDoctor - Plant Disease Detection") as demo:
+
+        gr.Markdown("""
+# CropDoctor - Plant Disease Detection
+
+Upload a plant leaf image to detect disease regions using AI.
+
+**Models used:**
+- **RF-DETR**: Fine-tuned object detector for disease localization
+- **SAM2**: Segment Anything Model 2 for precise mask generation
+        """)
+
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(
+                    label="Upload Plant Image",
+                    type="numpy",
+                    height=400
+                )
+
+                with gr.Row():
+                    leaf_seg_checkbox = gr.Checkbox(
+                        value=True,
+                        label="Isolate leaf (SAM2)",
+                        info="Segment leaf before detection to reduce false positives"
+                    )
+                    confidence_slider = gr.Slider(
+                        minimum=0.1,
+                        maximum=0.9,
+                        value=0.3,
+                        step=0.05,
+                        label="Confidence Threshold"
+                    )
+
+                detect_btn = gr.Button("Detect Disease", variant="primary", size="lg")
+
+            with gr.Column():
+                output_image = gr.Image(
+                    label="Detection Result",
+                    type="numpy",
+                    height=400
+                )
+                detection_info = gr.Markdown(
+                    label="Detection Info",
+                    value="Upload an image and click 'Detect Disease' to see results."
+                )
+
+        # Event handler
+        detect_btn.click(
+            fn=detect_disease,
+            inputs=[input_image, leaf_seg_checkbox, confidence_slider],
+            outputs=[output_image, detection_info]
+        )
+
+        gr.Markdown("""
+---
+**Note**: This demo uses models trained on the PlantVillage dataset.
+For best results, use clear images of individual plant leaves.
+        """)
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch()

configs/sam3_config.yaml

@@ -0,0 +1,138 @@
+# SAM 3 Configuration for CropDoctor-Semantic
+# ============================================
+
+model:
+  name: "sam3"
+  checkpoint: "models/sam3/sam3.pt"
+  device: "cuda"  # cuda, cpu, mps
+  half_precision: true  # Use FP16 for faster inference
+  
+inference:
+  # Confidence thresholds
+  confidence_threshold: 0.25
+  presence_threshold: 0.5
+  
+  # Object limits
+  max_objects_per_prompt: 50
+  min_mask_area: 100  # pixels
+  
+  # Post-processing
+  apply_nms: true
+  nms_threshold: 0.5
+  
+# Disease detection prompts (ordered by specificity)
+prompts:
+  # General disease detection
+  general:
+    - "diseased plant tissue"
+    - "infected leaf area"
+    - "plant disease symptoms"
+    - "abnormal leaf coloration"
+    
+  # Healthy reference
+  healthy:
+    - "healthy green leaf"
+    - "normal plant tissue"
+    - "unaffected leaf area"
+    
+  # Fungal diseases
+  fungal:
+    - "powdery mildew coating"
+    - "rust pustules on leaf"
+    - "leaf spot lesions"
+    - "anthracnose dark lesions"
+    - "downy mildew"
+    - "gray mold"
+    - "scab lesions"
+    
+  # Bacterial diseases  
+  bacterial:
+    - "bacterial blight"
+    - "water-soaked lesions"
+    - "angular leaf spots"
+    - "bacterial canker"
+    - "soft rot"
+    
+  # Viral diseases
+  viral:
+    - "mosaic pattern on leaf"
+    - "leaf curl symptoms"
+    - "yellowing veins"
+    - "ring spots"
+    - "stunted growth"
+    
+  # Nutrient deficiency
+  nutrient:
+    - "chlorosis yellowing"
+    - "interveinal chlorosis"
+    - "purple leaf coloration"
+    - "brown leaf edges"
+    - "pale green leaves"
+    
+  # Pest damage
+  pest:
+    - "insect chewing damage"
+    - "leaf mining trails"
+    - "aphid colony"
+    - "caterpillar damage"
+    - "mite damage stippling"
+    - "holes in leaves"
+
+# Prompt combinations for comprehensive analysis
+analysis_profiles:
+  quick_scan:
+    prompts:
+      - "diseased plant tissue"
+      - "healthy green leaf"
+    description: "Fast binary healthy/diseased detection"
+    
+  standard:
+    prompts:
+      - "diseased plant tissue"
+      - "leaf spot lesions"
+      - "yellowing leaves"
+      - "pest damage"
+    description: "Standard multi-symptom analysis"
+    
+  comprehensive:
+    prompts:
+      - "diseased plant tissue"
+      - "powdery mildew"
+      - "rust pustules"
+      - "bacterial blight"
+      - "mosaic pattern"
+      - "chlorosis"
+      - "insect damage"
+      - "healthy tissue"
+    description: "Full diagnostic scan"
+    
+  pest_focused:
+    prompts:
+      - "insect chewing damage"
+      - "leaf mining trails"
+      - "aphid infestation"
+      - "caterpillar damage"
+      - "mite stippling"
+    description: "Pest-specific detection"
+
+# Visualization settings
+visualization:
+  mask_alpha: 0.5
+  colormap: "viridis"
+  show_confidence: true
+  save_format: "png"
+  dpi: 150
+  
+  # Color scheme for severity
+  severity_colors:
+    healthy: [0, 255, 0]      # Green
+    mild: [255, 255, 0]       # Yellow
+    moderate: [255, 165, 0]   # Orange
+    severe: [255, 0, 0]       # Red
+
+# Performance optimization
+optimization:
+  batch_size: 1
+  num_workers: 4
+  prefetch_factor: 2
+  pin_memory: true

models/rfdetr/checkpoint_best_total.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e24e651f9f144db066cd372fc12f24f8d3a3400d9fddb514638ca513f65d3152
+size 133680431

models/sam2/sam2.1_hiera_small.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d1aa6f30de5c92224f8172114de081d104bbd23dd9dc5c58996f0cad5dc4d38
+size 184416285

requirements.txt

@@ -0,0 +1,12 @@
+# Requirements for Hugging Face Space
+gradio>=4.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+numpy>=1.24.0
+Pillow>=9.0.0
+opencv-python-headless>=4.8.0
+supervision>=0.16.0
+rfdetr
+sam2
+scipy
+PyYAML

src/__init__.py

@@ -0,0 +1,98 @@
+"""
+CropDoctor-Semantic: AI-Powered Plant Disease Diagnosis
+========================================================
+
+A comprehensive pipeline for plant disease diagnosis using:
+- SAM 3 (Segment Anything Model 3) for concept-based segmentation
+- CNN-based severity classification
+- LLM-powered treatment recommendations
+
+Main Components:
+    - SAM3Segmenter: Zero-shot disease region segmentation
+    - SeverityClassifier: CNN for severity assessment
+    - TreatmentRecommender: Claude API integration for treatment advice
+    - CropDoctorPipeline: End-to-end diagnostic pipeline
+
+Quick Start:
+    >>> from src.pipeline import CropDoctorPipeline
+    >>> pipeline = CropDoctorPipeline()
+    >>> result = pipeline.diagnose("path/to/leaf.jpg")
+    >>> print(result.disease_name, result.severity_label)
+
+For more information, see the README.md or documentation.
+"""
+
+__version__ = "0.1.0"
+__author__ = "CropDoctor Team"
+
+from .sam3_segmentation import (
+    SAM3Segmenter,
+    MockSAM3Segmenter,
+    create_segmenter,
+    SegmentationResult
+)
+
+from .severity_classifier import (
+    SeverityClassifier,
+    SeverityClassifierCNN,
+    SeverityPrediction,
+    SEVERITY_LABELS,
+    SEVERITY_DESCRIPTIONS
+)
+
+from .treatment_recommender import (
+    TreatmentRecommender,
+    TreatmentRecommendation,
+    DISEASE_DATABASE
+)
+
+from .pipeline import (
+    CropDoctorPipeline,
+    DiagnosticResult,
+    quick_diagnose
+)
+
+from .visualization import (
+    create_diagnostic_visualization,
+    create_mask_overlay,
+    create_severity_heatmap,
+    create_comparison_view,
+    create_treatment_card,
+    save_visualization
+)
+
+__all__ = [
+    # Version
+    '__version__',
+    
+    # Segmentation
+    'SAM3Segmenter',
+    'MockSAM3Segmenter',
+    'create_segmenter',
+    'SegmentationResult',
+    
+    # Classification
+    'SeverityClassifier',
+    'SeverityClassifierCNN',
+    'SeverityPrediction',
+    'SEVERITY_LABELS',
+    'SEVERITY_DESCRIPTIONS',
+    
+    # Recommendations
+    'TreatmentRecommender',
+    'TreatmentRecommendation',
+    'DISEASE_DATABASE',
+    
+    # Pipeline
+    'CropDoctorPipeline',
+    'DiagnosticResult',
+    'quick_diagnose',
+    
+    # Visualization
+    'create_diagnostic_visualization',
+    'create_mask_overlay',
+    'create_severity_heatmap',
+    'create_comparison_view',
+    'create_treatment_card',
+    'save_visualization',
+]

src/gradio_demo.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""
+Gradio Demo for CropDoctor-Semantic
+====================================
+
+Interactive web interface for plant disease diagnosis.
+
+Usage:
+    python src/gradio_demo.py
+    
+Then open http://localhost:7860 in your browser.
+"""
+
+import gradio as gr
+import numpy as np
+from PIL import Image
+from pathlib import Path
+from datetime import datetime
+import sys
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.pipeline import CropDoctorPipeline, DiagnosticResult
+from src.visualization import create_mask_overlay, SEVERITY_COLORS
+from src.treatment_recommender import TreatmentRecommender
+
+# Initialize pipeline with mock for demo
+# Set use_mock_sam3=False when you have SAM 3 installed
+pipeline = None
+
+# Output directory for saving results
+OUTPUT_DIR = Path("output")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+
+def get_pipeline(use_leaf_segmentation: bool = False):
+    """Lazy load pipeline."""
+    global pipeline
+    if pipeline is None:
+        pipeline = CropDoctorPipeline(
+            classifier_checkpoint="models/severity_classifier/best.pt",
+            use_mock_sam3=False,
+            use_rfdetr=True,
+            rfdetr_checkpoint="models/rfdetr/checkpoint_best_total.pth",
+            use_llm=False,
+            use_leaf_segmentation=use_leaf_segmentation,
+            sam2_checkpoint="models/sam2/sam2.1_hiera_small.pt"
+        )
+    # Update leaf segmentation setting
+    pipeline.use_leaf_segmentation = use_leaf_segmentation
+    return pipeline
+
+
+def diagnose_image(
+    image: np.ndarray,
+    plant_species: str,
+    analysis_profile: str,
+    use_leaf_segmentation: bool = True
+) -> tuple:
+    """
+    Main diagnosis function for Gradio.
+
+    Args:
+        image: Input image from Gradio
+        plant_species: Selected plant species
+        analysis_profile: Analysis profile to use
+        use_leaf_segmentation: Whether to segment leaf before detection
+
+    Returns:
+        Tuple of (annotated_image, diagnosis_text, treatment_text, severity_label)
+    """
+    if image is None:
+        return None, "Please upload an image", "", "unknown"
+
+    # Generate unique timestamp for this request
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    request_dir = OUTPUT_DIR / timestamp
+    request_dir.mkdir(exist_ok=True)
+
+    # Save original image
+    original_pil = Image.fromarray(image)
+    original_pil.save(request_dir / "original.png")
+
+    # Get pipeline with leaf segmentation option
+    pipe = get_pipeline(use_leaf_segmentation=use_leaf_segmentation)
+
+    # Get segmented leaf image if enabled
+    segmented_image = None
+    if use_leaf_segmentation:
+        segmented_pil, leaf_mask = pipe.leaf_segmenter.auto_segment_leaf(
+            original_pil, return_mask=True
+        )
+        segmented_image = np.array(segmented_pil)
+        # Save segmented leaf (no annotations yet)
+        segmented_pil.save(request_dir / "segmented_leaf.png")
+
+    # Run diagnosis
+    result = pipe.diagnose(
+        image,
+        plant_species=plant_species if plant_species != "Auto-detect" else None,
+        analysis_profile=analysis_profile.lower().replace(" ", "_"),
+        return_masks=True
+    )
+
+    # Create annotated images
+    # 1. Annotated original
+    if result.segmentation_masks is not None and len(result.segmentation_masks) > 0:
+        annotated_original = create_mask_overlay(
+            image,
+            result.segmentation_masks,
+            alpha=0.5
+        )
+        Image.fromarray(annotated_original).save(request_dir / "annotated_original.png")
+
+        # 2. Annotated segmented (if leaf segmentation enabled)
+        if segmented_image is not None:
+            annotated_segmented = create_mask_overlay(
+                segmented_image,
+                result.segmentation_masks,
+                alpha=0.5
+            )
+            Image.fromarray(annotated_segmented).save(request_dir / "annotated_segmented.png")
+        else:
+            annotated_segmented = annotated_original
+    else:
+        annotated_original = image
+        annotated_segmented = segmented_image if segmented_image is not None else image
+        Image.fromarray(annotated_original).save(request_dir / "annotated_original.png")
+        if segmented_image is not None:
+            Image.fromarray(segmented_image).save(request_dir / "annotated_segmented.png")
+
+    # Format diagnosis text
+    diagnosis_text = format_diagnosis(result)
+
+    # Format treatment text
+    treatment_text = format_treatment(result)
+
+    # Severity for color coding
+    severity = result.severity_label.lower()
+
+    # Add output path info to diagnosis
+    diagnosis_text += f"\n\n---\n*Output saved to: `{request_dir}`*"
+
+    # Return the segmented+annotated image (or original annotated if no segmentation)
+    display_image = annotated_segmented if use_leaf_segmentation else annotated_original
+
+    return display_image, diagnosis_text, treatment_text, severity
+
+
+def format_diagnosis(result: DiagnosticResult) -> str:
+    """Format diagnosis results as markdown."""
+    
+    severity_emoji = {
+        "healthy": "🟢",
+        "mild": "🟡", 
+        "moderate": "🟠",
+        "severe": "🔴"
+    }
+    
+    emoji = severity_emoji.get(result.severity_label.lower(), "⚪")
+    
+    text = f"""
+## 📋 Diagnostic Results
+
+### Disease Identification
+- **Disease**: {result.disease_name}
+- **Type**: {result.disease_type.capitalize()}
+- **Confidence**: {result.disease_confidence:.0%}
+
+### Severity Assessment
+- **Level**: {emoji} **{result.severity_label.upper()}** (Level {result.severity_level}/3)
+- **Affected Area**: {result.affected_area_percent:.1f}%
+- **Confidence**: {result.severity_confidence:.0%}
+
+### Detected Symptoms
+"""
+    
+    if result.detected_symptoms:
+        for symptom in result.detected_symptoms:
+            text += f"- {symptom}\n"
+    else:
+        text += "- No disease symptoms detected\n"
+        
+    text += f"""
+### Urgency
+**{result.urgency.upper()}** - {"Immediate action required!" if result.urgency == "critical" else "Monitor and treat as recommended."}
+"""
+    
+    return text
+
+
+def format_treatment(result: DiagnosticResult) -> str:
+    """Format treatment recommendations as markdown."""
+    
+    text = f"""
+## 🌿 Treatment Recommendations
+
+### Organic Treatments
+"""
+    
+    for i, treatment in enumerate(result.organic_treatments[:5], 1):
+        text += f"{i}. {treatment}\n"
+        
+    if result.chemical_treatments:
+        text += "\n### Chemical Treatments\n"
+        for i, treatment in enumerate(result.chemical_treatments[:3], 1):
+            text += f"{i}. {treatment}\n"
+            
+    text += "\n### Preventive Measures\n"
+    for i, measure in enumerate(result.preventive_measures[:5], 1):
+        text += f"{i}. {measure}\n"
+        
+    text += f"""
+### Application Timing
+{result.treatment_timing}
+
+---
+*Note: These recommendations are AI-generated. Always consult with a local agricultural expert for critical decisions.*
+"""
+    
+    return text
+
+
+def create_demo():
+    """Create Gradio interface."""
+    
+    # Custom CSS
+    css = """
+    .severity-healthy { background-color: #2ECC71 !important; }
+    .severity-mild { background-color: #F1C40F !important; }
+    .severity-moderate { background-color: #E67E22 !important; }
+    .severity-severe { background-color: #E74C3C !important; }
+    
+    .diagnosis-panel {
+        border-left: 4px solid #3498DB;
+        padding-left: 1rem;
+    }
+    
+    .treatment-panel {
+        border-left: 4px solid #27AE60;
+        padding-left: 1rem;
+    }
+    """
+    
+    # Plant species options
+    plant_species = [
+        "Auto-detect",
+        "Apple",
+        "Grape",
+        "Tomato",
+        "Corn/Maize",
+        "Potato",
+        "Pepper",
+        "Strawberry",
+        "Cherry",
+        "Peach",
+        "Citrus",
+        "Rice",
+        "Wheat",
+        "Other"
+    ]
+    
+    # Analysis profiles
+    profiles = [
+        "Quick Scan",
+        "Standard",
+        "Comprehensive",
+        "Pest Focused"
+    ]
+    
+    # Example images (you can add real examples here)
+    examples = [
+        ["examples/healthy_tomato.jpg", "Tomato", "Standard"],
+        ["examples/leaf_spot.jpg", "Apple", "Comprehensive"],
+        ["examples/powdery_mildew.jpg", "Grape", "Standard"],
+    ]
+    
+    with gr.Blocks(css=css, title="CropDoctor-Semantic") as demo:
+        
+        gr.Markdown("""
+        # 🌱 CropDoctor-Semantic
+        ### AI-Powered Plant Disease Diagnosis with SAM 3
+        
+        Upload an image of a plant leaf to get instant disease diagnosis and treatment recommendations.
+        
+        ---
+        """)
+        
+        with gr.Row():
+            # Left column - Input
+            with gr.Column(scale=1):
+                input_image = gr.Image(
+                    label="📷 Upload Plant Image",
+                    type="numpy",
+                    height=400
+                )
+                
+                with gr.Row():
+                    species_dropdown = gr.Dropdown(
+                        choices=plant_species,
+                        value="Auto-detect",
+                        label="🌿 Plant Species"
+                    )
+                    profile_dropdown = gr.Dropdown(
+                        choices=profiles,
+                        value="Standard",
+                        label="🔍 Analysis Profile"
+                    )
+
+                leaf_seg_checkbox = gr.Checkbox(
+                    value=True,
+                    label="🍃 Isoler la feuille (SAM2)",
+                    info="Segmente la feuille avant la detection pour reduire les faux positifs"
+                )
+
+                diagnose_btn = gr.Button(
+                    "🔬 Analyze Plant",
+                    variant="primary",
+                    size="lg"
+                )
+                
+            # Right column - Output  
+            with gr.Column(scale=1):
+                output_image = gr.Image(
+                    label="🎯 Detection Results",
+                    type="numpy",
+                    height=400
+                )
+                
+                severity_label = gr.Textbox(
+                    label="Severity",
+                    visible=False
+                )
+                
+        with gr.Row():
+            # Diagnosis panel
+            with gr.Column(scale=1, elem_classes=["diagnosis-panel"]):
+                diagnosis_output = gr.Markdown(
+                    label="Diagnosis",
+                    value="Upload an image and click 'Analyze Plant' to see results."
+                )
+                
+            # Treatment panel
+            with gr.Column(scale=1, elem_classes=["treatment-panel"]):
+                treatment_output = gr.Markdown(
+                    label="Treatment",
+                    value="Treatment recommendations will appear here."
+                )
+                
+        # Examples section
+        gr.Markdown("### 📚 Example Images")
+        gr.Markdown("*Click an example to try it out (examples require actual image files)*")
+        
+        # Event handlers
+        diagnose_btn.click(
+            fn=diagnose_image,
+            inputs=[input_image, species_dropdown, profile_dropdown, leaf_seg_checkbox],
+            outputs=[output_image, diagnosis_output, treatment_output, severity_label]
+        )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        ### About
+        
+        **CropDoctor-Semantic** uses cutting-edge AI technology:
+        - **SAM 3** (Segment Anything Model 3) for concept-based segmentation
+        - **Deep Learning** for severity classification
+        - **Claude AI** for intelligent treatment recommendations
+        
+        ⚠️ *This is a demo version. For production use, install SAM 3 and configure the Anthropic API.*
+        
+        📊 **Impact**: Plant diseases cause $220 billion in agricultural losses annually.
+        Early detection can significantly reduce crop losses.
+        
+        ---
+        *Built with ❤️ for sustainable agriculture*
+        """)
+        
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch(
+        share=False,  # Set to True for public link
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )

src/leaf_segmenter.py

@@ -0,0 +1,388 @@
+"""
+Leaf Segmentation using SAM2.
+
+This module provides leaf segmentation functionality to isolate leaves
+from backgrounds before disease detection.
+"""
+
+import numpy as np
+from PIL import Image
+from typing import Optional, Tuple
+import torch
+
+
+class SAM2LeafSegmenter:
+    """
+    Segments leaves from images using SAM2 (Segment Anything Model 2).
+
+    This is used as a preprocessing step to:
+    1. Isolate the leaf from the background
+    2. Create a white background image with just the leaf
+    3. Reduce false positives in disease detection
+    """
+
+    def __init__(
+        self,
+        checkpoint_path: str = "models/sam2/sam2.1_hiera_small.pt",
+        config_file: str = "configs/sam2.1/sam2.1_hiera_s.yaml",
+        device: Optional[str] = None
+    ):
+        """
+        Initialize SAM2 leaf segmenter.
+
+        Args:
+            checkpoint_path: Path to SAM2 checkpoint
+            config_file: SAM2 config file name
+            device: Device to use ('cuda', 'mps', 'cpu'). Auto-detected if None.
+        """
+        self.checkpoint_path = checkpoint_path
+        self.config_file = config_file
+
+        if device is None:
+            if torch.cuda.is_available():
+                self.device = 'cuda'
+            elif torch.backends.mps.is_available():
+                self.device = 'mps'
+            else:
+                self.device = 'cpu'
+        else:
+            self.device = device
+
+        self.model = None
+        self.predictor = None
+
+    def load_model(self):
+        """Load SAM2 model."""
+        if self.model is not None:
+            return
+
+        from sam2.build_sam import build_sam2
+        from sam2.sam2_image_predictor import SAM2ImagePredictor
+
+        print(f"Loading SAM2 model on {self.device}...")
+        self.model = build_sam2(
+            config_file=self.config_file,
+            ckpt_path=self.checkpoint_path,
+            device=self.device
+        )
+        self.predictor = SAM2ImagePredictor(self.model)
+        print("SAM2 model loaded.")
+
+    def segment_leaf(
+        self,
+        image: Image.Image,
+        point: Optional[Tuple[int, int]] = None,
+        return_mask: bool = False
+    ) -> Image.Image | Tuple[Image.Image, np.ndarray]:
+        """
+        Segment the leaf from the image.
+
+        Args:
+            image: PIL Image to segment
+            point: (x, y) point to indicate the leaf. If None, uses image center.
+            return_mask: If True, also returns the binary mask
+
+        Returns:
+            Image with leaf on white background (and mask if return_mask=True)
+        """
+        self.load_model()
+
+        # Convert to numpy array
+        image_np = np.array(image.convert('RGB'))
+        h, w = image_np.shape[:2]
+
+        # Use center point if not specified
+        if point is None:
+            point = (w // 2, h // 2)
+
+        # Set image for predictor
+        self.predictor.set_image(image_np)
+
+        # Predict mask using point prompt
+        point_coords = np.array([[point[0], point[1]]])
+        point_labels = np.array([1])  # 1 = foreground
+
+        masks, scores, _ = self.predictor.predict(
+            point_coords=point_coords,
+            point_labels=point_labels,
+            multimask_output=True
+        )
+
+        # Select best mask (highest score)
+        best_idx = np.argmax(scores)
+        mask = masks[best_idx].astype(bool)
+
+        # Create white background image
+        result = np.ones_like(image_np) * 255  # White background
+        result[mask] = image_np[mask]  # Copy leaf pixels
+
+        result_image = Image.fromarray(result.astype(np.uint8))
+
+        if return_mask:
+            return result_image, mask
+        return result_image
+
+    def segment_leaf_with_bbox(
+        self,
+        image: Image.Image,
+        bbox: Optional[Tuple[int, int, int, int]] = None,
+        return_mask: bool = False
+    ) -> Image.Image | Tuple[Image.Image, np.ndarray]:
+        """
+        Segment the leaf using a bounding box prompt.
+
+        Args:
+            image: PIL Image to segment
+            bbox: (x1, y1, x2, y2) bounding box. If None, uses full image.
+            return_mask: If True, also returns the binary mask
+
+        Returns:
+            Image with leaf on white background (and mask if return_mask=True)
+        """
+        self.load_model()
+
+        # Convert to numpy array
+        image_np = np.array(image.convert('RGB'))
+        h, w = image_np.shape[:2]
+
+        # Use full image bbox if not specified
+        if bbox is None:
+            # Use slightly inset bbox to focus on leaf
+            margin = min(w, h) // 20
+            bbox = (margin, margin, w - margin, h - margin)
+
+        # Set image for predictor
+        self.predictor.set_image(image_np)
+
+        # Predict mask using box prompt
+        box = np.array([bbox])
+
+        masks, scores, _ = self.predictor.predict(
+            box=box,
+            multimask_output=True
+        )
+
+        # Select best mask (highest score)
+        best_idx = np.argmax(scores)
+        mask = masks[best_idx].astype(bool)
+
+        # Create white background image
+        result = np.ones_like(image_np) * 255  # White background
+        result[mask] = image_np[mask]  # Copy leaf pixels
+
+        result_image = Image.fromarray(result.astype(np.uint8))
+
+        if return_mask:
+            return result_image, mask
+        return result_image
+
+    def auto_segment_leaf(
+        self,
+        image: Image.Image,
+        return_mask: bool = False
+    ) -> Image.Image | Tuple[Image.Image, np.ndarray]:
+        """
+        Automatically segment the main leaf/plant from the image.
+
+        Uses multiple strategies to find the best segmentation:
+        1. Center point
+        2. Multiple points in a grid
+        3. Green color detection for better point selection
+        4. Selects the largest coherent mask
+
+        Args:
+            image: PIL Image to segment
+            return_mask: If True, also returns the binary mask
+
+        Returns:
+            Image with leaf on white background (and mask if return_mask=True)
+        """
+        self.load_model()
+
+        # Convert to numpy array
+        image_np = np.array(image.convert('RGB'))
+        h, w = image_np.shape[:2]
+
+        # Set image for predictor
+        self.predictor.set_image(image_np)
+
+        # Try to find a good point on the leaf using green color detection
+        # Convert to HSV for better color detection
+        from PIL import ImageFilter
+        import colorsys
+
+        # Simple green detection: look for pixels with green hue
+        green_mask = self._detect_green_regions(image_np)
+
+        # Find centroid of green regions, fallback to image center
+        if green_mask.sum() > 100:  # At least some green pixels
+            y_coords, x_coords = np.where(green_mask)
+            center_x = int(np.median(x_coords))
+            center_y = int(np.median(y_coords))
+        else:
+            center_x, center_y = w // 2, h // 2
+
+        # Try multiple points for robustness
+        points_to_try = [
+            (center_x, center_y),  # Green centroid or center
+            (w // 2, h // 2),  # Image center
+            (w // 3, h // 2),  # Left third
+            (2 * w // 3, h // 2),  # Right third
+        ]
+
+        best_mask = None
+        best_score = -1
+
+        for px, py in points_to_try:
+            point = np.array([[px, py]])
+            label = np.array([1])
+
+            masks, scores, _ = self.predictor.predict(
+                point_coords=point,
+                point_labels=label,
+                multimask_output=True
+            )
+
+            for mask, score in zip(masks, scores):
+                # Ensure mask is boolean for indexing
+                mask = mask.astype(bool)
+
+                # Calculate mask coverage
+                coverage = mask.sum() / (h * w)
+
+                # Prefer masks that cover 5-95% of image (more flexible range)
+                if 0.05 < coverage < 0.95:
+                    # Check if mask contains green (likely a leaf)
+                    green_in_mask = green_mask[mask].sum() / max(mask.sum(), 1)
+
+                    # Bonus for being closer to 30-70% coverage
+                    coverage_score = 1 - abs(coverage - 0.5)
+
+                    # Combined score: SAM confidence + coverage + greenness
+                    combined_score = score * 0.5 + coverage_score * 0.2 + green_in_mask * 0.3
+
+                    if combined_score > best_score:
+                        best_score = combined_score
+                        best_mask = mask
+
+        # Fallback to highest score mask from center point
+        if best_mask is None:
+            center_point = np.array([[w // 2, h // 2]])
+            center_label = np.array([1])
+            masks, scores, _ = self.predictor.predict(
+                point_coords=center_point,
+                point_labels=center_label,
+                multimask_output=True
+            )
+            best_idx = np.argmax(scores)
+            best_mask = masks[best_idx]
+
+        # Ensure mask is boolean
+        best_mask = best_mask.astype(bool)
+
+        # Create white background image
+        result = np.ones_like(image_np) * 255  # White background
+        result[best_mask] = image_np[best_mask]  # Copy leaf pixels
+
+        result_image = Image.fromarray(result.astype(np.uint8))
+
+        if return_mask:
+            return result_image, best_mask
+        return result_image
+
+    def _detect_green_regions(self, image_np: np.ndarray) -> np.ndarray:
+        """Detect green regions in image (likely leaf areas)."""
+        # Convert RGB to HSV for better green detection
+        r, g, b = image_np[:,:,0], image_np[:,:,1], image_np[:,:,2]
+
+        # Green typically has: g > r, g > b, and reasonable brightness
+        green_mask = (
+            (g > r * 0.9) &  # Green channel dominant over red
+            (g > b * 0.9) &  # Green channel dominant over blue
+            (g > 40) &  # Not too dark
+            (g < 250)  # Not too bright (white)
+        )
+
+        # Also detect yellow-green (common in leaves)
+        yellow_green = (
+            (g > 50) &
+            (r > 50) &
+            (b < r * 0.8) &  # Blue much less than red
+            (abs(g.astype(int) - r.astype(int)) < 80)  # R and G similar
+        )
+
+        return green_mask | yellow_green
+
+    def refine_boxes_to_masks(
+        self,
+        image: Image.Image,
+        boxes: np.ndarray,
+        return_scores: bool = False
+    ) -> np.ndarray | Tuple[np.ndarray, np.ndarray]:
+        """
+        Refine bounding boxes into precise segmentation masks using SAM2.
+
+        This is used to convert RF-DETR detection boxes into proper
+        segmentation masks for disease regions.
+
+        Args:
+            image: PIL Image
+            boxes: Array of bounding boxes [N, 4] in xyxy format
+            return_scores: If True, also returns confidence scores
+
+        Returns:
+            Array of masks [N, H, W] (and scores if return_scores=True)
+        """
+        self.load_model()
+
+        # Convert to numpy array
+        image_np = np.array(image.convert('RGB'))
+        h, w = image_np.shape[:2]
+
+        if len(boxes) == 0:
+            empty_masks = np.zeros((0, h, w), dtype=bool)
+            if return_scores:
+                return empty_masks, np.zeros((0,), dtype=np.float32)
+            return empty_masks
+
+        # Set image for predictor
+        self.predictor.set_image(image_np)
+
+        masks_list = []
+        scores_list = []
+
+        for box in boxes:
+            # Use box prompt for SAM2
+            box_np = np.array([box])
+
+            masks, scores, _ = self.predictor.predict(
+                box=box_np,
+                multimask_output=True
+            )
+
+            # Select best mask (highest score)
+            best_idx = np.argmax(scores)
+            best_mask = masks[best_idx].astype(bool)
+            best_score = scores[best_idx]
+
+            masks_list.append(best_mask)
+            scores_list.append(best_score)
+
+        result_masks = np.stack(masks_list, axis=0) if masks_list else np.zeros((0, h, w), dtype=bool)
+        result_scores = np.array(scores_list, dtype=np.float32)
+
+        if return_scores:
+            return result_masks, result_scores
+        return result_masks
+
+
+# Convenience function
+def create_leaf_segmenter(
+    checkpoint_path: str = "models/sam2/sam2.1_hiera_small.pt",
+    device: Optional[str] = None
+) -> SAM2LeafSegmenter:
+    """Create a SAM2 leaf segmenter instance."""
+    return SAM2LeafSegmenter(
+        checkpoint_path=checkpoint_path,
+        device=device
+    )

src/pipeline.py

@@ -0,0 +1,631 @@
+"""
+CropDoctor Pipeline Module
+==========================
+
+This module integrates all components into a unified diagnostic pipeline:
+1. SAM 3 Segmentation - Detect disease regions
+2. Severity Classification - Assess severity level  
+3. Treatment Recommendation - Generate actionable advice
+
+Provides both single-image and batch processing capabilities.
+"""
+
+import torch
+import numpy as np
+from PIL import Image
+from pathlib import Path
+from typing import Dict, List, Optional, Union, Tuple
+from dataclasses import dataclass, asdict
+import json
+import csv
+from datetime import datetime
+import logging
+
+from .sam3_segmentation import SAM3Segmenter, create_segmenter, SegmentationResult
+from .severity_classifier import SeverityClassifier, SeverityPrediction, SEVERITY_LABELS
+from .treatment_recommender import TreatmentRecommender, TreatmentRecommendation
+from .leaf_segmenter import SAM2LeafSegmenter
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DiagnosticResult:
+    """Complete diagnostic result for an image."""
+    # Image info
+    image_path: str
+    timestamp: str
+    
+    # Segmentation results
+    num_regions_detected: int
+    affected_area_percent: float
+    detected_symptoms: List[str]
+    
+    # Severity assessment
+    severity_level: int
+    severity_label: str
+    severity_confidence: float
+    
+    # Treatment recommendations
+    disease_name: str
+    disease_type: str
+    disease_confidence: float
+    organic_treatments: List[str]
+    chemical_treatments: List[str]
+    preventive_measures: List[str]
+    treatment_timing: str
+    urgency: str
+    
+    # Raw data for further analysis
+    segmentation_masks: Optional[np.ndarray] = None
+    segmentation_scores: Optional[np.ndarray] = None
+
+
+class CropDoctorPipeline:
+    """
+    End-to-end pipeline for plant disease diagnosis.
+    
+    Integrates SAM 3 segmentation, severity classification, and
+    LLM-based treatment recommendations into a single workflow.
+    
+    Example:
+        >>> pipeline = CropDoctorPipeline()
+        >>> result = pipeline.diagnose("path/to/leaf.jpg")
+        >>> print(f"Disease: {result.disease_name}")
+        >>> print(f"Severity: {result.severity_label}")
+        >>> print(f"Treatment: {result.organic_treatments[0]}")
+    """
+    
+    def __init__(
+        self,
+        sam3_checkpoint: str = "models/sam3/sam3.pt",
+        sam3_config: str = "configs/sam3_config.yaml",
+        classifier_checkpoint: Optional[str] = None,
+        use_llm: bool = True,
+        anthropic_api_key: Optional[str] = None,
+        device: Optional[str] = None,
+        use_mock_sam3: bool = False,
+        use_rfdetr: bool = False,
+        rfdetr_checkpoint: str = "models/rfdetr/checkpoint_best_total.pth",
+        rfdetr_model_size: str = "medium",
+        use_leaf_segmentation: bool = False,
+        sam2_checkpoint: str = "models/sam2/sam2.1_hiera_small.pt"
+    ):
+        """
+        Initialize the CropDoctor pipeline.
+
+        Args:
+            sam3_checkpoint: Path to SAM 3 model checkpoint
+            sam3_config: Path to SAM 3 configuration
+            classifier_checkpoint: Path to severity classifier checkpoint
+            use_llm: Whether to use Claude API for recommendations
+            anthropic_api_key: Optional API key for Claude
+            device: Device to use (auto-detected if None)
+            use_mock_sam3: Use mock SAM 3 for testing without model
+            use_rfdetr: Use RF-DETR for detection (recommended)
+            rfdetr_checkpoint: Path to trained RF-DETR model
+            rfdetr_model_size: RF-DETR model size (nano, small, medium, base)
+            use_leaf_segmentation: Use SAM2 to segment leaf before detection
+            sam2_checkpoint: Path to SAM2 checkpoint for leaf segmentation
+        """
+        # Set device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+
+        logger.info(f"Initializing CropDoctor Pipeline on {self.device}")
+
+        # Initialize components (lazy loading)
+        self._segmenter = None
+        self._classifier = None
+        self._recommender = None
+        self._leaf_segmenter = None
+
+        # Store config
+        self.sam3_checkpoint = sam3_checkpoint
+        self.sam3_config = sam3_config
+        self.classifier_checkpoint = classifier_checkpoint
+        self.use_llm = use_llm
+        self.anthropic_api_key = anthropic_api_key
+        self.use_mock_sam3 = use_mock_sam3
+        self.use_rfdetr = use_rfdetr
+        self.rfdetr_checkpoint = rfdetr_checkpoint
+        self.rfdetr_model_size = rfdetr_model_size
+        self.use_leaf_segmentation = use_leaf_segmentation
+        self.sam2_checkpoint = sam2_checkpoint
+
+        # Default prompts for disease detection
+        self.disease_prompts = [
+            "diseased plant tissue",
+            "leaf with brown spots",
+            "powdery mildew",
+            "yellowing leaves",
+            "pest damage",
+            "wilted tissue",
+            "healthy green leaf"
+        ]
+        
+    @property
+    def segmenter(self) -> SAM3Segmenter:
+        """Lazy load segmenter (SAM 3, Mock, or RF-DETR)."""
+        if self._segmenter is None:
+            self._segmenter = create_segmenter(
+                self.sam3_checkpoint,
+                self.sam3_config,
+                use_mock=self.use_mock_sam3,
+                use_rfdetr=self.use_rfdetr,
+                rfdetr_checkpoint=self.rfdetr_checkpoint,
+                rfdetr_model_size=self.rfdetr_model_size
+            )
+        return self._segmenter
+        
+    @property
+    def classifier(self) -> SeverityClassifier:
+        """Lazy load severity classifier."""
+        if self._classifier is None:
+            self._classifier = SeverityClassifier(
+                checkpoint_path=self.classifier_checkpoint,
+                device=self.device
+            )
+        return self._classifier
+        
+    @property
+    def recommender(self) -> TreatmentRecommender:
+        """Lazy load treatment recommender."""
+        if self._recommender is None:
+            self._recommender = TreatmentRecommender(
+                api_key=self.anthropic_api_key,
+                use_llm=self.use_llm
+            )
+        return self._recommender
+
+    @property
+    def leaf_segmenter(self) -> SAM2LeafSegmenter:
+        """Lazy load SAM2 leaf segmenter."""
+        if self._leaf_segmenter is None:
+            self._leaf_segmenter = SAM2LeafSegmenter(
+                checkpoint_path=self.sam2_checkpoint,
+                device=self.device
+            )
+        return self._leaf_segmenter
+        
+    def diagnose(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        plant_species: Optional[str] = None,
+        analysis_profile: str = "standard",
+        custom_prompts: Optional[List[str]] = None,
+        return_masks: bool = False
+    ) -> DiagnosticResult:
+        """
+        Perform complete diagnosis on an image.
+        
+        Args:
+            image: Input image (path, PIL Image, or numpy array)
+            plant_species: Optional plant species for context
+            analysis_profile: SAM 3 analysis profile
+            custom_prompts: Optional custom prompts for segmentation
+            return_masks: Whether to include segmentation masks in result
+            
+        Returns:
+            DiagnosticResult with complete diagnosis
+        """
+        timestamp = datetime.now().isoformat()
+        image_path = str(image) if isinstance(image, (str, Path)) else "in_memory"
+        
+        logger.info(f"Starting diagnosis for {image_path}")
+        
+        # Load image if needed
+        if isinstance(image, (str, Path)):
+            pil_image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            pil_image = Image.fromarray(image)
+        else:
+            pil_image = image
+
+        # Store original image for visualization
+        original_image = pil_image
+        leaf_mask = None
+
+        # Step 0 (optional): Leaf segmentation with SAM2
+        if self.use_leaf_segmentation:
+            logger.info("Step 0: Leaf segmentation with SAM2")
+            pil_image, leaf_mask = self.leaf_segmenter.auto_segment_leaf(
+                pil_image,
+                return_mask=True
+            )
+            logger.info("Leaf isolated from background")
+
+        # Step 1: Disease Detection (SAM3/RF-DETR)
+        logger.info("Step 1: Disease detection")
+        prompts = custom_prompts or self.disease_prompts
+        seg_result = self.segmenter.segment_with_concepts(pil_image, prompts)
+
+        # Step 1.5: Refine bounding boxes to proper masks using SAM2
+        # This converts RF-DETR rectangular boxes to precise segmentation masks
+        if self.use_rfdetr and len(seg_result.boxes) > 0:
+            logger.info("Step 1.5: Refining detection boxes with SAM2")
+            refined_masks = self.leaf_segmenter.refine_boxes_to_masks(
+                pil_image,
+                seg_result.boxes
+            )
+            # Replace rectangular masks with refined masks
+            seg_result = SegmentationResult(
+                masks=refined_masks,
+                boxes=seg_result.boxes,
+                scores=seg_result.scores,
+                prompts=seg_result.prompts,
+                prompt_indices=seg_result.prompt_indices
+            )
+        
+        # Calculate affected area
+        area_stats = self.segmenter.calculate_affected_area(
+            seg_result,
+            healthy_prompt_idx=prompts.index("healthy green leaf") if "healthy green leaf" in prompts else None
+        )
+        
+        # Get detected symptoms (prompts with detections)
+        detected_symptoms = []
+        for prompt_idx in np.unique(seg_result.prompt_indices):
+            if prompt_idx < len(prompts):
+                prompt = prompts[prompt_idx]
+                if prompt != "healthy green leaf":
+                    detected_symptoms.append(prompt)
+                    
+        # Step 2: Severity Classification
+        logger.info("Step 2: Severity classification")
+        
+        # Create combined disease mask for classification
+        if len(seg_result.masks) > 0:
+            # Combine all disease masks (excluding healthy)
+            disease_mask = np.zeros(seg_result.masks[0].shape, dtype=bool)
+            for i, mask in enumerate(seg_result.masks):
+                prompt_idx = seg_result.prompt_indices[i]
+                if prompt_idx < len(prompts) and prompts[prompt_idx] != "healthy green leaf":
+                    disease_mask |= mask
+        else:
+            disease_mask = None
+            
+        severity_result = self.classifier.classify(pil_image, mask=disease_mask)
+        
+        # Override severity based on affected area if needed
+        if area_stats["total_affected_percent"] < 1:
+            severity_result = SeverityPrediction(
+                severity_level=0,
+                severity_label="healthy",
+                confidence=0.9,
+                probabilities={"healthy": 0.9, "mild": 0.05, "moderate": 0.03, "severe": 0.02},
+                affected_area_percent=area_stats["total_affected_percent"]
+            )
+        elif area_stats["total_affected_percent"] < 10 and severity_result.severity_level > 1:
+            severity_result.severity_level = 1
+            severity_result.severity_label = "mild"
+            
+        # Step 3: Treatment Recommendations
+        logger.info("Step 3: Generating treatment recommendations")
+        
+        if detected_symptoms and severity_result.severity_level > 0:
+            treatment_result = self.recommender.get_recommendation(
+                symptoms=detected_symptoms,
+                severity=severity_result.severity_label,
+                plant_species=plant_species,
+                affected_area_percent=area_stats["total_affected_percent"]
+            )
+        else:
+            # Healthy plant - no treatment needed
+            treatment_result = TreatmentRecommendation(
+                disease_name="No Disease Detected",
+                disease_type="healthy",
+                confidence=0.9,
+                symptoms_matched=[],
+                organic_treatments=["Continue regular care"],
+                chemical_treatments=[],
+                preventive_measures=[
+                    "Maintain good air circulation",
+                    "Water at soil level",
+                    "Monitor regularly for early symptoms"
+                ],
+                timing="Regular monitoring recommended",
+                urgency="low",
+                additional_notes="Plant appears healthy. Continue preventive care."
+            )
+            
+        # Compile final result
+        result = DiagnosticResult(
+            image_path=image_path,
+            timestamp=timestamp,
+            num_regions_detected=len(seg_result.masks),
+            affected_area_percent=area_stats["total_affected_percent"],
+            detected_symptoms=detected_symptoms,
+            severity_level=severity_result.severity_level,
+            severity_label=severity_result.severity_label,
+            severity_confidence=severity_result.confidence,
+            disease_name=treatment_result.disease_name,
+            disease_type=treatment_result.disease_type,
+            disease_confidence=treatment_result.confidence,
+            organic_treatments=treatment_result.organic_treatments,
+            chemical_treatments=treatment_result.chemical_treatments,
+            preventive_measures=treatment_result.preventive_measures,
+            treatment_timing=treatment_result.timing,
+            urgency=treatment_result.urgency,
+            segmentation_masks=seg_result.masks if return_masks else None,
+            segmentation_scores=seg_result.scores if return_masks else None
+        )
+        
+        logger.info(f"Diagnosis complete: {result.disease_name} ({result.severity_label})")
+        
+        return result
+        
+    def batch_diagnose(
+        self,
+        image_folder: Union[str, Path],
+        output_dir: Optional[Union[str, Path]] = None,
+        plant_species: Optional[str] = None,
+        save_visualizations: bool = True,
+        file_extensions: List[str] = [".jpg", ".jpeg", ".png"]
+    ) -> List[DiagnosticResult]:
+        """
+        Process multiple images from a folder.
+        
+        Args:
+            image_folder: Path to folder containing images
+            output_dir: Where to save results (optional)
+            plant_species: Plant species for all images
+            save_visualizations: Whether to save visualization images
+            file_extensions: Image file extensions to process
+            
+        Returns:
+            List of DiagnosticResult for each image
+        """
+        image_folder = Path(image_folder)
+        
+        if output_dir:
+            output_dir = Path(output_dir)
+            output_dir.mkdir(parents=True, exist_ok=True)
+            
+        # Find all images
+        images = []
+        for ext in file_extensions:
+            images.extend(image_folder.glob(f"*{ext}"))
+            images.extend(image_folder.glob(f"*{ext.upper()}"))
+            
+        logger.info(f"Found {len(images)} images to process")
+        
+        results = []
+        
+        for i, img_path in enumerate(images):
+            logger.info(f"Processing {i+1}/{len(images)}: {img_path.name}")
+            
+            try:
+                result = self.diagnose(
+                    img_path,
+                    plant_species=plant_species,
+                    return_masks=save_visualizations
+                )
+                results.append(result)
+                
+                # Save visualization if requested
+                if save_visualizations and output_dir:
+                    self._save_visualization(
+                        img_path,
+                        result,
+                        output_dir / f"{img_path.stem}_diagnosis.png"
+                    )
+                    
+            except Exception as e:
+                logger.error(f"Error processing {img_path}: {e}")
+                continue
+                
+        logger.info(f"Batch processing complete: {len(results)}/{len(images)} successful")
+        
+        return results
+        
+    def _save_visualization(
+        self,
+        image_path: Path,
+        result: DiagnosticResult,
+        output_path: Path
+    ):
+        """Save diagnostic visualization."""
+        # Import visualization module
+        from .visualization import create_diagnostic_visualization
+        
+        image = Image.open(image_path)
+        
+        fig = create_diagnostic_visualization(
+            image,
+            result.segmentation_masks,
+            result.severity_label,
+            result.disease_name,
+            result.affected_area_percent
+        )
+        
+        fig.savefig(output_path, dpi=150, bbox_inches='tight')
+        import matplotlib.pyplot as plt
+        plt.close(fig)
+        
+    def export_report(
+        self,
+        results: List[DiagnosticResult],
+        output_path: Union[str, Path],
+        format: str = "csv"
+    ):
+        """
+        Export results to file.
+        
+        Args:
+            results: List of diagnostic results
+            output_path: Output file path
+            format: Output format ("csv", "json")
+        """
+        output_path = Path(output_path)
+        
+        if format == "csv":
+            self._export_csv(results, output_path)
+        elif format == "json":
+            self._export_json(results, output_path)
+        else:
+            raise ValueError(f"Unknown format: {format}")
+            
+        logger.info(f"Report exported to {output_path}")
+        
+    def _export_csv(self, results: List[DiagnosticResult], output_path: Path):
+        """Export to CSV."""
+        with open(output_path, 'w', newline='') as f:
+            if not results:
+                return
+                
+            # Get fields (excluding numpy arrays)
+            fields = [
+                'image_path', 'timestamp', 'num_regions_detected',
+                'affected_area_percent', 'detected_symptoms',
+                'severity_level', 'severity_label', 'severity_confidence',
+                'disease_name', 'disease_type', 'disease_confidence',
+                'organic_treatments', 'urgency'
+            ]
+            
+            writer = csv.DictWriter(f, fieldnames=fields)
+            writer.writeheader()
+            
+            for result in results:
+                row = {
+                    'image_path': result.image_path,
+                    'timestamp': result.timestamp,
+                    'num_regions_detected': result.num_regions_detected,
+                    'affected_area_percent': f"{result.affected_area_percent:.2f}",
+                    'detected_symptoms': '; '.join(result.detected_symptoms),
+                    'severity_level': result.severity_level,
+                    'severity_label': result.severity_label,
+                    'severity_confidence': f"{result.severity_confidence:.3f}",
+                    'disease_name': result.disease_name,
+                    'disease_type': result.disease_type,
+                    'disease_confidence': f"{result.disease_confidence:.3f}",
+                    'organic_treatments': '; '.join(result.organic_treatments[:3]),
+                    'urgency': result.urgency
+                }
+                writer.writerow(row)
+                
+    def _export_json(self, results: List[DiagnosticResult], output_path: Path):
+        """Export to JSON."""
+        data = []
+        for result in results:
+            d = asdict(result)
+            # Remove numpy arrays
+            d.pop('segmentation_masks', None)
+            d.pop('segmentation_scores', None)
+            data.append(d)
+            
+        with open(output_path, 'w') as f:
+            json.dump(data, f, indent=2, default=str)
+            
+    def generate_summary_report(
+        self,
+        results: List[DiagnosticResult]
+    ) -> str:
+        """
+        Generate a summary report for batch results.
+        
+        Args:
+            results: List of diagnostic results
+            
+        Returns:
+            Formatted summary report string
+        """
+        if not results:
+            return "No results to summarize."
+            
+        # Calculate statistics
+        total = len(results)
+        healthy = sum(1 for r in results if r.severity_level == 0)
+        mild = sum(1 for r in results if r.severity_level == 1)
+        moderate = sum(1 for r in results if r.severity_level == 2)
+        severe = sum(1 for r in results if r.severity_level == 3)
+        
+        # Disease frequency
+        disease_counts = {}
+        for r in results:
+            disease_counts[r.disease_name] = disease_counts.get(r.disease_name, 0) + 1
+            
+        # Average affected area
+        avg_affected = np.mean([r.affected_area_percent for r in results])
+        
+        report = f"""
+╔══════════════════════════════════════════════════════════════╗
+║                    BATCH DIAGNOSIS SUMMARY                    ║
+╚══════════════════════════════════════════════════════════════╝
+
+📊 OVERALL STATISTICS
+   Total Images Analyzed: {total}
+   
+   Severity Distribution:
+   ├── 🟢 Healthy:  {healthy} ({healthy/total*100:.1f}%)
+   ├── 🟡 Mild:     {mild} ({mild/total*100:.1f}%)
+   ├── 🟠 Moderate: {moderate} ({moderate/total*100:.1f}%)
+   └── 🔴 Severe:   {severe} ({severe/total*100:.1f}%)
+   
+   Average Affected Area: {avg_affected:.1f}%
+
+🦠 DISEASE FREQUENCY
+"""
+        for disease, count in sorted(disease_counts.items(), key=lambda x: -x[1]):
+            report += f"   • {disease}: {count} ({count/total*100:.1f}%)\n"
+            
+        # Urgent cases
+        urgent = [r for r in results if r.urgency in ['high', 'critical']]
+        if urgent:
+            report += f"""
+⚠️ URGENT ATTENTION REQUIRED
+   {len(urgent)} images require immediate attention:
+"""
+            for r in urgent[:5]:  # Show top 5
+                report += f"   • {Path(r.image_path).name}: {r.disease_name} ({r.urgency})\n"
+                
+        report += """
+═══════════════════════════════════════════════════════════════
+"""
+        return report
+
+
+def quick_diagnose(
+    image_path: str,
+    use_mock: bool = True
+) -> DiagnosticResult:
+    """
+    Quick diagnosis function for simple use cases.
+    
+    Args:
+        image_path: Path to image
+        use_mock: Use mock models (for testing without SAM 3)
+        
+    Returns:
+        DiagnosticResult
+    """
+    pipeline = CropDoctorPipeline(
+        use_mock_sam3=use_mock,
+        use_llm=False
+    )
+    return pipeline.diagnose(image_path)
+
+
+if __name__ == "__main__":
+    # Test the pipeline with mock
+    print("Testing CropDoctor Pipeline...")
+    
+    # Create test image
+    test_img = Image.new("RGB", (640, 480), color=(139, 69, 19))
+    test_img.save("/tmp/test_leaf.jpg")
+    
+    # Run pipeline
+    pipeline = CropDoctorPipeline(use_mock_sam3=True, use_llm=False)
+    result = pipeline.diagnose("/tmp/test_leaf.jpg")
+    
+    print(f"\n📋 Diagnosis Results:")
+    print(f"   Disease: {result.disease_name}")
+    print(f"   Type: {result.disease_type}")
+    print(f"   Severity: {result.severity_label} (Level {result.severity_level})")
+    print(f"   Affected Area: {result.affected_area_percent:.1f}%")
+    print(f"   Urgency: {result.urgency}")
+    print(f"\n🌿 Recommended Treatments:")
+    for t in result.organic_treatments[:3]:
+        print(f"   • {t}")

src/sam3_segmentation.py

@@ -0,0 +1,864 @@
+"""
+SAM 3 Segmentation Module for CropDoctor-Semantic
+==================================================
+
+This module provides the core segmentation functionality using Meta's SAM 3
+for concept-based plant disease detection.
+
+SAM 3 enables zero-shot segmentation using natural language prompts,
+allowing detection of disease symptoms without task-specific training.
+"""
+
+import torch
+import numpy as np
+from PIL import Image
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional, Union
+from dataclasses import dataclass
+import yaml
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SegmentationResult:
+    """Container for segmentation results."""
+    masks: np.ndarray  # Shape: (N, H, W) boolean masks
+    boxes: np.ndarray  # Shape: (N, 4) bounding boxes [x1, y1, x2, y2]
+    scores: np.ndarray  # Shape: (N,) confidence scores
+    prompts: List[str]  # Prompts used for each detection
+    prompt_indices: np.ndarray  # Which prompt each mask corresponds to
+    
+
+class SAM3Segmenter:
+    """
+    SAM 3 based segmentation for plant disease detection.
+    
+    Uses text prompts to detect and segment disease symptoms in plant images.
+    SAM 3's Promptable Concept Segmentation (PCS) enables open-vocabulary
+    detection without fine-tuning.
+    
+    Example:
+        >>> segmenter = SAM3Segmenter("models/sam3/sam3.pt")
+        >>> result = segmenter.segment_with_concepts(
+        ...     "leaf_image.jpg",
+        ...     ["leaf with brown spots", "healthy leaf"]
+        ... )
+        >>> print(f"Found {len(result.masks)} regions")
+    """
+    
+    def __init__(
+        self,
+        checkpoint_path: str = "models/sam3/sam3.pt",
+        config_path: str = "configs/sam3_config.yaml",
+        device: Optional[str] = None
+    ):
+        """
+        Initialize SAM 3 segmenter.
+        
+        Args:
+            checkpoint_path: Path to SAM 3 checkpoint
+            config_path: Path to configuration file
+            device: Device to use (cuda, cpu, mps). Auto-detected if None.
+        """
+        self.checkpoint_path = Path(checkpoint_path)
+        self.config = self._load_config(config_path)
+        
+        # Set device
+        if device is None:
+            if torch.cuda.is_available():
+                self.device = "cuda"
+            elif torch.backends.mps.is_available():
+                self.device = "mps"
+            else:
+                self.device = "cpu"
+        else:
+            self.device = device
+            
+        logger.info(f"Using device: {self.device}")
+        
+        # Model will be loaded lazily
+        self.model = None
+        self.processor = None
+        
+    def _load_config(self, config_path: str) -> dict:
+        """Load configuration from YAML file."""
+        config_path = Path(config_path)
+        if config_path.exists():
+            with open(config_path, 'r') as f:
+                return yaml.safe_load(f)
+        else:
+            logger.warning(f"Config not found at {config_path}, using defaults")
+            return self._default_config()
+            
+    def _default_config(self) -> dict:
+        """Return default configuration."""
+        return {
+            "inference": {
+                "confidence_threshold": 0.25,
+                "presence_threshold": 0.5,
+                "max_objects_per_prompt": 50,
+                "min_mask_area": 100
+            },
+            "visualization": {
+                "mask_alpha": 0.5,
+                "show_confidence": True
+            }
+        }
+        
+    def load_model(self):
+        """Load SAM 3 model and processor."""
+        if self.model is not None:
+            return
+            
+        logger.info("Loading SAM 3 model...")
+        
+        try:
+            # Import SAM 3 modules
+            from sam3.model_builder import build_sam3_image_model
+            from sam3.model.sam3_image_processor import Sam3Processor
+            
+            # Build model
+            self.model = build_sam3_image_model(checkpoint=str(self.checkpoint_path))
+            self.model.to(self.device)
+            
+            if self.config.get("model", {}).get("half_precision", True) and self.device == "cuda":
+                self.model = self.model.half()
+                
+            self.model.eval()
+            
+            # Create processor
+            self.processor = Sam3Processor(self.model)
+            
+            logger.info("SAM 3 model loaded successfully")
+            
+        except ImportError:
+            logger.error("SAM 3 not installed. Please install from: https://github.com/facebookresearch/sam3")
+            raise
+        except FileNotFoundError:
+            logger.error(f"Checkpoint not found at {self.checkpoint_path}")
+            raise
+            
+    def segment_with_concepts(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        text_prompts: List[str],
+        confidence_threshold: Optional[float] = None
+    ) -> SegmentationResult:
+        """
+        Segment image using text prompts.
+        
+        Args:
+            image: Input image (path, PIL Image, or numpy array)
+            text_prompts: List of text prompts describing concepts to detect
+            confidence_threshold: Override default confidence threshold
+            
+        Returns:
+            SegmentationResult containing masks, boxes, scores, and prompt info
+        """
+        # Ensure model is loaded
+        self.load_model()
+        
+        # Load image
+        if isinstance(image, (str, Path)):
+            image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+            
+        # Get threshold
+        threshold = confidence_threshold or self.config["inference"]["confidence_threshold"]
+        
+        # Set image in processor
+        inference_state = self.processor.set_image(image)
+        
+        # Collect results from all prompts
+        all_masks = []
+        all_boxes = []
+        all_scores = []
+        all_prompt_indices = []
+        
+        for prompt_idx, prompt in enumerate(text_prompts):
+            logger.debug(f"Processing prompt: {prompt}")
+            
+            # Get segmentation for this prompt
+            output = self.processor.set_text_prompt(
+                state=inference_state,
+                prompt=prompt
+            )
+            
+            masks = output["masks"]
+            boxes = output["boxes"]
+            scores = output["scores"]
+            
+            if masks is not None and len(masks) > 0:
+                # Convert to numpy
+                masks_np = masks.cpu().numpy() if torch.is_tensor(masks) else masks
+                boxes_np = boxes.cpu().numpy() if torch.is_tensor(boxes) else boxes
+                scores_np = scores.cpu().numpy() if torch.is_tensor(scores) else scores
+                
+                # Filter by confidence
+                mask = scores_np >= threshold
+                
+                if mask.any():
+                    all_masks.append(masks_np[mask])
+                    all_boxes.append(boxes_np[mask])
+                    all_scores.append(scores_np[mask])
+                    all_prompt_indices.append(
+                        np.full(mask.sum(), prompt_idx, dtype=np.int32)
+                    )
+        
+        # Combine results
+        if all_masks:
+            combined_masks = np.concatenate(all_masks, axis=0)
+            combined_boxes = np.concatenate(all_boxes, axis=0)
+            combined_scores = np.concatenate(all_scores, axis=0)
+            combined_indices = np.concatenate(all_prompt_indices, axis=0)
+        else:
+            # Return empty results
+            h, w = np.array(image).shape[:2]
+            combined_masks = np.zeros((0, h, w), dtype=bool)
+            combined_boxes = np.zeros((0, 4), dtype=np.float32)
+            combined_scores = np.zeros((0,), dtype=np.float32)
+            combined_indices = np.zeros((0,), dtype=np.int32)
+            
+        return SegmentationResult(
+            masks=combined_masks,
+            boxes=combined_boxes,
+            scores=combined_scores,
+            prompts=text_prompts,
+            prompt_indices=combined_indices
+        )
+        
+    def segment_disease_regions(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        profile: str = "standard"
+    ) -> SegmentationResult:
+        """
+        Segment disease regions using predefined prompt profiles.
+        
+        Args:
+            image: Input image
+            profile: Analysis profile ("quick_scan", "standard", "comprehensive", "pest_focused")
+            
+        Returns:
+            SegmentationResult for the specified analysis profile
+        """
+        profiles = self.config.get("analysis_profiles", {})
+        
+        if profile not in profiles:
+            available = list(profiles.keys())
+            raise ValueError(f"Profile '{profile}' not found. Available: {available}")
+            
+        prompts = profiles[profile]["prompts"]
+        logger.info(f"Using profile '{profile}' with {len(prompts)} prompts")
+        
+        return self.segment_with_concepts(image, prompts)
+        
+    def calculate_affected_area(
+        self,
+        result: SegmentationResult,
+        healthy_prompt_idx: Optional[int] = None
+    ) -> Dict[str, float]:
+        """
+        Calculate the percentage of affected area.
+        
+        Args:
+            result: Segmentation result
+            healthy_prompt_idx: Index of the "healthy" prompt for comparison
+            
+        Returns:
+            Dictionary with area statistics
+        """
+        if len(result.masks) == 0:
+            return {"total_affected_percent": 0.0, "per_symptom": {}}
+            
+        # Total image area
+        h, w = result.masks[0].shape
+        total_area = h * w
+        
+        # Calculate areas per prompt
+        per_symptom = {}
+        total_diseased_area = 0
+        healthy_area = 0
+        
+        for prompt_idx, prompt in enumerate(result.prompts):
+            mask_indices = result.prompt_indices == prompt_idx
+            if mask_indices.any():
+                combined_mask = result.masks[mask_indices].any(axis=0)
+                area = combined_mask.sum()
+                percent = (area / total_area) * 100
+                per_symptom[prompt] = percent
+                
+                if healthy_prompt_idx is not None and prompt_idx == healthy_prompt_idx:
+                    healthy_area = area
+                else:
+                    total_diseased_area += area
+                    
+        # Calculate total affected (excluding overlaps approximation)
+        all_diseased_mask = np.zeros((h, w), dtype=bool)
+        for prompt_idx, prompt in enumerate(result.prompts):
+            if healthy_prompt_idx is None or prompt_idx != healthy_prompt_idx:
+                mask_indices = result.prompt_indices == prompt_idx
+                if mask_indices.any():
+                    all_diseased_mask |= result.masks[mask_indices].any(axis=0)
+                    
+        affected_percent = (all_diseased_mask.sum() / total_area) * 100
+        
+        return {
+            "total_affected_percent": affected_percent,
+            "per_symptom": per_symptom,
+            "healthy_percent": (healthy_area / total_area) * 100 if healthy_prompt_idx else None
+        }
+        
+    def get_disease_prompts(self, category: str = "all") -> List[str]:
+        """
+        Get predefined disease detection prompts.
+        
+        Args:
+            category: Prompt category ("general", "fungal", "bacterial", 
+                     "viral", "nutrient", "pest", or "all")
+                     
+        Returns:
+            List of prompts for the specified category
+        """
+        prompts_config = self.config.get("prompts", {})
+        
+        if category == "all":
+            all_prompts = []
+            for cat_prompts in prompts_config.values():
+                all_prompts.extend(cat_prompts)
+            return all_prompts
+        elif category in prompts_config:
+            return prompts_config[category]
+        else:
+            available = list(prompts_config.keys()) + ["all"]
+            raise ValueError(f"Category '{category}' not found. Available: {available}")
+
+
+class MockSAM3Segmenter(SAM3Segmenter):
+    """
+    Color-based segmentation for plant disease detection.
+
+    Analyzes actual image colors to detect disease symptoms:
+    - Green regions = healthy tissue
+    - Brown/yellow/spotted regions = potential disease
+
+    Uses scipy.ndimage for blob detection on non-green regions.
+    """
+
+    def load_model(self):
+        """Skip model loading for color-based analysis."""
+        logger.info("Using MockSAM3Segmenter (color-based analysis)")
+        self.model = "color_analysis"
+        self.processor = "color_analysis"
+
+    def _compute_hsv(self, img_array: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Convert RGB image to HSV channels."""
+        r, g, b = img_array[:,:,0], img_array[:,:,1], img_array[:,:,2]
+
+        rgb_max = np.maximum(np.maximum(r, g), b)
+        rgb_min = np.minimum(np.minimum(r, g), b)
+        delta = (rgb_max - rgb_min).astype(np.float32) + 1e-10
+
+        # Value
+        v = rgb_max
+
+        # Saturation
+        s = np.where(rgb_max > 0, (delta / (rgb_max.astype(np.float32) + 1e-10)) * 255, 0).astype(np.uint8)
+
+        # Hue
+        h_channel = np.zeros_like(r, dtype=np.float32)
+
+        mask_r = (rgb_max == r)
+        h_channel[mask_r] = 60 * (((g[mask_r].astype(np.float32) - b[mask_r]) / delta[mask_r]) % 6)
+
+        mask_g = (rgb_max == g) & ~mask_r
+        h_channel[mask_g] = 60 * (((b[mask_g].astype(np.float32) - r[mask_g]) / delta[mask_g]) + 2)
+
+        mask_b = (rgb_max == b) & ~mask_r & ~mask_g
+        h_channel[mask_b] = 60 * (((r[mask_b].astype(np.float32) - g[mask_b]) / delta[mask_b]) + 4)
+
+        h_channel = (h_channel / 2).astype(np.uint8)  # 0-180 range
+
+        return h_channel, s, v
+
+    def _segment_leaf(self, img_array: np.ndarray, h: np.ndarray, s: np.ndarray, v: np.ndarray) -> np.ndarray:
+        """
+        Segment the leaf/plant tissue from the background.
+
+        Uses color analysis to find plant material:
+        - High saturation (plants are colorful, backgrounds are often gray/neutral)
+        - Green to yellow-brown hue range (plant tissue colors)
+        - Reasonable brightness
+
+        Returns the largest connected region as the leaf mask.
+        """
+        from scipy import ndimage
+
+        img_h, img_w = img_array.shape[:2]
+
+        # Plant tissue typically has:
+        # 1. Good saturation (colorful, not gray)
+        # 2. Hue in plant range: green (35-85) OR yellow/brown diseased (10-45)
+        # 3. Reasonable brightness
+
+        # Broad plant color range (green to brown/yellow)
+        plant_hue_mask = (
+            ((h >= 15) & (h <= 90)) |  # Green to yellow-green
+            ((h >= 5) & (h <= 30))      # Brown/orange (diseased tissue)
+        )
+
+        # Plant tissue has good saturation and brightness
+        plant_saturation_mask = (s >= 25)  # Saturated (not gray)
+        plant_brightness_mask = (v >= 30) & (v <= 250)  # Not too dark, not blown out
+
+        # Combine criteria
+        potential_leaf = plant_hue_mask & plant_saturation_mask & plant_brightness_mask
+
+        # Also include high saturation areas regardless of hue (catches more plant tissue)
+        high_saturation = (s >= 50) & plant_brightness_mask
+        potential_leaf = potential_leaf | high_saturation
+
+        # Clean up with morphological operations
+        potential_leaf = ndimage.binary_closing(potential_leaf, iterations=3)
+        potential_leaf = ndimage.binary_opening(potential_leaf, iterations=2)
+        potential_leaf = ndimage.binary_fill_holes(potential_leaf)
+
+        # Find the largest connected component (main leaf)
+        labeled, num_features = ndimage.label(potential_leaf)
+
+        if num_features == 0:
+            # No leaf found - return full image as fallback
+            logger.warning("No leaf detected, using full image")
+            return np.ones((img_h, img_w), dtype=bool)
+
+        # Find largest component
+        component_sizes = ndimage.sum(potential_leaf, labeled, range(1, num_features + 1))
+        largest_idx = np.argmax(component_sizes) + 1
+        leaf_mask = (labeled == largest_idx)
+
+        # Leaf should cover at least 10% of image to be valid
+        leaf_coverage = leaf_mask.sum() / (img_h * img_w)
+        if leaf_coverage < 0.10:
+            logger.warning(f"Leaf too small ({leaf_coverage:.1%}), using full image")
+            return np.ones((img_h, img_w), dtype=bool)
+
+        logger.debug(f"Leaf segmented: {leaf_coverage:.1%} of image")
+        return leaf_mask
+
+    def _detect_disease_regions(self, image: Image.Image) -> Tuple[np.ndarray, List[Dict]]:
+        """
+        Detect disease regions based on color analysis.
+
+        First segments the leaf from background, then analyzes only
+        the leaf area for disease symptoms.
+
+        Returns:
+            Tuple of (binary mask of all abnormal regions, list of blob info dicts)
+        """
+        from scipy import ndimage
+
+        img_array = np.array(image)
+        img_h, img_w = img_array.shape[:2]
+
+        # Compute HSV
+        h_channel, s, v = self._compute_hsv(img_array)
+
+        # Step 1: Segment the leaf from background
+        leaf_mask = self._segment_leaf(img_array, h_channel, s, v)
+        leaf_area = leaf_mask.sum()
+
+        if leaf_area == 0:
+            return np.zeros((img_h, img_w), dtype=bool), []
+
+        # Step 2: Within the leaf, find healthy green regions
+        green_mask = (
+            (h_channel >= 35) & (h_channel <= 85) &  # Green hue
+            (s >= 30) &  # Saturated
+            (v >= 30) &  # Not too dark
+            leaf_mask    # Only within leaf
+        )
+
+        green_area = green_mask.sum()
+        green_ratio = green_area / leaf_area
+
+        logger.debug(f"Within leaf - Green: {green_ratio:.1%}, Leaf area: {leaf_area}px")
+
+        # Step 3: Define disease colors (only within leaf!)
+        # Brown spots: low hue, moderate saturation
+        brown_mask = (
+            (h_channel >= 5) & (h_channel <= 25) &
+            (s >= 30) &
+            (v >= 40) & (v <= 200) &
+            leaf_mask
+        )
+
+        # Yellow/chlorosis: yellow hue, high saturation
+        yellow_mask = (
+            (h_channel >= 20) & (h_channel <= 40) &
+            (s >= 40) &
+            (v >= 80) &
+            leaf_mask
+        )
+
+        # Necrotic dark spots (within leaf only)
+        dark_spots = (
+            (v <= 60) &
+            (s >= 15) &  # Some color, not pure black
+            leaf_mask
+        )
+
+        # White spots (powdery mildew) - within leaf
+        white_spots = (
+            (v >= 200) &
+            (s <= 40) &
+            leaf_mask
+        )
+
+        # Combine abnormal regions
+        abnormal_mask = (brown_mask | yellow_mask | dark_spots | white_spots)
+        abnormal_area = abnormal_mask.sum()
+
+        logger.debug(f"Abnormal pixels within leaf: {abnormal_area} ({abnormal_area/leaf_area:.1%} of leaf)")
+
+        # If mostly green (>80% of leaf is green), consider healthy
+        if green_ratio > 0.80 and abnormal_area < leaf_area * 0.05:
+            logger.info(f"Leaf appears healthy ({green_ratio:.0%} green)")
+            return np.zeros((img_h, img_w), dtype=bool), []
+
+        # If very little abnormal tissue, also healthy
+        if abnormal_area < leaf_area * 0.02:
+            logger.info("Minimal abnormal tissue detected - healthy")
+            return np.zeros((img_h, img_w), dtype=bool), []
+
+        # Clean up the abnormal mask
+        abnormal_mask = ndimage.binary_opening(abnormal_mask, iterations=1)
+        abnormal_mask = ndimage.binary_closing(abnormal_mask, iterations=2)
+
+        # Label connected components
+        labeled_array, num_features = ndimage.label(abnormal_mask)
+
+        # Filter blobs by size (relative to leaf, not image)
+        min_blob_area = max(50, leaf_area * 0.005)   # At least 0.5% of leaf
+        max_blob_area = leaf_area * 0.6              # At most 60% of leaf
+
+        blobs = []
+        for label_idx in range(1, num_features + 1):
+            blob_mask = (labeled_array == label_idx)
+            blob_area = blob_mask.sum()
+
+            if min_blob_area <= blob_area <= max_blob_area:
+                # Get bounding box
+                rows = np.any(blob_mask, axis=1)
+                cols = np.any(blob_mask, axis=0)
+                y_min, y_max = np.where(rows)[0][[0, -1]]
+                x_min, x_max = np.where(cols)[0][[0, -1]]
+
+                # Calculate confidence based on color
+                blob_region = img_array[blob_mask]
+                avg_color = blob_region.mean(axis=0)
+
+                r_ratio = avg_color[0] / 255
+                g_ratio = avg_color[1] / 255
+                b_ratio = avg_color[2] / 255
+
+                # Score: more brown/yellow = higher confidence
+                color_score = r_ratio - 0.5 * g_ratio + 0.3 * (1 - b_ratio)
+                color_score = np.clip(color_score, 0, 1)
+
+                # Area score relative to leaf
+                area_ratio = blob_area / leaf_area
+                area_score = min(1.0, area_ratio * 10)
+
+                confidence = 0.4 + 0.4 * color_score + 0.2 * area_score
+                confidence = np.clip(confidence, 0.3, 0.95)
+
+                blobs.append({
+                    'mask': blob_mask,
+                    'bbox': [x_min, y_min, x_max, y_max],
+                    'area': blob_area,
+                    'confidence': float(confidence)
+                })
+
+        return abnormal_mask, blobs
+
+    def segment_with_concepts(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        text_prompts: List[str],
+        confidence_threshold: Optional[float] = None
+    ) -> SegmentationResult:
+        """
+        Segment disease regions based on color analysis.
+
+        Analyzes the image colors to detect abnormal (non-green) regions
+        that may indicate disease. Returns empty results for healthy images.
+        """
+        # Load image
+        if isinstance(image, (str, Path)):
+            image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+
+        w, h = image.size
+        threshold = confidence_threshold or self.config["inference"]["confidence_threshold"]
+
+        # Detect disease regions based on color
+        abnormal_mask, blobs = self._detect_disease_regions(image)
+
+        # Filter by confidence threshold
+        blobs = [b for b in blobs if b['confidence'] >= threshold]
+
+        if not blobs:
+            logger.info("No disease regions detected (healthy image)")
+            return SegmentationResult(
+                masks=np.zeros((0, h, w), dtype=bool),
+                boxes=np.zeros((0, 4), dtype=np.float32),
+                scores=np.zeros((0,), dtype=np.float32),
+                prompts=text_prompts,
+                prompt_indices=np.zeros((0,), dtype=np.int32)
+            )
+
+        # Convert blobs to arrays
+        num_detections = len(blobs)
+        masks = np.zeros((num_detections, h, w), dtype=bool)
+        boxes = np.zeros((num_detections, 4), dtype=np.float32)
+        scores = np.zeros(num_detections, dtype=np.float32)
+
+        # Assign detections to first disease-related prompt (skip "healthy" prompts)
+        disease_prompt_idx = 0
+        for idx, prompt in enumerate(text_prompts):
+            if "healthy" not in prompt.lower():
+                disease_prompt_idx = idx
+                break
+
+        prompt_indices = np.full(num_detections, disease_prompt_idx, dtype=np.int32)
+
+        for i, blob in enumerate(blobs):
+            masks[i] = blob['mask']
+            boxes[i] = blob['bbox']
+            scores[i] = blob['confidence']
+
+        logger.info(f"Detected {num_detections} disease region(s)")
+
+        return SegmentationResult(
+            masks=masks,
+            boxes=boxes,
+            scores=scores,
+            prompts=text_prompts,
+            prompt_indices=prompt_indices
+        )
+
+
+class RFDETRSegmenter(SAM3Segmenter):
+    """
+    RF-DETR based object detection for plant disease detection.
+
+    Uses a trained RF-DETR model (DETR-based detector) instead of SAM 3.
+    RF-DETR is trained on annotated plant disease datasets with bounding boxes.
+
+    Example:
+        >>> segmenter = RFDETRSegmenter("models/rfdetr/best.pt")
+        >>> result = segmenter.segment_with_concepts(image, ["disease"])
+        >>> print(f"Found {len(result.masks)} disease regions")
+    """
+
+    def __init__(
+        self,
+        checkpoint_path: str = "models/rfdetr/best.pt",
+        config_path: str = "configs/sam3_config.yaml",
+        device: Optional[str] = None,
+        model_size: str = "medium"
+    ):
+        """
+        Initialize RF-DETR segmenter.
+
+        Args:
+            checkpoint_path: Path to trained RF-DETR checkpoint
+            config_path: Path to configuration file
+            device: Device to use (auto-detected if None)
+            model_size: RF-DETR model size (nano, small, medium, base)
+        """
+        super().__init__(checkpoint_path, config_path, device)
+        self.model_size = model_size
+        self.class_names = ["Pestalotiopsis"]  # Default class, updated after loading
+
+    def load_model(self):
+        """Load RF-DETR model."""
+        if self.model is not None:
+            return
+
+        logger.info(f"Loading RF-DETR {self.model_size} model...")
+
+        try:
+            # Import RF-DETR
+            if self.model_size == "nano":
+                from rfdetr import RFDETRNano as RFDETRModel
+            elif self.model_size == "small":
+                from rfdetr import RFDETRSmall as RFDETRModel
+            elif self.model_size == "medium":
+                from rfdetr import RFDETRMedium as RFDETRModel
+            else:
+                from rfdetr import RFDETRBase as RFDETRModel
+
+            # Load model with custom weights if available
+            checkpoint = Path(self.checkpoint_path)
+            if checkpoint.exists():
+                logger.info(f"Loading custom weights from {checkpoint}")
+                self.model = RFDETRModel(pretrain_weights=str(checkpoint))
+            else:
+                logger.warning(f"Checkpoint not found at {checkpoint}, using pretrained weights")
+                self.model = RFDETRModel()
+
+            logger.info("RF-DETR model loaded successfully")
+
+        except ImportError as e:
+            logger.error(f"RF-DETR not installed: {e}")
+            logger.error("Install with: pip install rfdetr")
+            raise
+
+    def segment_with_concepts(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        text_prompts: List[str],
+        confidence_threshold: Optional[float] = None
+    ) -> SegmentationResult:
+        """
+        Detect disease regions using RF-DETR.
+
+        Note: RF-DETR is class-based (not prompt-based), so text_prompts
+        are ignored. The model detects all trained disease classes.
+
+        Args:
+            image: Input image
+            text_prompts: Ignored (RF-DETR uses trained classes)
+            confidence_threshold: Detection confidence threshold
+
+        Returns:
+            SegmentationResult with detected disease regions
+        """
+        self.load_model()
+
+        # Load image
+        if isinstance(image, (str, Path)):
+            pil_image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            pil_image = Image.fromarray(image)
+        else:
+            pil_image = image
+
+        w, h = pil_image.size
+        threshold = confidence_threshold or self.config["inference"]["confidence_threshold"]
+
+        # Run RF-DETR detection
+        try:
+            detections = self.model.predict(pil_image, threshold=threshold)
+        except Exception as e:
+            logger.error(f"RF-DETR prediction failed: {e}")
+            return SegmentationResult(
+                masks=np.zeros((0, h, w), dtype=bool),
+                boxes=np.zeros((0, 4), dtype=np.float32),
+                scores=np.zeros((0,), dtype=np.float32),
+                prompts=text_prompts,
+                prompt_indices=np.zeros((0,), dtype=np.int32)
+            )
+
+        # Extract detections from supervision Detections object
+        num_detections = len(detections)
+
+        if num_detections == 0:
+            logger.info("No disease regions detected")
+            return SegmentationResult(
+                masks=np.zeros((0, h, w), dtype=bool),
+                boxes=np.zeros((0, 4), dtype=np.float32),
+                scores=np.zeros((0,), dtype=np.float32),
+                prompts=text_prompts,
+                prompt_indices=np.zeros((0,), dtype=np.int32)
+            )
+
+        # Get bounding boxes and scores
+        boxes = detections.xyxy.astype(np.float32)  # [x1, y1, x2, y2]
+        scores = detections.confidence.astype(np.float32)
+
+        # Create masks from bounding boxes (RF-DETR gives boxes, not masks)
+        masks = np.zeros((num_detections, h, w), dtype=bool)
+        for i, box in enumerate(boxes):
+            x1, y1, x2, y2 = box.astype(int)
+            x1, y1 = max(0, x1), max(0, y1)
+            x2, y2 = min(w, x2), min(h, y2)
+            masks[i, y1:y2, x1:x2] = True
+
+        # Assign to first disease prompt
+        disease_prompt_idx = 0
+        for idx, prompt in enumerate(text_prompts):
+            if "healthy" not in prompt.lower():
+                disease_prompt_idx = idx
+                break
+
+        prompt_indices = np.full(num_detections, disease_prompt_idx, dtype=np.int32)
+
+        logger.info(f"RF-DETR detected {num_detections} disease region(s)")
+
+        return SegmentationResult(
+            masks=masks,
+            boxes=boxes,
+            scores=scores,
+            prompts=text_prompts,
+            prompt_indices=prompt_indices
+        )
+
+
+def create_segmenter(
+    checkpoint_path: str = "models/sam3/sam3.pt",
+    config_path: str = "configs/sam3_config.yaml",
+    use_mock: bool = False,
+    use_rfdetr: bool = False,
+    rfdetr_checkpoint: str = "models/rfdetr/best.pt",
+    rfdetr_model_size: str = "medium"
+) -> SAM3Segmenter:
+    """
+    Factory function to create appropriate segmenter.
+
+    Args:
+        checkpoint_path: Path to SAM 3 checkpoint
+        config_path: Path to configuration
+        use_mock: If True, use color-based mock segmenter
+        use_rfdetr: If True, use RF-DETR detector
+        rfdetr_checkpoint: Path to RF-DETR checkpoint
+        rfdetr_model_size: RF-DETR model size (nano, small, medium, base)
+
+    Returns:
+        SAM3Segmenter, MockSAM3Segmenter, or RFDETRSegmenter instance
+    """
+    if use_rfdetr:
+        return RFDETRSegmenter(
+            checkpoint_path=rfdetr_checkpoint,
+            config_path=config_path,
+            model_size=rfdetr_model_size
+        )
+    elif use_mock:
+        return MockSAM3Segmenter(checkpoint_path, config_path)
+    else:
+        return SAM3Segmenter(checkpoint_path, config_path)
+
+
+if __name__ == "__main__":
+    # Quick test with mock
+    segmenter = create_segmenter(use_mock=True)
+    
+    # Create a test image
+    test_image = Image.new("RGB", (640, 480), color=(34, 139, 34))  # Forest green
+    
+    prompts = ["diseased leaf", "brown spots", "healthy tissue"]
+    result = segmenter.segment_with_concepts(test_image, prompts)
+    
+    print(f"Found {len(result.masks)} regions")
+    print(f"Scores: {result.scores}")
+    print(f"Prompts used: {[result.prompts[i] for i in result.prompt_indices]}")
+    
+    areas = segmenter.calculate_affected_area(result)
+    print(f"Affected area: {areas['total_affected_percent']:.1f}%")

src/severity_classifier.py

@@ -0,0 +1,590 @@
+"""
+Severity Classifier Module for CropDoctor-Semantic
+===================================================
+
+This module provides a CNN-based classifier to assess the severity
+of plant diseases from segmented regions.
+
+Severity Levels:
+    0 - Healthy: No disease symptoms
+    1 - Mild: <10% affected area, early stage
+    2 - Moderate: 10-30% affected, established infection
+    3 - Severe: >30% affected, critical intervention needed
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import torchvision.transforms as transforms
+from torchvision import models
+import numpy as np
+from PIL import Image
+from pathlib import Path
+from typing import Tuple, Dict, List, Optional, Union
+from dataclasses import dataclass
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SeverityPrediction:
+    """Container for severity classification results."""
+    severity_level: int  # 0-3
+    severity_label: str  # "healthy", "mild", "moderate", "severe"
+    confidence: float  # 0-1
+    probabilities: Dict[str, float]  # Per-class probabilities
+    affected_area_percent: float  # From mask analysis
+
+
+# Severity level mapping
+SEVERITY_LABELS = {
+    0: "healthy",
+    1: "mild", 
+    2: "moderate",
+    3: "severe"
+}
+
+SEVERITY_DESCRIPTIONS = {
+    0: "No disease symptoms detected. Plant appears healthy.",
+    1: "Early stage infection. Less than 10% of tissue affected. Preventive action recommended.",
+    2: "Established infection. 10-30% of tissue affected. Treatment required.",
+    3: "Severe infection. Over 30% of tissue affected. Urgent intervention needed."
+}
+
+
+class SeverityClassifierCNN(nn.Module):
+    """
+    CNN model for disease severity classification.
+    
+    Architecture options:
+    - EfficientNet-B0 (lightweight, fast)
+    - ResNet-50 (balanced)
+    - ConvNeXt-Tiny (modern, accurate)
+    """
+    
+    def __init__(
+        self,
+        num_classes: int = 4,
+        backbone: str = "efficientnet_b0",
+        pretrained: bool = True,
+        dropout: float = 0.3
+    ):
+        super().__init__()
+        
+        self.num_classes = num_classes
+        self.backbone_name = backbone
+        
+        # Load backbone
+        if backbone == "efficientnet_b0":
+            self.backbone = models.efficientnet_b0(
+                weights=models.EfficientNet_B0_Weights.DEFAULT if pretrained else None
+            )
+            in_features = self.backbone.classifier[1].in_features
+            self.backbone.classifier = nn.Sequential(
+                nn.Dropout(dropout),
+                nn.Linear(in_features, num_classes)
+            )
+            
+        elif backbone == "resnet50":
+            self.backbone = models.resnet50(
+                weights=models.ResNet50_Weights.DEFAULT if pretrained else None
+            )
+            in_features = self.backbone.fc.in_features
+            self.backbone.fc = nn.Sequential(
+                nn.Dropout(dropout),
+                nn.Linear(in_features, num_classes)
+            )
+            
+        elif backbone == "convnext_tiny":
+            self.backbone = models.convnext_tiny(
+                weights=models.ConvNeXt_Tiny_Weights.DEFAULT if pretrained else None
+            )
+            in_features = self.backbone.classifier[2].in_features
+            self.backbone.classifier = nn.Sequential(
+                nn.Flatten(1),
+                nn.LayerNorm(in_features),
+                nn.Dropout(dropout),
+                nn.Linear(in_features, num_classes)
+            )
+        else:
+            raise ValueError(f"Unknown backbone: {backbone}")
+            
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.backbone(x)
+    
+    def predict(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Get predictions with probabilities."""
+        logits = self.forward(x)
+        probs = F.softmax(logits, dim=1)
+        preds = torch.argmax(probs, dim=1)
+        return preds, probs
+
+
+class SeverityClassifier:
+    """
+    High-level interface for severity classification.
+    
+    Handles image preprocessing, model loading, and prediction formatting.
+    
+    Example:
+        >>> classifier = SeverityClassifier("models/severity_classifier/best.pt")
+        >>> result = classifier.classify("diseased_leaf.jpg")
+        >>> print(f"Severity: {result.severity_label} ({result.confidence:.2f})")
+    """
+    
+    def __init__(
+        self,
+        checkpoint_path: Optional[str] = None,
+        device: Optional[str] = None,
+        image_size: int = 224
+    ):
+        """
+        Initialize severity classifier.
+        
+        Args:
+            checkpoint_path: Path to trained model checkpoint
+            device: Device to use (auto-detected if None)
+            image_size: Input image size for the model
+        """
+        # Set device
+        if device is None:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        else:
+            self.device = device
+            
+        self.image_size = image_size
+        self.checkpoint_path = checkpoint_path
+        
+        # Initialize model
+        self.model = None
+        self._setup_transforms()
+        
+    def _setup_transforms(self):
+        """Setup image preprocessing transforms."""
+        # ImageNet normalization
+        self.transform = transforms.Compose([
+            transforms.Resize((self.image_size, self.image_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+        
+        # Augmentation for training
+        self.train_transform = transforms.Compose([
+            transforms.RandomResizedCrop(self.image_size, scale=(0.8, 1.0)),
+            transforms.RandomHorizontalFlip(),
+            transforms.RandomVerticalFlip(),
+            transforms.RandomRotation(15),
+            transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225]
+            )
+        ])
+        
+    def load_model(self, backbone: str = "efficientnet_b0"):
+        """Load or initialize the model."""
+        if self.model is not None:
+            return
+            
+        self.model = SeverityClassifierCNN(
+            num_classes=4,
+            backbone=backbone,
+            pretrained=True
+        )
+        
+        if self.checkpoint_path and Path(self.checkpoint_path).exists():
+            logger.info(f"Loading checkpoint from {self.checkpoint_path}")
+            checkpoint = torch.load(self.checkpoint_path, map_location=self.device, weights_only=False)
+            self.model.load_state_dict(checkpoint["model_state_dict"])
+        else:
+            logger.warning("No checkpoint loaded, using pretrained backbone only")
+            
+        self.model.to(self.device)
+        self.model.eval()
+        
+    def preprocess_image(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray]
+    ) -> torch.Tensor:
+        """Preprocess image for classification."""
+        if isinstance(image, (str, Path)):
+            image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+            
+        tensor = self.transform(image)
+        return tensor.unsqueeze(0)  # Add batch dimension
+        
+    def classify(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        mask: Optional[np.ndarray] = None
+    ) -> SeverityPrediction:
+        """
+        Classify disease severity in an image.
+        
+        Args:
+            image: Input image (path, PIL Image, or numpy array)
+            mask: Optional binary mask of diseased region
+            
+        Returns:
+            SeverityPrediction with severity level, confidence, and details
+        """
+        self.load_model()
+        
+        # Calculate affected area from mask
+        affected_percent = 0.0
+        if mask is not None:
+            affected_percent = (mask.sum() / mask.size) * 100
+            
+        # Preprocess and predict
+        input_tensor = self.preprocess_image(image).to(self.device)
+        
+        with torch.no_grad():
+            pred, probs = self.model.predict(input_tensor)
+            
+        severity_level = pred.item()
+        confidence = probs[0, severity_level].item()
+        
+        # Format probabilities
+        prob_dict = {
+            SEVERITY_LABELS[i]: probs[0, i].item()
+            for i in range(4)
+        }
+        
+        return SeverityPrediction(
+            severity_level=severity_level,
+            severity_label=SEVERITY_LABELS[severity_level],
+            confidence=confidence,
+            probabilities=prob_dict,
+            affected_area_percent=affected_percent
+        )
+        
+    def classify_region(
+        self,
+        image: Union[str, Path, Image.Image, np.ndarray],
+        mask: np.ndarray
+    ) -> SeverityPrediction:
+        """
+        Classify severity of a specific masked region.
+        
+        Extracts the bounding box of the mask and classifies that region.
+        
+        Args:
+            image: Full image
+            mask: Binary mask of region to classify
+            
+        Returns:
+            SeverityPrediction for the masked region
+        """
+        # Load image if needed
+        if isinstance(image, (str, Path)):
+            image = Image.open(image).convert("RGB")
+        elif isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+            
+        img_array = np.array(image)
+        
+        # Get bounding box from mask
+        rows = np.any(mask, axis=1)
+        cols = np.any(mask, axis=0)
+        
+        if not rows.any() or not cols.any():
+            # Empty mask, return healthy
+            return SeverityPrediction(
+                severity_level=0,
+                severity_label="healthy",
+                confidence=1.0,
+                probabilities={"healthy": 1.0, "mild": 0.0, "moderate": 0.0, "severe": 0.0},
+                affected_area_percent=0.0
+            )
+            
+        y_min, y_max = np.where(rows)[0][[0, -1]]
+        x_min, x_max = np.where(cols)[0][[0, -1]]
+        
+        # Add padding
+        pad = 10
+        y_min = max(0, y_min - pad)
+        y_max = min(img_array.shape[0], y_max + pad)
+        x_min = max(0, x_min - pad)
+        x_max = min(img_array.shape[1], x_max + pad)
+        
+        # Crop region
+        cropped = img_array[y_min:y_max, x_min:x_max]
+        cropped_mask = mask[y_min:y_max, x_min:x_max]
+        
+        return self.classify(cropped, mask=cropped_mask)
+        
+    def classify_batch(
+        self,
+        images: List[Union[str, Path, Image.Image, np.ndarray]],
+        masks: Optional[List[np.ndarray]] = None,
+        batch_size: int = 16
+    ) -> List[SeverityPrediction]:
+        """
+        Classify multiple images in batches.
+        
+        Args:
+            images: List of images to classify
+            masks: Optional list of masks for each image
+            batch_size: Batch size for inference
+            
+        Returns:
+            List of SeverityPrediction for each image
+        """
+        self.load_model()
+        
+        results = []
+        
+        for i in range(0, len(images), batch_size):
+            batch_images = images[i:i + batch_size]
+            batch_masks = masks[i:i + batch_size] if masks else [None] * len(batch_images)
+            
+            # Preprocess batch
+            tensors = [self.preprocess_image(img) for img in batch_images]
+            batch_tensor = torch.cat(tensors, dim=0).to(self.device)
+            
+            # Predict
+            with torch.no_grad():
+                preds, probs = self.model.predict(batch_tensor)
+                
+            # Format results
+            for j, (pred, prob) in enumerate(zip(preds, probs)):
+                mask = batch_masks[j]
+                affected_percent = 0.0
+                if mask is not None:
+                    affected_percent = (mask.sum() / mask.size) * 100
+                    
+                severity_level = pred.item()
+                
+                results.append(SeverityPrediction(
+                    severity_level=severity_level,
+                    severity_label=SEVERITY_LABELS[severity_level],
+                    confidence=prob[severity_level].item(),
+                    probabilities={
+                        SEVERITY_LABELS[k]: prob[k].item()
+                        for k in range(4)
+                    },
+                    affected_area_percent=affected_percent
+                ))
+                
+        return results
+
+
+class PlantDiseaseDataset(Dataset):
+    """
+    Dataset class for training severity classifier.
+    
+    Expected folder structure:
+        data_root/
+            healthy/
+                image1.jpg
+                image2.jpg
+            mild/
+                ...
+            moderate/
+                ...
+            severe/
+                ...
+    """
+    
+    def __init__(
+        self,
+        data_root: str,
+        transform: Optional[transforms.Compose] = None,
+        split: str = "train"
+    ):
+        self.data_root = Path(data_root)
+        self.transform = transform
+        self.split = split
+        
+        # Collect image paths and labels
+        self.samples = []
+        
+        for label_idx, label_name in SEVERITY_LABELS.items():
+            label_dir = self.data_root / label_name
+            if label_dir.exists():
+                for img_path in label_dir.glob("*.jpg"):
+                    self.samples.append((img_path, label_idx))
+                for img_path in label_dir.glob("*.png"):
+                    self.samples.append((img_path, label_idx))
+                    
+        logger.info(f"Loaded {len(self.samples)} samples for {split}")
+        
+    def __len__(self) -> int:
+        return len(self.samples)
+        
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, int]:
+        img_path, label = self.samples[idx]
+        
+        image = Image.open(img_path).convert("RGB")
+        
+        if self.transform:
+            image = self.transform(image)
+            
+        return image, label
+
+
+def train_classifier(
+    train_data_root: str,
+    val_data_root: str,
+    output_dir: str,
+    backbone: str = "efficientnet_b0",
+    epochs: int = 50,
+    batch_size: int = 32,
+    learning_rate: float = 1e-4,
+    device: str = "cuda"
+):
+    """
+    Train the severity classifier.
+    
+    Args:
+        train_data_root: Path to training data
+        val_data_root: Path to validation data
+        output_dir: Where to save checkpoints
+        backbone: Model backbone to use
+        epochs: Number of training epochs
+        batch_size: Training batch size
+        learning_rate: Initial learning rate
+        device: Device to train on
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Setup classifier for transforms
+    classifier = SeverityClassifier()
+    
+    # Create datasets
+    train_dataset = PlantDiseaseDataset(
+        train_data_root,
+        transform=classifier.train_transform,
+        split="train"
+    )
+    val_dataset = PlantDiseaseDataset(
+        val_data_root,
+        transform=classifier.transform,
+        split="val"
+    )
+    
+    # Create dataloaders
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        num_workers=4,
+        pin_memory=True
+    )
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=4
+    )
+    
+    # Initialize model
+    model = SeverityClassifierCNN(
+        num_classes=4,
+        backbone=backbone,
+        pretrained=True
+    ).to(device)
+    
+    # Loss and optimizer
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs)
+    
+    best_val_acc = 0.0
+    
+    for epoch in range(epochs):
+        # Training
+        model.train()
+        train_loss = 0.0
+        train_correct = 0
+        train_total = 0
+        
+        for images, labels in train_loader:
+            images, labels = images.to(device), labels.to(device)
+            
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            train_total += labels.size(0)
+            train_correct += predicted.eq(labels).sum().item()
+            
+        # Validation
+        model.eval()
+        val_loss = 0.0
+        val_correct = 0
+        val_total = 0
+        
+        with torch.no_grad():
+            for images, labels in val_loader:
+                images, labels = images.to(device), labels.to(device)
+                outputs = model(images)
+                loss = criterion(outputs, labels)
+                
+                val_loss += loss.item()
+                _, predicted = outputs.max(1)
+                val_total += labels.size(0)
+                val_correct += predicted.eq(labels).sum().item()
+                
+        train_acc = 100. * train_correct / train_total
+        val_acc = 100. * val_correct / val_total
+        
+        scheduler.step()
+        
+        logger.info(
+            f"Epoch {epoch+1}/{epochs} - "
+            f"Train Loss: {train_loss/len(train_loader):.4f}, Train Acc: {train_acc:.2f}% - "
+            f"Val Loss: {val_loss/len(val_loader):.4f}, Val Acc: {val_acc:.2f}%"
+        )
+        
+        # Save best model
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "val_acc": val_acc,
+                "backbone": backbone
+            }, output_dir / "best.pt")
+            logger.info(f"Saved best model with val_acc: {val_acc:.2f}%")
+            
+    # Save final model
+    torch.save({
+        "epoch": epochs,
+        "model_state_dict": model.state_dict(),
+        "optimizer_state_dict": optimizer.state_dict(),
+        "val_acc": val_acc,
+        "backbone": backbone
+    }, output_dir / "final.pt")
+    
+    logger.info(f"Training complete. Best val_acc: {best_val_acc:.2f}%")
+
+
+if __name__ == "__main__":
+    # Quick test
+    classifier = SeverityClassifier()
+    
+    # Create a test image
+    test_image = Image.new("RGB", (224, 224), color=(139, 69, 19))  # Brown
+    
+    # Test classification (will use random weights without checkpoint)
+    result = classifier.classify(test_image)
+    
+    print(f"Severity: {result.severity_label}")
+    print(f"Confidence: {result.confidence:.2f}")
+    print(f"Probabilities: {result.probabilities}")
+    print(f"Description: {SEVERITY_DESCRIPTIONS[result.severity_level]}")

src/treatment_recommender.py

@@ -0,0 +1,525 @@
+"""
+Treatment Recommender Module for CropDoctor-Semantic
+=====================================================
+
+This module uses Claude API to generate contextual treatment
+recommendations based on disease diagnosis results.
+
+Features:
+- Disease identification from symptoms
+- Treatment recommendations (organic/chemical)
+- Preventive measures
+- Timing and application guidance
+"""
+
+import os
+from typing import Dict, List, Optional, Union
+from dataclasses import dataclass
+import json
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TreatmentRecommendation:
+    """Container for treatment recommendations."""
+    disease_name: str
+    disease_type: str  # fungal, bacterial, viral, pest, nutrient
+    confidence: float
+    symptoms_matched: List[str]
+    organic_treatments: List[str]
+    chemical_treatments: List[str]
+    preventive_measures: List[str]
+    timing: str
+    urgency: str  # low, medium, high, critical
+    additional_notes: str
+
+
+# Disease knowledge base for offline fallback
+DISEASE_DATABASE = {
+    "powdery_mildew": {
+        "name": "Powdery Mildew",
+        "type": "fungal",
+        "symptoms": ["white powdery coating", "curled leaves", "stunted growth"],
+        "organic": [
+            "Neem oil spray (1 tbsp per liter water)",
+            "Baking soda solution (1 tsp per liter + few drops soap)",
+            "Milk spray (40% milk, 60% water)",
+            "Sulfur-based fungicide"
+        ],
+        "chemical": [
+            "Myclobutanil",
+            "Triadimefon",
+            "Propiconazole"
+        ],
+        "prevention": [
+            "Improve air circulation",
+            "Avoid overhead watering",
+            "Remove infected plant parts",
+            "Plant resistant varieties"
+        ],
+        "timing": "Apply at first sign of infection, repeat every 7-14 days"
+    },
+    "leaf_spot": {
+        "name": "Leaf Spot Disease",
+        "type": "fungal",
+        "symptoms": ["brown spots", "circular lesions", "yellow halos"],
+        "organic": [
+            "Copper-based fungicide",
+            "Neem oil treatment",
+            "Remove and destroy infected leaves"
+        ],
+        "chemical": [
+            "Chlorothalonil",
+            "Mancozeb",
+            "Azoxystrobin"
+        ],
+        "prevention": [
+            "Water at soil level",
+            "Mulch around plants",
+            "Rotate crops annually",
+            "Maintain proper spacing"
+        ],
+        "timing": "Begin treatment early, apply every 7-10 days during wet weather"
+    },
+    "bacterial_blight": {
+        "name": "Bacterial Blight",
+        "type": "bacterial",
+        "symptoms": ["water-soaked lesions", "angular spots", "wilting"],
+        "organic": [
+            "Copper hydroxide spray",
+            "Remove infected plants",
+            "Improve drainage"
+        ],
+        "chemical": [
+            "Streptomycin sulfate",
+            "Oxytetracycline",
+            "Copper-based bactericides"
+        ],
+        "prevention": [
+            "Use disease-free seeds",
+            "Avoid working with wet plants",
+            "Sanitize tools between plants",
+            "Practice crop rotation"
+        ],
+        "timing": "Apply preventively or at first symptoms, difficult to cure once established"
+    },
+    "viral_mosaic": {
+        "name": "Viral Mosaic Disease",
+        "type": "viral",
+        "symptoms": ["mosaic pattern", "mottled leaves", "distorted growth"],
+        "organic": [
+            "Remove and destroy infected plants",
+            "Control aphid vectors",
+            "Use reflective mulch"
+        ],
+        "chemical": [
+            "No direct treatment available",
+            "Control vectors with insecticides"
+        ],
+        "prevention": [
+            "Plant resistant varieties",
+            "Control aphid populations",
+            "Remove weeds that harbor virus",
+            "Sanitize tools frequently"
+        ],
+        "timing": "Prevention is key - no cure available once infected"
+    },
+    "nutrient_deficiency": {
+        "name": "Nutrient Deficiency",
+        "type": "nutrient",
+        "symptoms": ["chlorosis", "yellowing", "purple coloration"],
+        "organic": [
+            "Compost application",
+            "Foliar feeding with seaweed extract",
+            "Fish emulsion fertilizer"
+        ],
+        "chemical": [
+            "Balanced NPK fertilizer",
+            "Iron chelate for iron deficiency",
+            "Epsom salt for magnesium deficiency"
+        ],
+        "prevention": [
+            "Regular soil testing",
+            "Maintain soil pH 6.0-7.0",
+            "Add organic matter annually",
+            "Mulch to retain nutrients"
+        ],
+        "timing": "Apply fertilizers during active growth, avoid over-fertilization"
+    },
+    "aphid_infestation": {
+        "name": "Aphid Infestation",
+        "type": "pest",
+        "symptoms": ["sticky residue", "curled leaves", "visible insects"],
+        "organic": [
+            "Strong water spray to dislodge",
+            "Neem oil spray",
+            "Insecticidal soap",
+            "Release ladybugs or lacewings"
+        ],
+        "chemical": [
+            "Pyrethrin-based insecticides",
+            "Imidacloprid (systemic)",
+            "Malathion"
+        ],
+        "prevention": [
+            "Encourage beneficial insects",
+            "Remove weeds",
+            "Avoid excess nitrogen fertilization",
+            "Use reflective mulch"
+        ],
+        "timing": "Treat early when populations are low, monitor regularly"
+    }
+}
+
+
+class TreatmentRecommender:
+    """
+    Generate treatment recommendations using LLM.
+    
+    Uses Claude API for intelligent, contextual recommendations
+    with fallback to local knowledge base.
+    
+    Example:
+        >>> recommender = TreatmentRecommender(api_key="your_key")
+        >>> result = recommender.get_recommendation(
+        ...     symptoms=["brown spots", "yellowing"],
+        ...     severity="moderate",
+        ...     plant_species="tomato"
+        ... )
+        >>> print(result.disease_name)
+        >>> print(result.organic_treatments)
+    """
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        use_llm: bool = True,
+        model: str = "claude-sonnet-4-20250514"
+    ):
+        """
+        Initialize treatment recommender.
+        
+        Args:
+            api_key: Anthropic API key (uses env var ANTHROPIC_API_KEY if None)
+            use_llm: Whether to use LLM for recommendations
+            model: Claude model to use
+        """
+        self.use_llm = use_llm
+        self.model = model
+        self.client = None
+        
+        if use_llm:
+            api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+            if api_key:
+                try:
+                    import anthropic
+                    self.client = anthropic.Anthropic(api_key=api_key)
+                    logger.info("Anthropic client initialized successfully")
+                except ImportError:
+                    logger.warning("anthropic package not installed, using offline mode")
+                    self.use_llm = False
+            else:
+                logger.warning("No API key provided, using offline knowledge base")
+                self.use_llm = False
+                
+    def _build_prompt(
+        self,
+        symptoms: List[str],
+        severity: str,
+        plant_species: Optional[str] = None,
+        affected_area_percent: Optional[float] = None,
+        additional_context: Optional[str] = None
+    ) -> str:
+        """Build the prompt for Claude."""
+        
+        prompt = f"""You are an expert plant pathologist providing diagnosis and treatment recommendations.
+
+Based on the following observations, identify the most likely disease and provide treatment recommendations.
+
+## Observations:
+- **Symptoms detected**: {', '.join(symptoms)}
+- **Severity level**: {severity}
+"""
+        
+        if plant_species:
+            prompt += f"- **Plant species**: {plant_species}\n"
+            
+        if affected_area_percent is not None:
+            prompt += f"- **Affected area**: {affected_area_percent:.1f}%\n"
+            
+        if additional_context:
+            prompt += f"- **Additional context**: {additional_context}\n"
+            
+        prompt += """
+## Please provide:
+1. **Disease identification**: Name and type (fungal/bacterial/viral/pest/nutrient)
+2. **Confidence level**: How confident are you in this diagnosis (0-100%)
+3. **Organic treatments**: List 3-5 organic/natural treatment options
+4. **Chemical treatments**: List 2-3 chemical treatment options (if needed)
+5. **Preventive measures**: List 3-5 prevention strategies
+6. **Timing**: When and how often to apply treatments
+7. **Urgency**: How urgent is treatment (low/medium/high/critical)
+8. **Additional notes**: Any important considerations
+
+Format your response as JSON with these exact keys:
+{
+    "disease_name": "string",
+    "disease_type": "string",
+    "confidence": number,
+    "symptoms_matched": ["string"],
+    "organic_treatments": ["string"],
+    "chemical_treatments": ["string"],
+    "preventive_measures": ["string"],
+    "timing": "string",
+    "urgency": "string",
+    "additional_notes": "string"
+}
+"""
+        return prompt
+        
+    def get_recommendation(
+        self,
+        symptoms: List[str],
+        severity: str = "moderate",
+        plant_species: Optional[str] = None,
+        affected_area_percent: Optional[float] = None,
+        additional_context: Optional[str] = None
+    ) -> TreatmentRecommendation:
+        """
+        Get treatment recommendation for detected symptoms.
+        
+        Args:
+            symptoms: List of detected symptoms
+            severity: Severity level (healthy, mild, moderate, severe)
+            plant_species: Optional plant species for more specific advice
+            affected_area_percent: Percentage of plant affected
+            additional_context: Any additional observations
+            
+        Returns:
+            TreatmentRecommendation with diagnosis and treatment options
+        """
+        if self.use_llm and self.client:
+            return self._get_llm_recommendation(
+                symptoms, severity, plant_species,
+                affected_area_percent, additional_context
+            )
+        else:
+            return self._get_offline_recommendation(symptoms, severity)
+            
+    def _get_llm_recommendation(
+        self,
+        symptoms: List[str],
+        severity: str,
+        plant_species: Optional[str],
+        affected_area_percent: Optional[float],
+        additional_context: Optional[str]
+    ) -> TreatmentRecommendation:
+        """Get recommendation from Claude API."""
+        
+        prompt = self._build_prompt(
+            symptoms, severity, plant_species,
+            affected_area_percent, additional_context
+        )
+        
+        try:
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=1500,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            # Parse JSON response
+            content = response.content[0].text
+            
+            # Extract JSON from response
+            start = content.find('{')
+            end = content.rfind('}') + 1
+            if start >= 0 and end > start:
+                json_str = content[start:end]
+                data = json.loads(json_str)
+                
+                return TreatmentRecommendation(
+                    disease_name=data.get("disease_name", "Unknown"),
+                    disease_type=data.get("disease_type", "unknown"),
+                    confidence=data.get("confidence", 0) / 100,
+                    symptoms_matched=data.get("symptoms_matched", symptoms),
+                    organic_treatments=data.get("organic_treatments", []),
+                    chemical_treatments=data.get("chemical_treatments", []),
+                    preventive_measures=data.get("preventive_measures", []),
+                    timing=data.get("timing", "Consult local extension service"),
+                    urgency=data.get("urgency", "medium"),
+                    additional_notes=data.get("additional_notes", "")
+                )
+            else:
+                logger.warning("Could not parse LLM response, using offline mode")
+                return self._get_offline_recommendation(symptoms, severity)
+                
+        except Exception as e:
+            logger.error(f"LLM request failed: {e}")
+            return self._get_offline_recommendation(symptoms, severity)
+            
+    def _get_offline_recommendation(
+        self,
+        symptoms: List[str],
+        severity: str
+    ) -> TreatmentRecommendation:
+        """Get recommendation from local knowledge base."""
+        
+        # Simple symptom matching
+        best_match = None
+        best_score = 0
+        matched_symptoms = []
+        
+        symptoms_lower = [s.lower() for s in symptoms]
+        
+        for disease_key, disease_data in DISEASE_DATABASE.items():
+            score = 0
+            matches = []
+            
+            for symptom in disease_data["symptoms"]:
+                for input_symptom in symptoms_lower:
+                    if any(word in input_symptom for word in symptom.split()):
+                        score += 1
+                        matches.append(symptom)
+                        break
+                        
+            if score > best_score:
+                best_score = score
+                best_match = disease_key
+                matched_symptoms = matches
+                
+        if best_match is None:
+            # Default to general recommendation
+            return TreatmentRecommendation(
+                disease_name="Unidentified Condition",
+                disease_type="unknown",
+                confidence=0.3,
+                symptoms_matched=symptoms,
+                organic_treatments=[
+                    "Apply broad-spectrum organic fungicide",
+                    "Improve plant nutrition",
+                    "Remove affected plant parts"
+                ],
+                chemical_treatments=[
+                    "Consult local agricultural extension",
+                    "Get professional diagnosis"
+                ],
+                preventive_measures=[
+                    "Improve air circulation",
+                    "Avoid overwatering",
+                    "Maintain plant hygiene"
+                ],
+                timing="Monitor closely and treat at first sign of worsening",
+                urgency="medium" if severity in ["mild", "moderate"] else "high",
+                additional_notes="Unable to identify specific disease. Consider professional diagnosis."
+            )
+            
+        disease = DISEASE_DATABASE[best_match]
+        
+        # Calculate urgency based on severity
+        urgency_map = {
+            "healthy": "low",
+            "mild": "medium",
+            "moderate": "high",
+            "severe": "critical"
+        }
+        
+        return TreatmentRecommendation(
+            disease_name=disease["name"],
+            disease_type=disease["type"],
+            confidence=min(0.9, 0.5 + (best_score * 0.15)),
+            symptoms_matched=matched_symptoms,
+            organic_treatments=disease["organic"],
+            chemical_treatments=disease["chemical"],
+            preventive_measures=disease["prevention"],
+            timing=disease["timing"],
+            urgency=urgency_map.get(severity, "medium"),
+            additional_notes=f"Diagnosis based on {best_score} symptom matches."
+        )
+        
+    def format_report(
+        self,
+        recommendation: TreatmentRecommendation,
+        include_chemical: bool = True
+    ) -> str:
+        """
+        Format recommendation as a readable report.
+        
+        Args:
+            recommendation: TreatmentRecommendation to format
+            include_chemical: Whether to include chemical treatments
+            
+        Returns:
+            Formatted string report
+        """
+        urgency_emoji = {
+            "low": "🟢",
+            "medium": "🟡",
+            "high": "🟠",
+            "critical": "🔴"
+        }
+        
+        report = f"""
+╔══════════════════════════════════════════════════════════════╗
+║                    DIAGNOSTIC REPORT                          ║
+╚══════════════════════════════════════════════════════════════╝
+
+📋 DIAGNOSIS
+   Disease: {recommendation.disease_name}
+   Type: {recommendation.disease_type.capitalize()}
+   Confidence: {recommendation.confidence:.0%}
+   Urgency: {urgency_emoji.get(recommendation.urgency, '⚪')} {recommendation.urgency.upper()}
+
+📍 SYMPTOMS MATCHED
+"""
+        for symptom in recommendation.symptoms_matched:
+            report += f"   • {symptom}\n"
+            
+        report += """
+🌿 ORGANIC TREATMENTS
+"""
+        for treatment in recommendation.organic_treatments:
+            report += f"   • {treatment}\n"
+            
+        if include_chemical and recommendation.chemical_treatments:
+            report += """
+🧪 CHEMICAL TREATMENTS
+"""
+            for treatment in recommendation.chemical_treatments:
+                report += f"   • {treatment}\n"
+                
+        report += """
+🛡️ PREVENTIVE MEASURES
+"""
+        for measure in recommendation.preventive_measures:
+            report += f"   • {measure}\n"
+            
+        report += f"""
+⏰ TIMING
+   {recommendation.timing}
+
+📝 NOTES
+   {recommendation.additional_notes}
+
+═══════════════════════════════════════════════════════════════
+"""
+        return report
+
+
+if __name__ == "__main__":
+    # Test without API
+    recommender = TreatmentRecommender(use_llm=False)
+    
+    # Test with symptoms
+    result = recommender.get_recommendation(
+        symptoms=["brown spots", "yellow halos", "circular lesions"],
+        severity="moderate",
+        plant_species="tomato"
+    )
+    
+    print(recommender.format_report(result))

src/visualization.py

@@ -0,0 +1,460 @@
+"""
+Visualization Module for CropDoctor-Semantic
+=============================================
+
+This module provides visualization functions for:
+- Segmentation masks overlay
+- Severity heatmaps
+- Diagnostic dashboards
+- Comparison views
+"""
+
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.colors import LinearSegmentedColormap
+from typing import List, Optional, Tuple, Union, Dict
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Color schemes
+SEVERITY_COLORS = {
+    'healthy': '#2ECC71',    # Green
+    'mild': '#F1C40F',       # Yellow
+    'moderate': '#E67E22',   # Orange
+    'severe': '#E74C3C'      # Red
+}
+
+SYMPTOM_COLORS = [
+    '#E74C3C',  # Red
+    '#9B59B6',  # Purple
+    '#3498DB',  # Blue
+    '#E67E22',  # Orange
+    '#1ABC9C',  # Teal
+    '#F39C12',  # Yellow
+    '#D35400',  # Dark Orange
+    '#8E44AD',  # Dark Purple
+]
+
+
+def create_diagnostic_visualization(
+    image: Union[str, Path, Image.Image, np.ndarray],
+    masks: Optional[np.ndarray] = None,
+    severity_label: str = "unknown",
+    disease_name: str = "Unknown",
+    affected_percent: float = 0.0,
+    prompt_labels: Optional[List[str]] = None,
+    figsize: Tuple[int, int] = (16, 6)
+) -> plt.Figure:
+    """
+    Create a comprehensive diagnostic visualization.
+    
+    Args:
+        image: Input image
+        masks: Segmentation masks array (N, H, W)
+        severity_label: Severity classification result
+        disease_name: Identified disease name
+        affected_percent: Percentage of affected area
+        prompt_labels: Labels for each mask
+        figsize: Figure size
+        
+    Returns:
+        matplotlib Figure object
+    """
+    # Load image
+    if isinstance(image, (str, Path)):
+        image = Image.open(image).convert("RGB")
+    elif isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+        
+    img_array = np.array(image)
+    
+    # Create figure with subplots
+    fig, axes = plt.subplots(1, 3, figsize=figsize)
+    fig.suptitle(f'CropDoctor Diagnostic Report', fontsize=14, fontweight='bold')
+    
+    # Panel 1: Original Image
+    axes[0].imshow(img_array)
+    axes[0].set_title('Original Image', fontsize=12)
+    axes[0].axis('off')
+    
+    # Panel 2: Segmentation Overlay
+    if masks is not None and len(masks) > 0:
+        overlay = create_mask_overlay(img_array, masks, alpha=0.5)
+        axes[1].imshow(overlay)
+        
+        # Create legend
+        if prompt_labels:
+            patches = []
+            for i, label in enumerate(prompt_labels[:len(SYMPTOM_COLORS)]):
+                color = SYMPTOM_COLORS[i % len(SYMPTOM_COLORS)]
+                patches.append(mpatches.Patch(color=color, label=label, alpha=0.7))
+            axes[1].legend(handles=patches, loc='upper right', fontsize=8)
+    else:
+        axes[1].imshow(img_array)
+        axes[1].text(0.5, 0.5, 'No disease regions detected',
+                    transform=axes[1].transAxes, ha='center', va='center',
+                    fontsize=12, color='green')
+        
+    axes[1].set_title('Disease Detection', fontsize=12)
+    axes[1].axis('off')
+    
+    # Panel 3: Diagnostic Summary
+    axes[2].axis('off')
+    
+    # Create summary text
+    severity_color = SEVERITY_COLORS.get(severity_label.lower(), '#95A5A6')
+    
+    summary_text = f"""
+    ╔════════════════════════════════╗
+    ║     DIAGNOSTIC SUMMARY         ║
+    ╚════════════════════════════════╝
+    
+    📋 Disease: {disease_name}
+    
+    ⚠️ Severity: {severity_label.upper()}
+    
+    📊 Affected Area: {affected_percent:.1f}%
+    
+    """
+    
+    # Add severity indicator
+    axes[2].text(0.5, 0.65, summary_text, transform=axes[2].transAxes,
+                fontsize=11, fontfamily='monospace',
+                verticalalignment='top', horizontalalignment='center')
+    
+    # Add severity color bar
+    severity_bar = plt.Rectangle((0.15, 0.25), 0.7, 0.1, 
+                                  facecolor=severity_color, 
+                                  edgecolor='black',
+                                  transform=axes[2].transAxes)
+    axes[2].add_patch(severity_bar)
+    axes[2].text(0.5, 0.30, severity_label.upper(),
+                transform=axes[2].transAxes, ha='center', va='center',
+                fontsize=12, fontweight='bold', color='white')
+    
+    # Add affected area progress bar
+    bar_width = 0.7 * (affected_percent / 100)
+    bg_bar = plt.Rectangle((0.15, 0.12), 0.7, 0.06,
+                           facecolor='#EEEEEE', edgecolor='black',
+                           transform=axes[2].transAxes)
+    progress_bar = plt.Rectangle((0.15, 0.12), max(0.01, bar_width), 0.06,
+                                 facecolor='#E74C3C',
+                                 transform=axes[2].transAxes)
+    axes[2].add_patch(bg_bar)
+    axes[2].add_patch(progress_bar)
+    axes[2].text(0.5, 0.08, f'Affected Area: {affected_percent:.1f}%',
+                transform=axes[2].transAxes, ha='center', fontsize=10)
+    
+    plt.tight_layout()
+    
+    return fig
+
+
+def create_mask_overlay(
+    image: np.ndarray,
+    masks: np.ndarray,
+    alpha: float = 0.5,
+    colors: Optional[List[str]] = None
+) -> np.ndarray:
+    """
+    Create an overlay of segmentation masks on an image.
+    
+    Args:
+        image: RGB image array (H, W, 3)
+        masks: Binary masks (N, H, W)
+        alpha: Transparency of overlay
+        colors: Optional list of colors for masks
+        
+    Returns:
+        Image array with mask overlay
+    """
+    if colors is None:
+        colors = SYMPTOM_COLORS
+        
+    # Start with the original image
+    overlay = image.copy().astype(np.float32)
+    
+    for i, mask in enumerate(masks):
+        if mask.any():
+            # Get color for this mask
+            color_hex = colors[i % len(colors)]
+            color_rgb = hex_to_rgb(color_hex)
+            
+            # Create colored mask
+            colored_mask = np.zeros_like(overlay)
+            colored_mask[mask] = color_rgb
+            
+            # Blend with overlay
+            mask_3d = np.stack([mask] * 3, axis=-1)
+            overlay = np.where(
+                mask_3d,
+                overlay * (1 - alpha) + colored_mask * alpha,
+                overlay
+            )
+            
+    return overlay.astype(np.uint8)
+
+
+def create_severity_heatmap(
+    image: Union[str, Path, Image.Image, np.ndarray],
+    severity_map: np.ndarray,
+    figsize: Tuple[int, int] = (12, 5)
+) -> plt.Figure:
+    """
+    Create a heatmap showing severity distribution across the image.
+    
+    Args:
+        image: Input image
+        severity_map: Array of severity values (H, W) with values 0-3
+        figsize: Figure size
+        
+    Returns:
+        matplotlib Figure object
+    """
+    # Load image
+    if isinstance(image, (str, Path)):
+        image = Image.open(image).convert("RGB")
+    elif isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+        
+    img_array = np.array(image)
+    
+    # Create custom colormap
+    colors = ['#2ECC71', '#F1C40F', '#E67E22', '#E74C3C']  # Green to Red
+    cmap = LinearSegmentedColormap.from_list('severity', colors, N=256)
+    
+    fig, axes = plt.subplots(1, 2, figsize=figsize)
+    
+    # Original image
+    axes[0].imshow(img_array)
+    axes[0].set_title('Original Image')
+    axes[0].axis('off')
+    
+    # Heatmap overlay
+    axes[1].imshow(img_array)
+    heatmap = axes[1].imshow(severity_map, cmap=cmap, alpha=0.6, vmin=0, vmax=3)
+    axes[1].set_title('Severity Heatmap')
+    axes[1].axis('off')
+    
+    # Add colorbar
+    cbar = plt.colorbar(heatmap, ax=axes[1], fraction=0.046, pad=0.04)
+    cbar.set_ticks([0, 1, 2, 3])
+    cbar.set_ticklabels(['Healthy', 'Mild', 'Moderate', 'Severe'])
+    
+    plt.tight_layout()
+    
+    return fig
+
+
+def create_comparison_view(
+    images: List[Union[str, Path, Image.Image]],
+    results: List[Dict],
+    cols: int = 4,
+    figsize_per_image: Tuple[float, float] = (4, 5)
+) -> plt.Figure:
+    """
+    Create a grid comparison view of multiple diagnoses.
+    
+    Args:
+        images: List of images
+        results: List of diagnostic results (dicts with 'severity_label', 'disease_name', etc.)
+        cols: Number of columns in grid
+        figsize_per_image: Size per image in the grid
+        
+    Returns:
+        matplotlib Figure object
+    """
+    n_images = len(images)
+    rows = (n_images + cols - 1) // cols
+    
+    fig, axes = plt.subplots(
+        rows, cols,
+        figsize=(figsize_per_image[0] * cols, figsize_per_image[1] * rows)
+    )
+    
+    if rows == 1:
+        axes = [axes]
+    if cols == 1:
+        axes = [[ax] for ax in axes]
+        
+    for i, (img, result) in enumerate(zip(images, results)):
+        row = i // cols
+        col = i % cols
+        ax = axes[row][col] if rows > 1 else axes[col]
+        
+        # Load image
+        if isinstance(img, (str, Path)):
+            img = Image.open(img).convert("RGB")
+            
+        ax.imshow(img)
+        ax.axis('off')
+        
+        # Add colored border based on severity
+        severity = result.get('severity_label', 'unknown')
+        color = SEVERITY_COLORS.get(severity.lower(), '#95A5A6')
+        
+        for spine in ax.spines.values():
+            spine.set_edgecolor(color)
+            spine.set_linewidth(4)
+            spine.set_visible(True)
+            
+        # Add label
+        ax.set_title(
+            f"{result.get('disease_name', 'Unknown')}\n{severity.upper()}",
+            fontsize=10,
+            color=color
+        )
+        
+    # Hide empty subplots
+    for i in range(n_images, rows * cols):
+        row = i // cols
+        col = i % cols
+        ax = axes[row][col] if rows > 1 else axes[col]
+        ax.axis('off')
+        ax.set_visible(False)
+        
+    plt.tight_layout()
+    
+    return fig
+
+
+def create_treatment_card(
+    result: Dict,
+    figsize: Tuple[int, int] = (8, 10)
+) -> plt.Figure:
+    """
+    Create a treatment recommendation card.
+    
+    Args:
+        result: Diagnostic result dictionary
+        figsize: Figure size
+        
+    Returns:
+        matplotlib Figure object
+    """
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.axis('off')
+    
+    severity_color = SEVERITY_COLORS.get(
+        result.get('severity_label', 'unknown').lower(),
+        '#95A5A6'
+    )
+    
+    # Title
+    ax.text(0.5, 0.95, '🌿 TREATMENT CARD',
+           ha='center', va='top', fontsize=16, fontweight='bold',
+           transform=ax.transAxes)
+    
+    # Disease info
+    disease_text = f"""
+╔═══════════════════════════════════════════╗
+║ Disease: {result.get('disease_name', 'Unknown'):<32}║
+║ Type: {result.get('disease_type', 'unknown'):<35}║
+║ Severity: {result.get('severity_label', 'unknown').upper():<31}║
+║ Affected Area: {result.get('affected_area_percent', 0):.1f}%{' ' * 25}║
+╚═══════════════════════════════════════════╝
+"""
+    ax.text(0.5, 0.85, disease_text,
+           ha='center', va='top', fontfamily='monospace', fontsize=10,
+           transform=ax.transAxes)
+    
+    # Treatments
+    y_pos = 0.60
+    
+    # Organic treatments
+    ax.text(0.1, y_pos, '🌱 ORGANIC TREATMENTS', fontweight='bold', fontsize=11,
+           transform=ax.transAxes)
+    y_pos -= 0.03
+    
+    for treatment in result.get('organic_treatments', [])[:4]:
+        ax.text(0.12, y_pos, f'• {treatment[:50]}', fontsize=9,
+               transform=ax.transAxes)
+        y_pos -= 0.03
+        
+    y_pos -= 0.02
+    
+    # Chemical treatments
+    if result.get('chemical_treatments'):
+        ax.text(0.1, y_pos, '🧪 CHEMICAL TREATMENTS', fontweight='bold', fontsize=11,
+               transform=ax.transAxes)
+        y_pos -= 0.03
+        
+        for treatment in result.get('chemical_treatments', [])[:3]:
+            ax.text(0.12, y_pos, f'• {treatment[:50]}', fontsize=9,
+                   transform=ax.transAxes)
+            y_pos -= 0.03
+            
+    y_pos -= 0.02
+    
+    # Prevention
+    ax.text(0.1, y_pos, '🛡️ PREVENTION', fontweight='bold', fontsize=11,
+           transform=ax.transAxes)
+    y_pos -= 0.03
+    
+    for measure in result.get('preventive_measures', [])[:4]:
+        ax.text(0.12, y_pos, f'• {measure[:50]}', fontsize=9,
+               transform=ax.transAxes)
+        y_pos -= 0.03
+        
+    # Timing
+    y_pos -= 0.02
+    ax.text(0.1, y_pos, f"⏰ TIMING: {result.get('treatment_timing', 'Consult expert')[:60]}",
+           fontsize=9, transform=ax.transAxes)
+    
+    # Add border
+    rect = plt.Rectangle((0.05, 0.05), 0.9, 0.92,
+                         fill=False, edgecolor=severity_color, linewidth=3,
+                         transform=ax.transAxes)
+    ax.add_patch(rect)
+    
+    return fig
+
+
+def hex_to_rgb(hex_color: str) -> List[int]:
+    """Convert hex color to RGB."""
+    hex_color = hex_color.lstrip('#')
+    return [int(hex_color[i:i+2], 16) for i in (0, 2, 4)]
+
+
+def save_visualization(
+    fig: plt.Figure,
+    output_path: Union[str, Path],
+    dpi: int = 150
+):
+    """Save figure to file."""
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(output_path, dpi=dpi, bbox_inches='tight', facecolor='white')
+    plt.close(fig)
+    logger.info(f"Visualization saved to {output_path}")
+
+
+if __name__ == "__main__":
+    # Test visualizations
+    import numpy as np
+    
+    # Create test image
+    test_img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
+    test_img[:, :, 1] = 139  # Greenish tint
+    
+    # Create test masks
+    test_masks = np.zeros((2, 480, 640), dtype=bool)
+    test_masks[0, 100:200, 100:200] = True  # Square mask
+    test_masks[1, 300:400, 400:500] = True  # Another square
+    
+    # Test diagnostic visualization
+    fig = create_diagnostic_visualization(
+        test_img,
+        test_masks,
+        severity_label="moderate",
+        disease_name="Leaf Spot Disease",
+        affected_percent=15.5,
+        prompt_labels=["brown spots", "yellowing"]
+    )
+    
+    save_visualization(fig, "/tmp/test_diagnostic.png")
+    print("Test visualization saved to /tmp/test_diagnostic.png")