Update app.py

app.py

@@ -1,198 +1,180 @@
 import gradio as gr
-from transformers import Blip2Processor, Blip2ForConditionalGeneration
-import torch
+import json
 from PIL import Image
-import pandas as pd
+import requests
+from io import BytesIO
 
-# Carregar o modelo BLIP2
-model_name = "Salesforce/blip2-opt-2.7b"
-processor = Blip2Processor.from_pretrained(model_name)
-model = Blip2ForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
-
-# Base de dados nutricional
-NUTRITIONAL_DB = {
-    "arroz": {
-        "calorias": 130,
-        "proteinas": 2.7,
-        "carboidratos": 28,
-        "gorduras": 0.3,
-        "fibras": 0.4,
-        "vitamina_b1": 0.02,
-        "vitamina_b3": 0.4,
-        "ferro": 0.2,
-    },
-    "feijão": {
-        "calorias": 77,
-        "proteinas": 5.2,
-        "carboidratos": 13.6,
-        "gorduras": 0.5,
-        "fibras": 5.4,
-        "ferro": 1.5,
-        "potássio": 255,
-        "magnésio": 42,
-    },
-    "frango": {
-        "calorias": 165,
-        "proteinas": 31,
-        "carboidratos": 0,
-        "gorduras": 3.6,
-        "vitamina_b6": 0.5,
-        "niacina": 13.7,
-        "fósforo": 200,
-    },
-    "salada": {
-        "calorias": 15,
-        "proteinas": 1.4,
-        "carboidratos": 2.9,
-        "gorduras": 0.2,
-        "fibras": 1.3,
-        "vitamina_a": 370,
-        "vitamina_k": 126,
-        "folato": 38,
-    }
-}
-
-def get_food_description(image):
-    """
-    Usa o modelo BLIP2 para analisar a imagem e descrever os alimentos
-    """
-    prompt = "Descreva detalhadamente todos os alimentos visíveis nesta imagem. Liste cada item separadamente."
-    
-    # Processar imagem
-    inputs = processor(image, text=prompt, return_tensors="pt").to(model.device)
-    
-    # Gerar descrição
-    outputs = model.generate(
-        **inputs,
-        max_new_tokens=100,
-        do_sample=False,
-        num_beams=5,
-        temperature=1.0,
-        top_p=0.9,
-    )
-    
-    # Decodificar e retornar descrição
-    description = processor.decode(outputs[0], skip_special_tokens=True)
-    return description
-
-def parse_food_description(description):
-    """
-    Processa a descrição do modelo para identificar alimentos
-    """
-    foods = []
-    description = description.lower()
-    
-    for food in NUTRITIONAL_DB.keys():
-        if food in description:
-            # Quantidade padrão em gramas
-            qty = 100
-            foods.append((food, qty))
-    
-    return foods
-
-def analyze_food(image):
+def process_image(image, api_key=None):
     """
-    Analisa a imagem do alimento e retorna relatório nutricional detalhado
+    Processa a imagem usando a API de análise nutricional
     """
     try:
-        # Obter descrição dos alimentos
-        food_description = get_food_description(image)
-        
-        # Processar descrição para identificar alimentos
-        identified_foods = parse_food_description(food_description)
-        
-        if not identified_foods:
-            return "Nenhum alimento foi identificado com confiança suficiente na imagem. Por favor, tente outra foto."
+        # Prepara a imagem
+        if isinstance(image, str):
+            img = Image.open(image)
+        else:
+            img = Image.fromarray(image)
         
-        # Gerar relatório nutricional
-        report = "🍽️ RELATÓRIO NUTRICIONAL DETALHADO\n\n"
-        report += "📝 Alimentos Identificados:\n"
-        report += f"\nDescrição do modelo:\n{food_description}\n\n"
+        # Converte para formato adequado
+        buffered = BytesIO()
+        img.save(buffered, format="JPEG")
+        img_bytes = buffered.getvalue()
         
-        total_nutrients = {
-            "calorias": 0,
-            "proteinas": 0,
-            "carboidratos": 0,
-            "gorduras": 0,
-            "fibras": 0,
-        }
+        # Headers da requisição
+        headers = {}
+        if api_key:
+            headers['Authorization'] = f'Bearer {api_key}'
         
-        vitamins_minerals = {}
+        # Faz a requisição para a API
+        files = {'image': ('image.jpg', img_bytes, 'image/jpeg')}
+        response = requests.post(
+            'http://localhost:7860/api/predict',  # Ajuste a URL conforme necessário
+            files=files,
+            headers=headers
+        )
         
-        for food, quantity in identified_foods:
-            multiplier = quantity / 100  # Ajusta para a quantidade real
-            report += f"\n• {food.capitalize()} ({quantity}g)\n"
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return f"Erro na API: {response.status_code}"
             
-            if food in NUTRITIONAL_DB:
-                for nutrient, value in NUTRITIONAL_DB[food].items():
-                    adjusted_value = value * multiplier
-                    
-                    # Adiciona aos totais principais
-                    if nutrient in total_nutrients:
-                        total_nutrients[nutrient] += adjusted_value
-                    # Coleta vitaminas e minerais
-                    elif nutrient not in ['calorias', 'proteinas', 'carboidratos', 'gorduras', 'fibras']:
-                        if nutrient not in vitamins_minerals:
-                            vitamins_minerals[nutrient] = 0
-                        vitamins_minerals[nutrient] += adjusted_value
-        
-        # Adiciona seção de macronutrientes
-        report += "\n📊 MACRONUTRIENTES:\n"
-        report += f"• Calorias: {total_nutrients['calorias']:.1f} kcal\n"
-        report += f"• Proteínas: {total_nutrients['proteinas']:.1f}g\n"
-        report += f"• Carboidratos: {total_nutrients['carboidratos']:.1f}g\n"
-        report += f"• Gorduras: {total_nutrients['gorduras']:.1f}g\n"
-        report += f"• Fibras: {total_nutrients['fibras']:.1f}g\n"
+    except Exception as e:
+        return f"Erro no processamento: {str(e)}"
+
+def analyze_nutrition(image, api_key=""):
+    """
+    Função principal que processa a imagem e retorna os resultados formatados
+    """
+    try:
+        # Processa a imagem
+        result = process_image(image, api_key)
         
-        # Adiciona seção de micronutrientes
-        if vitamins_minerals:
-            report += "\n🧬 VITAMINAS E MINERAIS:\n"
-            for nutrient, value in vitamins_minerals.items():
-                report += f"• {nutrient.replace('_', ' ').capitalize()}: {value:.1f}mg\n"
+        if isinstance(result, str):  # Se for mensagem de erro
+            return (
+                result,  # Texto do erro
+                None,   # Gráfico de macronutrientes
+                None,   # Tabela nutricional
+                None    # Recomendações
+            )
         
-        # Adiciona recomendações personalizadas
-        report += "\n💡 RECOMENDAÇÕES:\n"
+        # Extrai informações do resultado
+        nutrients = result.get('nutrients', {})
         
-        if total_nutrients['calorias'] > 800:
-            report += "• Alto valor calórico - considere reduzir as porções\n"
-        if total_nutrients['proteinas'] < 15:
-            report += "• Baixo teor de proteínas - considere adicionar fontes proteicas\n"
-        if total_nutrients['fibras'] < 6:
-            report += "• Baixo teor de fibras - adicione mais vegetais e grãos integrais\n"
+        # Prepara dados para o gráfico
+        macro_data = {
+            'labels': ['Proteínas', 'Carboidratos', 'Gorduras'],
+            'values': [
+                nutrients.get('proteinas', 0),
+                nutrients.get('carboidratos', 0),
+                nutrients.get('gorduras', 0)
+            ]
+        }
         
-        # Análise de proporções
-        protein_cal = (total_nutrients['proteinas'] * 4)
-        carb_cal = (total_nutrients['carboidratos'] * 4)
-        fat_cal = (total_nutrients['gorduras'] * 9)
-        total_cal = protein_cal + carb_cal + fat_cal
+        # Prepara tabela nutricional
+        nutri_table = {
+            'Nutriente': ['Calorias', 'Proteínas', 'Carboidratos', 'Gorduras', 'Fibras'],
+            'Quantidade': [
+                f"{nutrients.get('calorias', 0):.1f} kcal",
+                f"{nutrients.get('proteinas', 0):.1f}g",
+                f"{nutrients.get('carboidratos', 0):.1f}g",
+                f"{nutrients.get('gorduras', 0):.1f}g",
+                f"{nutrients.get('fibras', 0):.1f}g"
+            ]
+        }
         
-        if total_cal > 0:
-            protein_pct = (protein_cal / total_cal) * 100
-            carb_pct = (carb_cal / total_cal) * 100
-            fat_pct = (fat_cal / total_cal) * 100
+        # Prepara recomendações
+        recommendations = []
+        if nutrients.get('calorias', 0) > 800:
+            recommendations.append("⚠️ Alto valor calórico - considere reduzir as porções")
+        if nutrients.get('proteinas', 0) < 15:
+            recommendations.append("⚠️ Baixo teor de proteínas - considere adicionar fontes proteicas")
+        if nutrients.get('fibras', 0) < 6:
+            recommendations.append("⚠️ Baixo teor de fibras - adicione mais vegetais")
             
-            report += f"\n📈 DISTRIBUIÇÃO CALÓRICA:\n"
-            report += f"• Proteínas: {protein_pct:.1f}%\n"
-            report += f"• Carboidratos: {carb_pct:.1f}%\n"
-            report += f"• Gorduras: {fat_pct:.1f}%\n"
+        recommendations = "\n".join(recommendations) if recommendations else "✅ Valores nutricionais dentro das recomendações!"
         
-        return report
+        # Retorna todos os componentes
+        return (
+            json.dumps(result, indent=2),  # Resultado completo em JSON
+            gr.BarPlot(
+                macro_data['values'],
+                macro_data['labels'],
+                title="Distribuição de Macronutrientes",
+                y="Gramas"
+            ),  # Gráfico
+            gr.Dataframe(
+                headers=['Nutriente', 'Quantidade'],
+                data=list(zip(nutri_table['Nutriente'], nutri_table['Quantidade']))
+            ),  # Tabela
+            recommendations  # Texto de recomendações
+        )
         
     except Exception as e:
-        return f"Erro na análise: {str(e)}\nPor favor, tente novamente com outra imagem."
+        return str(e), None, None, None
 
 # Interface Gradio
-iface = gr.Interface(
-    fn=analyze_food,
-    inputs=gr.Image(type="pil", label="Upload da Imagem do Prato"),
-    outputs=gr.Textbox(label="Relatório Nutricional", lines=20),
-    title="🍽️ Análise Nutricional com IA",
-    description="""
+with gr.Blocks(theme=gr.themes.Soft()) as iface:
+    gr.Markdown("""
+    # 🍽️ Análise Nutricional com IA
     Faça upload de uma foto do seu prato para receber uma análise nutricional detalhada.
-    O sistema identificará os alimentos e fornecerá informações nutricionais completas.
-    """,
-    theme=gr.themes.Soft()
-)
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            # Inputs
+            image_input = gr.Image(
+                type="pil",
+                label="Foto do Prato",
+                sources=['upload', 'webcam']
+            )
+            api_key = gr.Textbox(
+                label="API Key (opcional)",
+                placeholder="Digite sua API key aqui...",
+                type="password"
+            )
+            analyze_btn = gr.Button("📊 Analisar", variant="primary")
+            
+        with gr.Column():
+            # Outputs
+            with gr.Tab("Resumo"):
+                recommendations = gr.Textbox(
+                    label="Recomendações",
+                    lines=3
+                )
+                nutri_table = gr.Dataframe(
+                    label="Tabela Nutricional",
+                    headers=['Nutriente', 'Quantidade']
+                )
+                macro_plot = gr.Plot(
+                    label="Macronutrientes"
+                )
+            
+            with gr.Tab("Detalhes"):
+                json_output = gr.JSON(
+                    label="Resultado Detalhado"
+                )
+    
+    # Eventos
+    analyze_btn.click(
+        fn=analyze_nutrition,
+        inputs=[image_input, api_key],
+        outputs=[json_output, macro_plot, nutri_table, recommendations]
+    )
+    
+    gr.Markdown("""
+    ### 📝 Instruções
+    1. Faça upload de uma foto do seu prato ou tire uma foto com a webcam
+    2. Se tiver uma API key, insira-a (opcional)
+    3. Clique em "Analisar"
+    4. Veja os resultados nas abas "Resumo" e "Detalhes"
+    
+    ### 🎯 Dicas para melhores resultados
+    - Use fotos bem iluminadas
+    - Fotografe de cima para baixo
+    - Certifique-se que todos os alimentos estão visíveis
+    - Evite sombras ou reflexos fortes
+    """)
 
+# Inicia a interface
 if __name__ == "__main__":
     iface.launch(share=True)