common video and image upload field

app.py

@@ -19,8 +19,8 @@ import gradio as gr
 import numpy as np
 import spaces
 import torch
-from pillow_heif import register_heif_opener
 from PIL import Image
+from pillow_heif import register_heif_opener
 
 register_heif_opener()
 
@@ -368,7 +368,7 @@ def populate_visualization_tabs(processed_data):
 # -------------------------------------------------------------------------
 # 2) Handle uploaded video/images --> produce target_dir + images
 # -------------------------------------------------------------------------
-def handle_uploads(input_video, input_images, s_time_interval=1.0):
+def handle_uploads(unified_upload, s_time_interval=1.0):
     """
     Create a new 'target_dir' + 'images' subfolder, and place user-uploaded
     images or extracted frames from video into it. Return (target_dir, image_paths).
@@ -390,76 +390,100 @@ def handle_uploads(input_video, input_images, s_time_interval=1.0):
 
     image_paths = []
 
-    # --- Handle images ---
-    if input_images is not None:
-        for file_data in input_images:
+    # --- Handle uploaded files (both images and videos) ---
+    if unified_upload is not None:
+        for file_data in unified_upload:
             if isinstance(file_data, dict) and "name" in file_data:
                 file_path = file_data["name"]
             else:
-                file_path = file_data
-            
-            # Check if the file is a HEIC image
+                file_path = str(file_data)
+
             file_ext = os.path.splitext(file_path)[1].lower()
-            if file_ext in ['.heic', '.heif']:
-                # Convert HEIC to JPEG for better gallery compatibility
-                try:
-                    with Image.open(file_path) as img:
-                        # Convert to RGB if necessary (HEIC can have different color modes)
-                        if img.mode not in ('RGB', 'L'):
-                            img = img.convert('RGB')
-                        
-                        # Create JPEG filename
+
+            # Check if it's a video file
+            video_extensions = [
+                ".mp4",
+                ".avi",
+                ".mov",
+                ".mkv",
+                ".wmv",
+                ".flv",
+                ".webm",
+                ".m4v",
+                ".3gp",
+            ]
+            if file_ext in video_extensions:
+                # Handle as video
+                vs = cv2.VideoCapture(file_path)
+                fps = vs.get(cv2.CAP_PROP_FPS)
+                frame_interval = int(fps * s_time_interval)  # frames per interval
+
+                count = 0
+                video_frame_num = 0
+                while True:
+                    gotit, frame = vs.read()
+                    if not gotit:
+                        break
+                    count += 1
+                    if count % frame_interval == 0:
+                        # Use original filename as prefix for frames
                         base_name = os.path.splitext(os.path.basename(file_path))[0]
-                        dst_path = os.path.join(target_dir_images, f"{base_name}.jpg")
-                        
-                        # Save as JPEG with high quality
-                        img.save(dst_path, 'JPEG', quality=95)
+                        image_path = os.path.join(
+                            target_dir_images, f"{base_name}_{video_frame_num:06}.png"
+                        )
+                        cv2.imwrite(image_path, frame)
+                        image_paths.append(image_path)
+                        video_frame_num += 1
+                vs.release()
+                print(
+                    f"Extracted {video_frame_num} frames from video: {os.path.basename(file_path)}"
+                )
+
+            else:
+                # Handle as image
+                # Check if the file is a HEIC image
+                if file_ext in [".heic", ".heif"]:
+                    # Convert HEIC to JPEG for better gallery compatibility
+                    try:
+                        with Image.open(file_path) as img:
+                            # Convert to RGB if necessary (HEIC can have different color modes)
+                            if img.mode not in ("RGB", "L"):
+                                img = img.convert("RGB")
+
+                            # Create JPEG filename
+                            base_name = os.path.splitext(os.path.basename(file_path))[0]
+                            dst_path = os.path.join(
+                                target_dir_images, f"{base_name}.jpg"
+                            )
+
+                            # Save as JPEG with high quality
+                            img.save(dst_path, "JPEG", quality=95)
+                            image_paths.append(dst_path)
+                            print(
+                                f"Converted HEIC to JPEG: {os.path.basename(file_path)} -> {os.path.basename(dst_path)}"
+                            )
+                    except Exception as e:
+                        print(f"Error converting HEIC file {file_path}: {e}")
+                        # Fall back to copying as is
+                        dst_path = os.path.join(
+                            target_dir_images, os.path.basename(file_path)
+                        )
+                        shutil.copy(file_path, dst_path)
                         image_paths.append(dst_path)
-                        print(f"Converted HEIC to JPEG: {os.path.basename(file_path)} -> {os.path.basename(dst_path)}")
-                except Exception as e:
-                    print(f"Error converting HEIC file {file_path}: {e}")
-                    # Fall back to copying as is
-                    dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
+                else:
+                    # Regular image files - copy as is
+                    dst_path = os.path.join(
+                        target_dir_images, os.path.basename(file_path)
+                    )
                     shutil.copy(file_path, dst_path)
                     image_paths.append(dst_path)
-            else:
-                # Regular image files - copy as is
-                dst_path = os.path.join(target_dir_images, os.path.basename(file_path))
-                shutil.copy(file_path, dst_path)
-                image_paths.append(dst_path)
-
-    # --- Handle video ---
-    if input_video is not None:
-        if isinstance(input_video, dict) and "name" in input_video:
-            video_path = input_video["name"]
-        else:
-            video_path = input_video
-
-        vs = cv2.VideoCapture(video_path)
-        fps = vs.get(cv2.CAP_PROP_FPS)
-        frame_interval = int(fps * s_time_interval)  # 1 frame/sec
-
-        count = 0
-        video_frame_num = 0
-        while True:
-            gotit, frame = vs.read()
-            if not gotit:
-                break
-            count += 1
-            if count % frame_interval == 0:
-                image_path = os.path.join(
-                    target_dir_images, f"{video_frame_num:06}.png"
-                )
-                cv2.imwrite(image_path, frame)
-                image_paths.append(image_path)
-                video_frame_num += 1
 
     # Sort final images for gallery
     image_paths = sorted(image_paths)
 
     end_time = time.time()
     print(
-        f"Files copied to {target_dir_images}; took {end_time - start_time:.3f} seconds"
+        f"Files processed to {target_dir_images}; took {end_time - start_time:.3f} seconds"
     )
     return target_dir, image_paths
 
@@ -1058,8 +1082,14 @@ def load_example_scene(scene_name, examples_dir="examples"):
     if selected_scene is None:
         return None, None, None, "Scene not found"
 
-    # Create target directory and copy images
-    target_dir, image_paths = handle_uploads(None, selected_scene["image_files"])
+    # Create file-like objects for the unified upload system
+    # Convert image file paths to the format expected by unified_upload
+    file_objects = []
+    for image_path in selected_scene["image_files"]:
+        file_objects.append(image_path)
+
+    # Create target directory and copy images using the unified upload system
+    target_dir, image_paths = handle_uploads(file_objects, 1.0)
 
     return (
         None,  # Clear reconstruction output
@@ -1089,19 +1119,30 @@ with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
 
     with gr.Row():
         with gr.Column(scale=2):
-            input_video = gr.Video(label="Upload Video", interactive=True)
-            s_time_interval = gr.Slider(
-                minimum=0.1,
-                maximum=5.0,
-                value=1.0,
-                step=0.1,
-                label="Sample time interval (take a sample every x sec.)",
+            # Unified upload component for both videos and images
+            unified_upload = gr.File(
+                file_count="multiple",
+                label="Upload Video or Images",
                 interactive=True,
-                visible=True,
-            )
-            input_images = gr.File(
-                file_count="multiple", label="Upload Images", interactive=True
+                file_types=["image", "video"],
             )
+            with gr.Row():
+                s_time_interval = gr.Slider(
+                    minimum=0.1,
+                    maximum=5.0,
+                    value=1.0,
+                    step=0.1,
+                    label="Video sample time interval (take a sample every x sec.)",
+                    interactive=True,
+                    visible=True,
+                    scale=3,
+                )
+                resample_btn = gr.Button(
+                    "Resample Video",
+                    visible=False,
+                    variant="secondary",
+                    scale=1,
+                )
 
             image_gallery = gr.Gallery(
                 label="Preview",
@@ -1112,6 +1153,13 @@ with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
                 preview=True,
             )
 
+            clear_uploads_btn = gr.ClearButton(
+                [unified_upload, image_gallery],
+                value="Clear Uploads",
+                variant="secondary",
+                size="sm",
+            )
+
         with gr.Column(scale=4):
             with gr.Column():
                 gr.Markdown(
@@ -1202,8 +1250,7 @@ with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
                 submit_btn = gr.Button("Reconstruct", scale=1, variant="primary")
                 clear_btn = gr.ClearButton(
                     [
-                        input_video,
-                        input_images,
+                        unified_upload,
                         reconstruction_output,
                         log_output,
                         target_dir_output,
@@ -1422,15 +1469,130 @@ with gr.Blocks(theme=theme, css=GRADIO_CSS) as demo:
     # -------------------------------------------------------------------------
     # Auto-update gallery whenever user uploads or changes their files
     # -------------------------------------------------------------------------
-    input_video.change(
-        fn=update_gallery_on_upload,
-        inputs=[input_video, input_images, s_time_interval],
-        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+    def update_gallery_on_unified_upload(files, interval):
+        if not files:
+            return None, None, None
+        target_dir, image_paths = handle_uploads(files, interval)
+        return (
+            target_dir,
+            image_paths,
+            "Upload complete. Click 'Reconstruct' to begin 3D processing.",
+        )
+
+    def show_resample_button(files):
+        """Show the resample button only if there are uploaded files containing videos"""
+        if not files:
+            return gr.update(visible=False)
+
+        # Check if any uploaded files are videos
+        video_extensions = [
+            ".mp4",
+            ".avi",
+            ".mov",
+            ".mkv",
+            ".wmv",
+            ".flv",
+            ".webm",
+            ".m4v",
+            ".3gp",
+        ]
+        has_video = False
+
+        for file_data in files:
+            if isinstance(file_data, dict) and "name" in file_data:
+                file_path = file_data["name"]
+            else:
+                file_path = str(file_data)
+
+            file_ext = os.path.splitext(file_path)[1].lower()
+            if file_ext in video_extensions:
+                has_video = True
+                break
+
+        return gr.update(visible=has_video)
+
+    def hide_resample_button():
+        """Hide the resample button after use"""
+        return gr.update(visible=False)
+
+    def resample_video_with_new_interval(files, new_interval, current_target_dir):
+        """Resample video with new slider value"""
+        if not files:
+            return (
+                current_target_dir,
+                None,
+                "No files to resample.",
+                gr.update(visible=False),
+            )
+
+        # Check if we have videos to resample
+        video_extensions = [
+            ".mp4",
+            ".avi",
+            ".mov",
+            ".mkv",
+            ".wmv",
+            ".flv",
+            ".webm",
+            ".m4v",
+            ".3gp",
+        ]
+        has_video = any(
+            os.path.splitext(
+                str(file_data["name"] if isinstance(file_data, dict) else file_data)
+            )[1].lower()
+            in video_extensions
+            for file_data in files
+        )
+
+        if not has_video:
+            return (
+                current_target_dir,
+                None,
+                "No videos found to resample.",
+                gr.update(visible=False),
+            )
+
+        # Clean up old target directory if it exists
+        if (
+            current_target_dir
+            and current_target_dir != "None"
+            and os.path.exists(current_target_dir)
+        ):
+            shutil.rmtree(current_target_dir)
+
+        # Process files with new interval
+        target_dir, image_paths = handle_uploads(files, new_interval)
+
+        return (
+            target_dir,
+            image_paths,
+            f"Video resampled with {new_interval}s interval. Click 'Reconstruct' to begin 3D processing.",
+            gr.update(visible=False),
+        )
+
+    unified_upload.change(
+        fn=update_gallery_on_unified_upload,
+        inputs=[unified_upload, s_time_interval],
+        outputs=[target_dir_output, image_gallery, log_output],
+    ).then(
+        fn=show_resample_button,
+        inputs=[unified_upload],
+        outputs=[resample_btn],
     )
-    input_images.change(
-        fn=update_gallery_on_upload,
-        inputs=[input_video, input_images, s_time_interval],
-        outputs=[reconstruction_output, target_dir_output, image_gallery, log_output],
+
+    # Show resample button when slider changes (only if files are uploaded)
+    s_time_interval.change(
+        fn=show_resample_button,
+        inputs=[unified_upload],
+        outputs=[resample_btn],
+    )
+
+    # Handle resample button click
+    resample_btn.click(
+        fn=resample_video_with_new_interval,
+        inputs=[unified_upload, s_time_interval, target_dir_output],
+        outputs=[target_dir_output, image_gallery, log_output, resample_btn],
     )
 
     # -------------------------------------------------------------------------