Add files via upload

app.py

@@ -0,0 +1,170 @@
+import streamlit as st
+import cv2
+import numpy as np
+from sklearn.cluster import KMeans
+from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
+from tensorflow.keras.preprocessing import image
+import tempfile
+import os
+
+# Function to extract VGG16 features from a frame
+def extract_vgg_features(frame):
+    frame = cv2.resize(frame, (224, 224))
+    img_array = image.img_to_array(frame)
+    img_array = np.expand_dims(img_array, axis=0)
+    img_array = preprocess_input(img_array)
+    features = VGG16(weights="imagenet", include_top=False, pooling="avg").predict(img_array)
+    return features.flatten()
+
+# Function to compute histogram difference
+def histogram_difference(frame1, frame2):
+    hist1 = cv2.calcHist([frame1], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+    hist2 = cv2.calcHist([frame2], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+    hist1 = cv2.normalize(hist1, hist1).flatten()
+    hist2 = cv2.normalize(hist2, hist2).flatten()
+    return cv2.compareHist(hist1, hist2, cv2.HISTCMP_BHATTACHARYYA)
+
+# Function to detect scene changes using histogram comparison
+def detect_scene_changes(video_path, threshold=0.2):
+    cap = cv2.VideoCapture(video_path)
+    prev_frame = None
+    scene_change_frames = []
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        if prev_frame is not None:
+            diff = histogram_difference(prev_frame, frame)
+            if diff > threshold:
+                scene_change_frames.append(frame)
+
+        prev_frame = frame
+
+    cap.release()
+    return scene_change_frames[:5]  # Limit to 20 frames
+
+# Function to select frames based on motion
+def motion_based_selection(video_path, num_frames=5):
+    cap = cv2.VideoCapture(video_path)
+    prev_frame = None
+    motion_scores = []
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        if prev_frame is not None:
+            diff = cv2.absdiff(prev_frame, frame)
+            motion_score = np.mean(diff)
+            motion_scores.append((frame, motion_score))
+
+        prev_frame = frame
+
+    cap.release()
+
+    # Sort frames by motion score and select top frames
+    motion_scores.sort(key=lambda x: x[1], reverse=True)
+    selected_frames = [x[0] for x in motion_scores[:num_frames]]
+    return selected_frames
+
+# Function to cluster frames using VGG16 features
+def cluster_frames(video_path, num_clusters=5):
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+    features = []
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frames.append(frame)
+        feature = extract_vgg_features(frame)
+        features.append(feature)
+
+    cap.release()
+
+    # Perform K-Means clustering
+    kmeans = KMeans(n_clusters=num_clusters, random_state=42)
+    clusters = kmeans.fit_predict(features)
+
+    # Select one frame from each cluster
+    selected_frames = []
+    for cluster_id in range(num_clusters):
+        cluster_indices = np.where(clusters == cluster_id)[0]
+        centroid_index = cluster_indices[0]  # Select the first frame in the cluster
+        selected_frames.append(frames[centroid_index])
+
+    return selected_frames
+
+# Function to convert video to 15 FPS
+def convert_to_15fps(video_path, output_path):
+    cap = cv2.VideoCapture(video_path)
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    # Define the codec and create VideoWriter object
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    out = cv2.VideoWriter(output_path, fourcc, 15, (width, height))
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Write the frame to the output video
+        out.write(frame)
+
+        # Skip frames to achieve 15 FPS
+        for _ in range(int(fps / 15) - 1):
+            cap.read()
+
+    cap.release()
+    out.release()
+
+# Streamlit app
+def main():
+    st.title("Video Frame Selection App")
+    st.write("Upload a 60-second video to extract the best 20 frames using three methods.")
+
+    # Upload video
+    uploaded_file = st.file_uploader("Upload a 60-second video", type=["mp4", "avi", "mov"])
+    if uploaded_file is not None:
+        # Save the uploaded video to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_file:
+            temp_file.write(uploaded_file.getbuffer())
+            temp_video_path = temp_file.name
+
+        # Convert the video to 15 FPS
+        output_video_path = "temp_15fps_video.mp4"
+        convert_to_15fps(temp_video_path, output_video_path)
+
+        # Motion-based selection
+        st.header("Motion-Based Frames")
+        motion_frames = motion_based_selection(output_video_path, num_frames=5)
+        for i, frame in enumerate(motion_frames):
+            st.image(frame, caption=f"Motion Frame {i + 1}", use_column_width=True)
+
+        # Scene change detection
+        st.header("Scene Change-Based Frames")
+        scene_change_frames = detect_scene_changes(output_video_path, threshold=0.2)
+        for i, frame in enumerate(scene_change_frames):
+            st.image(frame, caption=f"Scene Change Frame {i + 1}", use_column_width=True)
+
+        # Clustering-based selection
+        st.header("Clustering-Based Frames")
+        clustered_frames = cluster_frames(output_video_path, num_clusters=5)
+        for i, frame in enumerate(clustered_frames):
+            st.image(frame, caption=f"Clustered Frame {i + 1}", use_column_width=True)
+
+        # Clean up temporary files
+        os.unlink(temp_video_path)
+        os.unlink(output_video_path)
+
+# Run the app
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+streamlit 
+opencv-python 
+numpy 
+scikit-learn 
+tensorflow