Spaces:
Sleeping
Sleeping
| 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ções e melhorias | |
| """ | |
| if iris_info is None or pupil_info is None: | |
| return {} | |
| ix, iy, ir = iris_info | |
| px, py, pr = pupil_info | |
| # Converter para escala de cinza com preservação de contraste | |
| gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY) | |
| # Equalização adaptativa do histograma | |
| clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)) | |
| gray = clahe.apply(gray) | |
| # Criar máscara anelar da íris com margem de segurança | |
| mask_iris = np.zeros_like(gray) | |
| cv2.circle(mask_iris, (ix, iy), int(ir * 0.95), 255, -1) # Reduzir raio em 5% | |
| cv2.circle(mask_iris, (px, py), int(pr * 1.05), 0, -1) # Aumentar raio em 5% | |
| # Dividir em 12 setores | |
| setores = {} | |
| for i in range(12): | |
| ang_inicio = i * 30 | |
| ang_fim = (i + 1) * 30 | |
| # Criar máscara do setor com ângulos precisos | |
| mask_setor = np.zeros_like(gray) | |
| cv2.ellipse(mask_setor, | |
| (ix, iy), | |
| (ir, ir), | |
| 0, | |
| ang_inicio, | |
| ang_fim, | |
| 255, | |
| -1) | |
| # Combinar máscaras com operação morfológica | |
| kernel = np.ones((3,3), 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 melhorada | |
| non_zero = setor_roi[setor_roi > 0] | |
| if len(non_zero) > 100: # Garantir amostra significativa | |
| # Normalizar valores | |
| non_zero = ((non_zero - non_zero.min()) / | |
| (non_zero.max() - non_zero.min() + 1e-8) * 255).astype(np.uint8) | |
| # Reshape para matriz 2D para GLCM | |
| tamanho_janela = int(np.sqrt(len(non_zero))) | |
| if tamanho_janela > 1: | |
| matriz_2d = non_zero[:tamanho_janela**2].reshape(tamanho_janela, tamanho_janela) | |
| # Calcular GLCM com múltiplas distâncias e ângulos | |
| distances = [1, 2, 3] | |
| angles = [0, np.pi/4, np.pi/2, 3*np.pi/4] | |
| glcm = graycomatrix(matriz_2d, distances, angles, | |
| symmetric=True, normed=True) | |
| # Calcular propriedades médias | |
| contraste = np.mean(graycoprops(glcm, 'contrast')) | |
| homogeneidade = np.mean(graycoprops(glcm, 'homogeneity')) | |
| energia = np.mean(graycoprops(glcm, 'energy')) | |
| correlacao = np.mean(graycoprops(glcm, 'correlation')) | |
| # Análise de gradiente | |
| sobelx = cv2.Sobel(matriz_2d, cv2.CV_64F, 1, 0, ksize=3) | |
| sobely = cv2.Sobel(matriz_2d, cv2.CV_64F, 0, 1, ksize=3) | |
| gradiente = np.mean(np.sqrt(sobelx**2 + sobely**2)) | |
| setores[f"setor_{i+1}"] = { | |
| "media": np.mean(non_zero), | |
| "std": np.std(non_zero), | |
| "contraste": float(contraste), | |
| "homogeneidade": float(homogeneidade), | |
| "energia": float(energia), | |
| "correlacao": float(correlacao), | |
| "gradiente": float(gradiente) | |
| } | |
| else: | |
| setores[f"setor_{i+1}"] = { | |
| "media": np.mean(non_zero), | |
| "std": np.std(non_zero), | |
| "contraste": 0.0, | |
| "homogeneidade": 1.0, | |
| "energia": 1.0, | |
| "correlacao": 0.0, | |
| "gradiente": 0.0 | |
| } | |
| else: | |
| setores[f"setor_{i+1}"] = { | |
| "media": 0.0, | |
| "std": 0.0, | |
| "contraste": 0.0, | |
| "homogeneidade": 1.0, | |
| "energia": 1.0, | |
| "correlacao": 0.0, | |
| "gradiente": 0.0 | |
| } | |
| return setores | |
| 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 | |
| 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 | |
| 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 | |
| output_img = imagem.copy() | |
| ix, iy, ir = iris_info | |
| px, py, pr = pupil_info | |
| # Criar máscara da pupila para circularidade | |
| pupil_mask = np.zeros_like(cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)) | |
| cv2.circle(pupil_mask, (px, py), pr, 255, -1) | |
| # Preparar métricas para análise NLP | |
| metricas = { | |
| 'pupila': { | |
| 'raio': pr, | |
| 'circularidade': avaliar_circularidade(pupil_mask) | |
| }, | |
| '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 | |
| } | |
| # Na função processar_imagem, antes de chamar integrar_analise_nlp: | |
| metricas = validar_metricas(metricas) | |
| interpretacao_nlp = integrar_analise_nlp(metricas) | |
| # Desenhar esclera | |
| contours, _ = cv2.findContours(mask_esclera, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) | |
| cv2.drawContours(output_img, contours, -1, (255, 255, 0), 1) | |
| # Desenhar íris | |
| cv2.circle(output_img, (ix, iy), ir, (0, 255, 0), 2) | |
| # Desenhar pupila | |
| cv2.circle(output_img, (px, py), pr, (255, 0, 0), 2) | |
| # 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), (0, 255, 0), 1) | |
| # Gerar relatório | |
| relatorio = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n" | |
| # Informações estruturais | |
| 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" | |
| # Análise setorial | |
| relatorio += "\n2. ANÁLISE SETORIAL\n" | |
| for setor, dados in analise_setorial.items(): | |
| relatorio += f"\n{setor}:\n" | |
| relatorio += f"- Contraste: {dados['contraste']:.2f}\n" | |
| relatorio += f"- Homogeneidade: {dados['homogeneidade']:.2f}\n" | |
| # Interpretação | |
| if dados['contraste'] > 2.0: | |
| relatorio += " * Alta densidade de sinais\n" | |
| if dados['homogeneidade'] < 0.5: | |
| relatorio += " * Possível área de alteração\n" | |
| # Análise do collarette | |
| if info_collarette: | |
| relatorio += "\n3. ANÁLISE DO COLLARETTE\n" | |
| relatorio += f"- Regularidade: {info_collarette['regularidade']:.2f}\n" | |
| relatorio += f"- Circularidade: {info_collarette['circularidade']:.2f}\n" | |
| # Interpretação | |
| if info_collarette['regularidade'] > 500: | |
| relatorio += " * Irregularidade significativa\n" | |
| if info_collarette['circularidade'] < 0.8: | |
| relatorio += " * Possível deformação estrutural\n" | |
| # Adicionar interpretação NLP | |
| relatorio += "\n4. INTERPRETAÇÃO EM LINGUAGEM NATURAL\n" | |
| relatorio += interpretacao_nlp | |
| 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() |