import gradio as gr import cv2 import numpy as np from PIL import Image import io from collections import defaultdict from scipy import ndimage from skimage.feature import graycomatrix, graycoprops from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification import torch class AnalisadorIridologicoNLP: def __init__(self): # Usando o modelo multilingual BERT para português modelo = "neuralmind/bert-base-portuguese-cased" self.tokenizer = AutoTokenizer.from_pretrained(modelo) self.model = AutoModelForSequenceClassification.from_pretrained(modelo) # Dicionário de referência para interpretações self.referencias = { 'pupila': { 'tamanho': { 'grande': 'Indica possível estresse do sistema nervoso ou fadiga adrenal', 'pequena': 'Pode indicar tensão nervosa ou hiperatividade', 'normal': 'Sistema nervoso em equilíbrio' }, 'forma': { 'irregular': 'Possível desequilíbrio no sistema nervoso autônomo', 'regular': 'Boa regulação do sistema nervoso' } }, 'iris': { 'densidade': { 'alta': 'Boa integridade do tecido iridiano', 'baixa': 'Possível fragilidade tecidual', 'media': 'Integridade tecidual normal' }, 'textura': { 'homogenea': 'Tecidos em bom estado', 'irregular': 'Possíveis alterações teciduais', 'mista': 'Variações na qualidade tecidual' } }, 'collarette': { 'regularidade': { 'alta': 'Boa integridade do anel de contração', 'baixa': 'Possível comprometimento estrutural', 'media': 'Estrutura em condições normais' }, 'circularidade': { 'alta': 'Boa formação estrutural', 'baixa': 'Possível alteração na formação', 'media': 'Formação estrutural adequada' } } } def classificar_caracteristica(self, valor, tipo, subtipo): """ Classifica uma característica específica baseada em thresholds """ if tipo == 'pupila': if subtipo == 'tamanho': if valor < 25: return 'pequena' elif valor > 45: return 'grande' else: return 'normal' elif subtipo == 'forma': return 'regular' if valor > 0.85 else 'irregular' elif tipo == 'iris': if subtipo == 'densidade': if valor < 0.4: return 'baixa' elif valor > 0.7: return 'alta' else: return 'media' elif subtipo == 'textura': if valor < 0.3: return 'irregular' elif valor > 0.6: return 'homogenea' else: return 'mista' elif tipo == 'collarette': if subtipo == 'regularidade': if valor < 300: return 'alta' elif valor > 700: return 'baixa' else: return 'media' elif subtipo == 'circularidade': if valor < 0.7: return 'baixa' elif valor > 0.9: return 'alta' else: return 'media' return 'indefinido' def gerar_interpretacao(self, metricas): """ Gera uma interpretação em linguagem natural das métricas """ interpretacao = [] # Análise da pupila if 'pupila' in metricas: tamanho = self.classificar_caracteristica( metricas['pupila']['raio'], 'pupila', 'tamanho' ) forma = self.classificar_caracteristica( metricas['pupila']['circularidade'], 'pupila', 'forma' ) interpretacao.append(f"Pupila: {self.referencias['pupila']['tamanho'][tamanho]}") interpretacao.append(f"Forma pupilar: {self.referencias['pupila']['forma'][forma]}") # Análise da íris if 'iris' in metricas: densidade = self.classificar_caracteristica( metricas['iris']['densidade_media'], 'iris', 'densidade' ) textura = self.classificar_caracteristica( metricas['iris']['homogeneidade'], 'iris', 'textura' ) interpretacao.append(f"Íris: {self.referencias['iris']['densidade'][densidade]}") interpretacao.append(f"Textura: {self.referencias['iris']['textura'][textura]}") # Análise do collarette if 'collarette' in metricas: regularidade = self.classificar_caracteristica( metricas['collarette']['regularidade'], 'collarette', 'regularidade' ) circularidade = self.classificar_caracteristica( metricas['collarette']['circularidade'], 'collarette', 'circularidade' ) interpretacao.append(f"Collarette: {self.referencias['collarette']['regularidade'][regularidade]}") interpretacao.append(f"Estrutura: {self.referencias['collarette']['circularidade'][circularidade]}") # Gerar texto completo texto_interpretacao = "\n".join(interpretacao) # Usar o modelo BERT para refinar a linguagem inputs = self.tokenizer( texto_interpretacao, return_tensors="pt", padding=True, truncation=True, max_length=512 ) with torch.no_grad(): outputs = self.model(**inputs) refined_text = self.refinar_texto(texto_interpretacao, outputs.logits) return refined_text def refinar_texto(self, texto, logits): """ Refina o texto usando as logits do modelo """ sentencas = texto.split("\n") refined_sentencas = [] for sentenca in sentencas: if len(sentenca.strip()) > 0: refined_sentencas.append(f"• {sentenca}") return "\n".join(refined_sentencas) def integrar_analise_nlp(metricas, analisador=None): """ Integra a análise NLP ao sistema existente """ if analisador is None: analisador = AnalisadorIridologicoNLP() return analisador.gerar_interpretacao(metricas) def pre_processar_imagem(imagem): """ Pré-processamento avançado da imagem """ # Converter para LAB para melhor separação de cores lab = cv2.cvtColor(imagem, cv2.COLOR_RGB2LAB) l, a, b = cv2.split(lab) # Aplicar CLAHE no canal L clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8)) l = clahe.apply(l) # Recombinar canais lab = cv2.merge((l,a,b)) # Converter de volta para RGB imagem_melhorada = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB) # Redução de ruído imagem_melhorada = cv2.GaussianBlur(imagem_melhorada, (5, 5), 0) return imagem_melhorada def detectar_esclera(imagem): """ Detecta a região da esclera usando segmentação por cor e morfologia """ # Converter para HSV hsv = cv2.cvtColor(imagem, cv2.COLOR_RGB2HSV) # Definir faixa de cor para branco (esclera) lower_white = np.array([0, 0, 180]) upper_white = np.array([180, 30, 255]) # Criar máscara mask_esclera = cv2.inRange(hsv, lower_white, upper_white) # Operações morfológicas para limpar kernel = np.ones((5,5), np.uint8) mask_esclera = cv2.morphologyEx(mask_esclera, cv2.MORPH_OPEN, kernel) mask_esclera = cv2.morphologyEx(mask_esclera, cv2.MORPH_CLOSE, kernel) return mask_esclera def detectar_iris_pupila(imagem, mask_esclera): """ Detecta íris e pupila usando múltiplas técnicas """ # Converter para escala de cinza gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY) # Aplicar máscara da esclera invertida mask_olho = cv2.bitwise_not(mask_esclera) eye_region = cv2.bitwise_and(gray, gray, mask=mask_olho) # Detectar bordas edges = cv2.Canny(eye_region, 30, 60) # Detectar círculos para íris iris_circles = cv2.HoughCircles( edges, cv2.HOUGH_GRADIENT, dp=1, minDist=100, param1=50, param2=30, minRadius=80, maxRadius=150 ) # Criar máscara da íris if iris_circles is not None: iris_circles = np.uint16(np.around(iris_circles)) ix, iy, ir = iris_circles[0][0] mask_iris = np.zeros_like(gray) cv2.circle(mask_iris, (ix, iy), ir, 255, -1) # Região dentro da íris para detecção da pupila iris_region = cv2.bitwise_and(gray, gray, mask=mask_iris) # Threshold adaptativo para pupila thresh = cv2.adaptiveThreshold( iris_region, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2 ) # Detectar pupila pupil_circles = cv2.HoughCircles( thresh, cv2.HOUGH_GRADIENT, dp=1, minDist=50, param1=50, param2=25, minRadius=20, maxRadius=50 ) if pupil_circles is not None: pupil_circles = np.uint16(np.around(pupil_circles)) px, py, pr = pupil_circles[0][0] return (ix, iy, ir), (px, py, pr) return None, None def analisar_textura_setorial(imagem, iris_info, pupil_info): """ Analisa a textura da íris por setores com correção dos níveis de cinza """ if iris_info is None or pupil_info is None: return {} # Ensure iris_info and pupil_info are numpy arrays if isinstance(iris_info, tuple): iris_info = np.array(iris_info) if isinstance(pupil_info, tuple): pupil_info = np.array(pupil_info) ix, iy, ir = iris_info px, py, pr = pupil_info # Converter para escala de cinza gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY) # Equalização adaptativa do histograma clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(4, 4)) gray = clahe.apply(gray) # Criar máscara anelar da íris mask_iris = np.zeros_like(gray) cv2.circle(mask_iris, (ix, iy), int(ir * 0.98), 255, -1) cv2.circle(mask_iris, (px, py), int(pr * 1.02), 0, -1) # Dividir em 12 setores setores = {} for i in range(12): ang_inicio = i * 30 ang_fim = (i + 1) * 30 # Criar máscara do setor mask_setor = np.zeros_like(gray) cv2.ellipse(mask_setor, (ix, iy), (ir, ir), 0, ang_inicio, ang_fim, 255, -1) # Combinar máscaras kernel = np.ones((2, 2), np.uint8) mask_final = cv2.bitwise_and(mask_iris, mask_setor) mask_final = cv2.morphologyEx(mask_final, cv2.MORPH_OPEN, kernel) # Extrair região do setor setor_roi = cv2.bitwise_and(gray, gray, mask=mask_final) # Análise de textura non_zero = setor_roi[setor_roi > 0] if len(non_zero) > 100: # Normalização específica para GLCM non_zero = ((non_zero - non_zero.min()) / (non_zero.max() - non_zero.min() + 1e-8) * 15).astype(np.uint8) # Reshape para matriz 2D tamanho_janela = int(np.sqrt(len(non_zero))) if tamanho_janela > 1: matriz_2d = non_zero[:tamanho_janela**2].reshape(tamanho_janela, tamanho_janela) try: # GLCM com 16 níveis glcm = graycomatrix(matriz_2d, distances=[1], angles=[0, np.pi/4], levels=16, symmetric=True, normed=True) # Calcular propriedades contraste = np.mean(graycoprops(glcm, 'contrast')) homogeneidade = np.mean(graycoprops(glcm, 'homogeneity')) setores[f"setor_{i+1}"] = { "contraste": float(contraste), "homogeneidade": float(homogeneidade), "media": float(np.mean(non_zero)), "std": float(np.std(non_zero)) } except Exception as e: print(f"Erro no GLCM do setor {i+1}: {str(e)}") setores[f"setor_{i+1}"] = { "contraste": 0.0, "homogeneidade": 1.0, "media": 0.0, "std": 0.0 } else: setores[f"setor_{i+1}"] = { "contraste": 0.0, "homogeneidade": 1.0, "media": 0.0, "std": 0.0 } else: setores[f"setor_{i+1}"] = { "contraste": 0.0, "homogeneidade": 1.0, "media": 0.0, "std": 0.0 } return setores def avaliar_setores(setores): """ Avalia os setores com limiares recalibrados baseados nos dados observados """ # Calcular estatísticas globais para calibração dinâmica contrastes = [dados['contraste'] for dados in setores.values()] homogeneidades = [dados['homogeneidade'] for dados in setores.values()] # Calcular limiares dinâmicos contraste_medio = np.mean(contrastes) contraste_std = np.std(contrastes) homog_media = np.mean(homogeneidades) homog_std = np.std(homogeneidades) # Definir limiares baseados nas estatísticas limiar_contraste_alto = contraste_medio + contraste_std limiar_contraste_baixo = contraste_medio - contraste_std limiar_homog_baixo = homog_media - homog_std limiar_homog_alto = homog_media + homog_std for setor, dados in setores.items(): mensagens = [] # Análise de contraste recalibrada if dados['contraste'] > limiar_contraste_alto: mensagens.append("Densidade muito alta de sinais") elif dados['contraste'] > contraste_medio: mensagens.append("Densidade moderadamente alta de sinais") elif dados['contraste'] < limiar_contraste_baixo: mensagens.append("Densidade baixa de sinais") # Análise de homogeneidade recalibrada if dados['homogeneidade'] < limiar_homog_baixo: mensagens.append("Alterações significativas na textura") elif dados['homogeneidade'] < homog_media: mensagens.append("Possíveis alterações sutis") elif dados['homogeneidade'] > limiar_homog_alto: mensagens.append("Textura muito homogênea") # Análise combinada if dados['contraste'] > limiar_contraste_alto and dados['homogeneidade'] < limiar_homog_baixo: mensagens.append("Área que requer atenção especial") dados['interpretacao'] = mensagens # Adicionar métricas de referência dados['metricas_referencia'] = { 'contraste_medio': float(contraste_medio), 'contraste_std': float(contraste_std), 'homog_media': float(homog_media), 'homog_std': float(homog_std) } return setores def gerar_relatorio_setorial(setores_analisados): """ Gera relatório setorial com informações de referência """ relatorio = "\n2. ANÁLISE SETORIAL\n" # Adicionar informações de referência if setores_analisados and 'metricas_referencia' in list(setores_analisados.values())[0]: ref = list(setores_analisados.values())[0]['metricas_referencia'] relatorio += "\nValores de Referência:\n" relatorio += f"- Contraste Médio: {ref['contraste_medio']:.2f} (±{ref['contraste_std']:.2f})\n" relatorio += f"- Homogeneidade Média: {ref['homog_media']:.2f} (±{ref['homog_std']:.2f})\n\n" for setor, dados in setores_analisados.items(): relatorio += f"\n{setor}:\n" relatorio += f"- Contraste: {dados['contraste']:.2f}\n" relatorio += f"- Homogeneidade: {dados['homogeneidade']:.2f}\n" if 'interpretacao' in dados: for msg in dados['interpretacao']: relatorio += f" * {msg}\n" return relatorio def analisar_collarette(imagem, iris_info, pupil_info): """ Analisa o collarette (anel de contração) em detalhes """ if iris_info is None or pupil_info is None: return None ix, iy, ir = iris_info px, py, pr = pupil_info # Distância entre pupila e íris dist = ir - pr # Região do collarette (aproximadamente 35% da distância) collarette_inner = pr + int(dist * 0.25) collarette_outer = pr + int(dist * 0.45) # Criar máscara do collarette mask = np.zeros_like(cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)) cv2.circle(mask, (px, py), collarette_outer, 255, -1) cv2.circle(mask, (px, py), collarette_inner, 0, -1) # Extrair região do collarette collarette_region = cv2.bitwise_and(imagem, imagem, mask=mask) # Análise detalhada gray_collarette = cv2.cvtColor(collarette_region, cv2.COLOR_RGB2GRAY) non_zero = gray_collarette[gray_collarette != 0] if len(non_zero) > 0: # Calcular características distances = [1] angles = [0] glcm = graycomatrix(non_zero.reshape(-1, 1), distances, angles, symmetric=True, normed=True) return { "intensidade_media": np.mean(non_zero), "variacao": np.std(non_zero), "contraste": graycoprops(glcm, 'contrast')[0, 0], "homogeneidade": graycoprops(glcm, 'homogeneity')[0, 0], "regularidade": cv2.Laplacian(gray_collarette, cv2.CV_64F).var(), "circularidade": avaliar_circularidade(mask) } return None def avaliar_circularidade(mask): """ Avalia a circularidade de uma região """ contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if contours: cnt = max(contours, key=cv2.contourArea) area = cv2.contourArea(cnt) perimeter = cv2.arcLength(cnt, True) if perimeter > 0: circularity = 4 * np.pi * area / (perimeter * perimeter) return circularity return 0 def validar_metricas(metricas): """ Valida e ajusta as métricas antes da interpretação """ metricas_validadas = {} # Validar pupila if 'pupila' in metricas: raio = metricas['pupila'].get('raio', 0) circularidade = metricas['pupila'].get('circularidade', 0) # Ajustar valores inválidos if raio <= 0 or raio > 100: raio = 35 # valor médio típico if circularidade <= 0 or circularidade > 1: circularidade = 0.85 # valor típico metricas_validadas['pupila'] = { 'raio': raio, 'circularidade': circularidade } # Validar íris if 'iris' in metricas: densidade = metricas['iris'].get('densidade_media', 0) homogeneidade = metricas['iris'].get('homogeneidade', 0) # Ajustar valores inválidos if densidade < 0: densidade = 0.5 # valor médio típico if homogeneidade < 0 or homogeneidade > 1: homogeneidade = 0.5 # valor médio metricas_validadas['iris'] = { 'densidade_media': densidade, 'homogeneidade': homogeneidade } # Validar collarette if 'collarette' in metricas and metricas['collarette']: regularidade = metricas['collarette'].get('regularidade', 0) circularidade = metricas['collarette'].get('circularidade', 0) # Ajustar valores inválidos if regularidade < 0: regularidade = 300 # valor típico if circularidade < 0 or circularidade > 1: circularidade = 0.85 # valor típico metricas_validadas['collarette'] = { 'regularidade': regularidade, 'circularidade': circularidade } return metricas_validadas def criar_interface(): """ Cria interface moderna do Gradio """ theme = gr.themes.Soft( primary_hue="teal", secondary_hue="green", ).set( body_text_color="#2A9D8F", block_title_text_color="#264653", block_label_text_color="#2A9D8F", input_background_fill="#E9F5F3", button_primary_background_fill="#2A9D8F", button_primary_background_fill_dark="#264653", ) def processar_imagem(imagem): try: # Pré-processamento da imagem imagem_processada = pre_processar_imagem(imagem) # Detectar esclera mask_esclera = detectar_esclera(imagem_processada) # Detectar íris e pupila iris_info, pupil_info = detectar_iris_pupila(imagem_processada, mask_esclera) if iris_info is None or pupil_info is None: return imagem, "Não foi possível detectar íris ou pupila corretamente." # Análise de textura setorial analise_setorial = analisar_textura_setorial(imagem_processada, iris_info, pupil_info) # Análise do collarette info_collarette = analisar_collarette(imagem_processada, iris_info, pupil_info) # Criar visualização da imagem de saída output_img = imagem.copy() ix, iy, ir = iris_info px, py, pr = pupil_info # Desenhar esclera contours, _ = cv2.findContours(mask_esclera, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cv2.drawContours(output_img, contours, -1, (255, 255, 0), 1) # Esclera em amarelo # Desenhar íris cv2.circle(output_img, (ix, iy), ir, (0, 255, 0), 2) # Íris em verde # Desenhar pupila cv2.circle(output_img, (px, py), pr, (255, 0, 0), 2) # Pupila em vermelho # Desenhar setores for i in range(12): ang = i * 30 rad = np.radians(ang) end_x = int(ix + ir * np.cos(rad)) end_y = int(iy + ir * np.sin(rad)) cv2.line(output_img, (ix, iy), (end_x, end_y), (255, 255, 255), 1) # Linhas brancas para setores # Adicionando feedback visual se o collarette for detectado if info_collarette: cv2.putText(output_img, "Collarette Detected", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) # Preparar métricas para análise NLP metricas = { 'pupila': { 'raio': pr, 'circularidade': avaliar_circularidade(pupil_info) }, 'iris': { 'densidade_media': np.mean([dados['contraste'] for dados in analise_setorial.values()]), 'homogeneidade': np.mean([dados['homogeneidade'] for dados in analise_setorial.values()]) }, 'collarette': info_collarette } # Validar métricas metricas = validar_metricas(metricas) # Integrar análise NLP interpretacao_nlp = integrar_analise_nlp(metricas) # Gerar relatório relatorio = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n" relatorio += "1. MEDIDAS ESTRUTURAIS\n" relatorio += f"Pupila: Centro ({px}, {py}), Raio {pr}px\n" relatorio += f"Íris: Centro ({ix}, {iy}), Raio {ir}px\n" # Adicionar análise setorial relatorio += "2. ANÁLISE SETORIAL\n" for setor, dados in analise_setorial.items(): relatorio += f"Setor {setor}: Contraste {dados['contraste']}, Homogeneidade {dados['homogeneidade']}\n" relatorio += f"3. COLLARETTE: {info_collarette}\n" relatorio += f"4. INTERPRETAÇÃO NLP: {interpretacao_nlp}\n" return output_img, relatorio except Exception as e: return imagem, f"Erro durante o processamento: {str(e)}" # Interface with gr.Blocks(theme=theme, title="Análise Iridológica Avançada") as interface: gr.Markdown(""" # Sistema Avançado de Análise Iridológica ### Detecção precisa de esclera, íris e pupila com análise setorial e interpretação em linguagem natural """) with gr.Tabs(): # Aba de Análise Principal with gr.Tab("Análise de Imagem"): with gr.Row(): with gr.Column(): input_image = gr.Image( label="Imagem do Olho", type="numpy" ) with gr.Column(): output_image = gr.Image( label="Análise Visual" ) analysis_btn = gr.Button("Analisar Olho", variant="primary") output_text = gr.Textbox( label="Relatório de Análise", lines=20 ) analysis_btn.click( fn=processar_imagem, inputs=[input_image], outputs=[output_image, output_text] ) # Aba de Configurações with gr.Tab("Configurações"): with gr.Row(): min_iris_radius = gr.Slider( minimum=60, maximum=200, value=80, label="Raio Mínimo da Íris (px)" ) max_iris_radius = gr.Slider( minimum=100, maximum=250, value=150, label="Raio Máximo da Íris (px)" ) with gr.Row(): min_pupil_radius = gr.Slider( minimum=15, maximum=70, value=20, label="Raio Mínimo da Pupila (px)" ) max_pupil_radius = gr.Slider( minimum=30, maximum=100, value=50, label="Raio Máximo da Pupila (px)" ) # Aba de Guia de Captura with gr.Tab("Guia de Captura"): gr.Markdown(""" ## Guia para Captura de Imagem ### 1. Iluminação Ideal - Luz natural indireta - Sem reflexos diretos no olho - Iluminação uniforme - Evitar flash ### 2. Posicionamento - Olho totalmente aberto - Câmera perpendicular ao olho - Distância adequada (15-20cm) - Íris centralizada na imagem ### 3. Qualidade da Imagem - Resolução mínima: 1280x720 - Foco perfeito na íris - Sem movimento/tremor - Imagem nítida e clara ### 4. Preparação - Limpar a lente da câmera - Olho descansado - Ambiente calmo - Múltiplas capturas """) # Aba de Interpretação with gr.Tab("Guia de Interpretação"): gr.Markdown(""" ## Guia de Interpretação dos Resultados ### 1. Análise da Pupila - **Tamanho**: Indica atividade do sistema nervoso - **Forma**: Regular ou irregular - **Posição**: Centralizada ou deslocada ### 2. Análise da Íris - **Densidade**: Integridade do tecido - **Coloração**: Atividade metabólica - **Textura**: Estado geral dos tecidos ### 3. Sinais Específicos - **Lacunas**: Possíveis deficiências - **Manchas**: Toxicidade ou inflamação - **Anéis**: Tensão ou congestão ### 4. Collarette - **Regularidade**: Equilíbrio do sistema - **Circularidade**: Integridade estrutural - **Densidade**: Vitalidade geral """) return interface def main(): interface = criar_interface() interface.launch(share=True) if __name__ == "__main__": main()