boris-behav-obs 8.16.6__py3-none-any.whl → 9.7.1__py3-none-any.whl

boris/observation.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -20,15 +20,14 @@ This file is part of BORIS.
 
 """
 
-import glob
 import logging
 import os
 import pandas as pd
 import pathlib as pl
 
-from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QColor
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
     QDialog,
     QVBoxLayout,
     QHBoxLayout,
@@ -46,7 +45,7 @@ from PyQt5.QtWidgets import (
 )
 
 from . import config as cfg
-from . import dialog, duration_widget, plot_data_module, project_functions
+from . import dialog, plot_data_module, project_functions
 from . import utilities as util
 from . import gui_utilities
 from .observation_ui import Ui_Form
@@ -97,7 +96,7 @@ class AssignConverter(QDialog):
 
 
 class Observation(QDialog, Ui_Form):
-    def __init__(self, tmp_dir, project_path="", converters={}, time_format=cfg.S, parent=None):
+    def __init__(self, tmp_dir: str, project_path: str = "", converters: dict = {}, time_format: str = cfg.S, parent=None):
         """
         Args:
             tmp_dir (str): path of temporary directory
@@ -111,22 +110,31 @@ class Observation(QDialog, Ui_Form):
         self.project_path = project_path
         self.converters = converters
         self.time_format = time_format
-        self.observation_time_interval = [0, 0]
+        self.observation_time_interval: tuple = [0, 0]
         self.mem_dir = ""
         self.test = None
 
         self.setupUi(self)
 
         # insert duration widget for time offset
-        self.obs_time_offset = duration_widget.Duration_widget(0)
+        # self.obs_time_offset = duration_widget.Duration_widget(0)
+        self.obs_time_offset = dialog.get_time_widget(0)
         self.horizontalLayout_6.insertWidget(1, self.obs_time_offset)
+        self.obs_time_offset.setEnabled(False)
+
+        # time offset
+        self.cb_time_offset.stateChanged.connect(self.cb_time_offset_changed)
+        # date offset
+        """self.cb_date_offset.stateChanged.connect(self.cb_date_offset_changed)"""
 
         # observation type
         self.rb_media_files.toggled.connect(self.obs_type_changed)
         self.rb_live.toggled.connect(self.obs_type_changed)
         self.rb_images.toggled.connect(self.obs_type_changed)
 
-        menu_items = [
+        # button menu for media
+
+        add_media_menu_items = [
             "media abs path|with absolute path",
             "media rel path|with relative path",
             {
@@ -136,23 +144,68 @@ class Observation(QDialog, Ui_Form):
                 ]
             },
         ]
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.add_media(mode=x.statusTip()))
-        self.add_button_menu(menu_items, menu)
-        self.pbAddVideo.setMenu(menu)
+
+        self.media_menu = QMenu()
+        # Add actions to the menu
+        """
+        self.action1 = QAction("with absolute path")
+        self.action2 = QAction("with relative path")
+        self.action3 = QAction("directory with absolute path")
+        self.action4 = QAction("directory with relative path")
+
+        self.menu.addAction(self.action1)
+        self.menu.addAction(self.action2)
+        self.menu.addAction(self.action3)
+        self.menu.addAction(self.action4)
+
+        # Connect actions to functions
+        self.action1.triggered.connect(lambda: self.add_media(mode="media abs path|with absolute path"))
+        self.action2.triggered.connect(lambda: self.add_media(mode="media rel path|with relative path"))
+        self.action3.triggered.connect(lambda: self.add_media(mode="dir abs path|with absolute path"))
+        self.action4.triggered.connect(lambda: self.add_media(mode="dir rel path|wih relative path"))
+        """
+
+        self.media_menu.triggered.connect(lambda x: self.add_media(mode=x.statusTip()))
+        self.add_button_menu(add_media_menu_items, self.media_menu)
+        self.pbAddVideo.setMenu(self.media_menu)
 
         self.pbRemoveVideo.clicked.connect(self.remove_media)
 
-        # add data file
+        # button menu for data file
         data_menu_items = [
             "data abs path|with absolute path",
             "data rel path|with relative path",
         ]
 
-        menu_data = QMenu()
-        menu_data.triggered.connect(lambda x: self.add_data_file(mode=x.statusTip()))
-        self.add_button_menu(data_menu_items, menu_data)
-        self.pb_add_data_file.setMenu(menu_data)
+        self.menu_data = QMenu()
+
+        # Add actions to the menu
+        """
+        self.data_action1 = QAction("with absolute path")
+        self.data_action2 = QAction("with relative path")
+        self.menu_data.addAction(self.data_action1)
+        self.menu_data.addAction(self.data_action2)
+
+        # Connect actions to functions
+        self.data_action1.triggered.connect(lambda: self.add_data_file(mode="data abs path|with absolute path"))
+        self.data_action2.triggered.connect(lambda: self.add_data_file(mode="data rel path|with relative path"))
+        """
+
+        self.menu_data.triggered.connect(lambda x: self.add_data_file(mode=x.statusTip()))
+        self.add_button_menu(data_menu_items, self.menu_data)
+        self.pb_add_data_file.setMenu(self.menu_data)
+
+        # button menu for images
+        images_menu_items = [
+            "images abs path|with absolute path",
+            "images rel path|with relative path",
+        ]
+
+        self.menu_images = QMenu()
+
+        self.menu_images.triggered.connect(lambda x: self.add_images_directory(mode=x.statusTip()))
+        self.add_button_menu(images_menu_items, self.menu_images)
+        self.pb_add_directory.setMenu(self.menu_images)
 
         self.pb_remove_data_file.clicked.connect(self.remove_data_file)
         self.pb_view_data_head.clicked.connect(self.view_data_file_head_tail)
@@ -163,6 +216,7 @@ class Observation(QDialog, Ui_Form):
 
         self.cbVisualizeSpectrogram.clicked.connect(self.extract_wav)
         self.cb_visualize_waveform.clicked.connect(self.extract_wav)
+
         self.cb_observation_time_interval.clicked.connect(self.limit_time_interval)
 
         self.pbSave.clicked.connect(self.pbSave_clicked)
@@ -171,20 +225,23 @@ class Observation(QDialog, Ui_Form):
 
         self.tw_data_files.cellDoubleClicked[int, int].connect(self.tw_data_files_cellDoubleClicked)
 
-        self.mediaDurations, self.mediaFPS, self.mediaHasVideo, self.mediaHasAudio = {}, {}, {}, {}
+        self.mediaDurations, self.mediaFPS, self.mediaHasVideo, self.mediaHasAudio, self.media_creation_time = {}, {}, {}, {}, {}
 
-        self.cbVisualizeSpectrogram.setEnabled(False)
-        self.cb_visualize_waveform.setEnabled(False)
-        self.cb_observation_time_interval.setEnabled(True)
+        for w in (
+            self.cbVisualizeSpectrogram,
+            self.cb_visualize_waveform,
+            self.cb_observation_time_interval,
+            self.cb_media_creation_date_as_offset,
+            self.cbCloseCurrentBehaviorsBetweenVideo,
+        ):
+            w.setEnabled(False)
 
-        # disabled due to problem when video goes back
-        self.cbCloseCurrentBehaviorsBetweenVideo.setChecked(False)
-        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
+        self.cb_observation_time_interval.setEnabled(True)
 
         self.cb_start_from_current_time.stateChanged.connect(self.cb_start_from_current_time_changed)
 
         # images
-        self.pb_add_directory.clicked.connect(self.add_images_directory)
+        # self.pb_add_directory.clicked.connect(self.add_images_directory)
         self.pb_remove_directory.clicked.connect(self.remove_images_directory)
 
         self.tabWidget.setCurrentIndex(0)
@@ -192,6 +249,60 @@ class Observation(QDialog, Ui_Form):
         # geometry
         gui_utilities.restore_geometry(self, "new observation", (800, 650))
 
+    # def cb_date_offset_changed(self):
+    #    """
+    #    activate/desactivate time value
+    #    """
+    #    self.de_date_offset.setEnabled(self.cb_date_offset.isChecked())
+
+    def check_media_creation_date(self):
+        """
+        check if all media files contain creation date time
+        search in metadata then in filename
+        """
+
+        creation_date_not_found: list = []
+        flag_filename_used = False
+
+        self.media_creation_time = {}
+
+        if self.cb_media_creation_date_as_offset.isChecked():
+            for row in range(self.twVideo1.rowCount()):
+                if self.twVideo1.item(row, 2).text():  # media file path
+                    date_time_original = util.extract_video_creation_date(
+                        project_functions.full_path(self.twVideo1.item(row, 2).text(), self.project_path)
+                    )
+                    if date_time_original is None:
+                        date_time_file_name = util.extract_date_time_from_file_name(self.twVideo1.item(row, 2).text())
+                        if date_time_file_name is None:
+                            creation_date_not_found.append(self.twVideo1.item(row, 2).text())
+                        else:
+                            self.media_creation_time[self.twVideo1.item(row, 2).text()] = date_time_file_name
+                            flag_filename_used = True
+                    else:
+                        self.media_creation_time[self.twVideo1.item(row, 2).text()] = date_time_original
+
+        if creation_date_not_found:
+            QMessageBox.warning(
+                self, cfg.programName, "The creation date time was not found for all media file(s).\nThe option was disabled."
+            )
+            self.cb_media_creation_date_as_offset.setChecked(False)
+            self.media_creation_time = {}
+            return 1
+
+        elif flag_filename_used:
+            QMessageBox.information(
+                self, cfg.programName, "The creation date time was not found in metadata. The media file name(s) was/were used"
+            )
+
+        return 0
+
+    def cb_time_offset_changed(self):
+        """
+        activate/desactivate date value
+        """
+        self.obs_time_offset.setEnabled(self.cb_time_offset.isChecked())
+
     def use_media_file_name_as_obsid(self) -> None:
         """
         set observation id with the media file name value (without path)
@@ -200,7 +311,7 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(self, cfg.programName, "A media file must be loaded in player #1")
             return
 
-        first_media_file = ""
+        first_media_file: str = ""
         for row in range(self.twVideo1.rowCount()):
             if int(self.twVideo1.cellWidget(row, 0).currentText()) == 1:
                 first_media_file = self.twVideo1.item(row, 2).text()
@@ -235,11 +346,39 @@ class Observation(QDialog, Ui_Form):
         # hide 'limit observation to time interval' for images
         self.cb_observation_time_interval.setEnabled(not self.rb_images.isChecked())
 
-    def add_images_directory(self):
+    def add_images_directory(self, mode: str):
         """
         add path to images directory
         """
-        dir_path = QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))
+
+        if mode.split("|")[0] not in (
+            "images abs path",
+            "images rel path",
+        ):
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                (f"Wrong mode to add a pictures directory {mode}"),
+            )
+            return
+
+        # check if project saved
+        if (" w/o" in mode or " rel " in mode) and (not self.project_file_name):
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                ("It is not possible to add a pictures directory with a relative path if the project is not already saved"),
+            )
+            return
+
+        fd = QFileDialog()
+        fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
+
+        dir_path = fd.getExistingDirectory(None, "Select directory")
+
+        if not dir_path:
+            return
+
         result = util.dir_images_number(dir_path)
         if not result.get("number of images", 0):
             response = dialog.MessageDialog(
@@ -250,7 +389,25 @@ class Observation(QDialog, Ui_Form):
             if response == "Cancel":
                 return
 
-        self.lw_images_directory.addItem(QListWidgetItem(dir_path))
+        # store directory for next usage
+        self.mem_dir = str(pl.Path(dir_path))
+
+        if " rel " in mode:
+            try:
+                pl.Path(dir_path).parent.relative_to(pl.Path(self.project_path).parent)
+            except ValueError:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    f"The directory <b>{pl.Path(dir_path).parent}</b> is not contained in <b>{pl.Path(self.project_path).parent}</b>.",
+                )
+                return
+
+        if " rel " in mode:
+            # convert to relative path (relative to BORIS project file)
+            self.lw_images_directory.addItem(QListWidgetItem(str(pl.Path(dir_path).relative_to(pl.Path(self.project_path).parent))))
+        else:
+            self.lw_images_directory.addItem(QListWidgetItem(dir_path))
         self.lb_images_info.setText(f"Number of images in {dir_path}: {result.get('number of images', 0)}")
 
     def remove_images_directory(self):
@@ -290,10 +447,14 @@ class Observation(QDialog, Ui_Form):
         """
 
         if self.cb_observation_time_interval.isChecked():
-            time_interval_dialog = dialog.Ask_time(self.time_format)
+            time_interval_dialog = dialog.Ask_time(0)
+            if self.time_format == cfg.S:
+                time_interval_dialog.time_widget.rb_seconds.setChecked(True)
+            if self.time_format == cfg.HHMMSS:
+                time_interval_dialog.time_widget.rb_time.setChecked(True)
             time_interval_dialog.time_widget.set_time(0)
             time_interval_dialog.setWindowTitle("Start observation at")
-            time_interval_dialog.label.setText("Start observation at")
+            time_interval_dialog.label.setText("<b>Start</b> observation at")
             start_time, stop_time = 0, 0
             if time_interval_dialog.exec_():
                 start_time = time_interval_dialog.time_widget.get_time()
@@ -302,7 +463,7 @@ class Observation(QDialog, Ui_Form):
                 return
             time_interval_dialog.time_widget.set_time(0)
             time_interval_dialog.setWindowTitle("Stop observation at")
-            time_interval_dialog.label.setText("Stop observation at")
+            time_interval_dialog.label.setText("<b>Stop</b> observation at")
             if time_interval_dialog.exec_():
                 stop_time = time_interval_dialog.time_widget.get_time()
             else:
@@ -316,7 +477,10 @@ class Observation(QDialog, Ui_Form):
                     return
                 self.observation_time_interval = [start_time, stop_time]
                 self.cb_observation_time_interval.setText(
-                    f"Limit observation to a time interval: {start_time} - {stop_time}"
+                    (
+                        "Limit observation to a time interval: "
+                        f"{util.smart_time_format(start_time, self.time_format)} - {util.smart_time_format(stop_time, self.time_format)}"
+                    )
                 )
         else:
             self.observation_time_interval = [0, 0]
@@ -338,9 +502,7 @@ class Observation(QDialog, Ui_Form):
 
                 if w.exec_():
                     d = {}
-                    for col_idx, cb in zip(
-                        self.tw_data_files.item(row, cfg.PLOT_DATA_COLUMNS_IDX).text().split(","), w.cbb
-                    ):
+                    for col_idx, cb in zip(self.tw_data_files.item(row, cfg.PLOT_DATA_COLUMNS_IDX).text().split(","), w.cbb):
                         if cb.currentText() != "None":
                             d[col_idx] = cb.currentText()
                     self.tw_data_files.item(row, cfg.PLOT_DATA_CONVERTERS_IDX).setText(str(d))
@@ -361,7 +523,6 @@ class Observation(QDialog, Ui_Form):
             return
 
         if self.tw_data_files.selectedIndexes() or self.tw_data_files.rowCount() == 1:
-
             if self.tw_data_files.rowCount() == 1:
                 row_idx = 0
             else:
@@ -381,9 +542,7 @@ class Observation(QDialog, Ui_Form):
             time_interval = int(self.tw_data_files.item(row_idx, cfg.PLOT_DATA_TIMEINTERVAL_IDX).text())
             time_offset = int(self.tw_data_files.item(row_idx, cfg.PLOT_DATA_TIMEOFFSET_IDX).text())
 
-            substract_first_value = self.tw_data_files.cellWidget(
-                row_idx, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX
-            ).currentText()
+            substract_first_value = self.tw_data_files.cellWidget(row_idx, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX).currentText()
 
             plot_color = self.tw_data_files.cellWidget(row_idx, cfg.PLOT_DATA_PLOTCOLOR_IDX).currentText()
 
@@ -428,6 +587,13 @@ class Observation(QDialog, Ui_Form):
         else:
             QMessageBox.warning(self, cfg.programName, "Select a data file")
 
+    def not_editable_column_color(self):
+        """
+        return a color for the not editable column
+        """
+        window_color = QApplication.instance().palette().window().color()
+        return QColor(window_color.red() - 5, window_color.green() - 5, window_color.blue() - 5)
+
     def add_data_file(self, mode: str):
         """
         user select a data file to be plotted synchronously with media file
@@ -461,19 +627,14 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.warning(
                 self,
                 cfg.programName,
-                (
-                    "It is not yet possible to plot more than 2 external data sources"
-                    "This limitation will be removed in future"
-                ),
+                ("It is not yet possible to plot more than 2 external data sourcesThis limitation will be removed in future"),
             )
             return
 
         fd = QFileDialog()
         fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
 
-        fn = fd.getOpenFileName(self, "Add data file", "", "All files (*)")
-        file_name = fn[0] if type(fn) is tuple else fn
-
+        file_name, _ = fd.getOpenFileName(self, "Add data file", "", "All files (*)")
         if not file_name:
             return
 
@@ -490,16 +651,14 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(self, cfg.programName, "This file does not contain a constant number of columns")
             return
 
-        header, footer = util.return_file_header_footer(
-            file_name, file_row_number=file_parameters["rows number"], row_number=5
-        )
+        header, footer = util.return_file_header_footer(file_name, file_row_number=file_parameters["rows number"], row_number=5)
 
         if not header:
             QMessageBox.critical(self, cfg.programName, f"Error on file {pl.Path(file_name).name}")
             return
 
         w = dialog.View_data()
-        w.setWindowTitle(f"View data")
+        w.setWindowTitle("View data")
         w.lb.setText(f"View first and last rows of <b>{pl.Path(file_name).name}</b> file")
 
         w.tw.setColumnCount(file_parameters["fields number"])
@@ -518,9 +677,7 @@ class Observation(QDialog, Ui_Form):
 
         # stats
         try:
-            df = pd.read_csv(
-                file_name, sep=file_parameters["separator"], header=None if not file_parameters["has header"] else [0]
-            )
+            df = pd.read_csv(file_name, sep=file_parameters["separator"], header=None if not file_parameters["has header"] else [0])
             # set columns names to based 1 index
             if not file_parameters["has header"]:
                 df.columns = range(1, len(df.columns) + 1)
@@ -556,7 +713,6 @@ class Observation(QDialog, Ui_Form):
         self.tw_data_files.setRowCount(self.tw_data_files.rowCount() + 1)
 
         if " rel " in mode:
-
             try:
                 file_path = str(pl.Path(file_name).relative_to(pl.Path(self.project_path).parent))
             except ValueError:
@@ -585,15 +741,14 @@ class Observation(QDialog, Ui_Form):
             item = QTableWidgetItem(value)
             if col_idx == cfg.PLOT_DATA_CONVERTERS_IDX:
                 item.setFlags(Qt.ItemIsEnabled)
-                item.setBackground(QColor(230, 230, 230))
+                # item.setBackground(QColor(230, 230, 230))
+                item.setBackground(self.not_editable_column_color())
             self.tw_data_files.setItem(self.tw_data_files.rowCount() - 1, col_idx, item)
 
         # substract first value
         combobox = QComboBox()
         combobox.addItems(["True", "False"])
-        self.tw_data_files.setCellWidget(
-            self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX, combobox
-        )
+        self.tw_data_files.setCellWidget(self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX, combobox)
 
         # plot line color
         combobox = QComboBox()
@@ -622,18 +777,16 @@ class Observation(QDialog, Ui_Form):
         if "error" in file_parameters:
             QMessageBox.critical(self, cfg.programName, f"Error on file {data_file_path}: {file_parameters['error']}")
             return
-        header, footer = util.return_file_header_footer(
-            data_file_path, file_row_number=file_parameters["rows number"], row_number=5
-        )
+        header, footer = util.return_file_header_footer(data_file_path, file_row_number=file_parameters["rows number"], row_number=5)
 
         if not header:
             QMessageBox.critical(self, cfg.programName, f"Error on file {pl.Path(data_file_path).name}")
             return
 
         w = dialog.View_data()
-        w.setWindowTitle(f"View data")
+        w.setWindowTitle("View data")
         w.lb.setText(f"View first and last rows of <b>{pl.Path(data_file_path).name}</b> file")
-        w.pbOK.setText("Close")
+        w.pbOK.setText(cfg.CLOSE)
         w.label.setText("Index of columns to plot")
         w.le.setEnabled(False)
         w.le.setText(columns_to_plot)
@@ -676,73 +829,139 @@ class Observation(QDialog, Ui_Form):
         extract wav of all media files loaded in player #1
         """
 
-        if self.cbVisualizeSpectrogram.isChecked() or self.cb_visualize_waveform.isChecked():
-            flag_wav_produced = False
-            # check if player 1 is selected
-            flag_player1 = False
-            for row in range(self.twVideo1.rowCount()):
-                if self.twVideo1.cellWidget(row, 0).currentText() == "1":
-                    flag_player1 = True
+        if not self.cbVisualizeSpectrogram.isChecked() and not self.cb_visualize_waveform.isChecked():
+            return
 
-            if not flag_player1:
-                QMessageBox.critical(self, cfg.programName, "The player #1 is not selected")
-                self.cbVisualizeSpectrogram.setChecked(False)
-                self.cb_visualize_waveform.setChecked(False)
-                return
-            """
-            if dialog.MessageDialog(programName, ("You choose to visualize the spectrogram or waveform for the media in player #1.<br>"
-                                                  "The WAV will be extracted from the media files, be patient"), [YES, NO]) == YES:
-            """
-            if True:
+        flag_wav_produced = False
+        # check if player 1 is selected
+        flag_player1 = False
+        for row in range(self.twVideo1.rowCount()):
+            if self.twVideo1.cellWidget(row, 0).currentText() == "1":
+                flag_player1 = True
 
-                w = dialog.Info_widget()
-                w.resize(350, 100)
-                # w.setWindowFlags(Qt.WindowStaysOnTopHint)
-                w.setWindowTitle("BORIS")
-                w.label.setText("Extracting WAV from media files...")
+        if not flag_player1:
+            QMessageBox.critical(self, cfg.programName, "The player #1 is not selected")
+            self.cbVisualizeSpectrogram.setChecked(False)
+            self.cb_visualize_waveform.setChecked(False)
+            return
 
-                for row in range(self.twVideo1.rowCount()):
-                    # check if player 1
-                    if self.twVideo1.cellWidget(row, 0).currentText() != "1":
-                        continue
+        if True:
+            w = dialog.Info_widget()
+            w.resize(350, 100)
+            # w.setWindowFlags(Qt.WindowStaysOnTopHint)
+            w.setWindowTitle("BORIS")
+            w.label.setText("Extracting WAV from media files...")
 
-                    media_file_path = project_functions.full_path(
-                        self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text(), self.project_path
-                    )
-                    if self.twVideo1.item(row, cfg.HAS_AUDIO_IDX).text() == "False":
+            for row in range(self.twVideo1.rowCount()):
+                # check if player 1
+                if self.twVideo1.cellWidget(row, 0).currentText() != "1":
+                    continue
+
+                media_file_path = project_functions.full_path(self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text(), self.project_path)
+                if self.twVideo1.item(row, cfg.HAS_AUDIO_IDX).text() == "False":
+                    QMessageBox.critical(self, cfg.programName, f"The media file {media_file_path} does not seem to have audio")
+                    flag_wav_produced = False
+                    break
+
+                if os.path.isfile(media_file_path):
+                    w.show()
+                    QApplication.processEvents()
+
+                    if util.extract_wav(self.ffmpeg_bin, media_file_path, self.tmp_dir) == "":
                         QMessageBox.critical(
-                            self, cfg.programName, f"The media file {media_file_path} does not seem to have audio"
+                            self,
+                            cfg.programName,
+                            f"Error during extracting WAV of the media file {media_file_path}",
                         )
                         flag_wav_produced = False
                         break
 
-                    if os.path.isfile(media_file_path):
-                        w.show()
-                        QApplication.processEvents()
+                    w.hide()
 
-                        if util.extract_wav(self.ffmpeg_bin, media_file_path, self.tmp_dir) == "":
-                            QMessageBox.critical(
-                                self,
-                                cfg.programName,
-                                f"Error during extracting WAV of the media file {media_file_path}",
-                            )
-                            flag_wav_produced = False
-                            break
+                    flag_wav_produced = True
+                else:
+                    QMessageBox.warning(self, cfg.programName, f"<b>{media_file_path}</b> file not found")
+
+            if not flag_wav_produced:
+                self.cbVisualizeSpectrogram.setChecked(False)
+                self.cb_visualize_waveform.setChecked(False)
 
-                        w.hide()
+    def check_creation_date(self) -> int:
+        """
+        check if media file exists
+        check if Creation Date tag is present in metadata of media file
 
-                        flag_wav_produced = True
-                    else:
-                        QMessageBox.warning(self, cfg.programName, f"<b>{media_file_path}</b> file not found")
+        Returns:
+            int: 0 if OK else error code: 1 -> media file date not used, 2 -> media file not found
 
-                if not flag_wav_produced:
-                    self.cbVisualizeSpectrogram.setChecked(False)
-                    self.cb_visualize_waveform.setChecked(False)
-            """
+        """
+
+        # check if media files exist
+
+        media_not_found_list: list = []
+        for row in range(self.twVideo1.rowCount()):
+            if not pl.Path(self.twVideo1.item(row, 2).text()).is_file():
+                media_not_found_list.append(self.twVideo1.item(row, 2).text())
+
+        """
+        if media_list:
+            dlg = dialog.Results_dialog()
+            dlg.setWindowTitle("BORIS")
+            dlg.pbOK.setText("OK")
+            dlg.pbCancel.setVisible(False)
+            dlg.ptText.clear()
+            dlg.ptText.appendHtml(
+                (
+                    "Some media file(s) were not found:<br>"
+                    f"{'<br>'.join(media_list)}<br><br>"
+                    "You cannot select the <b>Use the media creation date/time option</b>."
+                )
+            )
+            dlg.ptText.moveCursor(QTextCursor.Start)
+            ret = dlg.exec_()
+        """
+
+        """
+        not_tagged_media_list: list = []
+        for row in range(self.twVideo1.rowCount()):
+            if self.twVideo1.item(row, 2).text() not in media_not_found_list:
+                media_info = util.accurate_media_analysis(self.ffmpeg_bin, self.twVideo1.item(row, 2).text())
+                if cfg.MEDIA_CREATION_TIME not in media_info or media_info[cfg.MEDIA_CREATION_TIME] == cfg.NA:
+                    not_tagged_media_list.append(self.twVideo1.item(row, 2).text())
+                else:
+                    creation_time_epoch = int(dt.datetime.strptime(media_info[cfg.MEDIA_CREATION_TIME], "%Y-%m-%d %H:%M:%S").timestamp())
+                    self.media_creation_time[self.twVideo1.item(row, 2).text()] = creation_time_epoch
+
+        if not_tagged_media_list:
+            dlg = dialog.Results_dialog()
+            dlg.setWindowTitle("BORIS")
+            dlg.pbOK.setText("Yes")
+            dlg.pbCancel.setVisible(True)
+            dlg.pbCancel.setText("No")
+
+            dlg.ptText.clear()
+            dlg.ptText.appendHtml(
+                (
+                    "Some media file does not contain the <b>Creation date/time</b> metadata tag:<br>"
+                    f"{'<br>'.join(not_tagged_media_list)}<br><br>"
+                    "Use the media file date/time instead?"
+                )
+            )
+            dlg.ptText.moveCursor(QTextCursor.Start)
+            ret = dlg.exec_()
+
+            if ret == 1:  #  use file creation time
+                for media in not_tagged_media_list:
+                    self.media_creation_time[media] = pl.Path(media).stat().st_ctime
+                return 0  # OK use media file creation date/time
             else:
-                self.cbVisualizeSpectrogram.setChecked(False)
-                self.cb_visualize_waveform.setChecked(False)
-            """
+                self.cb_media_creation_date_as_offset.setChecked(False)
+                self.media_creation_time = {}
+                return 1
+        else:
+            return 0  # OK all media have a 'creation time' tag
+        """
+        return 0
 
     def closeEvent(self, event):
         """
@@ -761,11 +980,13 @@ class Observation(QDialog, Ui_Form):
             self.text = None
         self.reject()
 
-    def check_parameters(self):
+    def check_parameters(self) -> bool:
         """
         check observation parameters
 
-        return True if everything OK else False
+        Returns:
+            bool: True if everything is OK else False
+
         """
 
         def is_numeric(s):
@@ -786,21 +1007,40 @@ class Observation(QDialog, Ui_Form):
 
         # check if observation id not empty
         if not self.leObservationId.text():
-            self.qm = QMessageBox()
-            self.qm.setIcon(QMessageBox.Critical)
-            self.qm.setText("The <b>observation id</b> is mandatory and must be unique.")
-            self.qm.exec_()
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                "The <b>observation id</b> is mandatory and must be unique.",
+            )
             return False
 
         # check if observation_type
         if not any((self.rb_media_files.isChecked(), self.rb_live.isChecked(), self.rb_images.isChecked())):
-            self.qm = QMessageBox()
-            self.qm.setIcon(QMessageBox.Critical)
-            self.qm.setText("Choose an observation type.")
-            self.qm.exec_()
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                "Choose an observation type.",
+            )
             return False
 
+        # check if offset is correct
+        if self.cb_time_offset.isChecked():
+            if self.obs_time_offset.get_time() is None:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "Check the time offset value.",
+                )
+                return False
+
         if self.rb_media_files.isChecked():  # observation based on media file(s)
+            # check if media file exists
+            media_file_not_found: list = []
+            for row in range(self.twVideo1.rowCount()):
+                # check if media file exists
+                if not pl.Path(self.twVideo1.item(row, 2).text()).is_file():
+                    media_file_not_found.append(self.twVideo1.item(row, 2).text())
+
             # check player number
             players_list: list = []
             players: dict = {}  # for storing duration
@@ -813,18 +1053,20 @@ class Observation(QDialog, Ui_Form):
 
             # check if player #1 is used
             if not players_list or min(players_list) > 1:
-                self.qm = QMessageBox()
-                self.qm.setIcon(QMessageBox.Critical)
-                self.qm.setText("A media file must be loaded in player #1")
-                self.qm.exec_()
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "A media file must be loaded in player #1",
+                )
                 return False
 
             # check if players are used in crescent order
             if set(list(range(min(players_list), max(players_list) + 1))) != set(players_list):
-                self.qm = QMessageBox()
-                self.qm.setIcon(QMessageBox.Critical)
-                self.qm.setText("Some player are not used. Please reorganize your media files")
-                self.qm.exec_()
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "Some player are not used. Please reorganize your media files",
+                )
                 return False
 
             # check if more media in player #1 and media in other players
@@ -856,7 +1098,7 @@ class Observation(QDialog, Ui_Form):
                     return False
 
             # check that the longuest media is in player #1
-            durations = []
+            durations: list = []
             for i in sorted(list(players.keys())):
                 durations.append(sum(players[i]))
             if [x for x in durations[1:] if x > durations[0]]:
@@ -878,6 +1120,20 @@ class Observation(QDialog, Ui_Form):
                     )
                     return False
 
+            # check if offset set and only player #1 is used
+            if len(set(players_list)) == 1:
+                for row in range(self.twVideo1.rowCount()):
+                    if float(self.twVideo1.item(row, 1).text()):
+                        QMessageBox.critical(
+                            self,
+                            cfg.programName,
+                            (
+                                "It is not possible to use offset value(s) with only one player,<br>"
+                                "The offset values are use to synchronise various players."
+                            ),
+                        )
+                        return False
+
             # check offset for external data files
             for row in range(self.tw_data_files.rowCount()):
                 if not is_numeric(self.tw_data_files.item(row, cfg.PLOT_DATA_TIMEOFFSET_IDX).text()):
@@ -893,6 +1149,18 @@ class Observation(QDialog, Ui_Form):
                     )
                     return False
 
+            # check media creation time tag in metadata
+            # Disable because the check will be made at the observation start
+            """
+            if self.cb_media_creation_date_as_offset.isChecked():
+                if self.check_creation_date():
+                    return False
+            """
+
+            # check media creation date time (if option enabled)
+            if self.check_media_creation_date():
+                return False
+
         if self.rb_images.isChecked():  # observation based on images directory
             if not self.lw_images_directory.count():
                 QMessageBox.critical(self, cfg.programName, "You have to select at least one images directory")
@@ -901,9 +1169,7 @@ class Observation(QDialog, Ui_Form):
         # check if indep variables are correct type
         for row in range(self.twIndepVariables.rowCount()):
             if self.twIndepVariables.item(row, 1).text() == cfg.NUMERIC:
-                if self.twIndepVariables.item(row, 2).text() and not is_numeric(
-                    self.twIndepVariables.item(row, 2).text()
-                ):
+                if self.twIndepVariables.item(row, 2).text() and not is_numeric(self.twIndepVariables.item(row, 2).text()):
                     QMessageBox.critical(
                         self,
                         cfg.programName,
@@ -925,11 +1191,10 @@ class Observation(QDialog, Ui_Form):
                 )
                 return False
 
+        # check if numeric indep variable values are numeric
         for row in range(self.twIndepVariables.rowCount()):
             if self.twIndepVariables.item(row, 1).text() == cfg.NUMERIC:
-                if self.twIndepVariables.item(row, 2).text() and not is_numeric(
-                    self.twIndepVariables.item(row, 2).text()
-                ):
+                if self.twIndepVariables.item(row, 2).text() and not is_numeric(self.twIndepVariables.item(row, 2).text()):
                     QMessageBox.critical(
                         self,
                         cfg.programName,
@@ -941,7 +1206,7 @@ class Observation(QDialog, Ui_Form):
 
     def pbLaunch_clicked(self):
         """
-        Close window and start observation
+        Close dialog and start the observation
         """
 
         if self.check_parameters():
@@ -976,24 +1241,54 @@ class Observation(QDialog, Ui_Form):
              str: error message or empty string
         """
 
+        logging.debug(f"check_media function for {file_path}")
+
         media_info = util.accurate_media_analysis(self.ffmpeg_bin, file_path)
+
+        logging.debug(f"{media_info=}")
+
         if "error" in media_info:
-            return False, media_info["error"]
+            return (True, media_info["error"])
+
+        if media_info["format_long_name"] == "Tele-typewriter":
+            return (True, "Text file")
+
+        if media_info["duration"] > 0:
+            if " rel " in mode:
+                # convert to relative path (relative to BORIS project file)
+                file_path = str(pl.Path(file_path).relative_to(pl.Path(self.project_path).parent))
+
+            self.mediaDurations[file_path] = float(media_info["duration"])
+        elif media_info["has_video"] is False and media_info["audio_duration"]:
+            self.mediaDurations[file_path] = float(media_info["audio_duration"])
         else:
-            if media_info["duration"] > 0:
+            return (True, "Media duration not available")
 
-                if " rel " in mode:
-                    # convert to relative path (relative to BORIS project file)
-                    file_path = str(pl.Path(file_path).relative_to(pl.Path(self.project_path).parent))
-
-                self.mediaDurations[file_path] = float(media_info["duration"])
-                self.mediaFPS[file_path] = float(media_info["fps"])
-                self.mediaHasVideo[file_path] = media_info["has_video"]
-                self.mediaHasAudio[file_path] = media_info["has_audio"]
-                self.add_media_to_listview(file_path)
-                return (False, "")
-            else:
-                return (True, "Media duration not available")
+        self.mediaFPS[file_path] = float(media_info["fps"])
+        self.mediaHasVideo[file_path] = media_info["has_video"]
+        self.mediaHasAudio[file_path] = media_info["has_audio"]
+
+        logging.debug(f"{file_path=}")
+
+        self.add_media_to_listview(file_path)
+        return (False, "")
+
+    def update_media_options(self):
+        """
+        update the media options
+        """
+        for w in (
+            self.cbVisualizeSpectrogram,
+            self.cb_visualize_waveform,
+            self.cb_observation_time_interval,
+            self.cb_media_creation_date_as_offset,
+        ):
+            w.setEnabled(self.twVideo1.rowCount() > 0)
+
+        # enable stop ongoing state events if n. media > 1
+        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(self.twVideo1.rowCount() > 0)
+
+        # self.creation_date_as_offset()
 
     def add_media(self, mode: str):
         """
@@ -1021,9 +1316,7 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(
                 self,
                 cfg.programName,
-                (
-                    "It is not possible to add a media file without path or with a relative path if the project is not already saved"
-                ),
+                ("It is not possible to add a media file without path or with a relative path if the project is not already saved"),
             )
             return
 
@@ -1034,9 +1327,9 @@ class Observation(QDialog, Ui_Form):
             fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
 
         if "media " in mode:
+            file_paths, _ = fd.getOpenFileNames(self, "Add media file(s)", "", "All files (*)")
 
-            fn = fd.getOpenFileNames(self, "Add media file(s)", "", "All files (*)")
-            file_paths = fn[0] if type(fn) is tuple else fn
+            logging.debug(f"{file_paths=}")
 
             if file_paths:
                 # store directory for next usage
@@ -1058,39 +1351,40 @@ class Observation(QDialog, Ui_Form):
                     if error:
                         QMessageBox.critical(self, cfg.programName, f"<b>{file_path}</b>. {msg}")
 
-        if "dir " in mode:
-
+        if "dir " in mode:  # add media from dir
             dir_name = fd.getExistingDirectory(self, "Select directory")
             if dir_name:
                 response = ""
-                for file_path in glob.glob(dir_name + os.sep + "*"):
-                    (error, msg) = self.check_media(file_path, mode)
+                for file_path in sorted(pl.Path(dir_name).glob("*")):
+                    if not file_path.is_file():
+                        continue
+                    (error, msg) = self.check_media(str(file_path), mode)
                     if error:
                         if response != "Skip all non media files":
                             response = dialog.MessageDialog(
                                 cfg.programName,
                                 f"<b>{file_path}</b> {msg}",
-                                ["Continue", "Skip all non media files", "Cancel"],
+                                ["Continue", "Skip all non media files", cfg.CANCEL],
                             )
-                            if response == "Cancel":
+                            if response == cfg.CANCEL:
                                 break
+                # ask to use directory name / path as observation id
+                if response != cfg.CANCEL:
+                    selected_obs_id = dialog.MessageDialog(
+                        cfg.programName,
+                        "Select the observation id",
+                        [dir_name, str(pl.Path(dir_name).name), cfg.CANCEL],
+                    )
+                    if selected_obs_id != cfg.CANCEL:
+                        self.leObservationId.setText(selected_obs_id)
 
-        for w in [
-            self.cbVisualizeSpectrogram,
-            self.cb_visualize_waveform,
-            self.cb_observation_time_interval,
-            self.cbCloseCurrentBehaviorsBetweenVideo,
-        ]:
-            w.setEnabled(self.twVideo1.rowCount() > 0)
-
-        # disabled for problems
-        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
+        self.update_media_options()
 
     def add_media_to_listview(self, file_name):
         """
         add media file path to list widget
         """
-
+        # add a row
         self.twVideo1.setRowCount(self.twVideo1.rowCount() + 1)
 
         for col_idx, s in enumerate(
@@ -1131,33 +1425,22 @@ class Observation(QDialog, Ui_Form):
         remove all selected media files from list widget
         """
 
-        if self.twVideo1.selectedIndexes():
-            rows_to_delete = set([x.row() for x in self.twVideo1.selectedIndexes()])
-            for row in sorted(rows_to_delete, reverse=True):
-                media_path = self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text()
-                self.twVideo1.removeRow(row)
-                if media_path not in [
-                    self.twVideo1.item(idx, cfg.MEDIA_FILE_PATH_IDX).text() for idx in range(self.twVideo1.rowCount())
-                ]:
-                    try:
-                        del self.mediaDurations[media_path]
-                    except NameError:
-                        pass
-                    try:
-                        del self.mediaFPS[media_path]
-                    except NameError:
-                        pass
-
-            for w in [
-                self.cbVisualizeSpectrogram,
-                self.cb_visualize_waveform,
-                self.cb_observation_time_interval,
-                self.cbCloseCurrentBehaviorsBetweenVideo,
-            ]:
-                w.setEnabled(self.twVideo1.rowCount() > 0)
-
-            # disabled for problems
-            self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
-
-        else:
+        if not self.twVideo1.selectedIndexes():
             QMessageBox.warning(self, cfg.programName, "No media file selected")
+            return
+
+        rows_to_delete = set([x.row() for x in self.twVideo1.selectedIndexes()])
+        for row in sorted(rows_to_delete, reverse=True):
+            media_path = self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text()
+            self.twVideo1.removeRow(row)
+            if media_path not in [self.twVideo1.item(idx, cfg.MEDIA_FILE_PATH_IDX).text() for idx in range(self.twVideo1.rowCount())]:
+                try:
+                    del self.mediaDurations[media_path]
+                except NameError:
+                    pass
+                try:
+                    del self.mediaFPS[media_path]
+                except NameError:
+                    pass
+
+        self.update_media_options()