boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__py3-none-any.whl

boris/observation_operations.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -19,20 +19,23 @@ Copyright 2012-2023 Olivier Friard
   MA 02110-1301, USA.
 """
 
-from math import log2
-import os
 import logging
-import time
-import tempfile
+from collections import deque
+import datetime as dt
+from decimal import Decimal as dec
+import json
+from math import log2, floor
+import os
+from pathlib import Path
+import socket
 import subprocess
 import sys
-from decimal import Decimal as dec
-import pathlib as pl
-import datetime
-from typing import List, Tuple, Dict, Optional
+import tempfile
+import time
+from typing import List, Tuple, Optional
 
 
-from PyQt5.QtWidgets import (
+from PySide6.QtWidgets import (
     QMessageBox,
     QFileDialog,
     QDateTimeEdit,
@@ -41,11 +44,12 @@ from PyQt5.QtWidgets import (
     QSlider,
     QMainWindow,
     QDockWidget,
+    QWidget,
 )
-from PyQt5.QtCore import Qt, QDateTime, QTimer
-from PyQt5.QtGui import QFont, QIcon
+from PySide6.QtCore import Qt, QDateTime, QTimer
+from PySide6.QtGui import QFont, QIcon, QTextCursor
 
-from PyQt5 import QtTest
+from PySide6 import QtTest
 
 from . import menu_options
 from . import config as cfg
@@ -58,6 +62,7 @@ from . import plot_data_module
 from . import player_dock_widget
 from . import gui_utilities
 from . import video_operations
+from . import state_events
 
 
 def export_observations_list_clicked(self):
@@ -78,24 +83,17 @@ def export_observations_list_clicked(self):
         cfg.HTML,
     ]
 
-    file_name, filter_ = QFileDialog().getSaveFileName(
-        self, "Export list of selected observations", "", ";;".join(file_formats)
-    )
+    file_name, filter_ = QFileDialog().getSaveFileName(self, "Export list of selected observations", "", ";;".join(file_formats))
 
     if not file_name:
         return
 
     output_format = cfg.FILE_NAME_SUFFIX[filter_]
-    if pl.Path(file_name).suffix != "." + output_format:
-        file_name = str(pl.Path(file_name)) + "." + output_format
+    if Path(file_name).suffix != "." + output_format:
+        file_name = str(Path(file_name)) + "." + output_format
         # check if file name with extension already exists
-        if pl.Path(file_name).is_file():
-            if (
-                dialog.MessageDialog(
-                    cfg.programName, f"The file {file_name} already exists.", [cfg.CANCEL, cfg.OVERWRITE]
-                )
-                == cfg.CANCEL
-            ):
+        if Path(file_name).is_file():
+            if dialog.MessageDialog(cfg.programName, f"The file {file_name} already exists.", [cfg.CANCEL, cfg.OVERWRITE]) == cfg.CANCEL:
                 return
 
     if not project_functions.export_observations_list(self.pj, selected_observations, file_name, output_format):
@@ -107,7 +105,7 @@ def observations_list(self):
     show list of all observations of current project
     """
 
-    logging.debug(f"observations list")
+    logging.debug("observations list")
 
     if self.playerType in cfg.VIEWERS:
         close_observation(self)
@@ -115,16 +113,20 @@ def observations_list(self):
     result, selected_obs = select_observations.select_observations2(self, cfg.SINGLE)
 
     if not selected_obs:
+        # activate main window
+        self.activateWindow()
         return
 
     if self.observationId:
-
         self.hide_data_files()
         response = dialog.MessageDialog(
             cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO)
         )
         if response == cfg.NO:
             self.show_data_files()
+            # activate main window
+            self.activateWindow()
+
             return ""
         else:
             close_observation(self)
@@ -144,10 +146,12 @@ def observations_list(self):
             QMessageBox.warning(
                 self,
                 cfg.programName,
-                (f"The observation <b>{self.observationId}</b> is running!<br>" "Close it before editing."),
+                (f"The observation <b>{self.observationId}</b> is running!<br>Close it before editing."),
             )
 
-    logging.debug(f"end observations list")
+    logging.debug("end observations list")
+    # activate main window
+    self.activateWindow()
 
 
 def open_observation(self, mode: str) -> str:
@@ -159,11 +163,10 @@ def open_observation(self, mode: str) -> str:
                     "view" to view observation
     """
 
-    logging.debug(f"open observation")
+    logging.debug("open observation")
 
     # check if current observation must be closed to open a new one
     if self.observationId:
-
         self.hide_data_files()
         response = dialog.MessageDialog(
             cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO)
@@ -195,7 +198,7 @@ def load_observation(self, obs_id: str, mode: str = cfg.OBS_START) -> str:
                     "view"  to view observation
     """
 
-    logging.debug(f"load observation")
+    logging.debug("load observation")
 
     if obs_id not in self.pj[cfg.OBSERVATIONS]:
         return "Error: Observation not found"
@@ -206,7 +209,6 @@ def load_observation(self, obs_id: str, mode: str = cfg.OBS_START) -> str:
     self.observationId = obs_id
 
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
-
         self.image_idx = 0
         self.images_list = []
 
@@ -219,7 +221,6 @@ def load_observation(self, obs_id: str, mode: str = cfg.OBS_START) -> str:
             self.dwEvents.setVisible(True)
 
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.LIVE:
-
         if mode == cfg.OBS_START:
             initialize_new_live_observation(self)
 
@@ -228,12 +229,12 @@ def load_observation(self, obs_id: str, mode: str = cfg.OBS_START) -> str:
             self.dwEvents.setVisible(True)
 
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
-
         if mode == cfg.OBS_START:
             if not initialize_new_media_observation(self):
-                self.observationId = ""
-                self.twEvents.setRowCount(0)
-                menu_options.update_menu(self)
+                close_observation(self)
+                # self.observationId = ""
+                # self.twEvents.setRowCount(0)
+                # menu_options.update_menu(self)
                 return "Error: loading observation problem"
 
         if mode == cfg.VIEW:
@@ -246,7 +247,7 @@ def load_observation(self, obs_id: str, mode: str = cfg.OBS_START) -> str:
     # title of dock widget  “  ”
     self.dwEvents.setWindowTitle(f"Events for “{self.observationId}” observation")
 
-    logging.debug(f"end load observation")
+    logging.debug("end load observation")
     return ""
 
 
@@ -260,9 +261,7 @@ def edit_observation(self):
         # hide data plot
         self.hide_data_files()
         if (
-            dialog.MessageDialog(
-                cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO)
-            )
+            dialog.MessageDialog(cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO))
             == cfg.NO
         ):
             # restore plots
@@ -271,9 +270,7 @@ def edit_observation(self):
         else:
             close_observation(self)
 
-    _, selected_observations = select_observations.select_observations2(
-        self, cfg.EDIT, windows_title="Edit observation"
-    )
+    _, selected_observations = select_observations.select_observations2(self, cfg.EDIT, windows_title="Edit observation")
 
     if selected_observations:
         new_observation(self, mode=cfg.EDIT, obsId=selected_observations[0])
@@ -284,9 +281,7 @@ def remove_observations(self):
     remove observations from project file
     """
 
-    _, selected_observations = select_observations.select_observations2(
-        self, cfg.MULTIPLE, windows_title="Remove observations"
-    )
+    _, selected_observations = select_observations.select_observations2(self, cfg.MULTIPLE, windows_title="Remove observations")
     if not selected_observations:
         return
 
@@ -329,11 +324,7 @@ def coding_time(observations: dict, observations_list: list) -> Tuple[Optional[d
         observation = observations[obs_id]
         if observation[cfg.EVENTS]:
             # check if events contain a NA timestamp
-            if [
-                event[cfg.EVENT_TIME_FIELD_IDX]
-                for event in observation[cfg.EVENTS]
-                if event[cfg.EVENT_TIME_FIELD_IDX].is_nan()
-            ]:
+            if [event[cfg.EVENT_TIME_FIELD_IDX] for event in observation[cfg.EVENTS] if event[cfg.EVENT_TIME_FIELD_IDX].is_nan()]:
                 return dec("NaN"), dec("NaN"), dec("NaN")
             start_coding_list.append(observation[cfg.EVENTS][0][cfg.EVENT_TIME_FIELD_IDX])
             end_coding_list.append(observation[cfg.EVENTS][-1][cfg.EVENT_TIME_FIELD_IDX])
@@ -364,6 +355,47 @@ def coding_time(observations: dict, observations_list: list) -> Tuple[Optional[d
     return start_coding, end_coding, coding_duration
 
 
+def time_intervals_range(observations: dict, observations_list: list) -> Tuple[Optional[dec], Optional[dec]]:
+    """
+    returns earliest start interval and latest end interval
+
+    Args:
+        observations (dict): observations of project
+        observations_list (list): list of selected observations
+
+    Returns:
+        decimal.Decimal: time of earliest start interval
+        decimal.Decimal: time of latest end interval
+
+    """
+    start_interval_list: list = []
+    end_interval_list: list = []
+    for obs_id in observations_list:
+        observation = observations[obs_id]
+        offset = observation[cfg.TIME_OFFSET]
+        # check if observation interval is defined
+        if (
+            not observation.get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[0]
+            and not observation.get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1]
+        ):
+            return None, None
+
+        start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
+        end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
+
+    if not start_interval_list:
+        earliest_start_interval = None
+    else:
+        earliest_start_interval = min([x for x in start_interval_list])
+
+    if not end_interval_list:
+        latest_end_interval = None
+    else:
+        latest_end_interval = max([x for x in end_interval_list])
+
+    return earliest_start_interval, latest_end_interval
+
+
 def observation_total_length(observation: dict) -> dec:
     """
     Observation media duration (if any)
@@ -394,7 +426,7 @@ def observation_total_length(observation: dict) -> dec:
                 last_event = obs_length = max(observation[cfg.EVENTS])[cfg.TW_OBS_FIELD[cfg.IMAGES]["time"]]
                 obs_length = last_event - first_event
             except Exception:
-                logging.critical(f"Length of observation from images not available")
+                logging.critical("Length of observation from images not available")
                 obs_length = dec(-2)
         else:
             obs_length = dec(0)
@@ -510,10 +542,7 @@ def observation_length(pj: dict, selected_observations: list) -> tuple:
         if (
             dialog.MessageDialog(
                 cfg.programName,
-                (
-                    f"The observation length is not available (<b>{obs_id}</b>).<br>"
-                    "Use last event time as observation length?"
-                ),
+                (f"The observation length is not available (<b>{obs_id}</b>).<br>Use last event time as observation length?"),
                 (cfg.YES, cfg.NO),
             )
             == cfg.YES
@@ -545,7 +574,7 @@ def observation_length(pj: dict, selected_observations: list) -> tuple:
     return (max_obs_length, selectedObsTotalMediaLength)
 
 
-def new_observation(self, mode=cfg.NEW, obsId=""):
+def new_observation(self, mode: str = cfg.NEW, obsId: str = "") -> None:
     """
     define a new observation or edit an existing observation
 
@@ -553,18 +582,18 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
         mode (str): NEW or EDIT
         obsId (str): observation Id to be edited
 
+    Retruns:
+        None
+
     """
     # check if current observation must be closed to create a new one
     if mode == cfg.NEW and self.observationId:
         # hide data plot
         self.hide_data_files()
         if (
-            dialog.MessageDialog(
-                cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO)
-            )
+            dialog.MessageDialog(cfg.programName, "The current observation will be closed. Do you want to continue?", (cfg.YES, cfg.NO))
             == cfg.NO
         ):
-
             # show data plot
             self.show_data_files()
             return
@@ -572,9 +601,7 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
             close_observation(self)
 
     observationWindow = observation.Observation(
-        tmp_dir=self.ffmpeg_cache_dir
-        if (self.ffmpeg_cache_dir and pl.Path(self.ffmpeg_cache_dir).is_dir())
-        else tempfile.gettempdir(),
+        tmp_dir=self.ffmpeg_cache_dir if (self.ffmpeg_cache_dir and Path(self.ffmpeg_cache_dir).is_dir()) else tempfile.gettempdir(),
         project_path=self.projectFileName,
         converters=self.pj.get(cfg.CONVERTERS, {}),
         time_format=self.timeFormat,
@@ -586,16 +613,15 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
     observationWindow.mem_obs_id = obsId
     observationWindow.chunk_length = self.chunk_length
     observationWindow.dteDate.setDateTime(QDateTime.currentDateTime())
+    # observationWindow.de_date_offset.setDateTime(QDateTime.currentDateTime())
     observationWindow.ffmpeg_bin = self.ffmpeg_bin
     observationWindow.project_file_name = self.projectFileName
     observationWindow.rb_no_time.setChecked(True)
 
     # add independent variables
     if cfg.INDEPENDENT_VARIABLES in self.pj:
-
         observationWindow.twIndepVariables.setRowCount(0)
         for i in util.sorted_keys(self.pj[cfg.INDEPENDENT_VARIABLES]):
-
             observationWindow.twIndepVariables.setRowCount(observationWindow.twIndepVariables.rowCount() + 1)
 
             # label
@@ -630,22 +656,18 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                 comboBox = QComboBox()
                 comboBox.addItems(self.pj[cfg.INDEPENDENT_VARIABLES][i]["possible values"].split(","))
                 if txt in self.pj[cfg.INDEPENDENT_VARIABLES][i]["possible values"].split(","):
-                    comboBox.setCurrentIndex(
-                        self.pj[cfg.INDEPENDENT_VARIABLES][i]["possible values"].split(",").index(txt)
-                    )
-                observationWindow.twIndepVariables.setCellWidget(
-                    observationWindow.twIndepVariables.rowCount() - 1, 2, comboBox
-                )
+                    comboBox.setCurrentIndex(self.pj[cfg.INDEPENDENT_VARIABLES][i]["possible values"].split(",").index(txt))
+                observationWindow.twIndepVariables.setCellWidget(observationWindow.twIndepVariables.rowCount() - 1, 2, comboBox)
 
             elif self.pj[cfg.INDEPENDENT_VARIABLES][i]["type"] == cfg.TIMESTAMP:
                 cal = QDateTimeEdit()
-                cal.setDisplayFormat("yyyy-MM-dd hh:mm:ss")
+                cal.setDisplayFormat("yyyy-MM-dd hh:mm:ss.zzz")
                 cal.setCalendarPopup(True)
-                if txt:
-                    cal.setDateTime(QDateTime.fromString(txt, "yyyy-MM-ddThh:mm:ss"))
-                observationWindow.twIndepVariables.setCellWidget(
-                    observationWindow.twIndepVariables.rowCount() - 1, 2, cal
-                )
+                if len(txt) == len("yyyy-MM-ddThh:mm:ss"):
+                    txt += ".000"
+                cal.setDateTime(QDateTime.fromString(txt, "yyyy-MM-ddThh:mm:ss.zzz"))
+
+                observationWindow.twIndepVariables.setCellWidget(observationWindow.twIndepVariables.rowCount() - 1, 2, cal)
             else:
                 item.setText(txt)
                 observationWindow.twIndepVariables.setItem(observationWindow.twIndepVariables.rowCount() - 1, 2, item)
@@ -654,28 +676,34 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
 
     # adapt time offset for current time format
     if self.timeFormat == cfg.S:
-        observationWindow.obs_time_offset.set_format_s()
+        observationWindow.obs_time_offset.rb_seconds.setChecked(True)
     if self.timeFormat == cfg.HHMMSS:
-        observationWindow.obs_time_offset.set_format_hhmmss()
+        # observationWindow.obs_time_offset.set_format_hhmmss()
+        observationWindow.obs_time_offset.rb_time.setChecked(True)
 
-    if mode == cfg.EDIT:
+    observationWindow.obs_time_offset.set_time(0)
 
+    if mode == cfg.EDIT:
         observationWindow.setWindowTitle(f'Edit observation "{obsId}"')
-        mem_obs_id = obsId
+        """mem_obs_id = obsId"""
         observationWindow.leObservationId.setText(obsId)
 
         # check date format for old versions of BORIS app
         try:
             time.strptime(self.pj[cfg.OBSERVATIONS][obsId]["date"], "%Y-%m-%d %H:%M")
-            self.pj[cfg.OBSERVATIONS][obsId]["date"] = (
-                self.pj[cfg.OBSERVATIONS][obsId]["date"].replace(" ", "T") + ":00"
-            )
+            self.pj[cfg.OBSERVATIONS][obsId]["date"] = self.pj[cfg.OBSERVATIONS][obsId]["date"].replace(" ", "T") + ":00.000"
+            logging.info("Old observation date/time format was converted")
         except ValueError:
             pass
 
-        observationWindow.dteDate.setDateTime(
-            QDateTime.fromString(self.pj[cfg.OBSERVATIONS][obsId]["date"], "yyyy-MM-ddThh:mm:ss")
-        )
+        # print(f"{self.pj[cfg.OBSERVATIONS][obsId]['date']=}")
+
+        # test new date (with msec)
+        if len(self.pj[cfg.OBSERVATIONS][obsId]["date"]) == len("yyyy-MM-ddThh:mm:ss.zzz"):
+            observationWindow.dteDate.setDateTime(QDateTime.fromString(self.pj[cfg.OBSERVATIONS][obsId]["date"], "yyyy-MM-ddThh:mm:ss.zzz"))
+        elif len(self.pj[cfg.OBSERVATIONS][obsId]["date"]) == len("yyyy-MM-ddThh:mm:ss"):
+            observationWindow.dteDate.setDateTime(QDateTime.fromString(self.pj[cfg.OBSERVATIONS][obsId]["date"], "yyyy-MM-ddThh:mm:ss"))
+
         observationWindow.teDescription.setPlainText(self.pj[cfg.OBSERVATIONS][obsId][cfg.DESCRIPTION])
 
         try:
@@ -694,17 +722,20 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
             logging.info("No Video/Audio information")
 
         # offset
-        observationWindow.obs_time_offset.set_time(self.pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET])
+        if self.pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET] > cfg.DATE_CUTOFF:
+            observationWindow.obs_time_offset.rb_datetime.setChecked(True)
+
+        # time offset
+        if self.pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET]:
+            observationWindow.cb_time_offset.setChecked(True)
+            observationWindow.obs_time_offset.set_time(self.pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET])
 
         if self.pj[cfg.OBSERVATIONS][obsId]["type"] == cfg.MEDIA:
             observationWindow.rb_media_files.setChecked(True)
 
             observationWindow.twVideo1.setRowCount(0)
             for player in self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE]:
-                if (
-                    player in self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE]
-                    and self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE][player]
-                ):
+                if player in self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE] and self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE][player]:
                     for mediaFile in self.pj[cfg.OBSERVATIONS][obsId][cfg.FILE][player]:
                         observationWindow.twVideo1.setRowCount(observationWindow.twVideo1.rowCount() + 1)
 
@@ -713,19 +744,15 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                         combobox.setCurrentIndex(int(player) - 1)
                         observationWindow.twVideo1.setCellWidget(observationWindow.twVideo1.rowCount() - 1, 0, combobox)
 
-                        # set offset
+                        # set media file offset
                         try:
                             observationWindow.twVideo1.setItem(
                                 observationWindow.twVideo1.rowCount() - 1,
                                 1,
-                                QTableWidgetItem(
-                                    str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO]["offset"][player])
-                                ),
+                                QTableWidgetItem(str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO]["offset"][player])),
                             )
                         except Exception:
-                            observationWindow.twVideo1.setItem(
-                                observationWindow.twVideo1.rowCount() - 1, 1, QTableWidgetItem("0.0")
-                            )
+                            observationWindow.twVideo1.setItem(observationWindow.twVideo1.rowCount() - 1, 1, QTableWidgetItem("0.0"))
 
                         item = QTableWidgetItem(mediaFile)
                         item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
@@ -734,16 +761,12 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                         # duration and FPS
                         try:
                             item = QTableWidgetItem(
-                                util.seconds2time(
-                                    self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.LENGTH][mediaFile]
-                                )
+                                util.seconds2time(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.LENGTH][mediaFile])
                             )
                             item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                             observationWindow.twVideo1.setItem(observationWindow.twVideo1.rowCount() - 1, 3, item)
 
-                            item = QTableWidgetItem(
-                                f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.FPS][mediaFile]:.2f}"
-                            )
+                            item = QTableWidgetItem(f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.FPS][mediaFile]:.2f}")
                             item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                             observationWindow.twVideo1.setItem(observationWindow.twVideo1.rowCount() - 1, 4, item)
                         except Exception:
@@ -751,41 +774,41 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
 
                         # has_video has_audio
                         try:
-                            item = QTableWidgetItem(
-                                str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.HAS_VIDEO][mediaFile])
-                            )
+                            item = QTableWidgetItem(str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.HAS_VIDEO][mediaFile]))
                             item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                             observationWindow.twVideo1.setItem(observationWindow.twVideo1.rowCount() - 1, 5, item)
 
-                            item = QTableWidgetItem(
-                                str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.HAS_AUDIO][mediaFile])
-                            )
+                            item = QTableWidgetItem(str(self.pj[cfg.OBSERVATIONS][obsId][cfg.MEDIA_INFO][cfg.HAS_AUDIO][mediaFile]))
                             item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                             observationWindow.twVideo1.setItem(observationWindow.twVideo1.rowCount() - 1, 6, item)
                         except Exception:
                             pass
 
+            observationWindow.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(observationWindow.twVideo1.rowCount() > 0)
             # spectrogram
             observationWindow.cbVisualizeSpectrogram.setEnabled(True)
-            observationWindow.cbVisualizeSpectrogram.setChecked(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.VISUALIZE_SPECTROGRAM, False)
-            )
-
+            observationWindow.cbVisualizeSpectrogram.setChecked(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.VISUALIZE_SPECTROGRAM, False))
             # waveform
             observationWindow.cb_visualize_waveform.setEnabled(True)
-            observationWindow.cb_visualize_waveform.setChecked(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.VISUALIZE_WAVEFORM, False)
+            observationWindow.cb_visualize_waveform.setChecked(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.VISUALIZE_WAVEFORM, False))
+            # use Creation date metadata tag as offset
+            observationWindow.cb_media_creation_date_as_offset.setEnabled(True)
+
+            # DEVELOPMENT (REMOVE BEFORE RELEASE)
+            # observationWindow.cb_media_creation_date_as_offset.setEnabled(False)
+
+            observationWindow.cb_media_creation_date_as_offset.setChecked(
+                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.MEDIA_CREATION_DATE_AS_OFFSET, False)
             )
 
+            # scan sampling
+            observationWindow.sb_media_scan_sampling.setValue(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.MEDIA_SCAN_SAMPLING_DURATION, 0))
             # image display duration
-            observationWindow.sb_image_display_duration.setValue(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.IMAGE_DISPLAY_DURATION, 1)
-            )
+            observationWindow.sb_image_display_duration.setValue(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.IMAGE_DISPLAY_DURATION, 1))
 
             # plot data
             if cfg.PLOT_DATA in self.pj[cfg.OBSERVATIONS][obsId]:
                 if self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA]:
-
                     observationWindow.tw_data_files.setRowCount(0)
                     for idx2 in util.sorted_keys(self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA]):
                         observationWindow.tw_data_files.setRowCount(observationWindow.tw_data_files.rowCount() + 1)
@@ -795,9 +818,7 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                                 combobox.addItems(cfg.DATA_PLOT_STYLES)
                                 combobox.setCurrentIndex(
                                     cfg.DATA_PLOT_STYLES.index(
-                                        self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][
-                                            cfg.DATA_PLOT_FIELDS[idx3]
-                                        ]
+                                        self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][cfg.DATA_PLOT_FIELDS[idx3]]
                                     )
                                 )
 
@@ -811,9 +832,7 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                                 combobox2.addItems(["False", "True"])
                                 combobox2.setCurrentIndex(
                                     ["False", "True"].index(
-                                        self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][
-                                            cfg.DATA_PLOT_FIELDS[idx3]
-                                        ]
+                                        self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][cfg.DATA_PLOT_FIELDS[idx3]]
                                     )
                                 )
 
@@ -828,11 +847,7 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                                     observationWindow.tw_data_files.rowCount() - 1,
                                     idx3,
                                     QTableWidgetItem(
-                                        str(
-                                            self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][
-                                                cfg.DATA_PLOT_FIELDS[idx3]
-                                            ]
-                                        )
+                                        str(self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][cfg.DATA_PLOT_FIELDS[idx3]])
                                     ),
                                 )
 
@@ -840,24 +855,18 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                                 observationWindow.tw_data_files.setItem(
                                     observationWindow.tw_data_files.rowCount() - 1,
                                     idx3,
-                                    QTableWidgetItem(
-                                        self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][
-                                            cfg.DATA_PLOT_FIELDS[idx3]
-                                        ]
-                                    ),
+                                    QTableWidgetItem(self.pj[cfg.OBSERVATIONS][obsId][cfg.PLOT_DATA][idx2][cfg.DATA_PLOT_FIELDS[idx3]]),
                                 )
 
         if self.pj[cfg.OBSERVATIONS][obsId]["type"] == cfg.IMAGES:
             observationWindow.rb_images.setChecked(True)
-            observationWindow.lw_images_directory.addItems(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.DIRECTORIES_LIST, [])
-            )
+            observationWindow.lw_images_directory.addItems(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.DIRECTORIES_LIST, []))
             observationWindow.rb_use_exif.setChecked(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.USE_EXIF_DATE, False))
             if self.pj[cfg.OBSERVATIONS][obsId].get(cfg.TIME_LAPSE, 0):
                 observationWindow.rb_time_lapse.setChecked(True)
                 observationWindow.sb_time_lapse.setValue(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.TIME_LAPSE, 0))
 
-        if self.pj[cfg.OBSERVATIONS][obsId]["type"] in [cfg.LIVE]:
+        if self.pj[cfg.OBSERVATIONS][obsId]["type"] == cfg.LIVE:
             observationWindow.rb_live.setChecked(True)
             # sampling time
             observationWindow.sbScanSampling.setValue(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.SCAN_SAMPLING_TIME, 0))
@@ -867,39 +876,33 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                 or self.pj[cfg.OBSERVATIONS][obsId].get(cfg.START_FROM_CURRENT_EPOCH_TIME, False)
             )
             # day/epoch time
-            observationWindow.rb_day_time.setChecked(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.START_FROM_CURRENT_TIME, False)
-            )
-            observationWindow.rb_epoch_time.setChecked(
-                self.pj[cfg.OBSERVATIONS][obsId].get(cfg.START_FROM_CURRENT_EPOCH_TIME, False)
-            )
+            observationWindow.rb_day_time.setChecked(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.START_FROM_CURRENT_TIME, False))
+            observationWindow.rb_epoch_time.setChecked(self.pj[cfg.OBSERVATIONS][obsId].get(cfg.START_FROM_CURRENT_EPOCH_TIME, False))
 
         # observation time interval
         observationWindow.cb_observation_time_interval.setEnabled(True)
         if self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0]) != [0, 0]:
             observationWindow.cb_observation_time_interval.setChecked(True)
-            observationWindow.observation_time_interval = self.pj[cfg.OBSERVATIONS][obsId].get(
-                cfg.OBSERVATION_TIME_INTERVAL, [0, 0]
-            )
+            observationWindow.observation_time_interval = self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
             observationWindow.cb_observation_time_interval.setText(
                 (
                     "Limit observation to a time interval: "
-                    f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.OBSERVATION_TIME_INTERVAL][0]} - "
-                    f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.OBSERVATION_TIME_INTERVAL][1]}"
+                    f"{self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[0]} - "
+                    f"{self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[1]}"
                 )
             )
 
-        # disabled due to problem when video goes back
-        # if CLOSE_BEHAVIORS_BETWEEN_VIDEOS in self.pj[OBSERVATIONS][obsId]:
-        #    observationWindow.cbCloseCurrentBehaviorsBetweenVideo.setChecked(self.pj[OBSERVATIONS][obsId][CLOSE_BEHAVIORS_BETWEEN_VIDEOS])
+        if cfg.CLOSE_BEHAVIORS_BETWEEN_VIDEOS in self.pj[cfg.OBSERVATIONS][obsId]:
+            observationWindow.cbCloseCurrentBehaviorsBetweenVideo.setChecked(
+                self.pj[cfg.OBSERVATIONS][obsId][cfg.CLOSE_BEHAVIORS_BETWEEN_VIDEOS]
+            )
 
-    rv = observationWindow.exec_()
+    rv = observationWindow.exec()
 
     # save geometry
     gui_utilities.save_geometry(observationWindow, "new observation")
 
     if rv:
-
         self.project_changed()
 
         new_obs_id = observationWindow.leObservationId.text().strip()
@@ -918,14 +921,14 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
 
         # check if id changed
         if mode == cfg.EDIT and new_obs_id != obsId:
-
             logging.info(f"observation id {obsId} changed in {new_obs_id}")
 
             self.pj[cfg.OBSERVATIONS][new_obs_id] = dict(self.pj[cfg.OBSERVATIONS][obsId])
             del self.pj[cfg.OBSERVATIONS][obsId]
 
         # observation date
-        self.pj[cfg.OBSERVATIONS][new_obs_id]["date"] = observationWindow.dteDate.dateTime().toString(Qt.ISODate)
+        self.pj[cfg.OBSERVATIONS][new_obs_id]["date"] = observationWindow.dteDate.dateTime().toString("yyyy-MM-ddTHH:mm:ss.zzz")
+        # observation description
         self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.DESCRIPTION] = observationWindow.teDescription.toPlainText()
 
         # observation type: read project type from radio buttons
@@ -939,48 +942,53 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
         # independent variables for observation
         self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES] = {}
         for r in range(observationWindow.twIndepVariables.rowCount()):
-
             # set dictionary as label (col 0) => value (col 2)
             if observationWindow.twIndepVariables.item(r, 1).text() == cfg.SET_OF_VALUES:
-                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][
-                    observationWindow.twIndepVariables.item(r, 0).text()
-                ] = observationWindow.twIndepVariables.cellWidget(r, 2).currentText()
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][observationWindow.twIndepVariables.item(r, 0).text()] = (
+                    observationWindow.twIndepVariables.cellWidget(r, 2).currentText()
+                )
             elif observationWindow.twIndepVariables.item(r, 1).text() == cfg.TIMESTAMP:
-                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][
-                    observationWindow.twIndepVariables.item(r, 0).text()
-                ] = (observationWindow.twIndepVariables.cellWidget(r, 2).dateTime().toString(Qt.ISODate))
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][observationWindow.twIndepVariables.item(r, 0).text()] = (
+                    observationWindow.twIndepVariables.cellWidget(r, 2).dateTime().toString(Qt.ISODate)
+                )
             else:
-                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][
-                    observationWindow.twIndepVariables.item(r, 0).text()
-                ] = observationWindow.twIndepVariables.item(r, 2).text()
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.INDEPENDENT_VARIABLES][observationWindow.twIndepVariables.item(r, 0).text()] = (
+                    observationWindow.twIndepVariables.item(r, 2).text()
+                )
 
         # observation time offset
-        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TIME_OFFSET] = observationWindow.obs_time_offset.get_time()
+        if observationWindow.cb_time_offset.isChecked():
+            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TIME_OFFSET] = observationWindow.obs_time_offset.get_time()
+        else:
+            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TIME_OFFSET] = dec("0.0")
+
+        # add date (epoch) if date offset checked
+        # if observationWindow.cb_date_offset.isChecked():
+        #    print(f"{observationWindow.de_date_offset.date().toString(Qt.ISODate)=}")
+        #    date_timestamp = dec(dt.datetime.strptime(observationWindow.de_date_offset.date().toString(Qt.ISODate), "%Y-%m-%d").timestamp())
+        #    self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TIME_OFFSET] += date_timestamp
 
         if observationWindow.cb_observation_time_interval.isChecked():
-            self.pj[cfg.OBSERVATIONS][new_obs_id][
-                cfg.OBSERVATION_TIME_INTERVAL
-            ] = observationWindow.observation_time_interval
+            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.OBSERVATION_TIME_INTERVAL] = observationWindow.observation_time_interval
 
         self.display_statusbar_info(new_obs_id)
 
         # visualize spectrogram
-        self.pj[cfg.OBSERVATIONS][new_obs_id][
-            cfg.VISUALIZE_SPECTROGRAM
-        ] = observationWindow.cbVisualizeSpectrogram.isChecked()
-        # visualize spectrogram
-        self.pj[cfg.OBSERVATIONS][new_obs_id][
-            cfg.VISUALIZE_WAVEFORM
-        ] = observationWindow.cb_visualize_waveform.isChecked()
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.VISUALIZE_SPECTROGRAM] = observationWindow.cbVisualizeSpectrogram.isChecked()
+        # visualize waveform
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.VISUALIZE_WAVEFORM] = observationWindow.cb_visualize_waveform.isChecked()
+        # use Creation date metadata tag as offset
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_CREATION_DATE_AS_OFFSET] = (
+            observationWindow.cb_media_creation_date_as_offset.isChecked()
+        )
+
+        # media scan sampling
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_SCAN_SAMPLING_DURATION] = observationWindow.sb_media_scan_sampling.value()
         # image display duration
-        self.pj[cfg.OBSERVATIONS][new_obs_id][
-            cfg.IMAGE_DISPLAY_DURATION
-        ] = observationWindow.sb_image_display_duration.value()
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.IMAGE_DISPLAY_DURATION] = observationWindow.sb_image_display_duration.value()
 
         # time interval for observation
-        self.pj[cfg.OBSERVATIONS][new_obs_id][
-            cfg.OBSERVATION_TIME_INTERVAL
-        ] = observationWindow.observation_time_interval
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.OBSERVATION_TIME_INTERVAL] = observationWindow.observation_time_interval
 
         # plot data
         if observationWindow.tw_data_files.rowCount():
@@ -989,30 +997,27 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)] = {}
                 for idx2 in cfg.DATA_PLOT_FIELDS:
                     if idx2 in [cfg.PLOT_DATA_PLOTCOLOR_IDX, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX]:
-                        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][
-                            cfg.DATA_PLOT_FIELDS[idx2]
-                        ] = observationWindow.tw_data_files.cellWidget(row, idx2).currentText()
+                        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][cfg.DATA_PLOT_FIELDS[idx2]] = (
+                            observationWindow.tw_data_files.cellWidget(row, idx2).currentText()
+                        )
 
                     elif idx2 == cfg.PLOT_DATA_CONVERTERS_IDX:
                         if observationWindow.tw_data_files.item(row, idx2).text():
-                            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][
-                                cfg.DATA_PLOT_FIELDS[idx2]
-                            ] = eval(observationWindow.tw_data_files.item(row, idx2).text())
+                            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][cfg.DATA_PLOT_FIELDS[idx2]] = eval(
+                                observationWindow.tw_data_files.item(row, idx2).text()
+                            )
                         else:
-                            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][
-                                cfg.DATA_PLOT_FIELDS[idx2]
-                            ] = {}
+                            self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][cfg.DATA_PLOT_FIELDS[idx2]] = {}
 
                     else:
-                        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][
-                            cfg.DATA_PLOT_FIELDS[idx2]
-                        ] = observationWindow.tw_data_files.item(row, idx2).text()
+                        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.PLOT_DATA][str(row)][cfg.DATA_PLOT_FIELDS[idx2]] = (
+                            observationWindow.tw_data_files.item(row, idx2).text()
+                        )
 
         # Close current behaviors between video
-        # disabled due to problem when video goes back
-        # self.pj[OBSERVATIONS][new_obs_id][CLOSE_BEHAVIORS_BETWEEN_VIDEOS] =
-        # observationWindow.cbCloseCurrentBehaviorsBetweenVideo.isChecked()
-        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.CLOSE_BEHAVIORS_BETWEEN_VIDEOS] = False
+        self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.CLOSE_BEHAVIORS_BETWEEN_VIDEOS] = (
+            observationWindow.cbCloseCurrentBehaviorsBetweenVideo.isChecked()
+        )
 
         if self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TYPE] == cfg.LIVE:
             self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.SCAN_SAMPLING_TIME] = observationWindow.sbScanSampling.value()
@@ -1026,10 +1031,23 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
         # images dir
         if self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TYPE] == cfg.IMAGES:
             self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.DIRECTORIES_LIST] = [
-                observationWindow.lw_images_directory.item(i).text()
-                for i in range(observationWindow.lw_images_directory.count())
+                observationWindow.lw_images_directory.item(i).text() for i in range(observationWindow.lw_images_directory.count())
             ]
+
+            # check if exif data must be used
             self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.USE_EXIF_DATE] = observationWindow.rb_use_exif.isChecked()
+
+            # ask if the value of the exif date time of the first picture must be substracted
+            # TODO: improve this
+            if self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.USE_EXIF_DATE]:
+                response = dialog.MessageDialog(
+                    cfg.programName,
+                    "You choose to use the EXIF metadata. Do you want to substract the date time value of the first picture?",
+                    (cfg.YES, cfg.NO),
+                )
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.SUBSTRACT_FIRST_EXIF_DATE] = response == cfg.YES
+
+            # check if time lapse
             if observationWindow.rb_time_lapse.isChecked():
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TIME_LAPSE] = observationWindow.sb_time_lapse.value()
             else:
@@ -1040,17 +1058,19 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
 
         # media
         if self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.TYPE] == cfg.MEDIA:
-
             self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO] = {
                 cfg.LENGTH: observationWindow.mediaDurations,
                 cfg.FPS: observationWindow.mediaFPS,
             }
 
+            if self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_CREATION_DATE_AS_OFFSET]:
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO][cfg.MEDIA_CREATION_TIME] = observationWindow.media_creation_time
+
             try:
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO][cfg.HAS_VIDEO] = observationWindow.mediaHasVideo
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO][cfg.HAS_AUDIO] = observationWindow.mediaHasAudio
             except Exception:
-                logging.info("error with media_info information")
+                logging.warning("error with media_info information")
 
             self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO]["offset"] = {}
 
@@ -1060,9 +1080,9 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.FILE][str(i + 1)] = []
 
             for row in range(observationWindow.twVideo1.rowCount()):
-                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.FILE][
-                    observationWindow.twVideo1.cellWidget(row, 0).currentText()
-                ].append(observationWindow.twVideo1.item(row, 2).text())
+                self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.FILE][observationWindow.twVideo1.cellWidget(row, 0).currentText()].append(
+                    observationWindow.twVideo1.item(row, 2).text()
+                )
                 # store offset for media player
                 self.pj[cfg.OBSERVATIONS][new_obs_id][cfg.MEDIA_INFO]["offset"][
                     observationWindow.twVideo1.cellWidget(row, 0).currentText()
@@ -1084,11 +1104,11 @@ def new_observation(self, mode=cfg.NEW, obsId=""):
 
             if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
                 self.playerType = cfg.MEDIA
-                # load events in table widget
-                initialize_new_media_observation(self)
+                if not initialize_new_media_observation(self):
+                    close_observation(self)
+                    return "Observation not launched"
 
             if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
-                # QMessageBox.critical(self, cfg.programName, "Observation from images directory is not yet implemented")
                 initialize_new_images_observation(self)
 
             self.load_tw_events(self.observationId)
@@ -1100,10 +1120,10 @@ def close_observation(self):
     close current observation
     """
 
-    logging.info(f"Close observation {self.playerType}")
+    logging.info(f"Close observation (player type: {self.playerType})")
+
+    # check observation state events
 
-    logging.info(f"Check state events")
-    # check observation events
     flag_ok, msg = project_functions.check_state_events_obs(
         self.observationId,
         self.pj[cfg.ETHOGRAM],
@@ -1112,58 +1132,35 @@ def close_observation(self):
     )
 
     if not flag_ok:
-
         out = f"The current observation has state event(s) that are not PAIRED:<br><br>{msg}"
-        results = dialog.Results_dialog()
+        results = dialog.Results_dialog_exit_code()
         results.setWindowTitle(f"{cfg.programName} - Check selected observations")
         results.ptText.setReadOnly(True)
         results.ptText.appendHtml(out)
-        results.pbSave.setVisible(False)
-        results.pbCancel.setText("Close observation")
-        results.pbCancel.setVisible(True)
-        results.pbOK.setText("Fix unpaired state events")
-
-        if results.exec_():  # fix events
-
-            w = dialog.Ask_time(self.timeFormat)
-            w.setWindowTitle("Fix UNPAIRED state events")
-            w.label.setText("Fix UNPAIRED events at time")
-
-            if w.exec_():
-                fix_at_time = w.time_widget.get_time()
-                events_to_add = project_functions.fix_unpaired_state_events(
-                    self.pj[cfg.ETHOGRAM],
-                    self.pj[cfg.OBSERVATIONS][self.observationId],
-                    fix_at_time - dec("0.001"),
-                )
-                if events_to_add:
-                    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].extend(events_to_add)
-                    self.project_changed()
-                    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort()
-
-                    self.load_tw_events(self.observationId)
-                    item = self.twEvents.item(
-                        [
-                            i
-                            for i, t in enumerate(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS])
-                            if t[0] == fix_at_time
-                        ][0],
-                        0,
-                    )
-                    self.twEvents.scrollToItem(item)
-                    return
-            else:
-                return
 
-    logging.info(f"Check state events done")
+        results.pb1.setText("Close observation")
+        results.pb2.setText("Return to observation")
+        if self.playerType == cfg.IMAGES:
+            results.pb3.setVisible(False)
+        else:
+            results.pb3.setText("Fix unpaired state events")
+
+        r = results.exec()
+        if r == 2:  # Return to observation
+            return
+        if r == 3:  # Fix unpaired state events
+            state_events.fix_unpaired_events(self, silent_mode=True)
 
     self.saved_state = self.saveState()
 
     if self.playerType == cfg.MEDIA:
-
-        logging.info(f"Stop plot timer")
+        self.media_scan_sampling_mem = []
+        logging.info("Stop plot timer")
         self.plot_timer.stop()
 
+        if self.MPV_IPC_MODE:
+            self.main_window_activation_timer.stop()
+
         for i, player in enumerate(self.dw_player):
             if (
                 str(i + 1) in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE]
@@ -1172,6 +1169,16 @@ def close_observation(self):
                 logging.info(f"Stop player #{i + 1}")
                 player.player.stop()
 
+                if self.MPV_IPC_MODE:
+                    try:
+                        player.player.process.terminate()
+                        try:
+                            player.player.process.wait(timeout=3)  # wait up to 3s
+                        except subprocess.TimeoutExpired:
+                            player.player.process.kill()  # force if still alive
+                    except Exception as e:
+                        logging.warning(f"Error stopping MPV process #{i}: {e}")
+
         self.verticalLayout_3.removeWidget(self.video_slider)
 
         if self.video_slider is not None:
@@ -1186,21 +1193,22 @@ def close_observation(self):
         self.liveObservationStarted = False
         self.liveStartTime = None
 
-    if (
-        cfg.PLOT_DATA in self.pj[cfg.OBSERVATIONS][self.observationId]
-        and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA]
-    ):
+    if cfg.PLOT_DATA in self.pj[cfg.OBSERVATIONS][self.observationId] and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA]:
         for x in self.ext_data_timer_list:
             x.stop()
         for pd in self.plot_data:
             self.plot_data[pd].close_plot()
 
-    logging.info(f"close tool window")
+    logging.info("close tool window")
 
     self.close_tool_windows()
 
     self.observationId = ""
 
+    # delete undo queue
+    self.undo_queue = deque()
+    self.undo_description = deque()
+
     if self.playerType in (cfg.MEDIA, cfg.IMAGES):
         """
         for idx, _ in enumerate(self.dw_player):
@@ -1211,10 +1219,11 @@ def close_observation(self):
         """
 
         for dw in self.dw_player:
-
-            logging.info(f"remove dock widget")
-
+            logging.info("remove dock widget")
+            dw.player.log_handler = None
             self.removeDockWidget(dw)
+
+            del dw
             # sip.delete(dw)
             # dw = None
 
@@ -1226,10 +1235,12 @@ def close_observation(self):
 
     self.w_obs_info.setVisible(False)
 
-    self.twEvents.setRowCount(0)
+    # self.twEvents.setRowCount(0)
 
     self.lb_current_media_time.clear()
     self.lb_player_status.clear()
+    self.lb_video_info.clear()
+    self.lb_zoom_level.clear()
 
     self.currentSubject = ""
     self.lbFocalSubject.setText(cfg.NO_FOCAL_SUBJECT)
@@ -1238,7 +1249,7 @@ def close_observation(self):
     for i in range(self.twSubjects.rowCount()):
         self.twSubjects.item(i, len(cfg.subjectsFields)).setText("")
 
-    for w in [self.lbTimeOffset, self.lbSpeed, self.lb_obs_time_interval]:
+    for w in (self.lbTimeOffset, self.lb_obs_time_interval):
         w.clear()
     self.play_rate, self.playerType = 1, ""
 
@@ -1247,6 +1258,70 @@ def close_observation(self):
     logging.info(f"Observation {self.playerType} closed")
 
 
+def check_creation_date(self) -> Tuple[int, dict]:
+    """
+    check if media file exists
+    check if Creation Date tag is present in metadata of media file
+
+    Returns:
+        int: 0 if OK else error code: 1 -> media file date not used, 2 -> media file not found
+
+    """
+
+    not_tagged_media_list: list = []
+    media_creation_time: dict = {}
+
+    for nplayer in cfg.ALL_PLAYERS:
+        if nplayer in self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.FILE, {}):
+            for media_file in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][nplayer]:
+                media_path = project_functions.full_path(media_file, self.projectFileName)
+                media_info = util.accurate_media_analysis(self.ffmpeg_bin, media_path)
+
+                if cfg.MEDIA_CREATION_TIME not in media_info or media_info[cfg.MEDIA_CREATION_TIME] == cfg.NA:
+                    not_tagged_media_list.append(media_path)
+                else:
+                    creation_time_epoch = int(dt.datetime.strptime(media_info[cfg.MEDIA_CREATION_TIME], "%Y-%m-%d %H:%M:%S").timestamp())
+                    media_creation_time[media_path] = creation_time_epoch
+
+    """
+    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:
+                media_creation_time[media] = Path(media).stat().st_ctime
+            return (0, media_creation_time)  # OK use media file creation date/time
+        else:
+            return (1, {})
+    else:
+        return (0, media_creation_time)  # OK all media have a 'creation time' tag
+
+
 def initialize_new_media_observation(self) -> bool:
     """
     initialize new observation from media file(s)
@@ -1254,12 +1329,10 @@ def initialize_new_media_observation(self) -> bool:
 
     logging.debug("function: initialize new observation for media file(s)")
 
-    for dw in [self.dwEthogram, self.dwSubjects, self.dwEvents]:
+    for dw in (self.dwEthogram, self.dwSubjects, self.dwEvents):
         dw.setVisible(True)
 
-    ok, msg = project_functions.check_if_media_available(
-        self.pj[cfg.OBSERVATIONS][self.observationId], self.projectFileName
-    )
+    ok, msg = project_functions.check_if_media_available(self.pj[cfg.OBSERVATIONS][self.observationId], self.projectFileName)
 
     if not ok:
         QMessageBox.critical(
@@ -1287,6 +1360,8 @@ def initialize_new_media_observation(self) -> bool:
     font = QFont()
     font.setPointSize(15)
     self.lb_current_media_time.setFont(font)
+    self.lb_video_info.setFont(font)
+    self.lb_zoom_level.setFont(font)
 
     # initialize video slider
     self.video_slider = QSlider(Qt.Horizontal, self)
@@ -1298,9 +1373,20 @@ def initialize_new_media_observation(self) -> bool:
 
     # add all media files to media lists
     self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks)
-    self.dw_player: list = []
-    # create dock widgets for players
+    self.dw_player = []
+
+    # check if media creation time used as offset
+    # TODO check if cfg.MEDIA_CREATION_TIME dict is present
+    """
+    if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.MEDIA_CREATION_DATE_AS_OFFSET, False):
+        r, media_creation_time = check_creation_date(self)
 
+        if r:
+            return False
+        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.MEDIA_CREATION_TIME] = dict(media_creation_time)
+    """
+
+    # create dock widgets for players
     for i in range(cfg.N_PLAYER):
         n_player = str(i + 1)
         if (
@@ -1309,17 +1395,424 @@ def initialize_new_media_observation(self) -> bool:
         ):
             continue
 
+        # Not pretty but the unique solution I have found to capture the click signal for each player
+
         if i == 0:  # first player
-            p = player_dock_widget.DW_player(i, self)
-            self.dw_player.append(p)
+            p0 = player_dock_widget.DW_player(0, self)
 
-            @p.player.property_observer("time-pos")
-            def time_observer(_name, value):
-                if value is not None:
-                    self.time_observer_signal.emit(value)
+            if not self.MPV_IPC_MODE:
 
-        else:
-            self.dw_player.append(player_dock_widget.DW_player(i, self))
+                @p0.player.property_observer("time-pos")
+                def time_observer(_name, value):
+                    if value is not None:
+                        self.time_observer_signal.emit(value)
+
+                @p0.player.property_observer("eof-reached")
+                def eof_reached(_name, value):
+                    if value is not None:
+                        self.mpv_eof_reached_signal.emit(value)
+
+                @p0.player.on_key_press("MBTN_LEFT")
+                def mbtn_left0():
+                    self.video_click_signal.emit(0, "MBTN_LEFT")
+
+                @p0.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right0():
+                    self.video_click_signal.emit(0, "MBTN_RIGHT")
+
+                @p0.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl0():
+                    self.video_click_signal.emit(0, "MBTN_LEFT_DBL")
+
+                @p0.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl0():
+                    self.video_click_signal.emit(0, "MBTN_RIGHT_DBL")
+
+                @p0.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up0():
+                    self.video_click_signal.emit(0, "Ctrl+WHEEL_UP")
+
+                @p0.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down0():
+                    self.video_click_signal.emit(0, "Ctrl+WHEEL_DOWN")
+
+                @p0.player.on_key_press("WHEEL_UP")
+                def wheel_up0():
+                    self.video_click_signal.emit(0, "WHEEL_UP")
+
+                @p0.player.on_key_press("WHEEL_DOWN")
+                def wheel_down0():
+                    self.video_click_signal.emit(0, "WHEEL_DOWN")
+
+                @p0.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up0():
+                    self.video_click_signal.emit(0, "Shift+WHEEL_UP")
+
+                @p0.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down0():
+                    self.video_click_signal.emit(0, "Shift+WHEEL_DOWN")
+
+                @p0.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left0():
+                    self.video_click_signal.emit(0, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p0)
+
+        if i == 1:  # second player
+            p1 = player_dock_widget.DW_player(1, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p1.player.on_key_press("MBTN_LEFT")
+                def mbtn_left1():
+                    self.video_click_signal.emit(1, "MBTN_LEFT")
+
+                @p1.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right1():
+                    self.video_click_signal.emit(1, "MBTN_RIGHT")
+
+                @p1.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl1():
+                    self.video_click_signal.emit(1, "MBTN_LEFT_DBL")
+
+                @p1.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl1():
+                    self.video_click_signal.emit(1, "MBTN_RIGHT_DBL")
+
+                @p1.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up1():
+                    self.video_click_signal.emit(1, "Ctrl+WHEEL_UP")
+
+                @p1.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down1():
+                    self.video_click_signal.emit(1, "Ctrl+WHEEL_DOWN")
+
+                @p1.player.on_key_press("WHEEL_UP")
+                def wheel_up1():
+                    self.video_click_signal.emit(1, "WHEEL_UP")
+
+                @p1.player.on_key_press("WHEEL_DOWN")
+                def wheel_down1():
+                    self.video_click_signal.emit(1, "WHEEL_DOWN")
+
+                @p1.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up1():
+                    self.video_click_signal.emit(1, "Shift+WHEEL_UP")
+
+                @p1.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down1():
+                    self.video_click_signal.emit(1, "Shift+WHEEL_DOWN")
+
+                @p1.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left1():
+                    self.video_click_signal.emit(1, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p1)
+
+        if i == 2:
+            p2 = player_dock_widget.DW_player(2, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p2.player.on_key_press("MBTN_LEFT")
+                def mbtn_left2():
+                    self.video_click_signal.emit(2, "MBTN_LEFT")
+
+                @p2.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right2():
+                    self.video_click_signal.emit(2, "MBTN_RIGHT")
+
+                @p2.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl2():
+                    self.video_click_signal.emit(2, "MBTN_LEFT_DBL")
+
+                @p2.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl2():
+                    self.video_click_signal.emit(2, "MBTN_RIGHT_DBL")
+
+                @p2.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up2():
+                    self.video_click_signal.emit(2, "Ctrl+WHEEL_UP")
+
+                @p2.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down2():
+                    self.video_click_signal.emit(2, "Ctrl+WHEEL_DOWN")
+
+                @p2.player.on_key_press("WHEEL_UP")
+                def wheel_up2():
+                    self.video_click_signal.emit(2, "WHEEL_UP")
+
+                @p2.player.on_key_press("WHEEL_DOWN")
+                def wheel_down2():
+                    self.video_click_signal.emit(2, "WHEEL_DOWN")
+
+                @p2.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up2():
+                    self.video_click_signal.emit(2, "Shift+WHEEL_UP")
+
+                @p2.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down2():
+                    self.video_click_signal.emit(2, "Shift+WHEEL_DOWN")
+
+                @p2.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left2():
+                    self.video_click_signal.emit(2, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p2)
+
+        if i == 3:
+            p3 = player_dock_widget.DW_player(3, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p3.player.on_key_press("MBTN_LEFT")
+                def mbtn_left3():
+                    self.video_click_signal.emit(3, "MBTN_LEFT")
+
+                @p3.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right3():
+                    self.video_click_signal.emit(3, "MBTN_RIGHT")
+
+                @p3.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl3():
+                    self.video_click_signal.emit(3, "MBTN_LEFT_DBL")
+
+                @p3.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl3():
+                    self.video_click_signal.emit(3, "MBTN_RIGHT_DBL")
+
+                @p3.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up3():
+                    self.video_click_signal.emit(3, "Ctrl+WHEEL_UP")
+
+                @p3.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down3():
+                    self.video_click_signal.emit(3, "Ctrl+WHEEL_DOWN")
+
+                @p3.player.on_key_press("WHEEL_UP")
+                def wheel_up3():
+                    self.video_click_signal.emit(3, "WHEEL_UP")
+
+                @p3.player.on_key_press("WHEEL_DOWN")
+                def wheel_down3():
+                    self.video_click_signal.emit(3, "WHEEL_DOWN")
+
+                @p3.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up3():
+                    self.video_click_signal.emit(3, "Shift+WHEEL_UP")
+
+                @p3.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down3():
+                    self.video_click_signal.emit(3, "Shift+WHEEL_DOWN")
+
+                @p3.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left3():
+                    self.video_click_signal.emit(3, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p3)
+
+        if i == 4:
+            p4 = player_dock_widget.DW_player(4, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p4.player.on_key_press("MBTN_LEFT")
+                def mbtn_left4():
+                    self.video_click_signal.emit(4, "MBTN_LEFT")
+
+                @p4.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right4():
+                    self.video_click_signal.emit(4, "MBTN_RIGHT")
+
+                @p4.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl4():
+                    self.video_click_signal.emit(4, "MBTN_LEFT_DBL")
+
+                @p4.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl4():
+                    self.video_click_signal.emit(4, "MBTN_RIGHT_DBL")
+
+                @p4.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up4():
+                    self.video_click_signal.emit(4, "Ctrl+WHEEL_UP")
+
+                @p4.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down4():
+                    self.video_click_signal.emit(4, "Ctrl+WHEEL_DOWN")
+
+                @p4.player.on_key_press("WHEEL_UP")
+                def wheel_up4():
+                    self.video_click_signal.emit(4, "WHEEL_UP")
+
+                @p4.player.on_key_press("WHEEL_DOWN")
+                def wheel_down4():
+                    self.video_click_signal.emit(4, "WHEEL_DOWN")
+
+                @p4.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up4():
+                    self.video_click_signal.emit(4, "Shift+WHEEL_UP")
+
+                @p4.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down4():
+                    self.video_click_signal.emit(4, "Shift+WHEEL_DOWN")
+
+                @p4.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left4():
+                    self.video_click_signal.emit(4, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p4)
+
+        if i == 5:
+            p5 = player_dock_widget.DW_player(5, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p5.player.on_key_press("MBTN_LEFT")
+                def mbtn_left5():
+                    self.video_click_signal.emit(5, "MBTN_LEFT")
+
+                @p5.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right5():
+                    self.video_click_signal.emit(5, "MBTN_RIGHT")
+
+                @p5.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl5():
+                    self.video_click_signal.emit(5, "MBTN_LEFT_DBL")
+
+                @p5.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl5():
+                    self.video_click_signal.emit(5, "MBTN_RIGHT_DBL")
+
+                @p5.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up5():
+                    self.video_click_signal.emit(5, "Ctrl+WHEEL_UP")
+
+                @p5.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down5():
+                    self.video_click_signal.emit(5, "Ctrl+WHEEL_DOWN")
+
+                @p5.player.on_key_press("WHEEL_UP")
+                def wheel_up5():
+                    self.video_click_signal.emit(5, "WHEEL_UP")
+
+                @p5.player.on_key_press("WHEEL_DOWN")
+                def wheel_down5():
+                    self.video_click_signal.emit(5, "WHEEL_DOWN")
+
+                @p5.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up5():
+                    self.video_click_signal.emit(5, "Shift+WHEEL_UP")
+
+                @p5.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down5():
+                    self.video_click_signal.emit(5, "Shift+WHEEL_DOWN")
+
+                @p5.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left5():
+                    self.video_click_signal.emit(5, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p5)
+
+        if i == 6:
+            p6 = player_dock_widget.DW_player(6, self)
+            if not self.MPV_IPC_MODE:
+
+                @p6.player.on_key_press("MBTN_LEFT")
+                def mbtn_left6():
+                    self.video_click_signal.emit(6, "MBTN_LEFT")
+
+                @p6.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right6():
+                    self.video_click_signal.emit(6, "MBTN_RIGHT")
+
+                @p6.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl6():
+                    self.video_click_signal.emit(6, "MBTN_LEFT_DBL")
+
+                @p6.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl6():
+                    self.video_click_signal.emit(6, "MBTN_RIGHT_DBL")
+
+                @p6.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up6():
+                    self.video_click_signal.emit(6, "Ctrl+WHEEL_UP")
+
+                @p6.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down6():
+                    self.video_click_signal.emit(6, "Ctrl+WHEEL_DOWN")
+
+                @p6.player.on_key_press("WHEEL_UP")
+                def wheel_up6():
+                    self.video_click_signal.emit(6, "WHEEL_UP")
+
+                @p6.player.on_key_press("WHEEL_DOWN")
+                def wheel_down6():
+                    self.video_click_signal.emit(6, "WHEEL_DOWN")
+
+                @p6.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up6():
+                    self.video_click_signal.emit(6, "Shift+WHEEL_UP")
+
+                @p6.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down6():
+                    self.video_click_signal.emit(6, "Shift+WHEEL_DOWN")
+
+                @p6.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left6():
+                    self.video_click_signal.emit(6, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p6)
+
+        if i == 7:
+            p7 = player_dock_widget.DW_player(7, self)
+
+            if not self.MPV_IPC_MODE:
+
+                @p7.player.on_key_press("MBTN_LEFT")
+                def mbtn_left7():
+                    self.video_click_signal.emit(7, "MBTN_LEFT")
+
+                @p7.player.on_key_press("MBTN_RIGHT")
+                def mbtn_right7():
+                    self.video_click_signal.emit(7, "MBTN_RIGHT")
+
+                @p7.player.on_key_press("MBTN_LEFT_DBL")
+                def mbtn_left_dbl7():
+                    self.video_click_signal.emit(7, "MBTN_LEFT_DBL")
+
+                @p7.player.on_key_press("MBTN_RIGHT_DBL")
+                def mbtn_right_dbl7():
+                    self.video_click_signal.emit(7, "MBTN_RIGHT_DBL")
+
+                @p7.player.on_key_press("Ctrl+WHEEL_UP")
+                def ctrl_wheel_up7():
+                    self.video_click_signal.emit(7, "Ctrl+WHEEL_UP")
+
+                @p7.player.on_key_press("Ctrl+WHEEL_DOWN")
+                def ctrl_wheel_down7():
+                    self.video_click_signal.emit(7, "Ctrl+WHEEL_DOWN")
+
+                @p7.player.on_key_press("WHEEL_UP")
+                def wheel_up7():
+                    self.video_click_signal.emit(7, "WHEEL_UP")
+
+                @p7.player.on_key_press("WHEEL_DOWN")
+                def wheel_down7():
+                    self.video_click_signal.emit(7, "WHEEL_DOWN")
+
+                @p7.player.on_key_press("Shift+WHEEL_UP")
+                def shift_wheel_up7():
+                    self.video_click_signal.emit(7, "Shift+WHEEL_UP")
+
+                @p7.player.on_key_press("Shift+WHEEL_DOWN")
+                def shift_wheel_down7():
+                    self.video_click_signal.emit(7, "Shift+WHEEL_DOWN")
+
+                @p7.player.on_key_press("Shift+MBTN_LEFT")
+                def shift_mbtn_left7():
+                    self.video_click_signal.emit(7, "Shift+MBTN_LEFT")
+
+            self.dw_player.append(p7)
 
         self.dw_player[-1].setFloating(False)
         self.dw_player[-1].setVisible(False)
@@ -1339,12 +1832,11 @@ def initialize_new_media_observation(self) -> bool:
         # for receiving event from volume slider
         self.dw_player[i].volume_slider_moved_signal.connect(self.set_volume)
 
+        # for receiving event from mute toolbutton
+        self.dw_player[i].mute_action_triggered_signal.connect(self.set_mute)
+
         # for receiving resize event from dock widget
         self.dw_player[i].resize_signal.connect(self.resize_dw)
-        """
-        # for receiving event resize and clicked (Zoom - crop)
-        self.dw_player[i].view_signal.connect(self.signal_from_dw)
-        """
 
         # add durations list
         self.dw_player[i].media_durations = []
@@ -1353,8 +1845,21 @@ def initialize_new_media_observation(self) -> bool:
         # add fps list
         self.dw_player[i].fps = {}
 
-        for mediaFile in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][n_player]:
+        if self.MPV_IPC_MODE:
+            while True:
+                r = util.test_mpv_ipc(f"{cfg.MPV_SOCKET}{i}")
+                logging.debug(f"MPV IPC started: {r}")
+                if r:
+                    break
 
+            # start timer for activating the main window
+            self.main_window_activation_timer = QTimer()
+            self.main_window_activation_timer.setInterval(500)
+            # self.main_window_activation_timer.timeout.connect(self.activateWindow)
+            self.main_window_activation_timer.timeout.connect(self.activate_main_window)
+            self.main_window_activation_timer.start()
+
+        for mediaFile in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][n_player]:
             logging.debug(f"media file: {mediaFile}")
 
             media_full_path = project_functions.full_path(mediaFile, self.projectFileName)
@@ -1363,13 +1868,10 @@ def initialize_new_media_observation(self) -> bool:
 
             # media duration
             try:
-                mediaLength = (
-                    self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.LENGTH][mediaFile] * 1000
-                )
+                mediaLength = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.LENGTH][mediaFile] * 1000
                 mediaFPS = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.FPS][mediaFile]
             except Exception:
-
-                logging.debug("media_info key not found")
+                logging.debug("media_info key not found in project")
 
                 r = util.accurate_media_analysis(self.ffmpeg_bin, media_full_path)
                 if "error" not in r:
@@ -1392,67 +1894,76 @@ def initialize_new_media_observation(self) -> bool:
                     self.project_changed()
 
             self.dw_player[i].media_durations.append(int(mediaLength))
-            self.dw_player[i].cumul_media_durations.append(
-                self.dw_player[i].cumul_media_durations[-1] + int(mediaLength)
-            )
+            self.dw_player[i].cumul_media_durations.append(self.dw_player[i].cumul_media_durations[-1] + int(mediaLength))
 
             self.dw_player[i].fps[mediaFile] = mediaFPS
 
+            # add media file to playlist
             self.dw_player[i].player.playlist_append(media_full_path)
-            # self.dw_player[i].player.loadfile(media_full_path)
-            # self.dw_player[i].player.pause = True
 
-        # check if BORIS is running on a Windows VM with WMIC COMPUTERSYSTEM GET SERIALNUMBER
+            # add media file name to player window title
+            self.dw_player[i].setWindowTitle(f"Player #{i + 1} ({Path(media_full_path).name})")
+
+        # media duration cumuled in seconds
+        self.dw_player[i].cumul_media_durations_sec = [round(dec(x / 1000), 3) for x in self.dw_player[i].cumul_media_durations]
+
+        # check if BORIS is running on a Windows VM with the 'WMIC COMPUTERSYSTEM GET SERIALNUMBER' command
         # because "auto" or "auto-safe" crash in Windows VM
         # see https://superuser.com/questions/1128339/how-can-i-detect-if-im-within-a-vm-or-not
 
-        flag_vm = False
-        if sys.platform.startswith("win"):
-            p = subprocess.Popen(
-                ["WMIC", "BIOS", "GET", "SERIALNUMBER"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                shell=True,
-            )
-            out, _ = p.communicate()
-            flag_vm = b"SerialNumber  \r\r\n0 " in out
-            logging.debug(f"Running on Windows VM: {flag_vm}")
+        if not self.MPV_IPC_MODE:
+            flag_vm = False
+            if sys.platform.startswith("win"):
+                p = subprocess.Popen(
+                    ["WMIC", "BIOS", "GET", "SERIALNUMBER"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    shell=True,
+                )
+                out, _ = p.communicate()
+                flag_vm = b"SerialNumber  \r\r\n0 " in out
+                logging.debug(f"Running on Windows VM: {flag_vm}")
 
-        if not flag_vm:
-            self.dw_player[i].player.hwdec = self.config_param.get(cfg.MPV_HWDEC, cfg.MPV_HWDEC_DEFAULT_VALUE)
-        else:
-            self.dw_player[i].player.hwdec = "no"
+            if not flag_vm:
+                self.dw_player[i].player.hwdec = self.config_param.get(cfg.MPV_HWDEC, cfg.MPV_HWDEC_DEFAULT_VALUE)
+            else:
+                self.dw_player[i].player.hwdec = cfg.MPV_HWDEC_NO
+
+            logging.debug(f"Player hwdec of player #{i} set to: {self.dw_player[i].player.hwdec}")
+            self.config_param[cfg.MPV_HWDEC] = self.dw_player[i].player.hwdec
 
         self.dw_player[i].player.playlist_pos = 0
         self.dw_player[i].player.wait_until_playing()
         self.dw_player[i].player.pause = True
-        self.dw_player[i].player.wait_until_paused()
+        time.sleep(0.2)
+        # self.dw_player[i].player.wait_until_paused()
         self.dw_player[i].player.seek(0, "absolute")
         # do not close when playing finished
         self.dw_player[i].player.keep_open = True
         self.dw_player[i].player.keep_open_pause = False
 
-        self.dw_player[i].player.image_display_duration = self.pj[cfg.OBSERVATIONS][self.observationId].get(
-            cfg.IMAGE_DISPLAY_DURATION, 1
-        )
+        self.dw_player[i].player.image_display_duration = self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.IMAGE_DISPLAY_DURATION, 1)
 
         # position media
-        if cfg.OBSERVATION_TIME_INTERVAL in self.pj[cfg.OBSERVATIONS][self.observationId]:
-            self.seek_mediaplayer(
-                int(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.OBSERVATION_TIME_INTERVAL][0]), player=i
-            )
+        self.seek_mediaplayer(int(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[0]), player=i)
 
-        # restore zoom level
+        # restore video zoom level
         if cfg.ZOOM_LEVEL in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
             self.dw_player[i].player.video_zoom = log2(
                 self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.ZOOM_LEVEL].get(n_player, 0)
             )
 
+        # restore video pan
+        if cfg.PAN_X in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
+            self.dw_player[i].player.video_pan_x = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.PAN_X].get(n_player, 0)
+        if cfg.PAN_Y in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
+            self.dw_player[i].player.video_pan_y = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.PAN_Y].get(n_player, 0)
+
         # restore rotation angle
         if cfg.ROTATION_ANGLE in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
-            self.dw_player[i].player.video_rotate = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][
-                cfg.ROTATION_ANGLE
-            ].get(n_player, 0)
+            self.dw_player[i].player.video_rotate = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.ROTATION_ANGLE].get(
+                n_player, 0
+            )
 
         # restore subtitle visibility
         if cfg.DISPLAY_MEDIA_SUBTITLES in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
@@ -1461,7 +1972,6 @@ def initialize_new_media_observation(self) -> bool:
             ].get(n_player, True)
 
         # restore overlays
-
         if cfg.OVERLAY in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:
             if n_player in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.OVERLAY]:
                 self.overlays[i] = self.dw_player[i].player.create_image_overlay()
@@ -1469,9 +1979,20 @@ def initialize_new_media_observation(self) -> bool:
 
     menu_options.update_menu(self)
 
-    self.time_observer_signal.connect(self.mpv_timer_out)
+    if self.MPV_IPC_MODE:
+        # activate timer
+        self.ipc_mpv_timer = QTimer()
+        self.ipc_mpv_timer.setInterval(500)
+        self.ipc_mpv_timer.timeout.connect(self.mpv_timer_out)
+
+    else:
+        self.ipc_mpv_timer = None
+        self.time_observer_signal.connect(self.mpv_timer_out)
 
-    self.actionPlay.setIcon(QIcon(":/play"))
+    self.mpv_eof_reached_signal.connect(self.mpv_eof_reached)
+    self.video_click_signal.connect(self.player_clicked)
+
+    self.actionPlay.setIcon(QIcon(f":/play_{gui_utilities.theme_mode()}"))
 
     self.display_statusbar_info(self.observationId)
 
@@ -1480,24 +2001,17 @@ def initialize_new_media_observation(self) -> bool:
     self.state_behaviors_codes = tuple(util.state_behavior_codes(self.pj[cfg.ETHOGRAM]))
 
     video_operations.display_play_rate(self)
+    video_operations.display_zoom_level(self)
 
     # spectrogram
     if (
         cfg.VISUALIZE_SPECTROGRAM in self.pj[cfg.OBSERVATIONS][self.observationId]
         and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.VISUALIZE_SPECTROGRAM]
     ):
-
-        tmp_dir = (
-            self.ffmpeg_cache_dir
-            if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir)
-            else tempfile.gettempdir()
-        )
+        tmp_dir = self.ffmpeg_cache_dir if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir) else tempfile.gettempdir()
 
         wav_file_path = (
-            pl.Path(tmp_dir)
-            / pl.Path(
-                self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav"
-            ).name
+            Path(tmp_dir) / Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
         )
 
         if not wav_file_path.is_file():
@@ -1510,18 +2024,10 @@ def initialize_new_media_observation(self) -> bool:
         cfg.VISUALIZE_WAVEFORM in self.pj[cfg.OBSERVATIONS][self.observationId]
         and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.VISUALIZE_WAVEFORM]
     ):
-
-        tmp_dir = (
-            self.ffmpeg_cache_dir
-            if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir)
-            else tempfile.gettempdir()
-        )
+        tmp_dir = self.ffmpeg_cache_dir if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir) else tempfile.gettempdir()
 
         wav_file_path = (
-            pl.Path(tmp_dir)
-            / pl.Path(
-                self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav"
-            ).name
+            Path(tmp_dir) / Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
         )
 
         if not wav_file_path.is_file():
@@ -1530,11 +2036,7 @@ def initialize_new_media_observation(self) -> bool:
         self.show_plot_widget("waveform", warning=False)
 
     # external data plot
-    if (
-        cfg.PLOT_DATA in self.pj[cfg.OBSERVATIONS][self.observationId]
-        and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA]
-    ):
-
+    if cfg.PLOT_DATA in self.pj[cfg.OBSERVATIONS][self.observationId] and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA]:
         self.plot_data = {}
         self.ext_data_timer_list = []
         count = 0
@@ -1549,9 +2051,7 @@ def initialize_new_media_observation(self) -> bool:
                     QMessageBox.critical(
                         self,
                         cfg.programName,
-                        "Data file not found:\n{}".format(
-                            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]["file_path"]
-                        ),
+                        "Data file not found:\n{}".format(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]["file_path"]),
                     )
                     data_ok = False
                     # return False
@@ -1575,7 +2075,8 @@ def initialize_new_media_observation(self) -> bool:
                         self,
                         cfg.programName,
                         (
-                            f"Impossible to plot data from file {os.path.basename(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]['file_path'])}:\n"
+                            "Impossible to plot data from file "
+                            f"{os.path.basename(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]['file_path'])}:\n"
                             f"{w1.error_msg}"
                         ),
                     )
@@ -1606,9 +2107,7 @@ def initialize_new_media_observation(self) -> bool:
                     QMessageBox.critical(
                         self,
                         cfg.programName,
-                        "Data file not found:\n{}".format(
-                            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]["file_path"]
-                        ),
+                        "Data file not found:\n{}".format(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.PLOT_DATA][idx]["file_path"]),
                     )
                     data_ok = False
                     # return False
@@ -1673,9 +2172,12 @@ def initialize_new_media_observation(self) -> bool:
     for player in self.dw_player:
         player.setVisible(True)
 
+    self.load_tw_events(self.observationId)
+
     # initial synchro
-    for n_player in range(1, len(self.dw_player)):
-        self.sync_time(n_player, 0)
+    if not self.MPV_IPC_MODE:
+        for n_player in range(1, len(self.dw_player)):
+            self.sync_time(n_player, 0)
 
     self.mpv_timer_out(value=0.0)
 
@@ -1710,6 +2212,7 @@ def initialize_new_live_observation(self):
 
     # button start enabled
     self.pb_live_obs.setEnabled(True)
+
     self.w_live.setVisible(True)
     self.w_obs_info.setVisible(True)
 
@@ -1719,9 +2222,9 @@ def initialize_new_live_observation(self):
     self.pb_live_obs.setText("Start live observation")
 
     if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.START_FROM_CURRENT_TIME, False):
-        current_time = util.seconds_of_day(datetime.datetime.now())
+        current_time = util.seconds_of_day(dt.datetime.now())
     elif self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.START_FROM_CURRENT_EPOCH_TIME, False):
-        current_time = time.mktime(datetime.datetime.now().timetuple())
+        current_time = time.mktime(dt.datetime.now().timetuple())
     else:
         current_time = 0
 
@@ -1740,6 +2243,8 @@ def initialize_new_live_observation(self):
     self.liveStartTime = None
     self.liveTimer.stop()
 
+    self.load_tw_events(self.observationId)
+
     self.get_events_current_row()
 
 
@@ -1748,16 +2253,14 @@ def initialize_new_images_observation(self):
     initialize a new observation from directories of images
     """
 
-    for dw in [self.dwEthogram, self.dwSubjects, self.dwEvents]:
+    for dw in (self.dwEthogram, self.dwSubjects, self.dwEvents):
         dw.setVisible(True)
     # disable start live button
     self.pb_live_obs.setEnabled(False)
     self.w_live.setVisible(False)
 
     # check if directories are available
-    ok, msg = project_functions.check_directories_availability(
-        self.pj[cfg.OBSERVATIONS][self.observationId], self.projectFileName
-    )
+    ok, msg = project_functions.check_directories_availability(self.pj[cfg.OBSERVATIONS][self.observationId], self.projectFileName)
 
     if not ok:
         QMessageBox.critical(
@@ -1777,7 +2280,8 @@ def initialize_new_images_observation(self):
     # count number of images in all directories
     tot_images_number = 0
     for dir_path in self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.DIRECTORIES_LIST, []):
-        result = util.dir_images_number(dir_path)
+        full_dir_path = project_functions.full_path(dir_path, self.projectFileName)
+        result = util.dir_images_number(full_dir_path)
         tot_images_number += result.get("number of images", 0)
 
     if not tot_images_number:
@@ -1785,7 +2289,7 @@ def initialize_new_images_observation(self):
             self,
             cfg.programName,
             (
-                f"No images were found in directory(ies).<br><br>The observation will be opened in VIEW mode.<br>"
+                "No images were found in directory(ies).<br><br>The observation will be opened in VIEW mode.<br>"
                 "It will not be possible to log events.<br>"
                 "Modify the directoriy path(s) to point existing directory "
             ),
@@ -1799,15 +2303,16 @@ def initialize_new_images_observation(self):
     # load image paths
     # directories user order is maintained
     # images are sorted inside each directory
-    self.images_list = []
+    self.images_list: list = []
     for dir_path in self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.DIRECTORIES_LIST, []):
+        full_dir_path = project_functions.full_path(dir_path, self.projectFileName)
         for pattern in cfg.IMAGE_EXTENSIONS:
             self.images_list.extend(
                 sorted(
                     list(
                         set(
-                            [str(x) for x in pl.Path(dir_path).glob(pattern)]
-                            + [str(x) for x in pl.Path(dir_path).glob(pattern.upper())]
+                            [str(x) for x in Path(full_dir_path).glob(pattern)]
+                            + [str(x) for x in Path(full_dir_path).glob(pattern.upper())]
                         )
                     )
                 )
@@ -1872,31 +2377,170 @@ def event2media_file_name(observation: dict, timestamp: dec) -> Optional[str]:
     """
     returns the media file name corresponding to the event (start time in case of state event)
 
+    Args:
+        observation (dict): observation
+        timestamp (dec): time stamp
+
     Returns:
-        str: name of media file containing the event
+        str: path of media file containing the event
+    """
+    if observation.get(cfg.MEDIA_CREATION_DATE_AS_OFFSET, False):
+        # media creation date/time was used for coding
+        video_file_name = None
+        for media_path in observation[cfg.MEDIA_INFO].get(cfg.MEDIA_CREATION_TIME, {}):
+            start_media = observation[cfg.MEDIA_INFO][cfg.MEDIA_CREATION_TIME][media_path]
+            duration = observation[cfg.MEDIA_INFO][cfg.LENGTH][media_path]
+            if start_media <= timestamp <= start_media + duration:
+                video_file_name = media_path
+                break
+
+    else:  # no media creation date
+        cumul_media_durations: list = [dec(0)]
+        for media_file in observation[cfg.FILE][cfg.PLAYER1]:
+            try:
+                media_duration = observation[cfg.MEDIA_INFO][cfg.LENGTH][media_file]
+                # cut off media duration to 3 decimal places as that is how fine the player is
+                media_duration = floor(media_duration * 10**3) / dec(10**3)
+                cumul_media_durations.append(floor((cumul_media_durations[-1] + media_duration) * 10**3) / dec(10**3))
+            except KeyError:
+                return None
+
+        """
+        cumul_media_durations: list = [dec(0)]
+        for media_file in observation[cfg.FILE][cfg.PLAYER1]:
+            try:
+                media_duration = dec(str(observation[cfg.MEDIA_INFO][cfg.LENGTH][media_file]))
+                cumul_media_durations.append(round(cumul_media_durations[-1] + media_duration, 3))
+            except KeyError:
+                return None
+        """
+
+        cumul_media_durations.remove(dec(0))
+
+        logging.debug(f"{cumul_media_durations=}")
+
+        # test if timestamp is at end of last media
+        if timestamp == cumul_media_durations[-1]:
+            player_idx = len(observation[cfg.FILE][cfg.PLAYER1]) - 1
+        else:
+            player_idx = None
+            for idx, value in enumerate(cumul_media_durations):
+                start = 0 if idx == 0 else cumul_media_durations[idx - 1]
+                if start <= timestamp < value:
+                    player_idx = idx
+                    break
+
+        video_file_name = observation[cfg.FILE][cfg.PLAYER1][player_idx] if player_idx is not None else None
+
+    return video_file_name
+
+
+def create_observations(self):
     """
+    Create observations from a directory of media files
+    """
+
+    if not (dir_path := QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))):
+        return
 
-    cumul_media_durations: list = [dec(0)]
-    for media_file in observation[cfg.FILE]["1"]:
-        media_duration = dec(str(observation[cfg.MEDIA_INFO][cfg.LENGTH][media_file]))
-        cumul_media_durations.append(cumul_media_durations[-1] + media_duration)
+    elements_list: list = []
+    if util.is_subdir(Path(dir_path), Path(self.projectFileName).parent):
+        elements_list.append(("cb", "Use relative paths", False))
+
+    elements_list.extend(
+        [
+            ("cb", "Recurse the subdirectories", False),
+            ("cb", "Visualize spectrogram", False),
+            ("cb", "Visualize waveform", False),
+            ("cb", "Media creation date as offset", False),
+            ("cb", "Close behaviors between videos", False),
+            ("dsb", "Time offset (in seconds)", 0.0, 86400, 1, 0, 3),
+            ("dsb", "Media scan sampling duration (in seconds)", 0.0, 86400, 1, 0, 3),
+        ]
+    )
 
-    cumul_media_durations.remove(dec(0))
+    dlg = dialog.Input_dialog(
+        label_caption="Set the following observation parameters",
+        elements_list=elements_list,
+        title="Observation parameters",
+    )
+    if not dlg.exec_():
+        return
 
-    # test if timestamp is at end of last media
-    if timestamp == cumul_media_durations[-1]:
-        player_idx = len(observation[cfg.FILE]["1"]) - 1
+    file_count: int = 0
+
+    if dlg.elements["Recurse the subdirectories"].isChecked():
+        files_list = Path(dir_path).rglob("*")
     else:
-        player_idx = -1
-        for idx, value in enumerate(cumul_media_durations):
-            start = 0 if idx == 0 else cumul_media_durations[idx - 1]
-            if start <= timestamp < value:
-                player_idx = idx
-                break
+        files_list = Path(dir_path).glob("*")
+
+    for file in files_list:
+        if not file.is_file():
+            continue
+        r = util.accurate_media_analysis(ffmpeg_bin=self.ffmpeg_bin, file_name=file)
+        if "error" not in r:
+            if not r.get("frames_number", 0):
+                continue
 
-    if player_idx != -1:
-        video_file_name = observation[cfg.FILE]["1"][player_idx]
+            if "Use relative paths" in dlg.elements and dlg.elements["Use relative paths"].isChecked():
+                media_file = str(file.relative_to(Path(self.projectFileName).parent))
+            else:
+                media_file = str(file)
+
+            # else:
+            #    try:
+            #        media_file = str(file.relative_to(Path(self.projectFileName).parent))
+            #    except ValueError:
+            #        QMessageBox.critical(
+            #            self,
+            #            cfg.programName,
+            #            (
+            #                f"the media file <b>{file}</b> can not be relative to the project directory "
+            #                f"(<b>{Path(self.projectFileName).parent}</b>)"
+            #                "<br><br>Aborting the creation of observations"
+            #            ),
+            #        )
+            #        return
+
+            if media_file in self.pj[cfg.OBSERVATIONS]:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    (f"The observation <b>{media_file}</b> already exists.<br><br>Aborting the creation of observations"),
+                )
+                return
+
+            self.pj[cfg.OBSERVATIONS][media_file] = {
+                "file": {"1": [media_file], "2": [], "3": [], "4": [], "5": [], "6": [], "7": [], "8": []},
+                "type": "MEDIA",
+                "date": dt.datetime.now().replace(microsecond=0).isoformat(),
+                "description": "",
+                "time offset": dec(str(round(dlg.elements["Time offset (in seconds)"].value(), 3))),
+                "events": [],
+                "observation time interval": [0, 0],
+                "independent_variables": {},
+                "visualize_spectrogram": dlg.elements["Visualize spectrogram"].isChecked(),
+                "visualize_waveform": dlg.elements["Visualize waveform"].isChecked(),
+                "media_creation_date_as_offset": dlg.elements["Media creation date as offset"].isChecked(),
+                "media_scan_sampling_duration": dec(str(round(dlg.elements["Media scan sampling duration (in seconds)"].value(), 3))),
+                "image_display_duration": 1,
+                "close_behaviors_between_videos": dlg.elements["Close behaviors between videos"].isChecked(),
+                "media_info": {
+                    "length": {media_file: r["duration"]},
+                    "fps": {media_file: r["duration"]},
+                    "hasVideo": {media_file: r["has_video"]},
+                    "hasAudio": {media_file: r["has_audio"]},
+                    "offset": {"1": 0.0},
+                },
+            }
+            file_count += 1
+            self.project_changed()
+
+    if file_count:
+        message: str = f"{file_count} observation(s) were created" if file_count > 1 else "One observation was created"
     else:
-        video_file_name = None
+        message: str = f"No media file were found in {dir_path}"
 
-    return video_file_name
+    menu_options.update_menu(self)
+
+    QMessageBox.information(self, cfg.programName, message)