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

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/import_pose_frame.py

@@ -82,7 +82,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
             Label(self.import_tracking_frm, text="Please CREATE PROJECT CONFIG before importing tracking data \n", font=Formats.FONT_REGULAR.value).grid(row=0, column=0, sticky=NW)
         else:
             ConfigReader.__init__(self, config_path=config_path, read_video_info=False)
-            self.data_type_dropdown = SimBADropDown(parent=self.import_tracking_frm, dropdown_options=Options.IMPORT_TYPE_OPTIONS.value, label="DATA TYPE: ", label_width=25, command=self.create_import_menu, dropdown_width=25, value=Options.IMPORT_TYPE_OPTIONS.value[0])
+            self.data_type_dropdown = SimBADropDown(parent=self.import_tracking_frm, dropdown_options=Options.IMPORT_TYPE_OPTIONS.value, label="DATA TYPE: ", label_width=25, command=self.create_import_menu, dropdown_width=25, value=Options.IMPORT_TYPE_OPTIONS.value[0], img='file_type')
             self.data_type_dropdown.grid(row=0, column=0, sticky=NW)
             self.create_import_menu(data_type_choice=Options.IMPORT_TYPE_OPTIONS.value[0])
             self.import_tracking_frm.grid(row=idx_row, column=idx_column, sticky=NW)
@@ -91,7 +91,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
 
     def __show_smoothing_entry_box_from_dropdown(self, choice: str):
         if (choice == GAUSSIAN) or (choice == SAVITZKY_GOLAY):
-            self.smoothing_time_eb.grid(row=0, column=1, sticky=E)
+            self.smoothing_time_eb.grid(row=1, column=0, sticky=E)
         else:
             self.smoothing_time_eb.grid_forget()
 
@@ -265,21 +265,21 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
         self.animal_name_entry_boxes = None
 
         self.interpolation_frm = CreateLabelFrameWithIcon(parent=self.choice_frm, header="INTERPOLATION METHOD", pady=5, padx=5,font=Formats.FONT_HEADER.value, icon_name='fill', relief='groove')
-        self.interpolation_dropdown = SimBADropDown(parent=self.interpolation_frm, dropdown_options=Options.INTERPOLATION_OPTIONS_W_NONE.value, label='INTERPOLATION METHOD: ', label_width=25, dropdown_width=35, value=Options.INTERPOLATION_OPTIONS_W_NONE.value[0])
+        self.interpolation_dropdown = SimBADropDown(parent=self.interpolation_frm, dropdown_options=Options.INTERPOLATION_OPTIONS_W_NONE.value, label='INTERPOLATION METHOD: ', label_width=25, dropdown_width=35, value=Options.INTERPOLATION_OPTIONS_W_NONE.value[0], img='fill')
         self.interpolation_frm.grid(row=0, column=0, sticky=NW)
         self.interpolation_dropdown.grid(row=0, column=0, sticky=NW)
 
         self.smoothing_frm = CreateLabelFrameWithIcon(parent=self.choice_frm, header="SMOOTHING METHOD", pady=5, padx=5, font=Formats.FONT_HEADER.value, icon_name='smooth', relief='groove')
-        self.smoothing_dropdown = SimBADropDown(parent=self.smoothing_frm, dropdown_options=Options.SMOOTHING_OPTIONS_W_NONE.value, label='SMOOTHING: ', label_width=25, dropdown_width=35, value=Options.SMOOTHING_OPTIONS_W_NONE.value[0], command=self.__show_smoothing_entry_box_from_dropdown)
-        self.smoothing_time_eb = Entry_Box(self.smoothing_frm, "SMOOTHING PERIOD (MS):", labelwidth=30,  validation="numeric", entry_box_width=10)
+        self.smoothing_dropdown = SimBADropDown(parent=self.smoothing_frm, dropdown_options=Options.SMOOTHING_OPTIONS_W_NONE.value, label='SMOOTHING: ', label_width=25, dropdown_width=35, value=Options.SMOOTHING_OPTIONS_W_NONE.value[0], command=self.__show_smoothing_entry_box_from_dropdown, img='smooth')
+        self.smoothing_time_eb = Entry_Box(self.smoothing_frm, "SMOOTHING PERIOD (MS):", labelwidth=25,  validation="numeric", entry_box_width=35, img='timer_2')
         self.smoothing_frm.grid(row=1, column=0, sticky=NW)
         self.smoothing_dropdown.grid(row=0, column=0, sticky=NW)
 
         if data_type_choice in ["CSV (DLC/DeepPoseKit)", "MAT (DANNCE 3D)", "JSON (BENTO)", "CSV (SimBA BLOB)", 'H5 (FaceMap)', 'CSV (SimBA YOLO)']: # DATA TYPES WHERE NO TRACKS HAVE TO BE SPECIFIED
             self.import_directory_frm = LabelFrame(self.choice_frm, text=FRAME_DIR_IMPORT_TITLES[data_type_choice], pady=5, padx=5, font=Formats.FONT_HEADER.value,)
-            self.import_directory_select = FolderSelect(self.import_directory_frm, "Input data DIRECTORY:", lblwidth=25, initialdir=self.project_path)
+            self.import_directory_select = FolderSelect(self.import_directory_frm, "Input data DIRECTORY:", lblwidth=25, initialdir=self.project_path, lbl_icon='folder')
             self.import_single_frm = LabelFrame(self.choice_frm, text=FRAME_FILE_IMPORT_TITLES[data_type_choice], pady=5, padx=5, font=Formats.FONT_HEADER.value,)
-            self.import_file_select = FileSelect(self.import_single_frm, "Input data FILE:", lblwidth=25, file_types=[("Pose data file", FILE_TYPES[data_type_choice])])
+            self.import_file_select = FileSelect(self.import_single_frm, "Input data FILE:", lblwidth=25, file_types=[("Pose data file", FILE_TYPES[data_type_choice])], lbl_icon='file_type')
 
             if data_type_choice == "CSV (DLC/DeepPoseKit)":
                 self.import_dir_btn = Button(self.import_directory_frm, fg="blue", font=Formats.FONT_REGULAR.value, text="Import DLC CSV DIRECTORY to SimBA project", command=lambda: self.__import_dlc_csv_data(interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -342,7 +342,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                 self.dlc_data_type_option_dropdown.setChoices(Options.MULTI_DLC_TYPE_IMPORT_OPTION.value[1])
                 self.tracking_type_frm.grid(row=5, column=0, sticky=NW)
                 self.dlc_data_type_option_dropdown.grid(row=0, column=0, sticky=NW)
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 DLC DIRECTORY: ", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 DLC DIRECTORY: ", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, text="Please import videos BEFORE importing the \n multi animal DLC tracking data", font=Formats.FONT_REGULAR.value)
                 self.run_btn = Button(self.import_frm, text="IMPORT DLC .H5", fg="blue", command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                       interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -352,7 +352,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                                                                                                                                       data_path=self.data_dir_select.folder_path,
                                                                                                                                       tracking_data_type=self.dlc_data_type_option_dropdown.getChoices()))
             elif data_type_choice == "SLP (SLEAP)":
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "SLP SLEAP DIRECTORY: ", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "SLP SLEAP DIRECTORY: ", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, font=Formats.FONT_REGULAR.value, text="Please import videos before importing the \n multi animal SLEAP tracking data if you are tracking more than ONE animal")
                 self.run_btn = Button(self.import_frm, text="IMPORT SLEAP .SLP", fg="blue", font=Formats.FONT_REGULAR.value, command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                          interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -362,7 +362,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                                                                                                                                          data_path=self.data_dir_select.folder_path))
 
             elif data_type_choice == "TRK (multi-animal APT)":
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "TRK APT DIRECTORY: ", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "TRK APT DIRECTORY: ", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, text="Please import videos before importing the \n multi animal TRK tracking data", font=Formats.FONT_REGULAR.value,)
                 self.run_btn = Button(self.import_frm, text="IMPORT APT .TRK", font=Formats.FONT_REGULAR.value, fg="blue", command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                        interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -372,7 +372,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                                                                                                                                        data_path=self.data_dir_select.folder_path))
 
             elif data_type_choice == "CSV (SLEAP)":
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "CSV SLEAP DIRECTORY:", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "CSV SLEAP DIRECTORY:", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, font=Formats.FONT_REGULAR.value, text="Please import videos before importing the SLEAP tracking data \n IF you are tracking more than ONE animal")
                 self.run_btn = Button(self.import_frm, text="IMPORT SLEAP .CSV", fg="blue", font=Formats.FONT_REGULAR.value, command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                          interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -382,7 +382,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                                                                                                                                          data_path=self.data_dir_select.folder_path))
 
             elif data_type_choice == "H5 (SLEAP)":
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 SLEAP DIRECTORY", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 SLEAP DIRECTORY", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, font=Formats.FONT_REGULAR.value, text="Please import videos before importing the SLEAP H5 tracking data \n IF you are tracking more than ONE animal")
                 self.run_btn = Button(self.import_frm, text="IMPORT SLEAP H5", font=Formats.FONT_REGULAR.value, fg="blue", command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                        interpolation_settings=self.interpolation_dropdown.getChoices(),
@@ -391,7 +391,7 @@ class ImportPoseFrame(ConfigReader, PopUpMixin):
                                                                                                                                        animal_names=self.animal_name_entry_boxes,
                                                                                                                                        data_path=self.data_dir_select.folder_path))
             elif data_type_choice == "H5 (SuperAnimal-TopView)":
-                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 SuperAnimal DIRECTORY:", lblwidth=25)
+                self.data_dir_select = FolderSelect(self.data_dir_frm, "H5 SuperAnimal DIRECTORY:", lblwidth=25, lbl_icon='folder')
                 self.instructions_lbl = Label(self.data_dir_frm, font=Formats.FONT_REGULAR.value, text="Please import videos before importing the H5 SuperAnimal tracking data \n IF you are tracking more than ONE animal")
                 self.run_btn = Button(self.import_frm, text="IMPORT SuperAnimal-Mouse-TopView H5", fg="blue", font=Formats.FONT_REGULAR.value, command=lambda: self.__multi_animal_run_call(pose_estimation_tool=data_type_choice,
                                                                                                                                                                            interpolation_settings=self.interpolation_dropdown.getChoices(),

simba/ui/pop_ups/clf_plot_pop_up.py

@@ -57,7 +57,7 @@ class SklearnVisualizationPopUp(PopUpMixin, ConfigReader):
         self.bp_threshold_lbl.grid(row=0, column=0, sticky=NW)
         self.bp_threshold_entry.grid(row=1, column=0, sticky=NW)
 
-        self.style_settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="SETTINGS", icon_name='style', icon_link=Links.SKLEARN_PLOTS.value, padx=5, pady=5, relief='solid')
+        self.style_settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="TEXT SETTINGS", icon_name='style', icon_link=Links.SKLEARN_PLOTS.value, padx=5, pady=5, relief='solid')
         self.text_size_dropdown = SimBADropDown(parent=self.style_settings_frm, dropdown_options=TEXT_SIZE_OPTIONS, label='TEXT SIZE: ', label_width=40, dropdown_width=15, value='AUTO', img='text')
         self.text_spacing_dropdown = SimBADropDown(parent=self.style_settings_frm, dropdown_options=TEXT_SIZE_OPTIONS, label='TEXT SPACING: ', label_width=40, dropdown_width=15, value='AUTO', img='text_spacing')
         self.text_thickness_dropdown = SimBADropDown(parent=self.style_settings_frm, dropdown_options=TEXT_SIZE_OPTIONS, label='TEXT THICKNESS: ', label_width=40, dropdown_width=15, value='AUTO', img='bold')

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