boris-behav-obs 8.9.16__py3-none-any.whl → 9.7.6__py3-none-any.whl

boris/plot_events.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -25,42 +25,39 @@ import pathlib as pl
 
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
+
 import matplotlib.dates
-import matplotlib.font_manager as font_manager
+
 import matplotlib.pyplot as plt
-import matplotlib.transforms as mtransforms
 import numpy as np
-from matplotlib import colors as mcolors
 from matplotlib.dates import (
-    HOURLY,
-    MICROSECONDLY,
-    MINUTELY,
-    MONTHLY,
-    SECONDLY,
-    WEEKLY,
     DateFormatter,
-    RRuleLocator,
-    rrulewrapper,
 )
 
 from . import config as cfg
 from . import db_functions, project_functions, observation_operations
 from . import utilities as util
 
+# matplotlib.pyplot.switch_backend("Qt5Agg")
+
 
 def default_value(ethogram, behavior, parameter):
     """
     return value for duration in case of point event
     """
     default_value_ = 0
-    if project_functions.event_type(behavior, ethogram) == "POINT EVENT" and parameter in ["duration"]:
+    if project_functions.event_type(behavior, ethogram) in cfg.POINT_EVENT_TYPES and parameter in ["duration"]:
         default_value_ = "NA"
     return default_value_
 
 
 def init_behav_modif(
-    ethogram: dict, selected_subjects: list, distinct_behav_modif, include_modifiers, parameters
+    ethogram: dict,
+    selected_subjects: list,
+    distinct_behav_modif,
+    include_modifiers,
+    parameters,
 ) -> dict:
     """
     initialize dictionary with subject, behaviors and modifiers
@@ -70,7 +67,6 @@ def init_behav_modif(
     for subj in selected_subjects:
         behaviors[subj] = {}
         for behav_modif in distinct_behav_modif:
-
             behav, modif = behav_modif
             behav_modif_str = "|".join(behav_modif) if modif else behav
 
@@ -88,7 +84,7 @@ def init_behav(ethogram: dict, selected_subjects: list, distinct_behaviors, para
     initialize dictionary with subject, behaviors and modifiers
     """
 
-    behaviors = {}
+    behaviors: dict = {}
     for subj in selected_subjects:
         behaviors[subj] = {}
         for behavior in distinct_behaviors:
@@ -122,15 +118,12 @@ def create_behaviors_bar_plot(
 
     selected_subjects = param[cfg.SELECTED_SUBJECTS]
     selected_behaviors = param[cfg.SELECTED_BEHAVIORS]
-    time_interval = param["time"]
     start_time = param[cfg.START_TIME]
     end_time = param[cfg.END_TIME]
 
     parameters = ["duration", "number of occurences"]
 
-    ok, msg, db_connector = db_functions.load_aggregated_events_in_db(
-        pj, selected_subjects, selected_observations, selected_behaviors
-    )
+    ok, msg, db_connector = db_functions.load_aggregated_events_in_db(pj, selected_subjects, selected_observations, selected_behaviors)
 
     if not ok:
         return {"error": True, "message": msg}
@@ -139,10 +132,12 @@ def create_behaviors_bar_plot(
     all_behaviors = util.all_behaviors(pj[cfg.ETHOGRAM])
 
     for obs_id in selected_observations:
-
         cursor = db_connector.cursor()
         # distinct behaviors
-        cursor.execute("SELECT distinct behavior FROM aggregated_events WHERE observation = ?", (obs_id,))
+        cursor.execute(
+            "SELECT distinct behavior FROM aggregated_events WHERE observation = ?",
+            (obs_id,),
+        )
         distinct_behav = [rows["behavior"] for rows in cursor.fetchall()]
 
         # add selected behaviors that are not observed
@@ -154,7 +149,10 @@ def create_behaviors_bar_plot(
         """
 
         # distinct subjects
-        cursor.execute("SELECT distinct subject FROM aggregated_events WHERE observation = ?", (obs_id,))
+        cursor.execute(
+            "SELECT distinct subject FROM aggregated_events WHERE observation = ?",
+            (obs_id,),
+        )
         distinct_subjects = [rows["subject"] for rows in cursor.fetchall()]
 
         behaviors = init_behav(pj[cfg.ETHOGRAM], distinct_subjects, distinct_behav, parameters)
@@ -198,7 +196,7 @@ def create_behaviors_bar_plot(
             except Exception:
                 max_time = float(obs_length)
 
-        if param["time"] == cfg.TIME_ARBITRARY_INTERVAL:
+        if param["time"] in (cfg.TIME_ARBITRARY_INTERVAL, cfg.TIME_OBS_INTERVAL):
             min_time = float(start_time)
             max_time = float(end_time)
 
@@ -234,15 +232,10 @@ def create_behaviors_bar_plot(
         )
 
         for ax_idx, subject in enumerate(sorted(distinct_subjects)):
-
             for behavior in distinct_behav:
-
                 # number of occurences
                 cursor.execute(
-                    (
-                        "SELECT COUNT(*) AS count FROM aggregated_events "
-                        "WHERE observation = ? AND subject = ? AND behavior = ?"
-                    ),
+                    ("SELECT COUNT(*) AS count FROM aggregated_events WHERE observation = ? AND subject = ? AND behavior = ?"),
                     (
                         obs_id,
                         subject,
@@ -253,7 +246,7 @@ def create_behaviors_bar_plot(
                     behaviors[subject][behavior]["number of occurences"] = 0 if row["count"] is None else row["count"]
 
                 # total duration
-                if cfg.STATE in project_functions.event_type(behavior, pj[cfg.ETHOGRAM]):
+                if project_functions.event_type(behavior, pj[cfg.ETHOGRAM]) in cfg.STATE_EVENT_TYPES:
                     cursor.execute(
                         (
                             "SELECT SUM(stop - start) AS duration FROM aggregated_events "
@@ -268,27 +261,49 @@ def create_behaviors_bar_plot(
                     for row in cursor.fetchall():
                         behaviors[subject][behavior]["duration"] = 0 if row["duration"] is None else row["duration"]
 
-            durations, n_occurences, colors, x_labels, colors_duration, x_labels_duration = [], [], [], [], [], []
+            (
+                durations,
+                n_occurences,
+                colors,
+                x_labels,
+                colors_duration,
+                x_labels_duration,
+            ) = ([], [], [], [], [], [])
 
             for behavior in sorted(distinct_behav):
-
                 if param[cfg.EXCLUDE_BEHAVIORS] and behaviors[subject][behavior]["number of occurences"] == 0:
                     continue
 
                 n_occurences.append(behaviors[subject][behavior]["number of occurences"])
                 x_labels.append(behavior)
-                try:
-                    colors.append(util.behavior_color(plot_colors, all_behaviors.index(behavior)))
-                except Exception:
-                    colors.append("darkgray")
 
-                if cfg.STATE in project_functions.event_type(behavior, pj[cfg.ETHOGRAM]):
-                    durations.append(behaviors[subject][behavior]["duration"])
-                    x_labels_duration.append(behavior)
+                # color
+                behav_idx = [k for k in pj[cfg.ETHOGRAM] if pj[cfg.ETHOGRAM][k]["code"] == behavior][0]
+                col = None
+                if cfg.COLOR in pj[cfg.ETHOGRAM][behav_idx]:
+                    col = util.behavior_user_color(pj[cfg.ETHOGRAM], behavior)
+                if col is not None:
+                    colors.append(col)
+                else:
                     try:
-                        colors_duration.append(util.behavior_color(plot_colors, all_behaviors.index(behavior)))
+                        colors.append(util.behavior_color(plot_colors, all_behaviors.index(behavior)))
                     except Exception:
-                        colors_duration.append("darkgray")
+                        colors.append("darkgray")
+
+                if project_functions.event_type(behavior, pj[cfg.ETHOGRAM]) in cfg.STATE_EVENT_TYPES:
+                    durations.append(behaviors[subject][behavior]["duration"])
+                    x_labels_duration.append(behavior)
+
+                    col = None
+                    if cfg.COLOR in pj[cfg.ETHOGRAM][behav_idx]:
+                        col = util.behavior_user_color(pj[cfg.ETHOGRAM], behavior)
+                    if col is not None:
+                        colors_duration.append(col)
+                    else:
+                        try:
+                            colors_duration.append(util.behavior_color(plot_colors, all_behaviors.index(behavior)))
+                        except Exception:
+                            colors_duration.append("darkgray")
 
             # width = 0.35       # the width of the bars: can also be len(x) sequence
 
@@ -341,10 +356,15 @@ def create_behaviors_bar_plot(
 
 
 def create_events_plot(
-    pj, selected_observations, parameters, plot_colors=cfg.BEHAVIORS_PLOT_COLORS, plot_directory="", file_format="png"
+    self,
+    selected_observations,
+    parameters,
+    plot_colors=cfg.BEHAVIORS_PLOT_COLORS,
+    plot_directory="",
+    file_format="png",
 ):
     """
-    create a time diagram plot (sort of gantt chart)
+    create a time diagram plot (like a gantt chart)
     with matplotlib barh function (https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.barh.html)
     """
 
@@ -355,9 +375,7 @@ def create_events_plot(
     start_time = parameters[cfg.START_TIME]
     end_time = parameters[cfg.END_TIME]
 
-    ok, msg, db_connector = db_functions.load_aggregated_events_in_db(
-        pj, selected_subjects, selected_observations, selected_behaviors
-    )
+    ok, msg, db_connector = db_functions.load_aggregated_events_in_db(self.pj, selected_subjects, selected_observations, selected_behaviors)
 
     if not ok:
         return False, msg, None
@@ -379,14 +397,13 @@ def create_events_plot(
     distinct_behav_modif = sorted(distinct_behav_modif)
     max_len = len(distinct_behav_modif)
 
-    all_behaviors = [pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in util.sorted_keys(pj[cfg.ETHOGRAM])]
+    all_behaviors = [self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in util.sorted_keys(self.pj[cfg.ETHOGRAM])]
 
     par1 = 1
     bar_height = 0.5
-    init = dt.datetime(2017, 1, 1)
+    epoch_date = dt.datetime(2017, 1, 1)
 
     for obs_id in selected_observations:
-
         if len(selected_subjects) > 1:
             fig, axs = plt.subplots(figsize=(20, 8), nrows=len(selected_subjects), ncols=1, sharex=True)
         else:
@@ -394,9 +411,7 @@ def create_events_plot(
             axs = np.ndarray(shape=(1), dtype=type(ax))
             axs[0] = ax
 
-        ok, msg, db_connector = db_functions.load_aggregated_events_in_db(
-            pj, selected_subjects, [obs_id], selected_behaviors
-        )
+        ok, msg, db_connector = db_functions.load_aggregated_events_in_db(self.pj, selected_subjects, [obs_id], selected_behaviors)
 
         cursor = db_connector.cursor()
         # if modifiers not to be included set modifiers to ""
@@ -417,7 +432,7 @@ def create_events_plot(
         max_len = len(distinct_behav_modif)
 
         # time
-        obs_length = observation_operations.observation_total_length(pj[cfg.OBSERVATIONS][obs_id])
+        obs_length = observation_operations.observation_total_length(self.pj[cfg.OBSERVATIONS][obs_id])
         if obs_length == -1:  # media length not available
             interval = cfg.TIME_EVENTS
 
@@ -425,13 +440,20 @@ def create_events_plot(
             min_time = 0.0
             max_time = float(obs_length)
 
+        if interval == cfg.TIME_OBS_INTERVAL:
+            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
+            offset = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET])
+            min_time = float(obs_interval[0]) + offset
+            # Use max media duration for max time if no interval is defined (=0)
+            max_time = float(obs_interval[1]) + offset if obs_interval[1] != 0 else float(obs_length)
+
         if interval == cfg.TIME_EVENTS:
             try:
-                min_time = float(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][0][0])  # first event
+                min_time = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][0][0])  # first event
             except Exception:
                 min_time = 0.0
             try:
-                max_time = float(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][-1][0])  # last event
+                max_time = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][-1][0])  # last event
             except Exception:
                 max_time = float(obs_length)
 
@@ -478,10 +500,10 @@ def create_events_plot(
 
         ylabels = [" ".join(x) for x in distinct_behav_modif]
         for ax_idx, subject in enumerate(selected_subjects):
-
             if parameters["exclude behaviors"]:
                 cursor.execute(
-                    "SELECT DISTINCT behavior, modifiers FROM aggregated_events WHERE subject = ?", (subject,)
+                    "SELECT DISTINCT behavior, modifiers FROM aggregated_events WHERE subject = ?",
+                    (subject,),
                 )
                 distinct_behav_modif = [[rows["behavior"], rows["modifiers"]] for rows in cursor.fetchall()]
 
@@ -508,10 +530,7 @@ def create_events_plot(
 
                 # total duration
                 cursor.execute(
-                    (
-                        "SELECT start, stop FROM aggregated_events "
-                        "WHERE  subject = ? AND behavior = ? AND modifiers = ?"
-                    ),
+                    ("SELECT start, stop FROM aggregated_events WHERE  subject = ? AND behavior = ? AND modifiers = ?"),
                     (
                         subject,
                         behavior,
@@ -521,22 +540,36 @@ def create_events_plot(
                 for row in cursor.fetchall():
                     bars[behavior_modifiers_str].append((row["start"], row["stop"]))
 
-                    start_date = matplotlib.dates.date2num(init + dt.timedelta(seconds=row["start"]))
-                    end_date = matplotlib.dates.date2num(
-                        init
-                        + dt.timedelta(
-                            seconds=row["stop"] + cfg.POINT_EVENT_PLOT_DURATION * (row["stop"] == row["start"])
+                    if self.timeFormat == cfg.HHMMSS:
+                        start_date = matplotlib.dates.date2num(epoch_date + dt.timedelta(seconds=row["start"]))
+                        end_date = matplotlib.dates.date2num(
+                            epoch_date + dt.timedelta(seconds=row["stop"] + cfg.POINT_EVENT_PLOT_DURATION * (row["stop"] == row["start"]))
                         )
-                    )
-                    try:
-                        bar_color = util.behavior_color(plot_colors, all_behaviors.index(behavior))
-                    except Exception:
-                        bar_color = "darkgray"
+                    if self.timeFormat == cfg.S:
+                        start_date = row["start"]
+                        end_date = row["stop"]
+
+                    # color
+                    behav_idx = [k for k in self.pj[cfg.ETHOGRAM] if self.pj[cfg.ETHOGRAM][k]["code"] == behavior][0]
+                    col = None
+                    if cfg.COLOR in self.pj[cfg.ETHOGRAM][behav_idx]:
+                        col = util.behavior_user_color(self.pj[cfg.ETHOGRAM], behavior)
+                    if col is not None:
+                        bar_color = col
+                    else:
+                        try:
+                            bar_color = util.behavior_color(plot_colors, all_behaviors.index(behavior))
+                        except Exception:
+                            bar_color = "darkgray"
                     bar_color = cfg.POINT_EVENT_PLOT_COLOR if row["stop"] == row["start"] else bar_color
 
                     # sage colors removed from matplotlib colors list
-                    if bar_color in ["sage", "darksage", "lightsage"]:
-                        bar_color = {"darksage": "#598556", "lightsage": "#bcecac", "sage": "#87ae73"}[bar_color]
+                    if bar_color in ("sage", "darksage", "lightsage"):
+                        bar_color = {
+                            "darksage": "#598556",
+                            "lightsage": "#bcecac",
+                            "sage": "#87ae73",
+                        }[bar_color]
 
                     try:
                         axs[ax_idx].barh(
@@ -569,26 +602,30 @@ def create_events_plot(
 
             axs[ax_idx].set_yticklabels(ylabels, fontdict={"fontsize": 10})
 
-            axs[ax_idx].set_ylabel("Behaviors" + " (modifiers)" * include_modifiers, fontdict={"fontsize": 10})
-
-            """
-            axs[ax_idx].set_xlim(
-                left=matplotlib.dates.date2num(init + dt.timedelta(seconds=min_time)),
-                right=matplotlib.dates.date2num(init + dt.timedelta(seconds=max_time + 1)),
-            )
-            """
-            axs[ax_idx].set_xlim(
-                left=matplotlib.dates.date2num(init + dt.timedelta(seconds=min_time)),
-                right=matplotlib.dates.date2num(init + dt.timedelta(seconds=max_time)),
+            axs[ax_idx].set_ylabel(
+                "Behaviors" + " (modifiers)" * include_modifiers,
+                fontdict={"fontsize": 10},
             )
 
+            if self.timeFormat == cfg.HHMMSS:
+                axs[ax_idx].set_xlim(
+                    left=matplotlib.dates.date2num(epoch_date + dt.timedelta(seconds=min_time)),
+                    right=matplotlib.dates.date2num(epoch_date + dt.timedelta(seconds=max_time)),
+                )
+
             axs[ax_idx].grid(color="g", linestyle=":")
-            axs[ax_idx].xaxis_date()
-            axs[ax_idx].xaxis.set_major_formatter(DateFormatter("%H:%M:%S"))
-            axs[ax_idx].set_xlabel("Time (HH:MM:SS)", fontdict={"fontsize": 12})
+            if self.timeFormat == cfg.HHMMSS:
+                axs[ax_idx].xaxis_date()
+                axs[ax_idx].xaxis.set_major_formatter(DateFormatter("%H:%M:%S"))
+                axs[ax_idx].set_xlabel("Time (HH:MM:SS)", fontdict={"fontsize": 12})
+            if self.timeFormat == cfg.S:
+                axs[ax_idx].set_xlabel("Time (s)", fontdict={"fontsize": 12})
+
             axs[ax_idx].invert_yaxis()
 
-        fig.autofmt_xdate()
+        if self.timeFormat == cfg.HHMMSS:
+            fig.autofmt_xdate()
+
         plt.tight_layout()
 
         if len(selected_observations) > 1:

boris/plot_events_rt.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -25,33 +25,34 @@ Plot events in real time
 
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
+
 import numpy as np
-from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel
-from PyQt5.QtCore import pyqtSignal, QEvent
-from PyQt5 import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel
+from PySide6.QtCore import Signal, QEvent, Qt
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 
 from matplotlib.figure import Figure
 
 from . import config as cfg
 
+# matplotlib.pyplot.switch_backend("Qt5Agg")
 
-class Plot_events_RT(QWidget):
 
+class Plot_events_RT(QWidget):
     # send keypress event to mainwindow
-    sendEvent = pyqtSignal(QEvent)
+    sendEvent = Signal(QEvent)
 
     def __init__(self):
         super().__init__()
-        self.setWindowTitle(f"Events plot")
+        self.setWindowTitle("Events plot")
 
         self.interval = 60  # default interval of visualization (in seconds)
         self.time_mem = -1
 
         self.events_mem = {"init": 0}
 
-        self.cursor_color = "red"  # default cursor color
+        self.cursor_color = cfg.REALTIME_PLOT_CURSOR_COLOR  # default cursor color
         self.observation_type = cfg.MEDIA
         self.groupby = "behaviors"  # group results by "behaviors" or "modifiers"
 
@@ -65,13 +66,9 @@ class Plot_events_RT(QWidget):
 
         hlayout1 = QHBoxLayout()
         hlayout1.addWidget(QLabel("Time interval"))
-        hlayout1.addWidget(
-            QPushButton("+", self, clicked=lambda: self.time_interval_changed(1), focusPolicy=Qt.Qt.NoFocus)
-        )
-        hlayout1.addWidget(
-            QPushButton("-", self, clicked=lambda: self.time_interval_changed(-1), focusPolicy=Qt.Qt.NoFocus)
-        )
-        self.pb_mode = QPushButton("Include modifiers", self, clicked=self.change_mode, focusPolicy=Qt.Qt.NoFocus)
+        hlayout1.addWidget(QPushButton("+", self, clicked=lambda: self.time_interval_changed(1), focusPolicy=Qt.NoFocus))
+        hlayout1.addWidget(QPushButton("-", self, clicked=lambda: self.time_interval_changed(-1), focusPolicy=Qt.NoFocus))
+        self.pb_mode = QPushButton("Include modifiers", self, clicked=self.change_mode, focusPolicy=Qt.NoFocus)
         hlayout1.addWidget(self.pb_mode)
         layout.addLayout(hlayout1)
 
@@ -147,13 +144,11 @@ class Plot_events_RT(QWidget):
             intervals_behav[group(event[1], event[2], event[3])] = [(0, 0)]
 
         for event in events:
-
             time_, subject, code, modifier = event[:4]
             key = group(subject, code, modifier)
 
             # check if code is state
             if code in self.state_events_list:
-
                 if key in mem_behav and mem_behav[key] is not None:
                     # stop interval
 
@@ -172,22 +167,16 @@ class Plot_events_RT(QWidget):
                     mem_behav[key] = time_
 
             else:  # point event
-
                 if start <= time_ <= end:
-                    intervals_behav[key].append(
-                        (float(time_), float(time_) + self.point_event_plot_duration * 50)
-                    )  # point event -> 1 s
+                    intervals_behav[key].append((float(time_), float(time_) + self.point_event_plot_duration * 50))  # point event -> 1 s
 
         # check if intervals are closed
         for k in mem_behav:
             if mem_behav[k] is not None:  # interval open
                 if self.observation_type == cfg.LIVE:
-                    intervals_behav[k].append(
-                        (float(mem_behav[k]), float((end + start) / 2))
-                    )  # close interval with current time
+                    intervals_behav[k].append((float(mem_behav[k]), float((end + start) / 2)))  # close interval with current time
 
                 elif self.observation_type == cfg.MEDIA:
-
                     intervals_behav[k].append((float(mem_behav[k]), float(end)))  # close interval with end value
 
         return intervals_behav
@@ -201,9 +190,7 @@ class Plot_events_RT(QWidget):
             force_plot (bool): force plot even if media paused
         """
 
-        self.events = self.aggregate_events(
-            self.events_list, current_time - self.interval / 2, current_time + self.interval / 2
-        )
+        self.events = self.aggregate_events(self.events_list, current_time - self.interval / 2, current_time + self.interval / 2)
 
         if not force_plot and current_time == self.time_mem:
             return
@@ -211,7 +198,6 @@ class Plot_events_RT(QWidget):
         self.time_mem = current_time
 
         if self.events != self.events_mem:
-
             left, duration = {}, {}
             for k in self.events:
                 left[k] = []