Update app.py

app.py

@@ -9,69 +9,65 @@ import pytz
 import numpy as np
 import logging
 
-# Set up logging for better debugging
+# Set up logging for better visibility
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Ensure Tesseract is correctly set up
+# Configure Tesseract path (ensure it’s correctly set to your Tesseract installation)
 try:
-    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Make sure to set the correct path
-    pytesseract.get_tesseract_version()  # Confirm Tesseract is installed
+    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 enhance OCR accuracy
+# Image Preprocessing function
 def preprocess_image(img_cv):
-    """Preprocess the image for better OCR accuracy."""
+    """Enhance the image to improve OCR performance."""
     try:
-        # Convert to grayscale
         gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
         
-        # Enhance contrast with CLAHE
+        # Contrast enhancement using CLAHE
         clahe = cv2.createCLAHE(clipLimit=5.0, tileGridSize=(8, 8))
         contrast = clahe.apply(gray)
         
-        # Apply Gaussian blur to reduce noise
+        # Applying Gaussian blur
         blurred = cv2.GaussianBlur(contrast, (5, 5), 0)
         
-        # Apply adaptive thresholding
+        # Adaptive thresholding
         thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
         
-        # Sharpen the image to emphasize edges
+        # Sharpening the image
         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
 
-# Function to extract weight using Tesseract OCR
+# Function to extract weight using OCR
 def extract_weight(img):
-    """Extract weight using Tesseract OCR, focused on digits and decimals."""
+    """Extract weight using Tesseract OCR, focusing on digits and decimals."""
     try:
         if img is None:
             logging.error("No image provided for OCR")
             return "Not detected", 0.0, None
         
-        # Convert PIL image to OpenCV format
         img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-        
-        # Preprocess the image
         processed_img = preprocess_image(img_cv)
         
-        # Tesseract configuration to focus on digits and decimal points
+        # Tesseract configuration to extract digits and decimals
         custom_config = r'--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789.'
         
-        # Run OCR
         text = pytesseract.image_to_string(processed_img, config=custom_config)
         logging.info(f"OCR result: '{text}'")
         
-        # Extract the valid weight (numbers and decimal points)
         weight = ''.join(filter(lambda x: x in '0123456789.', text.strip()))
+        
         if weight:
             try:
                 weight_float = float(weight)
-                if weight_float >= 0:  # Ensure it's a valid weight
-                    confidence = 95.0  # High confidence for valid weight
+                if weight_float >= 0:
+                    confidence = 95.0  # High confidence
                     logging.info(f"Weight detected: {weight} (Confidence: {confidence:.2f}%)")
                     return weight, confidence, processed_img
             except ValueError:
@@ -83,25 +79,24 @@ 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 display results
+# Main function to process uploaded image and display results
 def process_image(img):
-    """Process the uploaded image and show results."""
+    """Process the uploaded image, extract weight, and display results."""
     if img is None:
         logging.error("No image uploaded")
         return "No image uploaded", None, gr.update(visible=False), gr.update(visible=False)
     
-    # Get the current timestamp in IST format
+    # Get the timestamp for IST (Indian Standard Time)
     ist_time = datetime.now(pytz.timezone("Asia/Kolkata")).strftime("%d-%m-%Y %I:%M:%S %p")
     
-    # Extract weight and confidence
     weight, confidence, processed_img = extract_weight(img)
     
-    # If weight detection fails, show the error message
+    # If detection failed
     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 Gradio to display
+    # Convert processed image to base64 for displaying in Gradio
     pil_image = Image.fromarray(processed_img)
     buffered = io.BytesIO()
     pil_image.save(buffered, format="PNG")
@@ -109,7 +104,7 @@ def process_image(img):
     
     return f"{weight} kg (Confidence: {confidence:.2f}%)", ist_time, img_base64, gr.update(visible=True)
 
-# Gradio Interface setup for Hugging Face
+# Gradio Interface Setup for Hugging Face
 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).")