add only scaling option to extrinsic

Author: wenliangyeoh

motion_analysis_2d/custom_components/__init__.py

@@ -5,6 +5,7 @@
 from .file_list import FileListWidget
 from .gui_save_base import BaseGuiSave
 from .help_widget import HelpView
+from .length_item import LengthItem
 from .my_colors import tab10_rgb, tab10_qcolor, tab10_gbr, tab10_rgb_cycle
 from .path_edit import PathEdit
 from .perspective_item import PerspectiveItem

motion_analysis_2d/custom_components/length_item.py

@@ -0,0 +1,168 @@
+import pyqtgraph as pg
+from qtpy import QtCore, QtGui
+
+
+class LengthItem(pg.GraphicsObject):
+    sigLineCornerMoved = QtCore.Signal(int, tuple)
+    sigMoved = QtCore.Signal(object)
+
+    def __init__(
+        self,
+        line_corners=((0, 0), (0, 1)),
+        line_pen=None,
+        line_hover_pen=None,
+        handle_size=10,
+        handle_pen=None,
+        handle_hover_pen=None,
+    ):
+        pg.GraphicsObject.__init__(self)
+
+        self.line_corners = list(line_corners)
+        self.handle_size = handle_size
+
+        self.handle_hover = [False] * 2
+        self.handle_dragging = [False] * 2
+        self.line_hover = False
+        self.line_dragging = None
+
+        self.picture = QtGui.QPicture()
+
+        if line_pen is None:
+            line_pen = pg.mkPen("w", width=2)
+        self.line_pen = line_pen
+
+        if line_hover_pen is None:
+            line_hover_pen = pg.mkPen("b", width=3)
+        self.line_hover_pen = line_hover_pen
+
+        if handle_pen is None:
+            handle_pen = pg.mkPen((150, 255, 255), width=1)
+        self.handle_pen = handle_pen
+
+        if handle_hover_pen is None:
+            handle_hover_pen = pg.mkPen((150, 255, 255), width=3)
+        self.handle_hover_pen = handle_hover_pen
+
+    def generatePicture(self):
+        if not self.getViewBox():
+            return
+
+        p = QtGui.QPainter(self.picture)
+        (w, _), (_, h) = self.pixelVectors()
+        local_handle_size = self.handle_size * w / 2
+
+        # line
+        if self.line_hover:
+            p.setPen(self.line_hover_pen)
+        else:
+            p.setPen(self.line_pen)
+        p.drawLine(*[QtCore.QPointF(*a) for a in self.line_corners])
+
+        # handles for line ends
+        for point, hover in zip(self.line_corners, self.handle_hover):
+            if hover:
+                p.setPen(self.handle_hover_pen)
+            else:
+                p.setPen(self.handle_pen)
+            p.drawEllipse(
+                QtCore.QRectF(
+                    point[0] - local_handle_size,
+                    point[1] - local_handle_size,
+                    local_handle_size * 2,
+                    local_handle_size * 2,
+                )
+            )
+        p.end()
+
+    def paint(self, p, *args):
+        p.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing)
+        self.generatePicture()
+        p.drawPicture(0, 0, self.picture)
+
+    def pos_at_handle(self, pos, size):
+        handles = [False] * 2
+        for i, point in enumerate(self.line_corners):
+            d = (pos - QtCore.QPointF(*point)).manhattanLength()
+            if d <= size * 2:
+                handles[i] = True
+                break
+        return handles
+
+    def hoverEvent(self, ev):
+        self.line_hover = False
+
+        if not ev.isExit():
+            if any(self.handle_dragging) or self.line_dragging is not None:
+                ev.acceptDrags(QtCore.Qt.LeftButton)
+            else:
+                (w, _), (_, h) = self.pixelVectors()
+                local_handle_size = self.handle_size * w / 2
+                self.handle_hover = self.pos_at_handle(ev.lastPos(), local_handle_size)
+                if any(self.handle_hover):
+                    self.update()
+                    return
+
+                self.line_hover = True
+                self.update()
+                return
+        else:
+            self.update()
+
+    def mouseDragEvent(self, ev):
+        if ev.button() != QtCore.Qt.MouseButton.LeftButton:
+            return
+
+        ev.accept()
+        if ev.isStart() and ev.button() == QtCore.Qt.MouseButton.LeftButton:
+            if any(self.handle_hover):
+                self.handle_dragging = self.handle_hover
+            elif self.line_hover:
+                pos = ev.pos()
+                self.line_dragging = [
+                    QtCore.QPointF(*v) - pos for v in self.line_corners
+                ]  # offsets
+
+        elif ev.isFinish():
+            self.handle_dragging = [False] * 4
+            self.line_dragging = None
+
+        if any(self.handle_dragging):
+            i = self.handle_dragging.index(True)
+            pos = ev.pos().toTuple()
+            self.line_corners[i] = pos
+            self.sigLineCornerMoved.emit(i, pos)
+            self.update()
+        elif self.line_dragging is not None:
+            pos = ev.pos()
+            self.line_corners = [(x + pos).toTuple() for x in self.line_dragging]
+            self.sigMoved.emit(self.line_corners)
+            self.update()
+
+    def boundingRect(self):
+        return QtCore.QRectF(self.picture.boundingRect())
+
+    def setData(self, line_corners=None, outer_offsets=None):
+        if line_corners is not None:
+            self.line_corners = line_corners
+
+    def setLineCorner(self, i, pos):
+        self.line_corners[i] = pos
+
+    def setLinePen(self, pen):
+        self.line_pen = pen
+        self.update()
+
+    def setLineHoverPen(self, pen):
+        self.line_hover_pen = pen
+        self.update()
+
+    def get_params(self):
+        return self.line_corners
+
+
+if __name__ == "__main__":
+    item = LengthItem(line_corners=((0, 0), (0, 10)))
+    plt = pg.plot()
+    plt.addItem(item)
+    plt.setAspectLocked()
+    pg.exec()

motion_analysis_2d/dialogs/perspective_dialog.py

@@ -2,35 +2,56 @@
 
 
 class PerspectiveDialog(QtWidgets.QDialog):
-    completed = QtCore.Signal(float, float)
+    mode_changed = QtCore.Signal(str)
+    completed = QtCore.Signal(str, tuple)
 
-    def __init__(self, title="Adjust perspective"):
+    def __init__(self, title="Adjust Perspective / Scaling"):
         super().__init__()
 
         self.setWindowFlag(QtCore.Qt.WindowContextHelpButtonHint, False)
         self.x_distance = None
         self.y_distance = None
+        self.length = None
 
-        self.resize(60, 10)
+        self.resize(300, 10)
         self.setWindowTitle(title)
         self.main_layout = QtWidgets.QVBoxLayout(self)
 
-        self.form_layout = QtWidgets.QFormLayout()
-        self.main_layout.addLayout(self.form_layout)
+        self.mode_combobox = QtWidgets.QComboBox(self)
+        self.mode_combobox.addItems(["Perspective", "Scaling"])
+        self.mode_combobox.activated.connect(self.switch_page)
+        self.main_layout.addWidget(self.mode_combobox)
+
+        self.stacked_layout = QtWidgets.QStackedLayout()
+        self.main_layout.addLayout(self.stacked_layout)
+
+        self.perspective_page = QtWidgets.QWidget(self)
+        self.perspective_form_layout = QtWidgets.QFormLayout(self.perspective_page)
+        self.stacked_layout.addWidget(self.perspective_page)
 
         self.x_spinbox = QtWidgets.QDoubleSpinBox(self)
         self.x_spinbox.setRange(0, 10**5)
         self.x_spinbox.setDecimals(3)
         self.x_spinbox.setValue(0)
         self.x_spinbox.setSpecialValueText("Auto")
-        self.form_layout.addRow("X: ", self.x_spinbox)
+        self.perspective_form_layout.addRow("X: ", self.x_spinbox)
 
         self.y_spinbox = QtWidgets.QDoubleSpinBox(self)
         self.y_spinbox.setRange(0, 10**5)
         self.y_spinbox.setDecimals(3)
         self.y_spinbox.setValue(0)
         self.y_spinbox.setSpecialValueText("Auto")
-        self.form_layout.addRow("Y: ", self.y_spinbox)
+        self.perspective_form_layout.addRow("Y: ", self.y_spinbox)
+
+        self.scaling_page = QtWidgets.QWidget(self)
+        self.scaling_form_layout = QtWidgets.QFormLayout(self.scaling_page)
+        self.stacked_layout.addWidget(self.scaling_page)
+
+        self.length_spinbox = QtWidgets.QDoubleSpinBox(self)
+        self.length_spinbox.setRange(0, 10**5)
+        self.length_spinbox.setDecimals(3)
+        self.length_spinbox.setValue(1)
+        self.scaling_form_layout.addRow("Length: ", self.length_spinbox)
 
         self.main_layout.addStretch()
 
@@ -40,10 +61,22 @@ def __init__(self, title="Adjust perspective"):
 
         self.main_layout.addStretch()
 
+    def switch_page(self):
+        self.stacked_layout.setCurrentIndex(self.mode_combobox.currentIndex())
+        self.mode_changed.emit(self.mode())
+
+    def mode(self):
+        return self.mode_combobox.currentText()
+
     def ok_clicked(self):
         self.x_distance = self.x_spinbox.value()
         self.y_distance = self.y_spinbox.value()
-        self.completed.emit(self.x_distance, self.y_distance)
+        self.length = self.length_spinbox.value()
+        mode = self.mode_combobox.currentText()
+        if mode == "Perspective":
+            self.completed.emit(mode, (self.x_distance, self.y_distance))
+        elif mode == "Scaling":
+            self.completed.emit(mode, (self.length,))
 
         self.accept()
         self.close()