Update app.py

app.py

@@ -15,7 +15,12 @@ import os
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Configure Tesseract path for Hugging Face
-pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
+try:
+    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
+    pytesseract.get_tesseract_version()  # Test Tesseract availability
+    logging.info("Tesseract is available")
+except Exception as e:
+    logging.error(f"Tesseract not found or misconfigured: {str(e)}")
 
 # Salesforce configuration (use environment variables in production)
 SF_USERNAME = os.getenv("SF_USERNAME", "your_salesforce_username")
@@ -56,27 +61,93 @@ def resize_image(img, max_size_mb=5):
         logging.error(f"Image resizing failed: {str(e)}")
         return img, None
 
+def preprocess_image(img_cv):
+    """Preprocess image for OCR: enhance contrast, reduce noise, and apply adaptive thresholding."""
+    try:
+        # Convert to grayscale
+        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        # Enhance contrast
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+        contrast = clahe.apply(gray)
+        # Reduce noise with Gaussian blur
+        blurred = cv2.GaussianBlur(contrast, (5, 5), 0)
+        # Apply adaptive thresholding
+        thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
+        # Sharpen the image
+        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
+        sharpened = cv2.filter2D(thresh, -1, kernel)
+        return sharpened
+    except Exception as e:
+        logging.error(f"Image preprocessing failed: {str(e)}")
+        return gray
+
+def detect_roi(img_cv):
+    """Detect the region of interest (ROI) containing the weight display."""
+    try:
+        # Convert to grayscale for edge detection
+        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        # Apply edge detection
+        edges = cv2.Canny(gray, 50, 150)
+        # Find contours
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            logging.warning("No contours detected for ROI")
+            return img_cv  # Return full image if no contours found
+        
+        # Find the largest contour (assuming it’s the display)
+        largest_contour = max(contours, key=cv2.contourArea)
+        x, y, w, h = cv2.boundingRect(largest_contour)
+        # Add padding
+        padding = 10
+        x = max(0, x - padding)
+        y = max(0, y - padding)
+        w = min(img_cv.shape[1] - x, w + 2 * padding)
+        h = min(img_cv.shape[0] - y, h + 2 * padding)
+        roi = img_cv[y:y+h, x:x+w]
+        logging.info(f"ROI detected at ({x}, {y}, {w}, {h})")
+        return roi
+    except Exception as e:
+        logging.error(f"ROI detection failed: {str(e)}")
+        return img_cv
+
 def extract_weight(img):
-    """Extract weight from image using Tesseract OCR."""
+    """Extract weight from image using Tesseract OCR with multiple PSM modes."""
     try:
+        if img is None:
+            logging.error("No image provided for OCR")
+            return "Not detected", 0.0
+        
         # Convert PIL image to OpenCV format
         img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-        # Preprocess image for better OCR accuracy
-        _, thresh = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY)
-        # Configure Tesseract for 7-segment display (digits only, single line)
-        config = '--psm 7 digits'
-        text = pytesseract.image_to_string(thresh, config=config)
-        # Extract numeric values (digits and decimal point)
-        weight = ''.join(filter(lambda x: x in '0123456789.', text))
-        # Validate weight (ensure it’s a valid number)
-        try:
-            weight_float = float(weight)
-            # Simplified confidence: 95% if valid number, else 0%
-            confidence = 95.0 if weight_float > 0 else 0.0
-            return weight, confidence
-        except ValueError:
-            return "Not detected", 0.0
+        # Detect ROI
+        roi_img = detect_roi(img_cv)
+        # Preprocess the ROI
+        processed_img = preprocess_image(roi_img)
+        
+        # Try multiple PSM modes for better detection
+        psm_modes = [
+            ('--psm 7 digits', 'Single line, digits only'),
+            ('--psm 6 digits', 'Single block, digits only'),
+            ('--psm 10 digits', 'Single character, digits only'),
+            ('--psm 8 digits', 'Single word, digits only')
+        ]
+        
+        for config, desc in psm_modes:
+            text = pytesseract.image_to_string(processed_img, config=config)
+            logging.info(f"OCR attempt with {desc}: Raw text = '{text}'")
+            weight = ''.join(filter(lambda x: x in '0123456789.', text.strip()))
+            try:
+                weight_float = float(weight)
+                if weight_float >= 0:  # Allow zero weights
+                    confidence = 95.0  # Simplified confidence for valid numbers
+                    logging.info(f"Weight detected: {weight} (Confidence: {confidence:.2f}%)")
+                    return weight, confidence
+            except ValueError:
+                logging.warning(f"Invalid number format: {weight}")
+                continue
+        
+        logging.error("All OCR attempts failed to detect a valid weight")
+        return "Not detected", 0.0
     except Exception as e:
         logging.error(f"OCR processing failed: {str(e)}")
         return "Not detected", 0.0
@@ -84,20 +155,24 @@ def extract_weight(img):
 def process_image(img):
     """Process uploaded or captured image and extract weight."""
     if img is None:
+        logging.error("No image provided")
         return "No image uploaded", None, None, None, gr.update(visible=False), gr.update(visible=False)
     
     ist_time = datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y %I:%M:%S %p")
     img, img_bytes = resize_image(img)
     if img_bytes is None:
+        logging.error("Image resizing failed")
         return "Image processing failed", ist_time, img, None, gr.update(visible=False), gr.update(visible=False)
     
     weight, confidence = extract_weight(img)
     
     if weight == "Not detected" or confidence < 95.0:
+        logging.warning(f"Weight detection failed: {weight} (Confidence: {confidence:.2f}%)")
         return f"{weight} (Confidence: {confidence:.2f}%)", ist_time, img, None, gr.update(visible=True), gr.update(visible=False)
     
     img_buffer = io.BytesIO(img_bytes)
     img_base64 = base64.b64encode(img_buffer.getvalue()).decode()
+    logging.info(f"Weight detected successfully: {weight} kg")
     return f"{weight} kg (Confidence: {confidence:.2f}%)", ist_time, img, img_base64, gr.update(visible=True), gr.update(visible=True)
 
 def save_to_salesforce(weight_text, img_base64):
@@ -105,6 +180,7 @@ def save_to_salesforce(weight_text, img_base64):
     try:
         sf = connect_to_salesforce()
         if sf is None:
+            logging.error("Salesforce connection failed")
             return "Failed to connect to Salesforce"
         
         weight = float(weight_text.split(" ")[0])
@@ -155,10 +231,11 @@ with gr.Blocks(title="⚖️ Auto Weight Logger") as demo:
 
     gr.Markdown("""
     ### Instructions
-    - Upload a clear, well-lit image of a digital weight scale display.
+    - Upload a clear, well-lit image of a digital weight scale display (7-segment font preferred).
     - Ensure the image is < 5MB (automatically resized if larger).
     - Review the detected weight and click 'Confirm and Save to Salesforce' to log the data.
     - Works on desktop and mobile browsers.
+    - If weight detection fails, check the image for glare, low contrast, or non-numeric characters and try again.
     """)
 
 if __name__ == "__main__":