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

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

@@ -69,13 +69,14 @@ from simba.video_processors.video_processing import (
     crop_single_video, crop_single_video_circle, crop_single_video_polygon,
     crossfade_two_videos, downsample_video, extract_frame_range,
     extract_frames_single_video, flip_videos, frames_to_movie, gif_creator,
-    multi_split_video, remove_beginning_of_video, resize_videos_by_height,
-    resize_videos_by_width, reverse_videos, roi_blurbox, rotate_video,
-    superimpose_elapsed_time, superimpose_frame_count, superimpose_freetext,
-    superimpose_overlay_video, superimpose_video_names,
-    superimpose_video_progressbar, temporal_concatenation, upsample_fps,
-    video_bg_subtraction, video_bg_subtraction_mp, video_concatenator,
-    video_to_bw, video_to_greyscale, watermark_video, remove_end_of_video)
+    multi_split_video, remove_beginning_of_video, remove_end_of_video,
+    resize_videos_by_height, resize_videos_by_width, reverse_videos,
+    roi_blurbox, rotate_video, superimpose_elapsed_time,
+    superimpose_frame_count, superimpose_freetext, superimpose_overlay_video,
+    superimpose_video_names, superimpose_video_progressbar,
+    temporal_concatenation, upsample_fps, video_bg_subtraction,
+    video_bg_subtraction_mp, video_concatenator, video_to_bw,
+    video_to_greyscale, watermark_video)
 
 sys.setrecursionlimit(10**7)
 
@@ -1548,7 +1549,7 @@ class ClipSingleVideoByFrameNumbers(PopUpMixin):
             if interactive_ui.img_window.winfo_exists(): interactive_ui.close()
             self.click_event.set(True)
 
-        interactive_ui = TimelapseSlider(video_path=self.selected_video.file_path)
+        interactive_ui = TimelapseSlider(video_path=self.selected_video.file_path, use_timestamps=False)
         interactive_ui.run()
         self.click_event = BooleanVar(value=False)
         interactive_ui.img_window.protocol("WM_DELETE_WINDOW", window_closed)
@@ -1647,7 +1648,7 @@ class ClipMultipleVideosByFrameNumbersPopUp(PopUpMixin):
             if interactive_ui.img_window.winfo_exists(): interactive_ui.close()
             self.click_event.set(True)
 
-        interactive_ui = TimelapseSlider(video_path=kwargs['video_path'], frame_cnt=kwargs['frame_cnt'], crop_ratio=kwargs['crop_ratio'])
+        interactive_ui = TimelapseSlider(video_path=kwargs['video_path'], frame_cnt=kwargs['frame_cnt'], crop_ratio=kwargs['crop_ratio'], use_timestamps=False)
         interactive_ui.run()
         self.click_event = BooleanVar(value=False)
         interactive_ui.img_window.protocol("WM_DELETE_WINDOW", window_closed)
@@ -2494,7 +2495,7 @@ class Convert2WEBMPopUp(PopUpMixin):
     def __init__(self):
         super().__init__(title="CONVERT VIDEOS TO WEBM", icon='webm')
         settings_frm = CreateLabelFrameWithIcon(parent=self.main_frm, header="SETTINGS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.VIDEO_TOOLS.value)
-        self.WEBM_CODEC_LK = {'VP8': 'vp8', 'VP9': 'vp9'}
+        self.WEBM_CODEC_LK = {'VP8': 'vp8', 'VP9': 'vp9', 'AV1': 'av1'}
 
         self.quality_dropdown = SimBADropDown(parent=settings_frm, label="OUTPUT VIDEO QUALITY:", dropdown_options=list(range(10, 110, 10)), label_width=25, value=60, img='pct', dropdown_width=30)
         self.codec_dropdown = SimBADropDown(parent=settings_frm, label="COMPRESSION CODEC:", dropdown_options=list(self.WEBM_CODEC_LK.keys()), label_width=25, value='VP9', img='file_type', dropdown_width=30)

simba/ui/video_timelaps.py

@@ -37,6 +37,7 @@ class TimelapseSlider():
     :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.
+    :param bool use_timestamps: If True, display timestamps (HH:MM:SS) in labels and ruler. If False, display frame numbers. Default True.
 
     :example:
     >>> slider = TimelapseSlider(video_path='path/to/video.mp4', frame_cnt=25, crop_ratio=75)
@@ -61,7 +62,8 @@ class TimelapseSlider():
                  ruler_height: Optional[int] = None,
                  ruler_width: Optional[int] = None,
                  img_width: Optional[int] = None,
-                 img_height: Optional[int] = None):
+                 img_height: Optional[int] = None,
+                 use_timestamps: bool = True):
 
         check_file_exist_and_readable(file_path=video_path)
         check_int(name='frame_cnt', value=frame_cnt, min_value=1, raise_error=True)
@@ -80,9 +82,11 @@ class TimelapseSlider():
         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)
+        check_valid_boolean(value=use_timestamps, source=f'{self.__class__.__name__} use_timestamps', raise_error=True)
         self.size, self.padding, self.crop_ratio, self.frame_cnt = ruler_width, 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.img_width, self.img_height = img_width, img_height
+        self.use_timestamps = use_timestamps
         self.frm_name = f'{self.video_meta["video_name"]} - TIMELAPSE VIEWER - hit "X" or ESC to close'
         self.video_capture, self._pending_frame_update, self._frame_debounce_ms = None, None, 50
 
@@ -94,16 +98,26 @@ class TimelapseSlider():
         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())
+        start_sec = self.start_scale.get_value()
+        end_sec = self.end_scale.get_value()
         max_sec = int(self.video_meta['video_length_s'])
+        
+        # Convert to int for timestamp mode, keep float for frame mode to preserve precision
+        if self.use_timestamps:
+            start_sec = int(start_sec)
+            end_sec = int(end_sec)
+        else:
+            # In frame mode, use float precision but ensure we're within bounds
+            start_sec = max(0.0, min(float(start_sec), float(max_sec)))
+            end_sec = max(0.0, min(float(end_sec), float(max_sec)))
+        
         if slider_type == 'start':
             if start_sec >= end_sec:
-                end_sec = min(start_sec + 1, max_sec)
+                end_sec = min(start_sec + (1.0 if self.use_timestamps else 1.0/self.video_meta['fps']), max_sec)
                 self.end_scale.set_value(end_sec)
         else:
             if end_sec <= start_sec:
-                start_sec = max(end_sec - 1, 0)
+                start_sec = max(end_sec - (1.0 if self.use_timestamps else 1.0/self.video_meta['fps']), 0)
                 self.start_scale.set_value(start_sec)
 
         self.selected_start[0] = start_sec
@@ -118,34 +132,118 @@ class TimelapseSlider():
         self.selected_start_frame[0] = start_frame
         self.selected_end_frame[0] = end_frame
 
-        self.start_time_label.config(text=seconds_to_timestamp(start_sec), fg='green')
-        self.end_time_label.config(text=seconds_to_timestamp(end_sec), fg='red')
+        if self.use_timestamps:
+            self.start_time_label.config(text=seconds_to_timestamp(start_sec), fg='green')
+            self.end_time_label.config(text=seconds_to_timestamp(end_sec), fg='red')
+        else:
+            start_frame = int(start_sec * self.video_meta['fps'])
+            end_frame = int(end_sec * self.video_meta['fps'])
+            self.start_time_label.config(text=str(start_frame), fg='green')
+            self.end_time_label.config(text=str(end_frame), fg='red')
 
         if self.video_meta['video_length_s'] > 0:
             self._highlight_segment(start_sec, end_sec)
             self._schedule_frame_update(slider_type=slider_type)
 
     def _move_start_frame(self, direction: int):
-        current_seconds = self.selected_start[0]
-        new_seconds = current_seconds + direction
-        new_seconds = max(0, min(new_seconds, int(self.video_meta['video_length_s'])))
-        self.start_scale.set_value(int(new_seconds))
-        self._update_selection(slider_type='start')
-        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._update_frame_display(slider_type='start')
+        # Temporarily unbind the callback to avoid conflicts
+        original_cmd = self.start_scale.scale.cget('command')
+        self.start_scale.scale.config(command='')
+        
+        try:
+            if self.use_timestamps:
+                current_seconds = self.selected_start[0]
+                new_seconds = current_seconds + direction
+                # Ensure start doesn't exceed end
+                end_seconds = self.selected_end[0]
+                new_seconds = max(0, min(new_seconds, int(self.video_meta['video_length_s']), end_seconds - 1))
+                self.start_scale.set_value(int(new_seconds))
+                self.selected_start[0] = int(new_seconds)
+                # Recalculate frame from seconds
+                new_frame = int(new_seconds * self.video_meta['fps'])
+                new_frame = max(0, min(new_frame, self.video_meta['frame_count'] - 1))
+                self.selected_start_frame[0] = new_frame
+            else:
+                # Get current frame from the selected_start_frame
+                current_frame = self.selected_start_frame[0]
+                new_frame = current_frame + direction
+                # Ensure start doesn't exceed end
+                end_frame = self.selected_end_frame[0]
+                new_frame = max(0, min(new_frame, self.video_meta['frame_count'] - 1, end_frame - 1))
+                # Convert frame to seconds for the slider
+                new_seconds = new_frame / self.video_meta['fps']
+                # Update the slider value
+                self.start_scale.set_value(new_seconds)
+                # Directly update both frame and seconds
+                self.selected_start_frame[0] = new_frame
+                self.selected_start[0] = new_seconds
+            
+            # Update the display labels and highlights
+            if self.use_timestamps:
+                self.start_time_label.config(text=seconds_to_timestamp(self.selected_start[0]), fg='green')
+            else:
+                self.start_time_label.config(text=str(self.selected_start_frame[0]), fg='green')
+            
+            # Update highlights and frame preview
+            if self.video_meta['video_length_s'] > 0:
+                self._highlight_segment(self.selected_start[0], self.selected_end[0])
+                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._update_frame_display(slider_type='start')
+        finally:
+            # Rebind the callback
+            self.start_scale.scale.config(command=original_cmd)
 
     def _move_end_frame(self, direction: int):
-        current_seconds = self.selected_end[0]
-        new_seconds = current_seconds + direction
-        new_seconds = max(0, min(new_seconds, int(self.video_meta['video_length_s'])))
-        self.end_scale.set_value(int(new_seconds))
-        self._update_selection(slider_type='end')
-        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._update_frame_display(slider_type='end')
+        # Temporarily unbind the callback to avoid conflicts
+        original_cmd = self.end_scale.scale.cget('command')
+        self.end_scale.scale.config(command='')
+        
+        try:
+            if self.use_timestamps:
+                current_seconds = self.selected_end[0]
+                new_seconds = current_seconds + direction
+                # Ensure end doesn't go below start
+                start_seconds = self.selected_start[0]
+                new_seconds = max(start_seconds + 1, min(new_seconds, int(self.video_meta['video_length_s'])))
+                self.end_scale.set_value(int(new_seconds))
+                self.selected_end[0] = int(new_seconds)
+                # Recalculate frame from seconds
+                new_frame = int(new_seconds * self.video_meta['fps'])
+                new_frame = max(0, min(new_frame, self.video_meta['frame_count'] - 1))
+                self.selected_end_frame[0] = new_frame
+            else:
+                # Get current frame from the selected_end_frame
+                current_frame = self.selected_end_frame[0]
+                new_frame = current_frame + direction
+                # Ensure end doesn't go below start
+                start_frame = self.selected_start_frame[0]
+                new_frame = max(start_frame + 1, min(new_frame, self.video_meta['frame_count'] - 1))
+                # Convert frame to seconds for the slider
+                new_seconds = new_frame / self.video_meta['fps']
+                # Update the slider value
+                self.end_scale.set_value(new_seconds)
+                # Directly update both frame and seconds
+                self.selected_end_frame[0] = new_frame
+                self.selected_end[0] = new_seconds
+            
+            # Update the display labels and highlights
+            if self.use_timestamps:
+                self.end_time_label.config(text=seconds_to_timestamp(self.selected_end[0]), fg='red')
+            else:
+                self.end_time_label.config(text=str(self.selected_end_frame[0]), fg='red')
+            
+            # Update highlights and frame preview
+            if self.video_meta['video_length_s'] > 0:
+                self._highlight_segment(self.selected_start[0], self.selected_end[0])
+                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._update_frame_display(slider_type='end')
+        finally:
+            # Rebind the callback
+            self.end_scale.scale.config(command=original_cmd)
 
     def _schedule_frame_update(self, slider_type: str):
         """Schedule frame preview update with debouncing.
@@ -164,10 +262,20 @@ class TimelapseSlider():
     def _update_frame_display(self, slider_type: str):
         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='green')
+            if self.use_timestamps:
+                label_text = f"Start Frame Preview ({seconds_to_timestamp(seconds)})"
+            else:
+                frame_num = int(seconds * self.video_meta['fps'])
+                label_text = f"Start Frame Preview (Frame {frame_num})"
+            self.frame_label.config(text=label_text, font=Formats.FONT_LARGE_BOLD.value, fg='green')
         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')
+            if self.use_timestamps:
+                label_text = f"End Frame Preview ({seconds_to_timestamp(seconds)})"
+            else:
+                frame_num = int(seconds * self.video_meta['fps'])
+                label_text = f"End Frame Preview (Frame {frame_num})"
+            self.frame_label.config(text=label_text, 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
@@ -207,7 +315,7 @@ class TimelapseSlider():
             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 = ImageMixin.create_time_ruler(video_path=self.video_path, width=timelapse_width, height=self.ruler_height, num_divisions=self.ruler_divisions)
+            ruler = ImageMixin.create_time_ruler(video_path=self.video_path, width=timelapse_width, height=self.ruler_height, num_divisions=self.ruler_divisions, show_time=self.use_timestamps)
             self.timelapse_img = cv2.vconcat([padded_timelapse, ruler])
 
         self.original_timelapse = self.timelapse_img.copy()
@@ -241,24 +349,37 @@ class TimelapseSlider():
         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='green')
+        initial_start_text = "00:00:00" if self.use_timestamps else "0"
+        self.start_time_label = SimBALabel(parent=self.slider_frame, txt=initial_start_text, font=Formats.FONT_LARGE_BOLD.value, width=10, txt_clr='green')
         self.start_time_label.grid(row=0, column=2, padx=5)
 
-        self.start_frame_left_btn = SimbaButton(parent=self.slider_frame, txt="-1s", tooltip_txt="Previous second", cmd=self._move_start_frame, cmd_kwargs={'direction': -1}, font=Formats.FONT_REGULAR_BOLD.value, img='left_arrow_green')
+        start_btn_txt = "Previous second" if self.use_timestamps else "Previous frame"
+        start_btn_tooltip = "Move start time back by 1 second" if self.use_timestamps else "Move start frame back by 1 frame"
+        self.start_frame_left_btn = SimbaButton(parent=self.slider_frame, txt=start_btn_txt, tooltip_txt=start_btn_tooltip, cmd=self._move_start_frame, cmd_kwargs={'direction': -1}, font=Formats.FONT_REGULAR_BOLD.value, img='left_arrow_green')
         self.start_frame_left_btn.grid(row=0, column=3, padx=2)
-        self.start_frame_right_btn = SimbaButton(parent=self.slider_frame, txt="+1s", tooltip_txt="Next second", cmd=self._move_start_frame, cmd_kwargs={'direction': 1}, font=Formats.FONT_REGULAR_BOLD.value, img='right_arrow_green')
+        start_btn_txt_right = "Next second" if self.use_timestamps else "Next frame"
+        start_btn_tooltip_right = "Move start time forward by 1 second" if self.use_timestamps else "Move start frame forward by 1 frame"
+        self.start_frame_right_btn = SimbaButton(parent=self.slider_frame, txt=start_btn_txt_right, tooltip_txt=start_btn_tooltip_right, cmd=self._move_start_frame, cmd_kwargs={'direction': 1}, font=Formats.FONT_REGULAR_BOLD.value, img='right_arrow_green')
         self.start_frame_right_btn.grid(row=0, column=4, padx=2)
 
         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')
+        if self.use_timestamps:
+            initial_end_text = seconds_to_timestamp(int(self.video_meta['video_length_s']))
+        else:
+            initial_end_text = str(self.video_meta['frame_count'] - 1)
+        self.end_time_label = SimBALabel(parent=self.slider_frame, txt=initial_end_text, font=Formats.FONT_LARGE_BOLD.value, width=10, txt_clr='red')
         self.end_time_label.grid(row=1, column=2, padx=5)
 
-        self.end_frame_left_btn = SimbaButton(parent=self.slider_frame, txt="-1s", tooltip_txt="Previous second", cmd=self._move_end_frame, cmd_kwargs={'direction': -1}, font=Formats.FONT_REGULAR_BOLD.value, img='left_arrow_red')
+        end_btn_txt = "Previous second" if self.use_timestamps else "Previous frame"
+        end_btn_tooltip = "Move end time back by 1 second" if self.use_timestamps else "Move end frame back by 1 frame"
+        self.end_frame_left_btn = SimbaButton(parent=self.slider_frame, txt=end_btn_txt, tooltip_txt=end_btn_tooltip, cmd=self._move_end_frame, cmd_kwargs={'direction': -1}, font=Formats.FONT_REGULAR_BOLD.value, img='left_arrow_red')
         self.end_frame_left_btn.grid(row=1, column=3, padx=2)
-        self.end_frame_right_btn = SimbaButton(parent=self.slider_frame, txt="+1s", tooltip_txt="Next second", cmd=self._move_end_frame, cmd_kwargs={'direction': 1}, font=Formats.FONT_REGULAR_BOLD.value, img='right_arrow_red')
+        end_btn_txt_right = "Next second" if self.use_timestamps else "Next frame"
+        end_btn_tooltip_right = "Move end time forward by 1 second" if self.use_timestamps else "Move end frame forward by 1 frame"
+        self.end_frame_right_btn = SimbaButton(parent=self.slider_frame, txt=end_btn_txt_right, tooltip_txt=end_btn_tooltip_right, cmd=self._move_end_frame, cmd_kwargs={'direction': 1}, font=Formats.FONT_REGULAR_BOLD.value, img='right_arrow_red')
         self.end_frame_right_btn.grid(row=1, column=4, padx=2)
 
         self.selected_start = [0]
@@ -325,8 +446,9 @@ class TimelapseSlider():
 
 
 
-#
+
 # 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)
+#         crop_ratio=75,
+#                     use_timestamps=False)
 # x.run()

simba/video_processors/video_processing.py

@@ -56,7 +56,7 @@ from simba.utils.lookups import (get_current_time, get_ffmpeg_codec,
                                  get_ffmpeg_crossfade_methods, get_fonts,
                                  get_named_colors, percent_to_crf_lookup,
                                  percent_to_qv_lk, quality_pct_to_crf,
-                                 video_quality_to_preset_lookup)
+                                 video_quality_to_preset_lookup, get_ffmpeg_encoders)
 from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (
     check_if_hhmmss_timestamp_is_valid_part_of_video,
@@ -440,10 +440,11 @@ def clahe_enhance_video(file_path: Union[str, os.PathLike],
     dir, file_name, file_ext = get_fn_ext(filepath=file_path)
     if out_path is None:
         save_path = os.path.join(dir, f"CLAHE_{file_name}.avi")
+        fourcc = cv2.VideoWriter_fourcc(*Formats.AVI_CODEC.value)
     else:
         check_if_dir_exists(in_dir=os.path.dirname(out_path), source=f'{clahe_enhance_video.__name__} out_path')
+        fourcc = cv2.VideoWriter_fourcc(*Formats.MP4_CODEC.value)
         save_path = out_path
-    fourcc = cv2.VideoWriter_fourcc(*Formats.AVI_CODEC.value)
     if verbose: print(f"Applying CLAHE on video {file_name}, this might take awhile...")
     cap = cv2.VideoCapture(file_path)
     writer = cv2.VideoWriter( save_path, fourcc, video_meta_data["fps"], (video_meta_data["width"], video_meta_data["height"]), 0)
@@ -3265,6 +3266,9 @@ def convert_to_avi(path: Union[str, os.PathLike],
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
     check_str(name=f'{convert_to_avi.__name__} codec', value=codec, options=('xvid', 'divx', 'mjpeg'))
+    CODEC_LK = {'mpeg4': 'mpeg4', 'divx': 'libxvid', 'mjpeg': 'mjpeg'}
+    codec = CODEC_LK[codec]
+    check_valid_codec(codec=codec, raise_error=True, source=f'{convert_to_avi.__name__} codec')
     check_instance(source=f'{convert_to_avi.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_avi.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -3292,18 +3296,18 @@ def convert_to_avi(path: Union[str, os.PathLike],
         _ = get_video_meta_data(video_path=file_path)
         out_path = os.path.join(save_dir, f'{video_name}.avi')
         if codec == 'divx':
-            cmd = f'ffmpeg -i "{file_path}" -c:v mpeg4 -crf {crf} -vtag DIVX "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -crf {crf} -vtag DIVX "{out_path}" -loglevel error -stats -hide_banner -y'
         elif codec == 'xvid':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libxvid -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
         else:
-            cmd = f'ffmpeg -i "{file_path}" -c:v mjpeg -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
+            cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -q:v {qv} "{out_path}" -loglevel error -stats -hide_banner -y'
         subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     stdout_success(msg=f"{len(file_paths)} video(s) converted to AVI and saved in {save_dir} directory.", elapsed_time=timer.elapsed_time_str, source=convert_to_avi.__name__,)
 
 
 def convert_to_webm(path: Union[str, os.PathLike],
-                    codec: Literal['vp8', 'vp9'] = 'vp9',
+                    codec: Literal['vp8', 'vp9', 'av1'] = 'vp9',
                     save_dir: Optional[Union[str, os.PathLike]] = None,
                     quality: Optional[int] = 60) -> None:
 
@@ -3326,7 +3330,10 @@ def convert_to_webm(path: Union[str, os.PathLike],
 
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
-    check_str(name=f'{convert_to_webm.__name__} codec', value=codec, options=('vp8', 'vp9'))
+    check_str(name=f'{convert_to_webm.__name__} codec', value=codec, options=('vp8', 'vp9', 'av1'))
+    CODEC_LK = {'vp8': 'libvpx', 'vp9': 'libvpx-vp9', 'av1': 'libaom-av1'}
+    codec = CODEC_LK[codec]
+    check_valid_codec(codec=codec, raise_error=True, source=f'{convert_to_webm.__name__} codec')
     check_instance(source=f'{convert_to_webm.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_webm.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")
@@ -3346,17 +3353,13 @@ def convert_to_webm(path: Union[str, os.PathLike],
         os.makedirs(save_dir)
     else:
         raise InvalidInputError(msg=f'Paths is not a valid file or directory path.', source=convert_to_webm.__name__)
+
     for file_cnt, file_path in enumerate(file_paths):
         _, video_name, _ = get_fn_ext(filepath=file_path)
         print(f'Converting video {video_name} to WEBM (Video {file_cnt+1}/{len(file_paths)})...')
         _ = get_video_meta_data(video_path=file_path)
         out_path = os.path.join(save_dir, f'{video_name}.webm')
-        if codec == 'vp8':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libvpx -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
-        elif codec == 'vp9':
-            cmd = f'ffmpeg -i "{file_path}" -c:v libvpx-vp9 -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
-        else:
-            cmd = f'ffmpeg -i "{file_path}" -c:v libaom-av1 -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
+        cmd = f'ffmpeg -i "{file_path}" -c:v {codec} -crf {crf} "{out_path}" -loglevel error -stats -hide_banner -y'
         subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
     timer.stop_timer()
     stdout_success(msg=f"{len(file_paths)} video(s) converted to WEBM and saved in {save_dir} directory.", elapsed_time=timer.elapsed_time_str, source=convert_to_webm.__name__,)
@@ -3381,6 +3384,10 @@ def convert_to_mov(path: Union[str, os.PathLike],
     timer = SimbaTimer(start=True)
     check_ffmpeg_available(raise_error=True)
     check_str(name=f'{convert_to_mov.__name__} codec', value=codec, options=('prores', 'animation', 'cineform', 'dnxhd'))
+
+
+
+
     check_instance(source=f'{convert_to_mov.__name__} path', instance=path, accepted_types=(str,))
     check_int(name=f'{convert_to_mov.__name__} quality', value=quality)
     datetime_ = datetime.now().strftime("%Y%m%d%H%M%S")

{simba_uw_tf_dev-4.7.4.dist-info → simba_uw_tf_dev-4.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba-uw-tf-dev
-Version: 4.7.4
+Version: 4.7.6
 Summary: Toolkit for computer classification and analysis of behaviors in experimental animals
 Home-page: https://github.com/sgoldenlab/simba
 Author: Simon Nilsson, Jia Jie Choong, Sophia Hwang