Update app.py

app.py

@@ -18,7 +18,7 @@ def ordenar_e_preprocessar_imagem(img, modelo):
     img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     h, w = img.shape
     img_out = preprocessar_imagem(img, modelo)
-    return img_out
+    return img_out, h, w, img, ori
 
 # Função para pré-processar a imagem com base no modelo selecionado
 def preprocessar_imagem(img, modelo='SE-RegUNet 4GF'):
@@ -67,6 +67,9 @@ def processar_imagem_de_entrada(img, modelo, pipe, salvar_resultado=False):
         # Coloque o modelo na GPU (se disponível) e configure-o para modo de avaliação
         pipe = pipe.to(device).eval()
         
+        # Registre o tempo de início
+        start = time.time()
+        
         # Pré-processe a imagem e obtenha informações de dimensão
         img, h, w, ori_gray, ori = ordenar_e_preprocessar_imagem(img, modelo)
         
@@ -79,6 +82,10 @@ def processar_imagem_de_entrada(img, modelo, pipe, salvar_resultado=False):
                 img = torch.cat([img, img], dim=0)
             logit = np.round(torch.softmax(pipe.forward(img), dim=1).detach().cpu().numpy()[0, 0]).astype(np.uint8)
         
+        # Calcule o tempo decorrido
+        spent = time.time() - start
+        spent = f"{spent:.3f} segundos"
+
         # Redimensione o resultado, se necessário
         if h != 512 or w != 512:
             logit = cv2.resize(logit, (h, w))
@@ -95,11 +102,13 @@ def processar_imagem_de_entrada(img, modelo, pipe, salvar_resultado=False):
             nome_arquivo = os.path.join(caminho_salvar_resultado, f'resultado_{int(time.time())}.png')
             cv2.imwrite(nome_arquivo, img_out)
         
-        return img_out
+        return spent, img_out
     
     except Exception as e:
         # Em caso de erro, retorne uma mensagem de erro
-        return str(e)
+        return str(e), None
+
+
 
 # Carregar modelos pré-treinados
 models = {
@@ -111,11 +120,68 @@ models = {
     'UNet3+': torch.jit.load('./model/UNet3plus.pt'),
 }
 
-# Função para processar a imagem de entrada e retornar apenas a imagem de saída
-def processar_imagem_de_entrada_wrapper(img, modelo):
+from scipy.spatial import distance
+from scipy.ndimage import label
+import numpy as np
+
+# Adicionar a opção de salvar o resultado em um arquivo
+def processar_imagem_de_entrada_wrapper(img, modelo, salvar_resultado=False):
     model = models[modelo]
-    img_out = processar_imagem_de_entrada(img, modelo, model)
-    return img_out
+    resultado, img_out = processar_imagem_de_entrada(img, modelo, model, salvar_resultado)
+    
+    # Resto do código permanece inalterado
+    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_
+    
+    # Detecção de doenças usando K-Means
+    kmeans = KMeans(n_clusters=2, random_state=0)
+    flattened_img = img_out[:, :, 0].reshape((-1, 1))  # Use o canal de intensidade
+    kmeans.fit(flattened_img)
+    labels = kmeans.labels_
+    cluster_centers = kmeans.cluster_centers_
+    
+    # Resto do código permanece inalterado
+    
+    # Extração de 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
+    
+        # Calcular área do cluster
+        area = np.sum(cluster_mask)
+    
+        if area == 0:  # Skip empty clusters
+            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)
+    
+            cluster_features.append({'area': area, 'compactness': compactness})
+    
+    # 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)
+    
+    # Formatar o indicador de doença como uma string
+    if has_disease_flag:
+        status_doenca = "Sim"
+        explanation = "A máquina detectou uma possível doença nos vasos sanguíneos."
+    else:
+        status_doenca = "Não"
+        explanation = "A máquina não detectou nenhuma doença nos vasos sanguíneos."
+    
+    # Resto do código permanece inalterado
+    
+    return resultado, img_out, status_doenca, explanation, f"{num_analises} análises realizadas"
+
+# Inicializar a contagem de análises
+num_analises = 0
 
 # Criar a interface Gradio
 my_app = gr.Interface(
@@ -123,8 +189,15 @@ my_app = gr.Interface(
     inputs=[
         gr.inputs.Image(label="Angiograma:", shape=(512, 512)),
         gr.inputs.Dropdown(['SE-RegUNet 4GF','SE-RegUNet 16GF', 'AngioNet', 'EffUNet++ B5', 'Reg-SA-UNet++', 'UNet3+'], label='Modelo', default='SE-RegUNet 4GF'),
+        gr.inputs.Checkbox(label="Salvar Resultado"),
+    ],
+    outputs=[
+        gr.outputs.Label(label="Tempo decorrido"),
+        gr.outputs.Image(type="numpy", label="Imagem de Saída"),
+        gr.outputs.Label(label="Possui Doença?"),
+        gr.outputs.Label(label="Explicação"),
+        gr.outputs.Label(label="Análises Realizadas"),
     ],
-    outputs=gr.outputs.Image(type="numpy", label="Imagem de Saída"),
     title="Segmentação de Angiograma Coronariano",
     description="Esta aplicação segmenta angiogramas coronarianos usando modelos de segmentação pré-treinados.",
     theme="default",