Prepare for multiple indices

apb2022.json

@@ -0,0 +1,42 @@
+[
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/algemene-politieke-beschouwingen-1e-termijn-kamer-0",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/0010e470-ce9d-4424-9462-8e8e10efc5af/download-20220921082013Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/mededelingen-1690",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/0010e470-ce9d-4424-9462-8e8e10efc5af/download-20220921133023Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/regeling-van-werkzaamheden-1227",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/0010e470-ce9d-4424-9462-8e8e10efc5af/download-20220921133038Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/algemene-politieke-beschouwingen-voortzetting-1e-termijn-kamer",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/a702d77f-49c5-4a69-a6f7-28e29ae4d1fe/20220921_pz_155828-010143_v2.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/mededelingen-1691",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922081620Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/algemene-politieke-beschouwingen-antwoord-1e-termijn-rest-deel-1",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922081653Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/mededelingen-1692",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922125211Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/regeling-van-werkzaamheden-1228",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922125220Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/algemene-politieke-beschouwingen-antwoord-1e-termijn-rest-deel-2",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922125338Z.mp4"
+    },
+    {
+        "url": "https://debatgemist.tweedekamer.nl/debatten/stemmingen-852",
+        "mp4": "https://amcpwetkms-euwe.streaming.media.azure.net/74c2e164-212d-4eda-a3ef-2dc406eea19b/download-20220922213719Z.mp4"
+    }
+]

app.py

@@ -4,7 +4,7 @@ import gradio as gr
 
 from config import *
 from videomatch import index_hashes_for_video, get_decent_distance, \
-    get_video_indices, compare_videos, get_change_points, get_videomatch_df
+    get_video_index, compare_videos, get_change_points, get_videomatch_df
 from plot import plot_comparison, plot_multi_comparison
 
 logging.basicConfig()
@@ -13,8 +13,9 @@ logging.getLogger().setLevel(logging.INFO)
 
 def get_comparison(url, target, MIN_DISTANCE = 4):
     """ Function for Gradio to combine all helper functions"""
-    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = MIN_DISTANCE)
-    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_indices, MIN_DISTANCE = MIN_DISTANCE)
+    video_index, hash_vectors = get_video_index(url)
+    target_index, _ = get_video_index(target)
+    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_index, MIN_DISTANCE = MIN_DISTANCE)
     fig = plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = MIN_DISTANCE)
     return fig
 
@@ -24,8 +25,9 @@ def get_auto_comparison(url, target, smoothing_window_size=10, method="CUSUM"):
     if distance == None:
         return None
         raise gr.Error("No matches found!")
-    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
-    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_indices, MIN_DISTANCE = distance)
+    video_index, hash_vectors = get_video_index(url)
+    target_index, _ = get_video_index(target)
+    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_index, MIN_DISTANCE = distance)
     # fig = plot_comparison(lims, D, I, hash_vectors, MIN_DISTANCE = distance)
     df = get_videomatch_df(url, target, min_distance=MIN_DISTANCE, vanilla_df=False)
     change_points = get_change_points(df, smoothing_window_size=smoothing_window_size, method=method)
@@ -38,8 +40,9 @@ def get_auto_edit_decision(url, target, smoothing_window_size=10):
     if distance == None:
         return None
         raise gr.Error("No matches found!")
-    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
-    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_indices, MIN_DISTANCE = distance)
+    video_index, hash_vectors = get_video_index(url)
+    target_index, _ = get_video_index(target)
+    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_index, MIN_DISTANCE = distance)
     
     df = get_videomatch_df(url, target, min_distance=MIN_DISTANCE, vanilla_df=False)
     change_points = get_change_points(df, smoothing_window_size=smoothing_window_size, method="ROBUST")

videohash.py

@@ -1,5 +1,6 @@
 import os
 import urllib.request
+import shutil
 import logging
 import hashlib
 
@@ -20,7 +21,7 @@ def download_video_from_url(url):
     filepath = filepath_from_url(url)
     if not os.path.exists(filepath):
         with (urllib.request.urlopen(url)) as f, open(filepath, 'wb') as fileout:
-            fileout.write(f.read())
+            shutil.copyfileobj(f, fileout, length=16*1024)
         logging.info(f"Downloaded video from {url} to {filepath}.")
     else:
         logging.info(f"Skipping downloading from {url} because {filepath} already exists.")

videomatch.py

@@ -38,45 +38,37 @@ def index_hashes_for_video(url: str) -> faiss.IndexBinaryIVF:
     logging.info(f"Indexed hashes for {index.ntotal} frames to {filepath}.index.")
     return index
 
-def get_video_indices(filepath: str, target: str, MIN_DISTANCE: int = 4):
-    """" The comparison between the target and the original video will be plotted based
-    on the matches between the target and the original video over time. The matches are determined
-    based on the minimum distance between hashes (as computed by faiss-vectors) before they're considered a match. 
-    
+def get_video_index(url: str):
+    """" Builds up a FAISS index for a video.
     args: 
-    - url: url of the source video (short video which you want to be checked)
-    - target: url of the target video (longer video which is a superset of the source video)
-    - MIN_DISTANCE: integer representing the minimum distance between hashes on bit-level before its considered a match
+    - filepath: location of the source video
     """
-    # TODO: Fix crash if no matches are found
-
     # Url (short video) 
-    video_index = index_hashes_for_video(filepath)
+    video_index = index_hashes_for_video(url)
     video_index.make_direct_map() # Make sure the index is indexable
     hash_vectors = np.array([video_index.reconstruct(i) for i in range(video_index.ntotal)]) # Retrieve original indices
     
-    # Target video (long video)
-    target_indices = [index_hashes_for_video(x) for x in [target]]
+    return video_index, hash_vectors
 
-    return video_index, hash_vectors, target_indices    
-
-def compare_videos(hash_vectors, target_indices, MIN_DISTANCE = 3):
-    """ Search for matches between the indices of the  target video (long video) 
-    and the given hash vectors of a video"""
+def compare_videos(hash_vectors, target_index, MIN_DISTANCE = 3):
+    """ The comparison between the target and the original video will be plotted based
+    on the matches between the target and the original video over time. The matches are determined
+    based on the minimum distance between hashes (as computed by faiss-vectors) before they're considered a match.
+    """
     # The results are returned as a triplet of 1D arrays 
     # lims, D, I, where result for query i is in I[lims[i]:lims[i+1]] 
     # (indices of neighbors), D[lims[i]:lims[i+1]] (distances).
-    for index in target_indices:
-        lims, D, I = index.range_search(hash_vectors, MIN_DISTANCE)
-        return lims, D, I, hash_vectors
+    lims, D, I = target_index.range_search(hash_vectors, MIN_DISTANCE)
+    return lims, D, I, hash_vectors
 
-def get_decent_distance(url, target, MIN_DISTANCE, MAX_DISTANCE):
+def get_decent_distance(filepath, target, MIN_DISTANCE, MAX_DISTANCE):
     """ To get a decent heurstic for a base distance check every distance from MIN_DISTANCE to MAX_DISTANCE
     until the number of matches found is equal to or higher than the number of frames in the source video"""
     for distance in np.arange(start = MIN_DISTANCE - 2, stop = MAX_DISTANCE + 2, step = 2, dtype=int):
         distance = int(distance)
-        video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
-        lims, D, I, hash_vectors = compare_videos(hash_vectors, target_indices, MIN_DISTANCE = distance)
+        video_index, hash_vectors = get_video_index(filepath)
+        target_index, _ = get_video_index(target)
+        lims, D, I, hash_vectors = compare_videos(hash_vectors, target_index, MIN_DISTANCE = distance)
         nr_source_frames = video_index.ntotal
         nr_matches = len(D)
         logging.info(f"{(nr_matches/nr_source_frames) * 100.0:.1f}% of frames have a match for distance '{distance}' ({nr_matches} matches for {nr_source_frames} frames)")
@@ -103,8 +95,9 @@ def get_change_points(df, smoothing_window_size=10, method='CUSUM'):
 
 def get_videomatch_df(url, target, min_distance=MIN_DISTANCE, vanilla_df=False):
     distance = get_decent_distance(url, target, MIN_DISTANCE, MAX_DISTANCE)
-    video_index, hash_vectors, target_indices = get_video_indices(url, target, MIN_DISTANCE = distance)
-    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_indices, MIN_DISTANCE = distance)
+    _, hash_vectors = get_video_index(url)
+    target_index, _ = get_video_index(target)
+    lims, D, I, hash_vectors = compare_videos(hash_vectors, target_index, MIN_DISTANCE = distance)
 
     target = [(lims[i+1]-lims[i]) * [i] for i in range(hash_vectors.shape[0])]
     target_s = [i/FPS for j in target for i in j]