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

simba/assets/lookups/yolo_schematics/yolo_mitra.csv

@@ -6,4 +6,4 @@ right_side
 tail_base
 center
 tail_center
-tail_tip
+tail_tip

simba/model/yolo_fit.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from contextlib import redirect_stderr, redirect_stdout
 
 os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
 import argparse
@@ -21,7 +22,8 @@ from simba.utils.checks import (check_file_exist_and_readable,
                                 check_valid_boolean, check_valid_device)
 from simba.utils.enums import Options
 from simba.utils.errors import SimBAGPUError, SimBAPAckageVersionError
-from simba.utils.read_write import find_core_cnt
+from simba.utils.printing import stdout_information
+from simba.utils.read_write import find_core_cnt, get_current_time
 from simba.utils.yolo import load_yolo_model
 
 
@@ -108,20 +110,25 @@ class FitYolo():
 
 
     def run(self):
-        model = load_yolo_model(weights_path=self.weights_path,
-                                verbose=self.verbose,
-                                format=self.format,
-                                device=self.device)
-
-        model.train(data=self.model_yaml,
-                    epochs=self.epochs,
-                    project=self.save_path,
-                    batch=self.batch,
-                    plots=self.plots,
-                    imgsz=self.imgsz,
-                    workers=self.workers,
-                    device=self.device,
-                    patience=self.patience)
+        # Temporarily redirect stdout/stderr to terminal to ensure ultralytics output goes to terminal
+        # sys.__stdout__ and sys.__stderr__ are the original terminal streams
+        stdout_information(msg=f'[{get_current_time()}] Please follow the YOLO pose model training in the terminal from where SimBA was launched ...', source=self.__class__.__name__)
+        stdout_information(msg=f'[{get_current_time()}] Results will be stored in the {self.save_path} directory ..', source=self.__class__.__name__)
+        with redirect_stdout(sys.__stdout__), redirect_stderr(sys.__stderr__):
+            model = load_yolo_model(weights_path=self.weights_path,
+                                    verbose=self.verbose,
+                                    format=self.format,
+                                    device=self.device)
+
+            model.train(data=self.model_yaml,
+                        epochs=self.epochs,
+                        project=self.save_path,
+                        batch=self.batch,
+                        plots=self.plots,
+                        imgsz=self.imgsz,
+                        workers=self.workers,
+                        device=self.device,
+                        patience=self.patience)
 
 
 if __name__ == "__main__" and not hasattr(sys, 'ps1'):

simba/model/yolo_pose_inference.py

@@ -34,7 +34,7 @@ from simba.utils.errors import (CountError, InvalidFilepathError,
                                 InvalidFileTypeError, SimBAGPUError,
                                 SimBAPAckageVersionError)
 from simba.utils.lookups import get_current_time
-from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_video_meta_data, recursive_file_search)
 from simba.utils.warnings import FileExistWarning, NoDataFoundWarning
@@ -182,7 +182,12 @@ class YOLOPoseInference():
         results = {}
         class_dict = self.model.names
         timer = SimbaTimer(start=True)
-        print(f'Starting tracking inference for {len(self.video_path)} video(s) ({get_current_time()})... ')
+        if self.save_dir is not None:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s). Results will be saved in {self.save_dir} ... '
+        else:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s) ... '
+        stdout_information(msg=msg, source=self.__class__.__name__)
+        stdout_information(msg='Follow progress in OS terminal window ...', source=self.__class__.__name__)
         for video_cnt, path in enumerate(self.video_path):
             video_timer = SimbaTimer(start=True)
             _, video_name, _ = get_fn_ext(filepath=path)

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/ui/pop_ups/run_machine_models_popup.py

@@ -8,8 +8,8 @@ from simba.mixins.config_reader import ConfigReader
 from simba.mixins.pop_up_mixin import PopUpMixin
 from simba.model.inference_batch import InferenceBatch
 from simba.ui.tkinter_functions import (CreateLabelFrameWithIcon, Entry_Box,
-                                        FileSelect, SimbaButton, SimBASeperator,
-                                        SimBALabel)
+                                        FileSelect, SimbaButton, SimBALabel,
+                                        SimBASeperator)
 from simba.utils.checks import (check_file_exist_and_readable, check_float,
                                 check_int)
 from simba.utils.enums import ConfigKey, Dtypes, Formats, Keys, Links

simba/utils/lookups.py

@@ -1201,4 +1201,70 @@ def check_for_updates(time_out: int = 2):
     else:
         msg = (f'NEW SimBA VERSION AVAILABLE. \nYou have SimBA version {env_simba_version}. \nThe latest version is {latest_simba_version}. '
                f'\nYou can update using "pip install simba-uw-tf-dev --upgrade"')
-    stdout_information(msg=msg, source=check_for_updates.__name__)
+    stdout_information(msg=msg, source=check_for_updates.__name__)
+
+
+def get_ext_codec_map() -> Dict[str, str]:
+    """
+    Get a dictionary mapping video file extensions to their recommended FFmpeg codecs.
+    Automatically falls back to alternative codecs if the preferred codec is not available.
+
+    :return: Dictionary mapping file extensions (without leading dot) to codec names.
+    :rtype: Dict[str, str]
+
+    :example:
+    >>> codec_map = get_ext_codec_map()
+    >>> codec = codec_map.get('webm', 'libx264')  # Returns 'libvpx-vp9' or fallback
+    """
+    codecs_available = get_ffmpeg_encoders(raise_error=False)
+    if not codecs_available: codecs_available = []
+
+    common_codecs = ['libx264', 'mpeg4', 'h264', 'mjpeg', 'libx265']
+    fallback_codec = None
+    for codec in common_codecs:
+        if codec in codecs_available:
+            fallback_codec = codec
+            break
+
+    # If no common codec found, use first available or default to mpeg4 (most universal)
+    if fallback_codec is None:
+        fallback_codec = codecs_available[0] if codecs_available else 'mpeg4'
+    
+    def get_codec(preferred: str, alternative: str = None) -> str:
+        if preferred in codecs_available:
+            return preferred
+        alt = alternative if alternative else fallback_codec
+        return alt if alt in codecs_available else preferred
+    
+    return {
+        'webm': get_codec(preferred='libvpx-vp9', alternative='libvpx'),
+        'avi': get_codec(preferred='mpeg4', alternative='libx264'),
+        'mp4': get_codec(preferred='libx264', alternative='mpeg4'),
+        'mov': get_codec(preferred='libx264', alternative='mpeg4'),
+        'mkv': get_codec(preferred='libx264', alternative='mpeg4'),
+        'flv': get_codec(preferred='libx264', alternative='mpeg4'),
+        'm4v': get_codec(preferred='libx264', alternative='mpeg4'),
+        'h264': get_codec(preferred='libx264', alternative='h264'),
+    }
+
+def get_ffmpeg_codec(file_name: Union[str, os.PathLike],
+                     fallback: str = 'mpeg4') -> str:
+    """
+    Get the recommended FFmpeg codec for a video file based on its extension.
+
+    :param Union[str, os.PathLike] file_name: Path to video file or file extension.
+    :param str fallback: Codec to return if file extension is not recognized. Default: 'mpeg4'.
+    :return: Recommended FFmpeg codec name for the video file.
+    :rtype: str
+
+    :example:
+    >>> codec = get_ffmpeg_codec(file_name='video.mp4')
+    >>> codec = get_ffmpeg_codec(file_name='video.webm', fallback='libx264')
+    >>> codec = get_ffmpeg_codec(file_name=r'C:/videos/my_video.avi')
+    """
+    codec_map = get_ext_codec_map()
+    _, file_name, ext = get_fn_ext(filepath=file_name)
+    if ext[1:] in codec_map.keys():
+        return codec_map[ext[1:]]
+    else:
+        return fallback