update src

algorithm.py

@@ -32,7 +32,7 @@ def offline(number_of_clusters, features):
 
     return closest_clips_frames
 
-def online(features, threshold):
+def online(features, threshold, ratio):
 
     i = 0
     previous = i
@@ -48,7 +48,7 @@ def online(features, threshold):
                 clip.append(b)
 
             # randomly select 15% of the frames from the clip list
-            random_num = round(len(clip)*0.15)
+            random_num = round(len(clip)*ratio/100)
             # sort the frames in the clip list to ensure the order of the frames
             random_Frames = sorted(random.sample(clip, random_num))
             i = j
@@ -61,13 +61,13 @@ def online(features, threshold):
     if i==j:
         for c in range(j*8, j*8+8):
             clip.append(c)
-            random_num = round(len(clip)*0.15)
+            random_num = round(len(clip)*ratio/100)
             random_Frames = sorted(random.sample(clip, random_num))
 
     else: # (i<j)
         for c in range(i*8, (j+1)*8):
             clip.append(c)
-            random_num = round(len(clip)*0.15)
+            random_num = round(len(clip)*ratio/100)
             random_Frames = sorted(random.sample(clip, random_num))
 
     clips.extend(random_Frames)

app.py

@@ -5,11 +5,23 @@ import tempfile
 import numpy as np
 from utils import *
 from algorithm import *
+import time
 
-def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMeans)'):
+def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMeans)', ratio=15, threshold_type='Average'):
     if algorithm not in ["Offline (KMeans)", "Online (Sum of Squared Difference)"]:
         algorithm = "Offline (KMeans)"
     
+    if threshold_type not in ["Small", "Average", "Large"]:
+        threshold_type = "Average"
+    
+    if threshold_type == "Small":
+        threshold = 100
+    elif threshold_type == "Average":
+        threshold = 400
+    else:
+        threshold = 800
+
+
     # nen them vao cac truong hop mo hinh khac
     model, processor, device = load_model()
 
@@ -32,10 +44,15 @@ def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMea
         
         raw_video = cv2.VideoCapture(filename)
         frame_rate = int(raw_video.get(cv2.CAP_PROP_FPS))
+        frame_count = int(raw_video.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration_seconds = frame_count / frame_rate
+        width = int(raw_video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(raw_video.get(cv2.CAP_PROP_FRAME_HEIGHT))
         #length = int(raw_video.get(cv2.CAP_PROP_FRAME_COUNT))
-
+        start_time = time.time()
         filename = os.path.basename(filename)
-
+        in_width = width
+        in_height = height
         # Find the size to resize
         if "shortest_edge" in processor.size:
             height = width = processor.size["shortest_edge"]
@@ -90,7 +107,7 @@ def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMea
             batch_features = np.array(batch_features.cpu().detach().numpy())
             features.extend(batch_features)
 
-        number_of_clusters = round(len(features)*0.15)
+        number_of_clusters = round(len(features)*ratio/100)
 
         print("Total of frames: ", len(final_key_frames))
         print("Shape of each frame: ", frames[0].shape)
@@ -101,7 +118,7 @@ def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMea
         if algorithm == "Offline (KMeans)":
             selected_frames = offline(number_of_clusters, features)
         else:
-            selected_frames = online(features, 400)
+            selected_frames = online(features, threshold, ratio)
 
         print("Selected frame: ", selected_frames)
         
@@ -110,10 +127,16 @@ def make_video(video_path, outdir='./summarized_video', algorithm='Offline (KMea
             video_writer.write(frames[idx])
             # video_writer.write(original_frames[idx]) if you want to write the original frames
         
+        out_duration_seconds = len(selected_frames) / frame_rate
+        out_width = frames[0].shape[1]
+        out_height = frames[0].shape[0]
+
         raw_video.release()
         video_writer.release()
         print("Completed summarizing the video (wait for a moment to load).")
-        return output_path
+        end_time = time.time()
+        process_time = round(end_time - start_time, 2)
+        return output_path, duration_seconds, frame_rate, f"{in_width} x {in_height}", process_time, out_duration_seconds, frame_rate, f"{out_width} x {out_height}"
 
 css = """
 #img-display-container {
@@ -127,31 +150,48 @@ css = """
     }
 """
 
-title = "# Video Summarization Demo"
-description = """Video Summarization using Timesformer.
+_HEADER_ = '''
+<h2><b>Video summarization 🤗 Gradio Demo</b></h2><h2><a href='https://github.com/youneedyourself/Video-Summarization_Timesformer target='_blank'><b>Video Summarization Using Timesformer Modal and K-means, SSD</b></a></h2>
 
+Code: <a href='https://github.com/youneedyourself/Video-Summarization_Timesformer' target='_blank'>GitHub</a>.
 Author: Nguyen Hoai Nam.
-"""
+'''
 
 with gr.Blocks(css=css) as demo:
-    gr.Markdown(title)
-    gr.Markdown(description)
-    gr.Markdown("### Video Summarization demo")
+    gr.Markdown(_HEADER_)
 
     with gr.Row():
-        input_video = gr.Video(label="Input Video")
-        algorithm_type = gr.Dropdown(["Offline (KMeans)", "Online (Sum of Squared Difference)"], type="value", label='Algorithm')
+        with gr.Column():
+            input_video = gr.Video(label="Input Video (Required Duration > 5s)")
+        with gr.Column():
+            # Thêm thông tin về video
+            algorithm_type = gr.Dropdown(["Offline (KMeans)", "Online (Sum of Squared Difference)"], type="value", label='Algorithm')
+            ratio = gr.Slider(15, 80, label="Summarization Ratio (%) (Recommend: 15)")
+            threshold = gr.Dropdown(["Small", "Average", "Large"], type="value", label='Difference Threshold for Online Algorithm (Recommend: Average)')
+            submit = gr.Button("Summarize")
+    with gr.Row():      
+        processed_video = gr.Video(label="Summarized Video")
+        with gr.Column():
+            input_video_duration = gr.Text(label="Input Video Duration (s)")
+            input_video_FPS = gr.Text(label="Input Video FPS")
+            input_video_resolution = gr.Text(label="Input Video Resolution")
+        
+        time_process = gr.Text(label="Time Process (s)")
 
-    submit = gr.Button("Submit")
-    processed_video = gr.Video(label="Summarized Video")
+        with gr.Column():
+            output_video_duration = gr.Text(label="Output Video Duration (s)")
+            output_video_FPS = gr.Text(label="Output Video FPS")
+            output_video_resolution = gr.Text(label="Output Video Resolution")
 
-    def on_submit(uploaded_video, algorithm_type):
-        print("Algorithm: ", algorithm_type)
+    def on_submit(uploaded_video, algorithm_type, ratio, threshold):
+        print("Ratio:", ratio)
+        print("Algorithm:", algorithm_type)
+        print("Threshold:", threshold)
         # Process the video and get the path of the output video
-        output_video_path = make_video(uploaded_video, algorithm=algorithm_type)
+        output_video_path = make_video(uploaded_video, algorithm=algorithm_type, ratio=ratio, threshold_type=threshold)
         return output_video_path
 
-    submit.click(on_submit, inputs=[input_video, algorithm_type], outputs=processed_video)
+    submit.click(on_submit, inputs=[input_video, algorithm_type, ratio, threshold], outputs=[processed_video, input_video_duration, input_video_FPS, input_video_resolution, time_process, output_video_duration, output_video_FPS, output_video_resolution])
 
 if __name__ == '__main__':
     demo.queue().launch(share=True)