Update app.py

app.py

@@ -16,109 +16,228 @@ from googleapiclient.http import MediaIoBaseUpload
 import gspread
 import time
 
-# 🔥 Initialize Roboflow
+# 🔥 Inicializar Roboflow
 API_KEY = st.secrets["roboflow_api_key"]
 rf = roboflow.Roboflow(api_key=API_KEY)
 project = rf.workspace(st.secrets["roboflow_workspace"]).project(st.secrets["roboflow_project"])
 model = project.version(st.secrets["roboflow_version"]).model
+model.confidence = 80
+model.overlap = 25
+dpi_value = 300
 
-st.set_page_config(
-    page_title="IA Model Segmentation",
-    layout="wide"
-)
-
-st.title("IA Model Segmentation")
-
-with st.expander("Advanced settings"):
-    st.write("Select the desired Roboflow model")
-    # Add advanced settings components if needed
-
-uploaded_files = st.file_uploader(
-    "Upload one or more images for segmentation:",
-    type=['jpg', 'jpeg', 'png', 'tif', 'tiff'],
-    accept_multiple_files=True,
-    help="Drag and drop files here or click to select"
-)
-
-if uploaded_files:
-    st.success("Files uploaded successfully!")
-else:
-    st.info("No image selected")
-
-if st.button("Segment Images"):
-    if not uploaded_files:
-        st.warning("No image selected")
-    else:
-        st.info("Segmenting images, please wait...")
-        segmented_images = []
-        polygons = []
-        for uploaded_file in uploaded_files:
-            try:
-                image = Image.open(uploaded_file)
-                # Assuming image is processed here
-                st.image(image, caption="Original Image")
-                # Dummy segmented image (replace with model output)
-                st.image(image, caption="Segmented Image")
-                st.write("Polygon")
-                # Add your polygon visualization here
-                segmented_images.append(image)
-                polygons.append([])  # Placeholder
-            except Exception as e:
-                st.error("Error loading image")
-
-        st.success("Processing completed")
-
-        with tempfile.TemporaryDirectory() as temp_dir:
-            zip_path = os.path.join(temp_dir, "segmented_images.zip")
-            with zipfile.ZipFile(zip_path, "w") as zipf:
-                for i, img in enumerate(segmented_images):
-                    img_byte_arr = BytesIO()
-                    img.save(img_byte_arr, format='PNG')
-                    img_byte_arr = img_byte_arr.getvalue()
-                    zipf.writestr(f"segmented_image_{i+1}.png", img_byte_arr)
-            with open(zip_path, "rb") as f:
-                st.download_button(
-                    label="Download results as ZIP",
-                    data=f,
-                    file_name="segmented_images.zip",
-                    mime="application/zip"
-                )
-
-        st.subheader("Manual feedback")
-        feedback_images = st.multiselect(
-            "Select images for manual feedback:",
-            options=[f"segmented_image_{i+1}.png" for i in range(len(segmented_images))]
-        )
-        for img_name in feedback_images:
-            st.write(f"Manual feedback for {img_name}")
-            quality = st.radio(
-                "Segmentation quality",
-                options=["Good", "Acceptable", "Poor"],
-                key=f"quality_{img_name}"
-            )
-            observation = st.text_area(
-                "Add observation",
-                key=f"observation_{img_name}"
-            )
-            if st.button("Submit feedback", key=f"submit_{img_name}"):
-                try:
-                    # Save feedback (implement as needed)
-                    st.success("Feedback successfully submitted")
-                except Exception as e:
-                    st.error("Failed to submit feedback")
-
-        # Results table (dummy for example)
-        df_results = pd.DataFrame({
-            "Image": [f"segmented_image_{i+1}.png" for i in range(len(segmented_images))],
-            "Quality": [""] * len(segmented_images),
-            "Observations": [""] * len(segmented_images)
-        })
-        st.dataframe(df_results)
-        st.download_button(
-            label="Download results table",
-            data=df_results.to_csv(index=False).encode("utf-8"),
-            file_name="segmentation_results.csv",
-            mime="text/csv"
-        )
-else:
-    st.write("Choose the images to segment")
+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_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
+
+# 📌 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):
+    for attempt in range(3):
+        try:
+            return model.predict(image_path)
+        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:
+        safe_name = uploaded_file.name.replace(" ", "_")
+        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 {
+                    "Imagem": safe_name,
+                    "SemSegmentacao": True,
+                    "Exibir": image,
+                    "Original": get_image_bytes(image)
+                }
+            prediction_data = prediction.json()
+
+        if not prediction_data["predictions"]:
+            return {
+                "Imagem": safe_name,
+                "SemSegmentacao": True,
+                "Exibir": image,
+                "Original": get_image_bytes(image)
+            }
+
+        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']]
+
+        original_buffer = get_image_bytes(image)
+
+        segmented_buffer = BytesIO()
+        fig, ax = plt.subplots(figsize=(6, 6), dpi=dpi_value)
+        ax.imshow(image)
+        ax.plot(x, y, color='red', linewidth=2)
+        plt.savefig(segmented_buffer, format="png", bbox_inches='tight')
+        plt.close()
+
+        polygon_buffer = BytesIO()
+        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("Contorno do Polígono")
+        ax2.grid()
+        plt.savefig(polygon_buffer, format="png", bbox_inches='tight')
+        plt.close()
+
+        return {
+            "Imagem": safe_name,
+            "Área Segmentada (px²)": area,
+            "Original": original_buffer,
+            "Segmentada": segmented_buffer,
+            "Poligono": polygon_buffer,
+            "Exibir": image,
+            "SemSegmentacao": False
+        }
+
+    except:
+        return None
+
+def get_image_bytes(image):
+    buf = BytesIO()
+    image.save(buf, format="PNG")
+    buf.seek(0)
+    return buf
+
+# 🗂️ 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 == "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["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("⚠️ Nenhuma segmentação foi detectada nesta imagem.")
+
+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))
+
+        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["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([
+                { "Imagem": r["Imagem"], "Área Segmentada (px²)": r["Área Segmentada (px²)"] if not r["SemSegmentacao"] else "Sem Segmentação" }
+                for r in results
+            ])
+            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("📥 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")
+
+# 📝 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", "Sem segmentação"], 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", "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["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_{sufixo}.png", subfolder)
+
+                    # 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, 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"{nome}_{sufixo}.png", subfolder)
+                    break
+
+        st.success("✅ Feedback salvo com sucesso!")