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

boris/ipc_mpv.py

@@ -1,8 +1,29 @@
+"""
+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/>.
+
+"""
+
 import socket
 import json
 import subprocess
 
-# from PySide6.QtCore import QTimer
 import logging
 import config as cfg
 
@@ -36,11 +57,13 @@ class IPC_MPV:
         self.process = subprocess.Popen(
             [
                 "mpv",
+                "--ontop",
                 "--no-border",
                 "--osc=no",  # no on screen commands
                 "--input-ipc-server=" + self.socket_path,
                 # "--wid=" + str(int(self.winId())),  # Embed in the widget
-                "--idle",  # Keeps mpv running with no video
+                "--idle=yes",  # Keeps mpv running with no video
+                "--keep-open=always",
                 "--input-default-bindings=no",
                 "--input-vo-keyboard=no",
             ],
@@ -48,30 +71,6 @@ class IPC_MPV:
             stderr=subprocess.PIPE,
         )
 
-    '''
-    def init_socket(self):
-        """
-        Initialize the JSON IPC socket.
-        """
-        print("init socket")
-        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        QTimer.singleShot(5000, self.connect_socket)  # Allow time for mpv to initialize
-    '''
-
-    '''
-    def connect_socket(self):
-        """
-        Connect to the mpv IPC socket.
-        """
-        print("connect socket")
-        try:
-            self.sock.connect(self.socket_path)
-            print("Connected to mpv IPC server.")
-        except socket.error as e:
-            print(f"Failed to connect to mpv IPC server: {e}")
-        print("end of connect_socket fucntion")
-    '''
-
     def send_command(self, command):
         """
         Send a JSON command to the mpv IPC server.
@@ -92,9 +91,7 @@ class IPC_MPV:
                 # Parse the response as JSON
                 response_data = json.loads(response.decode("utf-8"))
                 if response_data["error"] != "success":
-                    print(f"send command: {command}")
-                    print(f"{response_data=}")
-                    print()
+                    logging.warning(f"send command: {command} response data: {response_data}")
                 # Return the 'data' field which contains the playback position
                 return response_data.get("data")
         except FileNotFoundError:
@@ -128,7 +125,6 @@ class IPC_MPV:
 
     @pause.setter
     def pause(self, value):
-        print(f"set pause to {value}")
         return self.send_command({"command": ["set_property", "pause", value]})
 
     @property
@@ -143,6 +139,14 @@ class IPC_MPV:
     def playlist(self):
         return self.send_command({"command": ["get_property", "playlist"]})
 
+    def playlist_next(self):
+        self.send_command({"command": ["playlist-next"]})
+        return
+
+    def playlist_prev(self):
+        self.send_command({"command": ["playlist-prev"]})
+        return
+
     @property
     def playlist_pos(self):
         return self.send_command({"command": ["get_property", "playlist-pos"]})
@@ -168,7 +172,6 @@ class IPC_MPV:
     @property
     def playback_time(self):
         playback_time_ = self.send_command({"command": ["get_property", "playback-time"]})
-        print(f"playback_time: {playback_time_}")
         return playback_time_
 
     def frame_step(self):
@@ -292,6 +295,24 @@ class IPC_MPV:
     def core_idle(self):
         return self.send_command({"command": ["get_property", "core-idle"]})
 
+    @property
+    def video_pan_x(self):
+        return self.send_command({"command": ["get_property", "video-pan-x"]})
+
+    @video_pan_x.setter
+    def video_pan_x(self, value):
+        self.send_command({"command": ["set_property", "video-pan-x", value]})
+        return
+
+    @property
+    def video_pan_y(self):
+        return self.send_command({"command": ["get_property", "video-pan-y"]})
+
+    @video_pan_y.setter
+    def video_pan_y(self, value):
+        self.send_command({"command": ["set_property", "video-pan-y", value]})
+        return
+
     """
     @property
     def xxx(self):

boris/modifier_coding_map_creator.py

@@ -134,7 +134,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
         self.saveMapAction.setShortcut("Ctrl+S")
         self.saveMapAction.setStatusTip("Save modifiers map")
         self.saveMapAction.setEnabled(False)
-        self.saveMapAction.triggered.connect(self.saveMap_clicked)
+        self.saveMapAction.triggered.connect(self.save_map_clicked)
 
         self.saveAsMapAction = QAction(QIcon(), "Save modifiers map as", self)
         self.saveAsMapAction.setStatusTip("Save modifiers map as")
@@ -343,7 +343,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
             )
 
             if response == cfg.SAVE:
-                if not self.saveMap_clicked():
+                if not self.save_map_clicked():
                     event.ignore()
 
             if response == cfg.CANCEL:
@@ -567,7 +567,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
             )
 
             if response == "Save":
-                if not self.saveMap_clicked():
+                if not self.save_map_clicked():
                     return
 
             if response == "Cancel":
@@ -606,7 +606,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
             )
 
             if response == cfg.SAVE:
-                if not self.saveMap_clicked():
+                if not self.save_map_clicked():
                     return
 
             if response == cfg.CANCEL:
@@ -733,7 +733,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
                 self.fileName += ".boris_map"
             self.saveMap()
 
-    def saveMap_clicked(self):
+    def save_map_clicked(self):
         if not self.fileName:
             fn = QFileDialog(self).getSaveFileName(
                 self,
@@ -746,7 +746,7 @@ class ModifiersMapCreatorWindow(QMainWindow):
             else:
                 self.fileName = fn
 
-            if self.fileName and Path(self.fileName).suffix() != ".boris_map":
+            if self.fileName and Path(self.fileName).suffix != ".boris_map":
                 self.fileName += ".boris_map"
 
         if self.fileName:

boris/observation.py

@@ -42,6 +42,7 @@ from PySide6.QtWidgets import (
     QApplication,
     QMenu,
     QListWidgetItem,
+    QHeaderView,
 )
 
 from . import config as cfg
@@ -75,7 +76,10 @@ class AssignConverter(QDialog):
             self.cbb[-1].addItems(["None"] + sorted(converters.keys()))
 
             if column_idx in col_conv:
-                self.cbb[-1].setCurrentIndex((["None"] + sorted(converters.keys())).index(col_conv[column_idx]))
+                if col_conv[column_idx] in (["None"] + sorted(converters.keys())):
+                    self.cbb[-1].setCurrentIndex((["None"] + sorted(converters.keys())).index(col_conv[column_idx]))
+                else:
+                    self.cbb[-1].setCurrentIndex(0)
             else:
                 self.cbb[-1].setCurrentIndex(0)
             hbox.addWidget(self.cbb[-1])
@@ -224,6 +228,9 @@ class Observation(QDialog, Ui_Form):
         self.pbCancel.clicked.connect(self.pbCancel_clicked)
 
         self.tw_data_files.cellDoubleClicked[int, int].connect(self.tw_data_files_cellDoubleClicked)
+        self.tw_data_files.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
+
+        self.twVideo1.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
 
         self.mediaDurations, self.mediaFPS, self.mediaHasVideo, self.mediaHasAudio, self.media_creation_time = {}, {}, {}, {}, {}
 

boris/observation_operations.py

@@ -26,7 +26,7 @@ from decimal import Decimal as dec
 import json
 from math import log2, floor
 import os
-import pathlib as pl
+from pathlib import Path
 import socket
 import subprocess
 import sys
@@ -89,10 +89,10 @@ def export_observations_list_clicked(self):
         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 Path(file_name).is_file():
             if dialog.MessageDialog(cfg.programName, f"The file {file_name} already exists.", [cfg.CANCEL, cfg.OVERWRITE]) == cfg.CANCEL:
                 return
 
@@ -113,6 +113,8 @@ 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:
@@ -122,6 +124,9 @@ def observations_list(self):
         )
         if response == cfg.NO:
             self.show_data_files()
+            # activate main window
+            self.activateWindow()
+
             return ""
         else:
             close_observation(self)
@@ -145,6 +150,8 @@ def observations_list(self):
             )
 
     logging.debug("end observations list")
+    # activate main window
+    self.activateWindow()
 
 
 def open_observation(self, mode: str) -> str:
@@ -594,7 +601,7 @@ def new_observation(self, mode: str = cfg.NEW, obsId: str = "") -> None:
             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,
@@ -1151,6 +1158,9 @@ def close_observation(self):
         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]
@@ -1304,7 +1314,7 @@ def check_creation_date(self) -> Tuple[int, dict]:
 
         if ret == 1:  #  use file creation time
             for media in not_tagged_media_list:
-                media_creation_time[media] = pl.Path(media).stat().st_ctime
+                media_creation_time[media] = Path(media).stat().st_ctime
             return (0, media_creation_time)  # OK use media file creation date/time
         else:
             return (1, {})
@@ -1340,8 +1350,6 @@ def initialize_new_media_observation(self) -> bool:
         self.playerType = cfg.VIEWER_MEDIA
         return True
 
-        # print(f"{self.process=}")
-
     self.playerType = cfg.MEDIA
     self.fps = 0
 
@@ -1365,7 +1373,7 @@ def initialize_new_media_observation(self) -> bool:
 
     # add all media files to media lists
     self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks)
-    self.dw_player: list = []
+    self.dw_player = []
 
     # check if media creation time used as offset
     # TODO check if cfg.MEDIA_CREATION_TIME dict is present
@@ -1831,8 +1839,8 @@ def initialize_new_media_observation(self) -> bool:
         self.dw_player[i].resize_signal.connect(self.resize_dw)
 
         # add durations list
-        self.dw_player[i].media_durations: list = []
-        self.dw_player[i].cumul_media_durations: List[int] = [0]  # [idx for idx,x in enumerate(l) if l[idx-1]<pos<=x]
+        self.dw_player[i].media_durations = []
+        self.dw_player[i].cumul_media_durations = [0]  # [idx for idx,x in enumerate(l) if l[idx-1]<pos<=x]
 
         # add fps list
         self.dw_player[i].fps = {}
@@ -1844,6 +1852,13 @@ def initialize_new_media_observation(self) -> bool:
                 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}")
 
@@ -1887,7 +1902,7 @@ def initialize_new_media_observation(self) -> bool:
             self.dw_player[i].player.playlist_append(media_full_path)
 
             # add media file name to player window title
-            self.dw_player[i].setWindowTitle(f"Player #{i + 1} ({pl.Path(media_full_path).name})")
+            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]
@@ -1964,7 +1979,7 @@ def initialize_new_media_observation(self) -> bool:
 
     menu_options.update_menu(self)
 
-    if not self.MPV_IPC_MODE:
+    if self.MPV_IPC_MODE:
         # activate timer
         self.ipc_mpv_timer = QTimer()
         self.ipc_mpv_timer.setInterval(500)
@@ -1996,7 +2011,7 @@ def initialize_new_media_observation(self) -> bool:
         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():
@@ -2012,7 +2027,7 @@ def initialize_new_media_observation(self) -> bool:
         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():
@@ -2296,8 +2311,8 @@ def initialize_new_images_observation(self):
                 sorted(
                     list(
                         set(
-                            [str(x) for x in pl.Path(full_dir_path).glob(pattern)]
-                            + [str(x) for x in pl.Path(full_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())]
                         )
                     )
                 )
@@ -2422,26 +2437,31 @@ def event2media_file_name(observation: dict, timestamp: dec) -> Optional[str]:
 
 def create_observations(self):
     """
-    Create observations from a media file directory
+    Create observations from a directory of media files
     """
-    # print(self.pj[cfg.OBSERVATIONS])
 
-    dir_path = QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))
-    if not dir_path:
+    if not (dir_path := QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))):
         return
 
-    dlg = dialog.Input_dialog(
-        label_caption="Set the following observation parameters",
-        elements_list=[
+    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", "Save the absolute media file path", True),
             ("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),
-        ],
+        ]
+    )
+
+    dlg = dialog.Input_dialog(
+        label_caption="Set the following observation parameters",
+        elements_list=elements_list,
         title="Observation parameters",
     )
     if not dlg.exec_():
@@ -2450,9 +2470,9 @@ def create_observations(self):
     file_count: int = 0
 
     if dlg.elements["Recurse the subdirectories"].isChecked():
-        files_list = pl.Path(dir_path).rglob("*")
+        files_list = Path(dir_path).rglob("*")
     else:
-        files_list = pl.Path(dir_path).glob("*")
+        files_list = Path(dir_path).glob("*")
 
     for file in files_list:
         if not file.is_file():
@@ -2462,22 +2482,25 @@ def create_observations(self):
             if not r.get("frames_number", 0):
                 continue
 
-            if dlg.elements["Save the absolute media file path"].isChecked():
-                media_file = str(file)
+            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:
-                try:
-                    media_file = str(file.relative_to(pl.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>{pl.Path(self.projectFileName).parent}</b>)"
-                            "<br><br>Aborting the creation of observations"
-                        ),
-                    )
-                    return
+                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(
@@ -2518,4 +2541,6 @@ def create_observations(self):
     else:
         message: str = f"No media file were found in {dir_path}"
 
+    menu_options.update_menu(self)
+
     QMessageBox.information(self, cfg.programName, message)

boris/plot_data_module.py

@@ -134,6 +134,8 @@ class Plot_data(QWidget):
             column_converter=column_converter,
         )
 
+        print(f"{error_msg=}")
+
         if not result:
             self.error_msg = error_msg
             return

boris/plot_spectrogram_rt.py

@@ -183,7 +183,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) -> tuple[float, bool]:
+    def plot_spectro(self, current_time: float | None, force_plot: bool = False) -> tuple[float, bool] | None:
         """
         plot sound spectrogram centered on the current time
 
@@ -192,45 +192,54 @@ class Plot_spectrogram_RT(QWidget):
             force_plot (bool): force plot even if media paused
         """
 
-        if not force_plot and current_time == self.time_mem:
-            return
+        def spectrogram(self, x, window_type, nfft, noverlap, vmin, vmax) -> None:
+            window = matplotlib.mlab.window_hanning
 
-        self.time_mem = current_time
+            if window_type == "hanning":
+                window = matplotlib.mlab.window_hanning
 
-        self.ax.clear()
+            if window_type == "hamming":
+                window = signal.get_window(window_type, nfft)  
 
-        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)
+            if window_type == "blackmanharris":
+                window = signal.get_window(window_type, nfft)
 
-        # start
-        if current_time <= self.interval / 2:
+            # print(f"{self.frame_rate=} {vmin=} {vmax=} {window_type=} {nfft=} {noverlap=}")
             self.ax.specgram(
-                self.sound_info[: int(self.interval * self.frame_rate)],
+                x,
                 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,
+                window=window,
                 cmap=self.spectro_color_map,
                 vmin=vmin,
                 vmax=vmax,
-                # mode="psd",
-                ## NFFT=1024,
-                # Fs=self.frame_rate,
-                ## noverlap=900,
-                # cmap=self.spectro_color_map,
             )
 
+        if not force_plot and current_time == self.time_mem:
+            return
+
+        self.time_mem = current_time
+
+        self.ax.clear()
+
+        window_type = 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)
+        if self.config_param.get(cfg.SPECTROGRAM_USE_VMIN_VMAX, cfg.SPECTROGRAM_USE_VMIN_VMAX_DEFAULT):
+            vmin = self.config_param.get(cfg.SPECTROGRAM_VMIN, cfg.SPECTROGRAM_DEFAULT_VMIN)
+            vmax = self.config_param.get(cfg.SPECTROGRAM_VMAX, cfg.SPECTROGRAM_DEFAULT_VMAX)
+        else:
+            vmin, vmax = None, None
+
+        if current_time is None:
+            return
+
+        # start
+        if current_time <= self.interval / 2:
+            spectrogram(self, self.sound_info[: int(self.interval * self.frame_rate)], window_type, nfft, noverlap, vmin, vmax)
+
             self.ax.set_xlim(current_time - self.interval / 2, current_time + self.interval / 2)
 
             # cursor
@@ -239,29 +248,7 @@ class Plot_spectrogram_RT(QWidget):
         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,
-            )
+            spectrogram(self, self.sound_info[i:], window_type, nfft, noverlap, vmin, vmax)
 
             lim1 = current_time - (self.media_length - self.interval / 2)
             lim2 = lim1 + self.interval
@@ -276,32 +263,18 @@ class Plot_spectrogram_RT(QWidget):
 
         # middle
         else:
-            self.ax.specgram(
+            spectrogram(
+                self,
                 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,
+                window_type,
+                nfft,
+                noverlap,
+                vmin,
+                vmax,
             )
 
             self.ax.xaxis.set_major_locator(mticker.FixedLocator(self.ax.get_xticks().tolist()))
@@ -311,6 +284,5 @@ class Plot_spectrogram_RT(QWidget):
             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()