Update app.py

app.py

@@ -1,16 +1,23 @@
 import streamlit as st
-from roboflow import Roboflow
-import os
+import roboflow
 import pandas as pd
 import matplotlib.pyplot as plt
-from PIL import Image
-from shapely.geometry import Polygon
-from shapely.ops import unary_union
 import zipfile
-import io
-import uuid
+import tempfile
+import os
+import json
+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
+
+st.set_page_config(page_title="Image Segmentation - Roboflow", layout="wide")
 
-# === THEME SETUP ===
 st.markdown("""
     <style>
     .main {
@@ -31,62 +38,64 @@ st.markdown("""
     </style>
 """, unsafe_allow_html=True)
 
-# === PAGE SETUP ===
-st.set_page_config(page_title="Medical Image Segmentation", layout="wide")
-st.title("Medical Image Segmentation Platform")
-
-# === MAIN APP ===
-with st.expander("Upload Images"):
-    uploaded_files = st.file_uploader("Choose one or more image files", accept_multiple_files=True, type=['jpg', 'jpeg', 'png'])
-
-if uploaded_files:
-    st.subheader("Uploaded Images")
-    for uploaded_file in uploaded_files:
-        image = Image.open(uploaded_file)
-        st.image(image, caption=uploaded_file.name, use_column_width=True)
+# 🔥 Initialize 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
 
-    st.subheader("Segmentation Options")
-    model_api_key = st.text_input("mGkz7QhkhD90YfeiaOxV")
-    model_name = st.text_input("pre-eclampsia-vhaot")
-    project_version = st.text_input("20")
+with st.expander("⚙️ Advanced Settings", expanded=True):
+    model.confidence = st.slider("Model Confidence (%)", 20, 100, 80)
 
-    if st.button("Run Segmentation"):
-        if not model_api_key or not model_name or not project_version:
-            st.error("Please fill in all model information fields.")
-        else:
-            rf = Roboflow(api_key=model_api_key)
-            project = rf.workspace().project(model_name)
-            model = project.version(project_version).model
+# 📁 Setup Google Drive and Sheets
+scope = ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/spreadsheets"]
+credentials_dict = json.loads(st.secrets["gcp_service_account"])
+credentials = service_account.Credentials.from_service_account_info(credentials_dict, 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
 
-            results = []
-            for uploaded_file in uploaded_files:
-                image = Image.open(uploaded_file)
-                image_path = f"temp_{uuid.uuid4().hex}.png"
-                image.save(image_path)
+# 📌 Helper Functions
 
-                prediction = model.predict(image_path).json()
-                os.remove(image_path)
+def calculate_polygon_area(points):
+    polygon = Polygon([(p['x'], p['y']) for p in points])
+    return polygon.area
 
-                st.image(image, caption=f"Original: {uploaded_file.name}", use_column_width=True)
+def safe_predict(image_path):
+    for attempt in range(3):
+        try:
+            return model.predict(image_path)
+        except:
+            time.sleep(1)
+    return None
 
-                # Show segmentation result
-                mask_url = prediction['predictions'][0]['image'] if prediction['predictions'] else None
-                if mask_url:
-                    st.image(mask_url, caption="Segmented Image", use_column_width=True)
-                else:
-                    st.warning(f"No segmentation detected for {uploaded_file.name}.")
+def resize_image(image):
+    return image.resize((640, 640))
 
-                results.append({"filename": uploaded_file.name, "prediction": prediction})
+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()
 
-            st.success("Segmentation completed.")
-
-    # Download ZIP
-    if st.button("Download Results as ZIP"):
-        zip_buffer = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED) as zip_file:
-            for uploaded_file in uploaded_files:
-                image_bytes = uploaded_file.read()
-                zip_file.writestr(uploaded_file.name, image_bytes)
-
-        zip_buffer.seek(0)
-        st.download_button("Download ZIP", data=zip_buffer, file_name="segmented_images.zip", mime="application/zip")
+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')