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