Update app.py

app.py

@@ -1,266 +1,192 @@
 import streamlit as st
-import os
-import torch
+import cv2
+from ultralytics import YOLO
 from paddleocr import PaddleOCR
 from tensorflow.keras.models import load_model
-from tensorflow.keras.preprocessing.image import img_to_array, load_img
+from tensorflow.keras.preprocessing.image import img_to_array
 import numpy as np
-from datetime import datetime, timedelta
 import re
-from ultralytics import YOLO
+from datetime import datetime
 import pandas as pd
-import cv2
-from PIL import Image
 
-# Initialize models
-ocr = PaddleOCR(lang='en')
-fruit_model = load_model('DenseNet20_model.h5')
-brand_model = YOLO('b.pt')
-object_model = YOLO('yolov5s.pt')
+# Load YOLO models
+brand_model = YOLO('b.pt')  # Replace 'b.pt' with the correct path to your YOLO model for brands
+ocr = PaddleOCR(lang='en')  # Initialize PaddleOCR
+fruit_model = load_model('DenseNet20_model.h5')  # Replace with the correct path to your fruit freshness model
+object_model = YOLO('yolov5s.pt')  # Add object detection model
 
-# Class names for fruit freshness classification
+# Class names for freshness detection
 class_names = {
-    0: 'Banana_Bad',
-    1: 'Banana_Good',
-    2: 'Fresh',
-    3: 'FreshCarrot',
-    4: 'FreshCucumber',
-    5: 'FreshMango',
-    6: 'FreshTomato',
-    7: 'Guava_Bad',
-    8: 'Guava_Good',
-    9: 'Lime_Bad',
-    10: 'Lime_Good',
-    11: 'Rotten',
-    12: 'RottenCarrot',
-    13: 'RottenCucumber',
-    14: 'RottenMango',
-    15: 'RottenTomato',
-    16: 'freshBread',
-    17: 'rottenBread'
+    0: 'Banana_Bad', 1: 'Banana_Good', 2: 'Fresh', 3: 'FreshCarrot', 4: 'FreshCucumber',
+    5: 'FreshMango', 6: 'FreshTomato', 7: 'Guava_Bad', 8: 'Guava_Good', 9: 'Lime_Bad',
+    10: 'Lime_Good', 11: 'Rotten', 12: 'RottenCarrot', 13: 'RottenCucumber',
+    14: 'RottenMango', 15: 'RottenTomato', 16: 'freshBread', 17: 'rottenBread'
 }
 
-# Helper functions
-def preprocess_image(image_path):
-    img = load_img(image_path, target_size=(128, 128))
+# Helper function: Extract expiry dates
+# Helper function: Extract unique expiry dates
+def extract_expiry_dates(text):
+    patterns = [
+      r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',       # 20/07/2024 or 20-07-2024
+    r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2})',       # 20/07/24 or 20-07-24
+    r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{4})',       # 20 MAY 2024
+    r'([A-Za-z]{3,}\s*\d{1,2}[,\s]*\d{4})',    # July 20, 2024
+    r'(\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2})',       # 2024/07/20 or 2024-07-20
+    r'([A-Za-z]{3}[\-]\d{1,2}[\-]\d{4})'       # JAN-15-2024
+    ]
+    # Helper function: Extract expiry dates
+    dates = []
+    for pattern in patterns:
+        matches = re.findall(pattern, text)
+        dates.extend(matches)
+
+    # Deduplicate and prioritize the longest (likely full year) date format
+    unique_dates = sorted(dates, key=lambda x: len(x), reverse=True)
+    return [unique_dates[0]] if unique_dates else []  # Return the most likely date
+
+# Helper function: Preprocess image for fruit freshness
+def preprocess_image(image):
+    img = cv2.resize(image, (128, 128))
     img_array = img_to_array(img)
     img_array = np.expand_dims(img_array, axis=0)
     img_array = img_array / 255.0
     return img_array
 
-def extract_expiry_dates(text):
-    expiry_date_patterns = [
-        # Common phrases with DD/MM/YYYY format
-        r'USE BY[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Use by date
-        r'BEST BEFORE[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Best before date
-        r'EXPIRY DATE[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expiry Date
-        r'EXPIRY[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expiry
-        r'EXP[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Exp
-        r'VALID UNTIL[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Valid Until
-        r'CONSUME BY[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Consume By
-        r'EXPIRES ON[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expires On
-
-        # DDMMMYYYY format
-        r'(\d{1,2}[A-Za-z]{3}\d{4})',  # DDMMMYYYY format
-
-        # Short year formats
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2})',  # Short year date format (DD/MM/YY)
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # General date format (DD/MM/YYYY)
-
-        # Year-month-day formats
-        r'(\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2})',  # Year-month-day format (YYYY/MM/DD)
-
-        # Month/Year formats
-        r'(\d{1,2}[\/\-]\d{1,2})',  # MM/DD format
-        r'(\d{1,2}[\/\-]\d{2})',  # MM/YY format
-
-        # Month name formats
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{4})',  # Month name with day and year
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{2})',  # Month name with day and short year
-
-        # Year with month name
-        r'(\d{4}[A-Za-z]{3,}\d{1,2})',  # Year with month name
-        r'(\d{1,2}[A-Za-z]{3,}\d{4})',  # Day with month name and full year
-
-        # Additional formats
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2})',  # MM/DD/YY format
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # MM/DD/YYYY format
-        r'(\d{1,2}[\/\-]\d{1,2})',  # MM/DD format
-        r'(\d{1,2}[\/\-]\d{2})',  # MM/YY format
-
-        # Best before phrases
-        r'Best before (\d+) months',  # Best before in months
-        r'Expiration Date[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expiration Date
-        r'Expires[:\-]?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expires
-
-        # Additional variations
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{4})',  # Month name with day and year
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{2})',  # Month name with day and short year
-
-        # More variations
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # MM/DD/YYYY format
-        r'(\d{1,2}[\/\-]\d{1,2})',  # MM/DD format
-        r'(\d{1,2}[\/\-]\d{2})',  # MM/YY format
-
-        # Additional expiry phrases
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expiry in various formats
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2})',  # Expiry in short year formats
-        r'(\d{1,2}[\/\-]\d{1,2})',  # Expiry in MM/DD format
-        r'(\d{1,2}[\/\-]\d{2})',  # Expiry in MM/YY format
-
-        # Additional phrases
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{4})',  # Month name with day and year
-        r'(\d{1,2}\s*[A-Za-z]{3,}\s*\d{2})',  # Month name with day and short year
-        r'(\d{4}[A-Za-z]{3,}\d{1,2})',  # Year with month name
-        r'(\d{1,2}[A-Za-z]{3,}\d{4})',  # Day with month name and full year
-
-        # Additional expiry phrases
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{4})',  # Expiry in various formats
-        r'(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2})',  # Expiry in short year formats
-        r'(\d{1,2}[\/\-]\d{1,2})',  # Expiry in MM/DD format
-        r'(\d{1,2}[\/\-]\d{2})',  # Expiry in MM/YY format
-    ]
-    
-    current_date = datetime.now()
-    dates_info = []
-
-    for pattern in expiry_date_patterns:
-        match = re.search(pattern, text, re.IGNORECASE)
-        if match:
-            date_str = match.group(1)
-            try:
-                # Check for DDMMMYYYY format
-                if len(date_str) == 8 and date_str[2:5].isalpha():  # Check for DDMMMYYYY
-                    expiry_date = datetime.strptime(date_str, '%d%b%Y')
-                # Check for MM/YY format
-                elif len(date_str) == 5 and date_str[2] == '/':  # Check for MM/YY
-                    expiry_date = datetime.strptime(date_str, '%m/%y')
-                # Check for DD-MM-YYYY or DD/MM/YYYY format
-                elif len(date_str) == 10 and (date_str[2] in ['-', '/'] and date_str[5] in ['-', '/']):
-                    expiry_date = datetime.strptime(date_str, '%d/%m/%Y') if date_str[2] == '/' else datetime.strptime(date_str, '%d-%m-%Y')
-                # Check for DD-MM-YY or DD/MM/YY format
-                elif len(date_str) == 8 and (date_str[2] in ['-', '/'] and date_str[5] in ['-', '/']):
-                    expiry_date = datetime.strptime(date_str, '%d/%m/%y') if date_str[2] == '/' else datetime.strptime(date_str, '%d-%m-%y')
+# Helper function: Calculate days to expiry
+def calculate_days_to_expiry(expiry_dates):
+    results = []
+    today = datetime.now()
+    for date_str in expiry_dates:
+        try:
+            # Parse date
+            if '/' in date_str or '-' in date_str:
+                if len(date_str.split('/')[-1]) == 2 or len(date_str.split('-')[-1]) == 2:
+                    date_obj = datetime.strptime(date_str, '%d/%m/%y') if '/' in date_str else datetime.strptime(date_str, '%d-%m-%y')
                 else:
-                    # Existing parsing logic for other formats
-                    expiry_date = datetime.strptime(date_str, '%d/%m/%Y')
-            except ValueError:
-                continue
-
-            days_left = (expiry_date - current_date).days
-            if days_left < 0:
-                dates_info.append((date_str, "Expired"))
+                    date_obj = datetime.strptime(date_str, '%d/%m/%Y') if '/' in date_str else datetime.strptime(date_str, '%d-%m-%Y')
             else:
-                dates_info.append((date_str, f"{days_left} days left"))
-            break  # Stop after finding the first valid date
-
-    return dates_info
-
-# Streamlit app
-st.title("Image Processing Application")
+                date_obj = datetime.strptime(date_str, '%d %B %Y')
 
-# User choice for processing
-task_choice = st.radio("Choose a task", ("Text and Brand Detection", "Freshness Detection", "Object Detection"))
-
-uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
-
-if uploaded_file is not None:
-    # Ensure the uploads directory exists
-    if not os.path.exists("uploads"):
-        os.makedirs("uploads")
+            # Calculate difference
+            delta = (date_obj - today).days
+            if delta >= 0:
+                results.append(f"{date_str}: {delta} days to expire")
+            else:
+                results.append(f"{date_str}: Expired")
+        except ValueError:
+            results.append(f"{date_str}: Invalid date format")
+    return results
+
+# Streamlit App
+st.title("Flipkart Grid")
+
+# Sidebar options
+app_mode = st.sidebar.selectbox(
+    "Choose the mode",
+    ["Home", "Brand & Text Detection", "Fruit Freshness Detection", "Object Detection"]
+)
+
+if app_mode == "Home":
+    st.markdown("""
+    ## Welcome to the Detection App
+    Use the sidebar to choose between:
+    - *Brand & Text Detection*: Detect brands, extract text, and identify expiry dates from uploaded images.
+    - *Fruit Freshness Detection*: Detect and classify the freshness of fruits from uploaded images.
+    - *Object Detection*: Detect objects in uploaded images.
+    """)
+
+elif app_mode == "Brand & Text Detection":
+    st.header("Brand & Text Detection")
+    uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+
+    if uploaded_file is not None:
+        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+        image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+
+        # Brand detection
+        results = brand_model.predict(source=image, stream=False)
+        detected_image = results[0].plot()
+
+        # OCR for text extraction
+        _, img_buffer = cv2.imencode('.jpg', image)
+        ocr_result = ocr.ocr(img_buffer.tobytes())
+        if ocr_result and isinstance(ocr_result[0], list) and len(ocr_result[0]) > 0:
+            extracted_text = ' '.join([line[1][0] for line in ocr_result[0]])
+            expiry_dates = extract_expiry_dates(extracted_text)
+            expiry_info = calculate_days_to_expiry(expiry_dates)
+        else:
+            extracted_text = "No text detected"
+            expiry_dates = []
+            expiry_info = []
+
+        # Count objects
+        object_counts = {}
+        for box in results[0].boxes.data.cpu().numpy():
+            label = results[0].names[int(box[5])]
+            object_counts[label] = object_counts.get(label, 0) + 1
+
+        # Display results
+        st.image(cv2.cvtColor(detected_image, cv2.COLOR_BGR2RGB), caption="Detected Image")
+        st.markdown(f"*Extracted Text:* {extracted_text}")
+        st.markdown(f"*Expiry Dates:*")
+        if expiry_info:
+            for info in expiry_info:
+                st.markdown(f"- {info}")
+        else:
+            st.markdown("None")
+        st.markdown("*Object Counts:*")
+        for label, count in object_counts.items():
+            st.markdown(f"- {label}: {count}")
 
-    # Save the uploaded file
-    image_path = os.path.join("uploads", uploaded_file.name)
-    with open(image_path, "wb") as f:
-        f.write(uploaded_file.getbuffer())
+elif app_mode == "Fruit Freshness Detection":
+    st.header("Fruit Freshness Detection")
+    uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
 
-    # Display the uploaded image
-    st.image(image_path, caption='Uploaded Image', use_container_width=True)
+    if uploaded_file is not None:
+        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+        image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
 
-    if task_choice == "Text and Brand Detection":
-        # Text Extraction
-        st.header("Text Extraction")
-        result = ocr.ocr(image_path)
-        text = ' '.join([line[1][0] for line in result[0]])
-        st.write("Extracted Text:")
-        st.text(text)
+        # Preprocess and predict
+        img_array = preprocess_image(image)
+        predictions = fruit_model.predict(img_array)
+        predicted_class = np.argmax(predictions, axis=1)[0]
+        label = class_names[predicted_class]
+        confidence = predictions[0][predicted_class] * 100
 
-        # Expiry Date Extraction
-        st.header("Expiry Date Extraction")
-        expiry_dates_info = extract_expiry_dates(text)
-        if expiry_dates_info:
-            st.write("Expiry Dates Found:")
-            for date_str, days_left in expiry_dates_info:
-                st.text(f"{date_str} - {days_left}")
-        else:
-            st.write("No expiry dates found.")
+        # Display results
+        st.image(cv2.cvtColor(image, cv2.COLOR_BGR2RGB), caption="Uploaded Image")
+        st.markdown(f"*Label:* {label}")
+        st.markdown(f"*Confidence:* {confidence:.2f}%")
 
-        # Brand Prediction
-        st.header("Brand Prediction")
-        results = brand_model(image_path)
-        detected_brands = []
-        for result in results:
-            boxes = result.boxes.data.cpu().numpy()
-            for box in boxes:
-                class_id = int(box[5])
-                confidence = box[4]  # Assuming the confidence score is at index 4
-                detected_brands.append((result.names[class_id], confidence))
-        
-        # Count occurrences and average confidence of each brand
-        brand_data = {}
-        for brand, confidence in detected_brands:
-            if brand in brand_data:
-                brand_data[brand]['count'] += 1
-                brand_data[brand]['total_confidence'] += confidence
-            else:
-                brand_data[brand] = {'count': 1, 'total_confidence': confidence}
-        
-        # Prepare data for display
-        brand_display_data = [
-            {'Object': brand, 'Count': data['count'], 'Average Confidence': data['total_confidence'] / data['count']}
-            for brand, data in brand_data.items()
-        ]
-        
-        # Display detected brands in a table with column names
-        st.write("Detected Brands and Counts:")
-        st.table(pd.DataFrame(brand_display_data))
+elif app_mode == "Object Detection":
+    st.header("Object Detection")
+    uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
 
-    elif task_choice == "Freshness Detection":
-        # Freshness Prediction
-        st.header("Freshness Prediction")
-        img_array = preprocess_image(image_path)
-        predictions = fruit_model.predict(img_array)
-        predicted_class = np.argmax(predictions, axis=1)[0]
-        confidence_score = predictions[0][predicted_class]  # Get the confidence score for the predicted class
-        st.write("Predicted Freshness:", class_names[predicted_class])
-        st.write("Confidence Score:", f"{confidence_score * 100:.2f}%")  # Display the confidence score as a percentage
+    if uploaded_file is not None:
+        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+        image = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
 
-    elif task_choice == "Object Detection":
         # Object Detection
-        st.header("Object Detection")
-        results = object_model(image_path)
+        results = object_model.predict(source=image, stream=False)
         detected_objects = []
-        
-        # Load the image using OpenCV
-        image = cv2.imread(image_path)
-        
+
         for result in results:
             boxes = result.boxes.data.cpu().numpy()
             for box in boxes:
                 class_id = int(box[5])
                 confidence = box[4]  # Assuming the confidence score is at index 4
                 detected_objects.append((result.names[class_id], confidence))
-                
+
                 # Draw bounding box and label on the image
                 x1, y1, x2, y2 = map(int, box[:4])
                 label = f"{result.names[class_id]} {confidence * 100:.2f}%"
                 cv2.rectangle(image, (x1, y1), (x2, y2), (255, 0, 0), 2)
                 cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
-        
+
         # Convert the image back to RGB for display in Streamlit
         image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
         st.image(image_rgb, caption='Detected Objects', use_container_width=True)
-        
+
         # Count occurrences and average confidence of each object
         object_data = {}
         for obj, confidence in detected_objects:
@@ -269,13 +195,13 @@ if uploaded_file is not None:
                 object_data[obj]['total_confidence'] += confidence
             else:
                 object_data[obj] = {'count': 1, 'total_confidence': confidence}
-        
+
         # Prepare data for display
         object_display_data = [
             {'Object': obj, 'Count': data['count'], 'Average Confidence': data['total_confidence'] / data['count']}
             for obj, data in object_data.items()
         ]
-        
+
         # Display detected objects in a table with column names
         st.write("Detected Objects and Counts:")
         st.table(pd.DataFrame(object_display_data))