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

boris/latency.py

@@ -0,0 +1,244 @@
+"""
+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.
+
+
+Module for analyzing the latency of behaviors after another behavior(s) (marker)
+
+"""
+
+from . import config as cfg
+from . import select_subj_behav
+from . import dialog
+from . import select_observations
+from . import project_functions, observation_operations
+
+from PySide6.QtWidgets import QMessageBox
+
+
+def get_latency(self):
+    """
+    get latency (time after marker/stimulus)
+    """
+
+    QMessageBox.warning(
+        None,
+        cfg.programName,
+        (
+            "This function is experimental. Please test it and report any bug at <br>"
+            '<a href="https://github.com/olivierfriard/BORIS/issues">'
+            "https://github.com/olivierfriard/BORIS/issues</a><br>"
+            "Thank you for your collaboration!"
+        ),
+        QMessageBox.Ok | QMessageBox.Default,
+        QMessageBox.NoButton,
+    )
+
+    SUBJECT, BEHAVIOR, MODIFIERS = 0, 1, 2
+
+    _, selected_observations = select_observations.select_observations2(
+        self, cfg.SELECT1, windows_title="Select one observation for latency analysis"
+    )
+
+    if not selected_observations:
+        return
+
+    # check if coded behaviors are defined in ethogram
+    if project_functions.check_coded_behaviors_in_obs_list(self.pj, selected_observations):
+        return
+
+    # check if state events are paired
+    not_ok, selected_observations = project_functions.check_state_events(self.pj, selected_observations)
+    if not_ok or not selected_observations:
+        return
+
+    start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
+    # exit with message if events do not have timestamp
+    if start_coding.is_nan():
+        QMessageBox.critical(
+            None,
+            cfg.programName,
+            ("This function is not available for observations with events that do not have timestamp"),
+            QMessageBox.Ok | QMessageBox.Default,
+            QMessageBox.NoButton,
+        )
+        return
+
+    parameters: dict = select_subj_behav.choose_obs_subj_behav_category(
+        self,
+        selected_observations,
+        show_exclude_non_coded_behaviors=False,
+        window_title="Select the marker behaviors (stimulus)",
+        n_observations=len(selected_observations),
+    )
+
+    if parameters == {}:
+        return
+
+    if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:
+        QMessageBox.warning(None, cfg.programName, "Select subject(s) and behavior(s) to analyze")
+        return
+
+    marker_behaviors = parameters[cfg.SELECTED_BEHAVIORS]
+    marker_subjects = parameters[cfg.SELECTED_SUBJECTS]
+    include_marker_modifiers = parameters[cfg.INCLUDE_MODIFIERS]
+
+    print(f"{marker_behaviors=} {marker_subjects=} {include_marker_modifiers=}")
+
+    parameters: dict = select_subj_behav.choose_obs_subj_behav_category(
+        self, selected_observations, show_exclude_non_coded_behaviors=False, window_title="Select the latency behaviors"
+    )
+    if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:
+        return
+    latency_behaviors = parameters[cfg.SELECTED_BEHAVIORS]
+    latency_subjects = parameters[cfg.SELECTED_SUBJECTS]
+    include_latency_modifiers = parameters[cfg.INCLUDE_MODIFIERS]
+
+    print(f"{latency_behaviors=} {latency_subjects=} {include_latency_modifiers=}")
+
+    results: dict = {}
+    for obs_id in selected_observations:
+        print(f"{obs_id=}")
+
+        events_with_status = project_functions.events_start_stop(
+            self.pj[cfg.ETHOGRAM],
+            self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS],
+            self.pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE],
+        )
+
+        print(f"{events_with_status=}")
+
+        for idx, event in enumerate(events_with_status):
+            print(f"{event=}")
+
+            print(f"{event[cfg.EVENT_STATUS_FIELD_IDX]=}")
+
+            print(f"{event[cfg.EVENT_BEHAVIOR_FIELD_IDX]=}")
+
+            print(f"{event[cfg.EVENT_SUBJECT_FIELD_IDX]=}")
+
+            if all(
+                (
+                    event[cfg.EVENT_STATUS_FIELD_IDX] in (cfg.START, cfg.POINT),
+                    event[cfg.EVENT_BEHAVIOR_FIELD_IDX] in marker_behaviors,
+                    any(
+                        (
+                            event[cfg.EVENT_SUBJECT_FIELD_IDX] in marker_subjects,
+                            all((event[cfg.EVENT_SUBJECT_FIELD_IDX] == "", cfg.NO_FOCAL_SUBJECT in marker_subjects)),
+                        )
+                    ),
+                )
+            ):
+                if include_marker_modifiers:
+                    marker = event[cfg.EVENT_TIME_FIELD_IDX : cfg.EVENT_MODIFIER_FIELD_IDX + 1]
+                else:
+                    marker = event[cfg.EVENT_TIME_FIELD_IDX : cfg.EVENT_BEHAVIOR_FIELD_IDX + 1]
+
+                print(f"{marker=}")
+
+                if marker not in results:
+                    results[marker] = {}
+
+                for event2 in events_with_status[idx + 1 :]:
+                    if all(
+                        (
+                            event2[cfg.EVENT_STATUS_FIELD_IDX] in (cfg.START, cfg.POINT),
+                            event2[cfg.EVENT_BEHAVIOR_FIELD_IDX] in latency_behaviors,
+                            any(
+                                (
+                                    event2[cfg.EVENT_SUBJECT_FIELD_IDX] in latency_subjects,
+                                    all(
+                                        (
+                                            event2[cfg.EVENT_SUBJECT_FIELD_IDX] == "",
+                                            cfg.NO_FOCAL_SUBJECT in latency_subjects,
+                                        )
+                                    ),
+                                )
+                            ),
+                        )
+                    ):
+                        print(event, event2)
+                        if include_latency_modifiers:
+                            latency = event2[cfg.EVENT_SUBJECT_FIELD_IDX : cfg.EVENT_MODIFIER_FIELD_IDX + 1]
+                        else:
+                            latency = event2[cfg.EVENT_SUBJECT_FIELD_IDX : cfg.EVENT_BEHAVIOR_FIELD_IDX + 1]
+
+                        # print(f"{marker=}")
+                        print(f"{latency=}")
+                        if latency not in results[marker]:
+                            results[marker][latency] = []
+                        results[marker][latency].append(event2[cfg.EVENT_TIME_FIELD_IDX] - event[cfg.EVENT_TIME_FIELD_IDX])
+
+                        print(f"{results[marker][latency]=}")
+
+                    # check if new marker
+                    if all(
+                        (
+                            event2[cfg.EVENT_STATUS_FIELD_IDX] in (cfg.START, cfg.POINT),
+                            event2[cfg.EVENT_BEHAVIOR_FIELD_IDX] in marker_behaviors,
+                            any(
+                                (
+                                    event2[cfg.EVENT_SUBJECT_FIELD_IDX] in marker_subjects,
+                                    all(
+                                        (
+                                            event2[cfg.EVENT_SUBJECT_FIELD_IDX] == "",
+                                            cfg.NO_FOCAL_SUBJECT in marker_subjects,
+                                        )
+                                    ),
+                                )
+                            ),
+                        )
+                    ):
+                        break
+
+        break
+
+    # print()
+    # import pprint
+    # pprint.pprint(results)
+
+    out = ""
+
+    for marker in sorted(results.keys()):
+        subject = cfg.NO_FOCAL_SUBJECT if marker[cfg.EVENT_SUBJECT_FIELD_IDX] == "" else marker[1]
+        if include_marker_modifiers:
+            out += f"Marker: <b>{marker[cfg.EVENT_BEHAVIOR_FIELD_IDX]}</b> at {marker[cfg.EVENT_TIME_FIELD_IDX]} s (subject: {subject} - modifiers: {marker[cfg.EVENT_MODIFIER_FIELD_IDX]})<br><br>"
+        else:
+            out += f"Marker: <b>{marker[cfg.EVENT_BEHAVIOR_FIELD_IDX]}</b> at {marker[cfg.EVENT_TIME_FIELD_IDX]} s (subject: {subject})<br><br>"
+        for behav in results[marker]:
+            subject = cfg.NO_FOCAL_SUBJECT if behav[SUBJECT] == "" else behav[SUBJECT]
+            if include_latency_modifiers:
+                out += f"\nLatency for behavior: <b>{behav[BEHAVIOR]}</b> (subject: {subject} - modifiers: {behav[MODIFIERS]})<br>"
+            else:
+                out += f"\nLatency for behavior:  <b>{behav[BEHAVIOR]}</b> (subject: {subject})<br>"
+
+            out += "first occurrence: "
+            out += f"{sorted(results[marker][behav])[0]} s<br>"
+            out += "all occurrences: "
+
+            out += ", ".join([f"{x} s" for x in sorted(results[marker][behav])])
+            out += "<br><br>"
+
+        out += "<br><br>"
+
+    self.results = dialog.Results_dialog()
+    self.results.setWindowTitle("Latency")
+    self.results.ptText.clear()
+    self.results.ptText.appendHtml(out)
+    self.results.show()

boris/measurement_widget.py

@@ -0,0 +1,161 @@
+"""
+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 logging
+
+from PySide6.QtCore import Signal
+
+# from PySide6.QtGui import *
+from PySide6.QtWidgets import (
+    QApplication,
+    QWidget,
+    QRadioButton,
+    QLabel,
+    QHBoxLayout,
+    QVBoxLayout,
+    QLineEdit,
+    QPlainTextEdit,
+    QCheckBox,
+    QPushButton,
+    QFileDialog,
+    QMessageBox,
+)
+from . import dialog
+from . import config as cfg
+
+
+class wgMeasurement(QWidget):
+    """ """
+
+    closeSignal, clearSignal = Signal(), Signal()
+    flagSaved = True
+    draw_mem = []
+
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Geometric measurements")
+
+        vbox = QVBoxLayout(self)
+
+        self.rbPoint = QRadioButton("Point (left click)")
+        vbox.addWidget(self.rbPoint)
+
+        self.rbDistance = QRadioButton("Distance (start: left click, end: right click)")
+        vbox.addWidget(self.rbDistance)
+
+        self.rbArea = QRadioButton("Area (left click for area vertices, right click to close area)")
+        vbox.addWidget(self.rbArea)
+
+        self.rbAngle = QRadioButton("Angle (vertex: left click, segments: right click)")
+        vbox.addWidget(self.rbAngle)
+
+        self.cbPersistentMeasurements = QCheckBox("Measurements are persistent")
+        self.cbPersistentMeasurements.setChecked(True)
+        vbox.addWidget(self.cbPersistentMeasurements)
+
+        vbox.addWidget(QLabel("<b>Scale</b>"))
+
+        hbox1 = QHBoxLayout()
+
+        self.lbRef = QLabel("Reference")
+        hbox1.addWidget(self.lbRef)
+
+        self.lbPx = QLabel("Pixels")
+        hbox1.addWidget(self.lbPx)
+
+        vbox.addLayout(hbox1)
+
+        hbox2 = QHBoxLayout()
+
+        self.leRef = QLineEdit()
+        self.leRef.setText("1")
+        hbox2.addWidget(self.leRef)
+
+        self.lePx = QLineEdit()
+        self.lePx.setText("1")
+        hbox2.addWidget(self.lePx)
+
+        vbox.addLayout(hbox2)
+
+        self.pte = QPlainTextEdit()
+        vbox.addWidget(self.pte)
+
+        self.status_lb = QLabel()
+        vbox.addWidget(self.status_lb)
+
+        hbox3 = QHBoxLayout()
+
+        self.pbClear = QPushButton("Clear measurements", clicked=self.pbClear_clicked)
+        hbox3.addWidget(self.pbClear)
+
+        self.pbSave = QPushButton("Save results", clicked=self.pbSave_clicked)
+        hbox3.addWidget(self.pbSave)
+
+        self.pbClose = QPushButton(cfg.CLOSE, clicked=self.pbClose_clicked)
+        hbox3.addWidget(self.pbClose)
+
+        vbox.addLayout(hbox3)
+
+    def pbClear_clicked(self):
+        """
+        clear measurements draw and results
+        """
+        self.draw_mem = {}
+        self.pte.clear()
+        self.clearSignal.emit()
+
+    def pbClose_clicked(self):
+        if not self.flagSaved:
+            response = dialog.MessageDialog(
+                cfg.programName,
+                "The current results are not saved. Do you want to save results before closing?",
+                [cfg.YES, cfg.NO, cfg.CANCEL],
+            )
+            if response == cfg.YES:
+                self.pbSave_clicked()
+            if response == cfg.CANCEL:
+                return
+        self.closeSignal.emit()
+
+    def pbSave_clicked(self):
+        """
+        save results
+        """
+        if self.pte.toPlainText():
+            fileName, _ = QFileDialog().getSaveFileName(self, "Save measurement results", "", "Text files (*.txt);;All files (*)")
+            if fileName:
+                with open(fileName, "w") as f:
+                    f.write(self.pte.toPlainText())
+                self.flagSaved = True
+        else:
+            QMessageBox.information(self, cfg.programName, "There are no results to save")
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    w = wgMeasurement(logging.getLogger().getEffectiveLevel())
+    w.show()
+
+    sys.exit(app.exec_())

boris/media_file.py

@@ -0,0 +1,115 @@
+"""
+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/>.
+
+"""
+
+from PySide6.QtWidgets import QFileDialog
+
+from . import config as cfg
+from . import utilities as util
+from . import dialog
+from . import project_functions
+from . import utilities as util
+
+
+def get_info(self) -> None:
+    """
+    show info about media file (current media file if an observation is opened)
+    """
+
+    def media_analysis_str(ffmpeg_bin: str, media_full_path: str) -> str:
+        r = util.accurate_media_analysis(ffmpeg_bin, media_full_path)
+
+        if "error" in r:
+            ffmpeg_output = f"File path: {media_full_path}<br><br>{r['error']}<br><br>"
+        else:
+            ffmpeg_output = f"<br><b>{r['analysis_program']} analysis</b><br>"
+
+            ffmpeg_output += (
+                f"File path: <b>{media_full_path}</b><br><br>"
+                f"Duration: {r['duration']} seconds ({util.convertTime(self.timeFormat, r['duration'])})<br>"
+                f"FPS: {r['fps']}<br>"
+                f"Resolution: {r['resolution']} pixels<br>"
+                f"Format long name: {r.get('format_long_name', cfg.NA)}<br>"
+                f"Creation time: {r.get('creation_time', cfg.NA)}<br>"
+                f"Number of frames: {r['frames_number']}<br>"
+                f"Bitrate: {util.smart_size_format(r['bitrate'])}   <br>"
+                f"Has video: {r['has_video']}<br>"
+                f"Has audio: {r['has_audio']}<br>"
+                f"File size: {util.smart_size_format(r.get('file size', cfg.NA))}<br>"
+                f"Video codec: {r.get('video_codec', cfg.NA)}<br>"
+                f"Audio codec: {r.get('audio_codec', cfg.NA)}<br>"
+            )
+
+        return ffmpeg_output
+
+    if self.observationId and self.playerType == cfg.MEDIA:
+        tot_output: str = ""
+
+        for i, dw in enumerate(self.dw_player):
+            if not (
+                str(i + 1) in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE]
+                and self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][str(i + 1)]
+            ):
+                continue
+
+            mpv_output = (
+                "<b>MPV information</b><br>"
+                f"Duration: {dw.player.duration} seconds ({util.seconds2time(dw.player.duration)})<br>"
+                # "Position: {} %<br>"
+                f"FPS: {dw.player.container_fps}<br>"
+                # "Rate: {}<br>"
+                f"Resolution: {dw.player.width}x{dw.player.height} pixels<br>"
+                # "Scale: {}<br>"
+                f"Video format: {dw.player.video_format}<br>"
+                # "State: {}<br>"
+                # "Media Resource Location: {}<br>"
+                # "File name: {}<br>"
+                # "Track: {}/{}<br>"
+                f"Number of media in media list: {dw.player.playlist_count}<br>"
+                f"Current time position: {dw.player.time_pos}<br>"
+                f"Aspect ratio: {round(dw.player.width / dw.player.height, 3)}<br>"
+                # "is seekable? {}<br>"
+                # "has_vout? {}<br>"
+            )
+
+            # FFmpeg/FFprobe analysis
+            ffmpeg_output: str = ""
+            for file_path in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][str(i + 1)]:
+                media_full_path = project_functions.full_path(file_path, self.projectFileName)
+                ffmpeg_output += media_analysis_str(self.ffmpeg_bin, media_full_path)
+
+            ffmpeg_output += f"<br>Total duration: {sum(self.dw_player[i].media_durations) / 1000} ({util.convertTime(self.timeFormat, sum(self.dw_player[i].media_durations) / 1000)})"
+
+            tot_output += mpv_output + ffmpeg_output + "<br><hr>"
+
+    else:  # no open observation
+        file_paths, _ = QFileDialog().getOpenFileNames(self, "Select a media file", "", "Media files (*)")
+        if not file_paths:
+            return
+
+        tot_output: str = ""
+        for file_path in file_paths:
+            tot_output += media_analysis_str(self.ffmpeg_bin, file_path)
+
+    self.results = dialog.Results_dialog()
+    self.results.setWindowTitle(f"{cfg.programName} - Media file information")
+    self.results.ptText.appendHtml(tot_output)
+    self.results.show()