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

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

simba/sandbox/video_timelaps.py

@@ -0,0 +1,291 @@
+from typing import Union, Optional, Tuple
+import os
+from simba.mixins.image_mixin import ImageMixin
+import cv2
+import numpy as np
+from simba.utils.checks import check_file_exist_and_readable, check_int, check_valid_boolean
+from simba.utils.read_write import get_video_meta_data, seconds_to_timestamp, read_frm_of_video
+from simba.utils.lookups import get_fonts
+from simba.utils.enums import Formats
+from simba.ui.tkinter_functions import SimBAScaleBar, SimBALabel
+from tkinter import *
+from PIL import Image, ImageDraw, ImageFont, ImageTk
+
+class TimelapseSlider():
+    """
+    Interactive timelapse viewer with segment selection sliders.
+
+    Creates a Tkinter GUI window displaying a timelapse composite image generated from evenly-spaced frames
+    across a video. Includes interactive sliders to select start and end times for video segments, with
+    visual highlighting of the selected segment and frame previews.
+
+    :param Union[str, os.PathLike] video_path: Path to video file to create timelapse from.
+    :param int frame_cnt: Number of frames to include in timelapse composite. Default 25.
+    :param Optional[int] size: Width per frame in pixels. If None, calculated to match video width. Default None.
+    :param Optional[int] crop_ratio: Percentage of frame width to keep (0-100). Default 50.
+    :param int padding: Padding in pixels added to timelapse when ruler is shown. Default 60.
+    :param int ruler_divisions: Number of major divisions on time ruler. Default 6.
+    :param bool show_ruler: If True, display time ruler below timelapse. Default True.
+    :param int ruler_height: Height of ruler in pixels. Default 60.
+
+    :example:
+    >>> slider = TimelapseSlider(video_path='path/to/video.mp4', frame_cnt=25, crop_ratio=75)
+    >>> slider.run()
+    >>> # Use sliders to select segment, then access selected times:
+    >>> start_time = slider.img_window.get_selected_start_time()
+    >>> end_time = slider.img_window.get_selected_end_time()
+    >>> slider.close()
+    """
+
+    def __init__(self,
+                 video_path: Union[str, os.PathLike],
+                 frame_cnt: int = 25,
+                 size: Optional[int] = None,
+                 crop_ratio: Optional[int] = 50,
+                 padding: int = 60,
+                 ruler_divisions: int = 6,
+                 show_ruler: bool = True,
+                 ruler_height: int = 60):
+
+        check_file_exist_and_readable(file_path=video_path)
+        check_int(name='frame_cnt', value=frame_cnt, min_value=1, raise_error=True)
+        if size is not None: check_int(name='size', value=size, min_value=1, raise_error=True)
+        check_int(name='padding', value=padding, min_value=1, raise_error=True)
+        check_int(name='ruler_height', value=ruler_height, min_value=1, raise_error=True)
+        check_valid_boolean(value=show_ruler, source=f'{self.__class__.__name__} show_ruler', raise_error=True)
+        self.video_meta = get_video_meta_data(video_path=video_path, raise_error=True)
+        if show_ruler: check_int(name='ruler_divisions', value=ruler_divisions, min_value=1, raise_error=True)
+        self.size, self.padding, self.crop_ratio, self.frame_cnt = size, padding, crop_ratio, frame_cnt
+        self.ruler_height, self.video_path, self.show_ruler, self.ruler_divisions = ruler_height, video_path, show_ruler, ruler_divisions
+        self.frm_name = f'{self.video_meta["video_name"]} - TIMELAPSE VIEWER'
+        self.video_capture = None  # Will be initialized in run()
+        self._pending_frame_update = None  # For debouncing frame preview updates
+        self._frame_debounce_ms = 300  # Wait 300ms after slider stops before updating frame preview
+
+    def _draw_img(self, img: np.ndarray, lbl: SimBALabel):
+        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        self.pil_image = Image.fromarray(img_rgb)
+        self.tk_image = ImageTk.PhotoImage(self.pil_image)
+        lbl.configure(image=self.tk_image)
+        lbl.image = self.tk_image
+
+    def _update_selection(self, slider_type: str):
+        start_sec = int(self.start_scale.get_value())
+        end_sec = int(self.end_scale.get_value())
+        max_sec = int(self.video_meta['video_length_s'])
+        if slider_type == 'start':
+            if start_sec >= end_sec:
+                end_sec = min(start_sec + 1, max_sec)
+                self.end_scale.set_value(end_sec)
+        else:
+            if end_sec <= start_sec:
+                start_sec = max(end_sec - 1, 0)
+                self.start_scale.set_value(start_sec)
+
+        self.selected_start[0] = start_sec
+        self.selected_end[0] = end_sec
+
+        # Update time labels immediately (fast, no I/O)
+        self.start_time_label.config(text=seconds_to_timestamp(start_sec), fg='blue')
+        self.end_time_label.config(text=seconds_to_timestamp(end_sec), fg='red')
+
+        if self.video_meta['video_length_s'] > 0:
+            # Update highlight immediately (moderate cost, but needed for visual feedback)
+            self._highlight_segment(start_sec, end_sec)
+            # Debounce frame preview update (expensive I/O operation)
+            self._schedule_frame_update(slider_type=slider_type)
+
+    def _schedule_frame_update(self, slider_type: str):
+        """Schedule frame preview update with debouncing.
+        
+        Cancels any pending frame update and schedules a new one. If the slider
+        moves again before the delay expires, the update is cancelled and rescheduled.
+        This prevents expensive frame reads during fast slider dragging.
+        """
+        # Check if window exists (might be called during cleanup)
+        if not hasattr(self, 'img_window') or not self.img_window.winfo_exists():
+            return
+        
+        # Cancel any pending frame update
+        if self._pending_frame_update is not None:
+            self.img_window.after_cancel(self._pending_frame_update)
+        
+        # Schedule new update after debounce delay
+        self._pending_frame_update = self.img_window.after(
+            self._frame_debounce_ms,
+            lambda: self._update_frame_display(slider_type=slider_type)
+        )
+
+    def _update_frame_display(self, slider_type: str):
+        """Update the frame preview display using the persistent VideoCapture object."""
+        if slider_type == 'start':
+            seconds = self.selected_start[0]
+            self.frame_label.config(text=f"Start Frame Preview ({seconds_to_timestamp(seconds)})", font=Formats.FONT_LARGE_BOLD.value, fg='blue')
+        else:
+            seconds = self.selected_end[0]
+            self.frame_label.config(text=f"End Frame Preview ({seconds_to_timestamp(seconds)})", font=Formats.FONT_LARGE_BOLD.value, fg='red')
+
+        frame_index = int(seconds * self.video_meta['fps'])
+        if frame_index >= self.video_meta['frame_count']: frame_index = self.video_meta['frame_count'] - 1
+        if frame_index < 0: frame_index = 0
+        
+        # Use persistent VideoCapture object instead of read_frm_of_video
+        if self.video_capture is not None and self.video_capture.isOpened():
+            self.video_capture.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
+            ret, frame = self.video_capture.read()
+            if ret and frame is not None:
+                self._draw_img(img=frame, lbl=self.frame_display_lbl)
+
+    def _create_time_ruler(self, width: int, height: int, num_divisions: int) -> np.ndarray:
+        total_width = width + (2 * self.padding)
+        bg_color, line_color, text_color = (255, 255, 255), (128, 128, 128), (0, 0, 0)
+        img = Image.new('RGB', (total_width, height), color=bg_color)
+        draw = ImageDraw.Draw(img)
+        font_dict = get_fonts()
+        try:
+            font_path = font_dict['Algerian']
+            pil_font = ImageFont.truetype(font_path, size=12)
+        except (KeyError, OSError):
+            pil_font = ImageFont.load_default()
+        major_tick_height, half_tick_height = height * 0.6, height * 0.4
+        quarter_tick_height, eighth_tick_height = height * 0.25, height * 0.15
+
+        for i in range(num_divisions + 1):
+            x = self.padding + int(i * width / num_divisions)
+            draw.line([(x, 0), (x, major_tick_height)], fill=line_color, width=2)
+            if self.video_meta['video_length_s'] is not None:
+                seconds_at_division = i * self.video_meta['video_length_s'] / num_divisions
+                label = seconds_to_timestamp(seconds=seconds_at_division)
+            elif self.video_meta['frame_count'] is not None:
+                label = str(int(i * self.video_meta['frame_count'] / num_divisions))
+            else:
+                label = str(i)
+            bbox = draw.textbbox((0, 0), label, font=pil_font)
+            text_width = bbox[2] - bbox[0]
+            if i == 0:
+                draw.text((x, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            elif i == num_divisions:
+                draw.text((x - text_width, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            else:
+                draw.text((x - text_width // 2, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            if i < num_divisions:
+                x_half = self.padding + int((i + 0.5) * width / num_divisions)
+                draw.line([(x_half, 0), (x_half, half_tick_height)], fill=line_color, width=1)
+                for q in [0.25, 0.75]:
+                    x_quarter = self.padding + int((i + q) * width / num_divisions)
+                    draw.line([(x_quarter, 0), (x_quarter, quarter_tick_height)], fill=line_color, width=1)
+                for e in [0.125, 0.375, 0.625, 0.875]:
+                    x_eighth = self.padding + int((i + e) * width / num_divisions)
+                    draw.line([(x_eighth, 0), (x_eighth, eighth_tick_height)], fill=line_color, width=1)
+
+        draw.line([(0, height - 1), (total_width, height - 1)], fill=line_color, width=1)
+        img_array = np.array(img)
+        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+        return img_bgr
+
+    def _highlight_segment(self, start_sec: int, end_sec: int):
+        timelapse_width = self.original_timelapse.shape[1]
+        start_x = int((start_sec / self.video_meta['video_length_s']) * timelapse_width)
+        end_x = int((end_sec / self.video_meta['video_length_s']) * timelapse_width)
+        highlighted = self.original_timelapse.copy()
+        mask = np.ones(highlighted.shape[:2], dtype=np.uint8) * 128
+        mask[:, start_x:end_x] = 255
+        mask = cv2.merge([mask, mask, mask])
+        highlighted = cv2.multiply(highlighted, mask.astype(np.uint8), scale=1/255.0)
+        cv2.line(highlighted, (start_x, 0), (start_x, highlighted.shape[0]), (0, 255, 0), 2)
+        cv2.line(highlighted, (end_x, 0), (end_x, highlighted.shape[0]), (0, 255, 0), 2)
+        self._draw_img(img=highlighted, lbl=self.img_lbl)
+
+    def run(self):
+        # Create persistent VideoCapture object for efficient frame reading
+        self.video_capture = cv2.VideoCapture(self.video_path)
+        if not self.video_capture.isOpened():
+            raise ValueError(f"Failed to open video file: {self.video_path}")
+        
+        self.timelapse_img = ImageMixin.get_timelapse_img(video_path=self.video_path, frame_cnt=self.frame_cnt, size=self.size, crop_ratio=self.crop_ratio)
+        if self.show_ruler:
+            timelapse_height, timelapse_width = self.timelapse_img.shape[0], self.timelapse_img.shape[1]
+            padded_timelapse = np.zeros((timelapse_height, timelapse_width + (2 * self.padding), 3), dtype=np.uint8)
+            padded_timelapse[:, self.padding:self.padding + timelapse_width] = self.timelapse_img
+            ruler = self._create_time_ruler(width=timelapse_width, height=self.ruler_height, num_divisions=self.ruler_divisions)
+            self.timelapse_img = cv2.vconcat([padded_timelapse, ruler])
+
+        self.original_timelapse = self.timelapse_img.copy()
+        self.img_window = Toplevel()
+        self.img_window.resizable(False, False)
+        self.img_window.title(self.frm_name)
+        self.img_window.protocol("WM_DELETE_WINDOW", self.close)
+
+
+        self.img_lbl = SimBALabel(parent=self.img_window, txt='')
+        self.img_lbl.pack()
+        self._draw_img(img=self.timelapse_img, lbl=self.img_lbl)
+        self.frame_display_frame = Frame(self.img_window)
+        self.frame_display_frame.pack(pady=10, padx=10, fill=BOTH, expand=True)
+        self.frame_label = SimBALabel(parent=self.frame_display_frame, txt="Frame Preview", font=Formats.FONT_REGULAR_BOLD.value)
+        self.frame_label.pack()
+        self.frame_display_lbl = SimBALabel(parent=self.frame_display_frame, txt='', bg_clr='black')
+        self.frame_display_lbl.pack(pady=5)
+        self.slider_frame = Frame(self.img_window)
+        self.slider_frame.pack(pady=10, padx=10, fill=X)
+        self.slider_frame.columnconfigure(index=0, weight=1)
+        self.slider_frame.columnconfigure(index=1, weight=0)
+        self.slider_frame.columnconfigure(index=2, weight=0)
+        self.slider_frame.columnconfigure(index=3, weight=1)
+    
+        self.start_scale = SimBAScaleBar(parent=self.slider_frame, label="START TIME:", from_=0, to=self.video_meta['video_length_s'], orient=HORIZONTAL, length=400, resolution=1, value=0, showvalue=False, label_width=15, sliderrelief='raised', troughcolor='white', activebackground='blue', lbl_font=Formats.FONT_LARGE_BOLD.value)
+        self.start_scale.grid(row=0, column=1, padx=5)
+        self.start_scale.scale.config(command=lambda x: self._update_selection(slider_type='start'))
+    
+        self.start_time_label = SimBALabel(parent=self.slider_frame, txt="00:00:00", font=Formats.FONT_LARGE_BOLD.value, width=10, txt_clr='blue')
+        self.start_time_label.grid(row=0, column=2, padx=5)
+
+        self.end_scale = SimBAScaleBar(parent=self.slider_frame, label="END TIME:", from_=0, to=int(self.video_meta['video_length_s']), orient=HORIZONTAL, length=400, resolution=1, value=int(self.video_meta['video_length_s']), showvalue=False, label_width=15, sliderrelief='raised', troughcolor='white', activebackground='red',  lbl_font=Formats.FONT_LARGE_BOLD.value)
+        self.end_scale.grid(row=1, column=1, padx=5)
+        self.end_scale.scale.config(command=lambda x: self._update_selection(slider_type='end'))
+
+        self.end_time_label = SimBALabel(parent=self.slider_frame, txt=seconds_to_timestamp(int(self.video_meta['video_length_s'])), font=Formats.FONT_LARGE_BOLD.value, width=10, txt_clr='red')
+        self.end_time_label.grid(row=1, column=2, padx=5)
+
+        self.selected_start = [0]
+        self.selected_end = [int(self.video_meta['video_length_s'])]
+
+        self.img_window.get_selected_start = lambda: self.selected_start[0]
+        self.img_window.get_selected_end = lambda: self.selected_end[0]
+        self.img_window.get_selected_start_time = lambda: seconds_to_timestamp(self.selected_start[0])
+        self.img_window.get_selected_end_time = lambda: seconds_to_timestamp(self.selected_end[0])
+        
+        self.img_window.update_idletasks()
+        self.img_window.update()
+        req_width, req_height = self.img_window.winfo_reqwidth(), self.img_window.winfo_reqheight()
+        min_width = max(self.timelapse_img.shape[1] + 60, req_width + 20)
+        min_height = max(self.timelapse_img.shape[0] + 800, req_height + 100)
+        self.img_window.minsize(min_width, min_height)
+        self.img_window.geometry(f"{min_width}x{min_height}")
+        self._update_frame_display(slider_type='start')
+
+    def close(self):
+        # Cancel any pending frame updates
+        if self._pending_frame_update is not None:
+            if hasattr(self, 'img_window') and self.img_window.winfo_exists():
+                self.img_window.after_cancel(self._pending_frame_update)
+            self._pending_frame_update = None
+        
+        # Release VideoCapture object
+        if self.video_capture is not None:
+            self.video_capture.release()
+            self.video_capture = None
+        
+        # Destroy window
+        if hasattr(self, 'img_window') and self.img_window.winfo_exists():
+            self.img_window.destroy()
+
+
+
+
+x = TimelapseSlider(video_path=r"E:\troubleshooting\mitra_emergence\project_folder\clip_test\Box1_180mISOcontrol_Females_clipped_progress_bar.mp4",
+        frame_cnt=25,
+        crop_ratio=75,
+        size=100)
+
+x.run()

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