Update app.py

app.py

@@ -1,151 +1,238 @@
 import streamlit as st
 import os
-from PIL import Image, ImageDraw, ImageFont
+from pathlib import Path
+from PIL import Image
 import cv2
 import tempfile
 import time  # For simulating processing time
+
 from object_detection import detectObjects
 from object_detection import detectVideo
 from object_detection_count import detectObjectsAndCount
 from pose_analysis import process_gif
 from traffic_sign_detection import detectTrafficObjects
 
+# -----------------------------
 # Constants
+# -----------------------------
 MAX_FILE_SIZE_MB = 250
 TABS = ["Object Detection", "Pose Analysis", "Object Counting", "Traffic Sign Detection"]
 
-# Helper function to check file size
+ASSETS_DIR = Path("assets")
+
+TASK_TO_ASSET_SUBDIR = {
+    "Object Detection": "object_detection",
+    "Pose Analysis": "pose_analysis",
+    "Object Counting": "object_counting",
+    "Traffic Sign Detection": "traffic_sign_detection",
+}
+
+IMAGE_EXTS = {".jpg", ".jpeg", ".png"}
+VIDEO_EXTS = {".mp4", ".mov", ".avi", ".gif"}
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
 def check_file_size(file):
     file.seek(0, os.SEEK_END)
     file_size = file.tell() / (1024 * 1024)  # Convert to MB
     file.seek(0)  # Reset file pointer
     return file_size
 
-# Placeholder function for processing logic
-def process_file(uploaded_file, tab_name, confidence_score, progress_placeholder, class_type):
-    progress_placeholder.info(f"Processing... Please wait. (Confidence Score: {confidence_score})")
-    time.sleep(2)  # Simulate processing delay
-    if tab_name == 'Object Detection':
-        # Process Image
-        if uploaded_file.name.endswith((".jpg", ".png", ".jpeg")):  # Image file
-            #img = Image.open(uploaded_file)
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            img = detectObjects(uploaded_file.name, confidence_score)
+
+def save_uploaded_file_to_temp(uploaded_file) -> str:
+    """
+    Saves uploaded file to a temp folder and returns the absolute path.
+    This avoids filename collisions and issues with Streamlit reruns.
+    """
+    tmp_dir = Path(tempfile.gettempdir())
+    # Make name safer (optional) - keep it simple
+    safe_name = uploaded_file.name.replace("/", "_").replace("\\", "_")
+    save_path = tmp_dir / safe_name
+    with open(save_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+    return str(save_path)
+
+
+def list_demo_files(task_name: str, limit: int = 6):
+    subdir = TASK_TO_ASSET_SUBDIR.get(task_name)
+    if not subdir:
+        return []
+    folder = ASSETS_DIR / subdir
+    if not folder.exists():
+        return []
+    files = [
+        p
+        for p in folder.iterdir()
+        if p.is_file() and p.suffix.lower() in (IMAGE_EXTS | VIDEO_EXTS)
+    ]
+    files.sort(key=lambda p: p.name.lower())
+    return files[:limit]
+
+
+def render_media(path: Path):
+    ext = path.suffix.lower()
+    if ext in IMAGE_EXTS:
+        st.image(str(path), caption=path.name, use_container_width=True)
+    elif ext in VIDEO_EXTS:
+        st.video(str(path))
+        st.caption(path.name)
+
+
+def render_showcase(tasks, per_task_limit=6):
+    st.subheader("Example outputs (what to expect)")
+    st.write(
+        "These are pre-generated results (detected/segmented/pose analyzed/traffic signs) so you can see the expected output before uploading."
+    )
+
+    for task in tasks:
+        st.markdown(f"### {task}")
+        demo_files = list_demo_files(task, limit=per_task_limit)
+
+        if not demo_files:
+            st.info(
+                f"No demo files found for **{task}**. Add images/videos under: "
+                f"`{ASSETS_DIR / TASK_TO_ASSET_SUBDIR[task]}`"
+            )
+            continue
+
+        cols = st.columns(3)
+        for idx, p in enumerate(demo_files):
+            with cols[idx % 3]:
+                render_media(p)
+
+        st.divider()
+
+
+def process_file(file_path, tab_name, confidence_score, progress_placeholder, class_type):
+    progress_placeholder.info(
+        f"Processing... Please wait. (Confidence Score: {confidence_score})"
+    )
+    time.sleep(1)  # small UX delay
+
+    if tab_name == "Object Detection":
+        if file_path.lower().endswith((".jpg", ".png", ".jpeg")):
+            progress_placeholder.empty()
+            img = detectObjects(file_path, confidence_score)
             return img, "image"
-    
-        # Process Video
-        elif uploaded_file.name.endswith((".mp4", ".avi", ".mov", ".gif")):  # Video file
-            #temp_video_path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-            #with open(temp_video_path, "wb") as f:
-             #   f.write(uploaded_file.read())
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            temp_video_path = detectVideo(uploaded_file.name, confidence_score)
-            return temp_video_path, "video"
-    
-        # Unsupported file type
-        else:
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            st.error("Unsupported file format! Please upload an image or video.")
-            return None, None
-    elif tab_name == 'Object Counting':
-         # Process Image
-        if uploaded_file.name.endswith((".jpg", ".png", ".jpeg")):  # Image file
-            #img = Image.open(uploaded_file)
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            img, count = detectObjectsAndCount(uploaded_file.name, confidence_score, class_type)
+
+        elif file_path.lower().endswith((".mp4", ".avi", ".mov", ".gif")):
+            progress_placeholder.empty()
+            out_video_path = detectVideo(file_path, confidence_score)
+            return out_video_path, "video"
+
+        progress_placeholder.empty()
+        st.error("Unsupported file format! Please upload an image or video.")
+        return None, None
+
+    elif tab_name == "Object Counting":
+        if file_path.lower().endswith((".jpg", ".png", ".jpeg")):
+            progress_placeholder.empty()
+            img, count = detectObjectsAndCount(file_path, confidence_score, class_type)
+            # Show count in UI
+            st.info(f"Count for class '{class_type}': {count}")
             return img, "image"
-    
-        # Process Video
-        elif uploaded_file.name.endswith((".mp4", ".avi", ".mov", ".gif")):  # Video file
-            #temp_video_path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-            #with open(temp_video_path, "wb") as f:
-             #   f.write(uploaded_file.read())
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            temp_video_path = detectVideo(uploaded_file.name, confidence_score)
-            return temp_video_path, "video"
-    
-        # Unsupported file type
-        else:
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            st.error("Unsupported file format! Please upload an image or video.")
-            return None, None       
-    elif tab_name == 'Pose Analysis':
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            temp_video_path = process_gif(uploaded_file.name, confidence_score)
-            return temp_video_path, "video"        
-    elif tab_name == 'Traffic Sign Detection':
-        if uploaded_file.name.endswith((".jpg", ".png", ".jpeg")):  # Image file
-            #img = Image.open(uploaded_file)
-            progress_placeholder.empty()  # Clear the "Processing..." message
-            img = detectTrafficObjects(uploaded_file.name, confidence_score)
+
+        elif file_path.lower().endswith((".mp4", ".avi", ".mov", ".gif")):
+            progress_placeholder.empty()
+            out_video_path = detectVideo(file_path, confidence_score)
+            return out_video_path, "video"
+
+        progress_placeholder.empty()
+        st.error("Unsupported file format! Please upload an image or video.")
+        return None, None
+
+    elif tab_name == "Pose Analysis":
+        progress_placeholder.empty()
+        out_video_path = process_gif(file_path, confidence_score)
+        return out_video_path, "video"
+
+    elif tab_name == "Traffic Sign Detection":
+        if file_path.lower().endswith((".jpg", ".png", ".jpeg")):
+            progress_placeholder.empty()
+            img = detectTrafficObjects(file_path, confidence_score)
             return img, "image"
 
-# Streamlit app layout
+        progress_placeholder.empty()
+        st.error("Unsupported file format! Please upload an image.")
+        return None, None
+
+    st.error("Unknown tab selection.")
+    return None, None
+
+
+# -----------------------------
+# Streamlit Layout
+# -----------------------------
+st.set_page_config(page_title="AI Video/Image Analysis Platform", layout="wide")
+
 st.title("AI Video/Image Analysis Platform")
 st.write("Upload an image or video and choose a tab for analysis.")
 
-# Tabs for different functionalities
-tab = st.tabs(TABS)
+# Showcase section (NO expander)
+render_showcase(TABS, per_task_limit=6)
 
-uploaded_file = None
+# Tabs for different functionalities
+tabs = st.tabs(TABS)
 
 for i, tab_name in enumerate(TABS):
-    with tab[i]:
+    with tabs[i]:
         st.header(tab_name)
 
-        # File uploader
         uploaded_file = st.file_uploader(
-            "Upload an Image/Video", type=["jpg", "jpeg", "png", "gif", "mp4", "avi", "mov"], key=tab_name
+            "Upload an Image/Video",
+            type=["jpg", "jpeg", "png", "gif", "mp4", "avi", "mov"],
+            key=f"uploader_{tab_name}",
         )
 
-        # Check file size
         if uploaded_file:
             file_size = check_file_size(uploaded_file)
             if file_size > MAX_FILE_SIZE_MB:
-                st.error(f"File size exceeds {MAX_FILE_SIZE_MB} MB. Please upload a smaller file.")
-            else:
-                st.success(f"Uploaded file: {uploaded_file.name} ({file_size:.2f} MB)")
-                with open(f"{uploaded_file.name}", "wb") as f:
-                   f.write(uploaded_file.read())
-
-                # Confidence score input
-                confidence_score = st.number_input(
-                    "Adjust Confidence Score",
-                    min_value=0.0,
-                    max_value=1.0,
-                    value=0.5,
-                    step=0.01,
-                    help="Set the confidence score threshold for the analysis (default: 0.5).",
-                    key=f"confidence_{tab_name}",
+                st.error(
+                    f"File size exceeds {MAX_FILE_SIZE_MB} MB. Please upload a smaller file."
                 )
+                continue
+
+            st.success(f"Uploaded file: {uploaded_file.name} ({file_size:.2f} MB)")
+
+            # Save to temp and use the full path for downstream processing
+            file_path = save_uploaded_file_to_temp(uploaded_file)
 
-                # Additional input for "Object Counting" tab
-                class_type = None
-                if tab_name == "Object Counting":
-                    class_type = st.text_input(
-                        "Enter Class Type",
-                        value="car",  # Default value, adjust as needed
-                        help="Specify the class type to count (e.g., 'car', 'person').",
-                        key=f"class_type_{tab_name}",
+            confidence_score = st.number_input(
+                "Adjust Confidence Score",
+                min_value=0.0,
+                max_value=1.0,
+                value=0.5,
+                step=0.01,
+                help="Set the confidence score threshold for the analysis (default: 0.5).",
+                key=f"confidence_{tab_name}",
+            )
+
+            class_type = None
+            if tab_name == "Object Counting":
+                class_type = st.text_input(
+                    "Enter Class Type",
+                    value="car",
+                    help="Specify the class type to count (e.g., 'car', 'person').",
+                    key=f"class_type_{tab_name}",
+                )
+
+            if st.button(f"Process {tab_name}", key=f"process_{tab_name}"):
+                progress_placeholder = st.empty()
+                with st.spinner("Processing... Please wait."):
+                    result, result_type = process_file(
+                        file_path,
+                        tab_name,
+                        confidence_score,
+                        progress_placeholder,
+                        class_type,
                     )
 
-                # Process file when button is clicked
-                if st.button(f"Process {tab_name}", key=f"process_{tab_name}"):
-                    # Placeholder for the processing message
-                    progress_placeholder = st.empty()
-                    with st.spinner("Processing... Please wait."):
-                        result, result_type = process_file(
-                            uploaded_file,
-                            tab_name,
-                            confidence_score,
-                            progress_placeholder,
-                            class_type,  # Pass class_type to the processing function
-                        )
-                        if result_type == "video":
-                            if result:
-                                st.success(f"{tab_name} completed successfully!")
-                                st.video(result)
-                        if result_type == "image":
-                            #if result:
-                                st.success(f"{tab_name} completed successfully!")
-                                st.image(result, caption=f"{tab_name} Result", use_column_width=True)
+                if result_type == "video" and result:
+                    st.success(f"{tab_name} completed successfully!")
+                    st.video(result)
+
+                if result_type == "image" and result is not None:
+                    st.success(f"{tab_name} completed successfully!")
+                    st.image(result, caption=f"{tab_name} Result", use_container_width=True)