Update app.py

app.py

@@ -1,74 +1,116 @@
 import gradio as gr
-import cv2
-import numpy as np
+from weight_detector import WeightDetector
+import tempfile
+import os
 from PIL import Image
-import logging
-from ocr_engine import extract_weight_from_image
-from datetime import datetime
-import pytz
-import sys
+import requests
+from io import BytesIO
 
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[logging.StreamHandler(sys.stdout)])
+# Initialize detector
+detector = WeightDetector()
 
-def process_image(img):
+def process_input(image_source: str, image_upload=None, image_url: str = "") -> tuple:
+    """
+    Process image from different sources (upload, webcam, or URL)
+    Returns:
+        tuple: (detected_weight, detection_metadata, annotated_image)
+    """
+    temp_img_path = None
+    
     try:
-        # Convert Gradio image (PIL) to process
-        if img is None:
-            return "No image provided", "", None
+        # Handle different input types
+        if image_source == "upload" and image_upload is not None:
+            img = image_upload
+        elif image_source == "url" and image_url:
+            response = requests.get(image_url)
+            img = Image.open(BytesIO(response.content))
+        else:
+            return None, "No valid image provided", None
+            
+        # Save to temp file for processing
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
+            temp_img_path = f.name
+            img.save(f.name)
+            
+        # Detect weight
+        weight, metadata, annotated_img = detector.detect_weight(temp_img_path)
         
-        # Resize if > 5MB
-        img_bytes = img.tobytes()
-        size_mb = len(img_bytes) / (1024 * 1024)
-        if size_mb > 5:
-            scale = 0.9
-            while size_mb > 5:
-                w, h = img.size
-                img = img.resize((int(w * scale), int(h * scale)), Image.Resampling.LANCZOS)
-                img_bytes = img.tobytes()
-                size_mb = len(img_bytes) / (1024 * 1024)
-                scale *= 0.9
-            logging.info(f"Resized image to {size_mb:.2f} MB")
-
-        # Extract weight
-        weight, confidence, unit = extract_weight_from_image(img)
+        # Format result message
+        if weight is not None:
+            message = f"✅ Detected weight: {weight}g"
+            if len(metadata) > 1:
+                message += f" (from {len(metadata)} possible values)"
+        else:
+            message = "❌ No weight value detected"
+            
+        return weight, message, annotated_img
         
-        # Return results with improved feedback
-        result = f"{weight} {unit} (Confidence: {confidence:.2f}%)" if confidence > 0 else "No weight detected"
-        timestamp = f"Processed at {datetime.now(pytz.timezone('Asia/Kolkata')).strftime('%d-%m-%Y %I:%M:%S %p IST')}"
-        return result, timestamp, img
     except Exception as e:
-        logging.error(f"Error in process_image: {str(e)}")
-        return f"Error: {str(e)}", "", None
+        return None, f"Error: {str(e)}", None
+    finally:
+        if temp_img_path and os.path.exists(temp_img_path):
+            os.unlink(temp_img_path)
 
 # Gradio interface
 with gr.Blocks(title="Auto Weight Logger") as demo:
     gr.Markdown("""
-    # 📷 Auto Weight Logger — OCR-Based Smart Scale Reader
-    This app detects weight from uploaded or captured images of digital balance displays. Optimized for 7-segment displays and various formats, it extracts numeric weights with high accuracy.
+    # Auto Weight Logger
+    Capture or upload an image of a weight measurement to automatically detect and log the value.
     """)
     
     with gr.Row():
         with gr.Column():
-            image_input = gr.Image(source="upload", tool="select", type="pil", label="Upload Weight Display Image")
-            webcam_input = gr.Image(source="webcam", type="pil", label="Or Capture with Webcam")
+            image_source = gr.Radio(
+                ["upload", "url"],
+                label="Image Source",
+                value="upload"
+            )
+            
+            image_upload = gr.Image(
+                sources=["upload"],
+                type="pil",
+                label="Upload Image"
+            )
+            
+            image_url = gr.Textbox(
+                label="Image URL",
+                visible=False
+            )
+            
             submit_btn = gr.Button("Detect Weight")
-        
+            
         with gr.Column():
-            output_text = gr.Textbox(label="Detected Weight", interactive=False)
-            timestamp_text = gr.Textbox(label="Processed At", interactive=False)
-            output_image = gr.Image(label="Processed Image")
-
-    submit_btn.click(
-        fn=process_image,
-        inputs=[image_input],
-        outputs=[output_text, timestamp_text, output_image]
+            weight_value = gr.Number(
+                label="Detected Weight (g)",
+                interactive=False
+            )
+            
+            result_message = gr.Textbox(
+                label="Detection Result",
+                interactive=False
+            )
+            
+            annotated_image = gr.Image(
+                label="Annotated Image",
+                interactive=False
+            )
+    
+    # Show/hide URL input based on selection
+    def toggle_url_visibility(source):
+        return gr.Textbox(visible=source == "url")
+    
+    image_source.change(
+        toggle_url_visibility,
+        inputs=image_source,
+        outputs=image_url
     )
     
-    webcam_input.change(
-        fn=process_image,
-        inputs=[webcam_input],
-        outputs=[output_text, timestamp_text, output_image]
+    # Process submission
+    submit_btn.click(
+        process_input,
+        inputs=[image_source, image_upload, image_url],
+        outputs=[weight_value, result_message, annotated_image]
     )
 
+# For Hugging Face Spaces
 demo.launch()