boris-behav-obs 9.7.7__py3-none-any.whl

boris/plot_events_rt.py

@@ -0,0 +1,237 @@
+"""
+BORIS
+Behavioral Observation Research Interactive Software
+Copyright 2012-2025 Olivier Friard
+
+This file is part of BORIS.
+
+  BORIS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3 of the License, or
+  any later version.
+
+  BORIS is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not see <http://www.gnu.org/licenses/>.
+
+
+
+Plot events in real time
+"""
+
+import matplotlib
+
+matplotlib.use("QtAgg")
+
+import numpy as np
+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):
+    # send keypress event to mainwindow
+    sendEvent = Signal(QEvent)
+
+    def __init__(self):
+        super().__init__()
+        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 = cfg.REALTIME_PLOT_CURSOR_COLOR  # default cursor color
+        self.observation_type = cfg.MEDIA
+        self.groupby = "behaviors"  # group results by "behaviors" or "modifiers"
+
+        self.figure = Figure()
+        self.ax = self.figure.add_subplot(1, 1, 1)
+
+        self.canvas = FigureCanvas(self.figure)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.canvas)
+
+        hlayout1 = QHBoxLayout()
+        hlayout1.addWidget(QLabel("Time interval"))
+        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)
+
+        self.setLayout(layout)
+
+        self.installEventFilter(self)
+
+    def eventFilter(self, receiver, event):
+        """
+        send event (if keypress) to main window
+        """
+        if event.type() == QEvent.KeyPress:
+            self.sendEvent.emit(event)
+            return True
+        else:
+            return False
+
+    def change_mode(self) -> None:
+        """
+        Change plot mode
+        "behaviors" -> plot behaviors without modifiers
+        "modifiers" -> plot behaviors and modifiers
+        """
+
+        if self.groupby == "behaviors":
+            self.groupby = "modifiers"
+            self.pb_mode.setText("Show behaviors w/o modifiers")
+        else:
+            self.groupby = "behaviors"
+            self.pb_mode.setText("Include modifiers")
+
+    def time_interval_changed(self, action: int) -> None:
+        """
+        change the time interval for events plot
+
+        Args:
+            action (int): -1 decrease time interval, +1 increase time interval
+
+        Returns:
+            None
+        """
+
+        if action == -1 and self.interval <= 5:
+            return
+        self.interval += 5 * action
+        self.plot_events(current_time=self.time_mem, force_plot=True)
+
+    def aggregate_events(self, events: list, start: float, end: float) -> dict:
+        """
+        aggregate state events
+        take consideration of subject and modifiers
+
+        Args:
+            events (list): list of events
+            start (float): initial value
+            end (float): final value
+
+        Returns:
+            dict
+
+        """
+
+        def group(subject: str, code: str, modifier: str) -> tuple:
+            if self.groupby == "behaviors":
+                return (subject, code)
+            else:  # with modifiers
+                return (subject, code, modifier)
+
+        mem_behav = {}
+        intervals_behav = {}
+
+        for event in events:
+            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
+
+                    # check if event is in interval start-end
+                    if any(
+                        (
+                            start <= mem_behav[key] <= end,
+                            start <= time_ <= end,
+                            mem_behav[key] <= start and time_ > end,
+                        )
+                    ):
+                        intervals_behav[key].append((float(mem_behav[key]), float(time_)))
+                    mem_behav[key] = None
+                else:
+                    # start interval
+                    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
+
+        # 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
+
+                elif self.observation_type == cfg.MEDIA:
+                    intervals_behav[k].append((float(mem_behav[k]), float(end)))  # close interval with end value
+
+        return intervals_behav
+
+    def plot_events(self, current_time: float, force_plot: bool = False):
+        """
+        plot events centered on the current time
+
+        Args:
+            current_time (float): time for displaying events
+            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)
+
+        if not force_plot and current_time == self.time_mem:
+            return
+
+        self.time_mem = current_time
+
+        if self.events != self.events_mem:
+            left, duration = {}, {}
+            for k in self.events:
+                left[k] = []
+                duration[k] = []
+                for interv in self.events[k]:
+                    left[k].append(interv[0])
+                    duration[k].append(interv[1] - interv[0])
+
+            self.behaviors, self.durations, self.lefts, self.colors = [], [], [], []
+            for k in self.events:
+                if self.groupby == "behaviors":
+                    subject_name, bevavior_code = k
+                    if subject_name == "":
+                        subject_name = "No focal"
+                    behav_col = self.behav_color[bevavior_code]
+                    self.behaviors.extend([f"{subject_name} - {bevavior_code}"] * len(self.events[k]))
+                    self.colors.extend([behav_col] * len(self.events[k]))
+                else:  # with modifiers
+                    subject_name, bevavior_code, modifier = k
+                    behav_col = self.behav_color[bevavior_code]
+                    self.behaviors.extend([f"{subject_name} - {bevavior_code} ({modifier})"] * len(self.events[k]))
+                    self.colors.extend([behav_col] * len(self.events[k]))
+
+                self.lefts.extend(left[k])
+                self.durations.extend(duration[k])
+
+            self.events_mem = self.events
+
+        self.ax.clear()
+        self.ax.set_xlim(current_time - self.interval / 2, current_time + self.interval / 2)
+
+        self.ax.axvline(x=current_time, color=self.cursor_color, linestyle="-")
+
+        self.ax.barh(y=np.array(self.behaviors), width=self.durations, left=self.lefts, color=self.colors, height=0.5)
+
+        self.canvas.draw()
+        self.figure.canvas.flush_events()

boris/plot_spectrogram_rt.py

@@ -0,0 +1,316 @@
+"""
+BORIS
+Behavioral Observation Research Interactive Software
+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
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+  MA 02110-1301, USA.
+
+"""
+
+import wave
+import matplotlib
+
+matplotlib.use("QtAgg")
+
+import numpy as np
+from scipy import signal
+from . import config as cfg
+
+from PySide6.QtWidgets import (
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QPushButton,
+    QLabel,
+    QSpinBox,
+)
+from PySide6.QtCore import Signal, QEvent, Qt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+import matplotlib.ticker as mticker
+
+
+class Plot_spectrogram_RT(QWidget):
+    # send keypress event to mainwindow
+    sendEvent = Signal(QEvent)
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Spectrogram")
+
+        self.interval = 10  # interval of visualization (in seconds)
+        self.time_mem = -1
+
+        self.cursor_color = cfg.REALTIME_PLOT_CURSOR_COLOR
+
+        self.spectro_color_map = matplotlib.pyplot.get_cmap("viridis")
+
+        self.figure = Figure()
+        self.ax = self.figure.add_subplot(1, 1, 1)
+
+        self.canvas = FigureCanvas(self.figure)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.canvas)
+
+        hlayout1 = QHBoxLayout()
+        hlayout1.addWidget(QLabel("Time interval"))
+        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,
+            )
+        )
+        layout.addLayout(hlayout1)
+
+        hlayout2 = QHBoxLayout()
+        hlayout2.addWidget(QLabel("Frequency interval"))
+        self.sb_freq_min = QSpinBox(valueChanged=self.frequency_interval_changed, focusPolicy=Qt.NoFocus)
+        self.sb_freq_min.setRange(0, 200000)
+        self.sb_freq_min.setSingleStep(100)
+        self.sb_freq_max = QSpinBox(valueChanged=self.frequency_interval_changed, focusPolicy=Qt.NoFocus)
+        self.sb_freq_max.setRange(0, 200000)
+        self.sb_freq_max.setSingleStep(100)
+        hlayout2.addWidget(self.sb_freq_min)
+        hlayout2.addWidget(self.sb_freq_max)
+        layout.addLayout(hlayout2)
+
+        self.setLayout(layout)
+
+        self.installEventFilter(self)
+
+    def eventFilter(self, receiver, event):
+        """
+        send event (if keypress) to main window
+        """
+        if event.type() == QEvent.KeyPress:
+            self.sendEvent.emit(event)
+            return True
+        else:
+            return False
+
+    def get_wav_info(self, wav_file: str) -> tuple[np.array, int]:
+        """
+        read wav file and extract information
+
+        Args:
+            wav_file (str): path of wav file
+
+        Returns:
+            np.array: signal contained in wav file
+            int: frame rate of wav file
+
+        """
+
+        try:
+            wav = wave.open(wav_file, "r")
+            frames = wav.readframes(-1)
+            # sound_info = np.fromstring(frames, dtype=np.int16)
+            sound_info = np.frombuffer(frames, dtype=np.int16)
+            frame_rate = wav.getframerate()
+            wav.close()
+            return sound_info, frame_rate
+        except Exception:
+            return np.array([]), 0
+
+    def time_interval_changed(self, action: int):
+        """
+        change the time interval for plotting spectrogram
+
+        Args:
+            action (int): -1 decrease time interval, +1 increase time interval
+
+        Returns:
+            None
+        """
+
+        if action == -1 and self.interval <= 5:
+            return
+        self.interval += 5 * action
+        self.plot_spectro(current_time=self.time_mem, force_plot=True)
+
+    def frequency_interval_changed(self):
+        """
+        change the frequency interval for plotting spectrogram
+        """
+        self.plot_spectro(current_time=self.time_mem, force_plot=True)
+
+    def load_wav(self, wav_file_path: str) -> dict:
+        """
+        load wav file in numpy array
+
+        Args:
+            wav_file_path (str): path of wav file
+
+        Returns:
+            dict: "error" key if error, "media_length" and "frame_rate"
+        """
+
+        try:
+            self.sound_info, self.frame_rate = self.get_wav_info(wav_file_path)
+            if not self.frame_rate:
+                return {"error": f"unknown format for file {wav_file_path}"}
+        except FileNotFoundError:
+            return {"error": f"File not found: {wav_file_path}"}
+
+        self.media_length = len(self.sound_info) / self.frame_rate
+
+        self.wav_file_path = wav_file_path
+
+        return {"media_length": self.media_length, "frame_rate": self.frame_rate}
+
+    def plot_spectro(self, current_time: float, force_plot: bool = False) -> tuple[float, bool]:
+        """
+        plot sound spectrogram centered on the current time
+
+        Args:
+            current_time (float): time for displaying spectrogram
+            force_plot (bool): force plot even if media paused
+        """
+
+        if not force_plot and current_time == self.time_mem:
+            return
+
+        self.time_mem = current_time
+
+        self.ax.clear()
+
+        window_type = "blackmanharris"  # self.config_param.get(cfg.SPECTROGRAM_WINDOW_TYPE, cfg.SPECTROGRAM_DEFAULT_WINDOW_TYPE)
+        nfft = int(self.config_param.get(cfg.SPECTROGRAM_NFFT, cfg.SPECTROGRAM_DEFAULT_NFFT))
+        noverlap = self.config_param.get(cfg.SPECTROGRAM_NOVERLAP, cfg.SPECTROGRAM_DEFAULT_NOVERLAP)
+        vmin = self.config_param.get(cfg.SPECTROGRAM_VMIN, cfg.SPECTROGRAM_DEFAULT_VMIN)
+        vmax = self.config_param.get(cfg.SPECTROGRAM_VMAX, cfg.SPECTROGRAM_DEFAULT_VMAX)
+
+        # start
+        if current_time <= self.interval / 2:
+            self.ax.specgram(
+                self.sound_info[: int(self.interval * self.frame_rate)],
+                mode="psd",
+                NFFT=nfft,
+                Fs=self.frame_rate,
+                noverlap=noverlap,
+                window=signal.get_window(window_type, nfft),
+                # matplotlib.mlab.window_hanning
+                # if window_type == "hanning"
+                # else matplotlib.mlab.window_hamming
+                # if window_type == "hamming"
+                # else matplotlib.mlab.window_blackmanharris
+                # if window_type == "blackmanharris"
+                # else matplotlib.mlab.window_hanning,
+                cmap=self.spectro_color_map,
+                vmin=vmin,
+                vmax=vmax,
+                # mode="psd",
+                ## NFFT=1024,
+                # Fs=self.frame_rate,
+                ## noverlap=900,
+                # cmap=self.spectro_color_map,
+            )
+
+            self.ax.set_xlim(current_time - self.interval / 2, current_time + self.interval / 2)
+
+            # cursor
+            self.ax.axvline(x=current_time, color=self.cursor_color, linestyle="-")
+
+        elif current_time >= self.media_length - self.interval / 2:
+            i = int(round(len(self.sound_info) - (self.interval * self.frame_rate), 0))
+
+            self.ax.specgram(
+                self.sound_info[i:],
+                mode="psd",
+                NFFT=nfft,
+                Fs=self.frame_rate,
+                noverlap=noverlap,
+                window=signal.get_window(window_type, nfft),
+                # matplotlib.mlab.window_hanning
+                # if window_type == "hanning"
+                # else matplotlib.mlab.window_hamming
+                # if window_type == "hamming"
+                # else matplotlib.mlab.window_blackmanharris
+                # if window_type == "blackmanharris"
+                # else matplotlib.mlab.window_hanning,
+                cmap=self.spectro_color_map,
+                vmin=vmin,
+                vmax=vmax,
+                # mode="psd",
+                ## NFFT=1024,
+                # Fs=self.frame_rate,
+                ## noverlap=900,
+                # cmap=self.spectro_color_map,
+            )
+
+            lim1 = current_time - (self.media_length - self.interval / 2)
+            lim2 = lim1 + self.interval
+
+            self.ax.set_xlim(lim1, lim2)
+
+            self.ax.xaxis.set_major_locator(mticker.FixedLocator(self.ax.get_xticks().tolist()))
+            self.ax.set_xticklabels([str(round(w + self.media_length - self.interval, 1)) for w in self.ax.get_xticks()])
+
+            # cursor
+            self.ax.axvline(x=lim1 + self.interval / 2, color=self.cursor_color, linestyle="-")
+
+        # middle
+        else:
+            self.ax.specgram(
+                self.sound_info[
+                    int(round((current_time - self.interval / 2) * self.frame_rate, 0)) : int(
+                        round((current_time + self.interval / 2) * self.frame_rate, 0)
+                    )
+                ],
+                mode="psd",
+                NFFT=nfft,
+                Fs=self.frame_rate,
+                noverlap=noverlap,
+                window=signal.get_window(window_type, nfft),
+                # matplotlib.mlab.window_hanning
+                # if window_type == "hanning"
+                # else matplotlib.mlab.window_hamming
+                # if window_type == "hamming"
+                # else matplotlib.mlab.window_blackmanharris
+                # if window_type == "blackmanharris"
+                # else matplotlib.mlab.window_hanning,
+                cmap=self.spectro_color_map,
+                vmin=vmin,
+                vmax=vmax,
+                # mode="psd",
+                ## NFFT=1024,
+                # Fs=self.frame_rate,
+                ## noverlap=900,
+                # cmap=self.spectro_color_map,
+            )
+
+            self.ax.xaxis.set_major_locator(mticker.FixedLocator(self.ax.get_xticks().tolist()))
+            self.ax.set_xticklabels([str(round(current_time + w - self.interval / 2, 1)) for w in self.ax.get_xticks()])
+
+            # cursor
+            self.ax.axvline(x=self.interval / 2, color=self.cursor_color, linestyle="-")
+
+        self.ax.set_ylim(self.sb_freq_min.value(), self.sb_freq_max.value())
+        """self.figure.subplots_adjust(wspace=0, hspace=0)"""
+
+        self.canvas.draw()