resolve the image loading issue

.gitignore

@@ -0,0 +1 @@
+venv

app.py

@@ -1,6 +1,308 @@
+# import cv2
+# import numpy as np
+# from PIL import Image
+# import torch
+# from torchvision import models, transforms
+# from ultralytics import YOLO
+# import gradio as gr
+# import torch.nn as nn
+# import pandas as pd
+# from io import BytesIO
+
+# # ============================================
+# # RICE ANALYZER PRO
+# # Advanced Grain Analytics and Quality Assessment Platform
+# # ============================================
+
+# # --- SYSTEM CONFIGURATION ---
+# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# # Initialize detection and classification models
+# try:
+#     detection_model = YOLO('best.pt')
+#     classifier_network = models.resnet50(weights=None)
+#     classifier_network.fc = nn.Linear(classifier_network.fc.in_features, 3)
+#     classifier_network.load_state_dict(
+#         torch.load('rice_resnet_model.pth', map_location=device)
+#     )
+#     classifier_network = classifier_network.to(device)
+#     classifier_network.eval()
+#     models_loaded = True
+# except Exception as e:
+#     print(f"Model initialization failed: {e}")
+#     detection_model = None
+#     classifier_network = None
+#     models_loaded = False
+
+# # --- VARIETY DEFINITIONS ---
+# VARIETY_MAP = {
+#     0: "C9 Premium",
+#     1: "Kant Special",
+#     2: "Superfine Grade"
+# }
+
+# VARIETY_COLORS = {
+#     "C9 Premium": (255, 100, 100),      # Red
+#     "Kant Special": (100, 100, 255),    # Blue
+#     "Superfine Grade": (100, 255, 100)  # Green
+# }
+
+# # --- IMAGE PREPROCESSING ---
+# image_preprocessor = transforms.Compose([
+#     transforms.Resize((224, 224)),
+#     transforms.ToTensor(),
+#     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+# ])
+
+# # ============================================
+# # ANALYTICS FUNCTIONS
+# # ============================================
+
+# def classify_grain(grain_image):
+#     """
+#     Classify a single grain using the neural network.
+#     Returns the grain variety label.
+#     """
+#     if not models_loaded:
+#         return "System Error"
+    
+#     tensor_input = image_preprocessor(grain_image).unsqueeze(0).to(device)
+#     with torch.no_grad():
+#         output = classifier_network(tensor_input)
+#         class_idx = torch.argmax(output, dim=1).item()
+#     return VARIETY_MAP[class_idx]
+
+# def generate_distribution_report(variety_counts):
+#     """
+#     Generate a text-based summary of grain variety distribution
+#     with total counts, percentages, and dominant variety.
+#     """
+#     total = sum(variety_counts.values())
+#     if total == 0:
+#         return "No grains detected for analysis."
+    
+#     report = ["## Grain Distribution Report\n"]
+#     report.append(f"Total Grains Detected: **{total}**\n\n")
+#     report.append("### Breakdown by Variety:\n")
+    
+#     for variety, count in sorted(variety_counts.items(), key=lambda x: x[1], reverse=True):
+#         percentage = (count / total) * 100
+#         bar_length = int(percentage / 5)
+#         bar = "█" * bar_length + "░" * (20 - bar_length)
+#         report.append(f"- {variety}: {count}  ({percentage:.1f}%) {bar}\n")
+    
+#     dominant_variety = max(variety_counts.items(), key=lambda x: x[1])[0]
+#     report.append(f"\nDominant Variety: **{dominant_variety}**\n")
+#     return "".join(report)
+
+# def generate_csv_export(grain_details):
+#     """
+#     Convert grain detection results into CSV format for export.
+#     """
+#     if not grain_details:
+#         return None
+    
+#     df = pd.DataFrame(grain_details)
+#     csv_buffer = BytesIO()
+#     df.to_csv(csv_buffer, index=False)
+#     csv_buffer.seek(0)
+#     return csv_buffer.getvalue().decode()
+
+# def analyze_rice_image(input_image):
+#     """
+#     Full analysis pipeline:
+#     1. Detect grains
+#     2. Classify each grain
+#     3. Annotate image
+#     4. Generate distribution report
+#     5. Generate CSV export
+#     """
+#     if not models_loaded:
+#         raise gr.Error("Analysis engine not available. Check model files.")
+    
+#     if input_image is None:
+#         raise gr.Error("Please upload an image to start analysis.")
+    
+#     # Convert PIL image to BGR array for OpenCV
+#     img_array = np.array(input_image)
+#     img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+    
+#     # Step 1: Detect grains
+#     results = detection_model(img_bgr, verbose=False)[0]
+#     boxes = results.boxes.xyxy.cpu().numpy()
+    
+#     if len(boxes) == 0:
+#         return (
+#             Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)),
+#             "No grains detected. Try a clearer image.",
+#             None
+#         )
+    
+#     # Step 2: Classify grains
+#     variety_counts = {v: 0 for v in VARIETY_MAP.values()}
+#     grain_details = []
+    
+#     for idx, box in enumerate(boxes):
+#         x1, y1, x2, y2 = map(int, box[:4])
+#         crop = img_bgr[y1:y2, x1:x2]
+        
+#         if crop.shape[0] > 0 and crop.shape[1] > 0:
+#             pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
+#             variety_label = classify_grain(pil_crop)
+#             variety_counts[variety_label] += 1
+            
+#             # Save details for CSV export
+#             grain_details.append({
+#                 "Grain_ID": f"G{idx+1:04d}",
+#                 "Variety": variety_label,
+#                 "X_center": (x1 + x2)//2,
+#                 "Y_center": (y1 + y2)//2
+#             })
+            
+#             # Annotate image
+#             color = VARIETY_COLORS[variety_label]
+#             cv2.rectangle(img_bgr, (x1, y1), (x2, y2), color, 3)
+#             label = variety_label
+#             (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
+#             cv2.rectangle(img_bgr, (x1, y1-h-10), (x1+w, y1), color, -1)
+#             cv2.putText(img_bgr, label, (x1, y1-5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
+    
+#     # Step 3: Generate analytics report
+#     report_text = generate_distribution_report(variety_counts)
+#     csv_export = generate_csv_export(grain_details)
+    
+#     return (
+#         Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)),
+#         report_text,
+#         csv_export
+#     )
+
+# # ============================================
+# # GRADIO USER INTERFACE
+# # ============================================
+
+# custom_css = """
+# .gradio-container {
+#     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+# }
+# .header-box {
+#     background: linear-gradient(135deg, #1e5631 0%, #4c9a2a 100%);
+#     padding: 25px;
+#     border-radius: 12px;
+#     color: white;
+#     text-align: center;
+#     margin-bottom: 20px;
+# }
+# """
+
+# with gr.Blocks(css=custom_css, title="Rice Classifier") as app:
+    
+#     gr.HTML("""
+#         <div class="header-box">
+#             <h1>Rice Analyzer Pro</h1>
+#             <p>Advanced Grain Classification | Rice Grain Locattor</p>
+#         </div>
+#     """)
+    
+#     with gr.Tabs():
+#         # Analysis Tab
+#         with gr.Tab("Analysis"):
+#             gr.Markdown("""
+#             ### How to Use
+#             1. Upload a clear image of rice grains.
+#             2. Click "Start Analysis".
+#             3. Review annotated results, distribution report, and export CSV.
+            
+#             **Color Coding:** Red = C9 Premium, Blue = Kant Special, Green = Superfine Grade
+#             """)
+            
+#             with gr.Row():
+#                 with gr.Column(scale=1):
+#                     image_input = gr.Image(type="pil", label="Sample Image")
+#                     start_btn = gr.Button("Start Analysis", variant="primary", size="lg")
+                
+#                 #show the annotated image in specific width and height
+#                 with gr.Column(scale=1):
+#                     annotated_output = gr.Image(label="Annotated Results", height=600, width=600)
+            
+#             with gr.Row():
+#                 report_output = gr.Markdown(label="Distribution Report")
+            
+#             with gr.Row():
+#                 csv_output = gr.Textbox(
+#                     label="CSV Export (Copy or Save)",
+#                     lines=8,
+#                     max_lines=15,
+#                 )
+            
+#             start_btn.click(
+#                 fn=analyze_rice_image,
+#                 inputs=image_input,
+#                 outputs=[annotated_output, report_output, csv_output]
+#             )
+        
+#         # Documentation Tab
+#         with gr.Tab("Documentation"):
+#             gr.Markdown("""
+#             ## System Overview
+            
+#             Rice Classifier uses a deep learning pipeline:
+            
+#             1. **Grain Detection:** YOLO-based model identifies rice grains.
+#             2. **Grain Classification:** ResNet50 model classifies grains into three varieties.
+#             3. **CSV Export:** Detailed grain data available for download or copy.
+            
+#             ### Supported Varieties
+#             | Variety | Description |
+#             |---------|-------------|
+#             | C9 Premium | High-quality long grain |
+#             | Kant Special | Medium grain specialty |
+#             | Superfine Grade | Ultra-refined grain |
+            
+#             ### Best Practices
+#             - Use well-lit images without shadows
+#             - Keep grains separated
+#             - Use plain backgrounds
+#             - Resolution: 1024x1024 or higher for best results
+            
+#             ### Technical Details
+#             - Detection: YOLOv8
+#             - Classification: ResNet50 fine-tuned
+#             - GPU recommended for faster processing
+#             """)
+
+#     gr.Markdown("---")
+#     gr.Markdown("### Sample Gallery")
+    
+#     gr.Examples(
+#         examples=[
+#             "samples/rice1.jpg",
+#             "samples/rice2.jpg",
+#             "samples/rice4.jpg",
+#             "samples/rice5.jpg"
+#         ],
+#         inputs=image_input,
+#         outputs=[annotated_output, report_output, csv_output],
+#         fn=analyze_rice_image,
+#         label="Click any sample to run analysis"
+#     )
+
+# if __name__ == "__main__":
+#     app.queue()
+#     app.launch()
+
+
+
+
+
+
+
+
+import os
 import cv2
+import tempfile
 import numpy as np
-from PIL import Image
+from PIL import Image, UnidentifiedImageError
 import torch
 from torchvision import models, transforms
 from ultralytics import YOLO
@@ -65,7 +367,7 @@ def classify_grain(grain_image):
     """
     if not models_loaded:
         return "System Error"
-    
+
     tensor_input = image_preprocessor(grain_image).unsqueeze(0).to(device)
     with torch.no_grad():
         output = classifier_network(tensor_input)
@@ -80,101 +382,139 @@ def generate_distribution_report(variety_counts):
     total = sum(variety_counts.values())
     if total == 0:
         return "No grains detected for analysis."
-    
+
     report = ["## Grain Distribution Report\n"]
     report.append(f"Total Grains Detected: **{total}**\n\n")
     report.append("### Breakdown by Variety:\n")
-    
+
     for variety, count in sorted(variety_counts.items(), key=lambda x: x[1], reverse=True):
         percentage = (count / total) * 100
         bar_length = int(percentage / 5)
         bar = "█" * bar_length + "░" * (20 - bar_length)
         report.append(f"- {variety}: {count}  ({percentage:.1f}%) {bar}\n")
-    
+
     dominant_variety = max(variety_counts.items(), key=lambda x: x[1])[0]
     report.append(f"\nDominant Variety: **{dominant_variety}**\n")
     return "".join(report)
 
 def generate_csv_export(grain_details):
     """
-    Convert grain detection results into CSV format for export.
+    Convert grain detection results into a temporary CSV file for download.
+    Returns the file path.
     """
     if not grain_details:
         return None
-    
+
     df = pd.DataFrame(grain_details)
-    csv_buffer = BytesIO()
-    df.to_csv(csv_buffer, index=False)
-    csv_buffer.seek(0)
-    return csv_buffer.getvalue().decode()
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", mode='w')
+    df.to_csv(tmp.name, index=False)
+    tmp.close()
+    return tmp.name
+
+def load_image_safe(input_image):
+    """
+    Safely load and validate an image from various input types.
+    Accepts PIL Image, numpy array, or file path string.
+    Returns a valid RGB PIL Image or raises gr.Error.
+    """
+    try:
+        if input_image is None:
+            raise gr.Error("Please upload an image to start analysis.")
+
+        # If it's a file path string (e.g. from gr.Examples)
+        if isinstance(input_image, str):
+            if not os.path.exists(input_image):
+                raise gr.Error(f"Image file not found: {input_image}")
+            img = Image.open(input_image).convert("RGB")
+
+        # If it's already a PIL Image
+        elif isinstance(input_image, Image.Image):
+            img = input_image.convert("RGB")
+
+        # If it's a numpy array
+        elif isinstance(input_image, np.ndarray):
+            img = Image.fromarray(input_image).convert("RGB")
+
+        else:
+            raise gr.Error(f"Unsupported image type: {type(input_image)}")
+
+        return img
+
+    except UnidentifiedImageError:
+        raise gr.Error("Could not read the image file. It may be corrupted or in an unsupported format.")
+    except gr.Error:
+        raise
+    except Exception as e:
+        raise gr.Error(f"Image loading failed: {str(e)}")
 
 def analyze_rice_image(input_image):
     """
     Full analysis pipeline:
-    1. Detect grains
-    2. Classify each grain
-    3. Annotate image
-    4. Generate distribution report
-    5. Generate CSV export
+    1. Validate and load image
+    2. Detect grains
+    3. Classify each grain
+    4. Annotate image
+    5. Generate distribution report
+    6. Generate CSV export
     """
     if not models_loaded:
         raise gr.Error("Analysis engine not available. Check model files.")
-    
-    if input_image is None:
-        raise gr.Error("Please upload an image to start analysis.")
-    
+
+    # Safely load and validate the image
+    pil_image = load_image_safe(input_image)
+
     # Convert PIL image to BGR array for OpenCV
-    img_array = np.array(input_image)
+    img_array = np.array(pil_image)
     img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
-    
+
     # Step 1: Detect grains
     results = detection_model(img_bgr, verbose=False)[0]
     boxes = results.boxes.xyxy.cpu().numpy()
-    
+
     if len(boxes) == 0:
         return (
-            Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)),
+            pil_image,
             "No grains detected. Try a clearer image.",
             None
         )
-    
+
     # Step 2: Classify grains
     variety_counts = {v: 0 for v in VARIETY_MAP.values()}
     grain_details = []
-    
+
     for idx, box in enumerate(boxes):
         x1, y1, x2, y2 = map(int, box[:4])
         crop = img_bgr[y1:y2, x1:x2]
-        
+
         if crop.shape[0] > 0 and crop.shape[1] > 0:
             pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
             variety_label = classify_grain(pil_crop)
             variety_counts[variety_label] += 1
-            
+
             # Save details for CSV export
             grain_details.append({
                 "Grain_ID": f"G{idx+1:04d}",
                 "Variety": variety_label,
-                "X_center": (x1 + x2)//2,
-                "Y_center": (y1 + y2)//2
+                "X_center": (x1 + x2) // 2,
+                "Y_center": (y1 + y2) // 2
             })
-            
+
             # Annotate image
             color = VARIETY_COLORS[variety_label]
             cv2.rectangle(img_bgr, (x1, y1), (x2, y2), color, 3)
             label = variety_label
             (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
-            cv2.rectangle(img_bgr, (x1, y1-h-10), (x1+w, y1), color, -1)
-            cv2.putText(img_bgr, label, (x1, y1-5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
-    
-    # Step 3: Generate analytics report
+            cv2.rectangle(img_bgr, (x1, y1 - h - 10), (x1 + w, y1), color, -1)
+            cv2.putText(img_bgr, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+
+    # Step 3: Generate analytics
     report_text = generate_distribution_report(variety_counts)
-    csv_export = generate_csv_export(grain_details)
-    
+    csv_path = generate_csv_export(grain_details)
+
     return (
         Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)),
         report_text,
-        csv_export
+        csv_path
     )
 
 # ============================================
@@ -195,76 +535,82 @@ custom_css = """
 }
 """
 
+# Only include sample images that actually exist on disk
+_all_samples = [
+    "samples/rice1.jpg",
+    "samples/rice2.jpg",
+    "samples/rice4.jpg",
+    "samples/rice5.jpg"
+]
+sample_images = [s for s in _all_samples if os.path.exists(s)]
+
 with gr.Blocks(css=custom_css, title="Rice Classifier") as app:
-    
+
     gr.HTML("""
         <div class="header-box">
             <h1>Rice Analyzer Pro</h1>
-            <p>Advanced Grain Classification | Rice Grain Locattor</p>
+            <p>Advanced Grain Classification | Rice Grain Locator</p>
         </div>
     """)
-    
+
     with gr.Tabs():
         # Analysis Tab
         with gr.Tab("Analysis"):
             gr.Markdown("""
             ### How to Use
             1. Upload a clear image of rice grains.
-            2. Click "Start Analysis".
-            3. Review annotated results, distribution report, and export CSV.
-            
-            **Color Coding:** Red = C9 Premium, Blue = Kant Special, Green = Superfine Grade
+            2. Click **Start Analysis**.
+            3. Review annotated results, distribution report, and download CSV.
+
+            **Color Coding:**  Red = C9 Premium &nbsp;  Blue = Kant Special &nbsp;  Green = Superfine Grade
             """)
-            
+
             with gr.Row():
                 with gr.Column(scale=1):
-                    image_input = gr.Image(type="pil", label="Sample Image")
+                    image_input = gr.Image(type="pil", label="Upload Sample Image")
                     start_btn = gr.Button("Start Analysis", variant="primary", size="lg")
-                
-                #show the annotated image in specific width and height
+
                 with gr.Column(scale=1):
+                    # Removed unsupported `width` parameter
                     annotated_output = gr.Image(label="Annotated Results", height=600, width=600)
-            
+
             with gr.Row():
                 report_output = gr.Markdown(label="Distribution Report")
-            
+
             with gr.Row():
-                csv_output = gr.Textbox(
-                    label="CSV Export (Copy or Save)",
-                    lines=8,
-                    max_lines=15,
-                )
-            
+                # Changed to gr.File so users can download the CSV properly
+                csv_output = gr.File(label="Download CSV Export")
+
             start_btn.click(
                 fn=analyze_rice_image,
                 inputs=image_input,
                 outputs=[annotated_output, report_output, csv_output]
             )
-        
+
         # Documentation Tab
         with gr.Tab("Documentation"):
             gr.Markdown("""
             ## System Overview
-            
+
             Rice Classifier uses a deep learning pipeline:
-            
+
             1. **Grain Detection:** YOLO-based model identifies rice grains.
             2. **Grain Classification:** ResNet50 model classifies grains into three varieties.
-            3. **CSV Export:** Detailed grain data available for download or copy.
-            
+            3. **CSV Export:** Detailed grain data available for download.
+
             ### Supported Varieties
             | Variety | Description |
             |---------|-------------|
             | C9 Premium | High-quality long grain |
             | Kant Special | Medium grain specialty |
             | Superfine Grade | Ultra-refined grain |
-            
+
             ### Best Practices
             - Use well-lit images without shadows
             - Keep grains separated
             - Use plain backgrounds
             - Resolution: 1024x1024 or higher for best results
-            
+
             ### Technical Details
             - Detection: YOLOv8
             - Classification: ResNet50 fine-tuned
@@ -272,21 +618,20 @@ with gr.Blocks(css=custom_css, title="Rice Classifier") as app:
             """)
 
     gr.Markdown("---")
-    gr.Markdown("### Sample Gallery")
-    
-    gr.Examples(
-        examples=[
-            "samples/rice1.jpg",
-            "samples/rice2.jpg",
-            "samples/rice4.jpg",
-            "samples/rice5.jpg"
-        ],
-        inputs=image_input,
-        outputs=[annotated_output, report_output, csv_output],
-        fn=analyze_rice_image,
-        label="Click any sample to run analysis"
-    )
+
+    if sample_images:
+        gr.Markdown("### Sample Gallery")
+        gr.Examples(
+            examples=sample_images,
+            inputs=image_input,
+            outputs=[annotated_output, report_output, csv_output],
+            fn=analyze_rice_image,
+            cache_examples=False,   # Prevents stale/corrupted cache issues
+            label="Click any sample to run analysis"
+        )
+    else:
+        gr.Markdown("*No sample images found. Add images to the `samples/` folder.*")
 
 if __name__ == "__main__":
     app.queue()
-    app.launch()
+    app.launch()