Update app.py

app.py

@@ -5,13 +5,11 @@ from PIL import Image
 from dataclasses import dataclass
 from typing import Tuple, Dict, List
 import torch
-import torch.nn.functional as F
 import torchvision.transforms as transforms
 import logging
 from datetime import datetime
-import json
 
-# Configuração básica de logging
+# Configuração de logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
@@ -19,115 +17,14 @@ logging.basicConfig(
 
 @dataclass
 class IrisZone:
-    """Classe para definir as características de uma zona da íris"""
+    """Define características e atributos de uma zona da íris"""
     name: str
     inner_ratio: float
     outer_ratio: float
     color: Tuple[int, int, int]
     description: str
-    indicators: Dict[str, str]
-    
-    def __post_init__(self):
-        if not 0 <= self.inner_ratio <= 1:
-            raise ValueError("inner_ratio deve estar entre 0 e 1")
-        if not 0 <= self.outer_ratio <= 1:
-            raise ValueError("outer_ratio deve estar entre 0 e 1")
-        if self.inner_ratio >= self.outer_ratio:
-            raise ValueError("inner_ratio deve ser menor que outer_ratio")
-
-class IrisAnalysis:
-    """Classe para análise e interpretação dos resultados"""
-    
-    @staticmethod
-    def get_zone_interpretation(zone_name: str, intensity: float, variation: float) -> Dict:
-        """Interpretação detalhada para cada zona"""
-        base_interpretations = {
-            "Zona Cerebral/Neural": {
-                "aspectos": "Sistema nervoso central e periférico",
-                "sistemas": ["Cérebro", "Medula espinhal", "Nervos"],
-                "baixa": {
-                    "indicacao": "Possível fadiga neural",
-                    "sugestoes": [
-                        "Considerar avaliação do sono",
-                        "Verificar níveis de estresse",
-                        "Avaliar demanda cognitiva"
-                    ]
-                },
-                "média": {
-                    "indicacao": "Condição neural moderada",
-                    "sugestoes": [
-                        "Manter boa higiene do sono",
-                        "Praticar atividades mentais"
-                    ]
-                },
-                "alta": {
-                    "indicacao": "Boa vitalidade neural",
-                    "sugestoes": [
-                        "Manter práticas saudáveis",
-                        "Continuar estimulação cognitiva"
-                    ]
-                }
-            },
-            "Zona Digestiva": {
-                "aspectos": "Sistema digestivo completo",
-                "sistemas": ["Estômago", "Intestinos", "Fígado", "Pâncreas"],
-                "baixa": {
-                    "indicacao": "Possível sensibilidade digestiva",
-                    "sugestoes": [
-                        "Avaliar hábitos alimentares",
-                        "Considerar diário alimentar",
-                        "Observar reações a alimentos"
-                    ]
-                },
-                "média": {
-                    "indicacao": "Sistema digestivo em equilíbrio moderado",
-                    "sugestoes": [
-                        "Manter alimentação balanceada",
-                        "Observar horários das refeições"
-                    ]
-                },
-                "alta": {
-                    "indicacao": "Boa condição digestiva",
-                    "sugestoes": [
-                        "Manter dieta equilibrada",
-                        "Continuar bons hábitos"
-                    ]
-                }
-            },
-            # [Definições similares para outras zonas...]
-        }
-        
-        # Determinar nível baseado na intensidade
-        if intensity < 85:
-            nivel = "baixa"
-            confianca = "reduzida" if variation > 30 else "moderada"
-        elif intensity < 170:
-            nivel = "média"
-            confianca = "moderada" if variation > 20 else "alta"
-        else:
-            nivel = "alta"
-            confianca = "alta" if variation < 15 else "moderada"
-            
-        zone_info = base_interpretations.get(zone_name, {})
-        
-        return {
-            "nome": zone_name,
-            "aspectos_analisados": zone_info.get("aspectos", ""),
-            "sistemas_relacionados": zone_info.get("sistemas", []),
-            "interpretacao": zone_info.get(nivel, {}).get("indicacao", "Sem interpretação disponível"),
-            "sugestoes": zone_info.get(nivel, {}).get("sugestoes", []),
-            "metricas": {
-                "intensidade": intensity,
-                "variacao": variation,
-                "nivel_geral": nivel,
-                "confianca_analise": confianca,
-            },
-            "indicadores": {
-                "intensidade_valor": f"{intensity:.1f}/255",
-                "variacao_valor": f"{variation:.1f}%",
-                "homogeneidade": "Baixa" if variation > 30 else "Média" if variation > 15 else "Alta"
-            }
-        }
+    related_systems: List[str]
+    indicators: Dict[str, List[str]]
 
 class IrisAnalyzer:
     """Classe principal para análise da íris"""
@@ -139,15 +36,167 @@ class IrisAnalyzer:
                 outer_ratio=1.0,
                 color=(255, 0, 0),
                 description="Sistema nervoso central e periférico",
-                indicators={"estresse": "alto", "energia": "moderada"}
+                related_systems=["Cérebro", "Medula", "Nervos"],
+                indicators={
+                    "baixa": [
+                        "Possível fadiga mental",
+                        "Considerar níveis de estresse",
+                        "Avaliar qualidade do sono"
+                    ],
+                    "media": [
+                        "Estado neural adequado",
+                        "Manter atividades mentais"
+                    ],
+                    "alta": [
+                        "Boa vitalidade neural",
+                        "Continuar práticas saudáveis"
+                    ]
+                }
+            ),
+            IrisZone(
+                name="Zona Digestiva",
+                inner_ratio=0.7,
+                outer_ratio=0.85,
+                color=(0, 255, 0),
+                description="Sistema digestivo completo",
+                related_systems=["Estômago", "Intestinos", "Fígado"],
+                indicators={
+                    "baixa": [
+                        "Atenção à digestão",
+                        "Avaliar alimentação",
+                        "Observar sensibilidades"
+                    ],
+                    "media": [
+                        "Digestão adequada",
+                        "Manter dieta balanceada"
+                    ],
+                    "alta": [
+                        "Boa saúde digestiva",
+                        "Manter hábitos saudáveis"
+                    ]
+                }
+            ),
+            IrisZone(
+                name="Zona Respiratória",
+                inner_ratio=0.55,
+                outer_ratio=0.7,
+                color=(0, 0, 255),
+                description="Sistema respiratório",
+                related_systems=["Pulmões", "Brônquios", "Vias aéreas"],
+                indicators={
+                    "baixa": [
+                        "Atenção respiratória",
+                        "Considerar exercícios",
+                        "Avaliar ambiente"
+                    ],
+                    "media": [
+                        "Função respiratória adequada",
+                        "Manter atividades aeróbicas"
+                    ],
+                    "alta": [
+                        "Boa capacidade respiratória",
+                        "Continuar práticas saudáveis"
+                    ]
+                }
+            ),
+            IrisZone(
+                name="Zona Circulatória",
+                inner_ratio=0.4,
+                outer_ratio=0.55,
+                color=(255, 255, 0),
+                description="Sistema cardiovascular",
+                related_systems=["Coração", "Vasos", "Circulação"],
+                indicators={
+                    "baixa": [
+                        "Atenção circulatória",
+                        "Considerar exercícios",
+                        "Avaliar rotina"
+                    ],
+                    "media": [
+                        "Circulação adequada",
+                        "Manter atividade física"
+                    ],
+                    "alta": [
+                        "Boa saúde circulatória",
+                        "Manter hábitos ativos"
+                    ]
+                }
+            ),
+            IrisZone(
+                name="Zona Linfática",
+                inner_ratio=0.25,
+                outer_ratio=0.4,
+                color=(255, 0, 255),
+                description="Sistema imunológico",
+                related_systems=["Linfonodos", "Imunidade", "Defesa"],
+                indicators={
+                    "baixa": [
+                        "Atenção imunológica",
+                        "Considerar suporte",
+                        "Avaliar estresse"
+                    ],
+                    "media": [
+                        "Imunidade adequada",
+                        "Manter cuidados básicos"
+                    ],
+                    "alta": [
+                        "Boa resposta imune",
+                        "Manter hábitos saudáveis"
+                    ]
+                }
+            ),
+            IrisZone(
+                name="Zona Endócrina",
+                inner_ratio=0.15,
+                outer_ratio=0.25,
+                color=(0, 255, 255),
+                description="Sistema hormonal",
+                related_systems=["Glândulas", "Hormônios", "Metabolismo"],
+                indicators={
+                    "baixa": [
+                        "Atenção hormonal",
+                        "Considerar ritmos",
+                        "Avaliar rotina"
+                    ],
+                    "media": [
+                        "Função hormonal adequada",
+                        "Manter equilíbrio"
+                    ],
+                    "alta": [
+                        "Bom equilíbrio hormonal",
+                        "Manter hábitos regulares"
+                    ]
+                }
             ),
-            # [Outras zonas definidas similarmente...]
+            IrisZone(
+                name="Zona Pupilar",
+                inner_ratio=0,
+                outer_ratio=0.15,
+                color=(128, 128, 128),
+                description="Sistema nervoso autônomo",
+                related_systems=["SNA", "Reflexos", "Regulação"],
+                indicators={
+                    "baixa": [
+                        "Atenção autonômica",
+                        "Considerar relaxamento",
+                        "Avaliar estresse"
+                    ],
+                    "media": [
+                        "Função autonômica adequada",
+                        "Manter equilíbrio"
+                    ],
+                    "alta": [
+                        "Boa regulação autonômica",
+                        "Manter práticas saudáveis"
+                    ]
+                }
+            )
         ]
 
     def preprocess_image(self, img: np.ndarray) -> np.ndarray:
-        """Pré-processamento da imagem"""
+        """Pré-processa a imagem para melhor análise"""
         try:
-            # Converter para LAB para melhor contraste
+            # Converter para LAB
             lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
             l, a, b = cv2.split(lab)
             
@@ -168,13 +217,12 @@ class IrisAnalyzer:
             return img
 
     def detect_pupil(self, img: np.ndarray) -> Tuple[int, int, int]:
-        """Detecção avançada da pupila"""
+        """Detecta a pupila na imagem"""
         try:
-            # Pré-processar imagem
             processed = self.preprocess_image(img)
             gray = cv2.cvtColor(processed, cv2.COLOR_RGB2GRAY)
             
-            # Aplicar threshold adaptativo
+            # Threshold adaptativo
             blur = cv2.GaussianBlur(gray, (5,5), 0)
             _, thresh = cv2.threshold(blur, 30, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
             
@@ -189,7 +237,7 @@ class IrisAnalyzer:
                 return None
             
             # Encontrar o contorno mais circular
-            best_circularity = 0
+            max_circularity = 0
             best_contour = None
             
             for contour in contours:
@@ -197,16 +245,15 @@ class IrisAnalyzer:
                 perimeter = cv2.arcLength(contour, True)
                 if perimeter == 0:
                     continue
-                    
-                circularity = 4 * np.pi * area / (perimeter * perimeter)
                 
-                if circularity > best_circularity:
-                    best_circularity = circularity
+                circularity = 4 * np.pi * area / (perimeter * perimeter)
+                if circularity > max_circularity:
+                    max_circularity = circularity
                     best_contour = contour
             
             if best_contour is None:
                 return None
-                
+            
             (x, y), radius = cv2.minEnclosingCircle(best_contour)
             return (int(x), int(y), int(radius))
             
@@ -214,8 +261,8 @@ class IrisAnalyzer:
             logging.error(f"Erro na detecção da pupila: {str(e)}")
             return None
 
-    def analyze_zone(self, img: np.ndarray, mask: np.ndarray, zone_name: str) -> Dict:
-        """Análise detalhada de uma zona específica"""
+    def analyze_zone(self, img: np.ndarray, mask: np.ndarray, zone: IrisZone) -> Dict:
+        """Analisa uma zona específica da íris"""
         try:
             # Extrair características
             mean_color = cv2.mean(img, mask=mask)
@@ -227,86 +274,94 @@ class IrisAnalyzer:
                 mean_intensity = np.mean(pixels)
                 std_dev = np.std(pixels)
                 
-                # Calcular características adicionais
-                percentiles = np.percentile(pixels, [25, 50, 75])
+                # Determinar nível
+                if mean_intensity < 85:
+                    nivel = "baixa"
+                elif mean_intensity < 170:
+                    nivel = "media"
+                else:
+                    nivel = "alta"
                 
-                # Gerar interpretação detalhada
-                analysis = IrisAnalysis.get_zone_interpretation(
-                    zone_name, mean_intensity, std_dev
-                )
+                # Calcular confiança
+                confianca = "alta" if std_dev < 15 else "media" if std_dev < 30 else "baixa"
                 
-                # Adicionar métricas estatísticas
-                analysis["metricas_detalhadas"] = {
-                    "mediana": float(percentiles[1]),
-                    "quartil_inferior": float(percentiles[0]),
-                    "quartil_superior": float(percentiles[2]),
-                    "pixels_analisados": len(pixels),
-                    "variacao_cor": {
-                        "r": mean_color[0],
-                        "g": mean_color[1],
-                        "b": mean_color[2]
+                # Gerar análise
+                analysis = {
+                    "nome": zone.name,
+                    "descricao": zone.description,
+                    "sistemas_relacionados": zone.related_systems,
+                    "indicadores": zone.indicators[nivel],
+                    "metricas": {
+                        "intensidade": float(mean_intensity),
+                        "variacao": float(std_dev),
+                        "nivel": nivel,
+                        "confianca": confianca
+                    },
+                    "cores": {
+                        "r": float(mean_color[0]),
+                        "g": float(mean_color[1]),
+                        "b": float(mean_color[2])
                     }
                 }
                 
                 return analysis
             
-            return {"erro": "Zona sem pixels válidos para análise"}
+            return {"erro": "Zona sem pixels válidos"}
             
         except Exception as e:
-            logging.error(f"Erro na análise da zona {zone_name}: {str(e)}")
+            logging.error(f"Erro na análise da zona {zone.name}: {str(e)}")
             return {"erro": str(e)}
 
     def analyze_iris(self, img: np.ndarray) -> Tuple[np.ndarray, Dict]:
-        """Análise principal com relatório detalhado"""
+        """Realiza a análise completa da íris"""
         try:
             output_img = img.copy()
-            detailed_results = {
+            results = {
                 "meta": {
                     "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    "versao_analise": "1.0.0"
+                    "versao": "1.0.0"
                 },
-                "resumo_geral": {},
                 "zonas": {},
-                "observacoes": []
+                "resumo": {}
             }
             
             # Detectar pupila
             pupil = self.detect_pupil(img)
             if pupil is None:
                 return img, {"erro": "Não foi possível detectar a pupila"}
-                
+            
             x, y, pupil_radius = pupil
             iris_radius = pupil_radius * 4
             
-            # Desenhar círculo da pupila
+            # Desenhar pupila
             cv2.circle(output_img, (x, y), pupil_radius, (0, 0, 0), 2)
             
             # Analisar cada zona
-            overall_health_score = 0
-            num_zones = len(self.zones)
+            total_score = 0
+            valid_zones = 0
             
             for zone in self.zones:
                 inner_r = int(iris_radius * zone.inner_ratio)
                 outer_r = int(iris_radius * zone.outer_ratio)
                 
-                # Criar máscara para a zona
+                # Criar máscara
                 mask = np.zeros(img.shape[:2], dtype=np.uint8)
                 cv2.circle(mask, (x, y), outer_r, 255, -1)
                 cv2.circle(mask, (x, y), inner_r, 0, -1)
                 
-                # Desenhar círculos da zona
+                # Desenhar zona
                 cv2.circle(output_img, (x, y), outer_r, zone.color, 2)
                 
                 # Analisar zona
-                analysis = self.analyze_zone(img, mask, zone.name)
-                detailed_results["zonas"][zone.name] = analysis
+                analysis = self.analyze_zone(img, mask, zone)
+                results["zonas"][zone.name] = analysis
                 
-                # Calcular score geral
                 if "metricas" in analysis:
-                    if analysis["metricas"]["nivel_geral"] == "alta":
-                        overall_health_score += 1
-                    elif analysis["metricas"]["nivel_geral"] == "média":
-                        overall_health_score += 0.5
+                    if analysis["metricas"]["nivel"] == "alta":
+                        total_score += 1.0
+                    elif analysis["metricas"]["nivel"] == "media":
+                        total_score += 0.5
+                    valid_zones += 1
                 
                 # Adicionar texto
                 text_x = x - iris_radius
@@ -314,142 +369,235 @@ class IrisAnalyzer:
                 cv2.putText(output_img, zone.name, (text_x, text_y),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, zone.color, 1)
             
-            # Calcular resumo geral
-            health_percentage = (overall_health_score / num_zones) * 100
-            detailed_results["resumo_geral"] = {
-                "indice_geral": f"{health_percentage:.1f}%",
-                "interpretacao": "Bom" if health_percentage > 75 else 
-                               "Moderado" if health_percentage > 50 else 
-                               "Requer atenção"
-            }
+            # Calcular índice geral
+            if valid_zones > 0:
+                health_index = (total_score / valid_zones) * 100
+                results["resumo"] = {
+                    "indice_geral": f"{health_index:.1f}%",
+                    "interpretacao": "Excelente" if health_index > 80 else
+                                   "Bom" if health_index > 60 else
+                                   "Regular" if health_index > 40 else
+                                   "Requer atenção"
+                }
             
-            return output_img, detailed_results
+            return output_img, results
             
         except Exception as e:
             logging.error(f"Erro na análise da íris: {str(e)}")
             return img, {"erro": str(e)}
 
-def format_results(results: Dict) -> str:
-    """Formata os resultados para exibição"""
-    if "erro" in results:
-        return f"Erro na análise: {results['erro']}"
-        
-    formatted = "# Relatório de Análise da Íris\n\n"
+def format_zone_report(zone_name: str, analysis: Dict) -> str:
+    """Formata o relatório de uma zona específica"""
+    if "erro" in analysis:
+        return f"Erro na análise de {zone_name}: {analysis['erro']}"
     
-    # Adicionar resumo geral
-    if "resumo_geral" in results:
-        formatted += "## Resumo Geral\n"
-        formatted += f"- Índice Geral: {results['resumo_geral']['indice_geral']}\n"
-        formatted += f"- Interpretação: {results['resumo_geral']['interpretacao']}\n\n"
+    report = f"""### {zone_name}
+
+**Descrição:** {analysis.get('descricao', 'N/A')}
+
+**Sistemas Relacionados:**
+"""
+    for sistema in analysis.get('sistemas_relacionados', []):
+        report += f"- {sistema}\n"
     
-    # Adicionar análise por zona
-    if "zonas" in results:
-        formatted += "## Análise por Zona\n\n"
-        for zone_name, analysis in results["zonas"].items():
-            formatted += f"### {zone_name}\n"
-            formatted += f"- Aspectos Analisados: {analysis.get('aspectos_analisados', 'N/A')}\n"
-            formatted += f"- Interpretação: {analysis.get('interpretacao', 'N/A')}\n"
-            
-            if "sugestoes" in analysis:
-                formatted += "- Sugestões:\n"
-                for sugestao in analysis["sugestoes"]:
-                    formatted += f"  * {sugestao}\n"
-            
-            if "metricas" in analysis:
-                formatted += f"- Nível Geral: {analysis['metricas']['nivel_geral']}\n"
-                formatted += f"- Confiança da Análise: {analysis['metricas']['confianca_analise']}\n"
-            
-            formatted += "\n"
+    report += "\n**Indicadores:**\n"
+    for indicador in analysis.get('indicadores', []):
+        report += f"- {indicador}\n"
     
-    # Adicionar timestamp
-    if "meta" in results:
-        formatted += f"\n---\nAnálise realizada em: {results['meta']['timestamp']}\n"
-        formatted += f"Versão do sistema: {results['meta']['versao_analise']}\n"
+    if "metricas" in analysis:
+        report += f"""
+**Métricas:**
+- Nível: {analysis['metricas']['nivel'].title()}
+- Confiança: {analysis['metricas']['confianca'].title()}
+- Intensidade: {analysis['metricas']['intensidade']:.1f}
+- Variação: {analysis['metricas']['variacao']:.1f}
+"""
+    return report
+
+def format_technical_metrics(analysis: Dict) -> str:
+    """Formata as métricas técnicas de uma análise"""
+    metrics = """### Métricas Técnicas\n\n"""
     
-    return formatted
+    if "metricas" in analysis:
+        metrics += f"""
+- **Análise de Intensidade**
+  - Valor: {analysis['metricas']['intensidade']:.1f}/255
+  - Interpretação: {analysis['metricas']['nivel'].title()}
+
+- **Análise de Variação**
+  - Valor: {analysis['metricas']['variacao']:.1f}
+  - Confiança: {analysis['metricas']['confianca'].title()}
+
+- **Cores (RGB)**
+  - R: {analysis['cores']['r']:.1f}
+  - G: {analysis['cores']['g']:.1f}
+  - B: {analysis['cores']['b']:.1f}
+"""
+    return metrics
 
 def process_image(img):
-    """Função principal para processar imagem"""
+    """Processa a imagem e retorna todos os resultados formatados"""
     if img is None:
-        return None, "Erro: Nenhuma imagem fornecida"
-    
-    analyzer = IrisAnalyzer()
-    output_img, results = analyzer.analyze_iris(np.array(img))
-    formatted_results = format_results(results)
+        return [None] * 6, gr.Warning("Por favor, carregue uma imagem.")
     
-    return output_img, formatted_results
+    try:
+        analyzer = IrisAnalyzer()
+        output_img, results = analyzer.analyze_iris(np.array(img))
+        
+        if "erro" in results:
+            return [output_img] + [results["erro"]] * 5
+        
+        # 1. Resumo Geral
+        resumo = f"""## Resumo da Análise
+
+🎯 **Índice Geral de Saúde:** {results['resumo'].get('indice_geral', 'N/A')}
+📊 **Interpretação:** {results['resumo'].get('interpretacao', 'N/A')}
+🕒 **Data da Análise:** {results['meta']['timestamp']}
+
+---"""
+
+        # 2. Análise Detalhada
+        analise_detalhada = "## Análise Detalhada por Zona\n\n"
+        for zone_name, analysis in results['zonas'].items():
+            analise_detalhada += format_zone_report(zone_name, analysis) + "\n---\n"
+
+        # 3. Recomendações
+        recomendacoes = "## Recomendações Personalizadas\n\n"
+        for zone_name, analysis in results['zonas'].items():
+            if analysis.get('indicadores'):
+                recomendacoes += f"### {zone_name}\n"
+                for idx, rec in enumerate(analysis['indicadores'], 1):
+                    recomendacoes += f"{idx}. {rec}\n"
+                recomendacoes += "\n"
+
+        # 4. Métricas Técnicas
+        metricas = "## Métricas e Indicadores\n\n"
+        for zone_name, analysis in results['zonas'].items():
+            metricas += f"### {zone_name}\n"
+            metricas += format_technical_metrics(analysis) + "\n"
+
+        # 5. Observações Técnicas
+        observacoes = f"""## Informações Técnicas
+
+📌 **Detalhes da Análise**
+- Versão do Sistema: {results['meta']['versao']}
+- Data/Hora: {results['meta']['timestamp']}
+- Zonas Analisadas: {len(results['zonas'])}
+
+⚠️ **Observações**
+- Esta é uma análise educacional
+- Não substitui avaliação médica
+- Baseado na teoria de Jensen
+"""
+
+        return output_img, resumo, analise_detalhada, recomendacoes, metricas, observacoes
+        
+    except Exception as e:
+        logging.error(f"Erro no processamento: {str(e)}")
+        return [None] * 6, gr.Error(f"Erro no processamento: {str(e)}")
 
 # Interface Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
     gr.Markdown("""
     # 🔍 Analisador Avançado de Íris
-    ### Sistema de análise baseado na teoria de Jensen
+    ## Sistema Educacional de Análise Iridológica
     
-    ⚠️ **AVISO**: Esta é uma demonstração educacional. Não deve ser utilizada para diagnósticos médicos.
+    ⚠️ Este é um sistema para fins educacionais. Não utilize para diagnósticos médicos.
     """)
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(
-                label="Upload da imagem do olho",
-                type="numpy",
-                sources=["upload", "clipboard"]
-            )
-            
-            analyze_btn = gr.Button(
-                "📸 Analisar Imagem", 
-                variant="primary"
-            )
-            
+    with gr.Tabs() as tabs:
+        # Aba de Análise
+        with gr.Tab("📸 Análise"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    input_image = gr.Image(
+                        label="Upload da Imagem",
+                        type="numpy",
+                        sources=["upload", "clipboard"],
+                        height=400
+                    )
+                    analyze_btn = gr.Button("🔍 Analisar", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    output_image = gr.Image(label="Resultado da Análise", height=400)
+        
+        # Aba de Resultados
+        with gr.Tab("📊 Resultados"):
+            with gr.Tabs() as results_tabs:
+                with gr.Tab("📝 Resumo"):
+                    resumo_text = gr.Markdown()
+                
+                with gr.Tab("🔍 Análise Detalhada"):
+                    analise_text = gr.Markdown()
+                
+                with gr.Tab("💡 Recomendações"):
+                    recomendacoes_text = gr.Markdown()
+                
+                with gr.Tab("📈 Métricas"):
+                    metricas_text = gr.Markdown()
+                
+                with gr.Tab("ℹ️ Informações"):
+                    observacoes_text = gr.Markdown()
+        
+        # Aba de Ajuda
+        with gr.Tab("❓ Ajuda"):
             gr.Markdown("""
-            ### Instruções:
-            1. Faça upload de uma imagem clara do olho
-            2. Certifique-se que a íris está bem visível
-            3. Clique em "Analisar Imagem"
-            4. Revise o relatório detalhado
+            ## Como Usar o Sistema
+
+            1. **Upload da Imagem**
+               - Use uma foto clara do olho
+               - Certifique-se que a íris está visível
+               - Evite reflexos e sombras
+
+            2. **Análise**
+               - Clique em "Analisar"
+               - Aguarde o processamento
+               - Revise os resultados nas abas
+
+            3. **Interpretação**
+               - Resumo: visão geral
+               - Análise: detalhes por zona
+               - Recomendações: sugestões
+               - Métricas: dados técnicos
+
+            ## Zonas Analisadas
+
+            1. 🧠 **Zona Cerebral/Neural**
+               - Sistema nervoso
+            2. 🟢 **Zona Digestiva**
+               - Sistema digestivo
+            3. 🫁 **Zona Respiratória**
+               - Sistema respiratório
+            4. ❤️ **Zona Circulatória**
+               - Sistema cardiovascular
+            5. 🔵 **Zona Linfática**
+               - Sistema imunológico
+            6. 🟣 **Zona Endócrina**
+               - Sistema hormonal
+            7. ⚫ **Zona Pupilar**
+               - Sistema nervoso autônomo
+
+            ## Observações
+
+            - Sistema educacional
+            - Não substitui diagnósticos
+            - Consulte profissionais de saúde
             """)
-            
-        with gr.Column(scale=1):
-            output_image = gr.Image(label="Análise Visual")
-            results_text = gr.Markdown(label="Relatório Detalhado")
-    
-    with gr.Row():
-        gr.Markdown("""
-        ### Legenda das Zonas:
-        - 🔴 Zona Cerebral/Neural: Sistema nervoso
-        - 🟢 Zona Digestiva: Sistema digestivo
-        - 🔵 Zona Respiratória: Sistema respiratório
-        - 🟡 Zona Circulatória: Sistema circulatório
-        - 🟣 Zona Linfática: Sistema linfático
-        - 🔰 Zona Endócrina: Sistema hormonal
-        - ⚪ Zona Pupilar: Sistema nervoso autônomo
-        """)
     
+    # Configurar eventos
     analyze_btn.click(
         fn=process_image,
         inputs=input_image,
-        outputs=[output_image, results_text]
+        outputs=[
+            output_image,
+            resumo_text,
+            analise_text,
+            recomendacoes_text,
+            metricas_text,
+            observacoes_text
+        ]
     )
-    
-    gr.Markdown("""
-    ---
-    ### 📋 Sobre a Análise
-    
-    Este sistema realiza:
-    - Detecção automática da pupila
-    - Análise de 7 zonas principais da íris
-    - Avaliação de padrões e texturas
-    - Geração de relatório detalhado
-    
-    **Observações Importantes:**
-    - A iridologia é uma prática alternativa
-    - Os resultados são interpretativos
-    - Consulte profissionais de saúde para diagnósticos
-    
-    ---
-    """)
 
-# Configurações para execução
 if __name__ == "__main__":
     try:
         iface.launch()