utilities

compressVideos.py

@@ -0,0 +1,66 @@
+import os
+import subprocess
+import re
+from pathlib import Path
+
+def get_video_dimensions(file_path: str) -> tuple[int, int] | None:
+    """Extract original video width and height from HandBrakeCLI --scan output."""
+    try:
+        # Run HandBrakeCLI --scan and capture stderr (it prints to stderr)
+        result = subprocess.run(
+            ["HandBrakeCLI", "-i", file_path, "--scan"],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            text=True
+        )
+        output = result.stderr + result.stdout
+
+        # Find "+ size: 1920x1080" line
+        match = re.search(r"\+ size:\s*(\d+)x(\d+)", output)
+        if match:
+            width = int(match.group(1))
+            height = int(match.group(2))
+            return width, height
+        else:
+            raise RuntimeError("Could not parse width and height from HandBrakeCLI output.")
+    except Exception as e:
+        print(f"[ERROR] Failed to get dimensions for {file_path}: {e}")
+
+def process_video(file_path: str, qualities=range(40, 11, -2)):
+    """Process a video at multiple quality levels, scaling to 0.25x width."""
+    width,height = get_video_dimensions(file_path)
+    if width is None or height is None:
+        return
+
+    new_width = width // 4
+    new_height = height // 4
+    print(f"Original width = {width}, new width = {new_width}")
+    print(f"Original height = {height}, new width = {new_height}")
+
+    # Ensure output folder exists
+    out_dir = Path("processed")
+    out_dir.mkdir(exist_ok=True)
+
+    base_name = Path(file_path).stem
+    for q in qualities:
+        out_file = out_dir / f"{base_name}_{q}.mp4"
+        print(f"Encoding {file_path} → {out_file} (quality={q})")
+
+        cmd = [
+            "HandBrakeCLI",
+            "-i", file_path,
+            "-o", str(out_file),
+            "-q", str(q),
+            "--width", str(new_width),
+            "--height", str(new_height)
+        ]
+        subprocess.run(cmd, check=True)
+
+def main():
+    # Process all mp4 files in the current directory
+    for file in Path(".").glob("*.mp4"):
+        print(f"\n=== Processing {file} ===")
+        process_video(str(file))
+
+if __name__ == "__main__":
+    main()

copyKeepFrames.py

@@ -0,0 +1,42 @@
+import os
+import json
+import shutil
+
+base_folder = "hq_og"
+output_base = os.path.join("dedup", base_folder)
+
+# Make sure dedup/hq_og exists
+os.makedirs(output_base, exist_ok=True)
+
+# Iterate over JSON filter files in hq_og
+for file in os.listdir(base_folder):
+    if not file.endswith("_filter.json"):
+        continue
+    
+    json_path = os.path.join(base_folder, file)
+
+    with open(json_path, "r") as f:
+        data = json.load(f)  # this is your list of keep_files
+        moviename = data["moviename"]
+        keep_files = data["keep_files"]
+
+    # Extract folder name (before "_filter.json")
+    folder_name = file.replace("_filter.json", "")
+    input_folder = os.path.join(base_folder, folder_name)
+    output_folder = os.path.join(output_base, folder_name)
+
+    os.makedirs(output_folder, exist_ok=True)
+
+    print(f"Processing {folder_name}: copying {len(keep_files)} files")
+
+    for img_name in keep_files:
+        src = os.path.join(input_folder, img_name)
+        dst_name = f"{folder_name}_{img_name}"
+        dst = os.path.join(output_folder, dst_name)
+
+        if os.path.exists(src):
+            shutil.copy2(src, dst)
+        else:
+            print(f"Warning: file not found {src}")
+
+print("Copying complete. Deduplicated dataset saved in /dedup/hq_og/")

copyKeepFramesProcessed.py

@@ -0,0 +1,45 @@
+import os
+import json
+import shutil
+
+base_processed_folder = "processed/lq"
+base_folder = "hq_og"
+processed_folder = "lq"
+output_base = os.path.join("dedup", processed_folder)
+
+# Make sure dedup/hq_og exists
+os.makedirs(output_base, exist_ok=True)
+
+# Iterate over JSON filter files in hq_og
+for file in os.listdir(base_folder):
+    if not file.endswith("_filter.json"):
+        continue
+    
+    json_path = os.path.join(base_folder, file)
+
+    with open(json_path, "r") as f:
+        data = json.load(f)  # this is your list of keep_files
+        moviename = data["moviename"]
+        keep_files = data["keep_files"]
+    qualities = [12,14,16,18,20,22,24,26,28,30,32,34,36,38,40]
+    for quality in qualities:
+        folder_name = moviename + f"_{quality}"
+
+        input_folder = os.path.join(base_processed_folder, folder_name)
+        output_folder = os.path.join(output_base, folder_name)
+
+        os.makedirs(output_folder, exist_ok=True)
+
+        print(f"Processing {folder_name}: copying {len(keep_files)} files")
+
+        for img_name in keep_files:
+            src = os.path.join(input_folder, img_name)
+            dst_name = f"{folder_name}_{img_name}"
+            dst = os.path.join(output_folder, dst_name)
+
+            if os.path.exists(src):
+                shutil.copy2(src, dst)
+            else:
+                print(f"Warning: file not found {src}")
+
+print("Copying complete. Deduplicated dataset saved in /dedup/hq_og/")

cut.py

@@ -0,0 +1,54 @@
+import subprocess
+import sys
+import shlex
+
+def get_duration(input_file):
+    """Get video duration (in seconds) using ffprobe."""
+    result = subprocess.run(
+        [
+            "ffprobe",
+            "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            input_file,
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    return float(result.stdout.strip())
+
+def cut_video(input_file, output_file, skip_start, skip_end):
+    """Cut video: skip first skip_start seconds, drop last skip_end seconds."""
+    duration = get_duration(input_file)
+    if duration <= (skip_start + skip_end):
+        raise ValueError("Video too short for given cut parameters.")
+
+    # Compute new duration
+    new_duration = duration - skip_start - skip_end
+
+    # Run ffmpeg with stream copy
+    cmd = [
+        "ffmpeg",
+        "-y",              # overwrite output
+        "-ss", str(skip_start),
+        "-i", input_file,
+        "-t", str(new_duration),
+        "-c", "copy",
+        output_file
+    ]
+    print("Running:", " ".join(shlex.quote(c) for c in cmd))
+    subprocess.run(cmd, check=True)
+    print(f"Trimmed video saved to {output_file}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 5:
+        print("Usage: python cut_video.py input.mp4 output.mp4 skip_start_seconds skip_end_seconds")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2]
+    skip_start = int(sys.argv[3])
+    skip_end = int(sys.argv[4])
+
+    cut_video(input_file, output_file, skip_start, skip_end)

encode.py

@@ -0,0 +1,66 @@
+import os
+import subprocess
+import re
+from pathlib import Path
+
+def get_video_dimensions(file_path: str) -> tuple[int, int] | None:
+    """Extract original video width and height from HandBrakeCLI --scan output."""
+    try:
+        # Run HandBrakeCLI --scan and capture stderr (it prints to stderr)
+        result = subprocess.run(
+            ["HandBrakeCLI", "-i", file_path, "--scan"],
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            text=True
+        )
+        output = result.stderr + result.stdout
+
+        # Find "+ size: 1920x1080" line
+        match = re.search(r"\+ size:\s*(\d+)x(\d+)", output)
+        if match:
+            width = int(match.group(1))
+            height = int(match.group(2))
+            return width, height
+        else:
+            raise RuntimeError("Could not parse width and height from HandBrakeCLI output.")
+    except Exception as e:
+        print(f"[ERROR] Failed to get dimensions for {file_path}: {e}")
+
+def process_video(file_path: str, qualities=range(40, 11, -2)):
+    """Process a video at multiple quality levels, scaling to 0.25x width."""
+    width,height = get_video_dimensions(file_path)
+    if width is None or height is None:
+        return
+
+    new_width = width // 4
+    new_height = height // 4
+    print(f"Original width = {width}, new width = {new_width}")
+    print(f"Original height = {height}, new width = {new_height}")
+
+    # Ensure output folder exists
+    out_dir = Path("processed")
+    out_dir.mkdir(exist_ok=True)
+
+    base_name = Path(file_path).stem
+    for q in qualities:
+        out_file = out_dir / f"{base_name}_{q}.mp4"
+        print(f"Encoding {file_path} → {out_file} (quality={q})")
+
+        cmd = [
+            "HandBrakeCLI",
+            "-i", file_path,
+            "-o", str(out_file),
+            "-q", str(q),
+            "--width", str(new_width),
+            "--height", str(new_height)
+        ]
+        subprocess.run(cmd, check=True)
+
+def main():
+    # Process all mp4 files in the current directory
+    for file in Path(".").glob("*.mp4"):
+        print(f"\n=== Processing {file} ===")
+        process_video(str(file))
+
+if __name__ == "__main__":
+    main()

generateDuplicateMeta.py

@@ -0,0 +1,79 @@
+import os
+import json
+from PIL import Image
+import imagehash
+
+base_folder = "hq_og"
+HASH_SIZE = 16
+SIMILARITY_THRESHOLD = HASH_SIZE*HASH_SIZE * 0.2
+
+# Function to compute average hash of an image
+def get_image_hash(image_path):
+    try:
+        with Image.open(image_path) as img:
+            return imagehash.average_hash(img, hash_size=HASH_SIZE)
+    except Exception as e:
+        print(f"Error hashing {image_path}: {e}")
+        return None
+
+# Iterate over all subfolders in hq_og
+for folder in os.listdir(base_folder):
+    index=0
+    folder_path = os.path.join(base_folder, folder)
+    if not os.path.isdir(folder_path):
+        continue
+    
+    print(f"Processing folder: {folder_path}")
+
+    hashes = {}
+    removed_files = []
+    keep_files = []
+    keep_files2 = []
+
+    for filename in os.listdir(folder_path):
+        file_path = os.path.join(folder_path, filename)
+        if not os.path.isfile(file_path):
+            continue
+        index+=1
+        if index%100==0:
+            print(f"At {index} image")
+            print("Discard Rate:", len(removed_files)/index)
+
+        file_hash = get_image_hash(file_path)
+        if file_hash is None:
+            continue
+        
+        # Check against already kept images
+        is_duplicate = False
+        for h, kept_file in keep_files:
+            if file_hash - h <= SIMILARITY_THRESHOLD:
+                # This image is too similar to one we already kept
+                #os.remove(file_path)
+                removed_files.append(filename)
+                is_duplicate = True
+                break
+
+        if not is_duplicate:
+            keep_files.append((file_hash, filename))
+            keep_files2.append( filename)
+            
+        
+        '''
+        if file_hash in hashes:
+            # Duplicate found, remove it
+            #os.remove(file_path)
+            removed_files.append(filename)
+        else:
+            hashes[file_hash] = filename
+            keep_files.append(filename)
+        '''
+
+    # Save removed files list to JSON
+    if removed_files:
+        out = {"moviename":folder,"removed_files":removed_files,"keep_files":keep_files2}
+        json_path = os.path.join(base_folder, folder+"_filter.json")
+        with open(json_path, "w") as f:
+            json.dump(out, f, indent=4)
+        print(f"Keep {len(keep_files2)} Removed {len(removed_files)} duplicate files in {folder}")
+
+print("Duplicate removal complete.")

toImageHQ.py

@@ -0,0 +1,34 @@
+import os
+import subprocess
+
+# Folder to save extracted frames
+output_base = "hq_og"
+
+# Create the base output folder if it doesn't exist
+os.makedirs(output_base, exist_ok=True)
+
+# List all video files in the current directory
+video_extensions = [".mp4", ".mov", ".avi", ".mkv", ".flv"]
+videos = [f for f in os.listdir(".") if os.path.splitext(f)[1].lower() in video_extensions]
+
+for video in videos:
+    video_name = os.path.splitext(video)[0]
+    output_folder = os.path.join(output_base, video_name)
+    os.makedirs(output_folder, exist_ok=True)
+
+    # FFmpeg command to extract frames as high-quality WebP
+    cmd = [
+        "ffmpeg",
+        "-i", video,
+        "-vf", "fps=25",           # extract 25 frames per second
+        "-vcodec", "libwebp",      # use WebP encoder
+        "-lossless", "0",          # 0 = lossy, 1 = lossless
+        "-q:v", "90",              # quality (0 best, 100 worst)
+        "-compression_level", "2", # compression level (0–6)
+        os.path.join(output_folder, "frame_%05d.webp")
+    ]
+
+    print(f"Processing {video} -> {output_folder}")
+    subprocess.run(cmd, check=True)
+
+print("All videos processed!")