boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__py3-none-any.whl

boris/geometric_measurement.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -33,9 +33,9 @@ except ModuleNotFoundError:
     flag_pyreadr_loaded = False
 
 
-from PyQt5.QtCore import QPoint, Qt, pyqtSignal, QEvent
-from PyQt5.QtGui import QColor, QPainter, QPolygon, QPixmap
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import QPoint, Qt, Signal, QEvent
+from PySide6.QtGui import QColor, QPainter, QPolygon, QPixmap, QAction, QPen
+from PySide6.QtWidgets import (
     QApplication,
     QCheckBox,
     QFileDialog,
@@ -43,33 +43,38 @@ from PyQt5.QtWidgets import (
     QLabel,
     QLineEdit,
     QMessageBox,
-    QPlainTextEdit,
+    QTableWidget,
+    QTableWidgetItem,
     QPushButton,
     QRadioButton,
     QVBoxLayout,
-    QWidget,
     QColorDialog,
     QSpacerItem,
     QSizePolicy,
+    QDialog,
 )
 
-from typing import Union, Optional, List, Tuple, Dict
+from typing import List
 
 from . import config as cfg
 from . import dialog, menu_options
 from . import utilities as util
 
 
-class wgMeasurement(QWidget):
+class wgMeasurement(QDialog):
     """
     widget for geometric measurements
     """
 
-    closeSignal = pyqtSignal()
-    send_event_signal = pyqtSignal(QEvent)
+    closeSignal = Signal()
+    send_event_signal = Signal(QEvent)
+    reload_image_signal = Signal()
+    save_picture_signal = Signal(str)
     mark_color: str = cfg.ACTIVE_MEASUREMENTS_COLOR
     flag_saved = True  # store if measurements are saved
     draw_mem: dict = {}
+    mem_points: list = []  # memory of clicked points
+    mem_video: list = []  # memory of clicked points
 
     def __init__(self):
         super().__init__()
@@ -78,17 +83,22 @@ class wgMeasurement(QWidget):
 
         vbox = QVBoxLayout(self)
 
-        self.rbPoint = QRadioButton("Point (left click)")
-        vbox.addWidget(self.rbPoint)
+        self.rb_point = QRadioButton("Point (left click)", clicked=self.rb_clicked)
+        vbox.addWidget(self.rb_point)
 
-        self.rbDistance = QRadioButton("Distance (start: left click, end: right click)")
-        vbox.addWidget(self.rbDistance)
+        self.rb_polyline = QRadioButton("Polyline (left click for vertices, right click to finish)", clicked=self.rb_clicked)
+        vbox.addWidget(self.rb_polyline)
 
-        self.rbArea = QRadioButton("Area (left click for area vertices, right click to close area)")
-        vbox.addWidget(self.rbArea)
+        self.rb_polygon = QRadioButton(
+            "Polygon (left click for Polygon vertices, right click to close the polygon)", clicked=self.rb_clicked
+        )
+        vbox.addWidget(self.rb_polygon)
+
+        self.rb_angle = QRadioButton("Angle (vertex: left click, segments: right click)", clicked=self.rb_clicked)
+        vbox.addWidget(self.rb_angle)
 
-        self.rbAngle = QRadioButton("Angle (vertex: left click, segments: right click)")
-        vbox.addWidget(self.rbAngle)
+        self.rb_oriented_angle = QRadioButton("Oriented angle (vertex: left click, segments: right click)", clicked=self.rb_clicked)
+        vbox.addWidget(self.rb_oriented_angle)
 
         hbox = QHBoxLayout()
         self.cbPersistentMeasurements = QCheckBox("Measurements are persistent")
@@ -100,6 +110,8 @@ class wgMeasurement(QWidget):
         self.bt_color_chooser.setStyleSheet(f"QWidget {{background-color:{self.mark_color}}}")
         hbox.addWidget(self.bt_color_chooser)
 
+        hbox.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
+
         vbox.addLayout(hbox)
 
         vbox.addWidget(QLabel("<b>Scale</b>"))
@@ -120,28 +132,70 @@ class wgMeasurement(QWidget):
         hbox2.addWidget(self.lePx)
         vbox.addLayout(hbox2)
 
-        self.pte = QPlainTextEdit()
-        vbox.addWidget(self.pte)
-        self.pte.setReadOnly(True)
-        self.pte.setLineWrapMode(QPlainTextEdit.NoWrap)
+        self.pte = QTableWidget()
+        self.pte.verticalHeader().hide()
+
         # header
-        self.pte.setPlainText("Player\tTime\tFrame index\ttype of measurement\tx\ty\tdistance\tarea\tangle")
+        self.measurements_header = [
+            "Player",
+            "media file name",
+            "Time",
+            "Frame index",
+            "Type of measurement",
+            "x",
+            "y",
+            "Distance",
+            "Area",
+            "Angle",
+            "Coordinates",
+        ]
+        self.pte.setColumnCount(len(self.measurements_header))
+        self.pte.setHorizontalHeaderLabels(self.measurements_header)
+
+        self.pte.setSelectionBehavior(QTableWidget.SelectRows)
+        self.pte.setSelectionMode(QTableWidget.MultiSelection)
+
+        self.pte.setContextMenuPolicy(Qt.ActionsContextMenu)
+
+        self.action = QAction("Delete measurement")
+        self.action.triggered.connect(self.delete_measurement)
+
+        self.pte.addAction(self.action)
+
+        vbox.addWidget(self.pte)
 
         self.status_lb = QLabel()
         vbox.addWidget(self.status_lb)
 
         hbox3 = QHBoxLayout()
         hbox3.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
-        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("Close", clicked=self.pbClose_clicked)
-        hbox3.addWidget(self.pbClose)
+        self.pb_clear = QPushButton("Clear measurements", clicked=self.pbClear_clicked)
+        hbox3.addWidget(self.pb_clear)
+
+        self.pb_save_picture = QPushButton("Save current picture", clicked=self.pb_save_picture_clicked)
+        hbox3.addWidget(self.pb_save_picture)
+
+        # disabled for now
+        self.pb_save_all_pictures = QPushButton("Save all pictures", clicked=self.pb_save_all_pictures_clicked)
+        hbox3.addWidget(self.pb_save_all_pictures)
+
+        self.pb_save = QPushButton("Save results", clicked=self.pb_save_clicked)
+        hbox3.addWidget(self.pb_save)
+        self.pb_close = QPushButton(cfg.CLOSE, clicked=self.pbClose_clicked)
+        hbox3.addWidget(self.pb_close)
         vbox.addLayout(hbox3)
 
         self.installEventFilter(self)
 
+    def rb_clicked(self):
+        """
+        radiobutton clicked, all points in memory are cleared
+        """
+        self.mem_points = []
+        self.mem_video = []
+
+        self.reload_image_signal.emit()
+
     def eventFilter(self, receiver, event):
         """
         send event (if keypress) to main window
@@ -152,6 +206,51 @@ class wgMeasurement(QWidget):
         else:
             return False
 
+    def pb_save_picture_clicked(self):
+        """
+        ask to save the current frame
+        """
+        self.save_picture_signal.emit("current")
+
+    def pb_save_all_pictures_clicked(self):
+        """
+        ask to save all frames with measurements
+        """
+        self.save_picture_signal.emit("all")
+
+    def delete_measurement(self):
+        """
+        delete the selected measurement(s)
+        """
+
+        if not self.pte.selectedItems():
+            return
+
+        rows_to_delete: list = []
+        for item in self.pte.selectedItems():
+            if item.row() not in rows_to_delete:
+                rows_to_delete.append(item.row())
+
+        elements_to_delete = []
+        for row in sorted(rows_to_delete, reverse=True):
+            player = int(self.pte.item(row, 0).text())
+            frame_idx = int(self.pte.item(row, 2).text())
+            obj_type = self.pte.item(row, 3).text()
+            coord = eval(self.pte.item(row, 9).text())
+
+            if frame_idx in self.draw_mem:
+                for idx, element in enumerate(self.draw_mem[frame_idx]):
+                    if (element["player"] == player - 1) and (element["object_type"] == obj_type) and (element["coordinates"] == coord):
+                        elements_to_delete.append((frame_idx, idx))
+
+            self.pte.removeRow(row)
+            self.pte.flag_saved = False
+
+        for frame_idx, idx in sorted(elements_to_delete, reverse=True):
+            self.draw_mem[frame_idx].pop(idx)
+
+        self.reload_image_signal.emit()
+
     def choose_marks_color(self):
         """
         show the color chooser dialog
@@ -180,13 +279,15 @@ class wgMeasurement(QWidget):
                 (cfg.YES, cfg.NO, cfg.CANCEL),
             )
             if response == cfg.YES:
-                self.pbSave_clicked()
+                if self.pb_save_clicked():
+                    event.ignore()
+                    return
             if response == cfg.CANCEL:
                 event.ignore()
                 return
 
-        self.flag_saved = True
-        self.draw_mem = {}
+        self.flag_saved: bool = True
+        self.draw_mem: dict = {}
         self.closeSignal.emit()
 
     def pbClear_clicked(self):
@@ -203,10 +304,18 @@ class wgMeasurement(QWidget):
             if response == cfg.CANCEL:
                 return
 
-        self.draw_mem = {}
+        self.draw_mem: dict = {}
+        self.mem_points: list = []
+        self.mem_video: list = []
+
         self.pte.clear()
+        self.pte.setColumnCount(len(self.measurements_header))
+        self.pte.setRowCount(0)
+        self.pte.setHorizontalHeaderLabels(self.measurements_header)
         self.flag_saved = True
 
+        self.reload_image_signal.emit()
+
     def pbClose_clicked(self):
         """
         Close button
@@ -214,20 +323,28 @@ class wgMeasurement(QWidget):
         logging.debug("close function")
         self.close()
 
-    def pbSave_clicked(self):
+    def pb_save_clicked(self) -> bool:
         """
-        Save measurements results in plain text file
+        Save measurements results
         """
 
         file_formats = [cfg.TSV, cfg.CSV, cfg.ODS, cfg.XLSX, cfg.HTML, cfg.PANDAS_DF]
         if flag_pyreadr_loaded:
             file_formats.append(cfg.RDS)
 
-        file_name, filter_ = QFileDialog().getSaveFileName(
-            self, "Save geometric measurements", "", ";;".join(file_formats)
-        )
+        # default file name
+        media_file_list: list = []
+        for row in range(self.pte.rowCount()):
+            media_file_list.append(self.pte.item(row, 1).text())
+
+        if len(set(media_file_list)) == 1:
+            default_file_name = str(pl.Path(media_file_list[0]).with_suffix(""))
+        else:
+            default_file_name = ""
+
+        file_name, filter_ = QFileDialog().getSaveFileName(self, "Save geometric measurements", default_file_name, ";;".join(file_formats))
         if not file_name:
-            return
+            return True
 
         # add correct file extension if not present
         if pl.Path(file_name).suffix != f".{cfg.FILE_NAME_SUFFIX[filter_]}":
@@ -235,14 +352,21 @@ class wgMeasurement(QWidget):
             # check if file with new extension already exists
             if pl.Path(file_name).is_file():
                 if (
-                    dialog.MessageDialog(
-                        cfg.programName, f"The file {file_name} already exists.", (cfg.CANCEL, cfg.OVERWRITE)
-                    )
+                    dialog.MessageDialog(cfg.programName, f"The file {file_name} already exists.", (cfg.CANCEL, cfg.OVERWRITE))
                     == cfg.CANCEL
                 ):
-                    return
+                    return True
+
+        plain_text: str = "\t".join(self.measurements_header) + "\n"
+        for row in range(self.pte.rowCount()):
+            row_content: list = []
+            for col in range(self.pte.columnCount()):
+                row_content.append(self.pte.item(row, col).text())
+            plain_text += "\t".join(row_content) + "\n"
 
-        df = pd.read_csv(io.StringIO(self.pte.toPlainText()), sep="\t")
+        plain_text = plain_text[:-1]
+
+        df = pd.read_csv(io.StringIO(plain_text), sep="\t")
 
         try:
             if filter_ == cfg.ODS:
@@ -267,9 +391,11 @@ class wgMeasurement(QWidget):
 
         except Exception:
             QMessageBox.warning(self, cfg.programName, "An error occured during saving the measurement results")
+            return True
+        return False  # everything OK
 
 
-def show_widget(self):
+def show_widget(self) -> None:
     """
     active the geometric measurement widget
     """
@@ -306,9 +432,11 @@ def show_widget(self):
     self.actionPlay.setEnabled(False)
 
     self.measurement_w = wgMeasurement()
-    self.measurement_w.setWindowFlags(Qt.WindowStaysOnTopHint)
+    # self.measurement_w.setWindowFlags(Qt.WindowStaysOnTopHint)
     self.measurement_w.closeSignal.connect(close_measurement_widget)
     self.measurement_w.send_event_signal.connect(self.signal_from_widget)
+    self.measurement_w.reload_image_signal.connect(self.reload_frame)
+    self.measurement_w.save_picture_signal.connect(self.save_picture_with_measurements)
     self.measurement_w.draw_mem = {}
 
     self.measurement_w.show()
@@ -323,15 +451,24 @@ def draw_point(self, x: int, y: int, color: str, n_player: int = 0) -> None:
     """
     draw point on frame-by-frame image
     """
+
+    logging.debug("draw_point function")
+
     RADIUS = 6
-    painter = QPainter()
-    painter.begin(self.dw_player[n_player].frame_viewer.pixmap())
-    painter.setPen(QColor(color))
-    painter.drawEllipse(QPoint(x, y), RADIUS, RADIUS)
-    # cross inside circle
-    painter.drawLine(x - RADIUS, y, x + RADIUS, y)
-    painter.drawLine(x, y - RADIUS, x, y + RADIUS)
-    painter.end()
+
+    pixmap_copy = self.dw_player[n_player].frame_viewer.pixmap().copy()
+
+    painter = QPainter(pixmap_copy)
+    try:
+        painter.setPen(QPen(QColor(color), 1))
+        painter.drawEllipse(QPoint(x, y), RADIUS, RADIUS)
+        # cross inside circle
+        painter.drawLine(x - RADIUS, y, x + RADIUS, y)
+        painter.drawLine(x, y - RADIUS, x, y + RADIUS)
+    finally:
+        painter.end()
+
+    self.dw_player[n_player].frame_viewer.setPixmap(pixmap_copy)
     self.dw_player[n_player].frame_viewer.update()
 
 
@@ -339,19 +476,30 @@ def draw_line(self, x1: int, y1: int, x2: int, y2: int, color: str, n_player: in
     """
     draw line on frame-by-frame image
     """
-    painter = QPainter()
-    painter.begin(self.dw_player[n_player].frame_viewer.pixmap())
-    painter.setPen(QColor(color))
-    painter.drawLine(x1, y1, x2, y2)
-    painter.end()
+
+    pixmap_copy = self.dw_player[n_player].frame_viewer.pixmap().copy()
+    painter = QPainter(pixmap_copy)
+
+    try:
+        painter.setPen(QColor(color))
+        painter.drawLine(x1, y1, x2, y2)
+    finally:
+        painter.end()
+
+    self.dw_player[n_player].frame_viewer.setPixmap(pixmap_copy)
     self.dw_player[n_player].frame_viewer.update()
 
 
-def append_results(self, results: List):
+def append_results(self, results: list) -> None:
     """
-    append results to plain text widget
+    append results to measurements table
     """
-    self.measurement_w.pte.appendPlainText("\t".join([str(x) for x in results]))
+    self.measurement_w.pte.setRowCount(self.measurement_w.pte.rowCount() + 1)
+    for idx, x in enumerate(results):
+        item = QTableWidgetItem()
+        item.setText(str(x))
+        item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+        self.measurement_w.pte.setItem(self.measurement_w.pte.rowCount() - 1, idx, item)
 
 
 def image_clicked(self, n_player: int, event) -> None:
@@ -375,7 +523,7 @@ def image_clicked(self, n_player: int, event) -> None:
     self.mem_player = n_player
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
         if self.dw_player[n_player].player.estimated_frame_number is not None:
-            current_frame = self.dw_player[n_player].player.estimated_frame_number + 1
+            current_frame = self.dw_player[n_player].player.estimated_frame_number
         else:
             current_frame = cfg.NA
     elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
@@ -383,35 +531,19 @@ def image_clicked(self, n_player: int, event) -> None:
 
     if not (hasattr(self, "measurement_w") and (self.measurement_w is not None) and (self.measurement_w.isVisible())):
         return
-        """
-        QMessageBox.warning(
-            self,
-            cfg.programName,
-            "The Focus area function is not yet available in frame-by-frame mode.",
-            QMessageBox.Ok | QMessageBox.Default,
-            QMessageBox.NoButton,
-        )"""
 
     x, y = event.pos().x(), event.pos().y()
 
+    logging.debug(f"clicked on {x} {y}")
+
     # convert label coordinates in pixmap coordinates
-    pixmap_x = int(
-        x - (self.dw_player[n_player].frame_viewer.width() - self.dw_player[n_player].frame_viewer.pixmap().width()) / 2
-    )
-    pixmap_y = int(
-        y
-        - (self.dw_player[n_player].frame_viewer.height() - self.dw_player[n_player].frame_viewer.pixmap().height()) / 2
-    )
+    pixmap_x = int(x - (self.dw_player[n_player].frame_viewer.width() - self.dw_player[n_player].frame_viewer.pixmap().width()) / 2)
+    pixmap_y = int(y - (self.dw_player[n_player].frame_viewer.height() - self.dw_player[n_player].frame_viewer.pixmap().height()) / 2)
 
     if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
         # convert pixmap coordinates in video coordinates
-        x_video = round(
-            (pixmap_x / self.dw_player[n_player].frame_viewer.pixmap().width()) * self.dw_player[n_player].player.width
-        )
-        y_video = round(
-            (pixmap_y / self.dw_player[n_player].frame_viewer.pixmap().height())
-            * self.dw_player[n_player].player.height
-        )
+        x_video = round((pixmap_x / self.dw_player[n_player].frame_viewer.pixmap().width()) * self.dw_player[n_player].player.width)
+        y_video = round((pixmap_y / self.dw_player[n_player].frame_viewer.pixmap().height()) * self.dw_player[n_player].player.height)
     elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
         original_width = QPixmap(self.images_list[self.image_idx]).size().width()
         original_height = QPixmap(self.images_list[self.image_idx]).size().height()
@@ -427,117 +559,109 @@ def image_clicked(self, n_player: int, event) -> None:
 
     self.measurement_w.status_lb.clear()
 
+    # media file name
+    if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
+        fn = self.dw_player[n_player - 1].player.playlist[self.dw_player[n_player - 1].player.playlist_pos]["filename"]
+
+        # check if media file path contained in media list
+        if [True for x in self.pj[cfg.OBSERVATIONS][self.observationId]["file"].values() if fn in x]:
+            media_file_name = self.dw_player[n_player - 1].player.playlist[self.dw_player[n_player - 1].player.playlist_pos]["filename"]
+        else:
+            media_file_name = str(pl.Path(fn).relative_to(pl.Path(self.projectFileName).parent))
+
+    if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
+        # check if pictures dir path is relative
+        if str(pl.Path(self.images_list[current_frame]).parent) not in self.pj[cfg.OBSERVATIONS][self.observationId].get(
+            cfg.DIRECTORIES_LIST, []
+        ):
+            media_file_name = str(pl.Path(self.images_list[current_frame]).relative_to(pl.Path(self.projectFileName).parent))
+        else:
+            media_file_name = self.images_list[current_frame]
+
     # point
-    if self.measurement_w.rbPoint.isChecked():
-        if event.button() == 1:  # left click
+    if self.measurement_w.rb_point.isChecked():
+        if event.button() == Qt.LeftButton:
             draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
             if current_frame not in self.measurement_w.draw_mem:
                 self.measurement_w.draw_mem[current_frame] = []
 
             self.measurement_w.draw_mem[current_frame].append(
-                [n_player, "point", self.measurement_w.mark_color, x_video, y_video]
+                {
+                    "player": n_player,
+                    "object_type": cfg.POINT_OBJECT,
+                    "color": self.measurement_w.mark_color,
+                    "coordinates": [(x_video, y_video)],
+                }
             )
 
             append_results(
                 self,
                 (
                     n_player + 1,
+                    media_file_name,
                     f"{self.getLaps():.03f}",
                     current_frame,
-                    "Point",
+                    cfg.POINT_OBJECT,
                     x_video,
                     y_video,
                     cfg.NA,
                     cfg.NA,
                     cfg.NA,
+                    str([(x_video, y_video)]),
                 ),
             )
 
             self.measurement_w.flag_saved = False
 
-    # distance
-    elif self.measurement_w.rbDistance.isChecked():
-        if event.button() == 1:  # left
-            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
-            self.memx, self.memy = round(pixmap_x), round(pixmap_y)
-            self.memx_video, self.memy_video = round(x_video), round(y_video)
-
-        if event.button() == 2 and self.memx != -1 and self.memy != -1:
-            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
-            draw_line(self, self.memx, self.memy, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
-
-            if current_frame not in self.measurement_w.draw_mem:
-                self.measurement_w.draw_mem[current_frame] = []
-
-            self.measurement_w.draw_mem[current_frame].append(
-                [n_player, "line", self.measurement_w.mark_color, self.memx_video, self.memy_video, x_video, y_video]
-            )
-
-            distance = ((x_video - self.memx_video) ** 2 + (y_video - self.memy_video) ** 2) ** 0.5
-            try:
-                distance = distance / float(self.measurement_w.lePx.text()) * float(self.measurement_w.leRef.text())
-            except Exception:
-                QMessageBox.critical(
-                    None,
-                    cfg.programName,
-                    "Check reference and pixel values! Values must be numeric.",
-                    QMessageBox.Ok | QMessageBox.Default,
-                    QMessageBox.NoButton,
-                )
-
-            append_results(
-                self,
-                (
-                    n_player + 1,
-                    f"{self.getLaps():.03f}",
-                    current_frame,
-                    "Distance",
-                    cfg.NA,
-                    cfg.NA,
-                    round(distance, 3),
-                    cfg.NA,
-                    cfg.NA,
-                ),
-            )
-
-            self.measurement_w.flag_saved = False
-            self.memx, self.memy = -1, -1
-
-    # angle 1st clic -> vertex
-    elif self.measurement_w.rbAngle.isChecked():
-        if event.button() == 1:  # left for vertex
+    # angle
+    elif self.measurement_w.rb_angle.isChecked() or self.measurement_w.rb_oriented_angle.isChecked():
+        if event.button() == Qt.LeftButton:
             draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
-            self.memPoints = [(pixmap_x, pixmap_y)]
-            self.mem_video = [(x_video, y_video)]
+            self.measurement_w.mem_points = [(pixmap_x, pixmap_y)]
+            self.measurement_w.mem_video = [(x_video, y_video)]
 
-        if event.button() == 2 and len(self.memPoints):
+        if event.button() == Qt.RightButton and len(self.measurement_w.mem_points):
             draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
             draw_line(
                 self,
-                self.memPoints[0][0],
-                self.memPoints[0][1],
+                self.measurement_w.mem_points[0][0],
+                self.measurement_w.mem_points[0][1],
                 pixmap_x,
                 pixmap_y,
                 self.measurement_w.mark_color,
                 n_player,
             )
 
-            self.memPoints.append((pixmap_x, pixmap_y))
-            self.mem_video.append((x_video, y_video))
+            self.measurement_w.mem_points.append((pixmap_x, pixmap_y))
+            self.measurement_w.mem_video.append((x_video, y_video))
+
+            if len(self.measurement_w.mem_points) == 3:
+                if self.measurement_w.rb_angle.isChecked():
+                    angle = util.angle(self.measurement_w.mem_points[0], self.measurement_w.mem_points[1], self.measurement_w.mem_points[2])
+                    object_type = cfg.ANGLE_OBJECT
+                else:  # oriented angle
+                    angle = util.oriented_angle(
+                        self.measurement_w.mem_points[0], self.measurement_w.mem_points[1], self.measurement_w.mem_points[2]
+                    )
+                    object_type = cfg.ORIENTED_ANGLE_OBJECT
 
-            if len(self.memPoints) == 3:
                 append_results(
                     self,
                     (
                         n_player + 1,
+                        media_file_name,
                         f"{self.getLaps():.03f}",
                         current_frame,
-                        "Angle",
+                        object_type,
                         cfg.NA,
                         cfg.NA,
                         cfg.NA,
                         cfg.NA,
-                        round(util.angle(self.memPoints[0], self.memPoints[1], self.memPoints[2]), 1),
+                        round(
+                            angle,
+                            1,
+                        ),
+                        str(self.measurement_w.mem_video),
                     ),
                 )
 
@@ -546,63 +670,133 @@ def image_clicked(self, n_player: int, event) -> None:
                     self.measurement_w.draw_mem[current_frame] = []
 
                 self.measurement_w.draw_mem[current_frame].append(
-                    [n_player, "angle", self.measurement_w.mark_color, self.mem_video]
+                    {
+                        "player": n_player,
+                        "object_type": object_type,
+                        "color": self.measurement_w.mark_color,
+                        "coordinates": self.measurement_w.mem_video,
+                    }
                 )
 
-                self.memPoints, self.mem_video = [], []
+                self.measurement_w.mem_points, self.measurement_w.mem_video = [], []
 
-    # Area
-    elif self.measurement_w.rbArea.isChecked():
-        if event.button() == 1:  # left
-            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color)
-            if len(self.memPoints):
+    # polygon
+    elif self.measurement_w.rb_polygon.isChecked():
+        if event.button() == Qt.LeftButton:
+            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
+            if len(self.measurement_w.mem_points):
                 draw_line(
                     self,
-                    self.memPoints[-1][0],
-                    self.memPoints[-1][1],
+                    self.measurement_w.mem_points[-1][0],
+                    self.measurement_w.mem_points[-1][1],
                     pixmap_x,
                     pixmap_y,
                     self.measurement_w.mark_color,
                     n_player,
                 )
-            self.memPoints.append((pixmap_x, pixmap_y))
-            self.mem_video.append((x_video, y_video))
+            self.measurement_w.mem_points.append((pixmap_x, pixmap_y))
+            self.measurement_w.mem_video.append((x_video, y_video))
 
-        if event.button() == 2 and len(self.memPoints) >= 2:
-            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
+        if event.button() == Qt.RightButton and len(self.measurement_w.mem_points) >= 2:
+            # close polygon
             draw_line(
                 self,
-                self.memPoints[-1][0],
-                self.memPoints[-1][1],
-                pixmap_x,
-                pixmap_y,
+                self.measurement_w.mem_points[-1][0],
+                self.measurement_w.mem_points[-1][1],
+                self.measurement_w.mem_points[0][0],
+                self.measurement_w.mem_points[0][1],
                 self.measurement_w.mark_color,
                 n_player,
             )
-            self.memPoints.append((pixmap_x, pixmap_y))
-            self.mem_video.append((x_video, y_video))
+            if current_frame not in self.measurement_w.draw_mem:
+                self.measurement_w.draw_mem[current_frame] = []
 
-            # close polygon
-            draw_line(
+            self.measurement_w.draw_mem[current_frame].append(
+                {
+                    "player": n_player,
+                    "object_type": cfg.POLYGON_OBJECT,
+                    "color": self.measurement_w.mark_color,
+                    "coordinates": self.measurement_w.mem_video,
+                }
+            )
+
+            area = util.polygon_area(self.measurement_w.mem_video)
+            try:
+                area = area / (float(self.measurement_w.lePx.text()) ** 2) * float(self.measurement_w.leRef.text()) ** 2
+            except Exception:
+                QMessageBox.critical(
+                    None,
+                    cfg.programName,
+                    "Check reference and pixel values! Values must be numeric.",
+                    QMessageBox.Ok | QMessageBox.Default,
+                    QMessageBox.NoButton,
+                )
+
+            length = util.polyline_length(self.measurement_w.mem_video)
+            try:
+                length = length / float(self.measurement_w.lePx.text()) * float(self.measurement_w.leRef.text())
+            except Exception:
+                QMessageBox.critical(
+                    None,
+                    cfg.programName,
+                    "Check reference and pixel values! Values must be numeric.",
+                    QMessageBox.Ok | QMessageBox.Default,
+                    QMessageBox.NoButton,
+                )
+
+            append_results(
                 self,
-                self.memPoints[-1][0],
-                self.memPoints[-1][1],
-                self.memPoints[0][0],
-                self.memPoints[0][1],
-                self.measurement_w.mark_color,
-                n_player,
+                (
+                    n_player + 1,
+                    media_file_name,
+                    f"{self.getLaps():.03f}",
+                    current_frame,
+                    cfg.POLYGON_OBJECT,
+                    cfg.NA,
+                    cfg.NA,
+                    round(length, 1),
+                    round(area, 1),
+                    cfg.NA,
+                    str(self.measurement_w.mem_video),
+                ),
             )
-            area = util.polygon_area(self.mem_video)
 
+            self.measurement_w.flag_saved = False
+            self.measurement_w.mem_points, self.measurement_w.mem_video = [], []
+
+    # polyline
+    elif self.measurement_w.rb_polyline.isChecked():
+        if event.button() == Qt.LeftButton:
+            draw_point(self, pixmap_x, pixmap_y, self.measurement_w.mark_color, n_player)
+            if len(self.measurement_w.mem_points):
+                draw_line(
+                    self,
+                    self.measurement_w.mem_points[-1][0],
+                    self.measurement_w.mem_points[-1][1],
+                    pixmap_x,
+                    pixmap_y,
+                    self.measurement_w.mark_color,
+                    n_player,
+                )
+            self.measurement_w.mem_points.append((pixmap_x, pixmap_y))
+            self.measurement_w.mem_video.append((x_video, y_video))
+
+        if event.button() == Qt.RightButton:
             if current_frame not in self.measurement_w.draw_mem:
                 self.measurement_w.draw_mem[current_frame] = []
 
             self.measurement_w.draw_mem[current_frame].append(
-                [n_player, "polygon", self.measurement_w.mark_color, self.mem_video]
+                {
+                    "player": n_player,
+                    "object_type": cfg.POLYLINE_OBJECT,
+                    "color": self.measurement_w.mark_color,
+                    "coordinates": self.measurement_w.mem_video,
+                }
             )
 
+            length = util.polyline_length(self.measurement_w.mem_video)
             try:
-                area = area / (float(self.measurement_w.lePx.text()) ** 2) * float(self.measurement_w.leRef.text()) ** 2
+                length = length / float(self.measurement_w.lePx.text()) * float(self.measurement_w.leRef.text())
             except Exception:
                 QMessageBox.critical(
                     None,
@@ -616,19 +810,20 @@ def image_clicked(self, n_player: int, event) -> None:
                 self,
                 (
                     n_player + 1,
+                    media_file_name,
                     f"{self.getLaps():.03f}",
                     current_frame,
-                    "Area",
+                    cfg.POLYLINE_OBJECT,
                     cfg.NA,
                     cfg.NA,
+                    round(length, 1),
                     cfg.NA,
-                    round(area, 3),
                     cfg.NA,
+                    str(self.measurement_w.mem_video),
                 ),
             )
-
+            self.measurement_w.mem_points, self.measurement_w.mem_video = [], []
             self.measurement_w.flag_saved = False
-            self.memPoints, self.mem_video = [], []
 
     else:
         self.measurement_w.status_lb.setText("<b>Choose a measurement type!</b>")
@@ -673,7 +868,7 @@ def redraw_measurements(self):
     for idx, dw in enumerate(self.dw_player):
         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.MEDIA:
             if dw.player.estimated_frame_number is not None:
-                current_frame = dw.player.estimated_frame_number + 1
+                current_frame = dw.player.estimated_frame_number
             else:
                 current_frame = cfg.NA
         if self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
@@ -682,45 +877,59 @@ def redraw_measurements(self):
         for frame in self.measurement_w.draw_mem:
             for element in self.measurement_w.draw_mem[frame]:
                 if frame == current_frame:
-                    elementsColor = element[2]  # color
+                    elements_color = element["color"]
                 else:
-                    elementsColor = cfg.PASSIVE_MEASUREMENTS_COLOR
-
-                if element[0] == idx:
-                    if element[1] == "point":
-                        x, y = scale_coord(element[3:])
-
-                        draw_point(self, int(x), int(y), elementsColor, n_player=idx)
-
-                    if element[1] == "line":
-                        x1, y1, x2, y2 = scale_coord(element[3:])
-                        draw_line(self, x1, y1, x2, y2, elementsColor, n_player=idx)
-                        draw_point(self, x1, y1, elementsColor, n_player=idx)
-                        draw_point(self, x2, y2, elementsColor, n_player=idx)
-
-                    if element[1] == "angle":
-                        x1, y1 = scale_coord(element[3][0])
-                        x2, y2 = scale_coord(element[3][1])
-                        x3, y3 = scale_coord(element[3][2])
-                        draw_line(self, x1, y1, x2, y2, elementsColor, n_player=idx)
-                        draw_line(self, x1, y1, x3, y3, elementsColor, n_player=idx)
-                        draw_point(self, x1, y1, elementsColor, n_player=idx)
-                        draw_point(self, x2, y2, elementsColor, n_player=idx)
-                        draw_point(self, x3, y3, elementsColor, n_player=idx)
-
-                    if element[1] == "polygon":
+                    elements_color = cfg.PASSIVE_MEASUREMENTS_COLOR
+
+                if element["player"] == idx:
+                    if element["object_type"] == cfg.POINT_OBJECT:
+                        x, y = scale_coord(element["coordinates"][0])
+                        draw_point(self, int(x), int(y), elements_color, n_player=idx)
+
+                    if element["object_type"] == cfg.SEGMENT_OBJECT:
+                        x1, y1 = scale_coord(element["coordinates"][0])
+                        x2, y2 = scale_coord(element["coordinates"][1])
+                        draw_line(self, x1, y1, x2, y2, elements_color, n_player=idx)
+                        draw_point(self, x1, y1, elements_color, n_player=idx)
+                        draw_point(self, x2, y2, elements_color, n_player=idx)
+
+                    if element["object_type"] in (cfg.ANGLE_OBJECT, cfg.ORIENTED_ANGLE_OBJECT):
+                        x1, y1 = scale_coord(element["coordinates"][0])
+                        x2, y2 = scale_coord(element["coordinates"][1])
+                        x3, y3 = scale_coord(element["coordinates"][2])
+                        draw_line(self, x1, y1, x2, y2, elements_color, n_player=idx)
+                        draw_line(self, x1, y1, x3, y3, elements_color, n_player=idx)
+                        draw_point(self, x1, y1, elements_color, n_player=idx)
+                        draw_point(self, x2, y2, elements_color, n_player=idx)
+                        draw_point(self, x3, y3, elements_color, n_player=idx)
+
+                    if element["object_type"] == cfg.POLYGON_OBJECT:
                         polygon = QPolygon()
-
-                        for x, y in element[3]:
+                        for x, y in element["coordinates"]:
                             x, y = scale_coord([x, y])
                             polygon.append(QPoint(x, y))
-                        painter = QPainter()
-                        painter.begin(self.dw_player[idx].frame_viewer.pixmap())
-                        painter.setPen(QColor(elementsColor))
-                        painter.drawPolygon(polygon)
-                        painter.end()
+
+                        pixmap_copy = self.dw_player[idx].frame_viewer.pixmap().copy()
+                        painter = QPainter(pixmap_copy)
+
+                        try:
+                            painter.setPen(QColor(elements_color))
+                            painter.drawPolygon(polygon)
+                        finally:
+                            painter.end()
+
+                        self.dw_player[idx].frame_viewer.setPixmap(pixmap_copy)
+
                         dw.frame_viewer.update()
 
+                    if element["object_type"] == cfg.POLYLINE_OBJECT:
+                        for idx1, p1 in enumerate(element["coordinates"][:-1]):
+                            x1, y1 = scale_coord(p1)
+                            p2 = element["coordinates"][idx1 + 1]
+                            x2, y2 = scale_coord(p2)
+
+                            draw_line(self, x1, y1, x2, y2, elements_color, n_player=idx)
+
 
 if __name__ == "__main__":
     import sys