simba-uw-tf-dev 5.2.1__tar.gz → 5.2.3__tar.gz

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: simba_uw_tf_dev
-Version: 5.2.1
+Version: 5.2.3
 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

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/requirements_gpu.txt

@@ -3,5 +3,5 @@ cupy-cuda12x>=13.6.0
 shap==0.46.1.dev78
 cuml-cu12==24.12.0
 torch==2.5.0
-ultralytics==8.3.156
+ultralytics==8.4.9
 nvidia-cuda-runtime-cu12

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/setup.py

@@ -29,7 +29,7 @@ with open(GPU_REQUIREMENTS_PATH, "r") as f:
 # Setup configuration
 setuptools.setup(
     name="simba_uw_tf_dev",
-    version="5.2.1",
+    version="5.2.3",
     author="Simon Nilsson, Jia Jie Choong, Sophia Hwang",
     author_email="sronilsson@gmail.com",
     description="Toolkit for computer classification and analysis of behaviors in experimental animals",

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/simba/SimBA.py

@@ -481,17 +481,14 @@ class SimbaProjectPopUp(ConfigReader, PopUpMixin):
         targeted_clip_annotator_btn = SimbaButton(parent=targeted_clip_annotator_frm, txt="Select video", cmd=select_labelling_video_targeted_clips, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
 
         lbl_tools_frm = CreateLabelFrameWithIcon(parent=tab7, header="LABELLING TOOLS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.ADVANCED_LBL.value, bg=Formats.LABELFRAME_GREY.value, padx=5, pady=5)
-        visualize_annotation_img_btn = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="VISUALIZE ANNOTATIONS", cmd=ExtractAnnotationFramesPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
-        visualize_annotation_video_btn = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="VISUALIZE ANNOTATION BOUTS", txt_clr='blue', cmd=AnnotatedBoutsVideoPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
+        visualize_annotation_img_btn = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="VISUALIZE ANNOTATIONS FRAMES", cmd=ExtractAnnotationFramesPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
+        visualize_annotation_video_btn = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="VISUALIZE ANNOTATION VIDEO BOUTS", txt_clr='blue', cmd=AnnotatedBoutsVideoPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
         third_party_annotations_btn = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="APPEND THIRD-PARTY ANNOTATIONS", txt_clr='purple', cmd=ThirdPartyAnnotatorAppenderPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
         remove_roi_features_from_annotation_set = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="REMOVE ROI FEATURES FROM LABEL SET", txt_clr='darkred', cmd=RemoveROIFeaturesPopUp, cmd_kwargs={'config_path': lambda:self.config_path, 'dataset': lambda:'targets_inserted'}, thread=False)
         compute_annotation_statistics = SimbaButton(parent=lbl_tools_frm, width=Formats.BUTTON_WIDTH_XS.value, txt="COUNT ANNOTATIONS IN PROJECT", txt_clr='orange', cmd=ClfAnnotationCountPopUp, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
 
-
-
         label_trainmachinemodel = CreateLabelFrameWithIcon(parent=tab8, header="TRAIN MACHINE MODELS", icon_name=Keys.DOCUMENTATION.value, icon_link=Links.TRAIN_ML_MODEL.value, bg=Formats.LABELFRAME_GREY.value, padx=5, pady=5)
 
-
         button_trainmachinesettings = SimbaButton(parent=label_trainmachinemodel, width=Formats.BUTTON_WIDTH_XXL.value, txt="SETTINGS", img='settings', txt_clr='darkorange', cmd=self.trainmachinemodelsetting, thread=False)
         button_trainmachinemodel = SimbaButton(parent=label_trainmachinemodel, width=Formats.BUTTON_WIDTH_XXL.value, txt="TRAIN SINGLE MODEL (GLOBAL ENVIRONMENT)", img='one_blue', txt_clr='blue', cmd=self.train_single_model, cmd_kwargs={'config_path': lambda:self.config_path}, thread=False)
 

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/simba/assets/.recent_projects.txt

@@ -1,3 +1,4 @@
+F:/troubleshooting/varsha/project_folder/project_config.ini
 E:/troubleshooting/mitra/project_folder/project_config.ini
 F:/troubleshooting/sam/sam/project_folder/project_config.ini
 F:/troubleshooting/sophiaa/project_folder/project_config.ini

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/simba/assets/lookups/tooptips.json

@@ -31,6 +31,8 @@
   "MOVEMENT_DISTANCE": "If checked, calculates the total distance traveled (in centimeters) for each animal throughout the entire video. Distance is measured as cumulative path length of the selected body-part.",
   "MOVEMENT_VELOCITY": "If checked, calculates the average velocity (in cm/s) for each animal throughout the entire video. Velocity is computed as distance divided by time.",
   "MOVEMENT_TRANSPOSE": "If checked, transposes the output CSV so that videos are in rows and animal/body-part/measurement combinations are in columns. Default: each row is a video-animal-bodypart-measurement combination.",
+  "MOVEMENT_INCLUDE_FRAME_COUNT": "If checked, includes the total number of frames in each video as a metadata column in the output.",
+  "MOVEMENT_INCLUDE_VIDEO_LENGTH": "If checked, includes each video's length in HH:MM:SS format as a metadata column in the output.",
   "DISTANCE_ANALYSIS_NUMBER_OF_PAIRS": "How many body-part pairs to analyze. SimBA creates one BODY-PART 1 / BODY-PART 2 row per pair.",
   "DISTANCE_ANALYSIS_BODY_PART": "Pick one body-part for this side of the pair. Each row must use two different body-parts.",
   "DISTANCE_ANALYSIS_BP_THRESHOLD": "Pose confidence cutoff (0.0-1.0). Frames where either body-part is below this value are ignored for this pair.",
@@ -433,5 +435,69 @@
   "ANNOTATION_BOUTS_CPU_CORES": "Number of CPU cores used for rendering. More cores are often faster but use more memory.",
   "ANNOTATION_BOUTS_USE_GPU": "If TRUE and a compatible NVIDIA GPU is available, SimBA uses GPU-enabled path where supported.",
   "ANNOTATION_BOUTS_SHOW_BBOX": "Bounding box mode: FALSE disables boxes, AXIS_ALIGNED draws horizontal boxes, ANIMAL_ALIGNED draws rotated animal-oriented boxes.",
-  "ANNOTATION_BOUTS_TIMER": "Timer format shown in output clips. FALSE disables timer; SECONDS shows numeric seconds; HH:MM:SS.SSSS shows formatted timestamp."
+  "ANNOTATION_BOUTS_TIMER": "Timer format shown in output clips. FALSE disables timer; SECONDS shows numeric seconds; HH:MM:SS.SSSS shows formatted timestamp.",
+  "HORIZONTAL_FLIP": "If TRUE, flip the output video horizontally (mirror left-right). If FALSE, leave the video unchanged.",
+  "VERTICAL_FLIP": "If TRUE, flip the output video vertically (mirror top-bottom). If FALSE, leave the video unchanged.",
+  "WATERMARK_LOCATION": "Where the watermark image is placed on the output video. Options: TOP LEFT, TOP RIGHT, BOTTOM LEFT, BOTTOM RIGHT, or CENTER.",
+  "WATERMARK_IMAGE_PATH": "Path to the image file used as the watermark overlay (e.g. a PNG with transparency).",
+  "WATERMARK_OPACITY": "Opacity of the watermark overlay (0.0–1.0). 1.0 keeps the watermark fully visible; lower values make it more transparent.",
+  "WATERMARK_SCALE": "Watermark size as a percentage of the input image width (0–100%). 100% would use the full width; smaller values scale down.",
+  "PROGRESS_BAR_LOCATION": "Where the progress bar is drawn on the output video: TOP or BOTTOM.",
+  "PROGRESS_BAR_COLOR": "Color of the progress bar. Pick one of the color names shown in the dropdown.",
+  "PROGRESS_BAR_HEIGHT": "Height of the progress bar as a percentage of the video height (%).",
+  "SUPERIMPOSE_TEXT_LOCATION": "Where the free text overlay is placed on the output video (e.g. TOP LEFT, BOTTOM RIGHT).",
+  "SUPERIMPOSE_TEXT_VALUE": "The exact text string to overlay on the video.",
+  "SUPERIMPOSE_TEXT_FONT": "Font family used for the text overlay.",
+  "SUPERIMPOSE_TEXT_FONT_SIZE": "Font size (in points) for the text overlay.",
+  "SUPERIMPOSE_TEXT_FONT_COLOR": "Text fill color (chosen from the color names shown in the dropdown).",
+  "SUPERIMPOSE_TEXT_FONT_BORDER_COLOR": "Color of the text border/outline (chosen from the dropdown).",
+  "SUPERIMPOSE_TEXT_FONT_BORDER_WIDTH": "Thickness of the text border/outline (in pixels).",
+  "SUPERIMPOSE_VIDEO_NAME_TEXT_LOCATION": "Where the video filename text is placed on the output video (e.g. TOP LEFT, BOTTOM RIGHT).",
+  "SUPERIMPOSE_VIDEO_NAME_FONT": "Font family used for the video filename text overlay.",
+  "SUPERIMPOSE_VIDEO_NAME_FONT_SIZE": "Font size (in points) for the video filename text overlay.",
+  "SUPERIMPOSE_VIDEO_NAME_FONT_COLOR": "Text fill color (chosen from the color names shown in the dropdown).",
+  "SUPERIMPOSE_VIDEO_NAME_FONT_BORDER_COLOR": "Color of the video filename text border/outline (chosen from the dropdown).",
+  "SUPERIMPOSE_VIDEO_NAME_FONT_BORDER_WIDTH": "Thickness of the video filename text border/outline (in pixels).",
+  "SUPERIMPOSE_VIDEO_MAIN_VIDEO_PATH": "Path to the main video you want to add the overlay onto.",
+  "SUPERIMPOSE_VIDEO_OVERLAY_VIDEO_PATH": "Path to the second video that will be overlaid on the main video.",
+  "SUPERIMPOSE_VIDEO_OVERLAY_LOCATION": "Where the overlay video is placed on the main video: TOP LEFT, TOP RIGHT, BOTTOM LEFT, BOTTOM RIGHT, or CENTER.",
+  "SUPERIMPOSE_VIDEO_OVERLAY_OPACITY": "Opacity of the overlay video (0.0–1.0). Higher = more opaque.",
+  "SUPERIMPOSE_VIDEO_OVERLAY_SCALE": "Overlay scaling factor relative to the main video width. For example, 0.05 = 5% width; 0.5 = 50% width (dropdown values range from 0.05 to 0.95).",
+  "SUPERIMPOSE_FRAME_COUNT_FONT_SIZE": "Font size (in pixels) for the overlaid frame number.",
+  "SUPERIMPOSE_FRAME_COUNT_FONT_COLOR": "Text color of the overlaid frame number (chosen from the dropdown).",
+  "SUPERIMPOSE_FRAME_COUNT_FONT_BACKGROUND_COLOR": "Background box color behind the frame number text (chosen from the dropdown).",
+  "SUPERIMPOSE_FRAME_COUNT_FONT": "Font family used for the frame number text.",
+  "VIDEO_ROTATOR_USE_GPU": "If TRUE and a compatible NVIDIA GPU is available, rotate using FFmpeg GPU codecs (faster). If FALSE, use CPU rotation/encoding.",
+  "VIDEO_ROTATOR_USE_FFMPEG": "If TRUE, rotate using FFmpeg (instead of OpenCV). If FALSE, rotate using OpenCV/CPU.",
+  "ROTATE_VIDEO_DEGREES": "Rotate the video clockwise by this many degrees. Valid range is 1–359.",
+  "CONCAT_VIDEO_PATH_1": "Path to the first video to concatenate.",
+  "CONCAT_VIDEO_PATH_2": "Path to the second video to concatenate.",
+  "CONCAT_VIDEOS_USE_GPU": "If TRUE and a compatible GPU is available, uses GPU acceleration for concatenation/encoding when supported.",
+  "CROSSFADE_VIDEO_PATH_1": "Path to the first input video. This video provides the start of the timeline before the cross-fade.",
+  "CROSSFADE_VIDEO_PATH_2": "Path to the second input video. This video provides the end of the timeline during the cross-fade.",
+  "CROSSFADE_OUTPUT_FORMAT": "Output container/format for the cross-faded video (e.g. mp4, avi, webm).",
+  "CROSSFADE_METHOD": "Cross-fade transition style. The available methods come from FFmpeg and control how the blend occurs.",
+  "CROSSFADE_DURATION": "Cross-fade duration in seconds.",
+  "CROSSFADE_OFFSET": "Time offset into video 1 (HH:MM:SS). Cross-fade begins at this time in the first video.",
+  "BOX_BLUR_VIDEO_PATH": "Path to the input video to blur a user-selected ROI box on.",
+  "BOX_BLUR_BLUR_LEVEL": "Blur intensity for the ROI box (ratio 0.0–1.0). Higher = stronger blur.",
+  "BOX_BLUR_INVERT_REGION": "If TRUE, blur the unselected region (outside the ROI box). If FALSE, blur inside the ROI box.",
+  "CONVERT2BW_THRESHOLD": "Black/white threshold for binarizing the video (0.01–1.0). Higher values are stricter.",
+  "CONVERT2BW_VIDEO_PATH": "Video file to convert to black-and-white.",
+  "CONVERT2BW_VIDEO_DIR_PATH": "Directory of videos to convert to black-and-white.",
+  "AVG_FRAME_SAVE_DIR": "Folder where the generated average-frame PNG(s) will be saved.",
+  "AVG_FRAME_START_TIME": "Start time (HH:MM:SS) for the sample window to average. Leave blank to use the beginning.",
+  "AVG_FRAME_END_TIME": "End time (HH:MM:SS) for the sample window to average. Leave blank to use the end.",
+  "AVG_FRAME_VIDEO_PATH": "Video file to extract frames from and compute the average frame.",
+  "AVG_FRAME_VIDEO_DIR_PATH": "Directory containing video files to process when using batch mode.",
+  "CONVERT2MP4_QUALITY": "Quality for MP4 encoding. For CPU codecs this is CRF-like (10–100). For the GPU codec it becomes a preset: Low/Medium/High.",
+  "CONVERT2MP4_CODEC": "Compression codec used when converting to MP4 (CPU or GPU). Different codecs trade off speed and file size.",
+  "CONVERT2MP4_KEEP_AUDIO": "If TRUE, keep audio (AAC). If FALSE and audio exists, remove audio.",
+  "CONVERT2MP4_VIDEO_PATH": "Input video file to convert to MP4.",
+  "CONVERT2MP4_VIDEO_DIR_PATH": "Input directory containing videos to convert to MP4.",
+  "MULTICROP_INPUT_FOLDER": "Folder containing the input videos to crop.",
+  "MULTICROP_OUTPUT_FOLDER": "Folder where the cropped video clips will be saved.",
+  "MULTICROP_INPUT_VIDEO_FORMAT": "Input video file format inside the input folder (e.g. mp4).",
+  "MULTICROP_CROPS_PER_VIDEO": "How many cropped clips to create per input video (minimum 2).",
+  "MULTICROP_OUTPUT_QUALITY": "Encoding quality for the cropped output videos (1–100)."
 }

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/simba/data_processors/movement_calculator.py

@@ -19,7 +19,7 @@ from simba.utils.checks import (
 from simba.utils.errors import InvalidInputError, NoDataError
 from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
-                                    get_fn_ext, read_df)
+                                    get_fn_ext, read_df, seconds_to_timestamp)
 
 
 class MovementCalculator(ConfigReader, FeatureExtractionMixin):
@@ -58,7 +58,9 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
                  distance: bool = True,
                  velocity: bool = True,
                  transpose: bool = False,
-                 verbose: bool = True):
+                 verbose: bool = True,
+                 frame_count: bool = False,
+                 video_length: bool = False):
 
         ConfigReader.__init__(self, config_path=config_path)
         FeatureExtractionMixin.__init__(self)
@@ -89,6 +91,8 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
         check_valid_boolean(value=velocity, source=f'{self.__class__.__name__} velocity', raise_error=True)
         check_valid_boolean(value=transpose, source=f'{self.__class__.__name__} transpose', raise_error=True)
         check_valid_boolean(value=verbose, source=f'{self.__class__.__name__} verbose', raise_error=True)
+        check_valid_boolean(value=frame_count, source=f'{self.__class__.__name__} frame_count', raise_error=True)
+        check_valid_boolean(value=video_length, source=f'{self.__class__.__name__} video_length', raise_error=True)
         if not distance and not velocity:
             raise InvalidInputError(msg='distance AND velocity are both False. To compute movement metrics, set at least one value to True.', source=self.__class__.__name__)
         self.distance, self.velocity, = distance, velocity
@@ -99,6 +103,7 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
         else:
             raise InvalidInputError(msg='Body-parts has to be a list of tuple of strings', source=f'{self.__class__.__name__} body_parts')
         self.body_parts, self.threshold, self.body_parts, self.transpose, self.verbose = file_paths, threshold, body_parts, transpose, verbose
+        self.frame_count, self.video_length = frame_count, video_length
 
     def __find_body_part_columns(self):
         self.body_parts_dict, self.bp_list = {}, []
@@ -129,9 +134,9 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
                     animal_df = animal_df.iloc[:, 0:2].reset_index(drop=True)
                     distance, velocity = FeatureExtractionSupplemental.distance_and_velocity(x=animal_df.values, fps=self.fps, pixels_per_mm=self.px_per_mm, centimeters=True)
                     if self.distance:
-                        self.results.loc[len(self.results)] = [video_name, animal_data["ANIMAL NAME"], animal_data["BODY-PART"], "Distance (cm)", distance]
+                        self.results.loc[len(self.results)] = [video_name, animal_data["ANIMAL NAME"], animal_data["BODY-PART"], "DISTANCE (CM)", distance]
                     if self.velocity:
-                        self.results.loc[len(self.results)] = [video_name, animal_data["ANIMAL NAME"], animal_data["BODY-PART"], "Velocity (cm/s)", velocity]
+                        self.results.loc[len(self.results)] = [video_name, animal_data["ANIMAL NAME"], animal_data["BODY-PART"], "VELOCITY (CM/S)", velocity]
             else:
                 for animal in self.body_parts:
                     animal_name = animal.split("CENTER OF GRAVITY")[0].strip()
@@ -141,16 +146,23 @@ class MovementCalculator(ConfigReader, FeatureExtractionMixin):
                     df = self.dataframe_savgol_smoother(df=df, fps=self.fps).astype(np.int32)
                     distance, velocity = FeatureExtractionSupplemental.distance_and_velocity(x=df.values, fps=self.fps, pixels_per_mm=self.px_per_mm, centimeters=True)
                     if self.distance:
-                        self.results.loc[len(self.results)] = [video_name, animal_name, "GRAVITY CENTER", "Distance (cm)", distance]
+                        self.results.loc[len(self.results)] = [video_name, animal_name, "GRAVITY CENTER", "DISTANCE (CM)", distance]
                     if self.velocity:
-                        self.results.loc[len(self.results)] = [video_name, animal_name, "GRAVITY CENTER", "Velocity (cm/s)", velocity]
+                        self.results.loc[len(self.results)] = [video_name, animal_name, "GRAVITY CENTER", "VELOCITY (CM/S)", velocity]
+
+            if self.frame_count:
+                self.results.loc[len(self.results)] = [video_name, "", "", "VIDEO FRAME COUNT", len(self.data_df)]
+            if self.video_length:
+                timestamp = seconds_to_timestamp(seconds=int(np.ceil(len(self.data_df) / self.fps)), hh_mm_ss_sss=False)
+                self.results.loc[len(self.results)] = [video_name, "", "", "VIDEO LENGTH (HH:MM:SS)", timestamp]
+
             video_timer.stop_timer()
             if self.verbose:
                 stdout_information(msg=f'Movement analysis in video {video_name} complete', elapsed_time=video_timer.elapsed_time_str)
 
     def save(self):
         if self.transpose:
-            self.results = (self.results.assign(col=lambda x: x["ANIMAL"] + "_" + x["BODY-PART"] + "_" + x["MEASUREMENT"]).pivot(index="VIDEO", columns="col", values="VALUE").reset_index())
+            self.results = (self.results.assign(col=lambda x: (x["ANIMAL"] + "_" + x["BODY-PART"] + "_" + x["MEASUREMENT"]).str.strip("_")).pivot(index="VIDEO", columns="col", values="VALUE").reset_index())
         self.results.set_index("VIDEO").to_csv(self.save_path)
         self.timer.stop_timer()
         if self.verbose: stdout_success(msg=f"Movement log saved in {self.save_path}", elapsed_time=self.timer.elapsed_time_str)
@@ -171,9 +183,12 @@ if __name__ == "__main__" and not hasattr(sys, 'ps1'):
     runner.save()
 
 
-# test = MovementCalculator(config_path=r"C:\troubleshooting\mitra\project_folder\project_config.ini",
-#                           body_parts=['Animal_1 CENTER OF GRAVITY', 'Nose'], #['Simon CENTER OF GRAVITY', 'JJ CENTER OF GRAVITY', 'Animal_1 CENTER OF GRAVITY']
-#                           threshold=0.00)
+# test = MovementCalculator(config_path=r"F:\troubleshooting\sam\sam\project_folder\project_config.ini",
+#                           body_parts=['center', 'nose'], #['Simon CENTER OF GRAVITY', 'JJ CENTER OF GRAVITY', 'Animal_1 CENTER OF GRAVITY']
+#                           threshold=0.00,
+#                           frame_count=True,
+#                           video_length=True,
+#                           transpose=False)
 # test.run()
 # test.save()
 

simba_uw_tf_dev-5.2.3/simba/feature_extractors/wingwave_extractor.py

@@ -0,0 +1,189 @@
+import argparse
+import os
+import sys
+from copy import deepcopy
+from typing import Optional, Union
+
+import numpy as np
+import pandas as pd
+
+from simba.feature_extractors.perimeter_jit import get_hull_sizes
+from simba.mixins.abstract_classes import AbstractFeatureExtraction
+from simba.mixins.config_reader import ConfigReader
+from simba.mixins.feature_extraction_mixin import FeatureExtractionMixin
+from simba.mixins.statistics_mixin import Statistics
+from simba.mixins.timeseries_features_mixin import TimeseriesFeatureMixin
+from simba.utils.checks import (
+    check_all_file_names_are_represented_in_video_log, check_instance,
+    check_valid_array, check_valid_dataframe)
+from simba.utils.enums import Formats
+from simba.utils.printing import stdout_information, stdout_success
+from simba.utils.read_write import (find_files_of_filetypes_in_directory,
+                                    read_df, read_video_info, write_df)
+
+WING_LEFT, WING_RIGHT = 'wing_L', 'wing_R'
+HEAD, THORAX, ABDOMEN = 'head', 'thorax', 'abdomen'
+WINDOW_SIZES = np.array([0.5, 1.0, 2.0, 3.0, 6.0])
+
+class WingWaveFeatureExtractor(ConfigReader, FeatureExtractionMixin, AbstractFeatureExtraction):
+
+    def __init__(self,
+                 config_path: Union[str, os.PathLike],
+                 data_dir: Optional[Union[str, os.PathLike]] = None):
+
+        ConfigReader.__init__(self, config_path=config_path, read_video_info=True, create_logger=True)
+        self.data_dir = self.outlier_corrected_dir if data_dir is None else data_dir
+        self.data_paths = find_files_of_filetypes_in_directory(directory=self.data_dir, extensions='.csv', as_dict=True, raise_error=True, sort_alphabetically=True)
+
+    def run(self):
+        check_all_file_names_are_represented_in_video_log(video_info_df=self.video_info_df, data_paths=list(self.data_paths.values()))
+        for file_cnt, (file_name, file_path) in enumerate(self.data_paths.items()):
+            data_df = read_df(file_path=file_path, file_type='csv', verbose=False)
+            out_df = deepcopy(data_df)
+            _, px_per_mm, fps = read_video_info(video_info_df=self.video_info_df, video_name=file_name)
+            save_path = os.path.join(self.features_dir, f'{file_name}.csv')
+            stdout_information(msg=f'Analyzing {file_name}...')
+            for id in range(1, self.animal_cnt + 1):
+                print(id)
+                animal_df = data_df[[x for x in data_df.columns if f'_{id}_' in x]]
+                wing_l, wing_r = animal_df[[f'{WING_LEFT}_{id}_x', f'{WING_LEFT}_{id}_y']].values, animal_df[[f'{WING_RIGHT}_{id}_x', f'{WING_RIGHT}_{id}_y']].values
+                head, thorax = animal_df[[f'{HEAD}_{id}_x', f'{HEAD}_{id}_y']].values, animal_df[[f'{THORAX}_{id}_x', f'{THORAX}_{id}_y']].values
+                abdomen = animal_df[[f'{ABDOMEN}_{id}_x', f'{ABDOMEN}_{id}_y']].values
+
+                p_vals = animal_df[[f'{WING_LEFT}_{id}_p', f'{WING_RIGHT}_{id}_p', f'{HEAD}_{id}_p', f'{ABDOMEN}_{id}_x', f'{THORAX}_{id}_x']].values
+
+                out_df[f'wing_l_thorax_wing_r_angle_animal_{id}'] = FeatureExtractionMixin.three_point_angle(bp_1=wing_l, bp_2=thorax, bp_3=wing_r)
+                out_df[f'wing_l_head_wing_r_angle_animal_{id}'] = FeatureExtractionMixin.three_point_angle(bp_1=wing_l, bp_2=head, bp_3=wing_r)
+                out_df[f'wing_l_abdomen_wing_r_angle_animal_{id}'] = FeatureExtractionMixin.three_point_angle(bp_1=wing_l, bp_2=head, bp_3=wing_r)
+                wing_l_thorax_wing_r = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'wing_l_thorax_wing_r_angle_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'wing_l_thorax_wing_r_mean_500_animal_{id}', f'wing_l_thorax_wing_r_mean_1000_animal_{id}', f'wing_l_thorax_wing_r_mean_2000_animal_{id}', f'wing_l_thorax_wing_r_mean_3000_animal_{id}', f'wing_l_thorax_wing_r_mean_6000_animal_{id}'])
+                wing_l_head_wing_r = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'wing_l_head_wing_r_angle_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'wing_l_head_wing_r_mean_500_animal_{id}', f'wing_l_head_wing_r_mean_1000_animal_{id}', f'wing_l_head_wing_r_mean_2000_animal_{id}', f'wing_l_head_wing_r_mean_3000_animal_{id}', f'wing_l_head_wing_r_mean_6000_animal_{id}'])
+                wing_l_abdomen_wing_r = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'wing_l_head_wing_r_angle_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'wing_l_abdomen_wing_r_mean_500_animal_{id}', f'wing_l_abdomen_wing_r_mean_1000_animal_{id}', f'wing_l_abdomen_wing_r_mean_2000_animal_{id}', f'wing_l_abdomen_wing_r_mean_3000_animal_{id}', f'wing_l_abdomen_wing_r_mean_6000_animal_{id}'])
+                out_df = pd.concat([out_df, wing_l_thorax_wing_r, wing_l_head_wing_r, wing_l_abdomen_wing_r], axis=1)
+
+                out_df[f'framewise_wing_distance_animal_{id}'] = FeatureExtractionMixin.bodypart_distance(bp1_coords=wing_l, bp2_coords=wing_r, px_per_mm=px_per_mm, in_centimeters=False)
+                wing_dist_absenergy = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['absenergy'])[0], columns=[f'wing_distance_energy_500_animal_{id}', f'wing_distance_energy_1000_animal_{id}', f'wing_distance_energy_2000_animal_{id}', f'wing_distance_energy_3000_animal_{id}', f'wing_distance_energy_6000_animal_{id}'])
+                wing_dist_variance = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['var'])[0], columns=[f'wing_distance_var_500_animal_{id}', f'wing_distance_var_1000_animal_{id}', f'wing_distance_var_2000_animal_{id}', f'wing_distance_var_3000_animal_{id}', f'wing_distance_var_6000_animal_{id}'])
+                out_df = pd.concat([out_df, wing_dist_absenergy, wing_dist_variance], axis=1)
+
+                out_df[f'framewise_wing_l_head_distance_animal_{id}'] =  FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_l.astype(np.float64), location_2=head.astype(np.float64), px_per_mm=np.float64(px_per_mm), centimeter=False)
+                out_df[f'framewise_wing_r_head_distance_animal_{id}'] =  FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_r.astype(np.float64), location_2=head.astype(np.float64), px_per_mm=np.float64(px_per_mm), centimeter=False)
+                out_df[f'framewise_wing_l_abdomen_distance_animal_{id}'] = FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_l.astype(np.float64), location_2=abdomen.astype(np.float64),px_per_mm=np.float64(px_per_mm), centimeter=False)
+                out_df[f'framewise_wing_r_abdomen_distance_animal_{id}'] = FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_r.astype(np.float64), location_2=abdomen.astype(np.float64),px_per_mm=np.float64(px_per_mm), centimeter=False)
+                out_df[f'framewise_wing_l_thorax_distance_animal_{id}'] = FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_l.astype(np.float64), location_2=thorax.astype(np.float64),px_per_mm=np.float64(px_per_mm), centimeter=False)
+                out_df[f'framewise_wing_r_thorax_distance_animal_{id}'] = FeatureExtractionMixin.framewise_euclidean_distance(location_1=wing_r.astype(np.float64), location_2=thorax.astype(np.float64),px_per_mm=np.float64(px_per_mm), centimeter=False)
+
+                wing_l_head_distance_mean = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_l_head_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'wing_l_head_mean_500_animal_{id}', f'wing_l_head_mean_1000_animal_{id}', f'wing_l_head_mean_2000_animal_{id}', f'wing_l_head_mean_3000_animal_{id}', f'wing_l_head_mean_6000_animal_{id}'])
+                wing_r_head_distance_mean = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_r_head_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'wing_r_head_mean_500_animal_{id}', f'wing_r_head_mean_1000_animal_{id}', f'wing_r_head_mean_2000_animal_{id}', f'wing_r_head_mean_3000_animal_{id}', f'wing_r_head_mean_6000_animal_{id}'])
+                wing_r_head_distance_std = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_r_head_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['std'])[0], columns=[f'wing_r_head_std_500_animal_{id}', f'wing_r_head_std_1000_animal_{id}', f'wing_r_head_std_2000_animal_{id}', f'wing_r_head_std_3000_animal_{id}', f'wing_r_head_std_6000_animal_{id}'])
+                wing_l_head_distance_std = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_l_head_distance_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['std'])[0], columns=[f'wing_l_head_std_500_animal_{id}', f'wing_l_head_std_1000_animal_{id}', f'wing_l_head_std_2000_animal_{id}', f'wing_lr_head_std_3000_animal_{id}', f'wing_l_head_std_6000_animal_{id}'])
+                out_df = pd.concat([out_df, wing_l_head_distance_mean, wing_r_head_distance_mean, wing_r_head_distance_std, wing_l_head_distance_std], axis=1)
+
+                out_df[f'framewise_wing_l_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=wing_l, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_wing_r_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=wing_r, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_head_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=head, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_thorax_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=thorax, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_abdomen_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=abdomen, px_per_mm=px_per_mm, centimeter=False)
+                wing_l_sum = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_l_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'wing_l_sum_500_animal_{id}', f'wing_l_sum_1000_animal_{id}', f'wing_l_sum_2000_animal_{id}', f'wing_l_sum_3000_animal_{id}', f'wing_l_sum_6000_animal_{id}'])
+                wing_r_sum = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_r_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'wing_r_sum_500_animal_{id}', f'wing_r_sum_1000_animal_{id}', f'wing_r_sum_2000_animal_{id}', f'wing_r_sum_3000_animal_{id}', f'wing_r_sum_6000_animal_{id}'])
+                head_sum = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_head_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'head_sum_500_animal_{id}', f'head_sum_1000_animal_{id}', f'head_sum_2000_animal_{id}', f'head_sum_3000_animal_{id}', f'head_sum_6000_animal_{id}'])
+                thorax_sum = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_thorax_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'thorax_sum_500_animal_{id}', f'thorax_sum_1000_animal_{id}', f'thorax_sum_2000_animal_{id}', f'thorax_sum_3000_animal_{id}', f'thorax_sum_6000_animal_{id}'])
+                abdomen_sum = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_abdomen_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'abdomen_sum_500_animal_{id}', f'abdomen_sum_1000_animal_{id}', f'abdomen_sum_2000_animal_{id}', f'abdomen_sum_3000_animal_{id}', f'abdomen_sum_6000_animal_{id}'])
+                out_df = pd.concat([out_df, wing_l_sum, wing_r_sum, head_sum, thorax_sum, abdomen_sum], axis=1)
+
+                head_wing_l_pearson = pd.DataFrame(
+                    Statistics.sliding_pearsons_r(
+                        sample_1=out_df[f'framewise_head_movement_animal_{id}'].values.astype(np.float32),
+                        sample_2=out_df[f'framewise_wing_l_movement_animal_{id}'].values.astype(np.float32),
+                        time_windows=WINDOW_SIZES,
+                        fps=fps,
+                    ),
+                    columns=[
+                        f'head_wing_l_movement_pearson_500_animal_{id}',
+                        f'head_wing_l_movement_pearson_1000_animal_{id}',
+                        f'head_wing_l_movement_pearson_2000_animal_{id}',
+                        f'head_wing_l_movement_pearson_3000_animal_{id}',
+                        f'head_wing_l_movement_pearson_6000_animal_{id}',
+                    ],
+                )
+                head_wing_r_pearson = pd.DataFrame(
+                    Statistics.sliding_pearsons_r(
+                        sample_1=out_df[f'framewise_head_movement_animal_{id}'].values.astype(np.float32),
+                        sample_2=out_df[f'framewise_wing_r_movement_animal_{id}'].values.astype(np.float32),
+                        time_windows=WINDOW_SIZES,
+                        fps=fps,
+                    ),
+                    columns=[
+                        f'head_wing_r_movement_pearson_500_animal_{id}',
+                        f'head_wing_r_movement_pearson_1000_animal_{id}',
+                        f'head_wing_r_movement_pearson_2000_animal_{id}',
+                        f'head_wing_r_movement_pearson_3000_animal_{id}',
+                        f'head_wing_r_movement_pearson_6000_animal_{id}',
+                    ],
+                )
+                out_df = pd.concat([out_df, head_wing_l_pearson, head_wing_r_pearson], axis=1)
+
+                out_df[f'framewise_head_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=head, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_wing_l_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=wing_l, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_wing_r_movement_animal_{id}'] = FeatureExtractionMixin.framewise_bodypart_movement(data=wing_r, px_per_mm=px_per_mm, centimeter=False)
+                out_df[f'framewise_wing_l_abdomen_distance_animal_{id}'] = FeatureExtractionMixin.bodypart_distance(bp1_coords=wing_l, bp2_coords=abdomen, px_per_mm=px_per_mm, in_centimeters=False)
+                out_df[f'framewise_wing_r_abdomen_distance_animal_{id}'] = FeatureExtractionMixin.bodypart_distance(bp1_coords=wing_r, bp2_coords=abdomen, px_per_mm=px_per_mm, in_centimeters=False)
+
+                wing_l_head_wing_r_angle_var = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'wing_l_head_wing_r_angle_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['var'])[0], columns=[f'wing_head_angle_var_125_animal_{id}', f'wing_head_angle_var_250_animal_{id}', f'wing_head_angle_var_500_animal_{id}', f'wing_head_angle_var_1000_animal_{id}', f'wing_head_angle_var_2000_animal_{id}'])
+                wing_l_head_wing_r_angle_energy = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'wing_l_head_wing_r_angle_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['absenergy'])[0], columns=[f'wing_head_angle_energy_125_animal_{id}', f'wing_head_angle_energy_250_animal_{id}', f'wing_head_angle_energy_500_animal_{id}', f'wing_head_angle_energy_1000_animal_{id}', f'wing_head_angle_energy_2000_animal_{id}'])
+                out_df = pd.concat([out_df, wing_l_head_wing_r_angle_var, wing_l_head_wing_r_angle_energy], axis=1)
+
+
+                head_movement = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_head_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'head_movement_sum_125_animal_{id}',f'head_movement_sum_250_animal_{id}', f'head_movement_sum_500_animal_{id}', f'head_movement_sum_1000_animal_{id}', f'head_movement_sum_2000_animal_{id}'])
+                wing_r_movement = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_r_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'wing_r_movement_sum_125_animal_{id}', f'wing_r_movement_sum_250_animal_{id}', f'wing_r_movement_sum_500_animal_{id}', f'wing_r_movement_sum_1000_animal_animal_{id}', f'wing_r_movement_sum_2000_animal_animal_{id}'])
+                wing_l_movement = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_wing_l_movement_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['sum'])[0], columns=[f'wing_l_movement_sum_125_animal_{id}', f'wing_l_movement_sum_250_animal_{id}', f'wing_l_movement_sum_500_animal_{id}', f'wing_l_movement_sum_1000_animal_animal_{id}', f'wing_l_movement_sum_2000_animal_animal_{id}'])
+                out_df = pd.concat([out_df, head_movement, wing_l_movement, wing_r_movement], axis=1)
+
+                animal_3d = np.stack([wing_l, wing_r, head, thorax, abdomen], axis=1)
+                out_df[f'framewise_animal_size_animal_{id}'] = get_hull_sizes(points=animal_3d, pixels_per_mm=px_per_mm)
+                size_std = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_animal_size_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['std'])[0], columns=[f'size_std_500_animal_{id}', f'size_std_1000_animal_{id}', f'size_std_2000_animal_{id}', f'size_std_3000_animal_{id}', f'size_std_6000_animal_{id}'])
+                size_mean = pd.DataFrame(TimeseriesFeatureMixin.sliding_window_stats(data=out_df[f'framewise_animal_size_animal_{id}'].values, window_sizes=WINDOW_SIZES, sample_rate=fps, statistics=['mean'])[0], columns=[f'size_mean_500_animal_{id}', f'size_mean_1000_animal_{id}', f'size_mean_2000_animal_{id}', f'size_mean_3000_animal_{id}', f'size_mean_6000_animal_{id}'])
+                out_df = pd.concat([out_df, size_std, size_mean], axis=1)
+
+                p_val_cnts = pd.DataFrame(FeatureExtractionMixin.count_values_in_range(data=p_vals, ranges=np.array([[0.0, 0.25], [0.25, 0.5], [0.5, 0.75]])), columns=[f'p_vals_0.25_animal_{id}', f'p_vals_0.50_animal_{id}', f'p_vals_0.75_animal_{id}'])
+                out_df = pd.concat([out_df, p_val_cnts], axis=1)
+
+                out_df[f'rolling_t_sizes_500_animal_{id}'] = Statistics.rolling_independent_sample_t(data=out_df[f'framewise_animal_size_animal_{id}'].values.astype(np.float32), time_window=0.5, fps=fps)
+                out_df[f'rolling_t_wing_l_movement_500_animal_{id}'] = Statistics.rolling_independent_sample_t(data=out_df[f'framewise_wing_l_movement_animal_{id}'].values.astype(np.float32), time_window=0.5, fps=fps)
+                out_df[f'rolling_t_wing_r_movement_500_animal_{id}'] = Statistics.rolling_independent_sample_t(data=out_df[f'framewise_wing_r_movement_animal_{id}'].values.astype(np.float32), time_window=0.5, fps=fps)
+                out_df[f'rolling_t_thorax_movement_500_animal_{id}'] = Statistics.rolling_independent_sample_t(data=out_df[f'framewise_thorax_movement_animal_{id}'].values.astype(np.float32), time_window=0.5, fps=fps)
+
+                out_df[f'wing_l_movement_autocorreleation_1000_animal_{id}'] = Statistics.sliding_autocorrelation(data=out_df[f'framewise_wing_l_movement_animal_{id}'].values.astype(np.float32), max_lag=4.0, time_window=1.0, fps=fps)
+                out_df[f'wing_r_movement_autocorreleation_1000_animal_{id}'] = Statistics.sliding_autocorrelation(data=out_df[f'framewise_wing_r_movement_animal_{id}'].values.astype(np.float32), max_lag=4.0, time_window=1.0, fps=fps)
+                out_df[f'head_movement_autocorreleation_1000_animal_{id}'] = Statistics.sliding_autocorrelation(data=out_df[f'framewise_head_movement_animal_{id}'].values.astype(np.float32), max_lag=4.0, time_window=1.0, fps=fps)
+
+
+                x = pd.DataFrame(Statistics.sliding_dominant_frequencies(data=out_df[f'framewise_wing_l_movement_animal_{id}'].values.astype(np.float32), fps=fps, k=1, time_windows=np.array([1.0, 3.0, 5.0]), window_function='Hamming'), columns=[f'dominant_wing_l_frequency_1000_animal_{id}', f'dominant_wing_l_frequency_3000_animal_{id}', f'dominant_wing_l_frequency_5000_animal_{id}'])
+                y = pd.DataFrame(Statistics.sliding_dominant_frequencies(data=out_df[f'framewise_wing_r_movement_animal_{id}'].values.astype(np.float32), fps=fps, k=1, time_windows=np.array([1.0, 3.0, 5.0]), window_function='Hamming'), columns=[f'dominant_wing_r_frequency_1000_animal_{id}', f'dominant_wing_r_frequency_3000_animal_{id}', f'dominant_wing_r_frequency_5000_animal_{id}'])
+                z = pd.DataFrame(Statistics.sliding_dominant_frequencies(data=out_df[f'framewise_head_movement_animal_{id}'].values.astype(np.float32), fps=fps, k=1, time_windows=np.array([1.0, 3.0, 5.0]), window_function='Hamming'), columns=[f'dominant_head_frequency_1000_animal_{id}', f'dominant_head_frequency_3000_animal_{id}', f'dominant_head_frequency_5000_animal_{id}'])
+                out_df = pd.concat([out_df, x, y, z], axis=1)
+            self.save(data=out_df, save_path=save_path)
+        stdout_success(f'Feature extraction complete. Data saved in {self.features_dir}.')
+
+    def save(self, data: pd.DataFrame, save_path: Union[str, os.PathLike]):
+        write_df(df=data, file_type='csv', save_path=save_path)
+
+
+if __name__ == "__main__" and not hasattr(sys, 'ps1'):
+    parser = argparse.ArgumentParser(description="Extract features for aggression classification in resident intruder setups.")
+    parser.add_argument('--config_path', type=str, required=True, help='Path to SimBA Project config.')
+    args = parser.parse_args()
+    runner = WingWaveFeatureExtractor(config_path=args.config_path)
+    runner.run()
+
+#
+#
+# CONFIG_PATH = r"F:\troubleshooting\sophiaa\project_folder\project_config.ini"
+#
+#
+# r = WingWaveFeatureExtractor(config_path=CONFIG_PATH)
+# r.run()
+#
+#
+
+
+

{simba_uw_tf_dev-5.2.1 → simba_uw_tf_dev-5.2.3}/simba/mixins/geometry_mixin.py

@@ -1217,7 +1217,7 @@ class GeometryMixin(object):
                                         data: np.ndarray,
                                         video_name: Optional[str] = None,
                                         animal_name: Optional[str] = None,
-                                        verbose: Optional[bool] = False,
+                                        verbose: bool = False,
                                         cap_style: Optional[Literal["round", "square", "flat"]] = "round",
                                         parallel_offset: Optional[int] = 1,
                                         pixels_per_mm: Optional[float] = None,
@@ -1291,13 +1291,13 @@ class GeometryMixin(object):
         for cnt, mp_return in enumerate(pool.imap(constants, data, chunksize=1)):
             if verbose:
                 if not video_name and not animal_name:
-                    print(f"Computing polygon batch {cnt + 1}/{len(data)}...")
+                    if verbose: stdout_information(msg=f"Computing polygon batch {cnt + 1}/{len(data)}...")
                 elif not video_name and animal_name:
-                    print(f"Computing polygon batch {cnt + 1}/{len(data)} (Animal: {animal_name})...")
+                    if verbose: stdout_information(msg=f"Computing polygon batch {cnt + 1}/{len(data)} (Animal: {animal_name})...")
                 elif video_name and not animal_name:
-                    print(f"Computing polygon batch {cnt + 1}/{len(data)} (Video: {video_name})...")
+                    if verbose: stdout_information(msg=f"Computing polygon batch {cnt + 1}/{len(data)} (Video: {video_name})...")
                 else:
-                    print(f"Computing polygon batch {cnt + 1}/{len(data)} (Video: {video_name}, Animal: {animal_name})...")
+                    if verbose: stdout_information(msg=f"Computing polygon batch {cnt + 1}/{len(data)} (Video: {video_name}, Animal: {animal_name})...")
             results.append(mp_return)
 
         timer.stop_timer()