Create app.py

app.py

@@ -0,0 +1,1121 @@
+import gradio as gr
+import numpy as np
+import pytesseract
+from PIL import Image, ImageEnhance, ImageFilter
+import pandas as pd
+import re
+import json
+import os
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+import requests
+from io import BytesIO
+import csv
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import base64
+from pathlib import Path
+import cv2
+import html
+
+# Initialize models and data storage
+class NutritionAnalyzer:
+    def __init__(self):
+        self.nutrition_data = self.load_nutrition_data()
+        self.history = []
+        self.initialize_models()
+        
+    def initialize_models(self):
+        try:
+            # Initialize food classifier model
+            self.food_classifier = pipeline("zero-shot-classification", 
+                                          model="facebook/bart-large-mnli",
+                                          device=0 if torch.cuda.is_available() else -1)
+            
+            # Add sentiment analysis for feedback
+            self.sentiment_analyzer = pipeline("sentiment-analysis", 
+                                              model="distilbert-base-uncased-finetuned-sst-2-english",
+                                              device=0 if torch.cuda.is_available() else -1)
+            print("NLP models loaded successfully")
+        except Exception as e:
+            print(f"Error loading NLP models: {e}")
+            self.food_classifier = None
+            self.sentiment_analyzer = None
+
+    def load_nutrition_data(self):
+        """Load nutrition data from CSV if available, otherwise use default database"""
+        try:
+            if os.path.exists('nutrition_database.csv'):
+                df = pd.read_csv('nutrition_database.csv')
+                nutrition_data = {}
+                for _, row in df.iterrows():
+                    food_name = row['food_name'].lower()
+                    nutrition_data[food_name] = {
+                        "calories": row['calories'],
+                        "fat": row['fat'],
+                        "carbs": row['carbs'],
+                        "protein": row['protein'],
+                        "sugar": row['sugar'] if 'sugar' in row else 0,
+                        "fiber": row['fiber'] if 'fiber' in row else 0,
+                        "category": row['category']
+                    }
+                print(f"Loaded {len(nutrition_data)} items from nutrition database")
+                return nutrition_data
+            else:
+                return self.create_default_nutrition_database()
+        except Exception as e:
+            print(f"Error loading nutrition data: {e}")
+            return self.create_default_nutrition_database()
+    
+    def create_default_nutrition_database(self):
+        """Create a default nutrition database with extended food items"""
+        print("Creating default nutrition database")
+        food_data = {
+            # Fast food
+            "pizza": {"calories": 285, "fat": 10, "carbs": 36, "protein": 12, "sugar": 3, "fiber": 2, "category": "junk"},
+            "burger": {"calories": 354, "fat": 17, "carbs": 40, "protein": 15, "sugar": 8, "fiber": 1, "category": "junk"},
+            "fries": {"calories": 312, "fat": 15, "carbs": 41, "protein": 3, "sugar": 0, "fiber": 3, "category": "junk"},
+            "chicken sandwich": {"calories": 450, "fat": 19, "carbs": 45, "protein": 28, "sugar": 5, "fiber": 2, "category": "junk"},
+            "hot dog": {"calories": 290, "fat": 16, "carbs": 18, "protein": 10, "sugar": 2, "fiber": 1, "category": "junk"},
+            "nachos": {"calories": 600, "fat": 39, "carbs": 56, "protein": 15, "sugar": 2, "fiber": 7, "category": "junk"},
+            "onion rings": {"calories": 320, "fat": 16, "carbs": 40, "protein": 5, "sugar": 6, "fiber": 3, "category": "junk"},
+            
+            # Beverages
+            "soda": {"calories": 140, "fat": 0, "carbs": 39, "protein": 0, "sugar": 39, "fiber": 0, "category": "junk"},
+            "diet soda": {"calories": 0, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "neutral"},
+            "juice": {"calories": 110, "fat": 0, "carbs": 26, "protein": 0, "sugar": 22, "fiber": 0, "category": "neutral"},
+            "water": {"calories": 0, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "coffee": {"calories": 5, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "tea": {"calories": 2, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "milkshake": {"calories": 300, "fat": 10, "carbs": 50, "protein": 9, "sugar": 40, "fiber": 0, "category": "junk"},
+            "smoothie": {"calories": 170, "fat": 2, "carbs": 35, "protein": 5, "sugar": 25, "fiber": 3, "category": "neutral"},
+            "lemonade": {"calories": 120, "fat": 0, "carbs": 32, "protein": 0, "sugar": 28, "fiber": 0, "category": "junk"},
+            "beer": {"calories": 154, "fat": 0, "carbs": 13, "protein": 1, "sugar": 0, "fiber": 0, "category": "junk"},
+            "wine": {"calories": 125, "fat": 0, "carbs": 4, "protein": 0, "sugar": 1, "fiber": 0, "category": "neutral"},
+            "cocktail": {"calories": 210, "fat": 0, "carbs": 22, "protein": 0, "sugar": 20, "fiber": 0, "category": "junk"},
+            "espresso": {"calories": 3, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "cappuccino": {"calories": 80, "fat": 4, "carbs": 8, "protein": 4, "sugar": 6, "fiber": 0, "category": "neutral"},
+            "latte": {"calories": 120, "fat": 6, "carbs": 10, "protein": 6, "sugar": 8, "fiber": 0, "category": "neutral"},
+            
+            # Main dishes
+            "salad": {"calories": 100, "fat": 7, "carbs": 5, "protein": 2, "sugar": 2, "fiber": 2, "category": "healthy"},
+            "pasta": {"calories": 200, "fat": 2, "carbs": 42, "protein": 7, "sugar": 2, "fiber": 2, "category": "neutral"},
+            "steak": {"calories": 300, "fat": 15, "carbs": 0, "protein": 30, "sugar": 0, "fiber": 0, "category": "protein"},
+            "chicken": {"calories": 220, "fat": 8, "carbs": 0, "protein": 40, "sugar": 0, "fiber": 0, "category": "protein"},
+            "fish": {"calories": 180, "fat": 5, "carbs": 0, "protein": 30, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "rice": {"calories": 130, "fat": 0, "carbs": 28, "protein": 3, "sugar": 0, "fiber": 0, "category": "neutral"},
+            "noodles": {"calories": 190, "fat": 2, "carbs": 40, "protein": 7, "sugar": 1, "fiber": 2, "category": "neutral"},
+            "sandwich": {"calories": 250, "fat": 8, "carbs": 30, "protein": 15, "sugar": 4, "fiber": 3, "category": "neutral"},
+            "soup": {"calories": 120, "fat": 3, "carbs": 12, "protein": 10, "sugar": 2, "fiber": 2, "category": "healthy"},
+            "burrito": {"calories": 350, "fat": 12, "carbs": 50, "protein": 15, "sugar": 3, "fiber": 6, "category": "neutral"},
+            "taco": {"calories": 210, "fat": 10, "carbs": 22, "protein": 12, "sugar": 2, "fiber": 3, "category": "neutral"},
+            "wrap": {"calories": 220, "fat": 5, "carbs": 30, "protein": 13, "sugar": 2, "fiber": 2, "category": "neutral"},
+            "sushi": {"calories": 350, "fat": 10, "carbs": 60, "protein": 24, "sugar": 4, "fiber": 2, "category": "healthy"},
+            "curry": {"calories": 400, "fat": 20, "carbs": 35, "protein": 20, "sugar": 6, "fiber": 5, "category": "neutral"},
+            "stir fry": {"calories": 300, "fat": 10, "carbs": 30, "protein": 20, "sugar": 8, "fiber": 5, "category": "healthy"},
+            "lasagna": {"calories": 330, "fat": 15, "carbs": 33, "protein": 18, "sugar": 7, "fiber": 3, "category": "neutral"},
+            "risotto": {"calories": 310, "fat": 10, "carbs": 45, "protein": 8, "sugar": 1, "fiber": 2, "category": "neutral"},
+            "ramen": {"calories": 400, "fat": 15, "carbs": 60, "protein": 10, "sugar": 2, "fiber": 1, "category": "neutral"},
+            "pho": {"calories": 300, "fat": 5, "carbs": 45, "protein": 20, "sugar": 2, "fiber": 2, "category": "healthy"},
+            
+            # Appetizers and sides
+            "appetizer": {"calories": 200, "fat": 12, "carbs": 15, "protein": 8, "sugar": 2, "fiber": 1, "category": "neutral"},
+            "bread": {"calories": 80, "fat": 1, "carbs": 15, "protein": 3, "sugar": 1, "fiber": 1, "category": "neutral"},
+            "garlic bread": {"calories": 150, "fat": 7, "carbs": 18, "protein": 4, "sugar": 1, "fiber": 1, "category": "neutral"},
+            "mashed potatoes": {"calories": 160, "fat": 8, "carbs": 21, "protein": 2, "sugar": 1, "fiber": 2, "category": "neutral"},
+            "baked potato": {"calories": 160, "fat": 0, "carbs": 37, "protein": 4, "sugar": 2, "fiber": 4, "category": "healthy"},
+            "coleslaw": {"calories": 120, "fat": 8, "carbs": 12, "protein": 1, "sugar": 8, "fiber": 2, "category": "neutral"},
+            "corn on the cob": {"calories": 90, "fat": 2, "carbs": 21, "protein": 3, "sugar": 6, "fiber": 2, "category": "healthy"},
+            "green beans": {"calories": 35, "fat": 0, "carbs": 8, "protein": 2, "sugar": 2, "fiber": 4, "category": "healthy"},
+            "brussels sprouts": {"calories": 60, "fat": 2, "carbs": 10, "protein": 4, "sugar": 2, "fiber": 4, "category": "healthy"},
+            "mac and cheese": {"calories": 300, "fat": 15, "carbs": 30, "protein": 12, "sugar": 5, "fiber": 1, "category": "junk"},
+            
+            # Breakfast
+            "eggs": {"calories": 140, "fat": 10, "carbs": 1, "protein": 12, "sugar": 0, "fiber": 0, "category": "protein"},
+            "bacon": {"calories": 150, "fat": 12, "carbs": 0, "protein": 10, "sugar": 0, "fiber": 0, "category": "protein"},
+            "pancakes": {"calories": 250, "fat": 8, "carbs": 40, "protein": 6, "sugar": 12, "fiber": 1, "category": "neutral"},
+            "waffles": {"calories": 280, "fat": 10, "carbs": 42, "protein": 8, "sugar": 15, "fiber": 1, "category": "neutral"},
+            "french toast": {"calories": 260, "fat": 10, "carbs": 30, "protein": 8, "sugar": 10, "fiber": 1, "category": "neutral"},
+            "oatmeal": {"calories": 150, "fat": 3, "carbs": 27, "protein": 5, "sugar": 1, "fiber": 4, "category": "healthy"},
+            "cereal": {"calories": 200, "fat": 2, "carbs": 42, "protein": 5, "sugar": 12, "fiber": 3, "category": "neutral"},
+            "bagel": {"calories": 260, "fat": 2, "carbs": 51, "protein": 10, "sugar": 6, "fiber": 2, "category": "neutral"},
+            "croissant": {"calories": 270, "fat": 14, "carbs": 31, "protein": 5, "sugar": 7, "fiber": 1, "category": "junk"},
+            "muffin": {"calories": 340, "fat": 15, "carbs": 48, "protein": 5, "sugar": 24, "fiber": 2, "category": "junk"},
+            
+            # Desserts
+            "cake": {"calories": 350, "fat": 18, "carbs": 45, "protein": 4, "sugar": 30, "fiber": 1, "category": "junk"},
+            "ice cream": {"calories": 207, "fat": 11, "carbs": 24, "protein": 4, "sugar": 20, "fiber": 0, "category": "junk"},
+            "chocolate": {"calories": 200, "fat": 12, "carbs": 20, "protein": 2, "sugar": 18, "fiber": 1, "category": "junk"},
+            "dessert": {"calories": 280, "fat": 14, "carbs": 35, "protein": 5, "sugar": 25, "fiber": 1, "category": "junk"},
+            "cheesecake": {"calories": 320, "fat": 20, "carbs": 28, "protein": 6, "sugar": 21, "fiber": 0, "category": "junk"},
+            "pie": {"calories": 300, "fat": 14, "carbs": 40, "protein": 3, "sugar": 20, "fiber": 2, "category": "junk"},
+            "brownie": {"calories": 250, "fat": 12, "carbs": 35, "protein": 3, "sugar": 25, "fiber": 1, "category": "junk"},
+            "cookie": {"calories": 150, "fat": 7, "carbs": 20, "protein": 2, "sugar": 12, "fiber": 1, "category": "junk"},
+            "tiramisu": {"calories": 240, "fat": 15, "carbs": 24, "protein": 3, "sugar": 14, "fiber": 0, "category": "junk"},
+            "sorbet": {"calories": 120, "fat": 0, "carbs": 30, "protein": 0, "sugar": 28, "fiber": 0, "category": "junk"},
+            
+            # International
+            "pad thai": {"calories": 400, "fat": 17, "carbs": 50, "protein": 15, "sugar": 8, "fiber": 3, "category": "neutral"},
+            "fried rice": {"calories": 350, "fat": 12, "carbs": 45, "protein": 12, "sugar": 2, "fiber": 2, "category": "neutral"},
+            "biryani": {"calories": 400, "fat": 15, "carbs": 50, "protein": 20, "sugar": 2, "fiber": 3, "category": "neutral"},
+            "falafel": {"calories": 330, "fat": 18, "carbs": 32, "protein": 13, "sugar": 0, "fiber": 5, "category": "healthy"},
+            "hummus": {"calories": 170, "fat": 10, "carbs": 14, "protein": 8, "sugar": 0, "fiber": 6, "category": "healthy"},
+            "gyro": {"calories": 430, "fat": 22, "carbs": 33, "protein": 29, "sugar": 4, "fiber": 2, "category": "neutral"},
+            "enchiladas": {"calories": 380, "fat": 20, "carbs": 32, "protein": 18, "sugar": 3, "fiber": 5, "category": "neutral"},
+            "tandoori chicken": {"calories": 260, "fat": 8, "carbs": 2, "protein": 43, "sugar": 0, "fiber": 0, "category": "protein"},
+            "schnitzel": {"calories": 400, "fat": 22, "carbs": 20, "protein": 30, "sugar": 0, "fiber": 1, "category": "neutral"},
+            "shawarma": {"calories": 450, "fat": 30, "carbs": 26, "protein": 24, "sugar": 2, "fiber": 3, "category": "neutral"},
+            
+            # Common additions
+            "ketchup": {"calories": 15, "fat": 0, "carbs": 4, "protein": 0, "sugar": 3, "fiber": 0, "category": "junk"},
+            "mayonnaise": {"calories": 90, "fat": 10, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "junk"},
+            "mustard": {"calories": 5, "fat": 0, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "neutral"},
+            "butter": {"calories": 100, "fat": 11, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "neutral"},
+            "olive oil": {"calories": 120, "fat": 14, "carbs": 0, "protein": 0, "sugar": 0, "fiber": 0, "category": "healthy"},
+            "dressing": {"calories": 150, "fat": 16, "carbs": 2, "protein": 0, "sugar": 1, "fiber": 0, "category": "junk"},
+            "guacamole": {"calories": 100, "fat": 9, "carbs": 6, "protein": 1, "sugar": 0, "fiber": 4, "category": "healthy"},
+            "cheese": {"calories": 110, "fat": 9, "carbs": 1, "protein": 7, "sugar": 0, "fiber": 0, "category": "neutral"},
+            "sauce": {"calories": 50, "fat": 2, "carbs": 8, "protein": 1, "sugar": 6, "fiber": 0, "category": "neutral"}
+        }
+        
+        # Save the default database to CSV for future use
+        try:
+            df = pd.DataFrame(columns=['food_name', 'calories', 'fat', 'carbs', 'protein', 'sugar', 'fiber', 'category'])
+            for food_name, nutrition in food_data.items():
+                df = df.append({
+                    'food_name': food_name,
+                    'calories': nutrition['calories'],
+                    'fat': nutrition['fat'],
+                    'carbs': nutrition['carbs'],
+                    'protein': nutrition['protein'],
+                    'sugar': nutrition['sugar'],
+                    'fiber': nutrition['fiber'],
+                    'category': nutrition['category']
+                }, ignore_index=True)
+            df.to_csv('nutrition_database.csv', index=False)
+            print("Default nutrition database saved to CSV")
+        except Exception as e:
+            print(f"Warning: Could not save default database to CSV: {e}")
+        
+        return food_data
+    
+    def preprocess_image(self, image):
+        """Preprocess image to improve OCR results"""
+        try:
+            if isinstance(image, str) and (image.startswith('http://') or image.startswith('https://')):
+                response = requests.get(image)
+                img = Image.open(BytesIO(response.content))
+            else:
+                img = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+                
+            # Convert to grayscale
+            img = img.convert('L')
+            
+            # Increase contrast
+            enhancer = ImageEnhance.Contrast(img)
+            img = enhancer.enhance(2.0)
+            
+            # Apply noise reduction
+            img = img.filter(ImageFilter.MedianFilter(size=3))
+            
+            # Binarize (convert to black and white)
+            threshold = 150
+            img = img.point(lambda p: 255 if p > threshold else 0)
+            
+            return img
+        except Exception as e:
+            print(f"Image preprocessing error: {e}")
+            return image
+
+    def extract_text_from_image(self, image):
+        """Extract text from image using OCR with enhanced preprocessing"""
+        try:
+            # Preprocess image
+            img = self.preprocess_image(image)
+            
+            # Run OCR with optimized configuration
+            custom_config = r'--oem 3 --psm 6 -c preserve_interword_spaces=1'
+            text = pytesseract.image_to_string(img, config=custom_config)
+            
+            return text
+        except Exception as e:
+            return f"Error extracting text: {str(e)}"
+
+    def extract_food_items(self, text):
+        """Extract food items from OCR text with enhanced NLP capabilities"""
+        # Split into lines and preprocess
+        lines = text.split('\n')
+        food_items = []
+        
+        # Regular patterns for food items in bills
+        price_pattern = r'\$?\d+\.?\d{0,2}'
+        quantity_pattern = r'^\d+\s*[xX]?\s*'
+        
+        # First pass: Look for items with prices
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Skip lines that look like totals, headers, or payment info
+            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|terminal|merchant|transaction|approved|auth|method|reference|account)', 
+                        line.lower()):
+                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_parts = re.split(price_pattern, line)
+                if item_parts and len(item_parts[0].strip()) > 1:
+                    item_name = item_parts[0].strip()
+                    
+                    # Clean up the item name
+                    cleaned_item = re.sub(quantity_pattern, '', item_name)  # Remove quantities
+                    cleaned_item = re.sub(r'\d+\s*(oz|ml|g|lb|kg)\s*', '', cleaned_item)  # Remove sizes
+                    cleaned_item = re.sub(r'\(\w+\)', '', cleaned_item)  # Remove parentheses
+                    
+                    # Add to food items if it looks valid
+                    if len(cleaned_item.strip()) > 1:
+                        food_items.append(cleaned_item.strip().lower())
+        
+        # Second pass: Use NLP if we couldn't find many food items
+        if len(food_items) < 2 and self.food_classifier:
+            # Extract potential food words from text
+            common_words = []
+            for line in lines:
+                # Extract words that might be food items
+                words = re.findall(r'\b[a-zA-Z]{3,}\b', line.lower())
+                # Filter out common non-food words
+                words = [w for w in words if w not in ['total', 'tax', 'subtotal', 'amount', 'cash', 'credit', 'visa', 'card']]
+                common_words.extend(words)
+            
+            # Use NLP to identify food items
+            if common_words:
+                try:
+                    candidate_foods = list(set(common_words))
+                    food_categories = ["food", "drink", "meal", "dish", "beverage"]
+                    
+                    for item in candidate_foods:
+                        # Skip very short items
+                        if len(item) < 3:
+                            continue
+                            
+                        # Direct match in our database
+                        if item in self.nutrition_data:
+                            if item not in food_items:
+                                food_items.append(item)
+                            continue
+                                
+                        # Use classifier to determine if it's food
+                        result = self.food_classifier(item, food_categories)
+                        if result["scores"][0] > 0.7:  # High confidence
+                            food_items.append(item)
+                except Exception as e:
+                    print(f"Error in NLP food identification: {e}")
+        
+        # Remove duplicates and return
+        return list(set(food_items))
+
+    def match_food_to_nutrition(self, food_items):
+        """Match extracted food items to nutrition database with improved fuzzy matching"""
+        matched_items = []
+        unmatched_items = []
+        
+        for item in food_items:
+            # 1. Direct match
+            if item in self.nutrition_data:
+                matched_items.append({"name": item, "nutrition": self.nutrition_data[item]})
+                continue
+            
+            # 2. Check for exact word matches
+            item_words = set(item.split())
+            exact_match = False
+            
+            for db_food in self.nutrition_data:
+                db_words = set(db_food.split())
+                # If all words in database item are in our item
+                if db_words.issubset(item_words) and len(db_words) > 0:
+                    matched_items.append({"name": item, "matched_as": db_food, "nutrition": self.nutrition_data[db_food]})
+                    exact_match = True
+                    break
+            
+            if exact_match:
+                continue
+                
+            # 3. Partial fuzzy matching
+            best_match = None
+            max_score = 0
+            
+            for db_food in self.nutrition_data:
+                # Check if one is contained in the other
+                if db_food in item or item in db_food:
+                    # Calculate word overlap score
+                    db_words = set(db_food.split())
+                    item_words = set(item.split())
+                    intersection = len(item_words.intersection(db_words))
+                    
+                    # Score based on word overlap and length similarity
+                    overlap = intersection / max(len(item_words), len(db_words))
+                    length_sim = min(len(item), len(db_food)) / max(len(item), len(db_food))
+                    score = (overlap * 0.7) + (length_sim * 0.3)
+                    
+                    if score > max_score and score > 0.3:  # Threshold for match quality
+                        max_score = score
+                        best_match = db_food
+            
+            if best_match:
+                matched_items.append({"name": item, "matched_as": best_match, "nutrition": self.nutrition_data[best_match], "confidence": max_score})
+            else:
+                unmatched_items.append(item)
+        
+        # Return both matched and unmatched for potential manual entry
+        return matched_items, unmatched_items
+
+    def calculate_nutrition_and_health_score(self, matched_items):
+        """Calculate nutritional totals and health score with improved metrics"""
+        if not matched_items:
+            return {
+                "total_calories": 0,
+                "total_fat": 0,
+                "total_carbs": 0,
+                "total_protein": 0,
+                "total_sugar": 0,
+                "total_fiber": 0,
+                "health_score": 0,
+                "health_assessment": "No food items detected",
+                "items": []
+            }
+        
+        # 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)
+        total_sugar = sum(item["nutrition"]["sugar"] for item in matched_items)
+        total_fiber = sum(item["nutrition"]["fiber"] for item in matched_items)
+        
+        # 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)
+        total_items = len(matched_items)
+        
+        # Base health score from food categories
+        health_score = 0
+        if total_items > 0:
+            health_score += (category_counts["healthy"] / total_items) * 35
+            health_score += (category_counts["protein"] / total_items) * 30
+            health_score += (category_counts["neutral"] / total_items) * 20
+        
+        # Adjust for macronutrient balance
+        if total_calories > 0:
+            # Protein should be ~25% of calories (4 calories per gram)
+            protein_calories = total_protein * 4
+            protein_percentage = protein_calories / total_calories
+            if protein_percentage > 0.2:
+                health_score += 10
+            
+            # Fat shouldn't be more than 35% of calories (9 calories per gram)
+            fat_calories = total_fat * 9
+            fat_percentage = fat_calories / total_calories
+            if fat_percentage < 0.35:
+                health_score += 8
+            else:
+                health_score -= 10
+                
+            # Sugar should be limited
+            sugar_calories = total_sugar * 4
+            sugar_percentage = sugar_calories / total_calories
+            if sugar_percentage < 0.1:  # Less than 10% from sugar
+                health_score += 7
+            else:
+                health_score -= 7
+                
+            # Fiber is good
+            if total_fiber > 5:
+                health_score += 5
+        
+        # Apply a balanced meal bonus if there's variety
+        if len(set(categories)) >= 3 and category_counts["junk"] < total_items / 2:
+            health_score += 10
+        
+        # Cap between 0-100
+        health_score = max(0, min(100, health_score))
+        
+        # Generate health assessment
+        if health_score > 80:
+            assessment = f"Excellent! Your meal of {total_calories} calories is very well-balanced with great nutritional choices."
+        elif health_score > 60:
+            assessment = f"Good job! Your meal of {total_calories} calories is generally balanced with decent nutritional value."
+        elif health_score > 40:
+            assessment = f"Average meal. Your {total_calories} calories could be better balanced for optimal nutrition."
+        elif health_score > 20:
+            assessment = f"Caution - you consumed approximately {total_calories} calories with too much emphasis on less healthy options."
+        else:
+            assessment = f"Warning - your meal totaling {total_calories} calories is primarily composed of unhealthy items. Consider healthier choices next time."
+        
+        # Prepare detailed items list
+        items_details = []
+        for item in matched_items:
+            name = item["name"]
+            if "matched_as" in item:
+                confidence = item.get("confidence", 1.0)
+                confidence_str = f" - {int(confidence*100)}% match" if confidence < 0.95 else ""
+                name = f"{name} (matched as {item['matched_as']}{confidence_str})"
+            
+            items_details.append({
+                "name": name,
+                "calories": item["nutrition"]["calories"],
+                "fat": item["nutrition"]["fat"],
+                "carbs": item["nutrition"]["carbs"],
+                "protein": item["nutrition"]["protein"],
+                "sugar": item["nutrition"].get("sugar", 0),
+                "fiber": item["nutrition"].get("fiber", 0),
+                "category": item["nutrition"]["category"]
+            })
+        
+        # Return comprehensive results
+        return {
+            "total_calories": total_calories,
+            "total_fat": total_fat,
+            "total_carbs": total_carbs,
+            "total_protein": total_protein,
+            "total_sugar": total_sugar,
+            "total_fiber": total_fiber,
+            "health_score": round(health_score, 1),
+            "health_assessment": assessment,
+            "items": items_details
+        }
+
+    def generate_nutritional_charts(self, nutrition_results):
+        """Generate charts for nutritional breakdown"""
+        try:
+            # Create a figure with subplots
+            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+            
+            # Macronutrient distribution pie chart
+            if nutrition_results["total_calories"] > 0:
+                # Calculate macronutrient percentages
+                protein_cals = nutrition_results["total_protein"] * 4
+                carbs_cals = nutrition_results["total_carbs"] * 4
+                fat_cals = nutrition_results["total_fat"] * 9
+                
+                labels = ['Protein', 'Carbs', 'Fat']
+                sizes = [protein_cals, carbs_cals, fat_cals]
+                colors = ['#66c2a5', '#fc8d62', '#8da0cb']
+                
+                ax1.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90)
+                ax1.set_title('Macronutrient Distribution')
+                
+            # Category distribution bar chart
+            categories = {}
+            for item in nutrition_results["items"]:
+                cat = item["category"].title()
+                categories[cat] = categories.get(cat, 0) + item["calories"]
+            
+            cat_names = list(categories.keys())
+            cat_values = list(categories.values())
+            
+            colors = {'Healthy': '#5cb85c', 'Protein': '#5bc0de', 'Neutral': '#f0ad4e', 'Junk': '#d9534f'}
+            bar_colors = [colors.get(cat, '#777777') for cat in cat_names]
+            
+            ax2.bar(cat_names, cat_values, color=bar_colors)
+            ax2.set_title('Calories by Food Category')
+            ax2.set_ylabel('Calories')
+            plt.xticks(rotation=45)
+            
+            plt.tight_layout()
+            
+            # Save chart to bytes
+            chart_bytes = BytesIO()
+            plt.savefig(chart_bytes, format='png', dpi=100)
+            plt.close(fig)
+            chart_bytes.seek(0)
+            
+            # Convert to base64 for embedding in HTML
+            chart_base64 = base64.b64encode(chart_bytes.read()).decode('utf-8')
+            
+            return chart_base64
+        except Exception as e:
+            print(f"Error generating charts: {e}")
+            return None
+
+    def format_results(self, nutrition_results, unmatched_items=None, chart_base64=None):
+        """Format results into a readable summary with enhanced design"""
+        if not nutrition_results["items"]:
+            return "No food items were detected in the bill. Please try a clearer image or manually enter food items."
+        
+        # Start with CSS for better styling
+        result = """
+        <style>
+        .nutrition-container {
+            font-family: Arial, sans-serif;
+            max-width: 900px;
+            margin: 0 auto;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 0 10px rgba(0,0,0,0.1);
+            background-color: #f9f9f9;
+        }
+        .score-container {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        .score-circle {
+            display: inline-block;
+            width: 100px;
+            height: 100px;
+            line-height: 100px;
+            border-radius: 50%;
+            font-size: 32px;
+            color: white;
+            text-align: center;
+            margin: 20px;
+            font-weight: bold;
+        }
+        .assessment {
+            font-size: 18px;
+            margin: 15px 0;
+            padding: 10px;
+            border-radius: 5px;
+            background-color: #f0f0f0;
+        }
+        .macro-section {
+            display: flex;
+            justify-content: space-around;
+            flex-wrap: wrap;
+            margin: 20px 0;
+        }
+        .macro-box {
+            text-align: center;
+            width: 18%;
+            min-width: 120px;
+            margin: 10px;
+            padding: 15px;
+            border-radius: 8px;
+            box-shadow: 0 0 5px rgba(0,0,0,0.1);
+        }
+        .macro-title {
+            font-size: 14px;
+            text-transform: uppercase;
+            color: #666;
+        }
+        .macro-value {
+            font-size: 24px;
+            font-weight: bold;
+        }
+        .items-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin: 20px 0;
+        }
+        .items-table th, .items-table td {
+            padding: 10px;
+            text-align: left;
+            border-bottom: 1px solid #ddd;
+        }
+        .items-table th {
+            background-color: #f2f2f2;
+        }
+        .category-healthy {
+            color: #5cb85c;
+        }
+        .category-protein {
+            color: #5bc0de;
+        }
+        .category-neutral {
+            color: #f0ad4e;
+        }
+        .category-junk {
+            color: #d9534f;
+        }
+        .chart-container {
+            margin: 20px 0;
+            text-align: center;
+        }
+        .recommendations {
+            background-color: #e9f7ef;
+            padding: 15px;
+            border-left: 5px solid #27ae60;
+            margin: 20px 0;
+        }
+        </style>
+        """
+        
+        # Determine health score color
+        score = nutrition_results["health_score"]
+        if score > 80:
+            score_color = "#5cb85c"  # Green
+        elif score > 60:
+            score_color = "#5bc0de"  # Blue
+        elif score > 40:
+            score_color = "#f0ad4e"  # Orange
+        elif score > 20:
+            score_color = "#ff7f0e"  # Dark orange
+        else:
+            score_color = "#d9534f"  # Red
+        
+        # Main container
+        result += '<div class="nutrition-container">'
+        
+        # Header
+        result += '<h1 style="text-align:center;">Nutritional Analysis Report</h1>'
+        
+        # Health score
+        result += f'''
+        <div class="score-container">
+            <h2>Health Score</h2>
+            <div class="score-circle" style="background-color: {score_color};">{nutrition_results["health_score"]}</div>
+            <div class="assessment">{nutrition_results["health_assessment"]}</div>
+        </div>
+        '''
+        
+        # Insert chart if available
+        if chart_base64:
+            result += f'''
+            <div class="chart-container">
+                <h2>Nutritional Breakdown</h2>
+                <img src="data:image/png;base64,{chart_base64}" style="max-width:100%; height:auto;" alt="Nutritional Chart">
+            </div>
+            '''
+        
+        # Macronutrient summary
+        result += '''
+        <h2>Nutritional Summary</h2>
+        <div class="macro-section">
+        '''
+        
+        # Add macro boxes
+        result += f'''
+            <div class="macro-box" style="background-color: #f9f0ff;">
+                <div class="macro-title">Calories</div>
+                <div class="macro-value">{nutrition_results["total_calories"]}</div>
+                <div>kcal</div>
+            </div>
+            <div class="macro-box" style="background-color: #fff0f0;">
+                <div class="macro-title">Fat</div>
+                <div class="macro-value">{nutrition_results["total_fat"]}</div>
+                <div>grams</div>
+            </div>
+            <div class="macro-box" style="background-color: #fff9f0;">
+                <div class="macro-title">Carbs</div>
+                <div class="macro-value">{nutrition_results["total_carbs"]}</div>
+                <div>grams</div>
+            </div>
+            <div class="macro-box" style="background-color: #f0f9ff;">
+                <div class="macro-title">Protein</div>
+                <div class="macro-value">{nutrition_results["total_protein"]}</div>
+                <div>grams</div>
+            </div>
+            <div class="macro-box" style="background-color: #f0fff9;">
+                <div class="macro-title">Sugar</div>
+                <div class="macro-value">{nutrition_results["total_sugar"]}</div>
+                <div>grams</div>
+            </div>
+        </div>
+        '''
+        
+        # Food items table
+        result += '''
+        <h2>Detected Food Items</h2>
+        <div style="overflow-x:auto;">
+        <table class="items-table">
+            <tr>
+                <th>Item</th>
+                <th>Calories</th>
+                <th>Fat (g)</th>
+                <th>Carbs (g)</th>
+                <th>Protein (g)</th>
+                <th>Category</th>
+            </tr>
+        '''
+        
+        # Add items to table
+        for item in nutrition_results["items"]:
+            category_class = f"category-{item['category']}"
+            result += f'''
+            <tr>
+                <td>{html.escape(item['name']).title()}</td>
+                <td>{item['calories']}</td>
+                <td>{item['fat']}</td>
+                <td>{item['carbs']}</td>
+                <td>{item['protein']}</td>
+                <td class="{category_class}">{item['category'].title()}</td>
+            </tr>
+            '''
+        
+        result += '</table></div>'
+        
+        # Show unmatched items if any
+        if unmatched_items and len(unmatched_items) > 0:
+            result += f'''
+            <div style="margin: 20px 0; padding: 10px; background-color: #fff3cd; border-left: 5px solid #ffc107;">
+                <h3>Unrecognized Items</h3>
+                <p>The following items could not be matched to our nutrition database:</p>
+                <ul>{"".join([f"<li>{item}</li>" for item in unmatched_items])}</ul>
+            </div>
+            '''
+        
+        # Recommendations
+        result += '<div class="recommendations"><h2>Recommendations</h2><ul>'
+        
+        # Calculate macronutrient percentages
+        total_calories = nutrition_results['total_calories']
+        if total_calories > 0:
+            fat_percentage = (nutrition_results['total_fat'] * 9 / total_calories) * 100
+            carbs_percentage = (nutrition_results['total_carbs'] * 4 / total_calories) * 100
+            protein_percentage = (nutrition_results['total_protein'] * 4 / total_calories) * 100
+            sugar_percentage = (nutrition_results['total_sugar'] * 4 / total_calories) * 100
+            
+            # Make recommendations based on the composition
+            if protein_percentage < 15:
+                result += "<li>Your meal is low in protein. Consider adding lean protein sources like chicken, fish, tofu, or legumes to your next meal.</li>"
+            if fat_percentage > 35:
+                result += "<li>Your meal is high in fat. Try reducing fried foods and opting for leaner protein sources and cooking methods.</li>"
+            if carbs_percentage > 60:
+                result += "<li>Your meal is high in carbohydrates. Consider balancing with more vegetables and protein in your next meal.</li>"
+            if sugar_percentage > 15:
+                result += "<li>Your meal contains a high amount of sugar. Try to reduce sugary drinks and desserts.</li>"
+            if nutrition_results['total_fiber'] < 5:
+                result += "<li>Consider adding more fiber to your diet through whole grains, fruits, and vegetables.</li>"
+            
+            # Check total calories
+            if total_calories > 1000 and len(nutrition_results["items"]) <= 2:
+                result += "<li>This meal is high in calories for the number of items. Consider portion control or lighter options.</li>"
+        
+        # If no specific recommendations, add a general one
+        if "<li>" not in result:
+            result += "<li>Your meal is well-balanced! Keep up the good choices and maintain this eating pattern.</li>"
+        
+        result += '</ul></div>'
+        
+        # Close container
+        result += '</div>'
+        
+        return result
+
+    def analyze_restaurant_bill(self, image, manual_items=None):
+        """Main function to process the bill image and return nutritional analysis"""
+        start_time = datetime.now()
+        
+        # Initialize result
+        result = {"status": "processing"}
+        food_items = []
+        
+        # Process image if provided
+        if image is not None:
+            # Extract text from image using OCR
+            text = self.extract_text_from_image(image)
+            if text.startswith("Error"):
+                return f"OCR failed: {text}"
+            
+            # Extract food items from the text
+            food_items = self.extract_food_items(text)
+        
+        # Add manually entered items if provided
+        if manual_items and isinstance(manual_items, str) and len(manual_items.strip()) > 0:
+            manual_list = [item.strip().lower() for item in manual_items.split(',')]
+            food_items.extend(manual_list)
+        
+        # Remove duplicates
+        food_items = list(set(food_items))
+        
+        if not food_items:
+            return "No food items detected in the bill. Please try a clearer image or manually enter food items."
+        
+        # Match food items to nutrition database
+        matched_items, unmatched_items = self.match_food_to_nutrition(food_items)
+        
+        # Calculate nutritional information and health score
+        nutrition_results = self.calculate_nutrition_and_health_score(matched_items)
+        
+        # Generate charts
+        chart_base64 = self.generate_nutritional_charts(nutrition_results)
+        
+        # Format the results
+        formatted_results = self.format_results(nutrition_results, unmatched_items, chart_base64)
+        
+        # Add to history (keep last 10 analyses)
+        self.history.append({
+            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            'food_items': food_items,
+            'nutrition_results': nutrition_results
+        })
+        if len(self.history) > 10:
+            self.history.pop(0)
+        
+        # Log processing time
+        processing_time = (datetime.now() - start_time).total_seconds()
+        print(f"Analysis completed in {processing_time:.2f} seconds")
+        
+        return formatted_results
+    
+    def save_to_csv(self, file_path="nutrition_history.csv"):
+        """Save analysis history to CSV"""
+        try:
+            with open(file_path, 'w', newline='') as csvfile:
+                fieldnames = ['timestamp', 'total_calories', 'total_fat', 'total_carbs', 'total_protein', 'health_score', 'items']
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                
+                for entry in self.history:
+                    writer.writerow({
+                        'timestamp': entry['timestamp'],
+                        'total_calories': entry['nutrition_results']['total_calories'],
+                        'total_fat': entry['nutrition_results']['total_fat'],
+                        'total_carbs': entry['nutrition_results']['total_carbs'],
+                        'total_protein': entry['nutrition_results']['total_protein'],
+                        'health_score': entry['nutrition_results']['health_score'],
+                        'items': ', '.join([item['name'] for item in entry['nutrition_results']['items']])
+                    })
+                return True
+        except Exception as e:
+            print(f"Error saving to CSV: {e}")
+            return False
+
+# Initialize the analyzer
+analyzer = NutritionAnalyzer()
+
+# Define Gradio interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧾 Advanced Restaurant Bill Nutritional Analyzer 🍽️
+    
+    **Upload a photo of your restaurant bill to analyze the nutritional content and get a detailed health score.**
+    
+    This AI-powered tool uses OCR to read your bill, identifies food items, and provides nutritional analysis and recommendations.
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("Bill Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    input_image = gr.Image(type="pil", label="Upload Bill Image")
+                    manual_items = gr.Textbox(label="Manually Add Items (comma separated)", placeholder="burger, fries, soda")
+                    analyze_button = gr.Button("Analyze Nutrition", variant="primary")
+                    
+                    with gr.Accordion("Advanced Options", open=False):
+                        feedback = gr.Textbox(label="Give Feedback About Results", placeholder="The analysis was accurate and helpful.")
+                        submit_feedback = gr.Button("Submit Feedback")
+                
+                with gr.Column(scale=2):
+                    output_html = gr.HTML(label="Nutritional Analysis")
+                    
+                    with gr.Row():
+                        save_button = gr.Button("Save Analysis")
+                        clear_button = gr.Button("Clear")
+        
+        with gr.TabItem("History"):
+            history_html = gr.HTML("<p>Your analysis history will appear here.</p>")
+            refresh_history = gr.Button("Refresh History")
+        
+        with gr.TabItem("Help"):
+            gr.Markdown("""
+            ## How to use this tool
+            
+            1. **Upload a photo** of your restaurant bill or receipt
+            2. Optionally **manually add food items** that might be missed
+            3. Click **Analyze Nutrition** to get your results
+            4. Save your analysis if you want to track it
+            
+            ## Tips for best results
+            
+            - Ensure your bill is clearly visible and well-lit
+            - Take the photo straight-on with minimal glare
+            - Make sure food item names are readable
+            - Crop unnecessary parts of the image
+            - If items are missed, add them manually in the text box
+            
+            ## What you'll get
+            
+            - Detailed health score and assessment
+            - Complete nutritional breakdown (calories, macros, etc.)
+            - Visual charts showing your meal composition
+            - Personalized recommendations for better nutrition
+            - History tracking for your previous analyses
+            
+            ## About the food categories
+            
+            - **Healthy**: Nutrient-dense foods with health benefits
+            - **Protein**: High-protein foods that support muscle maintenance
+            - **Neutral**: Balanced foods that can fit in a healthy diet
+            - **Junk**: High-calorie, low-nutrient foods to limit
+            
+            ## Disclaimer
+            
+            This tool provides an estimate only. Actual nutritional content may vary based on specific recipes and preparation methods. It is not intended as medical advice.
+            """)
+    
+    # Handle button clicks
+    analyze_button.click(
+        fn=analyzer.analyze_restaurant_bill,
+        inputs=[input_image, manual_items],
+        outputs=[output_html]
+    )
+    
+    clear_button.click(
+        fn=lambda: (None, ""),
+        inputs=[],
+        outputs=[input_image, manual_items]
+    )
+    
+    def process_feedback(feedback_text):
+        """Process user feedback"""
+        if analyzer.sentiment_analyzer and feedback_text:
+            try:
+                sentiment = analyzer.sentiment_analyzer(feedback_text)
+                feedback_type = sentiment[0]['label']
+                confidence = sentiment[0]['score']
+                
+                # Log feedback
+                print(f"Feedback received: {feedback_text}")
+                print(f"Sentiment: {feedback_type} (confidence: {confidence:.2f})")
+                
+                return f"Thank you for your feedback! We've recorded your {feedback_type.lower()} comments."
+            except Exception as e:
+                print(f"Error processing feedback: {e}")
+                return "Thank you for your feedback!"
+        return "Thank you for your feedback!"
+    
+    submit_feedback.click(
+        fn=process_feedback,
+        inputs=[feedback],
+        outputs=[gr.Textbox(label="Feedback Status")]
+    )
+    
+    def format_history():
+        """Format history as HTML"""
+        if not analyzer.history:
+            return "<p>No analysis history found.</p>"
+        
+        html = """
+        <style>
+        .history-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 20px;
+        }
+        .history-table th, .history-table td {
+            border: 1px solid #ddd;
+            padding: 8px;
+            text-align: left;
+        }
+        .history-table th {
+            background-color: #f2f2f2;
+        }
+        .history-table tr:nth-child(even) {
+            background-color: #f9f9f9;
+        }
+        .history-table tr:hover {
+            background-color: #f1f1f1;
+        }
+        </style>
+        <h2>Analysis History</h2>
+        <table class="history-table">
+            <tr>
+                <th>Date & Time</th>
+                <th>Calories</th>
+                <th>Fat (g)</th>
+                <th>Carbs (g)</th>
+                <th>Protein (g)</th>
+                <th>Health Score</th>
+                <th>Items</th>
+            </tr>
+        """
+        
+        for entry in reversed(analyzer.history):
+            results = entry['nutrition_results']
+            items_text = ", ".join([item['name'] for item in results['items']])
+            
+            html += f"""
+            <tr>
+                <td>{entry['timestamp']}</td>
+                <td>{results['total_calories']}</td>
+                <td>{results['total_fat']}</td>
+                <td>{results['total_carbs']}</td>
+                <td>{results['total_protein']}</td>
+                <td>{results['health_score']}</td>
+                <td>{items_text}</td>
+            </tr>
+            """
+        
+        html += "</table>"
+        
+        # Add a simple chart of health scores over time
+        if len(analyzer.history) > 1:
+            html += """
+            <h3>Health Score Trend</h3>
+            <div style="padding: 20px; background-color: #f9f9f9; border-radius: 5px;">
+                <svg width="600" height="200" style="background-color: white; border: 1px solid #ddd;">
+            """
+            
+            # Extract dates and scores
+            dates = [entry['timestamp'].split()[0] for entry in analyzer.history]
+            scores = [entry['nutrition_results']['health_score'] for entry in analyzer.history]
+            
+            # Simple SVG line chart
+            max_score = 100
+            width = 580
+            height = 180
+            margin = 40
+            
+            # X axis
+            x_step = (width - 2 * margin) / (len(dates) - 1) if len(dates) > 1 else 0
+            
+            # Create points for the polyline
+            points = []
+            for i, score in enumerate(scores):
+                x = margin + i * x_step
+                y = height - margin - (score / max_score * (height - 2 * margin))
+                points.append(f"{x},{y}")
+            
+            # Draw x and y axes
+            html += f'<line x1="{margin}" y1="{height-margin}" x2="{width-margin}" y2="{height-margin}" stroke="black" />'
+            html += f'<line x1="{margin}" y1="{margin}" x2="{margin}" y2="{height-margin}" stroke="black" />'
+            
+            # Draw the line
+            html += f'<polyline points="{" ".join(points)}" fill="none" stroke="#5bc0de" stroke-width="2" />'
+            
+            # Add dots at data points
+            for i, point in enumerate(points):
+                x, y = point.split(',')
+                html += f'<circle cx="{x}" cy="{y}" r="4" fill="#5bc0de" />'
+                # Add tooltip
+                html += f'<title>Date: {dates[i]}, Score: {scores[i]}</title>'
+            
+            html += """
+                </svg>
+            </div>
+            """
+        
+        return html
+    
+    refresh_history.click(
+        fn=format_history,
+        inputs=[],
+        outputs=[history_html]
+    )
+    
+    save_button.click(
+        fn=lambda: "Analysis saved to history" if analyzer.history else "No analysis to save",
+        inputs=[],
+        outputs=[gr.Textbox(label="Save Status")]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    try:
+        # Load the pre-trained models
+        print("Initializing the application...")
+        
+        # Launch Gradio app
+        demo.launch()
+    except Exception as e:
+        print(f"Error launching application: {e}")