Update app.py

app.py

@@ -1,586 +1,167 @@
 import gradio as gr
 import cv2
 import numpy as np
-from dataclasses import dataclass
-from typing import Dict, List, Tuple, Optional
-from datetime import datetime
-
-@dataclass
-class IrisZone:
-    name: str
-    ratio: Tuple[float, float]  # (inner, outer)
-    color: Tuple[int, int, int]
-    conditions: Dict[str, List[str]]
-    recommendations: Dict[str, List[str]]
-
-class IrisAnalyzer:
-    def __init__(self):
-        self.zones = [
-            IrisZone(
-                name="Zona Cerebral/Neural",
-                ratio=(0.85, 1.0),
-                color=(255, 0, 0),
-                conditions={
-                    "baixa": [
-                        "Possível fadiga neural crônica",
-                        "Indicadores de estresse prolongado",
-                        "Sinais de insônia ou distúrbios do sono",
-                        "Possível déficit de vitamina B12"
-                    ],
-                    "media": ["Estado neural estável", "Função cognitiva normal"],
-                    "alta": ["Excelente saúde neural", "Ótima resposta cognitiva"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Suplementação de vitamina B12",
-                        "Técnicas de meditação diária",
-                        "Melhorar qualidade do sono",
-                        "Reduzir exposição a telas"
-                    ],
-                    "media": ["Manter rotina de sono", "Exercícios mentais regulares"],
-                    "alta": ["Manter práticas atuais", "Exercícios de mindfulness"]
-                }
-            ),
-            IrisZone(
-                name="Zona Digestiva",
-                ratio=(0.7, 0.85),
-                color=(0, 255, 0),
-                conditions={
-                    "baixa": [
-                        "Possível inflamação intestinal",
-                        "Sinais de má absorção",
-                        "Indicadores de disbiose",
-                        "Possível deficiência enzimática"
-                    ],
-                    "media": ["Digestão funcional", "Absorção adequada"],
-                    "alta": ["Excelente saúde digestiva", "Ótima absorção"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Probióticos específicos",
-                        "Enzimas digestivas",
-                        "Dieta anti-inflamatória",
-                        "Eliminar alimentos processados"
-                    ],
-                    "media": ["Manter dieta balanceada", "Hidratação adequada"],
-                    "alta": ["Manter dieta atual", "Rotina alimentar saudável"]
-                }
-            ),
-            IrisZone(
-                name="Zona Respiratória",
-                ratio=(0.55, 0.7),
-                color=(0, 0, 255),
-                conditions={
-                    "baixa": [
-                        "Possível comprometimento respiratório",
-                        "Sinais de baixa oxigenação",
-                        "Indicadores de congestão brônquica",
-                        "Possível sensibilidade respiratória"
-                    ],
-                    "media": ["Função respiratória adequada", "Oxigenação normal"],
-                    "alta": ["Excelente capacidade respiratória", "Ótima oxigenação"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Exercícios respiratórios diários",
-                        "Avaliar qualidade do ar",
-                        "Considerar atividades aeróbicas",
-                        "Técnicas de respiração profunda"
-                    ],
-                    "media": ["Manter exercícios regulares", "Praticar respiração consciente"],
-                    "alta": ["Continuar práticas saudáveis", "Manter atividades aeróbicas"]
-                }
-            ),
-            IrisZone(
-                name="Zona Circulatória",
-                ratio=(0.4, 0.55),
-                color=(255, 255, 0),
-                conditions={
-                    "baixa": [
-                        "Possível circulação periférica reduzida",
-                        "Indicadores de estagnação sanguínea",
-                        "Sinais de baixo fluxo sanguíneo",
-                        "Possível deficiência de ferro"
-                    ],
-                    "media": ["Circulação adequada", "Fluxo sanguíneo normal"],
-                    "alta": ["Excelente circulação", "Ótimo fluxo sanguíneo"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Aumentar atividade física",
-                        "Considerar suplementação de ferro",
-                        "Massagens circulatórias",
-                        "Hidratação adequada"
-                    ],
-                    "media": ["Manter exercícios regulares", "Alimentação rica em ferro"],
-                    "alta": ["Manter rotina atual", "Continuar exercícios"]
-                }
-            ),
-            IrisZone(
-                name="Zona Linfática",
-                ratio=(0.25, 0.4),
-                color=(255, 0, 255),
-                conditions={
-                    "baixa": [
-                        "Sistema linfático congestionado",
-                        "Possível retenção de líquidos",
-                        "Indicadores de toxicidade",
-                        "Baixa resposta imunológica"
-                    ],
-                    "media": ["Sistema linfático funcional", "Drenagem adequada"],
-                    "alta": ["Excelente drenagem linfática", "Ótima desintoxicação"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Drenagem linfática regular",
-                        "Aumentar consumo de água",
-                        "Exercícios específicos",
-                        "Dieta desintoxicante"
-                    ],
-                    "media": ["Manter hidratação", "Exercícios leves regulares"],
-                    "alta": ["Manter hábitos atuais", "Continuar atividades físicas"]
-                }
-            ),
-            IrisZone(
-                name="Zona Endócrina",
-                ratio=(0.15, 0.25),
-                color=(0, 255, 255),
-                conditions={
-                    "baixa": [
-                        "Possível desequilíbrio hormonal",
-                        "Sinais de estresse adrenal",
-                        "Indicadores de fadiga endócrina",
-                        "Possível disfunção tireoidiana"
-                    ],
-                    "media": ["Sistema endócrino estável", "Função hormonal adequada"],
-                    "alta": ["Excelente equilíbrio hormonal", "Ótima função endócrina"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Gestão do estresse",
-                        "Suporte adrenal natural",
-                        "Regular ciclo sono-vigília",
-                        "Alimentação rica em iodo"
-                    ],
-                    "media": ["Manter rotina regular", "Cuidar do sono"],
-                    "alta": ["Manter equilíbrio atual", "Continuar boas práticas"]
-                }
-            ),
-            IrisZone(
-                name="Zona Pupilar",
-                ratio=(0, 0.15),
-                color=(128, 128, 128),
-                conditions={
-                    "baixa": [
-                        "Sistema nervoso autônomo sobrecarregado",
-                        "Possível desequilíbrio simpático/parassimpático",
-                        "Indicadores de estresse crônico",
-                        "Sinais de fadiga autonômica"
-                    ],
-                    "media": ["SNA equilibrado", "Resposta autonômica normal"],
-                    "alta": ["Excelente regulação autonômica", "Ótimo equilíbrio do SNA"]
-                },
-                recommendations={
-                    "baixa": [
-                        "Técnicas de relaxamento",
-                        "Práticas de mindfulness",
-                        "Regular rotina diária",
-                        "Exercícios de respiração"
-                    ],
-                    "media": ["Manter práticas relaxantes", "Continuar boa rotina"],
-                    "alta": ["Manter equilíbrio atual", "Continuar práticas saudáveis"]
-                }
-            )
-        ]
-
-    def _assess_image_quality(self, image: np.ndarray) -> float:
-        """Assess image quality with better error handling."""
-        try:
-            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-            blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
-            brightness = np.mean(gray)
-            contrast = np.std(gray)
-            
-            quality_score = (
-                np.clip(blur_score / 500, 0, 1) * 0.4 +
-                np.clip(1 - abs(brightness - 128) / 128, 0, 1) * 0.3 +
-                np.clip(contrast / 50, 0, 1) * 0.3
-            ) * 100
-            
-            return float(quality_score)
-        except Exception as e:
-            print(f"Error in image quality assessment: {str(e)}")
-            return 0.0
-
-    def _analyze_texture(self, gray: np.ndarray, mask: np.ndarray) -> float:
-        """Analyze texture with improved error handling and normalization."""
-        try:
-            if mask is None or np.sum(mask) == 0:
-                return 0.0
-                
-            zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
-            valid_pixels = zone_pixels[mask > 0]
-            
-            if len(valid_pixels) == 0:
-                return 0.0
-                
-            mean = np.mean(valid_pixels)
-            std = np.std(valid_pixels)
-            entropy = np.sum(np.abs(np.diff(valid_pixels)))
-            
-            texture_score = (
-                np.clip(mean / 255, 0, 1) * 0.3 +
-                np.clip(std / 128, 0, 1) * 0.3 +
-                np.clip(entropy / 1000, 0, 1) * 0.4
-            ) * 100
-            
-            return float(texture_score)
-        except Exception as e:
-            print(f"Error in texture analysis: {str(e)}")
-            return 0.0
-
-    def _analyze_contrast(self, l_channel: np.ndarray, mask: np.ndarray) -> float:
-        """Analyze contrast with improved error handling."""
-        try:
-            if mask is None or np.sum(mask) == 0:
-                return 0.0
-                
-            zone_pixels = l_channel[mask > 0]
-            if len(zone_pixels) == 0:
-                return 0.0
-                
-            p5 = np.percentile(zone_pixels, 5)
-            p95 = np.percentile(zone_pixels, 95)
-            
-            contrast_score = np.clip((p95 - p5) / 255, 0, 1) * 100
-            return float(contrast_score)
-        except Exception as e:
-            print(f"Error in contrast analysis: {str(e)}")
-            return 0.0
-
-    def _detect_patterns(self, gray: np.ndarray, mask: np.ndarray) -> float:
-        """Detect patterns with improved error handling."""
-        try:
-            if mask is None or np.sum(mask) == 0:
-                return 0.0
-                
-            sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
-            sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
-            gradient = np.sqrt(sobelx**2 + sobely**2)
-            
-            zone_gradient = gradient[mask > 0]
-            if len(zone_gradient) == 0 or np.max(gradient) == 0:
-                return 0.0
-                
-            pattern_score = np.clip((np.mean(zone_gradient) / np.max(gradient)), 0, 1) * 100
-            return float(pattern_score)
-        except Exception as e:
-            print(f"Error in pattern detection: {str(e)}")
-            return 0.0
-
-    def _customize_conditions(self, base_conditions: List[str], metrics: Dict) -> List[str]:
-        """Customize conditions based on metrics."""
-        customized = []
-        for condition in base_conditions:
-            if metrics["intensity"] < 50:
-                condition += " (intensidade muito baixa)"
-            elif metrics["contrast"] < 30:
-                condition += " (baixo contraste)"
-            
-            if metrics["patterns"] > 70:
-                condition += " (padrões significativos detectados)"
-            
-            customized.append(condition)
-        return customized
-
-    def _customize_recommendations(self, base_recommendations: List[str], metrics: Dict) -> List[str]:
-        """Customize recommendations based on metrics."""
-        customized = []
-        for rec in base_recommendations:
-            if metrics["texture"] < 40:
-                rec += " (prioridade alta)"
-            elif metrics["saturation"] < 50:
-                rec += " (atenção especial necessária)"
-            
-            customized.append(rec)
-        return customized
-
-    def _calculate_confidence(self, metrics: Dict) -> str:
-        """Calculate analysis confidence level."""
-        confidence_score = (
-            metrics["intensity"] * 0.25 +
-            metrics["contrast"] * 0.25 +
-            metrics["texture"] * 0.25 +
-            metrics["patterns"] * 0.25
-        )
-        
-        if confidence_score > 75:
-            return "alta"
-        elif confidence_score > 50:
-            return "média"
-        else:
-            return "baixa"
-
-    def analyze_iris(self, image: np.ndarray) -> Tuple[np.ndarray, Dict]:
-        """Main analysis function with improved error handling and image processing."""
-        try:
-            # Convert BGR to RGB if needed
-            if len(image.shape) == 2:
-                image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
-            elif image.shape[2] == 4:
-                image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)
-            
-            # Create copies for different color spaces
-            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-            hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-            lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
-            
-            # Improve circle detection
-            circles = cv2.HoughCircles(
-                gray,
-                cv2.HOUGH_GRADIENT,
-                dp=1,
-                minDist=max(gray.shape[0], gray.shape[1]),  # Only detect one circle
-                param1=50,
-                param2=30,
-                minRadius=min(gray.shape) // 6,
-                maxRadius=min(gray.shape) // 2
-            )
-            
-            if circles is not None:
-                circles = np.uint16(np.around(circles))
-                circle = circles[0][0]
-                center = (int(circle[0]), int(circle[1]))
-                radius = int(circle[2])
-            else:
-                # Fallback to image center if no circle is detected
-                center = (image.shape[1] // 2, image.shape[0] // 2)
-                radius = min(image.shape[:2]) // 4
-            
-            results = {
-                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "analysis": {},
-                "metrics": {
-                    "iris_radius": radius,
-                    "image_quality": self._assess_image_quality(image)
-                }
-            }
-            
-            # Analysis for each zone
-            for zone in self.zones:
-                inner_r = int(radius * zone.ratio[0])
-                outer_r = int(radius * zone.ratio[1])
-                
-                # Create zone mask
-                mask = np.zeros(gray.shape, dtype=np.uint8)
-                cv2.circle(mask, center, outer_r, 255, -1)
-                cv2.circle(mask, center, inner_r, 0, -1)
-                
-                # Calculate metrics
-                zone_metrics = {
-                    "intensity": float(cv2.mean(gray, mask=mask)[0]),
-                    "saturation": float(cv2.mean(hsv[..., 1], mask=mask)[0]),
-                    "texture": self._analyze_texture(gray, mask),
-                    "contrast": self._analyze_contrast(lab[..., 0], mask),
-                    "patterns": self._detect_patterns(gray, mask)
-                }
-                
-                # Calculate health score
-                health_score = (
-                    zone_metrics["intensity"] * 0.3 +
-                    zone_metrics["saturation"] * 0.2 +
-                    zone_metrics["texture"] * 0.2 +
-                    zone_metrics["contrast"] * 0.15 +
-                    zone_metrics["patterns"] * 0.15
-                )
-                
-                # Determine health level
-                level = "baixa" if health_score < 40 else ("media" if health_score < 75 else "alta")
-                
-                # Store results
-                results["analysis"][zone.name] = {
-                    "conditions": self._customize_conditions(zone.conditions[level], zone_metrics),
-                    "recommendations": self._customize_recommendations(zone.recommendations[level], zone_metrics),
-                    "metrics": {k: float(v) for k, v in zone_metrics.items()},
-                    "health_score": float(health_score),
-                    "status": level,
-                    "confianca_analise": self._calculate_confidence(zone_metrics)
-                }
-                
-                # Draw zone visualization
-                cv2.circle(image, center, outer_r, zone.color, 2)
-                cv2.putText(
-                    image,
-                    zone.name,
-                    (center[0] - outer_r, center[1] + outer_r),
-                    cv2.FONT_HERSHEY_SIMPLEX,
-                    0.5,
-                    zone.color,
-                    1,
-                    cv2.LINE_AA
-                )
-            
-            return image, results
-            
-        except Exception as e:
-            print(f"Error in iris analysis: {str(e)}")
-            return image, {"error": str(e)}
-
-def process_image(img: Optional[np.ndarray]) -> Tuple[Optional[np.ndarray], str, str, str, str]:
-    """Process image with improved error handling and input validation."""
-    if img is None:
-        return None, "⚠️ Por favor, carregue uma imagem.", "", "", ""
+from PIL import Image
+import io
+
+def analisar_iris(imagem):
+    """
+    Função para analisar a íris através de processamento de imagem
+    """
+    # Converter para array numpy
+    img_array = np.array(imagem)
     
-    try:
-        analyzer = IrisAnalyzer()
-        processed_img, results = analyzer.analyze_iris(img)
-        
-        if "error" in results:
-            return None, f"⚠️ Erro na análise: {results['error']}", "", "", ""
-        
-        # Generate reports
-        general_report = "# 📊 Visão Geral da Análise\n\n"
-        status_counts = {"baixa": 0, "media": 0, "alta": 0}
-        
-        for analysis in results["analysis"].values():
-            status_counts[analysis["status"]] += 1
-        
-        health_score = (
-            (status_counts["alta"] * 100 + status_counts["media"] * 50) /
-            max(1, len(results["analysis"]))
-        )
-        
-        general_report += (
-            f"**Índice de Saúde Geral:** {health_score:.1f}%\n\n"
-            f"**Data da Análise:** {results['timestamp']}\n\n"
-            f"**Qualidade da Imagem:** {results['metrics']['image_quality']:.1f}%\n\n"
-        )
-        
-        # Detailed reports
-        detailed_conditions = "# 🔍 Análise Detalhada por Zona\n\n"
-        recommendations = "# 💡 Recomendações Personalizadas\n\n"
-        health_alerts = "# ⚠️ Alertas e Atenção Especial\n\n"
-        
-        for zone_name, analysis in results["analysis"].items():
-            # Add detailed conditions
-            detailed_conditions += f"## {zone_name}\n\n"
-            detailed_conditions += "### Condições Identificadas:\n"
-            for condition in analysis["conditions"]:
-                detailed_conditions += f"- {condition}\n"
-            detailed_conditions += (
-                f"\n**Status:** {analysis['status'].title()}\n"
-                f"**Confiança da Análise:** {analysis['confianca_analise']}\n"
-                "**Métricas Detalhadas:**\n"
-            )
-            for metric, value in analysis["metrics"].items():
-                detailed_conditions += f"- {metric.replace('_', ' ').title()}: {value:.1f}\n"
-            detailed_conditions += "\n"
-            
-            # Add recommendations
-            recommendations += f"## {zone_name}\n\n"
-            for rec in analysis["recommendations"]:
-                recommendations += f"- {rec}\n"
-            recommendations += "\n"
-            
-            # Add health alerts
-            if analysis["status"] == "baixa" or analysis["metrics"]["health_score"] < 50:
-                health_alerts += f"## {zone_name}\n"
-                health_alerts += "### Pontos de Atenção:\n"
-                for condition in analysis["conditions"]:
-                    health_alerts += f"- ⚠️ {condition}\n"
-                health_alerts += "\n### Ações Recomendadas:\n"
-                for rec in analysis["recommendations"]:
-                    health_alerts += f"- ✅ {rec}\n"
-                health_alerts += "\n"
-        
-        return processed_img, general_report, detailed_conditions, recommendations, health_alerts
-        
-    except Exception as e:
-        error_message = f"⚠️ Erro no processamento: {str(e)}"
-        return None, error_message, "", "", ""
-
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft()) as iface:
-    gr.Markdown("""
-    # 🔍 Analisador Avançado de Íris
-    ### Sistema Educacional de Análise Iridológica v2.0
+    # Converter para escala de cinza
+    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
     
-    ⚠️ Este é um sistema para fins educacionais. Não utilize para diagnósticos médicos.
-    """)
+    # Detectar círculos (íris) usando transformada de Hough
+    circles = cv2.HoughCircles(
+        gray,
+        cv2.HOUGH_GRADIENT,
+        dp=1,
+        minDist=50,
+        param1=50,
+        param2=30,
+        minRadius=20,
+        maxRadius=100
+    )
     
-    with gr.Tabs() as tabs:
-        with gr.Tab("📸 Análise de Imagem"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    input_image = gr.Image(
-                        label="Upload da Imagem da Íris",
-                        type="numpy",
-                        sources=["upload", "webcam", "clipboard"],
-                        height=400
-                    )
-                    analyze_btn = gr.Button("🔍 Analisar Íris", variant="primary", size="lg")
-                
-                with gr.Column(scale=1):
-                    output_image = gr.Image(label="Visualização da Análise", height=400)
-        
-        with gr.Tab("📊 Resultados"):
-            with gr.Tabs() as result_tabs:
-                with gr.Tab("📈 Visão Geral"):
-                    general_output = gr.Markdown()
-                
-                with gr.Tab("🔍 Condições Detalhadas"):
-                    conditions_output = gr.Markdown()
-                
-                with gr.Tab("💡 Recomendações"):
-                    recommendations_output = gr.Markdown()
-                
-                with gr.Tab("⚠️ Alertas"):
-                    alerts_output = gr.Markdown()
-        
-        with gr.Tab("ℹ️ Informações"):
-            gr.Markdown("""
-            ## 📚 Sobre a Análise Iridológica
-
-            ### 🎯 Zonas Analisadas:
-            1. **Zona Cerebral/Neural** - Sistema nervoso central e periférico
-            2. **Zona Digestiva** - Sistema digestório completo
-            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
-
-            ### 📋 Como Usar:
-            1. Faça upload de uma imagem clara da íris
-            2. Clique em "Analisar Íris"
-            3. Verifique os resultados nas diferentes abas
-            4. Consulte os alertas e recomendações
-
-            ### 🔍 Interpretação dos Resultados:
-            - **Visão Geral**: Índice geral de saúde e qualidade da análise
-            - **Condições**: Análise detalhada por zona
-            - **Recomendações**: Sugestões personalizadas
-            - **Alertas**: Pontos que requerem atenção especial
-
-            ### ⚠️ Observações Importantes:
-            - Sistema para fins educacionais
-            - Não substitui avaliação médica
-            - Consulte profissionais de saúde
-            - Mantenha check-ups regulares
-            """)
+    # Criar cópia da imagem para desenhar
+    output = img_array.copy()
+    
+    resultados = []
+    
+    if circles is not None:
+        circles = np.uint16(np.around(circles))
+        for i in circles[0, :]:
+            # Desenhar círculo externo
+            cv2.circle(output, (i[0], i[1]), i[2], (0, 255, 0), 2)
+            # Desenhar centro
+            cv2.circle(output, (i[0], i[1]), 2, (0, 0, 255), 3)
+            
+            # Análise de características
+            roi = gray[i[1]-i[2]:i[1]+i[2], i[0]-i[2]:i[0]+i[2]]
+            if roi.size > 0:
+                media = np.mean(roi)
+                std = np.std(roi)
+                
+                resultados.append(f"Análise da Íris:")
+                resultados.append(f"- Densidade média: {media:.2f}")
+                resultados.append(f"- Variação de textura: {std:.2f}")
+                
+                # Análise de setores
+                altura, largura = roi.shape
+                setor_superior = np.mean(roi[:altura//3, :])
+                setor_medio = np.mean(roi[altura//3:2*altura//3, :])
+                setor_inferior = np.mean(roi[2*altura//3:, :])
+                
+                resultados.append("\nAnálise por Setores:")
+                resultados.append(f"- Setor Superior: {setor_superior:.2f}")
+                resultados.append(f"- Setor Médio: {setor_medio:.2f}")
+                resultados.append(f"- Setor Inferior: {setor_inferior:.2f}")
+    
+    return output, "\n".join(resultados)
+
+def gerar_relatorio(imagem, nome_paciente, idade, data_analise):
+    """
+    Função para gerar relatório completo da análise
+    """
+    img_array = np.array(imagem)
+    resultado_analise, metricas = analisar_iris(imagem)
+    
+    relatorio = f"""
+    RELATÓRIO DE ANÁLISE IRIDOLÓGICA
+    
+    Data: {data_analise}
     
-    # Event handlers
-    analyze_btn.click(
-        fn=process_image,
-        inputs=input_image,
-        outputs=[
-            output_image,
-            general_output,
-            conditions_output,
-            recommendations_output,
-            alerts_output
-        ]
+    DADOS DO PACIENTE
+    Nome: {nome_paciente}
+    Idade: {idade}
+    
+    ANÁLISE TÉCNICA
+    {metricas}
+    
+    OBSERVAÇÕES GERAIS
+    - Análise realizada com processamento computadorizado de imagem
+    - Recomenda-se acompanhamento profissional para interpretação detalhada
+    """
+    
+    return relatorio
+
+def main():
+    # Configuração do tema
+    theme = gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="gray",
+    ).set(
+        body_background_fill="*neutral_50",
+        block_background_fill="*neutral_100",
+        button_primary_background_fill="*primary_500",
     )
+    
+    # Criação da interface
+    with gr.Blocks(theme=theme, title="Análise Iridológica") as iface:
+        gr.Markdown("# Sistema de Análise Iridológica")
+        
+        with gr.Tabs():
+            # Aba de Análise Básica
+            with gr.Tab("Análise Básica"):
+                with gr.Row():
+                    with gr.Column():
+                        input_image = gr.Image(label="Carregar Imagem da Íris", type="pil")
+                    with gr.Column():
+                        output_image = gr.Image(label="Íris Analisada")
+                        output_text = gr.Textbox(label="Resultados da Análise", lines=10)
+                
+                analyze_btn = gr.Button("Realizar Análise", variant="primary")
+                analyze_btn.click(
+                    fn=analisar_iris,
+                    inputs=[input_image],
+                    outputs=[output_image, output_text]
+                )
+            
+            # Aba de Relatório Completo
+            with gr.Tab("Relatório Completo"):
+                with gr.Row():
+                    with gr.Column():
+                        nome_input = gr.Textbox(label="Nome do Paciente")
+                        idade_input = gr.Number(label="Idade", minimum=0, maximum=120)
+                        data_input = gr.Textbox(label="Data da Análise")
+                        report_image = gr.Image(label="Carregar Imagem da Íris", type="pil")
+                    
+                    with gr.Column():
+                        report_output = gr.Textbox(label="Relatório Completo", lines=15)
+                
+                report_btn = gr.Button("Gerar Relatório", variant="primary")
+                report_btn.click(
+                    fn=gerar_relatorio,
+                    inputs=[report_image, nome_input, idade_input, data_input],
+                    outputs=[report_output]
+                )
+            
+            # Aba de Informações
+            with gr.Tab("Informações"):
+                gr.Markdown("""
+                ## Sobre a Análise Iridológica
+                
+                A iridologia é uma técnica de análise que estuda os sinais presentes na íris dos olhos 
+                para avaliar características e condições do organismo. Este sistema realiza uma análise 
+                computadorizada preliminar, que deve ser interpretada por um profissional qualificado.
+                
+                ### Recursos do Sistema:
+                1. Análise básica da íris com detecção automática
+                2. Medições de densidade e textura
+                3. Análise setorial da íris
+                4. Geração de relatórios personalizados
+                
+                ### Recomendações:
+                - Utilize fotos em boa resolução
+                - Certifique-se de que a íris está bem iluminada
+                - A imagem deve estar focada e nítida
+                """)
+    
+    # Iniciar a interface
+    iface.launch(share=True)
 
 if __name__ == "__main__":
-    iface.launch()
+    main()