Update app.py

app.py

@@ -294,7 +294,7 @@ def detectar_iris_pupila(imagem, mask_esclera):
 
 def analisar_textura_setorial(imagem, iris_info, pupil_info):
     """
-    Analisa a textura da íris por setores
+    Analisa a textura da íris por setores com correções e melhorias
     """
     if iris_info is None or pupil_info is None:
         return {}
@@ -302,21 +302,25 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
     ix, iy, ir = iris_info
     px, py, pr = pupil_info
     
-    # Converter para escala de cinza
+    # Converter para escala de cinza com preservação de contraste
     gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
     
-    # Criar máscara anelar da íris
+    # 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), ir, 255, -1)
-    cv2.circle(mask_iris, (px, py), pr, 0, -1)
+    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 (como um relógio)
+    # Dividir em 12 setores
     setores = {}
     for i in range(12):
         ang_inicio = i * 30
         ang_fim = (i + 1) * 30
         
-        # Criar máscara do setor
+        # Criar máscara do setor com ângulos precisos
         mask_setor = np.zeros_like(gray)
         cv2.ellipse(mask_setor,
                    (ix, iy),
@@ -327,28 +331,71 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
                    255,
                    -1)
         
-        # Combinar máscaras
+        # 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
-        non_zero = setor_roi[setor_roi != 0]
-        if len(non_zero) > 0:
-            # Calcular características de textura
-            distances = [1]
-            angles = [0]
-            glcm = graycomatrix(non_zero.reshape(-1, 1), distances, angles, 
-                              symmetric=True, normed=True)
+        # 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": np.mean(non_zero),
-                "std": np.std(non_zero),
-                "contraste": graycoprops(glcm, 'contrast')[0, 0],
-                "homogeneidade": graycoprops(glcm, 'homogeneity')[0, 0],
-                "energia": graycoprops(glcm, 'energy')[0, 0],
-                "correlacao": graycoprops(glcm, 'correlation')[0, 0]
+                "media": 0.0,
+                "std": 0.0,
+                "contraste": 0.0,
+                "homogeneidade": 1.0,
+                "energia": 1.0,
+                "correlacao": 0.0,
+                "gradiente": 0.0
             }
     
     return setores
@@ -414,6 +461,62 @@ def avaliar_circularidade(mask):
             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
@@ -472,7 +575,8 @@ def criar_interface():
                 'collarette': info_collarette
             }
             
-            # Gerar interpretação em linguagem natural
+            # Na função processar_imagem, antes de chamar integrar_analise_nlp:
+            metricas = validar_metricas(metricas)
             interpretacao_nlp = integrar_analise_nlp(metricas)
             
             # Desenhar esclera