Spaces:
Build error
Build error
| 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() | |
| # Mistral API Key | |
| MISTRAL_API_KEY = "GlrVCBWyvTYjWGKl5jqtK4K41uWWJ79F" | |
| # Import and configure Mistral API | |
| def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None): | |
| """ | |
| Use Mistral AI 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) | |
| # Create a prompt for Mistral | |
| 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: | |
| headers = { | |
| "Authorization": f"Bearer {MISTRAL_API_KEY}", | |
| "Content-Type": "application/json" | |
| } | |
| data = { | |
| "model": "mistral-small", # Or another suitable model | |
| "messages": [{"role": "user", "content": prompt}], | |
| "temperature": 0.7, | |
| } | |
| response = requests.post("https://api.mistral.ai/v1/chat/completions", headers=headers, json=data) | |
| if response.status_code == 200: | |
| analysis = response.json()['choices'][0]['message']['content'] | |
| else: | |
| return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: Mistral API Error - {response.status_code} - {response.text})" | |
| # 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 the Mistral API call failed. In the actual application, | |
| the ingredients would be analyzed by Mistral 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 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." | |
| # Import necessary libraries | |
| import cv2 | |
| import numpy as np | |
| from PIL import Image, ImageOps, ImageEnhance | |
| # First approach: Invert the image for light text on dark background | |
| inverted_image = ImageOps.invert(image) | |
| # Try OCR on inverted image | |
| custom_config = r'--oem 3 --psm 6 -l eng --dpi 300' | |
| inverted_text = pytesseract.image_to_string(inverted_image, config=custom_config) | |
| # Second approach: OpenCV processing for colored backgrounds | |
| img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR) | |
| # Convert to grayscale | |
| gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) | |
| # Apply bilateral filter to preserve edges while reducing noise | |
| filtered = cv2.bilateralFilter(gray, 11, 17, 17) | |
| # Adaptive thresholding to handle varied lighting | |
| thresh = cv2.adaptiveThreshold(filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, | |
| cv2.THRESH_BINARY, 11, 2) | |
| # Invert the image (if text is light on dark background) | |
| inverted_thresh = cv2.bitwise_not(thresh) | |
| # Try OCR on processed image | |
| cv_text = pytesseract.image_to_string( | |
| Image.fromarray(inverted_thresh), | |
| config=custom_config | |
| ) | |
| # Third approach: Color filtering to isolate text from colored background | |
| # Convert to HSV color space to better isolate colors | |
| hsv = cv2.cvtColor(img_cv, cv2.COLOR_BGR2HSV) | |
| # Create a mask to extract light colored text (assuming white/light text) | |
| lower_white = np.array([0, 0, 150]) | |
| upper_white = np.array([180, 30, 255]) | |
| mask = cv2.inRange(hsv, lower_white, upper_white) | |
| # Apply morphological operations to clean up the mask | |
| kernel = np.ones((2, 2), np.uint8) | |
| mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) | |
| mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) | |
| # Improve character connectivity | |
| mask = cv2.dilate(mask, kernel, iterations=1) | |
| # Try OCR on color filtered image | |
| color_text = pytesseract.image_to_string( | |
| Image.fromarray(mask), | |
| config=r'--oem 3 --psm 6 -l eng --dpi 300' | |
| ) | |
| # Fourth approach: Try directly with the image but with different configs | |
| direct_text = pytesseract.image_to_string( | |
| image, | |
| config=r'--oem 3 --psm 11 -l eng --dpi 300' | |
| ) | |
| # Compare results and select the best one | |
| results = [inverted_text, cv_text, color_text, direct_text] | |
| # Select the result with the most alphanumeric characters | |
| def count_alphanumeric(text): | |
| return sum(c.isalnum() for c in text) | |
| best_text = max(results, key=count_alphanumeric) | |
| # If still poor results, try with explicit text color inversion in tesseract | |
| if count_alphanumeric(best_text) < 20: | |
| # Try with tesseract's built-in inversion | |
| neg_text = pytesseract.image_to_string( | |
| image, | |
| config=r'--oem 3 --psm 6 -c textord_heavy_nr=1 -c textord_debug_printable=0 -l eng --dpi 300' | |
| ) | |
| if count_alphanumeric(neg_text) > count_alphanumeric(best_text): | |
| best_text = neg_text | |
| # Clean up the text | |
| best_text = re.sub(r'[^\w\s,;:%.()\n\'-]', '', best_text) | |
| best_text = best_text.replace('\n\n', '\n') | |
| # Special case for ingredients list format | |
| if "ingredient" in best_text.lower() or any(x in best_text.lower() for x in ["sugar", "cocoa", "milk", "contain"]): | |
| # Specific cleaning for ingredient lists | |
| best_text = re.sub(r'([a-z])([A-Z])', r'\1 \2', best_text) # Add space between lowercase and uppercase | |
| best_text = re.sub(r'(\d+)([a-zA-Z])', r'\1 \2', best_text) # Add space between number and letter | |
| if not best_text.strip(): | |
| return "No text could be extracted. Ensure image is clear and readable." | |
| return best_text.strip() | |
| 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 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_mistral(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_mistral(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_mistral(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() | |