Spaces:
Sleeping
Sleeping
| 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() |