Update app.py

app.py

@@ -9,31 +9,35 @@ import pytz
 import numpy as np
 import logging
 
-# Set up logging for better debugging
+# Set up logging for debugging and better visibility
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Configure Tesseract path (ensure it's correctly set to your Tesseract installation)
 try:
-    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Adjust this to your tesseract path
-    pytesseract.get_tesseract_version()  # Test Tesseract availability
-    logging.info("Tesseract is available")
+    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Change path if necessary
+    pytesseract.get_tesseract_version()  # Confirm Tesseract is properly set
+    logging.info("Tesseract is configured properly.")
 except Exception as e:
     logging.error(f"Tesseract not found or misconfigured: {str(e)}")
 
-# Image Preprocessing to improve OCR accuracy
+# Image Preprocessing to clean up the image for better OCR
 def preprocess_image(img_cv):
-    """Preprocess image for OCR: enhance contrast, reduce noise, and apply adaptive thresholding."""
+    """Preprocess the image to enhance clarity for OCR."""
     try:
-        # Convert to grayscale
+        # Convert image to grayscale for easier processing
         gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-        # Enhance contrast using CLAHE (Contrast Limited Adaptive Histogram Equalization)
+        
+        # Enhance the image 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
+        
+        # Apply Gaussian Blur to reduce noise
         blurred = cv2.GaussianBlur(contrast, (5, 5), 0)
-        # Apply adaptive thresholding for better binary image representation
+        
+        # Apply adaptive thresholding for better image clarity
         thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
-        # Sharpen the image to enhance details
+        
+        # Sharpen the image to emphasize digits
         sharpened = cv2.filter2D(thresh, -1, np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]))
         return sharpened
     except Exception as e:
@@ -42,35 +46,36 @@ def preprocess_image(img_cv):
 
 # Function to extract weight from the image using Tesseract OCR
 def extract_weight(img):
-    """Extract weight from image using Tesseract OCR."""
+    """Extract weight using Tesseract OCR, focusing on numeric digits."""
     try:
         if img is None:
             logging.error("No image provided for OCR")
             return "Not detected", 0.0, None
         
-        # Convert PIL image to OpenCV format for processing
+        # Convert the PIL image to OpenCV format for processing
         img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-        # Preprocess the image (contrast, noise reduction, etc.)
+        
+        # Preprocess the image for better OCR results
         processed_img = preprocess_image(img_cv)
         
-        # OCR configuration to focus on digits and decimals
+        # Tesseract configuration focusing on digits and decimals
         custom_config = r'--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789.'
         
         # Run OCR on the processed image
         text = pytesseract.image_to_string(processed_img, config=custom_config)
         logging.info(f"OCR result: '{text}'")
         
-        # Extract valid weight (only digits and decimals)
+        # Extract only the numeric part (weight)
         weight = ''.join(filter(lambda x: x in '0123456789.', text.strip()))
         if weight:
             try:
                 weight_float = float(weight)
-                if weight_float >= 0:  # Ensure valid weight value
-                    confidence = 95.0  # High confidence if weight is valid
+                if weight_float >= 0:  # Ensure it's a valid weight
+                    confidence = 95.0  # Set high confidence for valid weight
                     logging.info(f"Weight detected: {weight} (Confidence: {confidence:.2f}%)")
                     return weight, confidence, processed_img
             except ValueError:
-                logging.warning(f"Invalid number format: {weight}")
+                logging.warning(f"Invalid weight format: {weight}")
         
         logging.error("OCR failed to detect a valid weight")
         return "Not detected", 0.0, None
@@ -78,25 +83,25 @@ def extract_weight(img):
         logging.error(f"OCR processing failed: {str(e)}")
         return "Not detected", 0.0, None
 
-# Main function to process the image and return results
+# Main function to process the uploaded image and display results
 def process_image(img):
-    """Process uploaded or captured image and extract weight."""
+    """Process the uploaded image, extract weight, and display results."""
     if img is None:
-        logging.error("No image provided")
+        logging.error("No image uploaded")
         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
+    # Extract weight and confidence
     weight, confidence, processed_img = extract_weight(img)
     
-    # If no weight detected, display the failure message
+    # If weight detection failed, display an appropriate message
     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 to base64 for displaying it as a snapshot
+    # Convert processed image to base64 format for displaying in Gradio
     pil_image = Image.fromarray(processed_img)
     buffered = io.BytesIO()
     pil_image.save(buffered, format="PNG")
@@ -104,7 +109,7 @@ def process_image(img):
     
     return f"{weight} kg (Confidence: {confidence:.2f}%)", ist_time, img_base64, gr.update(visible=True)
 
-# Gradio Interface for user input and displaying results
+# Gradio interface setup
 with gr.Blocks(title="⚖️ Auto Weight Logger") as demo:
     gr.Markdown("## ⚖️ Auto Weight Logger")
     gr.Markdown("📷 Upload or capture an image of a digital weight scale (max 5MB).")
@@ -126,7 +131,7 @@ with gr.Blocks(title="⚖️ Auto Weight Logger") as demo:
 
     gr.Markdown("""
     ### Instructions
-    - Upload a clear, well-lit image of a digital weight scale display (7-segment font preferred).
+    - Upload a clear, well-lit image of a digital weight scale display (preferably a seven-segment font).
     - Ensure the image is < 5MB (automatically resized if larger).
     - Review the detected weight and try again if it's incorrect.
     """)