Upload 3 files

README.md

@@ -1,13 +1,12 @@
----
-title: Detector V1
-emoji: 📚
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: This will detect and crop the seeds
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Seed Detection Cropping
+emoji: 🌱
+colorFrom: green
+colorTo: yellow
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,250 @@
+import os
+import io
+import zipfile
+import gradio as gr
+import torch
+import cv2
+import numpy as np
+from PIL import Image
+import torchvision.transforms as T
+import torchvision
+from torchvision.models.detection import fasterrcnn_resnet50_fpn
+from pathlib import Path
+
+# Global variable to store the model
+model = None
+device = None
+
+def load_model(model_path="seed_frcnn.pth", num_classes=2):
+    """Load the trained Faster R-CNN model"""
+    global model, device
+    
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f"Loading model on {device}...")
+    
+    try:
+        model = fasterrcnn_resnet50_fpn(pretrained=False)
+        model.roi_heads.box_predictor = torchvision.models.detection.faster_rcnn.FastRCNNPredictor(
+            model.roi_heads.box_predictor.cls_score.in_features, num_classes
+        )
+        model.load_state_dict(torch.load(model_path, map_location=device))
+        model.to(device)
+        model.eval()
+        print("Model loaded successfully!")
+        return f"✅ Model loaded successfully on {device}!"
+    except Exception as e:
+        return f"❌ Error loading model: {str(e)}"
+
+def run_inference(img_pil, score_thresh=0.5):
+    """Run inference on a PIL image"""
+    if model is None:
+        return []
+    
+    transform = T.ToTensor()
+    img_tensor = transform(img_pil).to(device)
+    
+    with torch.no_grad():
+        outputs = model([img_tensor])[0]
+    
+    boxes = outputs["boxes"].cpu().numpy()
+    scores = outputs["scores"].cpu().numpy()
+    labels = outputs["labels"].cpu().numpy()
+    
+    detections = []
+    for box, score, label in zip(boxes, scores, labels):
+        if score >= score_thresh:
+            x1, y1, x2, y2 = box.astype(int)
+            detections.append({
+                'bbox': [x1, y1, x2, y2],
+                'score': float(score),
+                'class': 'seed'
+            })
+    
+    return detections
+
+def draw_boxes(image, detections):
+    """Draw bounding boxes on image"""
+    img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    
+    for det in detections:
+        x1, y1, x2, y2 = det['bbox']
+        score = det['score']
+        
+        # Draw rectangle
+        cv2.rectangle(img_cv, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        
+        # Add label
+        label = f"seed: {score:.2f}"
+        cv2.putText(img_cv, label, (x1, y1-10), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+    
+    return cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB)
+
+def process_images(images, threshold, folder_name):
+    """Process uploaded images and return crops as a ZIP file"""
+    if model is None:
+        return None, "❌ Model not loaded! Please wait for the app to initialize.", None
+    
+    if not images:
+        return None, "❌ Please upload at least one image!", None
+    
+    if not folder_name:
+        folder_name = "seed_crops"
+    
+    # Clean folder name
+    folder_name = "".join(c for c in folder_name if c.isalnum() or c in ('-', '_'))
+    
+    # Create in-memory ZIP file
+    zip_buffer = io.BytesIO()
+    total_crops = 0
+    processed_images = 0
+    preview_images = []
+    
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for idx, img_file in enumerate(images):
+            try:
+                # Load image
+                if isinstance(img_file, str):
+                    img = Image.open(img_file).convert("RGB")
+                    base_name = Path(img_file).stem
+                else:
+                    img = Image.open(img_file).convert("RGB")
+                    base_name = f"image_{idx+1}"
+                
+                # Run inference
+                detections = run_inference(img, threshold)
+                
+                if len(detections) > 0:
+                    # Convert to OpenCV format for cropping
+                    img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+                    h, w = img_cv.shape[:2]
+                    
+                    # Save crops
+                    for i, det in enumerate(detections):
+                        x1, y1, x2, y2 = map(int, det['bbox'])
+                        
+                        # Ensure coordinates are within bounds
+                        x1 = max(0, x1)
+                        y1 = max(0, y1)
+                        x2 = min(w, x2)
+                        y2 = min(h, y2)
+                        
+                        # Extract crop
+                        crop = img_cv[y1:y2, x1:x2]
+                        
+                        if crop.size > 0:
+                            # Convert crop to bytes
+                            _, buffer = cv2.imencode('.jpg', crop)
+                            crop_bytes = buffer.tobytes()
+                            
+                            # Add to ZIP with folder structure
+                            crop_filename = f"{folder_name}/{base_name}_seed_{i:03d}_score_{det['score']:.3f}.jpg"
+                            zip_file.writestr(crop_filename, crop_bytes)
+                            total_crops += 1
+                    
+                    # Create preview with boxes (for first 3 images only)
+                    if len(preview_images) < 3:
+                        preview_img = draw_boxes(img, detections)
+                        preview_images.append(preview_img)
+                    
+                    processed_images += 1
+                
+            except Exception as e:
+                print(f"Error processing image {idx}: {str(e)}")
+                continue
+    
+    if total_crops == 0:
+        return None, "⚠️ No seeds detected! Try lowering the threshold.", None
+    
+    zip_buffer.seek(0)
+    
+    # Save to temporary file for Gradio
+    temp_zip_path = f"/tmp/{folder_name}.zip"
+    with open(temp_zip_path, 'wb') as f:
+        f.write(zip_buffer.getvalue())
+    
+    status_msg = f"✅ Processed {processed_images} images\n"
+    status_msg += f"🌱 Detected and saved {total_crops} seed crops\n"
+    status_msg += f"📦 ZIP file ready for download!"
+    
+    # Return ZIP file path, status message, and preview images
+    return temp_zip_path, status_msg, preview_images if preview_images else None
+
+# Create Gradio interface
+with gr.Blocks(title="Seed Detection & Cropping", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🌱 Seed Detection & Cropping Tool
+    Upload images to detect seeds using AI-powered Faster R-CNN model. Get all detected seeds as individual cropped images in a ZIP file.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.File(
+                label="📤 Upload Images (One or Multiple)",
+                file_count="multiple",
+                file_types=["image"]
+            )
+            
+            threshold_slider = gr.Slider(
+                minimum=0.1,
+                maximum=0.95,
+                value=0.5,
+                step=0.05,
+                label="🎚️ Detection Confidence Threshold"
+            )
+            
+            folder_name_input = gr.Textbox(
+                label="📁 Output Folder Name",
+                value="seed_crops",
+                placeholder="Enter folder name for crops"
+            )
+            
+            process_btn = gr.Button("🔍 Detect & Crop Seeds", variant="primary", size="lg")
+        
+        with gr.Column():
+            status_output = gr.Textbox(label="📊 Status", lines=3)
+            download_output = gr.File(label="💾 Download Cropped Seeds (ZIP)")
+            preview_gallery = gr.Gallery(
+                label="🖼️ Preview (First 3 images with detections)",
+                columns=3,
+                height="auto"
+            )
+    
+    # Event handler
+    process_btn.click(
+        fn=process_images,
+        inputs=[image_input, threshold_slider, folder_name_input],
+        outputs=[download_output, status_output, preview_gallery]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📋 How to Use:
+    1. **Upload Images**: Click the upload box and select one or multiple images containing seeds
+    2. **Adjust Threshold**: Use the slider to control detection sensitivity
+       - **Lower (0.3-0.5)**: Detects more seeds, may include false positives
+       - **Higher (0.6-0.8)**: More conservative, only high-confidence detections
+    3. **Set Folder Name**: Name the folder that will organize your crops in the ZIP file
+    4. **Click Detect**: Process your images and wait for results
+    5. **Download**: Get your ZIP file with all cropped seeds!
+    
+    ### 💡 Tips:
+    - Upload clear, well-lit images for best results
+    - Start with default threshold (0.5) and adjust as needed
+    - Each crop is named with the original filename, seed number, and confidence score
+    
+    ### 🎯 Output Format:
+    ```
+    your_folder_name/
+    ├── image1_seed_000_score_0.850.jpg
+    ├── image1_seed_001_score_0.720.jpg
+    └── image2_seed_000_score_0.910.jpg
+    ```
+    """)
+
+# Auto-load model on startup
+print("Initializing model...")
+load_model("seed_frcnn.pth")
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.44.0
+torch==2.1.0
+torchvision==0.16.0
+opencv-python-headless==4.8.1.78
+Pillow==10.1.0
+numpy==1.24.3