Update app.py

app.py

@@ -7,8 +7,20 @@ import cv2
 import numpy as np
 from preprocess import unsharp_masking
 import time
-from sklearn.cluster import KMeans
 import os
+from scipy.spatial import distance
+from scipy.ndimage import label
+from sklearn.cluster import KMeans
+
+# Carregar modelos pré-treinados
+models = {
+    'SE-RegUNet 4GF': torch.jit.load('./model/SERegUNet4GF.pt'),
+    'SE-RegUNet 16GF': torch.jit.load('./model/SERegUNet16GF.pt'),
+    'AngioNet': torch.jit.load('./model/AngioNet.pt'),
+    'EffUNet++ B5': torch.jit.load('./model/EffUNetppb5.pt'),
+    'Reg-SA-UNet++': torch.jit.load('./model/RegSAUnetpp.pt'),
+    'UNet3+': torch.jit.load('./model/UNet3plus.pt'),
+}
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
@@ -52,9 +64,6 @@ def preprocessar_imagem(img, modelo='SE-RegUNet 4GF'):
     
     return img_out
 
-
-import os
-
 # Caminho absoluto para a pasta de salvamento
 caminho_salvar_resultado = "/Segmento_de_Angio_Coronariana_v5/Salvar Resultado"
 
@@ -108,58 +117,58 @@ def processar_imagem_de_entrada(img, modelo, pipe, salvar_resultado=False):
         # Em caso de erro, retorne uma mensagem de erro
         return str(e), None
 
-
-
-# Carregar modelos pré-treinados
-models = {
-    'SE-RegUNet 4GF': torch.jit.load('./model/SERegUNet4GF.pt'),
-    'SE-RegUNet 16GF': torch.jit.load('./model/SERegUNet16GF.pt'),
-    'AngioNet': torch.jit.load('./model/AngioNet.pt'),
-    'EffUNet++ B5': torch.jit.load('./model/EffUNetppb5.pt'),
-    'Reg-SA-UNet++': torch.jit.load('./model/RegSAUnetpp.pt'),
-    'UNet3+': torch.jit.load('./model/UNet3plus.pt'),
-}
-
-from scipy.spatial import distance
-from scipy.ndimage import label
-import numpy as np
-import numpy as np
-import cv2
-from sklearn.cluster import KMeans
-
 def processar_imagem_de_entrada_wrapper(img, modelo, salvar_resultado=False, nome_arquivo=None):
+    """
+    Processa uma imagem de entrada usando um modelo de segmentação pré-treinado e extrai características dos clusters.
+    
+    Args:
+        img (numpy.ndarray): A imagem de entrada.
+        modelo (str): O nome do modelo a ser utilizado.
+        salvar_resultado (bool): Indica se o resultado deve ser salvo em arquivo.
+        nome_arquivo (str): O nome do arquivo para salvar o resultado.
+
+    Returns:
+        tuple: Uma tupla contendo:
+            - resultado (str): Tempo decorrido para o processamento.
+            - img_out (numpy.ndarray): A imagem de saída.
+            - status_doenca (str): Indicador de presença de doença.
+            - explanation (str): Explicação do status de doença.
+            - num_analises (str): Número de análises realizadas.
+    """
+
+    # Carregar o modelo correspondente
     model = models[modelo]
+
+    # Processar a imagem usando o modelo
     resultado, img_out = processar_imagem_de_entrada(img, modelo, model)
     
-    # Resto do código permanece inalterado
+    # Aplicar o algoritmo K-Means para segmentação de imagem
     kmeans = KMeans(n_clusters=2, random_state=0)
     flattened_img = img_out[:, :, 0].reshape((-1, 1))
     kmeans.fit(flattened_img)
     labels = kmeans.labels_
     cluster_centers = kmeans.cluster_centers_
         
-    # Extração de características dos clusters
+    # Extrair características dos clusters
     num_clusters = len(cluster_centers)
     cluster_features = []
     for i in range(num_clusters):
-        cluster_mask = labels == i  # Create a boolean mask for the cluster
+        cluster_mask = labels == i  # Criar uma máscara booleana para o cluster
     
         # Calcular área do cluster
         area = np.sum(cluster_mask)
     
-        if area == 0:  # Skip empty clusters
+        if area == 0:  # Ignorar clusters vazios
             continue
     
-        # Calcular forma do cluster usando a relação entre área e perímetro
-        contours, _ = cv2.findContours(np.uint8(cluster_mask), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        if len(contours) > 0:
-            perimeter = cv2.arcLength(contours[0], True)
-            compactness = 4 * np.pi * area / (perimeter ** 2)
+        # Calcular momentos de Hu para descrição de forma
+        moments = cv2.moments(cluster_mask)
+        hu_moments = cv2.HuMoments(moments).flatten()
     
-            cluster_features.append({'area': area, 'compactness': compactness})
+        cluster_features.append({'area': area, 'hu_moments': hu_moments})
     
     # Decidir se há doença com base nas características dos clusters
-    has_disease_flag = any(feature['area'] >= 200 and feature['compactness'] < 0.3 for feature in cluster_features)
+    has_disease_flag = any(feature['area'] >= 200 and np.linalg.norm(feature['hu_moments']) < 0.1 for feature in cluster_features)
     
     # Formatar o indicador de doença como uma string
     if has_disease_flag:
@@ -169,9 +178,13 @@ def processar_imagem_de_entrada_wrapper(img, modelo, salvar_resultado=False, nom
         status_doenca = "Não"
         explanation = "A máquina não detectou nenhuma doença nos vasos sanguíneos."
     
+    # Número de análises realizadas (pode ser atualizado conforme necessário)
+    num_analises = "1"
+
     return resultado, img_out, status_doenca, explanation, f"{num_analises} análises realizadas"
 
 
+
 # Inicializar a contagem de análises
 num_analises = 0