import os import subprocess import sys import re import numpy as np from PIL import Image import gradio as gr import requests import json from dotenv import load_dotenv # Attempt to install pytesseract if not found try: import pytesseract except ImportError: subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pytesseract']) import pytesseract # AFTER importing pytesseract, then set the path try: # First try the default path if os.path.exists('/usr/bin/tesseract'): pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract' # Try to find it on the PATH else: tesseract_path = subprocess.check_output(['which', 'tesseract']).decode().strip() if tesseract_path: pytesseract.pytesseract.tesseract_cmd = tesseract_path except: # If all else fails, try the default installation path pytesseract.pytesseract.tesseract_cmd = 'tesseract' # Load environment variables load_dotenv() # Import and configure Gemini API try: import google.generativeai as genai # Configure Gemini API GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") if GEMINI_API_KEY: genai.configure(api_key=GEMINI_API_KEY) except ImportError: print("Google Generative AI package not found, using dummy implementation") genai = None # Function to extract text from images using OCR def extract_text_from_image(image): try: if image is None: return "No image captured. Please try again." # Verify Tesseract executable is accessible try: subprocess.run([pytesseract.pytesseract.tesseract_cmd, "--version"], check=True, capture_output=True, text=True) except (subprocess.SubprocessError, FileNotFoundError): return "Tesseract OCR is not installed or not properly configured. Please check installation." # Image preprocessing for better OCR import cv2 import numpy as np # Convert PIL image to OpenCV format img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR) # Convert to grayscale gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) # Apply thresholding to get black and white image _, binary = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) # Noise removal kernel = np.ones((1, 1), np.uint8) binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel) # Dilate to connect text binary = cv2.dilate(binary, kernel, iterations=1) # Convert back to PIL image for tesseract binary_pil = Image.fromarray(cv2.bitwise_not(binary)) # Run OCR with improved configuration custom_config = r'--oem 3 --psm 6 -l eng' text = pytesseract.image_to_string(binary_pil, config=custom_config) if not text.strip(): # Try original image as fallback text = pytesseract.image_to_string(image, config=custom_config) if not text.strip(): return "No text could be extracted. Ensure image is clear and readable." return text except Exception as e: return f"Error extracting text: {str(e)}" # Function to parse ingredients from text def parse_ingredients(text): if not text: return [] # Clean up the text text = re.sub(r'^ingredients:?\s*', '', text.lower(), flags=re.IGNORECASE) # Remove common OCR errors and extraneous characters text = re.sub(r'[|\\/@#$%^&*()_+=]', '', text) # Replace common OCR errors text = re.sub(r'\bngredients\b', 'ingredients', text) # Handle common OCR misreads replacements = { '0': 'o', 'l': 'i', '1': 'i', '5': 's', '8': 'b', 'Q': 'g', } for error, correction in replacements.items(): text = text.replace(error, correction) # Split by common ingredient separators ingredients = re.split(r',|;|\n', text) # Clean up each ingredient cleaned_ingredients = [] for i in ingredients: i = i.strip().lower() if i and len(i) > 1: # Ignore single characters which are likely OCR errors cleaned_ingredients.append(i) return cleaned_ingredients # Function to analyze ingredients with Gemini # Function to analyze ingredients with Gemini def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None): """ Use Gemini to analyze ingredients and provide health insights """ if not ingredients_list: return "No ingredients detected or provided." # Prepare the list of ingredients for the prompt ingredients_text = ", ".join(ingredients_list) # Check if Gemini API is available if not genai or not os.getenv("GEMINI_API_KEY"): return dummy_analyze(ingredients_list, health_conditions) # Create a prompt for Gemini if health_conditions and health_conditions.strip(): prompt = f""" Analyze the following food ingredients for a person with these health conditions: {health_conditions} Ingredients: {ingredients_text} For each ingredient: 1. Provide its potential health benefits 2. Identify any potential risks 3. Note if it may affect the specified health conditions Then provide an overall assessment of the product's suitability for someone with the specified health conditions. Format your response in markdown with clear headings and sections. """ else: prompt = f""" Analyze the following food ingredients: Ingredients: {ingredients_text} For each ingredient: 1. Provide its potential health benefits 2. Identify any potential risks or common allergens associated with it Then provide an overall assessment of the product's general health profile. Format your response in markdown with clear headings and sections. """ try: # First, check available models try: models = genai.list_models() available_models = [m.name for m in models] # Try models in order of preference model_names = ['gemini-pro', 'gemini-1.5-pro', 'gemini-1.0-pro'] # Find first available model from our preference list model_name = None for name in model_names: if any(name in m for m in available_models): model_name = name break # If none of our preferred models are available, use the first available model if not model_name and available_models: model_name = available_models[0] if not model_name: return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: No available models found)" model = genai.GenerativeModel(model_name) response = model.generate_content(prompt) # Check if response is valid if hasattr(response, 'text') and response.text: analysis = response.text else: return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: Empty API response)" except Exception as e: return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})" # Add disclaimer disclaimer = """ ## Disclaimer This analysis is provided for informational purposes only and should not replace professional medical advice. Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions. """ return analysis + disclaimer except Exception as e: # Fallback to basic analysis if API call fails return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})" # Dummy analysis function for when API is not available def dummy_analyze(ingredients_list, health_conditions=None): ingredients_text = ", ".join(ingredients_list) report = f""" # Ingredient Analysis Report ## Detected Ingredients {", ".join([i.title() for i in ingredients_list])} ## Overview This is a simulated analysis since no API key was provided. In the actual application, the ingredients would be analyzed by an LLM for their health implications. ## Health Considerations """ if health_conditions: report += f""" The analysis would specifically consider these health concerns: {health_conditions} """ else: report += """ No specific health concerns were provided, so a general analysis would be performed. """ report += """ ## Disclaimer This analysis is provided for informational purposes only and should not replace professional medical advice. Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions. """ return report # Function to process input based on method (camera, upload, or manual entry) def process_input(input_method, text_input, camera_input, upload_input, health_conditions): if input_method == "Camera": if camera_input is not None: extracted_text = extract_text_from_image(camera_input) # If OCR fails, inform the user they can try manual entry if "Error" in extracted_text or "No text could be extracted" in extracted_text: return extracted_text + "\n\nPlease try using the 'Manual Entry' option instead." ingredients = parse_ingredients(extracted_text) return analyze_ingredients_with_gemini(ingredients, health_conditions) else: return "No camera image captured. Please try again." elif input_method == "Image Upload": if upload_input is not None: extracted_text = extract_text_from_image(upload_input) # If OCR fails, inform the user they can try manual entry if "Error" in extracted_text or "No text could be extracted" in extracted_text: return extracted_text + "\n\nPlease try using the 'Manual Entry' option instead." ingredients = parse_ingredients(extracted_text) return analyze_ingredients_with_gemini(ingredients, health_conditions) else: return "No image uploaded. Please try again." elif input_method == "Manual Entry": if text_input and text_input.strip(): ingredients = parse_ingredients(text_input) return analyze_ingredients_with_gemini(ingredients, health_conditions) else: return "No ingredients entered. Please try again." return "Please provide input using one of the available methods." # Create the Gradio interface with gr.Blocks(title="AI Ingredient Scanner") as app: gr.Markdown("# AI Ingredient Scanner") gr.Markdown("Scan product ingredients and analyze them for health benefits, risks, and potential allergens.") with gr.Row(): with gr.Column(): input_method = gr.Radio( ["Camera", "Image Upload", "Manual Entry"], label="Input Method", value="Camera" ) # Camera input camera_input = gr.Image(label="Capture ingredients with camera", type="pil", visible=True) # Image upload upload_input = gr.Image(label="Upload image of ingredients label", type="pil", visible=False) # Text input text_input = gr.Textbox( label="Enter ingredients list (comma separated)", placeholder="milk, sugar, flour, eggs, vanilla extract", lines=3, visible=False ) # Health conditions input - now optional and more flexible health_conditions = gr.Textbox( label="Enter your health concerns (optional)", placeholder="diabetes, high blood pressure, peanut allergy, etc.", lines=2, info="The AI will automatically analyze ingredients for these conditions" ) analyze_button = gr.Button("Analyze Ingredients") with gr.Column(): output = gr.Markdown(label="Analysis Results") extracted_text_output = gr.Textbox(label="Extracted Text (for verification)", lines=3) # Show/hide inputs based on selection def update_visible_inputs(choice): return { upload_input: gr.update(visible=(choice == "Image Upload")), camera_input: gr.update(visible=(choice == "Camera")), text_input: gr.update(visible=(choice == "Manual Entry")) } input_method.change(update_visible_inputs, input_method, [upload_input, camera_input, text_input]) # Extract and display the raw text (for verification purposes) def show_extracted_text(input_method, text_input, camera_input, upload_input): if input_method == "Camera" and camera_input is not None: return extract_text_from_image(camera_input) elif input_method == "Image Upload" and upload_input is not None: return extract_text_from_image(upload_input) elif input_method == "Manual Entry": return text_input return "No input detected" # Set up event handlers analyze_button.click( fn=process_input, inputs=[input_method, text_input, camera_input, upload_input, health_conditions], outputs=output ) analyze_button.click( fn=show_extracted_text, inputs=[input_method, text_input, camera_input, upload_input], outputs=extracted_text_output ) gr.Markdown("### How to use") gr.Markdown(""" 1. Choose your input method (Camera, Image Upload, or Manual Entry) 2. Take a photo of the ingredients label or enter ingredients manually 3. Optionally enter your health concerns 4. Click "Analyze Ingredients" to get your personalized analysis The AI will automatically analyze the ingredients, their health implications, and their potential impact on your specific health concerns. """) gr.Markdown("### Examples of what you can ask") gr.Markdown(""" The system can handle a wide range of health concerns, such as: - General health goals: "trying to reduce sugar intake" or "watching sodium levels" - Medical conditions: "diabetes" or "hypertension" - Allergies: "peanut allergy" or "shellfish allergy" - Dietary restrictions: "vegetarian" or "gluten-free diet" - Multiple conditions: "diabetes, high cholesterol, and lactose intolerance" The AI will tailor its analysis to your specific needs. """) gr.Markdown("### Tips for best results") gr.Markdown(""" - Hold the camera steady and ensure good lighting - Focus directly on the ingredients list - Make sure the text is clear and readable - Be specific about your health concerns for more targeted analysis """) gr.Markdown("### Disclaimer") gr.Markdown(""" This tool is for informational purposes only and should not replace professional medical advice. Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions. """) # Launch the app if __name__ == "__main__": app.launch()