modif

app.py

@@ -0,0 +1,275 @@
+import os
+import gradio as gr
+import random
+import json
+import itertools
+from pathlib import Path
+
+# List of methods that already have results
+EXISTING_METHODS = ["Liveportrait", "ControlTalk", "Lia", "Hallo2", "Echomimic", "Dimitra", "Sadtalker", "Wav2Lip"]
+
+# List of new methods to compare
+NEW_METHODS = ["First-Order-Motion", "X-Portrait", "MCNET", "EMOPortrait", "DaGAN", "LIA-X", "OmniAvatar", "Real3DPortrait"]
+
+# Number of videos per new method to compare
+VIDEOS_PER_NEW_METHOD = 23
+
+# File to save results
+RESULTS_FILE = "comparison_results.json"
+
+def find_videos_by_method(base_dir):
+    """Find all videos in the method folders."""
+    videos_by_method = {}
+    
+    # Check each method directory
+    for method in EXISTING_METHODS + NEW_METHODS:
+        method_dir = os.path.join(base_dir, method)
+        if not os.path.exists(method_dir):
+            continue
+        
+        videos = []
+        # Walk through the directory structure to find all video files
+        for root, _, files in os.walk(method_dir):
+            for file in files:
+                if file.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
+                    videos.append(os.path.join(root, file))
+        
+        if videos:
+            videos_by_method[method] = videos
+    
+    return videos_by_method
+
+def generate_comparison_pairs(videos_by_method):
+    """Generate pairs of videos between new methods and existing methods."""
+    pairs = []
+    
+    for new_method in NEW_METHODS:
+        if new_method not in videos_by_method:
+            continue
+        
+        for existing_method in EXISTING_METHODS:
+            if existing_method not in videos_by_method:
+                continue
+            
+            # Get video basenames to match videos across methods
+            new_method_videos = {os.path.basename(v): v for v in videos_by_method[new_method]}
+            existing_method_videos = {os.path.basename(v): v for v in videos_by_method[existing_method]}
+            
+            # Find common videos between the two methods
+            common_videos = set(new_method_videos.keys()) & set(existing_method_videos.keys())
+            
+            for video_name in common_videos:
+                new_video = new_method_videos[video_name]
+                existing_video = existing_method_videos[video_name]
+                
+                # Randomly order the videos (left/right)
+                if random.choice([True, False]):
+                    pairs.append({
+                        'left_video': new_video,
+                        'right_video': existing_video,
+                        'left_method': new_method,
+                        'right_method': existing_method,
+                        'video_name': video_name
+                    })
+                else:
+                    pairs.append({
+                        'left_video': existing_video,
+                        'right_video': new_video,
+                        'left_method': existing_method,
+                        'right_method': new_method,
+                        'video_name': video_name
+                    })
+    
+    # Shuffle pairs for unbiased comparison
+    random.shuffle(pairs)
+    return pairs
+
+def load_results():
+    """Load existing comparison results."""
+    if os.path.exists(RESULTS_FILE):
+        try:
+            with open(RESULTS_FILE, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            pass
+    return {"comparisons": [], "count": 0}
+
+def save_result(results, comparison_data):
+    """Save the comparison result."""
+    results["comparisons"].append(comparison_data)
+    results["count"] += 1
+    
+    with open(RESULTS_FILE, 'w') as f:
+        json.dump(results, f, indent=4)
+    
+    return results
+
+def get_total_expected_comparisons():
+    """Calculate the total number of comparisons needed."""
+    return len(NEW_METHODS) * VIDEOS_PER_NEW_METHOD
+
+def create_app(videos_dir):
+    """Create the Gradio app for video comparison."""
+    # Load existing results if any
+    results = load_results()
+    
+    # Find videos in the directory structure
+    videos_by_method = find_videos_by_method(videos_dir)
+    
+    # Generate pairs for comparison
+    all_pairs = generate_comparison_pairs(videos_by_method)
+    
+    # Calculate the total expected comparisons
+    total_expected = get_total_expected_comparisons()
+    
+    # Track the current state
+    state = {
+        "current_pair_index": 0,
+        "results": results,
+        "all_pairs": all_pairs,
+        "total_expected": total_expected
+    }
+    
+    def update_ui_state(state):
+        """Update the UI based on current state."""
+        if state["results"]["count"] >= state["total_expected"]:
+            return {
+                "left_video": None,
+                "right_video": None,
+                "status": f"Completed all {state['total_expected']} comparisons!",
+                "left_button_visible": False,
+                "right_button_visible": False,
+                "done_visible": True,
+                "progress": 100
+            }
+        
+        if state["current_pair_index"] >= len(state["all_pairs"]):
+            return {
+                "left_video": None,
+                "right_video": None,
+                "status": "No more pairs to compare, but target count not reached.",
+                "left_button_visible": False,
+                "right_button_visible": False,
+                "done_visible": True,
+                "progress": (state["results"]["count"] / state["total_expected"]) * 100
+            }
+        
+        current_pair = state["all_pairs"][state["current_pair_index"]]
+        progress_percent = (state["results"]["count"] / state["total_expected"]) * 100
+        
+        return {
+            "left_video": current_pair["left_video"],
+            "right_video": current_pair["right_video"],
+            "status": f"Compare videos: {state['results']['count']}/{state['total_expected']} completed ({progress_percent:.1f}%)",
+            "left_button_visible": True,
+            "right_button_visible": True,
+            "done_visible": False,
+            "progress": progress_percent
+        }
+    
+    def handle_choice(choice, state):
+        """Handle user's choice between videos."""
+        if state["results"]["count"] >= state["total_expected"]:
+            return state, update_ui_state(state)
+        
+        if state["current_pair_index"] < len(state["all_pairs"]):
+            current_pair = state["all_pairs"][state["current_pair_index"]]
+            
+            # Record the comparison result
+            comparison_data = {
+                "video_name": current_pair["video_name"],
+                "choice": choice,
+                "left_method": current_pair["left_method"],
+                "right_method": current_pair["right_method"],
+                "timestamp": str(import_datetime().now())
+            }
+            
+            # Update results
+            state["results"] = save_result(state["results"], comparison_data)
+            state["current_pair_index"] += 1
+        
+        return state, update_ui_state(state)
+    
+    def import_datetime():
+        """Import datetime module on demand."""
+        import datetime
+        return datetime
+    
+    with gr.Blocks() as demo:
+        gr.Markdown("# Video Comparison App")
+        gr.Markdown("Compare the quality of videos generated by different methods")
+        
+        # State components
+        state_data = gr.State(state)
+        
+        # Display components
+        with gr.Row():
+            with gr.Column():
+                left_video = gr.Video(label="Video A")
+                left_button = gr.Button("Choose Video A", variant="primary")
+            with gr.Column():
+                right_video = gr.Video(label="Video B")
+                right_button = gr.Button("Choose Video B", variant="primary")
+        
+        progress_bar = gr.Progress()
+        status_text = gr.Markdown("")
+        done_text = gr.Markdown("All comparisons completed! Thank you for your participation.", visible=False)
+        
+        # Initialize UI with first pair
+        ui_state = update_ui_state(state)
+        left_video.value = ui_state["left_video"]
+        right_video.value = ui_state["right_video"]
+        status_text.value = ui_state["status"]
+        left_button.visible = ui_state["left_button_visible"]
+        right_button.visible = ui_state["right_button_visible"]
+        done_text.visible = ui_state["done_visible"]
+        
+        # Button click handlers
+        def handle_left_click(state_data):
+            new_state, ui_state = handle_choice("left", state_data)
+            return [
+                new_state,
+                ui_state["left_video"],
+                ui_state["right_video"],
+                ui_state["status"],
+                ui_state["left_button_visible"],
+                ui_state["right_button_visible"],
+                ui_state["done_visible"],
+                ui_state["progress"]
+            ]
+        
+        def handle_right_click(state_data):
+            new_state, ui_state = handle_choice("right", state_data)
+            return [
+                new_state,
+                ui_state["left_video"],
+                ui_state["right_video"],
+                ui_state["status"],
+                ui_state["left_button_visible"],
+                ui_state["right_button_visible"],
+                ui_state["done_visible"],
+                ui_state["progress"]
+            ]
+        
+        left_button.click(
+            handle_left_click,
+            inputs=[state_data],
+            outputs=[state_data, left_video, right_video, status_text, left_button, right_button, done_text, progress_bar]
+        )
+        
+        right_button.click(
+            handle_right_click,
+            inputs=[state_data],
+            outputs=[state_data, left_video, right_video, status_text, left_button, right_button, done_text, progress_bar]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    # Set the directory containing the method folders
+    videos_directory = input("Enter the directory containing the method folders: ").strip()
+    if not videos_directory:
+        videos_directory = "."  # Default to current directory
+    
+    app = create_app(videos_directory)
+    app.launch()