app.py

import gradio as gr
import cv2
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Tuple
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]]  # Detailed health conditions
    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:
        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
        brightness = np.mean(gray)
        contrast = np.std(gray)
        
        quality_score = (
            min(blur_score / 500, 1) * 0.4 +
            min(abs(brightness - 128) / 128, 1) * 0.3 +
            min(contrast / 50, 1) * 0.3
        ) * 100
        
        return quality_score

    def _analyze_texture(self, gray: np.ndarray, mask: np.ndarray) -> float:
        zone_pixels = cv2.bitwise_and(gray, gray, mask=mask)
        if np.sum(mask) == 0:
            return 0
            
        mean = np.mean(zone_pixels[mask > 0])
        std = np.std(zone_pixels[mask > 0])
        entropy = np.sum(np.abs(np.diff(zone_pixels[mask > 0])))
        
        texture_score = (mean * 0.3 + std * 0.3 + min(entropy/1000, 1) * 0.4) * 100
        return min(texture_score, 100)

    def _analyze_contrast(self, l_channel: np.ndarray, mask: np.ndarray) -> float:
        if np.sum(mask) == 0:
            return 0
            
        zone_pixels = l_channel[mask > 0]
        p5 = np.percentile(zone_pixels, 5)
        p95 = np.percentile(zone_pixels, 95)
        
        contrast_score = ((p95 - p5) / 255) * 100
        return min(contrast_score, 100)

    def _detect_patterns(self, gray: np.ndarray, mask: np.ndarray) -> float:
        if np.sum(mask) == 0:
            return 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]
        pattern_score = (np.mean(zone_gradient) / np.max(gradient)) * 100
        return min(pattern_score, 100)

    def _customize_conditions(self, base_conditions: List[str], metrics: Dict) -> List[str]:
        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]:
        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:
        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) -> Dict:
        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
        
        circles = cv2.HoughCircles(
            gray, cv2.HOUGH_GRADIENT, dp=1, minDist=100,
            param1=50, param2=30, minRadius=50, maxRadius=150
        )
        
        if circles is not None:
            circle = circles[0][0]
            center = (int(circle[0]), int(circle[1]))
            radius = int(circle[2])
        else:
            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)
            }
        }
        
        for zone in self.zones:
            inner_r = int(radius * zone.ratio[0])
            outer_r = int(radius * zone.ratio[1])
            
            mask = np.zeros(gray.shape, dtype=np.uint8)
            cv2.circle(mask, center, outer_r, 255, -1)
            cv2.circle(mask, center, inner_r, 0, -1)
            
            zone_metrics = {
                "intensity": cv2.mean(gray, mask=mask)[0],
                "saturation": 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)
            }
            
            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
            )
            
            if health_score < 40:
                level = "baixa"
            elif health_score < 75:
                level = "media"
            else:
                level = "alta"
                
            results["analysis"][zone.name] = {
                "conditions": self._customize_conditions(zone.conditions[level], zone_metrics),
                "recommendations": self._customize_recommendations(zone.recommendations[level], zone_metrics),
                "metrics": {
                    "intensity": float(zone_metrics["intensity"]),
                    "saturation": float(zone_metrics["saturation"]),
                    "texture": float(zone_metrics["texture"]),
                    "contrast": float(zone_metrics["contrast"]),
                    "patterns": float(zone_metrics["patterns"]),
                    "health_score": float(health_score)
                },
                "status": level,
                "confianca_analise": self._calculate_confidence(zone_metrics)
            }
            
            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)
        
        return image, results

def process_image(img):
    if img is None:
        return [None] * 5, gr.Warning("Por favor, carregue uma imagem.")
    
    analyzer = IrisAnalyzer()
    processed_img, results = analyzer.analyze_iris(img)
    
    # Relatório Geral
    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)) / len(results["analysis"])
    general_report += f"**Índice de Saúde Geral:** {health_score:.1f}%\n\n"
    general_report += f"**Data da Análise:** {results['timestamp']}\n\n"
    general_report += "**Qualidade da Imagem:** {:.1f}%\n\n".format(results['metrics']['image_quality'])
    
    # Condições Detalhadas
    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():
        # 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"
        detailed_conditions += f"**Confiança da Análise:** {analysis['confianca_analise']}\n"
        detailed_conditions += "**Métricas Detalhadas:**\n"
        for metric, value in analysis["metrics"].items():
            detailed_conditions += f"- {metric.replace('_', ' ').title()}: {value:.1f}\n"
        detailed_conditions += "\n"
        
        # Recommendations
        recommendations += f"## {zone_name}\n\n"
        for rec in analysis["recommendations"]:
            recommendations += f"- {rec}\n"
        recommendations += "\n"
        
        # 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
    ]

# Interface Gradio
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
    
    ⚠️ Este é um sistema para fins educacionais. Não utilize para diagnósticos médicos.
    """)
    
    with gr.Tabs() as tabs:
        with gr.Tab("📸 Análise de Imagem", id=1):
            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", id=2):
            with gr.Tabs() as result_tabs:
                with gr.Tab("📈 Visão Geral", id=2.1):
                    general_output = gr.Markdown()
                
                with gr.Tab("🔍 Condições Detalhadas", id=2.2):
                    conditions_output = gr.Markdown()
                
                with gr.Tab("💡 Recomendações", id=2.3):
                    recommendations_output = gr.Markdown()
                
                with gr.Tab("⚠️ Alertas", id=2.4):
                    alerts_output = gr.Markdown()
        
        with gr.Tab("ℹ️ Informações", id=3):
            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
            """)
    
    # Configurar eventos
    analyze_btn.click(
        fn=process_image,
        inputs=input_image,
        outputs=[
            output_image,
            general_output,
            conditions_output,
            recommendations_output,
            alerts_output
        ]
    )

if __name__ == "__main__":
    iface.launch()