Update app.py

app.py

@@ -9,13 +9,17 @@ from shapely.geometry import Polygon
 from PIL import Image
 from io import BytesIO
 from concurrent.futures import ThreadPoolExecutor
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseUpload
+import gspread
+import time
 
 # 🔥 Inicializar Roboflow
 API_KEY = "mGkz7QhkhD90YfeiaOxV"
 rf = roboflow.Roboflow(api_key=API_KEY)
 project = rf.workspace().project("pre-eclampsia-vhaot")
 model = project.version("20").model
-
 model.confidence = 80
 model.overlap = 25
 dpi_value = 300
@@ -23,31 +27,64 @@ dpi_value = 300
 with st.expander("⚙️ Configurações Avançadas", expanded=True):
     model.confidence = st.slider("Confiança do Modelo (%)", 20, 100, 80)
 
+# 📁 Setup Google Drive e Sheets
+scope = ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/spreadsheets"]
+credentials = service_account.Credentials.from_service_account_info(st.secrets["gcp_service_account"], scopes=scope)
+drive_service = build("drive", "v3", credentials=credentials)
+sheets_client = gspread.authorize(credentials)
+sheet = sheets_client.open_by_url(st.secrets["feedback_sheet_url"]).sheet1
+
+# 📌 Funções auxiliares
 def calculate_polygon_area(points):
     polygon = Polygon([(p['x'], p['y']) for p in points])
     return polygon.area
 
 def safe_predict(image_path):
-    import time
     for attempt in range(3):
         try:
             return model.predict(image_path)
-        except Exception as e:
-            if attempt == 2:
-                raise e
+        except:
             time.sleep(1)
+    return None
+
+def resize_image(image):
+    return image.resize((640, 640))
+
+def upload_to_drive(image_bytes, filename, folder_id):
+    media = MediaIoBaseUpload(image_bytes, mimetype='image/png')
+    drive_service.files().create(
+        body={"name": filename, "parents": [folder_id]},
+        media_body=media,
+        fields='id'
+    ).execute()
+
+def find_or_create_folder(folder_name, parent=None):
+    query = f"name='{folder_name}' and mimeType='application/vnd.google-apps.folder' and trashed=false"
+    if parent:
+        query += f" and '{parent}' in parents"
+    results = drive_service.files().list(q=query, spaces='drive', fields='files(id, name)').execute()
+    folders = results.get('files', [])
+    if folders:
+        return folders[0]['id']
+    file_metadata = {
+        'name': folder_name,
+        'mimeType': 'application/vnd.google-apps.folder'
+    }
+    if parent:
+        file_metadata['parents'] = [parent]
+    file = drive_service.files().create(body=file_metadata, fields='id').execute()
+    return file.get('id')
 
 def process_image(uploaded_file):
     try:
-        # 🛡️ Sanitização do nome do arquivo
         safe_name = uploaded_file.name.replace(" ", "_")
-
-        # 🔁 Conversão leve para garantir compatibilidade
         image = Image.open(uploaded_file).convert("RGB")
 
         with tempfile.NamedTemporaryFile(suffix=".png", delete=True) as temp_file:
             image.save(temp_file.name)
             prediction = safe_predict(temp_file.name)
+            if not prediction:
+                return None
             prediction_data = prediction.json()
 
         if not prediction_data["predictions"]:
@@ -55,7 +92,6 @@ def process_image(uploaded_file):
 
         points = prediction_data["predictions"][0]["points"]
         area = calculate_polygon_area(points)
-
         x = [p['x'] for p in points] + [points[0]['x']]
         y = [p['y'] for p in points] + [points[0]['y']]
 
@@ -88,11 +124,10 @@ def process_image(uploaded_file):
             "Exibir": image
         }
 
-    except Exception as e:
-        st.error(f"Erro ao processar {uploaded_file.name}: {e}")
+    except:
         return None
 
-# 🖼️ Interface principal
+# Interface principal
 st.title("Segmentação de Imagens - Roboflow")
 upload_option = st.radio("Escolha o tipo de upload:", ["Imagem única", "Pasta de imagens"])
 results = []
@@ -123,15 +158,14 @@ elif upload_option == "Pasta de imagens":
                     st.image(result["Segmentada"], caption="Segmentação", use_container_width=True)
                     st.image(result["Poligono"], caption="Polígono", use_container_width=True)
                     st.write(f"📏 **Área segmentada:** {result['Área Segmentada (px²)']:.2f} pixels²")
+
                     zip_file.writestr(f"segmentada_{result['Imagem']}.png", result["Segmentada"].getvalue())
                     zip_file.writestr(f"poligono_{result['Imagem']}.png", result["Poligono"].getvalue())
+
         zip_images_buffer.seek(0)
 
         if results:
-            df = pd.DataFrame([{
-                "Imagem": r["Imagem"],
-                "Área Segmentada (px²)": r["Área Segmentada (px²)"]
-            } for r in results])
+            df = pd.DataFrame([{ "Imagem": r["Imagem"], "Área Segmentada (px²)": r["Área Segmentada (px²)"] } for r in results])
             st.markdown("### 📊 Tabela de Resultados")
             st.dataframe(df)
 
@@ -140,4 +174,35 @@ elif upload_option == "Pasta de imagens":
             excel_buffer.seek(0)
 
             st.download_button("📥 Baixar Tabela (Excel)", data=excel_buffer, file_name="resultados_segmentacao.xlsx", mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
-            st.download_button("📥 Baixar Todas as Imagens Segmentadas e Polígonos", data=zip_images_buffer, file_name="imagens_segmentadas.zip", mime="application/zip")
+            st.download_button("📥 Baixar Todas as Imagens Segmentadas e Polígonos", data=zip_images_buffer, file_name="imagens_segmentadas.zip", mime="application/zip")
+
+# Feedback manual
+if results:
+    st.markdown("## 📝 Feedback")
+    imagem_escolhida = st.selectbox("Selecione uma imagem para avaliar:", [r["Imagem"] for r in results])
+    avaliacao = st.radio("Como você avalia essa segmentação?", ["Ótima", "Aceitável", "Ruim"], horizontal=True)
+    observacao = st.text_area("Observações (opcional):")
+
+    if st.button("Salvar Feedback"):
+        row = [imagem_escolhida, avaliacao, observacao]
+        sheet.append_row(row)
+
+        if avaliacao in ["Aceitável", "Ruim"]:
+            sufixo = "aceitavel" if avaliacao == "Aceitável" else "ruim"
+            parent_folder = find_or_create_folder("Feedback Segmentacoes")
+            subfolder = find_or_create_folder(imagem_escolhida.replace(".png", ""), parent_folder)
+
+            for r in results:
+                if r["Imagem"] == imagem_escolhida:
+                    resized_original = resize_image(Image.open(r["Original"]))
+                    resized_segmented = resize_image(Image.open(r["Segmentada"]))
+                    resized_polygon = resize_image(Image.open(r["Poligono"]))
+
+                    for img_obj, nome in zip([resized_original, resized_segmented, resized_polygon], ["original", "segmentada", "poligono"]):
+                        buffer = BytesIO()
+                        img_obj.save(buffer, format="PNG")
+                        buffer.seek(0)
+                        upload_to_drive(buffer, f"{nome}_{sufixo}.png", subfolder)
+                    break
+
+        st.success("✅ Feedback salvo com sucesso!")