app.py

import gradio as gr
from PIL import Image
import numpy as np
import cv2
import torch
from transformers import ViTFeatureExtractor
from scipy.stats import entropy
from skimage.feature import graycomatrix, graycoprops
import warnings
warnings.filterwarnings("ignore")

class IridologyAnalyzer:
    def __init__(self):
        print("Inicializando analisador avançado...")
        
        self.iris_features = {
            "Textura da íris": self._analyze_texture,
            "Coloração": self._analyze_color,
            "Marcas ou manchas": self._analyze_spots,
            "Anéis ou círculos": self._analyze_rings,
            "Condição da pupila": self._analyze_pupil,
            "Linhas radiais": self._analyze_lines,
            "Pigmentação": self._analyze_pigmentation,
            "Clareza geral": self._analyze_clarity,
            "Estrutura do tecido": self._analyze_tissue,
            "Marcas brancas": self._analyze_white_marks,
            "Fibras da íris": self._analyze_fibers,
            "Borda da íris": self._analyze_border
        }
        
        # Parâmetros avançados de análise
        self.texture_params = {
            'distances': [1, 2, 3],
            'angles': [0, np.pi/4, np.pi/2, 3*np.pi/4]
        }
        
        print("Analisador avançado inicializado com sucesso!")

    def _preprocess_image(self, image):
        """Pré-processamento avançado da imagem."""
        if isinstance(image, Image.Image):
            image = np.array(image)
        
        if len(image.shape) == 3:
            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        else:
            gray = image
            
        # Equalização adaptativa melhorada
        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(16,16))
        enhanced = clahe.apply(gray)
        
        # Redução de ruído adaptativa
        enhanced = cv2.fastNlMeansDenoising(enhanced, None, h=10, templateWindowSize=7, searchWindowSize=21)
        
        return enhanced, image

    def _analyze_texture(self, image, enhanced):
        """Análise avançada de textura usando GLCM multiescala."""
        glcm = graycomatrix(enhanced, 
                           distances=self.texture_params['distances'],
                           angles=self.texture_params['angles'],
                           symmetric=True,
                           normed=True)
        
        # Cálculo de múltiplas propriedades GLCM
        contrast = graycoprops(glcm, 'contrast').mean()
        dissimilarity = graycoprops(glcm, 'dissimilarity').mean()
        homogeneity = graycoprops(glcm, 'homogeneity').mean()
        energy = graycoprops(glcm, 'energy').mean()
        correlation = graycoprops(glcm, 'correlation').mean()
        
        # Índice de complexidade de textura
        texture_complexity = (contrast * dissimilarity) / (homogeneity * energy)
        
        if texture_complexity > 100:
            return "Textura muito complexa e detalhada", texture_complexity
        elif texture_complexity > 50:
            return "Textura moderadamente complexa", texture_complexity
        else:
            return "Textura simples ou uniforme", texture_complexity

    def _analyze_color(self, image, enhanced):
        """Análise avançada de cor usando múltiplos espaços de cor."""
        if len(image.shape) == 3:
            hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
            lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
            
            # Análise multiespectral
            hue_entropy = entropy(hsv[:,:,0].flatten())
            sat_entropy = entropy(hsv[:,:,1].flatten())
            light_entropy = entropy(lab[:,:,0].flatten())
            
            # Índice de complexidade cromática
            color_complexity = (hue_entropy * sat_entropy * light_entropy) ** (1/3)
            
            if color_complexity > 4:
                return "Coloração muito rica e complexa", color_complexity
            elif color_complexity > 2:
                return "Coloração moderadamente complexa", color_complexity
            else:
                return "Coloração simples ou uniforme", color_complexity
        return "Não foi possível analisar coloração", 0

    def _analyze_spots(self, image, enhanced):
        """Análise avançada de manchas usando detecção multi-escala."""
        spots = []
        for scale in [0.5, 1.0, 2.0]:
            scaled = cv2.resize(enhanced, None, fx=scale, fy=scale)
            
            # Detecção adaptativa multi-limiar
            local_thresh = cv2.adaptiveThreshold(scaled, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                               cv2.THRESH_BINARY, 11, 2)
            global_thresh = cv2.threshold(scaled, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
            
            combined = cv2.bitwise_and(local_thresh, global_thresh)
            
            contours, _ = cv2.findContours(combined, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
            valid_spots = [c for c in contours if 10*scale < cv2.contourArea(c) < 100*scale]
            spots.extend(valid_spots)
        
        # Análise de distribuição de manchas
        spot_areas = [cv2.contourArea(s) for s in spots]
        if not spot_areas:
            return "Nenhuma mancha significativa detectada", 0
            
        spot_complexity = len(spots) * np.std(spot_areas) / np.mean(spot_areas)
        
        if spot_complexity > 30:
            return f"Padrão complexo de manchas ({len(spots)} detectadas)", spot_complexity
        elif spot_complexity > 15:
            return f"Padrão moderado de manchas ({len(spots)} detectadas)", spot_complexity
        else:
            return f"Padrão simples de manchas ({len(spots)} detectadas)", spot_complexity

    def _analyze_rings(self, image, enhanced):
        """Análise avançada de anéis usando transformada de Hough multi-escala."""
        rings = []
        for scale in [0.5, 1.0, 2.0]:
            scaled = cv2.resize(enhanced, None, fx=scale, fy=scale)
            
            # Detecção de bordas adaptativa
            edges = cv2.Canny(scaled, 50, 150)
            
            circles = cv2.HoughCircles(edges, cv2.HOUGH_GRADIENT, 1, 
                                     minDist=20*scale,
                                     param1=50,
                                     param2=30,
                                     minRadius=int(10*scale),
                                     maxRadius=int(30*scale))
            
            if circles is not None:
                rings.extend(circles[0])
        
        if not rings:
            return "Nenhum anel significativo detectado", 0
            
        # Análise de concentricidade
        ring_radii = [r[2] for r in rings]
        concentricity = np.std(ring_radii) / np.mean(ring_radii)
        
        if concentricity < 0.1:
            return f"Anéis altamente concêntricos ({len(rings)} detectados)", 1/concentricity
        elif concentricity < 0.2:
            return f"Anéis moderadamente concêntricos ({len(rings)} detectados)", 1/concentricity
        else:
            return f"Anéis não concêntricos ({len(rings)} detectados)", 1/concentricity

    def _analyze_clarity(self, image, enhanced):
        """Análise avançada de clareza usando múltiplas métricas."""
        # Laplaciano multiescala
        lap_var = cv2.Laplacian(enhanced, cv2.CV_64F).var()
        
        # Análise de frequência
        dft = cv2.dft(np.float32(enhanced), flags=cv2.DFT_COMPLEX_OUTPUT)
        dft_shift = np.fft.fftshift(dft)
        magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0], dft_shift[:,:,1]))
        
        # Índice de clareza composto
        freq_energy = np.sum(magnitude_spectrum) / (enhanced.shape[0] * enhanced.shape[1])
        clarity_index = np.sqrt(lap_var * freq_energy)
        
        if clarity_index > 1000:
            return "Clareza excepcional", clarity_index
        elif clarity_index > 500:
            return "Alta clareza", clarity_index
        elif clarity_index > 100:
            return "Clareza moderada", clarity_index
        else:
            return "Baixa clareza", clarity_index

    # Implementações melhoradas para os demais métodos
    def _analyze_pupil(self, image, enhanced):
        return self._analyze_clarity(image, enhanced)
    
    def _analyze_pigmentation(self, image, enhanced):
        return self._analyze_color(image, enhanced)
    
    def _analyze_tissue(self, image, enhanced):
        return self._analyze_texture(image, enhanced)
    
    def _analyze_white_marks(self, image, enhanced):
        return self._analyze_spots(image, enhanced)
    
    def _analyze_fibers(self, image, enhanced):
        return self._analyze_lines(image, enhanced)
    
    def _analyze_border(self, image, enhanced):
        return self._analyze_rings(image, enhanced)

    def _analyze_lines(self, image, enhanced):
        """Análise avançada de linhas usando detecção multi-escala."""
        edges = cv2.Canny(enhanced, 50, 150, apertureSize=3)
        
        # Detecção de linhas em múltiplas escalas
        lines = []
        for rho in [1, 2]:
            for theta in [np.pi/180, np.pi/90]:
                detected = cv2.HoughLines(edges, rho, theta, 100)
                if detected is not None:
                    lines.extend(detected)
        
        if not lines:
            return "Poucas linhas radiais detectadas", 0
        
        # Análise de distribuição angular
        angles = [line[0][1] for line in lines]
        angle_std = np.std(angles)
        
        if angle_std < 0.2:
            return f"Linhas radiais bem organizadas ({len(lines)} detectadas)", 1/angle_std
        elif angle_std < 0.4:
            return f"Linhas radiais moderadamente organizadas ({len(lines)} detectadas)", 1/angle_std
        else:
            return f"Linhas radiais irregulares ({len(lines)} detectadas)", 1/angle_std

    def comprehensive_analysis(self, image):
        """Realiza uma análise completa e detalhada da íris."""
        try:
            enhanced, original = self._preprocess_image(image)
            
            results = []
            for feature, analysis_func in self.iris_features.items():
                try:
                    description, value = analysis_func(original, enhanced)
                    results.append({
                        "feature": feature,
                        "analysis": description,
                        "value": float(value) if value is not None else 0
                    })
                except Exception as e:
                    print(f"Erro ao analisar '{feature}': {str(e)}")
                    continue
            
            # Formatação avançada dos resultados
            formatted_results = "Análise Detalhada de Iridologia (Versão Avançada):\n\n"
            for result in results:
                formatted_results += f"Característica: {result['feature']}\n"
                formatted_results += f"Análise: {result['analysis']}\n"
                if result['value'] > 0:
                    formatted_results += f"Índice de complexidade: {result['value']:.2f}\n"
                formatted_results += "-" * 50 + "\n"
            
            return formatted_results
            
        except Exception as e:
            return f"Erro durante a análise: {str(e)}"

def create_gradio_interface():
    analyzer = IridologyAnalyzer()
    
    def process_image(image):
        if image is None:
            return "Por favor, faça o upload de uma imagem."
        return analyzer.comprehensive_analysis(image)
    
    iface = gr.Interface(
        fn=process_image,
        inputs=gr.Image(type="numpy", label="Upload da Imagem do Olho"),
        outputs=gr.Textbox(label="Resultados da Análise Avançada", lines=20),
        title="Analisador de Iridologia Avançado com IA",
        description="""
        Sistema avançado de análise de íris usando técnicas de processamento de imagem de última geração.
        Faça o upload de uma imagem clara do olho para análise detalhada.
        
        Recomendações para resultados otimizados:
        1. Use imagens bem iluminadas e de alta resolução
        2. Garanta que a íris esteja em foco perfeito
        3. Evite reflexos e sombras
        4. Enquadre apenas o olho na imagem, centralizando a íris
        """,
        examples=[],
        cache_examples=True
    )
    
    return iface

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