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 com calibração melhorada
+    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 {}
@@ -302,17 +302,17 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
     ix, iy, ir = iris_info
     px, py, pr = pupil_info
     
-    # Converter para escala de cinza com preservação de contraste
+    # Converter para escala de cinza
     gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
     
-    # Equalização adaptativa do histograma com parâmetros ajustados
+    # Equalização adaptativa do histograma
     clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(4,4))
     gray = clahe.apply(gray)
     
-    # Criar máscara anelar da íris com margens ajustadas
+    # Criar máscara anelar da íris
     mask_iris = np.zeros_like(gray)
-    cv2.circle(mask_iris, (ix, iy), int(ir * 0.98), 255, -1)  # Margem externa menor
-    cv2.circle(mask_iris, (px, py), int(pr * 1.02), 0, -1)    # Margem interna menor
+    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 = {}
@@ -331,7 +331,7 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
                    255,
                    -1)
         
-        # Combinar máscaras com operação morfológica suave
+        # 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)
@@ -339,69 +339,84 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
         # Extrair região do setor
         setor_roi = cv2.bitwise_and(gray, gray, mask=mask_final)
         
-        # Análise de textura calibrada
+        # Análise de textura
         non_zero = setor_roi[setor_roi > 0]
         if len(non_zero) > 100:
-            # Normalização com range reduzido
+            # Normalização específica para GLCM (importante: valores entre 0 e 15)
             non_zero = ((non_zero - non_zero.min()) / 
-                       (non_zero.max() - non_zero.min() + 1e-8) * 100).astype(np.uint8)
+                       (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)
                 
-                # GLCM com parâmetros calibrados
-                distances = [1]  # Reduzir para apenas distância 1
-                angles = [0, np.pi/4]  # Reduzir número de ângulos
-                glcm = graycomatrix(matriz_2d, distances, angles, 
-                                  levels=32,  # Reduzir níveis
-                                  symmetric=True, 
-                                  normed=True)
-                
-                # Calcular propriedades com normalização
-                contraste = np.mean(graycoprops(glcm, 'contrast')) / 10  # Normalizar contraste
-                homogeneidade = np.mean(graycoprops(glcm, 'homogeneity'))
-                
-                setores[f"setor_{i+1}"] = {
-                    "contraste": float(contraste),
-                    "homogeneidade": float(homogeneidade)
-                }
+                try:
+                    # GLCM com 16 níveis
+                    glcm = graycomatrix(matriz_2d, 
+                                      distances=[1], 
+                                      angles=[0, np.pi/4], 
+                                      levels=16,  # Deve ser maior que o máximo valor na imagem (15)
+                                      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
+                    "homogeneidade": 1.0,
+                    "media": 0.0,
+                    "std": 0.0
                 }
         else:
             setores[f"setor_{i+1}"] = {
                 "contraste": 0.0,
-                "homogeneidade": 1.0
+                "homogeneidade": 1.0,
+                "media": 0.0,
+                "std": 0.0
             }
     
     return setores
 
 def avaliar_setores(setores):
     """
-    Avalia os setores com novos limiares calibrados
+    Avalia os setores com limiares ajustados para os novos valores
     """
     for setor, dados in setores.items():
         mensagens = []
         
-        # Novos limiares calibrados
-        if dados['contraste'] > 50:  # Ajustado de 2.0
+        # Limiares ajustados para os novos valores de contraste
+        if dados['contraste'] > 5:
             mensagens.append("Alta densidade de sinais")
-        elif dados['contraste'] < 10:  # Novo limiar
+        elif dados['contraste'] < 1:
             mensagens.append("Baixa densidade de sinais")
             
-        if dados['homogeneidade'] < 0.3:  # Ajustado de 0.5
+        if dados['homogeneidade'] < 0.3:
             mensagens.append("Possível área de alteração")
-        elif dados['homogeneidade'] > 0.8:  # Novo limiar
+        elif dados['homogeneidade'] > 0.8:
             mensagens.append("Área homogênea e saudável")
             
         dados['interpretacao'] = mensagens
     
     return setores
-
+    
 def analisar_collarette(imagem, iris_info, pupil_info):
     """
     Analisa o collarette (anel de contração) em detalhes