boris-behav-obs 9.4.1__py2.py3-none-any.whl → 9.5__py2.py3-none-any.whl

boris/analysis_plugins/_latency.py

@@ -8,7 +8,7 @@ import pandas as pd
 
 __version__ = "0.0.1"
 __version_date__ = "2025-04-10"
-__plugin_name__ = "Behavior latency"
+__plugin_name__ = "Behavior latencyxxx"
 __author__ = "Olivier Friard - University of Torino - Italy"
 
 

boris/config.py

@@ -531,6 +531,16 @@ NO_COLOR_CODING_PAD = "#777777"
 SPECTROGRAM_COLOR_MAPS = ["viridis", "inferno", "plasma", "magma", "gray", "YlOrRd"]
 SPECTROGRAM_DEFAULT_COLOR_MAP = "viridis"
 SPECTROGRAM_DEFAULT_TIME_INTERVAL = 10
+SPECTROGRAM_WINDOW_TYPE = "SPECTROGRAM_WINDOW_TYPE"
+SPECTROGRAM_DEFAULT_WINDOW_TYPE = "hanning"
+SPECTROGRAM_NFFT = "SPECTROGRAM_NFFT"
+SPECTROGRAM_DEFAULT_NFFT = "1024"
+SPECTROGRAM_NOVERLAP = "SPECTROGRAM_NOVERLAP"
+SPECTROGRAM_DEFAULT_NOVERLAP = 900
+SPECTROGRAM_VMIN = "SPECTROGRAM_VMIN"
+SPECTROGRAM_DEFAULT_VMIN = -100
+SPECTROGRAM_VMAX = "SPECTROGRAM_VMAX"
+SPECTROGRAM_DEFAULT_VMAX = -20
 
 # see matplotlib.colors.cnames.keys()
 # https://xkcd.com/color/rgb/

boris/connections.py

@@ -193,10 +193,11 @@ def connections(self):
     self.actionAdd_image_overlay_on_video.triggered.connect(lambda: image_overlay.add_image_overlay(self))
     self.actionRemove_image_overlay.triggered.connect(lambda: image_overlay.remove_image_overlay(self))
 
+    self.actionMedia_file_information_2.triggered.connect(lambda: media_file.get_info(self))
     self.actionRecode_resize_video.triggered.connect(lambda: external_processes.ffmpeg_process(self, "reencode_resize"))
     self.actionRotate_video.triggered.connect(lambda: external_processes.ffmpeg_process(self, "rotate"))
     self.actionMerge_media_files.triggered.connect(lambda: external_processes.ffmpeg_process(self, "merge"))
-    self.actionMedia_file_information_2.triggered.connect(lambda: media_file.get_info(self))
+    self.actionCreate_video_spectrogram.triggered.connect(lambda: external_processes.ffmpeg_process(self, "video_spectrogram"))
 
     self.actionCreate_transitions_flow_diagram.triggered.connect(transitions.transitions_dot_script)
     self.actionCreate_transitions_flow_diagram_2.triggered.connect(transitions.transitions_flow_diagram)

boris/core.py

@@ -1034,6 +1034,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 self.spectro.interval = self.spectrogram_time_interval
                 self.spectro.cursor_color = cfg.REALTIME_PLOT_CURSOR_COLOR
 
+                self.spectro.config_param = self.config_param
+
                 # color palette
                 try:
                     self.spectro.spectro_color_map = matplotlib.pyplot.get_cmap(self.spectrogram_color_map)

boris/core_ui.py

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'core.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.8.0
+## Created by: Qt User Interface Compiler version 6.9.0
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -378,6 +378,8 @@ class Ui_MainWindow(object):
         self.actionAdd_frame_indexes.setObjectName(u"actionAdd_frame_indexes")
         self.action_load_plugins = QAction(MainWindow)
         self.action_load_plugins.setObjectName(u"action_load_plugins")
+        self.actionCreate_video_spectrogram = QAction(MainWindow)
+        self.actionCreate_video_spectrogram.setObjectName(u"actionCreate_video_spectrogram")
         self.centralwidget = QWidget(MainWindow)
         self.centralwidget.setObjectName(u"centralwidget")
         self.horizontalLayout_2 = QHBoxLayout(self.centralwidget)
@@ -484,7 +486,7 @@ class Ui_MainWindow(object):
         MainWindow.setCentralWidget(self.centralwidget)
         self.menubar = QMenuBar(MainWindow)
         self.menubar.setObjectName(u"menubar")
-        self.menubar.setGeometry(QRect(0, 0, 1509, 22))
+        self.menubar.setGeometry(QRect(0, 0, 1509, 20))
         self.menuHelp = QMenu(self.menubar)
         self.menuHelp.setObjectName(u"menuHelp")
         self.menuFile = QMenu(self.menubar)
@@ -775,6 +777,7 @@ class Ui_MainWindow(object):
         self.menuMedia_file.addAction(self.actionRecode_resize_video)
         self.menuMedia_file.addAction(self.actionRotate_video)
         self.menuMedia_file.addAction(self.actionMerge_media_files)
+        self.menuMedia_file.addAction(self.actionCreate_video_spectrogram)
         self.toolBar.addAction(self.action_obs_list)
         self.toolBar.addAction(self.actionPlay)
         self.toolBar.addAction(self.actionReset)
@@ -1029,6 +1032,7 @@ class Ui_MainWindow(object):
         self.actionConfigure_tvevents_columns.setText(QCoreApplication.translate("MainWindow", u"Configure columns", None))
         self.actionAdd_frame_indexes.setText(QCoreApplication.translate("MainWindow", u"Add frame indexes", None))
         self.action_load_plugins.setText(QCoreApplication.translate("MainWindow", u"Load plugins", None))
+        self.actionCreate_video_spectrogram.setText(QCoreApplication.translate("MainWindow", u"Create video spectrogram", None))
         self.lbLogoBoris.setText("")
         self.lbLogoUnito.setText("")
         self.lb_player_status.setText(QCoreApplication.translate("MainWindow", u"lb_player_status", None))

boris/external_processes.py

@@ -22,7 +22,7 @@ This file is part of BORIS.
 
 import os
 import tempfile
-import pathlib as pl
+from pathlib import Path
 import logging
 
 from PySide6.QtWidgets import QFileDialog, QMessageBox, QInputDialog
@@ -41,9 +41,9 @@ def ffmpeg_process(self, action: str):
     launch ffmpeg process with QProcess
 
     Args:
-        action (str): "reencode_resize, rotate, merge
+        action (str): "reencode_resize, rotate, merge, video_spectrogram
     """
-    if action not in ("reencode_resize", "rotate", "merge"):
+    if action not in ("reencode_resize", "rotate", "merge", "video_spectrogram"):
         return
 
     def readStdOutput(idx):
@@ -61,7 +61,7 @@ def ffmpeg_process(self, action: str):
         # self.processes_widget.lwi.clear()
         std_out = self.processes[idx - 1][0].readAllStandardOutput().data().decode("utf-8")
         if std_out:
-            self.processes_widget.lwi.addItems((f"{pl.Path(self.processes[idx - 1][1][2]).name}:   {std_out}",))
+            self.processes_widget.lwi.addItems((f"{Path(self.processes[idx - 1][1][2]).name}:   {std_out}",))
 
         """
         std_err = self.processes[idx - 1][0].readAllStandardError().data().decode("utf-8")
@@ -153,7 +153,7 @@ def ffmpeg_process(self, action: str):
         file_list_lst = []
         for file_name in file_names:
             file_list_lst.append(f"file '{file_name}'")
-            file_extensions.append(pl.Path(file_name).suffix)
+            file_extensions.append(Path(file_name).suffix)
         if len(set(file_extensions)) > 1:
             QMessageBox.critical(self, cfg.programName, "All media files must have the same format")
             return
@@ -162,13 +162,13 @@ def ffmpeg_process(self, action: str):
             output_file_name, _ = QFileDialog().getSaveFileName(self, "Output file name", "", "*")
             if output_file_name == "":
                 return
-            if pl.Path(output_file_name).suffix != file_extensions[0]:
+            if Path(output_file_name).suffix != file_extensions[0]:
                 QMessageBox.warning(
                     self,
                     cfg.programName,
                     (
                         "The extension of output file must be the same than the extension of input files "
-                        f"(<b>{file_extensions[0]}</b>).<br>You selected a {pl.Path(output_file_name).suffix} file."
+                        f"(<b>{file_extensions[0]}</b>).<br>You selected a {Path(output_file_name).suffix} file."
                     ),
                 )
             else:
@@ -215,93 +215,118 @@ def ffmpeg_process(self, action: str):
     self.processes_widget.resize(700, 300)
 
     self.processes_widget.setWindowFlags(Qt.WindowStaysOnTopHint)
-    if action == "reencode_resize":
-        self.processes_widget.setWindowTitle("Re-encoding and resizing with FFmpeg")
-    if action == "rotate":
-        self.processes_widget.setWindowTitle("Rotating the video with FFmpeg")
-    if action == "merge":
-        self.processes_widget.setWindowTitle("Merging media files")
+    match action:
+        case "reencode_resize":
+            self.processes_widget.setWindowTitle("Re-encoding and resizing with FFmpeg")
+        case "rotate":
+            self.processes_widget.setWindowTitle("Rotating the video with FFmpeg")
+        case "merge":
+            self.processes_widget.setWindowTitle("Merging media files")
+        case "video_spectrogram":
+            self.processes_widget.setWindowTitle("Creating a video spectrogram")
 
     self.processes_widget.label.setText("This operation can be long. Be patient...\nIn the meanwhile you can continue to use BORIS\n\n")
     self.processes_widget.number_of_files = len(file_names)
     self.processes_widget.show()
 
-    if action == "merge":
-        # ffmpeg -f concat -safe 0 -i join_video.txt -c copy output_demuxer.mp4
-        args = ["-hide_banner", "-y", "-f", "concat", "-safe", "0", "-i", file_list, "-c", "copy", output_file_name]
-        self.processes.append([QProcess(self), [self.ffmpeg_bin, args, output_file_name]])
-        self.processes[-1][0].setProcessChannelMode(QProcess.MergedChannels)
-        self.processes[-1][0].readyReadStandardOutput.connect(lambda: readStdOutput(len(self.processes)))
-        self.processes[-1][0].readyReadStandardError.connect(lambda: readStdOutput(len(self.processes)))
-        self.processes[-1][0].finished.connect(lambda: qprocess_finished(len(self.processes)))
+    match action:
+        case "merge":
+            # ffmpeg -f concat -safe 0 -i join_video.txt -c copy output.mp4
+            args = ["-hide_banner", "-y", "-f", "concat", "-safe", "0", "-i", file_list, "-c", "copy", output_file_name]
+            self.processes.append([QProcess(self), [self.ffmpeg_bin, args, output_file_name]])
+            self.processes[-1][0].setProcessChannelMode(QProcess.MergedChannels)
+            self.processes[-1][0].readyReadStandardOutput.connect(lambda: readStdOutput(len(self.processes)))
+            self.processes[-1][0].readyReadStandardError.connect(lambda: readStdOutput(len(self.processes)))
+            self.processes[-1][0].finished.connect(lambda: qprocess_finished(len(self.processes)))
 
-        self.processes[-1][0].start(self.processes[-1][1][0], self.processes[-1][1][1])
+            self.processes[-1][0].start(self.processes[-1][1][0], self.processes[-1][1][1])
 
-    if action in ("reencode_resize", "rotate"):
-        for file_name in sorted(file_names, reverse=True):
-            if action == "reencode_resize":
+        case "video_spectrogram":
+            # ffmpeg -i video.mp4 -filter_complex showspectrum=mode=combined:color=intensity:slide=1:scale=cbrt -y -acodec copy output.mp4
+            for file_name in sorted(file_names, reverse=True):
+                output_file_name = str(Path(file_name).with_suffix(f".spectrogram{Path(file_name).suffix}"))
                 args = [
                     "-hide_banner",
                     "-y",
                     "-i",
-                    f"{file_name}",
-                    "-vf",
-                    f"scale={horiz_resol}:-1",
-                    "-b:v",
-                    f"{video_quality * 1024 * 1024}",
-                    f"{file_name}.re-encoded.{horiz_resol}px.{video_quality}Mb.avi",
+                    file_name,
+                    "-filter_complex",
+                    "showspectrum=mode=combined:color=intensity:slide=1:scale=cbrt",
+                    "-acodec",
+                    "copy",
+                    output_file_name,
                 ]
+                self.processes.append([QProcess(self), [self.ffmpeg_bin, args, output_file_name]])
+                self.processes[-1][0].setProcessChannelMode(QProcess.MergedChannels)
+                self.processes[-1][0].readyReadStandardOutput.connect(lambda: readStdOutput(len(self.processes)))
+                self.processes[-1][0].readyReadStandardError.connect(lambda: readStdOutput(len(self.processes)))
+                self.processes[-1][0].finished.connect(lambda: qprocess_finished(len(self.processes)))
 
-            if action == "rotate":
-                # check bitrate
-                r = util.accurate_media_analysis(self.ffmpeg_bin, file_name)
-                if "error" not in r and r["bitrate"] is not None:
-                    current_bitrate = r["bitrate"]
-                else:
-                    current_bitrate = 10_000_000
-
-                if rotation_idx in (1, 2):
-                    args = [
-                        "-hide_banner",
-                        "-y",
-                        "-i",
-                        f"{file_name}",
-                        "-vf",
-                        f"transpose={rotation_idx}",
-                        "-codec:a",
-                        "copy",
-                        "-b:v",
-                        f"{current_bitrate}",
-                        f"{file_name}.rotated{['', '90', '-90'][rotation_idx]}.avi",
-                    ]
+                self.processes[-1][0].start(self.processes[-1][1][0], self.processes[-1][1][1])
 
-                if rotation_idx == 3:  # 180
+        case "reencode_resize" | "rotate":
+            for file_name in sorted(file_names, reverse=True):
+                if action == "reencode_resize":
                     args = [
                         "-hide_banner",
                         "-y",
                         "-i",
                         f"{file_name}",
                         "-vf",
-                        "transpose=2,transpose=2",
-                        "-codec:a",
-                        "copy",
+                        f"scale={horiz_resol}:-1",
                         "-b:v",
-                        f"{current_bitrate}",
-                        f"{file_name}.rotated180.avi",
+                        f"{video_quality * 1024 * 1024}",
+                        f"{file_name}.re-encoded.{horiz_resol}px.{video_quality}Mb.avi",
                     ]
 
-            logging.debug("Launch process")
-            logging.debug(f"{self.ffmpeg_bin} {' '.join(args)}")
-
-            self.processes.append([QProcess(self), [self.ffmpeg_bin, args, file_name]])
-
-            # self.processes[-1][0].setProcessChannelMode(QProcess.SeparateChannels)
+                if action == "rotate":
+                    # check bitrate
+                    r = util.accurate_media_analysis(self.ffmpeg_bin, file_name)
+                    if "error" not in r and r["bitrate"] is not None:
+                        current_bitrate = r["bitrate"]
+                    else:
+                        current_bitrate = 10_000_000
+
+                    if rotation_idx in (1, 2):
+                        args = [
+                            "-hide_banner",
+                            "-y",
+                            "-i",
+                            f"{file_name}",
+                            "-vf",
+                            f"transpose={rotation_idx}",
+                            "-codec:a",
+                            "copy",
+                            "-b:v",
+                            f"{current_bitrate}",
+                            f"{file_name}.rotated{['', '90', '-90'][rotation_idx]}.avi",
+                        ]
+
+                    if rotation_idx == 3:  # 180
+                        args = [
+                            "-hide_banner",
+                            "-y",
+                            "-i",
+                            f"{file_name}",
+                            "-vf",
+                            "transpose=2,transpose=2",
+                            "-codec:a",
+                            "copy",
+                            "-b:v",
+                            f"{current_bitrate}",
+                            f"{file_name}.rotated180.avi",
+                        ]
+
+                logging.debug("Launch process")
+                logging.debug(f"{self.ffmpeg_bin} {' '.join(args)}")
+
+                self.processes.append([QProcess(self), [self.ffmpeg_bin, args, file_name]])
+
+                ## FFmpeg output the work in progress on stderr
+                self.processes[-1][0].setProcessChannelMode(QProcess.MergedChannels)
+                self.processes[-1][0].readyReadStandardOutput.connect(lambda: readStdOutput(len(self.processes)))
+                # self.processes[-1][0].readyReadStandardError.connect(lambda: readStdOutput(len(self.processes)))
+
+                self.processes[-1][0].finished.connect(lambda: qprocess_finished(len(self.processes)))
 
-            ## FFmpeg output the work in progress on stderr
-            self.processes[-1][0].setProcessChannelMode(QProcess.MergedChannels)
-            self.processes[-1][0].readyReadStandardOutput.connect(lambda: readStdOutput(len(self.processes)))
-            # self.processes[-1][0].readyReadStandardError.connect(lambda: readStdOutput(len(self.processes)))
-
-            self.processes[-1][0].finished.connect(lambda: qprocess_finished(len(self.processes)))
-
-        self.processes[-1][0].start(self.processes[-1][1][0], self.processes[-1][1][1])
+            self.processes[-1][0].start(self.processes[-1][1][0], self.processes[-1][1][1])

boris/import_observations.py

@@ -19,10 +19,11 @@ Copyright 2012-2025 Olivier Friard
   MA 02110-1301, USA.
 """
 
-import json
 import datetime
-from pathlib import Path
+import gzip
+import json
 import pandas as pd
+from pathlib import Path
 
 from PySide6.QtWidgets import (
     QMessageBox,
@@ -49,8 +50,14 @@ def load_observations_from_boris_project(self, project_file_path: str):
         )
         return
 
+    if project_file_path.endswith(".boris.gz"):
+        file_in = gzip.open(project_file_path, mode="rt", encoding="utf-8")
+    else:
+        file_in = open(project_file_path, "r")
+    file_content = file_in.read()
+
     try:
-        fromProject = json.loads(open(project_file_path, "r").read())
+        fromProject = json.loads(file_content)
     except Exception:
         QMessageBox.critical(self, cfg.programName, "This project file seems corrupted")
         return
@@ -84,7 +91,7 @@ def load_observations_from_boris_project(self, project_file_path: str):
             if new_behav_set:
                 diag_result = dialog.MessageDialog(
                     cfg.programName,
-                    (f"Some coded behaviors in <b>{obs_id}</b> are " f"not defined in the ethogram:<br><b>{', '.join(new_behav_set)}</b>"),
+                    (f"Some coded behaviors in <b>{obs_id}</b> are not defined in the ethogram:<br><b>{', '.join(new_behav_set)}</b>"),
                     ["Interrupt import", "Skip observation", "Import observation"],
                 )
                 if diag_result == "Interrupt import":
@@ -103,7 +110,7 @@ def load_observations_from_boris_project(self, project_file_path: str):
             if new_subject_set and new_subject_set != {""}:
                 diag_result = dialog.MessageDialog(
                     cfg.programName,
-                    (f"Some coded subjects in <b>{obs_id}</b> are not defined in the project:<br>" f"<b>{', '.join(new_subject_set)}</b>"),
+                    (f"Some coded subjects in <b>{obs_id}</b> are not defined in the project:<br><b>{', '.join(new_subject_set)}</b>"),
                     ["Interrupt import", "Skip observation", "Import observation"],
                 )
 
@@ -116,7 +123,7 @@ def load_observations_from_boris_project(self, project_file_path: str):
             if obs_id in self.pj[cfg.OBSERVATIONS].keys():
                 diag_result = dialog.MessageDialog(
                     cfg.programName,
-                    (f"The observation <b>{obs_id}</b>" "already exists in the current project.<br>"),
+                    (f"The observation <b>{obs_id}</b>already exists in the current project.<br>"),
                     ["Interrupt import", "Skip observation", "Rename observation"],
                 )
                 if diag_result == "Interrupt import":
@@ -141,18 +148,11 @@ def load_observations_from_spreadsheet(self, project_file_path: str):
     import observations from a spreadsheet file
     """
 
-    if Path(project_file_path).suffix.upper() == ".XLSX":
+    if Path(project_file_path).suffix.lower() == ".xlsx":
         engine = "openpyxl"
-    elif Path(project_file_path).suffix.upper() == ".ODS":
+    elif Path(project_file_path).suffix.lower() == ".ods":
         engine = "odf"
     else:
-        QMessageBox.warning(
-            None,
-            cfg.programName,
-            ("The type of file was not recognized. Must be Microsoft-Excel XLSX format or OpenDocument ODS"),
-            QMessageBox.Ok | QMessageBox.Default,
-            QMessageBox.NoButton,
-        )
         return
 
     try:
@@ -167,7 +167,7 @@ def load_observations_from_spreadsheet(self, project_file_path: str):
         )
         return
 
-    expected_labels: list = ["time", "subject", "code", "modifier", "comment"]
+    expected_labels: list = ("time", "subject", "code", "modifier", "comment")
 
     df.columns = df.columns.str.upper()
 
@@ -210,16 +210,16 @@ def import_observations(self):
     """
 
     file_name, _ = QFileDialog().getOpenFileName(
-        None, "Choose a file", "", "BORIS project files (*.boris);;Spreadsheet files (*.ods *.xlsx *);;All files (*)"
+        None, "Choose a file", "", "BORIS project files (*.boris *.boris.gz);;Spreadsheet files (*.ods *.xlsx *);;All files (*)"
     )
 
     if not file_name:
         return
 
-    if Path(file_name).suffix == ".boris":
+    if file_name.endswith(".boris") or file_name.endswith(".boris.gz"):
         load_observations_from_boris_project(self, file_name)
 
-    if Path(file_name).suffix in (".ods", ".xlsx"):
+    elif Path(file_name).suffix.lower() in (".ods", ".xlsx"):
         if not self.observationId:
             QMessageBox.warning(
                 None,
@@ -231,3 +231,12 @@ def import_observations(self):
             return
 
         load_observations_from_spreadsheet(self, file_name)
+
+    else:
+        QMessageBox.warning(
+            None,
+            cfg.programName,
+            ("The type of file was not recognized. Must be a BORIS project or a Microsoft-Excel XLSX format or OpenDocument ODS"),
+            QMessageBox.Ok | QMessageBox.Default,
+            QMessageBox.NoButton,
+        )

boris/observation_operations.py

@@ -19,7 +19,7 @@ Copyright 2012-2025 Olivier Friard
   MA 02110-1301, USA.
 """
 
-from math import log2
+from math import log2, floor
 import os
 import logging
 import time
@@ -2426,6 +2426,17 @@ def event2media_file_name(observation: dict, timestamp: dec) -> Optional[str]:
         str: name of media file containing the event
     """
 
+    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:
@@ -2433,9 +2444,12 @@ def event2media_file_name(observation: dict, timestamp: dec) -> Optional[str]:
             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

boris/plot_events.py

@@ -25,7 +25,7 @@ import pathlib as pl
 
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
 
 import matplotlib.dates
 

boris/plot_events_rt.py

@@ -25,7 +25,7 @@ Plot events in real time
 
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
 
 import numpy as np
 from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel

boris/plot_spectrogram_rt.py

@@ -24,10 +24,10 @@ Copyright 2012-2025 Olivier Friard
 import wave
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
 
 import numpy as np
-
+from scipy import signal
 from . import config as cfg
 
 from PySide6.QtWidgets import (
@@ -43,8 +43,6 @@ from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 import matplotlib.ticker as mticker
 
-# matplotlib.pyplot.switch_backend("Qt5Agg")
-
 
 class Plot_spectrogram_RT(QWidget):
     # send keypress event to mainwindow
@@ -115,7 +113,7 @@ class Plot_spectrogram_RT(QWidget):
         else:
             return False
 
-    def get_wav_info(self, wav_file: str):
+    def get_wav_info(self, wav_file: str) -> tuple[np.array, int]:
         """
         read wav file and extract information
 
@@ -184,7 +182,7 @@ class Plot_spectrogram_RT(QWidget):
 
         return {"media_length": self.media_length, "frame_rate": self.frame_rate}
 
-    def plot_spectro(self, current_time: float, force_plot: bool = False):
+    def plot_spectro(self, current_time: float, force_plot: bool = False) -> tuple[float, bool]:
         """
         plot sound spectrogram centered on the current time
 
@@ -200,15 +198,36 @@ class Plot_spectrogram_RT(QWidget):
 
         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)],
+                self.sound_info[: int(self.interval * self.frame_rate)],
                 mode="psd",
-                # NFFT=1024,
+                NFFT=nfft,
                 Fs=self.frame_rate,
-                # noverlap=900,
+                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)
@@ -222,10 +241,25 @@ class Plot_spectrogram_RT(QWidget):
             self.ax.specgram(
                 self.sound_info[i:],
                 mode="psd",
-                # NFFT=1024,
+                NFFT=nfft,
                 Fs=self.frame_rate,
-                # noverlap=900,
+                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)
@@ -248,10 +282,25 @@ class Plot_spectrogram_RT(QWidget):
                     )
                 ],
                 mode="psd",
-                # NFFT=1024,
+                NFFT=nfft,
                 Fs=self.frame_rate,
-                # noverlap=900,
+                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()))

boris/plot_waveform_rt.py

@@ -25,7 +25,7 @@ import wave
 from . import config as cfg
 import matplotlib
 
-matplotlib.use("Qt5Agg")
+matplotlib.use("QtAgg")
 
 import numpy as np
 from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel