Update app.py

app.py

@@ -16,60 +16,7 @@ from googleapiclient.http import MediaIoBaseUpload
 import gspread
 import time
 
-st.markdown("""
-    <style>
-    html, body, [data-testid="stApp"] {
-        background-color: #0f1117;
-        color: #f2f2f2;
-        font-family: 'Helvetica Neue', sans-serif;
-    }
-
-    [data-testid="stHeader"] {
-        background-color: #0f1117;
-    }
-
-    .stButton > button {
-        background-color: #1d4ed8;
-        color: white;
-        font-weight: 600;
-        border: none;
-        padding: 0.5em 1.2em;
-        border-radius: 6px;
-    }
-
-    .stButton > button:hover {
-        background-color: #1e40af;
-    }
-
-    label, .stRadio label, .stSelectbox label,
-    .stTextInput label, .stTextArea label {
-        color: #d1d5db !important;
-        font-weight: 500;
-        opacity: 1 !important;
-    }
-
-    div[role="radiogroup"] label,
-    .stRadio > div label {
-        opacity: 1 !important;
-        color: #d1d5db !important;
-    }
-
-    input, textarea {
-        color: #ffffff !important;
-        background-color: #2a2e39;
-        border-radius: 4px;
-        border: none;
-        padding: 0.4em;
-    }
-
-    .stMarkdown h1, .stMarkdown h2, .stMarkdown h3 {
-        color: #ffffff;
-    }
-    </style>
-""", unsafe_allow_html=True)
-
-
-# 🔥 Initialize Roboflow
+# 🔥 Inicializar Roboflow
 API_KEY = "mGkz7QhkhD90YfeiaOxV"
 rf = roboflow.Roboflow(api_key=API_KEY)
 project = rf.workspace().project("pre-eclampsia-vhaot")
@@ -78,10 +25,10 @@ model.confidence = 80
 model.overlap = 25
 dpi_value = 300
 
-with st.expander("⚙️ Advanced Settings", expanded=True):
-    model.confidence = st.slider("Model Confidence (%)", 20, 100, 80)
+with st.expander("⚙️ Configurações Avançadas", expanded=True):
+    model.confidence = st.slider("Confiança do Modelo (%)", 20, 100, 80)
 
-# 📁 Setup Google Drive and Sheets
+# 📁 Setup Google Drive e 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)
@@ -89,7 +36,7 @@ drive_service = build("drive", "v3", credentials=credentials)
 sheets_client = gspread.authorize(credentials)
 sheet = sheets_client.open_by_url(st.secrets["feedback_sheet_url"]).sheet1
 
-# 📌 Helper Functions
+# 📌 Funções auxiliares
 def calculate_polygon_area(points):
     polygon = Polygon([(p['x'], p['y']) for p in points])
     return polygon.area
@@ -121,7 +68,10 @@ def find_or_create_folder(folder_name, parent=None):
     folders = results.get('files', [])
     if folders:
         return folders[0]['id']
-    file_metadata = {'name': folder_name, 'mimeType': 'application/vnd.google-apps.folder'}
+    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()
@@ -137,18 +87,18 @@ def process_image(uploaded_file):
             prediction = safe_predict(temp_file.name)
             if not prediction:
                 return {
-                    "Image": safe_name,
-                    "NoSegmentation": True,
-                    "Display": image,
+                    "Imagem": safe_name,
+                    "SemSegmentacao": True,
+                    "Exibir": image,
                     "Original": get_image_bytes(image)
                 }
             prediction_data = prediction.json()
 
         if not prediction_data["predictions"]:
             return {
-                "Image": safe_name,
-                "NoSegmentation": True,
-                "Display": image,
+                "Imagem": safe_name,
+                "SemSegmentacao": True,
+                "Exibir": image,
                 "Original": get_image_bytes(image)
             }
 
@@ -170,19 +120,19 @@ def process_image(uploaded_file):
         fig2, ax2 = plt.subplots(figsize=(6, 6), dpi=dpi_value)
         ax2.plot(x, y, 'r-', linewidth=2)
         ax2.scatter(x, y, color='red', s=5)
-        ax2.set_title("Polygon Contour")
+        ax2.set_title("Contorno do Polígono")
         ax2.grid()
         plt.savefig(polygon_buffer, format="png", bbox_inches='tight')
         plt.close()
 
         return {
-            "Image": safe_name,
-            "Segmented Area (px²)": area,
+            "Imagem": safe_name,
+            "Área Segmentada (px²)": area,
             "Original": original_buffer,
-            "Segmented": segmented_buffer,
-            "Polygon": polygon_buffer,
-            "Display": image,
-            "NoSegmentation": False
+            "Segmentada": segmented_buffer,
+            "Poligono": polygon_buffer,
+            "Exibir": image,
+            "SemSegmentacao": False
         }
 
     except:
@@ -194,98 +144,100 @@ def get_image_bytes(image):
     buf.seek(0)
     return buf
 
-# 🗂️ Main Interface
-st.title("Image Segmentation - Roboflow")
-upload_option = st.radio("Select upload type:", ["Single Image", "Folder of Images"])
+# 🗂️ Interface principal
+st.title("Segmentação de Imagens - Roboflow")
+upload_option = st.radio("Escolha o tipo de upload:", ["Imagem única", "Pasta de imagens"])
 results = []
 
-if upload_option == "Single Image":
-    uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg", "tiff"])
+if upload_option == "Imagem única":
+    uploaded_file = st.file_uploader("Escolha uma imagem", type=["png", "jpg", "jpeg", "tiff"])
     if uploaded_file:
         result = process_image(uploaded_file)
         if result:
             results.append(result)
-            st.image(result["Display"], caption=f"Original Image - {result['Image']}", use_container_width=True)
-            if not result["NoSegmentation"]:
-                st.image(result["Segmented"], caption="Segmentation", use_container_width=True)
-                st.image(result["Polygon"], caption="Polygon", use_container_width=True)
-                st.write(f"📏 **Segmented Area:** {result['Segmented Area (px²)']:.2f} pixels²")
+            st.image(result["Exibir"], caption=f"Imagem Original - {result['Imagem']}", use_container_width=True)
+            if not result["SemSegmentacao"]:
+                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²")
             else:
-                st.warning("⚠️ No segmentation was detected in this image.")
+                st.warning("⚠️ Nenhuma segmentação foi detectada nesta imagem.")
 
-elif upload_option == "Folder of Images":
-    uploaded_files = st.file_uploader("Upload multiple images", type=["png", "jpg", "jpeg", "tiff"], accept_multiple_files=True)
+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:
         with ThreadPoolExecutor(max_workers=4) as executor:
             processed = list(executor.map(process_image, uploaded_files))
 
-        failures = [f.name for f, r in zip(uploaded_files, processed) if r and r.get("NoSegmentation")]
-        if failures:
-            st.warning(f"⚠️ {len(failures)} image(s) without detected segmentation:\n\n- " + "\n- ".join(failures))
+        falhas = [f.name for f, r in zip(uploaded_files, processed) if r and r.get("SemSegmentacao")]
+        if falhas:
+            st.warning(f"⚠️ {len(falhas)} imagem(ns) sem segmentação detectada:\n\n- " + "\n- ".join(falhas))
 
         zip_images_buffer = BytesIO()
         with zipfile.ZipFile(zip_images_buffer, "w") as zip_file:
             for result in processed:
                 if result:
                     results.append(result)
-                    st.image(result["Display"], caption=f"Original Image - {result['Image']}", use_container_width=True)
-                    if not result["NoSegmentation"]:
-                        st.image(result["Segmented"], caption="Segmentation", use_container_width=True)
-                        st.image(result["Polygon"], caption="Polygon", use_container_width=True)
-                        st.write(f"📏 **Segmented Area:** {result['Segmented Area (px²)']:.2f} pixels²")
-                        zip_file.writestr(f"segmented_{result['Image']}.png", result["Segmented"].getvalue())
-                        zip_file.writestr(f"polygon_{result['Image']}.png", result["Polygon"].getvalue())
+                    st.image(result["Exibir"], caption=f"Imagem Original - {result['Imagem']}", use_container_width=True)
+                    if not result["SemSegmentacao"]:
+                        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([
-                { "Image": r["Image"], "Segmented Area (px²)": r["Segmented Area (px²)"] if not r["NoSegmentation"] else "No Segmentation" }
+                { "Imagem": r["Imagem"], "Área Segmentada (px²)": r["Área Segmentada (px²)"] if not r["SemSegmentacao"] else "Sem Segmentação" }
                 for r in results
             ])
-            st.markdown("### 📊 Results Table")
+            st.markdown("### 📊 Tabela de Resultados")
             st.dataframe(df)
 
             excel_buffer = BytesIO()
             df.to_excel(excel_buffer, index=False)
             excel_buffer.seek(0)
 
-            st.download_button("📥 Download Table (Excel)", data=excel_buffer, file_name="segmentation_results.xlsx", mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
-            st.download_button("📥 Download Segmented Images", data=zip_images_buffer, file_name="segmented_images.zip", mime="application/zip")
+            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 Imagens Segmentadas", data=zip_images_buffer, file_name="imagens_segmentadas.zip", mime="application/zip")
 
-# 📝 Manual Feedback
+# 📝 Feedback manual
 if results:
     st.markdown("## 📝 Feedback")
-    selected_image = st.selectbox("Select an image to evaluate:", [r["Image"] for r in results])
-    evaluation = st.radio("How do you rate this segmentation?", ["Excellent", "Acceptable", "Poor", "No segmentation"], horizontal=True)
-    comment = st.text_area("Comments (optional):")
+    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", "Sem segmentação"], horizontal=True)
+    observacao = st.text_area("Observações (opcional):")
 
-    if st.button("Save Feedback"):
-        row = [selected_image, evaluation, comment]
+    if st.button("Salvar Feedback"):
+        row = [imagem_escolhida, avaliacao, observacao]
         sheet.append_row(row)
 
-        if evaluation in ["Acceptable", "Poor", "No segmentation"]:
-            suffix = "acceptable" if evaluation == "Acceptable" else "poor" if evaluation == "Poor" else "no_segmentation"
-            parent_folder = find_or_create_folder("Segmentation Feedback")
-            subfolder = find_or_create_folder(selected_image.replace(".png", ""), parent_folder)
+        if avaliacao in ["Aceitável", "Ruim", "Sem segmentação"]:
+            sufixo = "aceitavel" if avaliacao == "Aceitável" else "ruim" if avaliacao == "Ruim" else "sem_segmentacao"
+            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["Image"] == selected_image:
-                    resized_original = resize_image(r["Display"])
+                if r["Imagem"] == imagem_escolhida:
+                    # Sempre salva a original
+                    resized_original = resize_image(r["Exibir"])
                     buffer = BytesIO()
                     resized_original.save(buffer, format="PNG")
                     buffer.seek(0)
-                    upload_to_drive(buffer, f"original_{suffix}.png", subfolder)
+                    upload_to_drive(buffer, f"original_{sufixo}.png", subfolder)
 
-                    if evaluation != "No segmentation" and "Segmented" in r and "Polygon" in r:
-                        resized_segmented = resize_image(Image.open(BytesIO(r["Segmented"].getvalue())))
-                        resized_polygon = resize_image(Image.open(BytesIO(r["Polygon"].getvalue())))
+                    # Só salva segmentada e polígono se houver segmentação
+                    if avaliacao != "Sem segmentação" and "Segmentada" in r and "Poligono" in r:
+                        resized_segmented = resize_image(Image.open(BytesIO(r["Segmentada"].getvalue())))
+                        resized_polygon = resize_image(Image.open(BytesIO(r["Poligono"].getvalue())))
 
-                        for img_obj, name in zip([resized_segmented, resized_polygon], ["segmented", "polygon"]):
+                        for img_obj, nome in zip([resized_segmented, resized_polygon], ["segmentada", "poligono"]):
                             buffer = BytesIO()
                             img_obj.save(buffer, format="PNG")
                             buffer.seek(0)
-                            upload_to_drive(buffer, f"{name}_{suffix}.png", subfolder)
+                            upload_to_drive(buffer, f"{nome}_{sufixo}.png", subfolder)
                     break
 
-        st.success("✅ Feedback successfully saved!")
+        st.success("✅ Feedback salvo com sucesso!")