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()