Add application files

README.md

@@ -4,7 +4,7 @@ emoji: 📊
 colorFrom: yellow
 colorTo: red
 sdk: gradio
-sdk_version: 3.29.0
+sdk_version: 3.32.0
 app_file: app.py
 pinned: false
 license: apache-2.0

app.py

@@ -0,0 +1,225 @@
+import gradio as gr
+import os
+import glob
+import validators
+from config import *
+from download_video import download_video
+from bg_modeling import capture_slides_bg_modeling
+from frame_differencing import capture_slides_frame_diff
+from post_process import remove_duplicates
+from utils import create_output_directory, convert_slides_to_pdf
+
+
+def process(
+    video_path,
+    bg_type,
+    frame_buffer_history,
+    hash_size,
+    hash_func,
+    hash_queue_len,
+    sim_threshold,
+):
+    output_dir_path = "output_results"
+    output_dir_path = create_output_directory(video_path, output_dir_path, bg_type)
+
+    if bg_type.lower() == "Frame Diff":
+        capture_slides_frame_diff(video_path, output_dir_path)
+    else:
+        if bg_type.lower() == "gmg":
+            thresh = DEC_THRESH
+        elif bg_type.lower() == "knn":
+            thresh = DIST_THRESH
+
+        capture_slides_bg_modeling(
+            video_path,
+            output_dir_path,
+            type_bgsub=bg_type,
+            history=frame_buffer_history,
+            threshold=thresh,
+            MIN_PERCENT_THRESH=MIN_PERCENT,
+            MAX_PERCENT_THRESH=MAX_PERCENT,
+        )
+
+    # Perform post-processing using difference hashing technique to remove duplicate slides.
+    hash_func = HASH_FUNC_DICT.get(hash_func.lower())
+
+    diff_threshold = int(hash_size * hash_size * (100 - sim_threshold) / 100)
+    remove_duplicates(
+        output_dir_path, hash_size, hash_func, hash_queue_len, diff_threshold
+    )
+
+    pdf_path = convert_slides_to_pdf(video_path, output_dir_path)
+
+    # Remove unneccessary files
+    os.remove(video_path)
+    for image_path in glob.glob(f"{output_dir_path}/*.jpg"):
+        os.remove(image_path)
+    return pdf_path
+
+
+def process_file(
+    file_obj,
+    bg_type,
+    frame_buffer_history,
+    hash_size,
+    hash_func,
+    hash_queue_len,
+    sim_threshold,
+):
+    return process(
+        file_obj.name,
+        bg_type,
+        frame_buffer_history,
+        hash_size,
+        hash_func,
+        hash_queue_len,
+        sim_threshold,
+    )
+
+
+def process_via_url(
+    url,
+    bg_type,
+    frame_buffer_history,
+    hash_size,
+    hash_func,
+    hash_queue_len,
+    sim_threshold,
+):
+    if validators.url(url):
+        video_path = download_video(url)
+        if video_path is None:
+            raise gr.Error("Please enter a valid video URL")
+        return process(
+            video_path,
+            bg_type,
+            frame_buffer_history,
+            hash_size,
+            hash_func,
+            hash_queue_len,
+            sim_threshold,
+        )
+    else:
+        raise gr.Error("Please enter a valid video URL")
+
+
+with gr.Blocks(css="style.css") as demo:
+    with gr.Row(elem_classes=["container"]):
+        gr.Markdown(
+            """
+        # Video 2 Slides Converter
+        
+        Convert your video presentation into PDF slides with one click.
+
+        You can browse your video from the local file system, or enter a video URL/YouTube video link to start processing.
+
+        **Note**: 
+        - It will take a bit of time to complete (~40% of the original video length), so stay tuned!
+        - Remember to press Enter if you are using an external URL
+        """,
+            elem_id="container",
+        )
+
+    with gr.Row(elem_classes=["container"]):
+        with gr.Column(scale=1):
+            with gr.Accordion("Advanced parameters"):
+                bg_type = gr.Dropdown(
+                    ["Frame Diff", "GMG", "KNN"],
+                    value="GMG",
+                    label="Background subtraction",
+                    info="Type of background subtraction to be used",
+                )
+                frame_buffer_history = gr.Slider(
+                    minimum=5,
+                    maximum=20,
+                    value=FRAME_BUFFER_HISTORY,
+                    step=5,
+                    label="Frame buffer history",
+                    info="Length of the frame buffer history to model background.",
+                )
+                # Post process
+                hash_func = gr.Dropdown(
+                    ["Difference hashing", "Perceptual hashing", "Average hashing"],
+                    value="Difference hashing",
+                    label="Background subtraction",
+                    info="Hash function to use for image hashing",
+                )
+                hash_size = gr.Slider(
+                    minimum=8,
+                    maximum=16,
+                    value=HASH_SIZE,
+                    step=2,
+                    label="Hash size",
+                    info="Hash size to use for image hashing",
+                )
+                hash_queue_len = gr.Slider(
+                    minimum=5,
+                    maximum=15,
+                    value=HASH_BUFFER_HISTORY,
+                    step=5,
+                    label="Hash queue len",
+                    info="Number of history images used to find out duplicate image",
+                )
+                sim_threshold = gr.Slider(
+                    minimum=90,
+                    maximum=100,
+                    value=SIM_THRESHOLD,
+                    step=1,
+                    label="Similarity threshold",
+                    info="Minimum similarity threshold (in percent) to consider 2 images to be similar",
+                )
+
+        with gr.Column(scale=2):
+            with gr.Row(elem_id="row-flex"):
+                with gr.Column(scale=3):
+                    file_url = gr.Textbox(
+                        value="",
+                        label="Upload your file",
+                        placeholder="Enter a video url or YouTube link",
+                        show_label=False,
+                    )
+                with gr.Column(scale=1, min_width=160):
+                    upload_button = gr.UploadButton("Browse File", file_types=["video"])
+            file_output = gr.File(file_types=[".pdf"], label="Output PDF")
+            gr.Examples(
+                [
+                    [
+                        "https://www.youtube.com/watch?v=bfmFfD2RIcg",
+                        "output_results/Neural Network In 5 Minutes.pdf",
+                    ],
+                    [
+                        "https://www.youtube.com/watch?v=EEo10bgsh0k",
+                        "output_results/react-in-5-minutes.pdf",
+                    ],
+                ],
+                [file_url, file_output],
+            )
+
+    file_url.submit(
+        process_via_url,
+        [
+            file_url,
+            bg_type,
+            frame_buffer_history,
+            hash_size,
+            hash_func,
+            hash_queue_len,
+            sim_threshold,
+        ],
+        file_output,
+    )
+    upload_button.upload(
+        process_file,
+        [
+            upload_button,
+            bg_type,
+            frame_buffer_history,
+            hash_size,
+            hash_func,
+            hash_queue_len,
+            sim_threshold,
+        ],
+        file_output,
+    )
+
+demo.queue(concurrency_count=4).launch()

bg_modeling.py

@@ -0,0 +1,86 @@
+import os
+import time
+import sys
+import cv2
+from utils import resize_image_frame
+
+
+def capture_slides_bg_modeling(
+    video_path,
+    output_dir_path,
+    type_bgsub,
+    history,
+    threshold,
+    MIN_PERCENT_THRESH,
+    MAX_PERCENT_THRESH,
+):
+    print(f"Using {type_bgsub} for Background Modeling...")
+    print("---" * 10)
+
+    if type_bgsub == "GMG":
+        bg_sub = cv2.bgsegm.createBackgroundSubtractorGMG(
+            initializationFrames=history, decisionThreshold=threshold
+        )
+    elif type_bgsub == "KNN":
+        bg_sub = cv2.createBackgroundSubtractorKNN(
+            history=history, dist2Threshold=threshold, detectShadows=False
+        )
+    else:
+        raise ValueError("Please choose GMG or KNN as background subtraction method")
+
+    capture_frame = False
+    screenshots_count = 0
+
+    # Capture video frames.
+    cap = cv2.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        print("Unable to open video file: ", video_path)
+        sys.exit()
+
+    start = time.time()
+    # Loop over subsequent frames.
+    while cap.isOpened():
+        ret, frame = cap.read()
+
+        if not ret:
+            break
+
+        # Create a copy of the original frame.
+        orig_frame = frame.copy()
+        # Resize the frame keeping aspect ratio.
+        frame = resize_image_frame(frame, resize_width=640)
+
+        # Apply each frame through the background subtractor.
+        fg_mask = bg_sub.apply(frame)
+
+        # Compute the percentage of the Foreground mask."
+        p_non_zero = (cv2.countNonZero(fg_mask) / (1.0 * fg_mask.size)) * 100
+
+        # %age of non-zero pixels < MAX_PERCENT_THRESH, implies motion has stopped.
+        # Therefore, capture the frame.
+        if p_non_zero < MAX_PERCENT_THRESH and not capture_frame:
+            capture_frame = True
+
+            screenshots_count += 1
+
+            png_filename = f"{screenshots_count:03}.jpg"
+            out_file_path = os.path.join(output_dir_path, png_filename)
+            print(f"Saving file at: {out_file_path}")
+            cv2.imwrite(out_file_path, orig_frame, [cv2.IMWRITE_JPEG_QUALITY, 75])
+
+        # p_non_zero >= MIN_PERCENT_THRESH, indicates motion/animations.
+        # Hence wait till the motion across subsequent frames has settled down.
+        elif capture_frame and p_non_zero >= MIN_PERCENT_THRESH:
+            capture_frame = False
+
+    end_time = time.time()
+    print("***" * 10, "\n")
+    print("Statistics:")
+    print("---" * 10)
+    print(f"Total Time taken: {round(end_time-start, 3)} secs")
+    print(f"Total Screenshots captured: {screenshots_count}")
+    print("---" * 10, "\n")
+
+    # Release Video Capture object.
+    cap.release()

config.py

@@ -0,0 +1,41 @@
+import imagehash
+
+# -------------- Initializations ---------------------
+
+DOWNLOAD_DIR = "downloads"
+
+FRAME_BUFFER_HISTORY = 15  # Length of the frame buffer history to model background.
+DEC_THRESH = (
+    0.75  # Threshold value, above which it is marked foreground, else background.
+)
+DIST_THRESH = 100  # Threshold on the squared distance between the pixel and the sample to decide whether a pixel is close to that sample.
+
+MIN_PERCENT = (
+    0.15  # %age threshold to check if there is motion across subsequent frames
+)
+MAX_PERCENT = (
+    0.01  # %age threshold to determine if the motion across frames has stopped.
+)
+
+# Post processing
+
+SIM_THRESHOLD = (
+    96  # Minimum similarity threshold (in percent) to consider 2 images to be similar
+)
+
+HASH_SIZE = 12  # Hash size to use for image hashing
+
+HASH_FUNC = "dhash"  # Hash function to use for image hashing
+
+HASH_BUFFER_HISTORY = 5  # Number of history images used to find out duplicate image
+
+HASH_FUNC_DICT = {
+    "dhash": imagehash.dhash,
+    "phash": imagehash.phash,
+    "ahash": imagehash.average_hash,
+    "difference hashing": imagehash.dhash,
+    "perceptual hashing": imagehash.phash,
+    "average hashing": imagehash.average_hash,
+}
+
+# ----------------------------------------------------

download_video.py

@@ -0,0 +1,81 @@
+import mimetypes
+import tempfile
+import requests
+import os
+from urllib.parse import urlparse
+from pytube import YouTube
+from config import DOWNLOAD_DIR
+
+
+def download_video_from_url(url, output_dir=DOWNLOAD_DIR):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Check if the request was successful
+
+        content_type = response.headers.get("content-type")
+        if "video" not in content_type:
+            print("The given URL is not a valid video")
+            return None
+        file_extension = mimetypes.guess_extension(content_type)
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        temp_file = tempfile.NamedTemporaryFile(
+            delete=False, suffix=file_extension, dir=output_dir
+        )
+        temp_file_path = temp_file.name
+
+        with open(temp_file_path, "wb") as file:
+            file.write(response.content)
+        return temp_file_path
+
+    except requests.exceptions.RequestException as e:
+        print("An error occurred while downloading the video:", str(e))
+        return None
+
+
+def download_video_from_youtube(url, output_dir=DOWNLOAD_DIR):
+    try:
+        yt = YouTube(url)
+        video = (
+            yt.streams.filter(progressive=True, file_extension="mp4")
+            .order_by("resolution")
+            .desc()
+            .first()
+        )
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        video_path = video.download(output_dir)
+        return video_path
+
+    except Exception as e:
+        print("An error occurred while downloading the video:", str(e))
+        return None
+
+
+def download_video(url, output_dir=DOWNLOAD_DIR):
+    parsed_url = urlparse(url)
+    domain = parsed_url.netloc.lower()
+
+    print("---" * 5, "Downloading video file", "---" * 5)
+
+    if "youtube" in domain:
+        video_path = download_video_from_youtube(url, output_dir)
+    else:
+        video_path = download_video_from_url(url, output_dir)
+
+    if video_path:
+        print(f"Saving file at: {video_path}")
+        print("---" * 10)
+    return video_path
+
+
+if __name__ == "__main__":
+    youtube_link = "https://www.youtube.com/watch?v=2OTq15A5s0Y"
+    temp_video_path = download_video_from_youtube(youtube_link)
+
+    if temp_video_path is not None:
+        print("Video downloaded successfully to:", temp_video_path)
+    else:
+        print("Failed to download the video.")

frame_differencing.py

@@ -0,0 +1,97 @@
+import cv2
+import os
+import time
+import sys
+
+
+def capture_slides_frame_diff(
+    video_path, output_dir_path, MIN_PERCENT_THRESH=0.06, ELAPSED_FRAME_THRESH=85
+):
+    prev_frame = None
+    curr_frame = None
+    screenshots_count = 0
+    capture_frame = False
+    frame_elapsed = 0
+
+    # Initialize kernel.
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
+
+    # Capture video frames
+    cap = cv2.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        print("Unable to open video file: ", video_path)
+        sys.exit()
+
+    success, first_frame = cap.read()
+
+    print("Using frame differencing for Background Subtraction...")
+    print("---" * 10)
+
+    start = time.time()
+
+    # The 1st frame should always be present in the output directory.
+    # Hence capture and save the 1st frame.
+    if success:
+        # Convert frame to grayscale.
+        first_frame_gray = cv2.cvtColor(first_frame, cv2.COLOR_BGR2GRAY)
+
+        prev_frame = first_frame_gray
+
+        screenshots_count += 1
+
+        filename = f"{screenshots_count:03}.lpg"
+        out_file_path = os.path.join(output_dir_path, filename)
+        print(f"Saving file at: {out_file_path}")
+
+        # Save frame.
+        cv2.imwrite(out_file_path, first_frame, [cv2.IMWRITE_JPEG_QUALITY, 75])
+
+    # Loop over subsequent frames.
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        curr_frame = frame_gray
+
+        if (prev_frame is not None) and (curr_frame is not None):
+            frame_diff = cv2.absdiff(curr_frame, prev_frame)
+            _, frame_diff = cv2.threshold(frame_diff, 80, 255, cv2.THRESH_BINARY)
+
+            # Perform dilation to capture motion.
+            frame_diff = cv2.dilate(frame_diff, kernel)
+
+            # Compute the percentage of non-zero pixels in the frame.
+            p_non_zero = (cv2.countNonZero(frame_diff) / (1.0 * frame_gray.size)) * 100
+
+            if p_non_zero >= MIN_PERCENT_THRESH and not capture_frame:
+                capture_frame = True
+
+            elif capture_frame:
+                frame_elapsed += 1
+
+            if frame_elapsed >= ELAPSED_FRAME_THRESH:
+                capture_frame = False
+                frame_elapsed = 0
+
+                screenshots_count += 1
+
+                filename = f"{screenshots_count:03}.png"
+                out_file_path = os.path.join(output_dir_path, filename)
+                print(f"Saving file at: {out_file_path}")
+
+                cv2.imwrite(out_file_path, frame)
+
+        prev_frame = curr_frame
+
+    end_time = time.time()
+    print("***" * 10, "\n")
+    print("Statistics:")
+    print("---" * 5)
+    print(f"Total Time taken: {round(end_time-start, 3)} secs")
+    print(f"Total Screenshots captured: {screenshots_count}")
+    print("---" * 10, "\n")
+
+    cap.release()

output_results/Neural Network In 5 Minutes.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe8c6f4fc132de07cc528f6fff4021fd084a07b17858f1b294e7726109dac89a
+size 3656629

output_results/react-in-5-minutes.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dee28ec7ce33a50b70553540af6ea4329226785fe1fc9da1f14acf13bf0417d2
+size 371324

post_process.py

@@ -0,0 +1,77 @@
+import imagehash
+import os
+from collections import deque
+from PIL import Image
+
+
+def find_similar_images(
+    base_dir, hash_size=8, hashfunc=imagehash.dhash, queue_len=5, threshold=4
+):
+    snapshots_files = sorted(os.listdir(base_dir))
+
+    hash_dict = {}
+    hash_queue = deque([], maxlen=queue_len)
+    duplicates = []
+    num_duplicates = 0
+
+    print("---" * 5, "Finding similar files", "---" * 5)
+
+    for file in snapshots_files:
+        read_file = Image.open(os.path.join(base_dir, file))
+        comp_hash = hashfunc(read_file, hash_size=hash_size)
+        duplicate = False
+
+        if comp_hash not in hash_dict:
+            hash_dict[comp_hash] = file
+            # Compare with hash queue to find out potential duplicates
+            for img_hash in hash_queue:
+                if img_hash - comp_hash <= threshold:
+                    duplicate = True
+                    break
+
+            if not duplicate:
+                hash_queue.append(comp_hash)
+        else:
+            duplicate = True
+
+        if duplicate:
+            print("Duplicate file: ", file)
+            duplicates.append(file)
+            num_duplicates += 1
+
+    print("\nTotal duplicate files:", num_duplicates)
+    print("-----" * 10)
+    return hash_dict, duplicates
+
+
+def remove_duplicates(
+    base_dir, hash_size=8, hashfunc=imagehash.dhash, queue_len=5, threshold=4
+):
+    _, duplicates = find_similar_images(
+        base_dir,
+        hash_size=hash_size,
+        hashfunc=hashfunc,
+        queue_len=queue_len,
+        threshold=threshold,
+    )
+
+    if not len(duplicates):
+        print("No duplicates found!")
+    else:
+        print("Removing duplicates...")
+
+        for dup_file in duplicates:
+            file_path = os.path.join(base_dir, dup_file)
+
+            if os.path.exists(file_path):
+                os.remove(file_path)
+            else:
+                print("Filepath: ", file_path, "does not exists.")
+
+        print("All duplicates removed!")
+
+    print("***" * 10, "\n")
+
+
+if __name__ == "__main__":
+    remove_duplicates("sample_1")

requirements.txt

@@ -0,0 +1,10 @@
+opencv-contrib-python==4.7.0.72
+numpy
+Pillow
+scipy
+six
+ImageHash
+img2pdf
+pytube
+validators
+requests

style.css

@@ -0,0 +1,25 @@
+.container {
+  max-width: 1200px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+#row-flex {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+a,
+a:hover,
+a:visited {
+  text-decoration-line: underline;
+  font-weight: 600;
+  color: #1f2937 !important;
+}
+
+.dark a,
+.dark a:hover,
+.dark a:visited {
+  color: #f3f4f6 !important;
+}

utils.py

@@ -0,0 +1,53 @@
+import os
+import cv2
+import shutil
+import img2pdf
+import glob
+
+# PIL can also be used to convert the image set into PDFs.
+# However, using PIL requires opening each of the images in the set.
+# Hence img2pdf package was used, which is able to convert the entire image set into a PDF
+# without opening at once.
+
+
+def resize_image_frame(frame, resize_width):
+    ht, wd, _ = frame.shape
+    new_height = resize_width * ht / wd
+    frame = cv2.resize(
+        frame, (resize_width, int(new_height)), interpolation=cv2.INTER_AREA
+    )
+
+    return frame
+
+
+def create_output_directory(video_path, output_path, type_bgsub):
+    vid_file_name = video_path.rsplit(os.sep)[-1].split(".")[0]
+    output_dir_path = os.path.join(output_path, vid_file_name, type_bgsub)
+
+    # Remove the output directory if there is already one.
+    if os.path.exists(output_dir_path):
+        shutil.rmtree(output_dir_path)
+
+    # Create output directory.
+    os.makedirs(output_dir_path, exist_ok=True)
+    print("Output directory created...")
+    print("Path:", output_dir_path)
+    print("***" * 10, "\n")
+
+    return output_dir_path
+
+
+def convert_slides_to_pdf(video_path, output_path):
+    pdf_file_name = video_path.rsplit(os.sep)[-1].split(".")[0] + ".pdf"
+    output_pdf_path = os.path.join(output_path, pdf_file_name)
+
+    print("Output PDF Path:", output_pdf_path)
+    print("Converting captured slide images to PDF...")
+
+    with open(output_pdf_path, "wb") as f:
+        f.write(img2pdf.convert(sorted(glob.glob(f"{output_path}/*.jpg"))))
+
+    print("PDF Created!")
+    print("***" * 10, "\n")
+
+    return output_pdf_path

video_2_slides.py

@@ -0,0 +1,134 @@
+import argparse
+import os
+import validators
+from config import *
+from download_video import download_video
+from bg_modeling import capture_slides_bg_modeling
+from frame_differencing import capture_slides_frame_diff
+from post_process import remove_duplicates
+from utils import create_output_directory, convert_slides_to_pdf
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This script is used to convert video frames into slide PDFs."
+    )
+    parser.add_argument(
+        "-v", "--video_path", help="Path to the video file, video url, or YouTube video link", type=str
+    )
+    parser.add_argument(
+        "-o",
+        "--out_dir",
+        default="output_results",
+        help="Path to the output directory",
+        type=str,
+    )
+    parser.add_argument(
+        "--type",
+        help="type of background subtraction to be used",
+        default="GMG",
+        choices=["Frame_Diff", "GMG", "KNN"],
+        type=str,
+    )
+    parser.add_argument(
+        "-hf",
+        "--hash-func",
+        help="Hash function to use for image hashing. Only effective if post-processing is enabled",
+        default=HASH_FUNC,
+        choices=["dhash", "phash", "ahash"],
+        type=str,
+    )
+    parser.add_argument(
+        "-hs",
+        "--hash-size",
+        help="Hash size to use for image hashing. Only effective if post-processing is enabled",
+        default=HASH_SIZE,
+        choices=[8, 12, 16],
+        type=int,
+    )
+    parser.add_argument(
+        "--threshold",
+        help="Minimum similarity threshold (in percent) to consider 2 images to be similar. Only effective if post-processing is enabled",
+        default=SIM_THRESHOLD,
+        choices=range(90, 101),
+        type=int,
+    )
+    parser.add_argument(
+        "-q",
+        "--queue-len",
+        help="Number of history images used to find out duplicate image. Only effective if post-processing is enabled",
+        default=HASH_BUFFER_HISTORY,
+        type=int,
+    )
+    parser.add_argument(
+        "--no_post_process",
+        action="store_true",
+        default=False,
+        help="flag to apply post processing or not",
+    )
+    parser.add_argument(
+        "--convert_to_pdf",
+        action="store_true",
+        default=False,
+        help="flag to convert the entire image set to pdf or not",
+    )
+    args = parser.parse_args()
+
+    queue_len = args.queue_len
+    if queue_len <= 0:
+        print(
+            f"Warnings: queue_len argument must be positive. Fallback to {HASH_BUFFER_HISTORY}"
+        )
+        queue_len = HASH_BUFFER_HISTORY
+
+    video_path = args.video_file_path
+    output_dir_path = args.out_dir
+    type_bg_sub = args.type
+    temp_file = False
+
+    if validators.url(video_path):
+        video_path = download_video(video_path)
+        temp_file = True
+        if video_path is None:
+            exit(1)
+    elif not os.path.exists(video_path):
+        raise ValueError(
+            "The video doesn't exist or isn't a valid URL. Please check your video path again"
+        )
+
+    output_dir_path = create_output_directory(video_path, output_dir_path, type_bg_sub)
+
+    if type_bg_sub.lower() == "frame_diff":
+        capture_slides_frame_diff(video_path, output_dir_path)
+    else:
+        if type_bg_sub.lower() == "gmg":
+            thresh = DEC_THRESH
+        elif type_bg_sub.lower() == "knn":
+            thresh = DIST_THRESH
+
+        capture_slides_bg_modeling(
+            video_path,
+            output_dir_path,
+            type_bgsub=type_bg_sub,
+            history=FRAME_BUFFER_HISTORY,
+            threshold=thresh,
+            MIN_PERCENT_THRESH=MIN_PERCENT,
+            MAX_PERCENT_THRESH=MAX_PERCENT,
+        )
+
+    # Perform post-processing using difference hashing technique to remove duplicate slides.
+    if not args.no_post_process:
+        hash_size = args.hash_size
+        hash_func = HASH_FUNC_DICT.get(args.hash_func)
+        sim_threshold = args.threshold
+
+        diff_threshold = int(hash_size * hash_size * (100 - sim_threshold) / 100)
+        remove_duplicates(
+            output_dir_path, hash_size, hash_func, queue_len, diff_threshold
+        )
+
+    if args.convert_to_pdf:
+        convert_slides_to_pdf(video_path, output_dir_path)
+
+    # if temp_file:
+    #     os.remove(video_path)