app.py

import gradio as gr
from PIL import Image
import numpy as np
import cv2
import torch
from transformers import ViTFeatureExtractor
import warnings
warnings.filterwarnings("ignore")

class IridologyAnalyzer:
    def __init__(self):
        print("Inicializando analisador...")
        
        # Características de iridologia para análise
        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
        }
        
        print("Analisador inicializado com sucesso!")

    def _preprocess_image(self, image):
        """Pré-processa a imagem para análise."""
        # Converter para array numpy se necessário
        if isinstance(image, Image.Image):
            image = np.array(image)
        
        # Converter para escala de cinza se for colorida
        if len(image.shape) == 3:
            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        else:
            gray = image
            
        # Aplicar equalização de histograma adaptativa
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
        enhanced = clahe.apply(gray)
        
        return enhanced, image

    def _analyze_texture(self, image, enhanced):
        """Analisa a textura da íris."""
        # Calcular métricas de textura usando GLCM
        glcm = cv2.GaussianBlur(enhanced, (5,5), 0)
        mean_val = np.mean(glcm)
        std_val = np.std(glcm)
        
        if std_val > 40:
            return "Alta texturização", std_val
        elif std_val > 20:
            return "Texturização moderada", std_val
        else:
            return "Baixa texturização", std_val

    def _analyze_color(self, image, enhanced):
        """Analisa a coloração da íris."""
        if len(image.shape) == 3:
            hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
            hue_mean = np.mean(hsv[:,:,0])
            sat_mean = np.mean(hsv[:,:,1])
            
            if sat_mean > 100:
                return "Coloração intensa", sat_mean
            elif sat_mean > 50:
                return "Coloração moderada", sat_mean
            else:
                return "Coloração suave", sat_mean
        return "Não foi possível analisar coloração", 0

    def _analyze_spots(self, image, enhanced):
        """Analisa manchas na íris."""
        # Detectar manchas usando thresholding adaptativo
        thresh = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                     cv2.THRESH_BINARY, 11, 2)
        contours, _ = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
        
        spot_count = len([c for c in contours if 10 < cv2.contourArea(c) < 100])
        
        if spot_count > 10:
            return f"Múltiplas manchas detectadas ({spot_count})", spot_count
        elif spot_count > 5:
            return f"Algumas manchas detectadas ({spot_count})", spot_count
        else:
            return f"Poucas ou nenhuma mancha detectada ({spot_count})", spot_count

    def _analyze_rings(self, image, enhanced):
        """Analisa anéis na íris."""
        circles = cv2.HoughCircles(enhanced, cv2.HOUGH_GRADIENT, 1, 20,
                                 param1=50, param2=30, minRadius=10, maxRadius=30)
        
        if circles is not None:
            circle_count = len(circles[0])
            return f"Detectados {circle_count} anéis/círculos", circle_count
        return "Nenhum anel/círculo detectado", 0

    def _analyze_lines(self, image, enhanced):
        """Analisa linhas radiais."""
        edges = cv2.Canny(enhanced, 50, 150, apertureSize=3)
        lines = cv2.HoughLines(edges, 1, np.pi/180, 100)
        
        if lines is not None:
            line_count = len(lines)
            return f"Detectadas {line_count} linhas radiais", line_count
        return "Poucas linhas radiais detectadas", 0

    def _analyze_clarity(self, image, enhanced):
        """Analisa a clareza geral da imagem."""
        laplacian_var = cv2.Laplacian(enhanced, cv2.CV_64F).var()
        
        if laplacian_var > 500:
            return "Alta clareza", laplacian_var
        elif laplacian_var > 100:
            return "Clareza moderada", laplacian_var
        else:
            return "Baixa clareza", laplacian_var

    # Implementações simplificadas 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 comprehensive_analysis(self, image):
        """Realiza uma análise completa 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": value
                    })
                except Exception as e:
                    print(f"Erro ao analisar '{feature}': {str(e)}")
                    continue
            
            # Formatar resultados
            formatted_results = "Análise Detalhada de Iridologia:\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"Intensidade: {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)
    
    # Interface Gradio
    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", lines=20),
        title="Analisador de Iridologia com IA",
        description="""
        Este sistema analisa imagens de íris usando técnicas avançadas de processamento de imagem.
        Faça o upload de uma imagem clara do olho para análise.
        
        Recomendações para melhores resultados:
        1. Use imagens bem iluminadas
        2. Garanta que a íris esteja em foco
        3. Evite reflexos excessivos
        4. Enquadre apenas o olho na imagem
        """,
        examples=[],
        cache_examples=True
    )
    
    return iface

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