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

simba/mixins/image_mixin.py

@@ -18,6 +18,7 @@ from collections import ChainMap
 import cv2
 import pandas as pd
 from numba import float64, int64, jit, njit, prange, uint8
+from PIL import Image, ImageDraw, ImageFont
 from shapely.geometry import Polygon
 from skimage.metrics import structural_similarity
 
@@ -30,11 +31,12 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
 from simba.utils.data import terminate_cpu_pool
 from simba.utils.enums import Defaults, Formats, GeometryEnum, Options
 from simba.utils.errors import ArrayError, FrameRangeError, InvalidInputError
+from simba.utils.lookups import get_fonts
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (find_core_cnt,
                                     find_files_of_filetypes_in_directory,
                                     get_fn_ext, get_video_meta_data,
-                                    read_frm_of_video)
+                                    read_frm_of_video, seconds_to_timestamp)
 
 
 class ImageMixin(object):
@@ -2052,18 +2054,141 @@ class ImageMixin(object):
 
         return denoised_img
 
+    @staticmethod
+    def get_timelapse_img(video_path: Union[str, os.PathLike],
+                          frame_cnt: int = 25,
+                          size: Optional[int] = None,
+                          crop_ratio: int = 50) -> np.ndarray:
 
+        """
+        Creates timelapse image from video.
 
+        .. image:: _static/img/get_timelapse_img.png
+           :width: 600
+           :align: center
 
+        :param Union[str, os.PathLike] video_path: Path to the video to cerate the timelapse image from.
+        :param int frame_cnt: Number of frames to grab from the video. There will be an even interval between each frame.
+        :param Optional[int] size: The total width in pixels of the final timelapse image. If None, uses the video width (adjusted for crop_ratio).
+        :param int crop_ratio: The percent of each original video (from the left) to show.
+        :return np.ndarray: The timelapse image as a numpy array
 
+        :example:
+        >>> img = ImageMixin.get_timelapse_img(video_path=r"E:\troubleshooting\mitra_emergence\project_folder\clip_test\Box1_180mISOcontrol_Females_clipped_progress_bar.mp4", size=100)
+        """
 
+        video_meta = get_video_meta_data(video_path=video_path, raise_error=True)
+        frm_ids = [int(i * video_meta['frame_count'] / frame_cnt) for i in range(frame_cnt)]
+        cap = cv2.VideoCapture(video_path)
+        frms = [read_frm_of_video(video_path=cap, frame_index=x, use_ffmpeg=False) for x in frm_ids]
+
+        effective_video_width = int(video_meta['width'] * (crop_ratio / 100))
+        if size is None:
+            size = effective_video_width
+        per_frame_width_after_crop = size / frame_cnt
+        per_frame_width_before_crop = per_frame_width_after_crop / (crop_ratio / 100)
+        scale_factor = per_frame_width_before_crop / frms[0].shape[1]
+        scaled_frms = [cv2.resize(x, None, fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_LINEAR) for x in frms]
+        if crop_ratio is not None:
+            scaled_frms = [ImageMixin.segment_img_vertical(img=x, pct=crop_ratio, left=True) for x in scaled_frms]
+        
+        return cv2.hconcat(scaled_frms)
 
+    @staticmethod
+    def create_time_ruler(width: int,
+                          video_path: Union[str, os.PathLike],
+                          height: int = 60,
+                          num_divisions: int = 6,
+                          font: str = 'Arial',
+                          bg_color: Tuple[int, int, int] = (255, 255, 255),
+                          line_color: Tuple[int, int, int] = (128, 128, 128),
+                          text_color: Tuple[int, int, int] = (0, 0, 0),
+                          padding: int = 60,
+                          show_time: bool = True) -> np.ndarray:
+        """
+        Create a horizontal ruler/scale bar with tick marks and labels.
+
+        .. image:: _static/img/create_time_ruler.png
+           :width: 600
+           :align: center
 
+        :param int width: Width of the ruler in pixels (should match timelapse image width if one is used)
+        :param Union[str, os.PathLike] video_path: Path to video file to get metadata from
+        :param int height: Height of the ruler in pixels. Default 60.
+        :param int num_divisions: Number of major divisions on the ruler. Default 6.
+        :param str font: Font name to use for labels. Default 'Algerian'.
+        :param Tuple[int, int, int] bg_color: Background color (R, G, B). Default white.
+        :param Tuple[int, int, int] line_color: Color for tick marks and lines (R, G, B). Default grey.
+        :param Tuple[int, int, int] text_color: Color for text labels (R, G, B). Default black.
+        :param bool show_time: If True, show time labels, else show frame numbers. Default True.
+        :return: Ruler image as numpy array (BGR format for OpenCV compatibility)
+        :rtype: np.ndarray
 
+        :example:
+        >>> ruler = ImageMixin.create_time_ruler(width=1920, video_path='path/to/video.mp4', height=60, num_divisions=6)
+        """
 
-
-
-
+        check_file_exist_and_readable(file_path=video_path)
+        check_int(name='width', value=width, min_value=1, raise_error=True)
+        check_int(name='height', value=height, min_value=1, raise_error=True)
+        check_int(name='num_divisions', value=num_divisions, min_value=1, raise_error=True)
+        check_int(name='padding', value=padding, min_value=0, raise_error=True)
+        check_str(name='font', value=font, allow_blank=False, raise_error=True)
+        check_if_valid_rgb_tuple(data=bg_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+        check_if_valid_rgb_tuple(data=line_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+        check_if_valid_rgb_tuple(data=text_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+
+        video_meta = get_video_meta_data(video_path=video_path, raise_error=True)
+        total_width = width + (2 * padding)
+
+        img = Image.new('RGB', (total_width, height), color=bg_color)
+        draw = ImageDraw.Draw(img)
+        font_dict = get_fonts()
+        try:
+            font_path = font_dict[font]
+            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 = padding + int(i * width / num_divisions)
+            draw.line([(x, 0), (x, major_tick_height)], fill=line_color, width=2)
+            if show_time and video_meta['video_length_s'] is not None:
+                seconds_at_division = i * video_meta['video_length_s'] / num_divisions
+                label = seconds_to_timestamp(seconds=seconds_at_division)
+            elif video_meta['frame_count'] is not None:
+                label = str(int(i * 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 = 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 = 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 = 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_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+        return img_bgr
+
+
+# img = ImageMixin.create_time_ruler(width=1920, video_path=r"E:\troubleshooting\mitra_emergence\project_folder\clip_test\Box1_180mISOcontrol_Females_clipped_progress_bar.mp4", height=60, num_divisions=6)
+#
+# cv2.imshow('sadasdas', img)
+# cv2.waitKey(40000)
 
 #x = ImageMixin.get_blob_locations(video_path=r"C:\troubleshooting\RAT_NOR\project_folder\videos\2022-06-20_NOB_DOT_4_downsampled_bg_subtracted.mp4", gpu=True)
 # imgs = ImageMixin().read_all_img_in_dir(dir='/Users/simon/Desktop/envs/simba/troubleshooting/RAT_NOR/project_folder/videos/examples')

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/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()