Create app.py

app.py

@@ -0,0 +1,136 @@
+import streamlit as st
+import roboflow
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import re
+import io
+from shapely.geometry import Polygon
+from PIL import Image
+
+# 🔥 Inicializar o modelo do Roboflow
+API_KEY = "SUA_API_KEY_AQUI"  # ⚠️ Substitua pela sua API Key do Roboflow
+rf = roboflow.Roboflow(api_key=API_KEY)
+project = rf.workspace().project("pre-eclampsia-vhaot")
+model = project.version("4").model
+
+# Configurar confiança e sobreposição
+model.confidence = 80
+model.overlap = 25
+
+# 📌 Função para calcular a área do polígono segmentado
+def calculate_polygon_area(points):
+    polygon = Polygon([(p['x'], p['y']) for p in points])
+    return polygon.area
+
+# 📌 Função para processar uma única imagem
+def process_image(image, image_name):
+    # Converter imagem para RGB (caso seja TIFF ou outro formato especial)
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    # Salvar temporariamente a imagem para passar ao Roboflow
+    temp_path = "temp_image.png"
+    image.save(temp_path)
+
+    # Fazer a predição
+    prediction = model.predict(temp_path)
+    prediction_data = prediction.json()
+
+    # Verificar se há segmentação
+    if "predictions" not in prediction_data or len(prediction_data["predictions"]) == 0:
+        return None, None, None
+
+    # Obter os pontos da segmentação e calcular a área
+    points = prediction_data['predictions'][0]['points']
+    area = calculate_polygon_area(points)
+
+    # Criar contorno da segmentação
+    x_coords = [p['x'] for p in points] + [points[0]['x']]
+    y_coords = [p['y'] for p in points] + [points[0]['y']]
+
+    # Criar figura
+    fig, ax = plt.subplots(figsize=(6, 6))
+    ax.imshow(image)
+    ax.plot(x_coords, y_coords, color='red', linewidth=2)
+    ax.set_title(f"Segmentação: {image_name}")
+
+    # Salvar a imagem segmentada em buffer
+    img_buffer = io.BytesIO()
+    plt.savefig(img_buffer, format="png", bbox_inches='tight')
+    img_buffer.seek(0)
+    plt.close()
+
+    return area, img_buffer, fig
+
+# 📌 Função para extrair a hora do nome do arquivo (se aplicável)
+def extract_hour_from_filename(filename):
+    match = re.search(r"(\d{1,2})h", filename.lower())
+    return int(match.group(1)) if match else None
+
+# 📌 Interface Streamlit
+st.title("Segmentação de Imagens - Roboflow")
+st.write("Envie uma ou mais imagens para segmentação usando o modelo do Roboflow.")
+
+# Opção de carregar uma única imagem ou múltiplas imagens
+upload_option = st.radio("Escolha o tipo de upload:", ["Imagem única", "Pasta de imagens"])
+
+# Lista para armazenar resultados
+results = []
+
+if upload_option == "Imagem única":
+    uploaded_file = st.file_uploader("Escolha uma imagem", type=["png", "jpg", "jpeg", "tiff"])
+
+    if uploaded_file:
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Imagem Original", use_column_width=True)
+
+        st.write("Processando a segmentação...")
+        area, segmented_buffer, fig = process_image(image, uploaded_file.name)
+
+        if area is not None:
+            st.image(segmented_buffer, caption="Imagem Segmentada", use_column_width=True)
+            st.write(f"📏 **Área segmentada:** {area:.2f} pixels²")
+            st.download_button("Baixar Imagem Segmentada", segmented_buffer, file_name="segmentada.png", mime="image/png")
+        else:
+            st.warning("Nenhuma segmentação encontrada.")
+
+elif upload_option == "Pasta de imagens":
+    uploaded_files = st.file_uploader("Envie várias imagens", type=["png", "jpg", "jpeg", "tiff"], accept_multiple_files=True)
+
+    if uploaded_files:
+        for uploaded_file in uploaded_files:
+            image = Image.open(uploaded_file)
+            st.write(f"**Processando:** {uploaded_file.name}")
+            st.image(image, caption="Imagem Original", use_column_width=True)
+
+            area, segmented_buffer, fig = process_image(image, uploaded_file.name)
+
+            if area is not None:
+                st.image(segmented_buffer, caption="Imagem Segmentada", use_column_width=True)
+                st.write(f"📏 **Área segmentada:** {area:.2f} pixels²")
+
+                results.append({
+                    "Imagem": uploaded_file.name,
+                    "Hora": extract_hour_from_filename(uploaded_file.name),
+                    "Área Segmentada (px²)": area
+                })
+
+        # Criar DataFrame e exibir os resultados
+        if results:
+            results_df = pd.DataFrame(results).sort_values(by="Hora", na_position='last')
+            st.write("📊 **Tabela de Resultados**")
+            st.dataframe(results_df)
+
+            # Salvar em Excel para download
+            excel_buffer = io.BytesIO()
+            results_df.to_excel(excel_buffer, index=False)
+            excel_buffer.seek(0)
+
+            st.download_button(
+                label="📥 Baixar Resultados em Excel",
+                data=excel_buffer,
+                file_name="resultados_segmentacao.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )