Update app.py

app.py

@@ -7,191 +7,91 @@ import re
 import json
 import os
 import random
-from datetime import datetime
-import matplotlib.pyplot as plt
-import io
-import base64
+import datetime
 from transformers import pipeline
 import requests
 from io import BytesIO
+import matplotlib.pyplot as plt
+import seaborn as sns
+import cv2
 
 # Load nutrition database
 def load_nutrition_data():
-    # Enhanced food database with nutritional information
+    # Create a basic food database with nutritional information
+    # In a production environment, you might want to use a more comprehensive database
     food_data = {
-        "pizza": {"calories": 285, "fat": 10, "carbs": 36, "protein": 12, "category": "junk", "diet_type": ["vegetarian"], "health_index": 30},
-        "burger": {"calories": 354, "fat": 17, "carbs": 40, "protein": 15, "category": "junk", "diet_type": ["non-vegetarian"], "health_index": 25},
-        "fries": {"calories": 312, "fat": 15, "carbs": 41, "protein": 3, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 20},
-        "salad": {"calories": 100, "fat": 7, "carbs": 5, "protein": 2, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 90},
-        "soda": {"calories": 140, "fat": 0, "carbs": 39, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 10},
-        "juice": {"calories": 110, "fat": 0, "carbs": 26, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 50},
-        "water": {"calories": 0, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 100},
-        "pasta": {"calories": 200, "fat": 2, "carbs": 42, "protein": 7, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 60},
-        "steak": {"calories": 300, "fat": 15, "carbs": 0, "protein": 30, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 65},
-        "chicken": {"calories": 220, "fat": 8, "carbs": 0, "protein": 40, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 75},
-        "fish": {"calories": 180, "fat": 5, "carbs": 0, "protein": 30, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 85},
-        "rice": {"calories": 130, "fat": 0, "carbs": 28, "protein": 3, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 65},
-        "beer": {"calories": 154, "fat": 0, "carbs": 13, "protein": 1, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 20},
-        "wine": {"calories": 125, "fat": 0, "carbs": 4, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 40},
-        "ice cream": {"calories": 207, "fat": 11, "carbs": 24, "protein": 4, "category": "junk", "diet_type": ["vegetarian"], "health_index": 25},
-        "coffee": {"calories": 5, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "sandwich": {"calories": 250, "fat": 8, "carbs": 30, "protein": 15, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 60},
-        "soup": {"calories": 120, "fat": 3, "carbs": 12, "protein": 10, "category": "healthy", "diet_type": ["vegetarian"], "health_index": 80},
-        "cake": {"calories": 350, "fat": 18, "carbs": 45, "protein": 4, "category": "junk", "diet_type": ["vegetarian"], "health_index": 15},
-        "bread": {"calories": 80, "fat": 1, "carbs": 15, "protein": 3, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 50},
-        "chocolate": {"calories": 200, "fat": 12, "carbs": 20, "protein": 2, "category": "junk", "diet_type": ["vegetarian"], "health_index": 20},
-        "milkshake": {"calories": 300, "fat": 10, "carbs": 50, "protein": 9, "category": "junk", "diet_type": ["vegetarian"], "health_index": 20},
-        "dessert": {"calories": 280, "fat": 14, "carbs": 35, "protein": 5, "category": "junk", "diet_type": ["vegetarian"], "health_index": 15},
-        "smoothie": {"calories": 170, "fat": 2, "carbs": 35, "protein": 5, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 70},
-        "tea": {"calories": 2, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "appetizer": {"calories": 200, "fat": 12, "carbs": 15, "protein": 8, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 45},
-        "noodles": {"calories": 190, "fat": 2, "carbs": 40, "protein": 7, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 50},
-        "taco": {"calories": 210, "fat": 10, "carbs": 22, "protein": 12, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 55},
-        "burrito": {"calories": 350, "fat": 12, "carbs": 50, "protein": 15, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 50},
-        "wrap": {"calories": 220, "fat": 5, "carbs": 30, "protein": 13, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 65},
-        "sushi": {"calories": 300, "fat": 7, "carbs": 40, "protein": 20, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 80},
-        "vegetables": {"calories": 50, "fat": 0, "carbs": 10, "protein": 2, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 95},
-        "fruits": {"calories": 60, "fat": 0, "carbs": 15, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 90},
-        "oatmeal": {"calories": 150, "fat": 3, "carbs": 27, "protein": 5, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "eggs": {"calories": 155, "fat": 11, "carbs": 1, "protein": 13, "category": "protein", "diet_type": ["vegetarian"], "health_index": 75},
-        "tofu": {"calories": 144, "fat": 8, "carbs": 4, "protein": 16, "category": "protein", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "yogurt": {"calories": 120, "fat": 5, "carbs": 9, "protein": 12, "category": "healthy", "diet_type": ["vegetarian"], "health_index": 75},
-        "nuts": {"calories": 170, "fat": 15, "carbs": 7, "protein": 6, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "chips": {"calories": 150, "fat": 10, "carbs": 15, "protein": 2, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 20},
-        "cookies": {"calories": 200, "fat": 10, "carbs": 25, "protein": 3, "category": "junk", "diet_type": ["vegetarian"], "health_index": 15},
-        "pancakes": {"calories": 175, "fat": 7, "carbs": 22, "protein": 5, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 40},
-        "waffles": {"calories": 220, "fat": 11, "carbs": 26, "protein": 6, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 35},
-        "french toast": {"calories": 250, "fat": 10, "carbs": 30, "protein": 8, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 40},
-        "bacon": {"calories": 180, "fat": 14, "carbs": 0, "protein": 12, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 30},
-        "sausage": {"calories": 230, "fat": 20, "carbs": 1, "protein": 14, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 25},
-        "ham": {"calories": 140, "fat": 5, "carbs": 1, "protein": 21, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 60},
-        "cheese": {"calories": 110, "fat": 9, "carbs": 1, "protein": 7, "category": "protein", "diet_type": ["vegetarian"], "health_index": 50},
-        "butter": {"calories": 100, "fat": 11, "carbs": 0, "protein": 0, "category": "junk", "diet_type": ["vegetarian"], "health_index": 20},
-        "oil": {"calories": 120, "fat": 14, "carbs": 0, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 20},
-        "honey": {"calories": 64, "fat": 0, "carbs": 17, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 55},
-        "syrup": {"calories": 210, "fat": 0, "carbs": 53, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 15},
-        "jam": {"calories": 50, "fat": 0, "carbs": 13, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 40},
-        "peanut butter": {"calories": 190, "fat": 16, "carbs": 7, "protein": 8, "category": "protein", "diet_type": ["vegetarian", "vegan"], "health_index": 60},
-        "hummus": {"calories": 166, "fat": 10, "carbs": 14, "protein": 8, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "avocado": {"calories": 160, "fat": 15, "carbs": 9, "protein": 2, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "beans": {"calories": 120, "fat": 0, "carbs": 22, "protein": 8, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 90},
-        "lentils": {"calories": 115, "fat": 0, "carbs": 20, "protein": 9, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 90},
-        "quinoa": {"calories": 120, "fat": 2, "carbs": 21, "protein": 4, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "muffin": {"calories": 210, "fat": 8, "carbs": 33, "protein": 4, "category": "junk", "diet_type": ["vegetarian"], "health_index": 30},
-        "croissant": {"calories": 230, "fat": 12, "carbs": 26, "protein": 5, "category": "junk", "diet_type": ["vegetarian"], "health_index": 25},
-        "bagel": {"calories": 245, "fat": 1, "carbs": 48, "protein": 10, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 45},
-        "donut": {"calories": 195, "fat": 11, "carbs": 22, "protein": 2, "category": "junk", "diet_type": ["vegetarian"], "health_index": 10},
-        "alcohol": {"calories": 150, "fat": 0, "carbs": 5, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 10},
-        "cocktail": {"calories": 200, "fat": 0, "carbs": 15, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 10},
-        "mango": {"calories": 60, "fat": 0, "carbs": 15, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "berries": {"calories": 40, "fat": 0, "carbs": 10, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 95},
-        "banana": {"calories": 105, "fat": 0, "carbs": 27, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "orange": {"calories": 45, "fat": 0, "carbs": 11, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 90},
-        "apple": {"calories": 95, "fat": 0, "carbs": 25, "protein": 0, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 85},
-        "grapes": {"calories": 65, "fat": 0, "carbs": 17, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "salmon": {"calories": 175, "fat": 11, "carbs": 0, "protein": 19, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 90},
-        "tuna": {"calories": 120, "fat": 1, "carbs": 0, "protein": 26, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 85},
-        "shrimp": {"calories": 85, "fat": 1, "carbs": 0, "protein": 18, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 85},
-        "lobster": {"calories": 89, "fat": 1, "carbs": 0, "protein": 17, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 85},
-        "crab": {"calories": 83, "fat": 1, "carbs": 0, "protein": 16, "category": "healthy", "diet_type": ["non-vegetarian"], "health_index": 85},
-        "lamb": {"calories": 250, "fat": 20, "carbs": 0, "protein": 20, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 60},
-        "pork": {"calories": 210, "fat": 13, "carbs": 0, "protein": 22, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 60},
-        "turkey": {"calories": 175, "fat": 7, "carbs": 0, "protein": 25, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 75},
-        "duck": {"calories": 280, "fat": 24, "carbs": 0, "protein": 19, "category": "protein", "diet_type": ["non-vegetarian"], "health_index": 55},
-        "curry": {"calories": 300, "fat": 15, "carbs": 20, "protein": 25, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 60},
-        "stir fry": {"calories": 250, "fat": 10, "carbs": 15, "protein": 20, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 70},
-        "lasagna": {"calories": 330, "fat": 16, "carbs": 30, "protein": 18, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 45},
-        "risotto": {"calories": 310, "fat": 12, "carbs": 40, "protein": 8, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 55},
-        "paella": {"calories": 320, "fat": 12, "carbs": 38, "protein": 16, "category": "neutral", "diet_type": ["non-vegetarian"], "health_index": 60},
-        "chips and salsa": {"calories": 170, "fat": 8, "carbs": 18, "protein": 2, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 35},
-        "nachos": {"calories": 350, "fat": 19, "carbs": 34, "protein": 8, "category": "junk", "diet_type": ["vegetarian"], "health_index": 20},
-        "hot dog": {"calories": 290, "fat": 17, "carbs": 18, "protein": 11, "category": "junk", "diet_type": ["non-vegetarian"], "health_index": 15},
-        "ice tea": {"calories": 90, "fat": 0, "carbs": 22, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 50},
-        "lemonade": {"calories": 120, "fat": 0, "carbs": 30, "protein": 0, "category": "neutral", "diet_type": ["vegetarian", "vegan"], "health_index": 40},
-        "milk": {"calories": 120, "fat": 5, "carbs": 12, "protein": 8, "category": "neutral", "diet_type": ["vegetarian"], "health_index": 70},
-        "almond milk": {"calories": 40, "fat": 3, "carbs": 1, "protein": 1, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 80},
-        "coconut water": {"calories": 45, "fat": 0, "carbs": 10, "protein": 0, "category": "healthy", "diet_type": ["vegetarian", "vegan"], "health_index": 75},
-        "energy drink": {"calories": 160, "fat": 0, "carbs": 40, "protein": 0, "category": "junk", "diet_type": ["vegetarian", "vegan"], "health_index": 5},
-        "protein shake": {"calories": 170, "fat": 3, "carbs": 15, "protein": 25, "category": "protein", "diet_type": ["vegetarian"], "health_index": 75},
+        "pizza": {"calories": 285, "fat": 10, "carbs": 36, "protein": 12, "category": "junk"},
+        "burger": {"calories": 354, "fat": 17, "carbs": 40, "protein": 15, "category": "junk"},
+        "fries": {"calories": 312, "fat": 15, "carbs": 41, "protein": 3, "category": "junk"},
+        "salad": {"calories": 100, "fat": 7, "carbs": 5, "protein": 2, "category": "healthy"},
+        "soda": {"calories": 140, "fat": 0, "carbs": 39, "protein": 0, "category": "junk"},
+        "juice": {"calories": 110, "fat": 0, "carbs": 26, "protein": 0, "category": "neutral"},
+        "water": {"calories": 0, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy"},
+        "pasta": {"calories": 200, "fat": 2, "carbs": 42, "protein": 7, "category": "neutral"},
+        "steak": {"calories": 300, "fat": 15, "carbs": 0, "protein": 30, "category": "protein"},
+        "chicken": {"calories": 220, "fat": 8, "carbs": 0, "protein": 40, "category": "protein"},
+        "fish": {"calories": 180, "fat": 5, "carbs": 0, "protein": 30, "category": "healthy"},
+        "rice": {"calories": 130, "fat": 0, "carbs": 28, "protein": 3, "category": "neutral"},
+        "beer": {"calories": 154, "fat": 0, "carbs": 13, "protein": 1, "category": "junk"},
+        "wine": {"calories": 125, "fat": 0, "carbs": 4, "protein": 0, "category": "neutral"},
+        "ice cream": {"calories": 207, "fat": 11, "carbs": 24, "protein": 4, "category": "junk"},
+        "coffee": {"calories": 5, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy"},
+        "sandwich": {"calories": 250, "fat": 8, "carbs": 30, "protein": 15, "category": "neutral"},
+        "soup": {"calories": 120, "fat": 3, "carbs": 12, "protein": 10, "category": "healthy"},
+        "cake": {"calories": 350, "fat": 18, "carbs": 45, "protein": 4, "category": "junk"},
+        "bread": {"calories": 80, "fat": 1, "carbs": 15, "protein": 3, "category": "neutral"},
+        "chocolate": {"calories": 200, "fat": 12, "carbs": 20, "protein": 2, "category": "junk"},
+        "milkshake": {"calories": 300, "fat": 10, "carbs": 50, "protein": 9, "category": "junk"},
+        "dessert": {"calories": 280, "fat": 14, "carbs": 35, "protein": 5, "category": "junk"},
+        "smoothie": {"calories": 170, "fat": 2, "carbs": 35, "protein": 5, "category": "neutral"},
+        "tea": {"calories": 2, "fat": 0, "carbs": 0, "protein": 0, "category": "healthy"},
+        "appetizer": {"calories": 200, "fat": 12, "carbs": 15, "protein": 8, "category": "neutral"},
+        "noodles": {"calories": 190, "fat": 2, "carbs": 40, "protein": 7, "category": "neutral"},
+        "taco": {"calories": 210, "fat": 10, "carbs": 22, "protein": 12, "category": "neutral"},
+        "burrito": {"calories": 350, "fat": 12, "carbs": 50, "protein": 15, "category": "neutral"},
+        "wrap": {"calories": 220, "fat": 5, "carbs": 30, "protein": 13, "category": "neutral"},
     }
     return food_data
 
-# Motivational quotes based on health score
-def get_motivational_quote(health_score, items):
-    # Categories for quotes
-    high_health_quotes = [
-        "Your choices today reflect your health tomorrow! Keep making those smart food choices.",
-        "Nutrition isn't about eating less; it's about eating right. You're doing great!",
-        "Health is wealth, and you're investing wisely!",
-        "Your body is a temple, and you're taking good care of it!",
-        "The greatest wealth is health. You're rich in smart choices!",
-        "Eating well is a form of self-respect. You're clearly loving yourself!",
-        "You are what you eat - today, you're choosing to be vibrant and healthy!",
-        "Let food be thy medicine. You're practicing this wisdom!"
-    ]
-    
-    medium_health_quotes = [
-        "Balance is not something you find, it's something you create. Keep working on your food choices!",
-        "Small changes lead to big results. Keep making those mindful choices!",
-        "Progress, not perfection. You're on the right track with your nutrition!",
-        "Every healthy choice is a step in the right direction. Keep walking!",
-        "Your diet doesn't have to be perfect to be healthy. Keep finding that balance!",
-        "Healthy eating is a journey, not a destination. You're making progress!"
-    ]
-    
-    low_health_quotes = [
-        "Tomorrow is a new opportunity to nourish your body better.",
-        "Every meal is a chance to make a healthier choice. Your next one can be better!",
-        "Your body deserves the best. Consider what fuels you optimally!",
-        "Small, consistent changes in your diet can transform your health over time.",
-        "Eating well is loving yourself in action. Start with your very next meal!",
-        "It's never too late to make a healthy choice. Your body will thank you!"
-    ]
-    
-    # Check for specific food types to personalize quotes
-    has_vegetables = any("vegetable" in item["name"].lower() for item in items)
-    has_fruits = any("fruit" in item["name"].lower() or item["name"].lower() in ["apple", "banana", "orange", "berries"] for item in items)
-    has_protein = any(item["nutrition"]["category"] == "protein" for item in items)
-    has_water = any(item["name"].lower() == "water" for item in items)
-    high_fat = sum(item["nutrition"]["fat"] for item in items) > 50
-    high_sugar = any(item["name"].lower() in ["soda", "cake", "ice cream", "dessert", "cookies", "donut"] for item in items)
-    
-    # Personalized quotes based on specific food choices
-    personalized_quotes = []
-    
-    if has_vegetables:
-        personalized_quotes.append("Loving those vegetables! They're nature's multivitamin package.")
-    if has_fruits:
-        personalized_quotes.append("Fruits are nature's candy - sweet and nutritious. Great choice!")
-    if has_protein and health_score > 60:
-        personalized_quotes.append("Good job balancing your proteins - they're the building blocks of a healthy body!")
-    if has_water:
-        personalized_quotes.append("Staying hydrated is crucial for overall health. Water is always a smart choice!")
-    if high_fat and health_score < 40:
-        personalized_quotes.append("Consider foods with healthier fats like avocados, nuts, and olive oil next time.")
-    if high_sugar and health_score < 40:
-        personalized_quotes.append("Natural sugars from fruits can satisfy your sweet tooth while providing nutrients!")
-    
-    # Select quote based on health score
-    if health_score >= 70:
-        quotes = high_health_quotes
-    elif health_score >= 40:
-        quotes = medium_health_quotes
-    else:
-        quotes = low_health_quotes
-    
-    # If we have personalized quotes, mix them in
-    if personalized_quotes:
-        quotes.extend(personalized_quotes)
-    
-    return random.choice(quotes)
+# Initialize nutrition data
+nutrition_data = load_nutrition_data()
 
-# Keep track of user's food history
-user_history = {
-    "meals": [],
-    "health_scores": [],
-    "timestamps": []
-}
+# Load motivational quotes based on health score ranges
+def load_motivational_quotes():
+    quotes = {
+        "excellent": [
+            "You're making excellent food choices! Your body thanks you for the premium fuel.",
+            "Fantastic choices! You're investing in your long-term health with every bite.",
+            "Your healthy eating habits today are building your stronger body for tomorrow.",
+            "Impressive meal choices! You're mastering the art of nutritious eating.",
+            "You're a nutrition champion! These balanced choices will energize your day."
+        ],
+        "good": [
+            "Good job balancing nutrition! Small improvements can take you to the next level.",
+            "You're on the right track with your food choices. Keep building those healthy habits!",
+            "Nice work choosing a fairly balanced meal. Your body appreciates the consideration.",
+            "Your meal choices show you care about your health. Keep that momentum going!",
+            "Good balance of nutrients in this meal. Remember: consistency is key to health."
+        ],
+        "moderate": [
+            "This meal has some nutritional bright spots. Consider adding more protein next time.",
+            "Balance is a journey. Try adding more vegetables to your next meal.",
+            "Everyone indulges sometimes. Tomorrow is a new opportunity for nourishing choices.",
+            "Consider this meal a starting point. Small improvements add up to big health benefits.",
+            "Moderation is key. Try balancing this meal with healthier choices later today."
+        ],
+        "poor": [
+            "Your body deserves premium fuel. Consider more nutrient-dense options next time.",
+            "One meal doesn't define your health journey. Your next choice can be a healthier one.",
+            "We all have indulgences. Balance this meal with nutritious choices for your next one.",
+            "Small steps lead to big changes. Consider adding vegetables to your next meal.",
+            "Remember: food is fuel. Choose options that will energize rather than drain you."
+        ]
+    }
+    return quotes
+
+# Initialize motivational quotes
+motivational_quotes = load_motivational_quotes()
 
 # Initialize NLP model for food item recognition
 try:
@@ -200,7 +100,36 @@ except Exception as e:
     print(f"Error loading NLP model: {e}")
     food_classifier = None
 
-# Enhanced OCR function with image preprocessing
+# Helper function to preprocess the image for better OCR results
+def preprocess_image(image):
+    # Convert to numpy array if needed
+    if not isinstance(image, np.ndarray):
+        image = np.array(image)
+    
+    try:
+        # Convert to grayscale
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image
+        
+        # Apply adaptive thresholding
+        thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                      cv2.THRESH_BINARY, 11, 2)
+        
+        # Denoise
+        denoised = cv2.fastNlMeansDenoising(thresh, None, 10, 7, 21)
+        
+        # Convert back to PIL image for tesseract
+        enhanced_img = Image.fromarray(denoised)
+        
+        return enhanced_img
+    except Exception as e:
+        print(f"Error preprocessing image: {e}")
+        # If preprocessing fails, return the original image
+        return Image.fromarray(image) if isinstance(image, np.ndarray) else image
+
+# OCR function to extract text from bill image with enhanced image processing
 def extract_text_from_image(image):
     try:
         # If image is a URL, download it
@@ -210,52 +139,31 @@ def extract_text_from_image(image):
         else:
             img = Image.fromarray(image) if isinstance(image, np.ndarray) else image
         
-        # Apply image preprocessing to enhance OCR quality
-        # Convert to grayscale
-        img_gray = img.convert('L')
-        
-        # Increase contrast
-        enhancer = ImageEnhance.Contrast(img_gray)
-        img_contrast = enhancer.enhance(2.0)
+        # Preprocess the image for better OCR results
+        preprocessed_img = preprocess_image(img)
         
-        # Apply slight blur to reduce noise
-        img_blur = img_contrast.filter(ImageFilter.GaussianBlur(1))
+        # Use tesseract with optimized configuration
+        custom_config = r'--oem 3 --psm 6 -l eng'
+        text = pytesseract.image_to_string(preprocessed_img, config=custom_config)
         
-        # Apply threshold to make text stand out
-        threshold = 150
-        img_binary = img_blur.point(lambda p: p > threshold and 255)
+        # Fallback to original image if the result is too short
+        if len(text.strip()) < 20:
+            text = pytesseract.image_to_string(img, config=custom_config)
         
-        # Run OCR on both processed and original images and combine results
-        text_processed = pytesseract.image_to_string(img_binary)
-        text_original = pytesseract.image_to_string(img)
-        
-        # Combine results (processed image might be better for some cases, original for others)
-        combined_text = text_processed if len(text_processed) > len(text_original) else text_original
-        
-        # Try different OCR configurations if results are poor
-        if len(combined_text.strip()) < 20:  # Arbitrary threshold for "poor results"
-            # Try page segmentation mode 4 (assume a single column of text)
-            text_alt = pytesseract.image_to_string(img, config='--psm 4')
-            if len(text_alt.strip()) > len(combined_text.strip()):
-                combined_text = text_alt
-            
-            # Try page segmentation mode 6 (assume a single uniform block of text)
-            text_alt = pytesseract.image_to_string(img, config='--psm 6')
-            if len(text_alt.strip()) > len(combined_text.strip()):
-                combined_text = text_alt
-        
-        return combined_text
+        return text
     except Exception as e:
         return f"Error extracting text: {str(e)}"
 
-# Enhanced extraction of food items from the OCR text
+# Extract food items from the OCR text with improved pattern recognition
 def extract_food_items(text):
     # Common patterns found in restaurant bills
+    # Look for items with prices
     lines = text.split('\n')
     food_items = []
     
     # Regular patterns for food items in bills
-    price_pattern = r'\$?\d+\.\d{2}'
+    # More comprehensive price pattern to catch various formats
+    price_pattern = r'(\$?\d+\.\d{2}|\$?\d+\,\d{2}|\$?\d+)'
     
     for line in lines:
         line = line.strip()
@@ -263,56 +171,622 @@ def extract_food_items(text):
             continue
             
         # Skip lines that look like totals or headers
-        if re.search(r'(total|subtotal|tax|gratuity|tip|service|amount|due|change|cash|credit|card|payment|date|time|server|check|table|guest|invoice|receipt|bill|order|#)', 
-                    line.lower()):
+        skip_keywords = [
+            'total', 'subtotal', 'tax', 'gratuity', 'tip', 'service', 'amount', 'due', 'change',
+            'cash', 'credit', 'card', 'payment', 'date', 'time', 'server', 'check', 'table', 
+            'guest', 'invoice', 'receipt', 'bill', 'order', 'tel', 'phone', 'address',
+            'thank you', 'restaurant', 'cafe', 'bar', 'grill', 'kitchen'
+        ]
+        
+        if any(keyword in line.lower() for keyword in skip_keywords):
             continue
             
         # If line contains a price, it's likely a food item
         if re.search(price_pattern, line):
             # Extract the item name (everything before the price)
-            item_match = re.split(price_pattern, line)[0].strip()
-            if item_match and len(item_match) > 1:  # Ensure it's not just whitespace
-                # Clean up the item name (remove quantities, etc.)
-                cleaned_item = re.sub(r'^\d+\s*[xX]?\s*', '', item_match)  # Remove quantities like "2 x" or "2"
-                cleaned_item = re.sub(r'\d+\s*oz\s*', '', cleaned_item)    # Remove sizes like "12oz"
-                cleaned_item = re.sub(r'\(\w+\)', '', cleaned_item)        # Remove parentheses
-                food_items.append(cleaned_item.strip().lower())
-    
-    # If we couldn't find food items using the price pattern, try to extract words that might be food
+            item_parts = re.split(price_pattern, line)
+            if item_parts and len(item_parts) > 1:
+                item_match = item_parts[0].strip()
+                if item_match and len(item_match) > 1:  # Ensure it's not just whitespace
+                    # Clean up the item name (remove quantities, etc.)
+                    cleaned_item = re.sub(r'^\d+\s*[xX]?\s*', '', item_match)  # Remove quantities like "2 x" or "2"
+                    cleaned_item = re.sub(r'\d+\s*oz\s*', '', cleaned_item)  # Remove sizes like "12oz"
+                    cleaned_item = re.sub(r'\(\w+\)', '', cleaned_item)  # Remove parentheses
+                    
+                    # Filter out very short items that are likely not food
+                    if len(cleaned_item.strip()) > 2:
+                        food_items.append(cleaned_item.strip().lower())
+    
+    # Enhanced approach: look for menu item formats (even without prices)
+    item_pattern = r'^\s*\d+\.\s+(.+)$'  # Matches numbered items like "1. Burger"
+    for line in lines:
+        match = re.search(item_pattern, line)
+        if match:
+            food_item = match.group(1).strip().lower()
+            if len(food_item) > 2 and food_item not in food_items:
+                food_items.append(food_item)
+    
+    # If we couldn't find food items using patterns, try to extract words that might be food
     if not food_items:
-        # Build a potential list of food words
-        potential_foods = []
+        # Use NLP to identify potential food items
+        common_words = []
         for line in lines:
-            # Clean and extract potential food names
-            cleaned_line = re.sub(r'\d+\.*\d*', ' ', line)  # Remove numbers
-            words = re.findall(r'\b[a-zA-Z]{3,}\b', cleaned_line.lower())
-            
-            # Add words that could be food items
-            for word in words:
-                if word not in ["total", "subtotal", "tax", "tip", "amount", "due", "cash", "credit", 
-                               "card", "date", "time", "server", "table", "guest", "check", "receipt"]:
-                    potential_foods.append(word)
-        
-        # Use NLP to identify which words are likely food items
-        if potential_foods and food_classifier:
+            words = re.findall(r'\b[a-zA-Z]{3,}\b', line.lower())
+            common_words.extend(words)
+        
+        # Filter by known food terms if we have enough words
+        if common_words and food_classifier:
             try:
-                # Process words in small batches to avoid overloading the model
-                batch_size = 10
-                for i in range(0, len(potential_foods), batch_size):
-                    batch = potential_foods[i:i+batch_size]
-                    for word in batch:
-                        # Check if word is directly in our database
-                        if word in nutrition_data:
-                            food_items.append(word)
-                            continue
-                            
-                        # Use zero-shot classification
-                        result = food_classifier(word, ["food item", "not food"])
-                        if result["scores"][0] > 0.7 and result["labels"][0] == "food item":
-                            food_items.append(word)
-                            
-                # Look for multi-word food items
-                for i in range(len(lines)):
-                    line = lines[i].lower()
-                    for food_name in nutrition_data:
-                        if " " in food_name and food_name
+                candidate_foods = list(set(common_words))
+                if candidate_foods:
+                    food_items = identify_food_items_with_nlp(candidate_foods)
+            except Exception as e:
+                print(f"Error identifying food items with NLP: {e}")
+    
+    return food_items
+
+# Use NLP to identify food items from candidate text with improved confidence threshold
+def identify_food_items_with_nlp(candidate_items, threshold=0.65):
+    food_items = []
+    
+    # List of candidate food categories
+    food_categories = ["food", "drink", "meal", "dish", "beverage", "dessert", "snack"]
+    
+    for item in candidate_items:
+        if item in nutrition_data:  # Directly in our database
+            food_items.append(item)
+            continue
+            
+        # Use zero-shot classification to check if the item is a food
+        try:
+            result = food_classifier(item, food_categories)
+            if result["scores"][0] > threshold:
+                food_items.append(item)
+        except Exception as e:
+            print(f"Error classifying {item}: {e}")
+    
+    return food_items
+
+# Match extracted food items to our nutrition database with improved fuzzy matching
+def match_food_to_nutrition(food_items):
+    matched_items = []
+    
+    for item in food_items:
+        # Direct match
+        if item in nutrition_data:
+            matched_items.append({"name": item, "nutrition": nutrition_data[item]})
+            continue
+            
+        # Improved matching logic - word-based matching and ngram similarity
+        best_match = None
+        max_score = 0
+        
+        # Split the item into words for better matching
+        item_words = set(item.split())
+        
+        for db_food in nutrition_data:
+            # Calculate word overlap
+            db_food_words = set(db_food.split())
+            if item_words and db_food_words:
+                overlap = len(item_words.intersection(db_food_words))
+                score = overlap / max(len(item_words), len(db_food_words))
+                
+                # Boost score if one string contains the other
+                if db_food in item or item in db_food:
+                    score += 0.3
+                
+                if score > max_score:
+                    max_score = score
+                    best_match = db_food
+        
+        # Only match if the score is reasonably high
+        if best_match and max_score > 0.3:
+            matched_items.append({"name": item, "matched_as": best_match, "nutrition": nutrition_data[best_match]})
+    
+    return matched_items
+
+# Calculate nutritional totals and health score with more sophisticated scoring
+def calculate_nutrition_and_health_score(matched_items):
+    if not matched_items:
+        return {
+            "total_calories": 0,
+            "total_fat": 0,
+            "total_carbs": 0,
+            "total_protein": 0,
+            "health_score": 0,
+            "health_assessment": "No food items detected",
+            "items": [],
+            "macronutrient_ratios": {"protein": 0, "fat": 0, "carbs": 0}
+        }
+    
+    # Calculate totals
+    total_calories = sum(item["nutrition"]["calories"] for item in matched_items)
+    total_fat = sum(item["nutrition"]["fat"] for item in matched_items)
+    total_carbs = sum(item["nutrition"]["carbs"] for item in matched_items)
+    total_protein = sum(item["nutrition"]["protein"] for item in matched_items)
+    
+    # Calculate macronutrient ratios
+    total_nutrient_calories = (total_protein * 4) + (total_carbs * 4) + (total_fat * 9)
+    if total_nutrient_calories > 0:
+        protein_ratio = (total_protein * 4) / total_nutrient_calories
+        carbs_ratio = (total_carbs * 4) / total_nutrient_calories
+        fat_ratio = (total_fat * 9) / total_nutrient_calories
+    else:
+        protein_ratio = carbs_ratio = fat_ratio = 0
+    
+    macronutrient_ratios = {
+        "protein": round(protein_ratio * 100, 1),
+        "fat": round(fat_ratio * 100, 1),
+        "carbs": round(carbs_ratio * 100, 1)
+    }
+    
+    # Count categories
+    categories = [item["nutrition"]["category"] for item in matched_items]
+    category_counts = {
+        "healthy": categories.count("healthy"),
+        "protein": categories.count("protein"),
+        "neutral": categories.count("neutral"),
+        "junk": categories.count("junk")
+    }
+    
+    # Calculate health score (0-100) with more sophisticated algorithm
+    health_score = 0
+    total_items = len(matched_items)
+    
+    # Base score from category distribution (50% of total score)
+    if total_items > 0:
+        health_score += (category_counts["healthy"] / total_items) * 25
+        health_score += (category_counts["protein"] / total_items) * 20
+        health_score += (category_counts["neutral"] / total_items) * 10
+    
+    # Macronutrient balance (50% of total score)
+    if total_nutrient_calories > 0:
+        # Protein score (ideal: 20-30%)
+        if protein_ratio >= 0.2 and protein_ratio <= 0.3:
+            health_score += 15
+        elif protein_ratio > 0.15 and protein_ratio < 0.35:
+            health_score += 10
+        elif protein_ratio > 0.1:
+            health_score += 5
+        
+        # Fat score (ideal: 20-35%)
+        if fat_ratio >= 0.2 and fat_ratio <= 0.35:
+            health_score += 15
+        elif fat_ratio > 0.15 and fat_ratio < 0.4:
+            health_score += 10
+        elif fat_ratio < 0.45:
+            health_score += 5
+        
+        # Carb score (ideal: 45-65%)
+        if carbs_ratio >= 0.45 and carbs_ratio <= 0.65:
+            health_score += 15
+        elif carbs_ratio > 0.35 and carbs_ratio < 0.7:
+            health_score += 10
+        elif carbs_ratio > 0.25 and carbs_ratio < 0.75:
+            health_score += 5
+    
+    # Cap between 0-100
+    health_score = max(0, min(100, health_score))
+    
+    # Get appropriate motivational quote based on health score
+    motivational_quote = get_motivational_quote(health_score)
+    
+    # Generate detailed health assessment
+    if health_score > 75:
+        assessment = f"Excellent! Your meal of {total_calories} calories shows thoughtful, balanced choices."
+        assessment_category = "excellent"
+    elif health_score > 50:
+        assessment = f"Good job! Your meal of {total_calories} calories has decent nutritional balance."
+        assessment_category = "good"
+    elif health_score > 25:
+        assessment = f"This {total_calories}-calorie meal has some nutritional gaps. Consider more balance next time."
+        assessment_category = "moderate"
+    else:
+        assessment = f"Your {total_calories}-calorie meal is primarily composed of less nutritious options. Try incorporating more whole foods."
+        assessment_category = "poor"
+    
+    # Prepare detailed items list
+    items_details = []
+    for item in matched_items:
+        name = item["name"]
+        if "matched_as" in item:
+            name = f"{name} (matched as {item['matched_as']})"
+        
+        items_details.append({
+            "name": name,
+            "calories": item["nutrition"]["calories"],
+            "fat": item["nutrition"]["fat"],
+            "carbs": item["nutrition"]["carbs"],
+            "protein": item["nutrition"]["protein"],
+            "category": item["nutrition"]["category"]
+        })
+    
+    # Calculate the timestamp for meal tracking
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Return comprehensive results
+    return {
+        "total_calories": total_calories,
+        "total_fat": total_fat,
+        "total_carbs": total_carbs,
+        "total_protein": total_protein,
+        "health_score": round(health_score, 1),
+        "health_assessment": assessment,
+        "assessment_category": assessment_category,
+        "motivational_quote": motivational_quote,
+        "items": items_details,
+        "macronutrient_ratios": macronutrient_ratios,
+        "timestamp": timestamp
+    }
+
+# Get a motivational quote based on health score
+def get_motivational_quote(health_score):
+    if health_score > 75:
+        category = "excellent"
+    elif health_score > 50:
+        category = "good"
+    elif health_score > 25:
+        category = "moderate"
+    else:
+        category = "poor"
+    
+    return random.choice(motivational_quotes[category])
+
+# Generate visualizations based on nutritional analysis
+def generate_visualizations(nutrition_results):
+    if not nutrition_results["items"]:
+        return None, None, None
+    
+    try:
+        # Create figures with white background for better visibility
+        plt.style.use('default')
+        
+        # Macronutrient distribution pie chart
+        fig1, ax1 = plt.subplots(figsize=(6, 4), facecolor='white')
+        labels = ['Protein', 'Carbs', 'Fat']
+        sizes = [
+            nutrition_results['macronutrient_ratios']['protein'],
+            nutrition_results['macronutrient_ratios']['carbs'],
+            nutrition_results['macronutrient_ratios']['fat']
+        ]
+        colors = ['#4CAF50', '#2196F3', '#FFC107']
+        explode = (0.1, 0, 0)  # explode the protein slice
+        
+        ax1.pie(sizes, explode=explode, labels=labels, colors=colors, autopct='%1.1f%%',
+                shadow=True, startangle=90)
+        ax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle
+        plt.title('Macronutrient Distribution')
+        plt.tight_layout()
+        
+        # Item comparison bar chart
+        fig2, ax2 = plt.subplots(figsize=(8, 5), facecolor='white')
+        
+        # Limit to top 6 items for readability
+        items = nutrition_results['items'][:6] if len(nutrition_results['items']) > 6 else nutrition_results['items']
+        
+        # Prepare data
+        item_names = [item['name'].split(' (matched')[0] for item in items]  # Just use the first part
+        item_names = [name[:12] + '...' if len(name) > 15 else name for name in item_names]  # Truncate long names
+        calories = [item['calories'] for item in items]
+        
+        # Color based on category
+        category_colors = {
+            'healthy': '#4CAF50',  # Green
+            'protein': '#2196F3',  # Blue
+            'neutral': '#9E9E9E',  # Grey
+            'junk': '#F44336'      # Red
+        }
+        bar_colors = [category_colors[item['category']] for item in items]
+        
+        # Create bars
+        bars = ax2.barh(range(len(item_names)), calories, color=bar_colors)
+        ax2.set_yticks(range(len(item_names)))
+        ax2.set_yticklabels(item_names)
+        ax2.set_xlabel('Calories')
+        ax2.set_title('Calorie Content by Food Item')
+        
+        # Add value labels
+        for i, bar in enumerate(bars):
+            ax2.text(bar.get_width() + 5, bar.get_y() + bar.get_height()/2, 
+                    str(calories[i]) + ' cal', 
+                    va='center', fontsize=8)
+        
+        plt.tight_layout()
+        
+        # Health score gauge chart
+        fig3, ax3 = plt.subplots(figsize=(6, 3), facecolor='white')
+        
+        # Create health score gauge
+        score = nutrition_results['health_score']
+        
+        # Create a horizontal bar for the gauge
+        cmap = plt.cm.RdYlGn  # Red-Yellow-Green colormap
+        norm = plt.Normalize(0, 100)
+        
+        # Create gradient background
+        for i in range(100):
+            ax3.barh(0, 1, left=i, height=0.5, color=cmap(norm(i)), alpha=0.7)
+        
+        # Add marker for the score
+        ax3.barh(0, 3, left=score-1.5, height=0.7, color='black')
+        
+        # Remove axes and add labels
+        ax3.set_yticks([])
+        ax3.set_xticks([0, 25, 50, 75, 100])
+        ax3.set_xlim(0, 100)
+        ax3.set_title(f'Health Score: {score}/100')
+        
+        plt.tight_layout()
+        
+        # Convert figures to images
+        macros_chart = fig_to_image(fig1)
+        items_chart = fig_to_image(fig2)
+        score_chart = fig_to_image(fig3)
+        
+        plt.close(fig1)
+        plt.close(fig2)
+        plt.close(fig3)
+        
+        return macros_chart, items_chart, score_chart
+        
+    except Exception as e:
+        print(f"Error generating visualizations: {e}")
+        return None, None, None
+
+# Helper function to convert matplotlib figure to image
+def fig_to_image(fig):
+    from io import BytesIO
+    
+    buf = BytesIO()
+    fig.savefig(buf, format='png', dpi=100)
+    buf.seek(0)
+    return buf
+
+# Format nutritional analysis results with enhanced styling
+def format_results(nutrition_results):
+    if not nutrition_results["items"]:
+        return "No food items were detected in the bill. Please try a clearer image or check that the image shows food items clearly."
+    
+    # Basic summary
+    result = f"## Nutrition Summary\n\n"
+    
+    # Health score & assessment
+    result += f"**Health Score:** {nutrition_results['health_score']}/100\n\n"
+    result += f"**Assessment:** {nutrition_results['health_assessment']}\n\n"
+    
+    # Motivational quote
+    result += f"**💪 Motivation:** {nutrition_results['motivational_quote']}\n\n"
+    
+    # Macronutrient breakdown
+    result += "### Nutritional Totals\n"
+    result += f"- **Calories:** {nutrition_results['total_calories']} kcal\n"
+    result += f"- **Protein:** {nutrition_results['total_protein']}g ({nutrition_results['macronutrient_ratios']['protein']}%)\n"
+    result += f"- **Carbs:** {nutrition_results['total_carbs']}g ({nutrition_results['macronutrient_ratios']['carbs']}%)\n"
+    result += f"- **Fat:** {nutrition_results['total_fat']}g ({nutrition_results['macronutrient_ratios']['fat']}%)\n\n"
+    
+    # Item breakdown
+    result += "### Detected Food Items\n"
+    for item in nutrition_results["items"]:
+        # Emoji based on food category
+        emoji = "🥦" if item['category'] == "healthy" else "🍗" if item['category'] == "protein" else "⚖️" if item['category'] == "neutral" else "🍰"
+        
+        result += f"- {emoji} **{item['name'].title()}**: {item['calories']} kcal ({item['fat']}g fat, {item['carbs']}g carbs, {item['protein']}g protein)\n"
+    
+    # Recommendations
+    result += "\n### Recommendations\n"
+    
+    # Targeted recommendations based on nutrient analysis
+    if nutrition_results['macronutrient_ratios']['protein'] < 15:
+        result += "- 🥩 **Protein Boost Needed:** Consider adding more protein sources like chicken, fish, tofu, or legumes.\n"
+    
+    if nutrition_results['macronutrient_ratios']['fat'] > 35:
+        result += "- 🥑 **Fat Watch:** This meal is high in fat. Try reducing fried foods and choosing leaner options.\n"
+    
+    if nutrition_results['macronutrient_ratios']['carbs'] > 60:
+        result += "- 🍞 **Carb Heavy:** Consider reducing refined carbs and choosing more vegetables and proteins.\n"
+    
+    # Check total calories
+    if nutrition_results["total_calories"] > 900 and len(nutrition_results["items"]) <= 2:
+        result += "- 📊 **Portion Alert:** This meal contains high calories in few items. Consider portion control.\n"
+    
+    # If no specific recommendations, add a general one
+    if "Consider" not in result:
+        result += "- 🌟 **Keep it Up:** Your meal is well-balanced! Maintain this approach to nutrition.\n"
+    
+    return result
+
+# Main function to process the image and return analysis
+def analyze_restaurant_bill(image):
+    if image is None:
+        return "Please upload an image of your restaurant bill to analyze.", None, None, None
+    
+    # Extract text from image using OCR
+    text = extract_text_from_image(image)
+    if text.startswith("Error"):
+        return f"OCR failed: {text}", None, None, None
+    
+    # Extract food items from the text
+    food_items = extract_food_items(text)
+    if not food_items:
+        return "No food items detected in the bill. Please try a clearer image or manually enter food items.", None, None, None
+    
+# Match food items to nutrition database
+    matched_items = match_food_to_nutrition(food_items)
+    
+    # Calculate nutritional information and health score
+    nutrition_results = calculate_nutrition_and_health_score(matched_items)
+    
+    # Format results as a readable string
+    formatted_results = format_results(nutrition_results)
+    
+    # Generate visualizations
+    macro_chart, items_chart, score_chart = generate_visualizations(nutrition_results)
+    
+    return formatted_results, macro_chart, items_chart, score_chart
+
+# Function to process manually entered food items
+def analyze_manual_food_items(food_items_text):
+    if not food_items_text.strip():
+        return "Please enter some food items to analyze.", None, None, None
+    
+    # Parse the text into a list of food items
+    food_items = [item.strip().lower() for item in food_items_text.split(',') if item.strip()]
+    
+    # Match food items to nutrition database
+    matched_items = match_food_to_nutrition(food_items)
+    
+    if not matched_items:
+        return "None of the entered items could be matched to our nutrition database. Please try different foods or check spelling.", None, None, None
+    
+    # Calculate nutritional information and health score
+    nutrition_results = calculate_nutrition_and_health_score(matched_items)
+    
+    # Format results as a readable string
+    formatted_results = format_results(nutrition_results)
+    
+    # Generate visualizations
+    macro_chart, items_chart, score_chart = generate_visualizations(nutrition_results)
+    
+    return formatted_results, macro_chart, items_chart, score_chart
+
+# Save meal data to file
+def save_meal_data(nutrition_results, log_file="meal_log.json"):
+    if not nutrition_results or not nutrition_results.get("items"):
+        return False
+    
+    # Create simplified data for logging
+    log_entry = {
+        "timestamp": nutrition_results["timestamp"],
+        "total_calories": nutrition_results["total_calories"],
+        "health_score": nutrition_results["health_score"],
+        "macros": {
+            "protein": nutrition_results["total_protein"],
+            "carbs": nutrition_results["total_carbs"],
+            "fat": nutrition_results["total_fat"]
+        },
+        "items": [item["name"] for item in nutrition_results["items"]]
+    }
+    
+    # Load existing log if available
+    try:
+        if os.path.exists(log_file):
+            with open(log_file, 'r') as f:
+                log_data = json.load(f)
+        else:
+            log_data = []
+    except Exception:
+        log_data = []
+    
+    # Add new entry
+    log_data.append(log_entry)
+    
+    # Save updated log
+    try:
+        with open(log_file, 'w') as f:
+            json.dump(log_data, f, indent=2)
+        return True
+    except Exception:
+        return False
+
+# Setup Gradio interface with improved UI and layout
+def create_interface():
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="green"), title="Restaurant Bill Nutrition Analyzer") as demo:
+        gr.Markdown(
+            """
+            # 🧾 Restaurant Bill Nutrition Analyzer 🥗
+            
+            Upload a photo of your restaurant bill or receipt, and this app will:
+            
+            1. 🔍 Extract food items from the image using OCR
+            2. 📊 Match them to a nutrition database
+            3. 📋 Calculate total calories, macronutrients, and a health score
+            4. 📈 Provide visualizations and personalized recommendations
+            
+            Alternatively, you can manually enter food items separated by commas.
+            """
+        )
+        
+        with gr.Tabs():
+            with gr.TabItem("📸 Analyze Restaurant Bill"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        upload_image = gr.Image(
+                            label="Upload Restaurant Bill Image",
+                            type="numpy", 
+                            height=300
+                        )
+                        analyze_button = gr.Button("Analyze Bill", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        output_text = gr.Markdown(label="Analysis Results")
+                
+                with gr.Row():
+                    with gr.Column():
+                        macros_chart = gr.Image(label="Macronutrient Distribution")
+                    with gr.Column():
+                        score_chart = gr.Image(label="Health Score")
+                    with gr.Column():
+                        items_chart = gr.Image(label="Calories by Item")
+            
+            with gr.TabItem("✍️ Manual Food Entry"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        food_input = gr.Textbox(
+                            label="Enter Food Items (separate with commas)",
+                            placeholder="e.g., pizza, salad, soda, chicken"
+                        )
+                        manual_analyze_button = gr.Button("Analyze Foods", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        manual_output_text = gr.Markdown(label="Analysis Results")
+                
+                with gr.Row():
+                    with gr.Column():
+                        manual_macros_chart = gr.Image(label="Macronutrient Distribution")
+                    with gr.Column():
+                        manual_score_chart = gr.Image(label="Health Score")
+                    with gr.Column():
+                        manual_items_chart = gr.Image(label="Calories by Item")
+        
+        gr.Markdown(
+            """
+            ### How it works
+            
+            This app uses Optical Character Recognition (OCR) to read text from your bill image, 
+            then applies Natural Language Processing to identify food items and match them to a 
+            nutrition database. The results include total calories, macronutrient breakdown, and 
+            a health score from 0-100.
+            
+            ### Limitations
+            
+            - OCR accuracy depends on image quality - clear, well-lit photos work best
+            - Limited nutrition database - some foods may not be recognized
+            - Calorie estimates are approximations based on general serving sizes
+            
+            ### Tips
+            
+            - Take clear, straight-on photos of your bill in good lighting
+            - If the app misses items, try the manual entry option
+            - For best results, ensure food items are clearly listed on the receipt
+            """
+        )
+        
+        # Set up event handlers
+        analyze_button.click(
+            fn=analyze_restaurant_bill,
+            inputs=upload_image,
+            outputs=[output_text, macros_chart, score_chart, items_chart]
+        )
+        
+        manual_analyze_button.click(
+            fn=analyze_manual_food_items,
+            inputs=food_input,
+            outputs=[manual_output_text, manual_macros_chart, manual_score_chart, manual_items_chart]
+        )
+    
+    return demo
+
+# Launch the application
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()