Update app.py

app.py

@@ -8,68 +8,39 @@ from datetime import datetime
 import pytz
 import numpy as np
 import logging
-import os
 
 # Set up logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Configure Tesseract path
 try:
-    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Adjust the path if needed
+    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Adjust path if needed
     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)}")
 
+# Preprocessing function
 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 with CLAHE
-        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+        # Enhance contrast using CLAHE (Contrast Limited Adaptive Histogram Equalization)
+        clahe = cv2.createCLAHE(clipLimit=5.0, tileGridSize=(8, 8))
         contrast = clahe.apply(gray)
         # Reduce noise with Gaussian blur
         blurred = cv2.GaussianBlur(contrast, (5, 5), 0)
         # Apply adaptive thresholding for better binary image representation
-        thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
-        # Sharpen the image to bring out more details in the numbers
-        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
-        sharpened = cv2.filter2D(thresh, -1, kernel)
+        thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
+        # Sharpen the image to enhance details
+        sharpened = cv2.filter2D(thresh, -1, np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]))
         return sharpened
     except Exception as e:
         logging.error(f"Image preprocessing failed: {str(e)}")
         return img_cv
 
-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 to the detected region to ensure weight is fully captured
-        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
-
+# Function to extract weight using OCR
 def extract_weight(img):
     """Extract weight from image using Tesseract OCR with improved configuration."""
     try:
@@ -79,10 +50,8 @@ def extract_weight(img):
         
         # Convert PIL image to OpenCV format
         img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-        # Detect ROI
-        roi_img = detect_roi(img_cv)
-        # Preprocess the ROI
-        processed_img = preprocess_image(roi_img)
+        # Preprocess the image
+        processed_img = preprocess_image(img_cv)
         
         # OCR configuration for digit extraction
         custom_config = r'--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789.'
@@ -91,12 +60,12 @@ def extract_weight(img):
         text = pytesseract.image_to_string(processed_img, config=custom_config)
         logging.info(f"OCR result: '{text}'")
         
-        # Extract valid weight from OCR result
+        # Extract valid weight from OCR result (strip unwanted characters)
         weight = ''.join(filter(lambda x: x in '0123456789.', text.strip()))
         if weight:
             try:
                 weight_float = float(weight)
-                if weight_float >= 0 and weight_float <= 500:  # Only accept reasonable weight values
+                if weight_float >= 0:  # Only accept valid weights
                     confidence = 95.0  # Assume high confidence if we have a valid weight
                     logging.info(f"Weight detected: {weight} (Confidence: {confidence:.2f}%)")
                     return weight, confidence, processed_img
@@ -109,20 +78,24 @@ def extract_weight(img):
         logging.error(f"OCR processing failed: {str(e)}")
         return "Not detected", 0.0, None
 
+# Main function to process image and display results
 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, gr.update(visible=False), gr.update(visible=False)
     
+    # Get the current time in IST format
     ist_time = datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y %I:%M:%S %p")
+    
+    # Extract weight and confidence from the image
     weight, confidence, processed_img = 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, gr.update(visible=True), gr.update(visible=False)
     
-    # Convert processed image back to PIL and encode as base64
+    # Convert processed image to base64 for display
     pil_image = Image.fromarray(processed_img)
     buffered = io.BytesIO()
     pil_image.save(buffered, format="PNG")