autogaita 1.5.2__py3-none-any.whl → 1.5.5__py3-none-any.whl

autogaita_backup/dlc_gui.py

@@ -0,0 +1,359 @@
+# %% imports
+import autogaita.gui.gaita_widgets as gaita_widgets
+import autogaita.gui.gui_utils as gui_utils
+from autogaita.gui.common2D_columninfo_gui import build_column_info_window
+from autogaita.gui.common2D_advanced_config_gui import build_cfg_window
+from autogaita.gui.common2D_run_and_done_gui import build_run_and_done_windows
+from autogaita.gui.first_level_gui_utils import (
+    update_config_file,
+    extract_cfg_from_json_file,
+)
+
+import tkinter as tk
+import customtkinter as ctk
+import os
+import platform
+
+# %% global constants
+from autogaita.gui.gui_constants import (
+    DLC_FG_COLOR,
+    DLC_HOVER_COLOR,
+    TEXT_FONT_NAME,
+    TEXT_FONT_SIZE,
+    WINDOWS_TASKBAR_MAXHEIGHT,
+    AUTOGAITA_FOLDER_PATH,
+    get_widget_cfg_dict,  # function!
+)
+
+# these colors are GUI-specific - add to common widget cfg
+FG_COLOR = DLC_FG_COLOR
+HOVER_COLOR = DLC_HOVER_COLOR
+WIDGET_CFG = get_widget_cfg_dict()
+WIDGET_CFG["FG_COLOR"] = FG_COLOR
+WIDGET_CFG["HOVER_COLOR"] = HOVER_COLOR
+
+# gaita-variable related constants
+CONFIG_FILE_NAME = "dlc_gui_config.json"
+FLOAT_VARS = ["pixel_to_mm_ratio"]
+INT_VARS = [
+    "sampling_rate",
+    "x_sc_broken_threshold",
+    "y_sc_broken_threshold",
+    "bin_num",
+    "mouse_num",
+    "run_num",
+    "plot_joint_number",
+]
+LIST_VARS = [
+    "hind_joints",
+    "fore_joints",
+    "x_standardisation_joint",
+    "y_standardisation_joint",
+    "beam_hind_jointadd",
+    "beam_fore_jointadd",
+    "beam_col_left",
+    "beam_col_right",
+]
+DICT_VARS = ["angles"]
+# TK_BOOL/STR_VARS are only used for initialising widgets based on cfg file
+# (note that numbers are initialised as strings)
+TK_BOOL_VARS = [
+    "subtract_beam",
+    "dont_show_plots",
+    "convert_to_mm",
+    "x_acceleration",
+    "angular_acceleration",
+    "save_to_xls",
+    "plot_SE",
+    "standardise_y_at_SC_level",
+    "standardise_y_to_a_joint",
+    "standardise_x_coordinates",
+    "invert_y_axis",
+    "flip_gait_direction",
+    "analyse_average_x",
+    "legend_outside",
+]
+TK_STR_VARS = [
+    "mouse_num",  # (config file's) results dict
+    "run_num",
+    "root_dir",
+    "sctable_filename",
+    "data_string",
+    "beam_string",
+    "premouse_string",
+    "postmouse_string",
+    "prerun_string",
+    "postrun_string",
+    "sampling_rate",  # (config file's) cfg dict
+    "pixel_to_mm_ratio",
+    "x_sc_broken_threshold",
+    "y_sc_broken_threshold",
+    "bin_num",
+    "plot_joint_number",
+    "color_palette",
+    "results_dir",
+]
+GUI_SPECIFIC_VARS = {
+    "CONFIG_FILE_NAME": CONFIG_FILE_NAME,
+    "FLOAT_VARS": FLOAT_VARS,
+    "INT_VARS": INT_VARS,
+    "LIST_VARS": LIST_VARS,
+    "DICT_VARS": DICT_VARS,
+    "TK_BOOL_VARS": TK_BOOL_VARS,
+    "TK_STR_VARS": TK_STR_VARS,
+}
+
+
+# %% An important Note
+# I am using a global variable called cfg because I need its info to be shared
+# between root and advanced_cfg windows. This is not the object-oriented way
+# that one would do this typically. However, it works as expected since:
+# 1) cfg's values are only ever modified except @ initialisation & by widgets
+# 2) cfg's values are shared for analysis of a single and multiple video(s)
+# 3) cfg's values are passed to all functions that need them
+# 4) and (IMPORTANTLY!) just before running either (i.e. single/multi) analysis, cfg's
+#    and result's values are unpacked and assigned to "this_" dicts that are passed
+#    to the runanalysis local function. Hence, from that point onwards, only
+#    "this_" dicts are used, never cfg or result dicts themselves.
+#    ==> see donewindow for point 4)
+
+# %%............................  MAIN PROGRAM ................................
+
+
+def run_dlc_gui():
+    # ..........................................................................
+    # ......................  root window initialisation .......................
+    # ..........................................................................
+    # Check for config file
+    config_file_path = os.path.join(AUTOGAITA_FOLDER_PATH, CONFIG_FILE_NAME)
+    if not os.path.isfile(config_file_path):
+        config_file_error_msg = (
+            "dlc_gui_config.json file not found in autogaita folder.\n"
+            "Confirm that the file exists and is named correctly.\n"
+            "If not, download it again from the GitHub repository."
+        )
+        tk.messagebox.showerror(
+            title="Config File Error", message=config_file_error_msg
+        )
+        exit()
+
+    # CustomTkinter vars
+    ctk.set_appearance_mode("dark")  # Modes: system (default), light, dark
+    ctk.set_default_color_theme("green")  # Themes: blue , dark-blue, green
+    # root
+    root = ctk.CTk()
+    # make window pretty
+    screen_width = root.winfo_screenwidth()  # width of the screen
+    screen_height = root.winfo_screenheight()  # height of the screen
+    if platform.system() == "Windows":  # adjust for taskbar in windows only
+        screen_height -= WINDOWS_TASKBAR_MAXHEIGHT
+    # create root dimensions (based on fullscreen) to pass to other window-functions l8r
+    w, h, x, y = screen_width, screen_height, 0, 0
+    root_dimensions = (w, h, x, y)
+    # set the dimensions of the screen and where it is placed
+    # => have it half-wide starting at 1/4 of screen's width (dont change w & x!)
+    root.geometry(f"{int(screen_width / 2)}x{screen_height}+{int(screen_width / 4)}+0")
+    root.title("DLC GaitA")
+    gui_utils.fix_window_after_its_creation(root)
+    gui_utils.configure_the_icon(root)
+
+    # .....................  load cfg dict from config .....................
+    # use the values in the config json file for the results dictionary
+    global cfg
+    cfg = extract_cfg_from_json_file(
+        root,
+        AUTOGAITA_FOLDER_PATH,
+        CONFIG_FILE_NAME,
+        LIST_VARS,
+        DICT_VARS,
+        TK_STR_VARS,
+        TK_BOOL_VARS,
+    )
+
+    # ...............................  header ..........................................
+    # main configuration header
+    main_cfg_header_label = gaita_widgets.header_label(
+        root,
+        "Main Configuration",
+        WIDGET_CFG,
+    )
+    main_cfg_header_label.grid(row=0, column=0, columnspan=3, sticky="nsew")
+
+    # ............................  main cfg section  ..................................
+    # sampling rate
+    samprate_label, samprate_entry = gaita_widgets.label_and_entry_pair(
+        root,
+        "Sampling rate of videos in Hertz (frames/second):",
+        cfg["sampling_rate"],
+        WIDGET_CFG,
+    )
+    samprate_label.grid(row=1, column=0, columnspan=2, sticky="w")
+    samprate_entry.grid(row=1, column=2, sticky="w")
+
+    # convert pixel to mm - checkbox
+    convert_checkbox = gaita_widgets.checkbox(
+        root,
+        "Convert pixels to millimetres:",
+        cfg["convert_to_mm"],
+        WIDGET_CFG,
+    )
+    convert_checkbox.configure(
+        command=lambda: gui_utils.change_widget_state_based_on_checkbox(
+            cfg, "convert_to_mm", ratio_entry
+        ),
+    )
+    convert_checkbox.grid(row=2, column=0, columnspan=2, sticky="w")
+
+    # ratio label
+    ratio_entry = ctk.CTkEntry(
+        root,
+        textvariable=cfg["pixel_to_mm_ratio"],
+        font=(TEXT_FONT_NAME, TEXT_FONT_SIZE),
+    )
+    ratio_entry.grid(row=2, column=1, sticky="e")
+    ratio_right_string = "pixels = 1 mm"
+    ratio_right_label = ctk.CTkLabel(
+        root, text=ratio_right_string, font=(TEXT_FONT_NAME, TEXT_FONT_SIZE)
+    )
+    ratio_right_label.grid(row=2, column=2, sticky="w")
+    # to initialise the widget correctly, run this function once
+    gui_utils.change_widget_state_based_on_checkbox(cfg, "convert_to_mm", ratio_entry)
+
+    # subtract beam
+    subtract_beam_checkbox = gaita_widgets.checkbox(
+        root,
+        "Standardise y-coordinates to baseline height (requires to be tracked)",
+        cfg["subtract_beam"],
+        WIDGET_CFG,
+    )
+    subtract_beam_checkbox.grid(row=3, column=0, columnspan=3, sticky="w")
+
+    # flip gait direction
+    flip_gait_direction_box = gaita_widgets.checkbox(
+        root,
+        "Adjust x-coordinates to follow direction of movement",
+        cfg["flip_gait_direction"],
+        WIDGET_CFG,
+    )
+    flip_gait_direction_box.grid(row=4, column=0, columnspan=3, sticky="w")
+
+    # plot plots to python
+    showplots_checkbox = gaita_widgets.checkbox(
+        root,
+        "Don't show plots in Figure GUI (save only)",
+        cfg["dont_show_plots"],
+        WIDGET_CFG,
+    )
+    showplots_checkbox.grid(row=5, column=0, columnspan=2, sticky="w")
+
+    # bin number of SC normalisation
+    bin_num_label, bin_num_entry = gaita_widgets.label_and_entry_pair(
+        root,
+        "Number of bins used to normalise the step cycle:",
+        cfg["bin_num"],
+        WIDGET_CFG,
+    )
+    bin_num_label.grid(row=6, column=0, columnspan=2, sticky="w")
+    bin_num_entry.grid(row=6, column=2, sticky="w")
+
+    # empty label 1 (for spacing)
+    empty_label_one = ctk.CTkLabel(root, text="")
+    empty_label_one.grid(row=7, column=0)
+
+    # ..........................  advanced cfg section  ................................
+    # advanced header string
+    advanced_cfg_header_label = gaita_widgets.header_label(
+        root,
+        "Advanced Configuration",
+        WIDGET_CFG,
+    )
+    advanced_cfg_header_label.grid(row=8, column=0, columnspan=3, sticky="nsew")
+
+    # column name information window
+    column_info_button = gaita_widgets.header_button(
+        root, "Customise Joints & Angles", WIDGET_CFG
+    )
+    column_info_button.configure(
+        command=lambda: build_column_info_window(root, cfg, WIDGET_CFG, root_dimensions)
+    )
+    column_info_button.grid(row=9, column=0, columnspan=3)
+
+    # advanced cfg
+    cfg_window_button = gaita_widgets.header_button(
+        root, "Advanced Configuration", WIDGET_CFG
+    )
+    cfg_window_button.configure(
+        command=lambda: build_cfg_window(root, cfg, WIDGET_CFG, root_dimensions)
+    )
+    cfg_window_button.grid(row=10, column=0, columnspan=3)
+
+    # empty label 2 (for spacing)
+    empty_label_two = ctk.CTkLabel(root, text="")
+    empty_label_two.grid(row=11, column=0)
+
+    # run analysis label
+    runheader_label = gaita_widgets.header_label(root, "Run Analysis", WIDGET_CFG)
+    runheader_label.grid(row=12, column=0, columnspan=3, sticky="nsew")
+
+    # single gaita button
+    onevid_button = gaita_widgets.header_button(root, "One Video", WIDGET_CFG)
+    onevid_button.configure(
+        command=lambda: build_run_and_done_windows(
+            "DLC", "single", root, cfg, WIDGET_CFG, GUI_SPECIFIC_VARS, root_dimensions
+        )
+    )
+    onevid_button.grid(row=13, column=1, sticky="ew")
+
+    # multi gaita button
+    multivid_button = gaita_widgets.header_button(root, "Batch Analysis", WIDGET_CFG)
+    multivid_button.configure(
+        command=lambda: build_run_and_done_windows(
+            "DLC", "multi", root, cfg, WIDGET_CFG, GUI_SPECIFIC_VARS, root_dimensions
+        )
+    )
+    multivid_button.grid(row=14, column=1, sticky="ew")
+
+    # empty label 2 (for spacing)
+    empty_label_two = ctk.CTkLabel(root, text="")
+    empty_label_two.grid(row=15, column=0)
+
+    # close & exit button
+    exit_button = gaita_widgets.exit_button(root, WIDGET_CFG)
+    exit_button.configure(
+        command=lambda: (
+            # results variable is only defined later in populate_run_window()
+            # therefore only cfg settings will be updated
+            update_config_file(
+                "results dict not defined yet",
+                cfg,
+                AUTOGAITA_FOLDER_PATH,
+                CONFIG_FILE_NAME,
+                LIST_VARS,
+                DICT_VARS,
+                TK_STR_VARS,
+                TK_BOOL_VARS,
+            ),
+            root.withdraw(),
+            root.after(5000, root.destroy),
+        ),
+    )
+    exit_button.grid(row=16, column=0, columnspan=3)
+
+    # # .........................  widget configuration  ...............................
+
+    # first maximise everything according to sticky
+    # => Silent_Creme is some undocumented option that makes stuff uniform
+    #   see: https://stackoverflow.com/questions/45847313/tkinter-grid-rowconfigure-weight-doesnt-work
+    root.columnconfigure(list(range(3)), weight=1, uniform="Silent_Creme")
+    root.rowconfigure(list(range(17)), weight=1, uniform="Silent_Creme")
+
+    # then un-maximise main config rows to have them grouped together
+    root.rowconfigure(list(range(1, 7)), weight=0)
+
+    # main loop
+    root.mainloop()
+
+
+# %% what happens if we hit run
+if __name__ == "__main__":
+    run_dlc_gui()

autogaita_backup/sleap_1_preparation.py

@@ -0,0 +1,303 @@
+# %% imports
+from autogaita.resources.utils import write_issues_to_textfile
+from autogaita.common2D.common2D_1_preparation import (
+    check_and_expand_cfg,
+    flip_mouse_body,
+)
+import os
+import shutil
+import json
+import pandas as pd
+import numpy as np
+import h5py
+import pdb
+
+# %% constants
+from autogaita.resources.constants import (
+    TIME_COL,
+    ISSUES_TXT_FILENAME,
+    CONFIG_JSON_FILENAME,
+)
+
+
+# %% workflow step #1 - preparation
+
+
+def some_prep(info, folderinfo, cfg):
+    """Preparation of the data & cfg file for later analyses"""
+
+    # ............................  unpack stuff  ......................................
+    # => DON'T unpack (joint) cfg-keys that are tested later by check_and_expand_cfg
+    # SLEAP-specific NOTE
+    # => I commented out vars that we dont need but might need in the future
+    name = info["name"]
+    results_dir = info["results_dir"]
+    data_string = folderinfo["data_string"]
+    beam_string = folderinfo["beam_string"]
+    sampling_rate = cfg["sampling_rate"]
+
+    # VERY
+    # VERY
+    # VERY
+    # IMPORTANT NOTE
+
+    # => subtract_beam is hardcoded to False until I have data that allows me to test
+    #    it properly (same for gait direction flipping @ end of this function)
+    cfg["subtract_beam"] = False
+    subtract_beam = cfg["subtract_beam"]
+    convert_to_mm = cfg["convert_to_mm"]
+    pixel_to_mm_ratio = cfg["pixel_to_mm_ratio"]
+    standardise_y_at_SC_level = cfg["standardise_y_at_SC_level"]
+    # invert_y_axis = cfg["invert_y_axis"]
+    flip_gait_direction = cfg["flip_gait_direction"]
+    analyse_average_x = cfg["analyse_average_x"]
+    standardise_x_coordinates = cfg["standardise_x_coordinates"]
+    standardise_y_to_a_joint = cfg["standardise_y_to_a_joint"]
+
+    # .............................  move data  ........................................
+    # => see if we can delete a previous runs results folder if existant. if not, it's a
+    #    bit ugly since we only update results if filenames match...
+    # => for example if angle acceleration not wanted in current run, but was stored in
+    #    previous run, the previous run's figure is in the folder
+    # => inform the user and leave this as is
+    if os.path.exists(results_dir):
+        try:
+            shutil.rmtree(results_dir)
+            move_data_to_folders(info, folderinfo)
+        except OSError:
+            move_data_to_folders(info, folderinfo)
+            unable_to_rm_resdir_error = (
+                "\n***********\n! WARNING !\n***********\n"
+                + "Unable to remove previous Results subfolder of ID: "
+                + name
+                + "!\n Results will only be updated if filenames match!"
+            )
+            print(unable_to_rm_resdir_error)
+            write_issues_to_textfile(unable_to_rm_resdir_error, info)
+    else:
+        move_data_to_folders(info, folderinfo)
+
+    # .......  initialise Issues.txt & quick check for file existence  .................
+    # Issues.txt - delete if saved in a previous run
+    issues_txt_path = os.path.join(results_dir, ISSUES_TXT_FILENAME)
+    if os.path.exists(issues_txt_path):
+        os.remove(issues_txt_path)
+    # read data & beam
+    if not os.listdir(results_dir):
+        no_files_error = (
+            "\n******************\n! CRITICAL ERROR !\n******************\n"
+            + "Unable to identify ANY RELEVANT FILES for "
+            + name
+        )
+        write_issues_to_textfile(no_files_error, info)
+        print(no_files_error)
+        return
+
+    # ............................  import data  .......................................
+    # initialise dfs for user error handling
+    datadf = pd.DataFrame(data=None)
+    datadf_duplicate_error = ""
+    beamdf = pd.DataFrame(data=None)
+    beamdf_duplicate_error = ""
+    # loop through folder and import data
+    for filename in os.listdir(results_dir):
+        if name + data_string + ".h5" in filename:
+            if datadf.empty:
+                datadf = h5_to_df(results_dir, filename)
+            else:
+                datadf_duplicate_error = (
+                    "\n******************\n! CRITICAL ERROR !\n******************\n"
+                    + "Multiple DATA .h5 files found for "
+                    + name
+                    + "!\nPlease make sure to only have one data file per ID."
+                )
+        if subtract_beam and name + beam_string + ".h5" in filename:
+            if beamdf.empty:
+                beamdf = h5_to_df(results_dir, filename)
+            else:
+                beamdf_duplicate_error = (
+                    "\n******************\n! CRITICAL ERROR !\n******************\n"
+                    + "Multiple BEAM .h5 files found for "
+                    + name
+                    + "!\nPlease make sure to only have one beam file per ID."
+                )
+    # handle errors now
+    import_error_message = ""
+    if datadf_duplicate_error:
+        import_error_message += datadf_duplicate_error
+    if datadf.empty:
+        import_error_message += (
+            "\n******************\n! CRITICAL ERROR !\n******************\n"
+            + "No DATA .h5 file found for "
+            + name
+            + "!\nTry again!"
+        )
+    if subtract_beam:
+        if beamdf_duplicate_error:
+            import_error_message += beamdf_duplicate_error
+        if beamdf.empty:
+            import_error_message += (
+                "\n******************\n! CRITICAL ERROR !\n******************\n"
+                + "No BEAM .h5 file found for "
+                + name
+                + "!\nTry again!"
+            )
+    if import_error_message:
+        write_issues_to_textfile(import_error_message, info)
+        print(import_error_message)
+        return  # make sure to stop execution if there is an issue!
+    # create "data" as floats and depending on whether we subtracted beam or not
+    if subtract_beam:
+        data = pd.concat([datadf, beamdf], axis=1)
+    else:
+        data = datadf.copy(deep=True)
+    data = data.astype(float)
+
+    # ................  final data checks, conversions & additions  ....................
+    # IMPORTANT - MAIN TESTS OF USER-INPUT VALIDITY OCCUR HERE!
+    # => UNPACK VARS FROM CFG THAT ARE TESTED BY check_and_expand HERE, NOT EARLIER!
+    cfg = check_and_expand_cfg(data, cfg, info)
+    if cfg is None:  # some critical error occured
+        return
+    hind_joints = cfg["hind_joints"]
+    fore_joints = cfg["fore_joints"]
+    angles = cfg["angles"]
+    beam_hind_jointadd = cfg["beam_hind_jointadd"]
+    beam_fore_jointadd = cfg["beam_fore_jointadd"]
+    direction_joint = cfg["direction_joint"]
+    # important to unpack to vars hand not to cfg since cfg is overwritten in multiruns!
+    x_standardisation_joint = cfg["x_standardisation_joint"][0]
+    y_standardisation_joint = cfg["y_standardisation_joint"][0]
+    # store config json file @ group path
+    # !!! NU - do this @ mouse path!
+    group_path = results_dir.split(name)[0]
+    config_json_path = os.path.join(group_path, CONFIG_JSON_FILENAME)
+    config_vars_to_json = {
+        "sampling_rate": sampling_rate,
+        "convert_to_mm": convert_to_mm,
+        "standardise_y_at_SC_level": standardise_y_at_SC_level,
+        "analyse_average_x": analyse_average_x,
+        "standardise_x_coordinates": standardise_x_coordinates,
+        "x_standardisation_joint": x_standardisation_joint,
+        "standardise_y_to_a_joint": standardise_y_to_a_joint,
+        "y_standardisation_joint": y_standardisation_joint,
+        "hind_joints": hind_joints,
+        "fore_joints": fore_joints,
+        "angles": angles,
+        "tracking_software": "SLEAP",
+    }
+    # note - using "w" will overwrite/truncate file, thus no need to remove it if exists
+    with open(config_json_path, "w") as config_json_file:
+        json.dump(config_vars_to_json, config_json_file, indent=4)
+    # if we don't have a beam to subtract, standardise y to a joint's or global ymin = 0
+    if not subtract_beam:
+        y_min = float("inf")
+        y_cols = [col for col in data.columns if col.endswith("y")]
+        if standardise_y_to_a_joint:
+            y_min = data[y_standardisation_joint + "y"].min()
+        else:
+            y_min = data[y_cols].min().min()
+        data[y_cols] -= y_min
+    # convert pixels to millimeters
+    if convert_to_mm:
+        for column in data.columns:
+            # if might be unnecessary but I'm cautious as I don't know SLEAP data much
+            if column.endswith("x") or column.endswith("y"):
+                data[column] = data[column] / pixel_to_mm_ratio
+
+    # IMPORTANT NOTE
+    # => I keep gait direction flipping commented out until receiving data that allows
+    #    me to test it properly
+    # => Note that subtract_beam is hardcoded to False above for the same reason
+
+    pdb.set_trace()
+
+    # quick warning if cfg is set to not flip gait direction but to standardise x
+    if not flip_gait_direction and standardise_x_coordinates:
+        message = (
+            "\n***********\n! WARNING !\n***********\n"
+            + "You are standardising x-coordinates without standardising the direction "
+            + "of gait (e.g. all walking from right to left)."
+            + "\nThis can be correct if you are doing things like treadmill walking "
+            + "but can lead to unexpected behaviour otherwise!"
+            + "\nMake sure you know what you are doing!"
+        )
+        print(message)
+        write_issues_to_textfile(message, info)
+
+    # check gait direction
+    # data = check_gait_direction(data, direction_joint, flip_gait_direction, info)
+    data["Flipped"] = False  # because of IMPORTANT NOTE above
+
+    # subtract the beam from the joints to standardise y
+    # => bc. we simulate that all mice run from left to right, we can write:
+    #     (note that we also flip beam x columns, but never y-columns!)
+    # => & bc. we multiply y values by *-1 earlier, it's a neg_num - - neg_num
+    #    pushing it towards zero.
+    # => using list(set()) to ensure that we don't have duplicate values (if users
+    #    should have provided them in both cfg vars by misstake)
+    # => beam_col_left and right is provided by users
+    if subtract_beam:
+        # note beam_col_left/right are always lists in cfg!
+        beam_col_left = cfg["beam_col_left"][0]
+        beam_col_right = cfg["beam_col_right"][0]
+        for joint in list(set(hind_joints + beam_hind_jointadd)):
+            data[joint + "y"] = data[joint + "y"] - data[beam_col_left + "y"]
+        for joint in list(set(fore_joints + beam_fore_jointadd)):
+            data[joint + "y"] = data[joint + "y"] - data[beam_col_right + "y"]
+        data.drop(columns=list(beamdf.columns), inplace=True)  # beam not needed anymore
+    # add Time
+    data[TIME_COL] = data.index * (1 / sampling_rate)
+    # reorder the columns we added
+    cols = [TIME_COL, "Flipped"]
+    data = data[cols + [c for c in data.columns if c not in cols]]
+    return data
+
+
+# ..............................  helper functions  ....................................
+
+
+def move_data_to_folders(info, folderinfo):
+    """Copy data to new results_dir"""
+    # unpack
+    name = info["name"]
+    results_dir = info["results_dir"]
+    root_dir = folderinfo["root_dir"]
+    data_string = folderinfo["data_string"]
+    os.makedirs(results_dir)
+    # move h5 files
+    for filename in os.listdir(root_dir):
+        if name + data_string + ".h5" in filename:
+            shutil.copy2(
+                os.path.join(root_dir, filename),
+                os.path.join(results_dir, filename),
+            )
+
+
+def h5_to_df(results_dir, filename):
+    """Convert a SLEAP h5 file to the pandas dataframe used in gaita"""
+    df = pd.DataFrame(data=None)
+    with h5py.File(os.path.join(results_dir, filename), "r") as f:
+        locations = f["tracks"][:].T
+        node_names = [n.decode() for n in f["node_names"][:]]
+        df.index = np.arange(np.shape(locations)[0])
+        for node_idx, node_name in enumerate(node_names):
+            for c, coord in enumerate(["x", "y"]):
+                df[node_name + " " + coord] = locations[:, node_idx, c, 0]
+    return df
+
+
+def check_gait_direction(data, direction_joint, flip_gait_direction, info):
+    """Check direction of gait - reverse it if needed"""
+
+    data["Flipped"] = False
+
+    # beloow if condition means that the mouse ran from right to left
+    # => in this case we flip
+    if np.median(data[direction_joint + "x"][: len(data) // 2]) > np.median(
+        data[direction_joint + "x"][len(data) // 2 :]
+    ):
+        if flip_gait_direction:
+            data = flip_mouse_body(data, info)
+            data["Flipped"] = True
+    return data