simba-uw-tf-dev 4.7.2__py3-none-any.whl → 4.7.5__py3-none-any.whl

simba/roi_tools/roi_utils.py

@@ -17,8 +17,8 @@ from PIL import ImageTk
 from scipy.spatial.distance import cdist
 from shapely.geometry import Polygon
 
-from simba.utils.checks import (check_file_exist_and_readable, check_instance,
-                                check_int, check_str, check_valid_array,
+from simba.utils.checks import (check_file_exist_and_readable, check_int,
+                                check_str, check_valid_array,
                                 check_valid_dataframe, check_valid_tuple,
                                 check_video_and_data_frm_count_align)
 from simba.utils.enums import (ROI_SETTINGS, ConfigKey, Formats, Keys, Options,

simba/sandbox/convert_h264_to_mp4_lossless.py

@@ -0,0 +1,129 @@
+"""
+Convert .h264 files to lossless MP4 format using FFmpeg.
+
+This script converts H.264 raw video files to MP4 container format using
+lossless encoding (copy codec) to preserve quality.
+"""
+import os
+import subprocess
+import glob
+from pathlib import Path
+from typing import List, Union
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def convert_h264_to_mp4_lossless(input_path: Union[str, Path], 
+                                  output_path: Union[str, Path] = None) -> bool:
+    """
+    Convert a single .h264 file to lossless MP4.
+    
+    :param Union[str, Path] input_path: Path to input .h264 file
+    :param Union[str, Path] output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    :return: True if conversion successful, False otherwise
+    """
+    input_path = Path(input_path)
+    
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path}")
+        return False
+    
+    # FFmpeg command for lossless conversion (copy codec, no re-encoding)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -movflags +faststart: Optimize for web streaming (optional)
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',  # Overwrite output file if exists
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}: {e.stderr}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def convert_all_h264_files(directory: str, 
+                           pattern: str = None) -> None:
+    """
+    Convert all .h264 files in a directory to MP4.
+    
+    :param str directory: Directory containing .h264 files
+    :param str pattern: Optional pattern to match in filename (e.g., '4.03.001_6_2026_01_16_09_15_00_000')
+    """
+    dir_path = Path(directory)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Find all .h264 files
+    h264_files = list(dir_path.glob('*.h264'))
+    
+    if pattern:
+        h264_files = [f for f in h264_files if pattern in f.name]
+    
+    if not h264_files:
+        pattern_msg = f" matching pattern '{pattern}'" if pattern else ""
+        print(f"No .h264 files found{pattern_msg} in {directory}")
+        return
+    
+    print(f"Found {len(h264_files)} .h264 file(s) to convert...")
+    
+    successful = 0
+    failed = 0
+    
+    for h264_file in sorted(h264_files):
+        if convert_h264_to_mp4_lossless(h264_file):
+            successful += 1
+        else:
+            failed += 1
+    
+    print(f"\nConversion complete!")
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Total: {len(h264_files)}")
+
+if __name__ == "__main__":
+    # Convert all .h264 files in the directory
+    directory = r"E:\lp_videos_tar"
+    pattern = None  # Convert all .h264 files, not just matching a pattern
+    
+    convert_all_h264_files(directory, pattern=pattern)

simba/sandbox/extract_and_convert_videos.py

@@ -0,0 +1,257 @@
+"""
+Extract tar files and convert all videos to lossless MP4 format.
+
+This script:
+1. Extracts all .tar, .tar.gz, and .tgz files in a directory
+2. Finds all video files (various formats)
+3. Converts them to lossless MP4 using FFmpeg stream copy
+"""
+import os
+import tarfile
+import glob
+import subprocess
+from pathlib import Path
+from typing import List, Set
+
+# Common video file extensions
+VIDEO_EXTENSIONS = {'.h264', '.avi', '.mov', '.mkv', '.flv', '.m4v', '.mp4', 
+                    '.webm', '.wmv', '.mpg', '.mpeg', '.ts', '.mts', '.m2ts'}
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def extract_tar_files(directory_path: str, output_dir: str = None) -> List[Path]:
+    """
+    Extracts all .tar, .tar.gz, and .tgz files in a given directory.
+
+    Args:
+        directory_path (str): The path to the directory containing the tar files.
+        output_dir (str, optional): The directory where to extract the contents.
+                                    If None, extracts to the same directory as the tar file.
+                                    Defaults to None.
+    Returns:
+        List[Path]: List of directories where files were extracted
+    """
+    if output_dir is None:
+        output_dir = directory_path
+    
+    dir_path = Path(directory_path)
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    tar_files = []
+    for ext in ['*.tar', '*.tar.gz', '*.tgz']:
+        tar_files.extend(dir_path.glob(ext))
+
+    if not tar_files:
+        print(f"No tar file(s) found in {directory_path}")
+        return []
+
+    print(f"Found {len(tar_files)} tar file(s) to extract...")
+
+    extracted_dirs = []
+    for tar_file_path in tar_files:
+        tar_file = Path(tar_file_path)
+        print(f"Extracting {tar_file.name}...")
+        try:
+            # Extract to a subdirectory named after the tar file (without extension)
+            extract_dir = output_path / tar_file.stem
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            
+            with tarfile.open(tar_file_path, 'r:*') as f:
+                if hasattr(tarfile, 'data_filter'):  # Python 3.12+
+                    f.extractall(path=extract_dir, filter='data')
+                else:
+                    f.extractall(path=extract_dir)
+            print(f"  [OK] Extracted {tar_file.name} to {extract_dir}")
+            extracted_dirs.append(extract_dir)
+        except tarfile.ReadError as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e} (Not a valid tar file or corrupted)")
+        except Exception as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e}")
+    
+    print("\nExtraction complete!")
+    return extracted_dirs
+
+def find_video_files(directory: Path, recursive: bool = True) -> List[Path]:
+    """
+    Find all video files in a directory.
+    
+    Args:
+        directory: Directory to search
+        recursive: If True, search recursively in subdirectories
+    
+    Returns:
+        List of video file paths
+    """
+    video_files = []
+    
+    if recursive:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.rglob(f'*{ext}'))
+    else:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.glob(f'*{ext}'))
+    
+    return sorted(video_files)
+
+def convert_video_to_mp4_lossless(input_path: Path, output_path: Path = None) -> bool:
+    """
+    Convert a video file to lossless MP4 using FFmpeg stream copy.
+    
+    Args:
+        input_path: Path to input video file
+        output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    
+    Returns:
+        True if conversion successful, False otherwise
+    """
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    # Skip if already MP4
+    if input_path.suffix.lower() == '.mp4':
+        print(f"[SKIP] File is already MP4: {input_path.name}")
+        return False
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path.name}")
+        return False
+    
+    # FFmpeg command for lossless conversion (stream copy)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -y: Overwrite output file if exists
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}")
+        # Print first few lines of stderr for debugging
+        stderr_lines = e.stderr.split('\n')[:5]
+        for line in stderr_lines:
+            if line.strip():
+                print(f"    {line}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def extract_and_convert_videos(directory_path: str, 
+                               extract_to_subdirs: bool = True,
+                               convert_recursive: bool = True) -> None:
+    """
+    Extract all tar files and convert all videos to lossless MP4.
+    
+    Args:
+        directory_path: Directory containing tar files
+        extract_to_subdirs: If True, extract each tar to its own subdirectory
+        convert_recursive: If True, search for videos recursively in extracted directories
+    """
+    dir_path = Path(directory_path)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory_path}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Step 1: Extract tar files
+    print("=" * 60)
+    print("STEP 1: Extracting tar files...")
+    print("=" * 60)
+    extracted_dirs = extract_tar_files(directory_path, 
+                                       output_dir=directory_path if extract_to_subdirs else None)
+    
+    # Step 2: Find all video files
+    print("\n" + "=" * 60)
+    print("STEP 2: Finding video files...")
+    print("=" * 60)
+    
+    # Search in extracted directories and the main directory
+    search_dirs = extracted_dirs if extracted_dirs else [dir_path]
+    all_video_files = []
+    
+    for search_dir in search_dirs:
+        videos = find_video_files(search_dir, recursive=convert_recursive)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {search_dir}")
+    
+    # Also search in main directory if we extracted to subdirs
+    if extract_to_subdirs and dir_path not in search_dirs:
+        videos = find_video_files(dir_path, recursive=False)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {dir_path}")
+    
+    if not all_video_files:
+        print("No video files found to convert.")
+        return
+    
+    print(f"\nTotal video files found: {len(all_video_files)}")
+    
+    # Step 3: Convert videos to MP4
+    print("\n" + "=" * 60)
+    print("STEP 3: Converting videos to lossless MP4...")
+    print("=" * 60)
+    
+    successful = 0
+    failed = 0
+    skipped = 0
+    
+    for video_file in all_video_files:
+        result = convert_video_to_mp4_lossless(video_file)
+        if result is True:
+            successful += 1
+        elif result is False and video_file.suffix.lower() == '.mp4':
+            skipped += 1
+        else:
+            failed += 1
+    
+    print("\n" + "=" * 60)
+    print("Conversion complete!")
+    print("=" * 60)
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Skipped (already MP4): {skipped}")
+    print(f"  Total: {len(all_video_files)}")
+
+if __name__ == "__main__":
+    target_directory = r"E:\new_tars"
+    extract_and_convert_videos(target_directory, 
+                               extract_to_subdirs=True,
+                               convert_recursive=True)

simba/sandbox/remove_end_of_video.py

@@ -0,0 +1,80 @@
+"""
+Function to remove N seconds from the end of a video file.
+
+Similar to simba.video_processors.video_processing.remove_beginning_of_video
+but removes from the end instead of the beginning.
+"""
+
+import os
+import subprocess
+from typing import Union, Optional
+
+from simba.utils.checks import (
+    check_ffmpeg_available,
+    check_file_exist_and_readable,
+    check_int,
+    check_if_dir_exists,
+    check_nvidea_gpu_available
+)
+from simba.utils.errors import FFMPEGCodecGPUError, InvalidInputError
+from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.read_write import get_fn_ext, get_video_meta_data
+from simba.utils.lookups import quality_pct_to_crf
+
+
+def remove_end_of_video(file_path: Union[str, os.PathLike],
+                       time: int,
+                       quality: int = 60,
+                       save_path: Optional[Union[str, os.PathLike]] = None,
+                       gpu: Optional[bool] = False) -> None:
+    """
+    Remove N seconds from the end of a video file.
+
+    :param Union[str, os.PathLike] file_path: Path to video file
+    :param int time: Number of seconds to remove from the end of the video.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the shortened video. If None, then the new video is saved in the same directory as the input video with the ``_shortened`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_shorten.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+
+    :example:
+    >>> _ = remove_end_of_video(file_path='project_folder/videos/Video_1.avi', time=10)
+    >>> remove_end_of_video(file_path=f'/Users/simon/Desktop/imgs_4/test/blahhhh.mp4', save_path='/Users/simon/Desktop/imgs_4/test/CUT.mp4', time=3)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(msg="No GPU found (as evaluated by nvidea-smi returning None)", source=remove_end_of_video.__name__)
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    video_meta_data = get_video_meta_data(video_path=file_path)
+    check_int(name="Cut time", value=time, min_value=1)
+    check_int(name=f'{remove_end_of_video.__name__} quality', value=quality, min_value=1, max_value=100, raise_error=True)
+    quality_crf = quality_pct_to_crf(pct=int(quality))
+    time = int(time)
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    if video_meta_data['video_length_s'] <= time:
+        raise InvalidInputError(msg=f"The cut time {time}s is invalid for video {file_name} with length {video_meta_data['video_length_s']}s", source=remove_end_of_video.__name__)
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_shorten.mp4")
+    else:
+        check_if_dir_exists(in_dir=os.path.dirname(save_path), source=f'{remove_end_of_video.__name__} save_path', create_if_not_exist=True)
+        save_name = save_path
+    duration = video_meta_data['video_length_s'] - time
+    if gpu:
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -t {duration} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        cmd = f'ffmpeg -i "{file_path}" -t {duration} -c:v libx264 -crf {quality_crf} -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
+    print(f"Removing final {time}s from {file_name}... ")
+    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
+    timer.stop_timer()
+    stdout_success(msg=f"SIMBA COMPLETE: Video converted! {save_name} generated!", elapsed_time=timer.elapsed_time_str, source=remove_end_of_video.__name__)
+
+
+if __name__ == "__main__":
+    # Example usage
+    # remove_end_of_video(file_path='path/to/video.mp4', time=10)
+    pass