Update app.py

app.py

@@ -9,69 +9,69 @@ import pytz
 import numpy as np
 import logging
 
-# Set up logging for debugging and better visibility
+# Set up logging for better debugging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Configure Tesseract path (ensure it's correctly set to your Tesseract installation)
+# Ensure Tesseract is correctly set up
 try:
-    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Change path if necessary
-    pytesseract.get_tesseract_version()  # Confirm Tesseract is properly set
+    pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'  # Make sure to set the correct path
+    pytesseract.get_tesseract_version()  # Confirm Tesseract is installed
     logging.info("Tesseract is configured properly.")
 except Exception as e:
     logging.error(f"Tesseract not found or misconfigured: {str(e)}")
 
-# Image Preprocessing to clean up the image for better OCR
+# Image Preprocessing to enhance OCR accuracy
 def preprocess_image(img_cv):
-    """Preprocess the image to enhance clarity for OCR."""
+    """Preprocess the image for better OCR accuracy."""
     try:
-        # Convert image to grayscale for easier processing
+        # Convert to grayscale
         gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
         
-        # Enhance the image contrast using CLAHE (Contrast Limited Adaptive Histogram Equalization)
+        # Enhance contrast with CLAHE
         clahe = cv2.createCLAHE(clipLimit=5.0, tileGridSize=(8, 8))
         contrast = clahe.apply(gray)
         
-        # Apply Gaussian Blur to reduce noise
+        # Apply Gaussian blur to reduce noise
         blurred = cv2.GaussianBlur(contrast, (5, 5), 0)
         
-        # Apply adaptive thresholding for better image clarity
+        # Apply adaptive thresholding
         thresh = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)
         
-        # Sharpen the image to emphasize digits
+        # Sharpen the image to emphasize edges
         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 from the image using Tesseract OCR
+# Function to extract weight using Tesseract OCR
 def extract_weight(img):
-    """Extract weight using Tesseract OCR, focusing on numeric digits."""
+    """Extract weight using Tesseract OCR, focused on digits and decimals."""
     try:
         if img is None:
             logging.error("No image provided for OCR")
             return "Not detected", 0.0, None
         
-        # Convert the PIL image to OpenCV format for processing
+        # Convert PIL image to OpenCV format
         img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
         
-        # Preprocess the image for better OCR results
+        # Preprocess the image
         processed_img = preprocess_image(img_cv)
         
-        # Tesseract configuration focusing on digits and decimals
+        # Tesseract configuration to focus on digits and decimal points
         custom_config = r'--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789.'
         
-        # Run OCR on the processed image
+        # Run OCR
         text = pytesseract.image_to_string(processed_img, config=custom_config)
         logging.info(f"OCR result: '{text}'")
         
-        # Extract only the numeric part (weight)
+        # 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  # Set high confidence for valid weight
+                    confidence = 95.0  # High confidence for valid weight
                     logging.info(f"Weight detected: {weight} (Confidence: {confidence:.2f}%)")
                     return weight, confidence, processed_img
             except ValueError:
@@ -83,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 uploaded image and display results
+# Main function to process the image and display results
 def process_image(img):
-    """Process the uploaded image, extract weight, and display results."""
+    """Process the uploaded image and show 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 time in IST format
+    # Get the current timestamp in IST format
     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 failed, display an appropriate message
+    # If weight detection fails, show the error 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 format for displaying in Gradio
+    # Convert processed image to base64 for Gradio to display
     pil_image = Image.fromarray(processed_img)
     buffered = io.BytesIO()
     pil_image.save(buffered, format="PNG")
@@ -109,7 +109,7 @@ def process_image(img):
     
     return f"{weight} kg (Confidence: {confidence:.2f}%)", ist_time, img_base64, gr.update(visible=True)
 
-# Gradio interface setup
+# 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).")