Update app.py

app.py

@@ -5,6 +5,183 @@ 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):
     """
@@ -160,7 +337,10 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
         non_zero = setor_roi[setor_roi != 0]
         if len(non_zero) > 0:
             # Calcular características de textura
-            glcm = graycomatrix(non_zero.reshape(-1, 1), [1], [0], symmetric=True, normed=True)
+            distances = [1]
+            angles = [0]
+            glcm = graycomatrix(non_zero.reshape(-1, 1), distances, angles, 
+                              symmetric=True, normed=True)
             
             setores[f"setor_{i+1}"] = {
                 "media": np.mean(non_zero),
@@ -204,7 +384,10 @@ def analisar_collarette(imagem, iris_info, pupil_info):
     
     if len(non_zero) > 0:
         # Calcular características
-        glcm = graycomatrix(non_zero.reshape(-1, 1), [1], [0], symmetric=True, normed=True)
+        distances = [1]
+        angles = [0]
+        glcm = graycomatrix(non_zero.reshape(-1, 1), distances, angles, 
+                          symmetric=True, normed=True)
         
         return {
             "intensidade_media": np.mean(non_zero),
@@ -221,7 +404,7 @@ def avaliar_circularidade(mask):
     """
     Avalia a circularidade de uma região
     """
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    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)
@@ -269,17 +452,37 @@ def criar_interface():
             
             # 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
+            }
+            
+            # Gerar interpretação em linguagem natural
+            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
-            ix, iy, ir = iris_info
             cv2.circle(output_img, (ix, iy), ir, (0, 255, 0), 2)
             
             # Desenhar pupila
-            px, py, pr = pupil_info
             cv2.circle(output_img, (px, py), pr, (255, 0, 0), 2)
             
             # Desenhar setores
@@ -323,6 +526,10 @@ def criar_interface():
                 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:
@@ -332,7 +539,7 @@ def criar_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
+        ### Detecção precisa de esclera, íris e pupila com análise setorial e interpretação em linguagem natural
         """)
         
         with gr.Tabs():