app.py

import gradio as gr
import numpy as np
import cv2
from dataclasses import dataclass
from typing import Dict, List, Tuple, Optional
import json

@dataclass
class IrisCharacteristics:
    color: str
    density: str
    structure: str
    marks: List[str]
    regions: Dict[str, List[str]]

class AdvancedIridologyAnalyzer:
    def __init__(self):
        # Classificação de cores da íris
        self.iris_colors = {
            'azul': {
                'range': [(200, 220, 220), (240, 255, 255)],
                'characteristics': ['Sistema linfático sensível', 'Tendência à acidez', 'Sensibilidade digestiva']
            },
            'castanho': {
                'range': [(0, 60, 60), (20, 150, 150)],
                'characteristics': ['Sistema imunológico robusto', 'Metabolismo mais ativo', 'Tendência à alcalinidade']
            },
            'verde': {
                'range': [(35, 50, 50), (85, 255, 255)],
                'characteristics': ['Misto de características', 'Adaptabilidade metabólica', 'Sensibilidade moderada']
            },
            'misto': {
                'characteristics': ['Complexidade constitucional', 'Variabilidade metabólica', 'Adaptação mista']
            }
        }

        # Mapa detalhado de órgãos e sistemas
        self.detailed_iris_map = {
            'zona_pupilar': {
                'órgãos': ['Estômago', 'Intestino delgado'],
                'significados': {
                    'escuro': 'Possível estagnação digestiva',
                    'claro': 'Hiperatividade digestiva',
                    'irregular': 'Disbiose potencial'
                }
            },
            'zona_ciliar': {
                'órgãos': ['Coração', 'Pulmões', 'Fígado', 'Rins'],
                'significados': {
                    'manchas': 'Sobrecarga orgânica',
                    'lacunas': 'Deficiência funcional',
                    'anéis': 'Tensão crônica'
                }
            },
            'zona_periférica': {
                'órgãos': ['Pele', 'Sistema linfático', 'Circulação'],
                'significados': {
                    'pigmentos': 'Deposição tóxica',
                    'raios': 'Eliminação prejudicada',
                    'nuvens': 'Congestão linfática'
                }
            }
        }

        # Constituições iridianas
        self.constitutions = {
            'linfática': {
                'características': ['Íris azul clara', 'Fibras separadas', 'Aspecto rendilhado'],
                'tendências': ['Alergias', 'Problemas respiratórios', 'Sensibilidade digestiva']
            },
            'hematogênica': {
                'características': ['Íris castanha', 'Fibras densas', 'Aspecto compacto'],
                'tendências': ['Inflamações', 'Problemas circulatórios', 'Metabolismo acelerado']
            },
            'mista': {
                'características': ['Íris heterocromática', 'Padrões mistos', 'Variações estruturais'],
                'tendências': ['Adaptabilidade', 'Reações mistas', 'Variabilidade sintomática']
            }
        }

    def detect_iris_color(self, image: np.ndarray) -> str:
        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
        mean_color = np.mean(hsv, axis=(0, 1))
        
        # Lógica melhorada para detecção de cor
        if mean_color[0] < 20:  # Matiz
            return 'castanho'
        elif 20 <= mean_color[0] < 85:
            return 'verde'
        elif mean_color[0] >= 85:
            return 'azul'
        return 'misto'

    def analyze_density(self, gray_region: np.ndarray) -> str:
        std_dev = np.std(gray_region)
        if std_dev < 15:
            return 'muito_densa'
        elif std_dev < 30:
            return 'densa'
        elif std_dev < 45:
            return 'normal'
        else:
            return 'esparsa'

    def detect_marks(self, region: np.ndarray) -> List[str]:
        marks = []
        gray = cv2.cvtColor(region, cv2.COLOR_BGR2GRAY)
        
        # Detecção de lacunas
        _, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
        contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        if len(contours) > 5:
            marks.append('lacunas')

        # Detecção de anéis de tensão
        circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1, 20, 
                                 param1=50, param2=30, minRadius=5, maxRadius=30)
        if circles is not None:
            marks.append('anéis_de_tensão')

        # Detecção de radii solaris
        edges = cv2.Canny(gray, 50, 150)
        lines = cv2.HoughLines(edges, 1, np.pi/180, 100)
        if lines is not None and len(lines) > 10:
            marks.append('radii_solaris')

        return marks

    def analyze_specific_regions(self, image: np.ndarray, iris_center: Tuple[int, int], 
                               iris_radius: int) -> Dict[str, List[str]]:
        regions_analysis = {}
        angles = {
            'cerebral': (75, 105),
            'digestivo': (255, 285),
            'circulatório': (165, 195),
            'respiratório': (345, 15)
        }

        for region_name, (start_angle, end_angle) in angles.items():
            mask = np.zeros(image.shape[:2], dtype=np.uint8)
            cv2.ellipse(mask, center=iris_center, axes=(iris_radius, iris_radius),
                       angle=0, startAngle=start_angle, endAngle=end_angle,
                       color=255, thickness=-1)
            
            region = cv2.bitwise_and(image, image, mask=mask)
            findings = []
            
            # Análise específica por região
            if region_name == 'cerebral':
                if np.mean(region) > 150:
                    findings.append('Alta atividade cerebral')
                elif np.mean(region) < 100:
                    findings.append('Possível fadiga mental')
                    
            elif region_name == 'digestivo':
                std_dev = np.std(region)
                if std_dev > 40:
                    findings.append('Irregularidade digestiva')
                if np.mean(region) < 100:
                    findings.append('Possível estagnação')
                    
            elif region_name == 'circulatório':
                if np.mean(region) > 160:
                    findings.append('Hiperatividade circulatória')
                edges = cv2.Canny(region, 100, 200)
                if np.sum(edges) > 1000:
                    findings.append('Tensão vascular')
                    
            elif region_name == 'respiratório':
                if np.mean(region) < 90:
                    findings.append('Congestão respiratória')
                if np.std(region) > 45:
                    findings.append('Sensibilidade pulmonar')

            regions_analysis[region_name] = findings

        return regions_analysis

    def generate_recommendations(self, characteristics: IrisCharacteristics) -> List[str]:
        recommendations = []
        
        # Recomendações baseadas na cor
        if characteristics.color == 'azul':
            recommendations.extend([
                'Fortalecer sistema imunológico',
                'Equilibrar pH corporal',
                'Cuidados com sistema linfático'
            ])
        elif characteristics.color == 'castanho':
            recommendations.extend([
                'Monitorar níveis inflamatórios',
                'Atenção à circulação',
                'Suporte hepático preventivo'
            ])

        # Recomendações baseadas na densidade
        if characteristics.density == 'esparsa':
            recommendations.extend([
                'Suplementação mineral',
                'Fortalecimento tecidual',
                'Avaliação nutricional completa'
            ])

        # Recomendações baseadas em marcas específicas
        if 'lacunas' in characteristics.marks:
            recommendations.extend([
                'Terapia regenerativa tecidual',
                'Suporte orgânico específico'
            ])
        if 'anéis_de_tensão' in characteristics.marks:
            recommendations.extend([
                'Técnicas de gerenciamento de estresse',
                'Terapias de relaxamento'
            ])

        return recommendations

    def analyze_iris(self, image) -> str:
        if image is None:
            return "Erro: Imagem não fornecida."
    
        if len(image.shape) == 2:
            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
    
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (7, 7), 0)
    
        circles = cv2.HoughCircles(
            blurred,
            cv2.HOUGH_GRADIENT,
            dp=1,
            minDist=50,
            param1=50,
            param2=30,
            minRadius=20,
            maxRadius=100
        )
    
        if circles is None:
            return "Não foi possível detectar a íris na imagem. Tente uma imagem mais clara ou de melhor qualidade."
    
        x, y, r = np.round(circles[0][0]).astype(int)
        
        iris_color = self.detect_iris_color(image)
        density = self.analyze_density(gray)
        marks = self.detect_marks(image)
        regions = self.analyze_specific_regions(image, (x, y), r)
    
        characteristics = IrisCharacteristics(
            color=iris_color,
            density=density,
            structure='regular' if np.std(gray) < 40 else 'irregular',
            marks=marks,
            regions=regions
        )
    
        recommendations = self.generate_recommendations(characteristics)
    
        # Formatted result
        result = [
            "=== ANÁLISE IRIDIOLÓGICA COMPLETA ===\n",
            f"Cor da Íris: {iris_color.upper()}",
            f"Densidade: {density.upper()}",
            f"Estrutura: {characteristics.structure.upper()}\n",
            "=== MARCAS DETECTADAS ==="
        ]
    
        # Append marks or a message if none are detected
        if marks:
            result.extend([f"- {mark}" for mark in marks])
        else:
            result.append("Nenhuma marca detectada.")
    
        result.append("\n=== ANÁLISE POR REGIÃO ===")
    
        for region, findings in regions.items():
            if findings:
                result.append(f"\n{region.upper()}:")
                result.extend([f"- {finding}" for finding in findings])
    
        result.extend([
            "\n=== RECOMENDAÇÕES ===",
            *[f"- {rec}" for rec in recommendations],
            "\nOBSERVAÇÃO: Esta análise é apenas para fins educativos e não substitui diagnóstico médico profissional."
        ])
    
        return "\n".join(result)
    

# Interface Gradio
iface = gr.Interface(
    fn=lambda img: AdvancedIridologyAnalyzer().analyze_iris(img),
    inputs=gr.Image(),
    outputs=gr.Textbox(label="Resultado da Análise", lines=25),
    title="Análise Iridiológica Avançada",
    description="Faça upload de uma imagem clara do olho para análise iridiológica detalhada",
    theme="default"
)

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