Update app.py

app.py

@@ -16,6 +16,9 @@ from googleapiclient.http import MediaIoBaseUpload
 import gspread
 import time
 
+APP_VERSION = "2.4"
+
+
 # 🔥 Inicializar Roboflow
 API_KEY = st.secrets["roboflow_api_key"]
 rf = roboflow.Roboflow(api_key=API_KEY)
@@ -24,12 +27,32 @@ model = project.version(st.secrets["roboflow_version"]).model
 model.confidence = 80
 model.overlap = 25
 dpi_value = 300
-APP_VERSION = "2.4"
-
 
 with st.expander("⚙️ Advanced Settings", expanded=True):
     model.confidence = st.slider("Model Confidence (%)", 20, 100, 80)
 
+    st.markdown(
+        "### Physical calibration (optional)\n"
+        "Provide the physical scale to convert pixel area to µm². "
+        "If left empty, results will be reported only in pixels²."
+    )
+
+    col1, col2 = st.columns(2)
+    fov_um = col1.number_input(
+        "Field of view width (µm)",
+        min_value=0.0,
+        value=0.0,
+        step=1.0,
+        help="Physical width of the image field, in micrometers."
+    )
+    pixel_size_um = col2.number_input(
+        "Pixel size (µm / pixel)",
+        min_value=0.0,
+        value=0.0,
+        step=0.01,
+        help="If provided, this value overrides the FOV-based calibration."
+    )
+
 # 📁 Setup Google Drive e Sheets com OAuth 2.0
 scope = ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/spreadsheets"]
 credentials = Credentials(
@@ -49,6 +72,7 @@ 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:
@@ -57,9 +81,11 @@ def safe_predict(image_path):
             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(
@@ -68,6 +94,7 @@ def upload_to_drive(image_bytes, filename, folder_id):
         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:
@@ -85,39 +112,61 @@ def find_or_create_folder(folder_name, parent=None):
     file = drive_service.files().create(body=file_metadata, fields='id').execute()
     return file.get('id')
 
+
 def get_image_bytes(image):
     buf = BytesIO()
     image.save(buf, format="PNG")
     buf.seek(0)
     return buf
 
-def process_image(uploaded_file):
+
+def process_image(uploaded_file, fov_um=None, pixel_size_um=None):
     try:
         safe_name = uploaded_file.name.replace(" ", "_")
         image = Image.open(uploaded_file).convert("RGB")
 
+        # Image dimensions for physical calibration
+        width_px, height_px = image.size
+
+        # Determine effective pixel size in µm/pixel
+        effective_pixel_size_um = None
+        if pixel_size_um is not None and pixel_size_um > 0:
+            effective_pixel_size_um = pixel_size_um
+        elif fov_um is not None and fov_um > 0:
+            # Assume FOV refers to the horizontal field of view
+            effective_pixel_size_um = fov_um / float(width_px)
+
         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,
+                    "Área Segmentada (px²)": None,
+                    "Área Segmentada (µm²)": None,
                     "SemSegmentacao": True,
                     "Exibir": image,
-                    "Original": get_image_bytes(image)
+                    "Original": get_image_bytes(image),
                 }
             prediction_data = prediction.json()
 
         if not prediction_data["predictions"]:
             return {
                 "Imagem": safe_name,
+                "Área Segmentada (px²)": None,
+                "Área Segmentada (µm²)": None,
                 "SemSegmentacao": True,
                 "Exibir": image,
-                "Original": get_image_bytes(image)
+                "Original": get_image_bytes(image),
             }
 
         points = prediction_data["predictions"][0]["points"]
-        area = calculate_polygon_area(points)
+        area_px2 = calculate_polygon_area(points)
+
+        area_um2 = None
+        if effective_pixel_size_um is not None:
+            area_um2 = area_px2 * (effective_pixel_size_um ** 2)
+
         x = [p['x'] for p in points] + [points[0]['x']]
         y = [p['y'] for p in points] + [points[0]['y']]
 
@@ -141,51 +190,117 @@ def process_image(uploaded_file):
 
         return {
             "Imagem": safe_name,
-            "Área Segmentada (px²)": area,
+            "Área Segmentada (px²)": area_px2,
+            "Área Segmentada (µm²)": area_um2,
             "Original": original_buffer,
             "Segmentada": segmented_buffer,
             "Poligono": polygon_buffer,
             "Exibir": image,
-            "SemSegmentacao": False
+            "SemSegmentacao": False,
         }
 
     except:
         return None
 
+
+def save_feedback(result, avaliacao, observacao):
+    image_name = result["Imagem"]
+
+    # Save feedback row to Google Sheet
+    row = [image_name, avaliacao, observacao]
+    sheet.append_row(row)
+
+    # Upload feedback images to Google Drive for curation
+    if avaliacao in ["Acceptable", "Bad", "No segmentation"]:
+        sufixo = (
+            "aceitavel" if avaliacao == "Acceptable"
+            else "ruim" if avaliacao == "Bad"
+            else "sem_segmentacao"
+        )
+        parent_folder = find_or_create_folder("Feedback Segmentacoes")
+        subfolder = find_or_create_folder(image_name.replace(".png", ""), parent_folder)
+
+        # Original image (always saved)
+        resized_original = resize_image(result["Exibir"])
+        buffer = BytesIO()
+        resized_original.save(buffer, format="PNG")
+        buffer.seek(0)
+        upload_to_drive(buffer, f"original_{sufixo}.png", subfolder)
+
+        # Segmented and polygon images (only if segmentation exists)
+        if avaliacao != "No segmentation" and "Segmentada" in result and "Poligono" in result:
+            resized_segmented = resize_image(Image.open(BytesIO(result["Segmentada"].getvalue())))
+            resized_polygon = resize_image(Image.open(BytesIO(result["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)
+
+
 # 🗂️ Interface principal
 st.title("IA Model Segmentation")
-st.caption(f"Version {APP_VERSION}")
+st.caption(f"Version {APP_VERSION} (model retrained with user feedback)")
 upload_option = st.radio("Choose upload type:", ["Single image", "Image folder"])
-
-
 results = []
 
 if upload_option == "Single image":
     uploaded_file = st.file_uploader("Choose an image", type=["png", "jpg", "jpeg", "tiff"])
     if uploaded_file:
-        result = process_image(uploaded_file)
+        result = process_image(uploaded_file, fov_um=fov_um, pixel_size_um=pixel_size_um)
         if result:
             results.append(result)
             st.image(result["Exibir"], caption=f"Original Image - {result['Imagem']}", use_container_width=True)
+
             if not result["SemSegmentacao"]:
                 st.image(result["Segmentada"], caption="Segmentation", use_container_width=True)
                 st.image(result["Poligono"], caption="Polygon", use_container_width=True)
-                st.write(f"📏 **Segmented Area:** {result['Área Segmentada (px²)']:.2f} pixels²")
+
+                area_px2 = result["Área Segmentada (px²)"]
+                area_um2 = result["Área Segmentada (µm²)"]
+
+                if area_px2 is not None:
+                    st.write(f"📏 **Segmented Area:** {area_px2:.2f} pixels²")
+                    if area_um2 is not None:
+                        st.write(f"📏 **Segmented Area (calibrated):** {area_um2:.2f} µm²")
 
                 st.download_button(
                     label="📥 Download Segmented Image",
                     data=result["Segmentada"],
                     file_name="segmented_images.png",
-                    mime="image/png"
+                    mime="image/png",
                 )
             else:
                 st.warning("⚠️ No segmentation was detected in this image.")
 
+            st.markdown("## 📝 Feedback for this image")
+            avaliacao = st.radio(
+                "How do you evaluate this segmentation?",
+                ["Great", "Acceptable", "Bad", "No segmentation"],
+                horizontal=True,
+                key=f"single_radio_{result['Imagem']}",
+            )
+            observacao = st.text_area(
+                "Observations (optional):",
+                key=f"single_obs_{result['Imagem']}",
+            )
+            if st.button("Save Feedback", key=f"single_btn_{result['Imagem']}"):
+                save_feedback(result, avaliacao, observacao)
+                st.success("✅ Feedback saved successfully!")
+
 elif upload_option == "Image folder":
-    uploaded_files = st.file_uploader("Upload multiple images", type=["png", "jpg", "jpeg", "tiff"], accept_multiple_files=True)
+    uploaded_files = st.file_uploader(
+        "Upload multiple images",
+        type=["png", "jpg", "jpeg", "tiff"],
+        accept_multiple_files=True,
+    )
     if uploaded_files:
+        def process_wrapper(f):
+            return process_image(f, fov_um=fov_um, pixel_size_um=pixel_size_um)
+
         with ThreadPoolExecutor(max_workers=4) as executor:
-            processed = list(executor.map(process_image, uploaded_files))
+            processed = list(executor.map(process_wrapper, uploaded_files))
 
         falhas = [f.name for f, r in zip(uploaded_files, processed) if r and r.get("SemSegmentacao")]
         if falhas:
@@ -197,18 +312,56 @@ elif upload_option == "Image folder":
                 if result:
                     results.append(result)
                     st.image(result["Exibir"], caption=f"Original Image - {result['Imagem']}", use_container_width=True)
+
                     if not result["SemSegmentacao"]:
                         st.image(result["Segmentada"], caption="Segmentation", use_container_width=True)
                         st.image(result["Poligono"], caption="Polygon", use_container_width=True)
-                        st.write(f"📏 **Segmented Area:** {result['Área Segmentada (px²)']:.2f} pixels²")
+
+                        area_px2 = result["Área Segmentada (px²)"]
+                        area_um2 = result["Área Segmentada (µm²)"]
+
+                        if area_px2 is not None:
+                            st.write(f"📏 **Segmented Area:** {area_px2:.2f} pixels²")
+                            if area_um2 is not None:
+                                st.write(f"📏 **Segmented Area (calibrated):** {area_um2:.2f} µm²")
+
                         zip_file.writestr(f"segmentada_{result['Imagem']}.png", result["Segmentada"].getvalue())
                         zip_file.writestr(f"poligono_{result['Imagem']}.png", result["Poligono"].getvalue())
+                    else:
+                        st.warning("⚠️ No segmentation was detected in this image.")
+
+                    st.markdown(f"#### 📝 Feedback – {result['Imagem']}")
+                    avaliacao = st.radio(
+                        "How do you evaluate this segmentation?",
+                        ["Great", "Acceptable", "Bad", "No segmentation"],
+                        horizontal=True,
+                        key=f"folder_radio_{result['Imagem']}",
+                    )
+                    observacao = st.text_area(
+                        "Observations (optional):",
+                        key=f"folder_obs_{result['Imagem']}",
+                    )
+                    if st.button("Save Feedback", key=f"folder_btn_{result['Imagem']}"):
+                        save_feedback(result, avaliacao, observacao)
+                        st.success(f"✅ Feedback for {result['Imagem']} saved successfully.")
 
         zip_images_buffer.seek(0)
 
         if results:
             df = pd.DataFrame([
-                { "Image": r["Imagem"], "Segmented Area (px²)": r["Área Segmentada (px²)"] if not r["SemSegmentacao"] else "No Segmentation" }
+                {
+                    "Image": r["Imagem"],
+                    "Segmented Area (px²)": (
+                        r["Área Segmentada (px²)"]
+                        if (not r["SemSegmentacao"] and r["Área Segmentada (px²)"] is not None)
+                        else "No Segmentation"
+                    ),
+                    "Segmented Area (µm²)": (
+                        f"{r['Área Segmentada (µm²)']:.2f}"
+                        if (not r["SemSegmentacao"] and r["Área Segmentada (µm²)"] is not None)
+                        else ""
+                    ),
+                }
                 for r in results
             ])
             st.markdown("### 📊 Results Table")
@@ -218,42 +371,15 @@ elif upload_option == "Image folder":
             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")
-
-# 📝 Manual Feedback
-if results:
-    st.markdown("## 📝 Feedback")
-    imagem_escolhida = st.selectbox("Select an image to evaluate:", [r["Imagem"] for r in results])
-    avaliacao = st.radio("How do you evaluate this segmentation?", ["Great", "Acceptable", "Bad", "No segmentation"], horizontal=True)
-    observacao = st.text_area("Observations (optional):")
-
-    if st.button("Save Feedback"):
-        row = [imagem_escolhida, avaliacao, observacao]
-        sheet.append_row(row)
-
-        if avaliacao in ["Acceptable", "Bad", "No segmentation"]:
-            sufixo = "aceitavel" if avaliacao == "Acceptable" else "ruim" if avaliacao == "Bad" 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:
-                    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)
-
-                    if avaliacao != "No segmentation" 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 saved successfully!")
+            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",
+            )