Samples: Fix resource mgtm and improve instructions

Hand-Eye GUI
- Update how the step-by-step instructions are displayed to better
  indicate the completion status of each step.
- Provide more feedback while connecting to a camera
- Fix resource management by explicitly releasing Zivid resources when
  the application is closed.

Author: csu-bot-zivid

modules/zividsamples/gui/camera_selection.py

@@ -5,24 +5,28 @@
 
 """
 
-from typing import List, Optional
+from typing import Optional
 
 import zivid
 from PyQt5.QtCore import QSize, QTimer
 from PyQt5.QtWidgets import QDialog, QListWidget, QListWidgetItem, QPushButton, QVBoxLayout
 from zividsamples.gui.qt_application import ZividQtApplication
 
+CAMERA_ROLE = 1
+
 
 class CameraSelectionDialog(QDialog):
 
-    def __init__(self, cameras):
+    def __init__(self, zivid_app: zivid.Application, connect: bool):
         super().__init__()
-        self.selected_camera = None
-        self.init_ui(cameras)
+        self.selected_camera: Optional[zivid.Camera] = None
+        self.zivid_app = zivid_app
+        self.connect = connect
+        self.init_ui()
 
-        QTimer.singleShot(0, self.adjust_dialog_size)
+        QTimer.singleShot(0, self.find_cameras)
 
-    def init_ui(self, cameras: List[zivid.Camera]):
+    def init_ui(self):
         self.setWindowTitle("Select a Camera")
         layout = QVBoxLayout(self)
 
@@ -31,20 +35,30 @@ def init_ui(self, cameras: List[zivid.Camera]):
 
         self.select_button = QPushButton("Select", self)
         self.select_button.clicked.connect(self.on_select)
+        self.select_button.setEnabled(False)
         layout.addWidget(self.select_button)
 
         self.setLayout(layout)
 
+    def find_cameras(self):
+        self.camera_list_widget.addItem("Finding cameras...")
+        QTimer.singleShot(0, self.update_camera_list)
+
+    def update_camera_list(self):
+        cameras = self.zivid_app.cameras()
+        self.camera_list_widget.clear()
         camera_selected = False
         for camera in cameras:
             camera_item = QListWidgetItem(
                 f"{camera.info.model_name} ({camera.info.serial_number} - {camera.state.status})",
                 self.camera_list_widget,
             )
-            camera_item.setData(1, camera)
+            camera_item.setData(CAMERA_ROLE, camera)
             if camera.state.status == zivid.CameraState.Status.available and not camera_selected:
                 camera_item.setSelected(True)
                 camera_selected = True
+        self.select_button.setEnabled(camera_selected)
+        QTimer.singleShot(0, self.adjust_dialog_size)
 
     def adjust_dialog_size(self):
         max_width = 0
@@ -58,22 +72,31 @@ def adjust_dialog_size(self):
         dialog_size = QSize(max_width, self.sizeHint().height())
         self.resize(dialog_size.expandedTo(QSize(300, 200)))
 
+    def connect_camera(self, camera: Optional[zivid.Camera]):
+        if camera is not None:
+            camera.connect()
+            self.accept()
+
     def on_select(self):
         selected_items = self.camera_list_widget.selectedItems()
         if selected_items:
-            self.selected_camera = selected_items[0].data(1)
-        self.accept()
+            self.selected_camera = selected_items[0].data(CAMERA_ROLE)
+        if self.connect and self.selected_camera:
+            self.camera_list_widget.clear()
+            self.camera_list_widget.addItem("Connecting...")
+            QTimer.singleShot(100, lambda: self.connect_camera(self.selected_camera))
+        else:
+            self.accept()
 
 
-def select_camera(cameras: List[zivid.Camera]) -> Optional[zivid.Camera]:
-    dialog = CameraSelectionDialog(cameras)
+def select_camera(zivid_app: zivid.Application, connect: bool) -> Optional[zivid.Camera]:
+    dialog = CameraSelectionDialog(zivid_app, connect)
     if dialog.exec_() == QDialog.Accepted:
         return dialog.selected_camera
     return None
 
 
 if __name__ == "__main__":  # NOLINT
-    qtApp = ZividQtApplication()
-    zividApp = zivid.Application()
-    select_camera(zividApp.cameras())
-    qtApp.exec_()
+    with ZividQtApplication() as qtApp:
+        selected_camera = select_camera(qtApp.zivid_app, connect=True)
+        print(f"Selected camera: {selected_camera}")

modules/zividsamples/gui/hand_eye_configuration.py

@@ -166,7 +166,6 @@ def select_hand_eye_configuration(
 
 
 if __name__ == "__main__":  # NOLINT
-
-    qtApp = ZividQtApplication()
-    hand_eye_configuration = select_hand_eye_configuration()
-    print(f"Selected settings: {hand_eye_configuration}")
+    with ZividQtApplication():
+        hand_eye_configuration = select_hand_eye_configuration()
+        print(f"Selected settings: {hand_eye_configuration}")

modules/zividsamples/gui/hand_eye_settings_tester.py

@@ -12,7 +12,7 @@
 import zivid
 from nptyping import NDArray, Shape, UInt8
 from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QColor, QImage, QPainter, QPixmap
+from PyQt5.QtGui import QCloseEvent, QColor, QImage, QPainter, QPixmap
 from PyQt5.QtWidgets import QAction, QCheckBox, QFileDialog, QGroupBox, QHBoxLayout, QMainWindow, QVBoxLayout, QWidget
 from zivid.calibration import DetectionResult, DetectionResultFiducialMarkers, MarkerShape
 from zivid.experimental import PixelMapping
@@ -109,13 +109,13 @@ class TestHandEyeCaptureSettings(QMainWindow):
     camera: Optional[zivid.Camera] = None
     last_frame: zivid.Frame
 
-    def __init__(self, parent=None):
+    def __init__(self, zivid_app: zivid.Application, parent=None):
         super().__init__(parent)
         self.setObjectName("HandEyeSettingsTester")
 
         self.cv2_handler = CV2Handler()
-
-        self.setup_camera()
+        self.zivid_app = zivid_app
+        self.camera = select_camera(self.zivid_app, connect=True)
         self.setup_settings()
         self.create_widgets()
         self.setup_layout()
@@ -129,14 +129,6 @@ def __init__(self, parent=None):
 
         self.live2d_widget.start_live_2d()
 
-    def setup_camera(self):
-        self.zividApp = zivid.Application()
-        cameras = self.zividApp.cameras()
-        if len(cameras) > 0:
-            self.camera = select_camera(cameras)
-        if self.camera is not None:
-            self.camera.connect()
-
     def setup_settings(self):
         if self.camera:
             self.settings = select_settings_for_hand_eye(self.camera)
@@ -226,7 +218,9 @@ def on_capture_button_clicked(self):
         self.live2d_widget.stop_live_2d()
         try:
             frame = self.camera.capture_2d_3d(
-                self.settings.hand_eye if self.capture_with_hand_eye_settings.isChecked() else self.settings.production
+                self.settings.hand_eye.settings_2d3d
+                if self.capture_with_hand_eye_settings.isChecked()
+                else self.settings.production.settings_2d3d
             )
             self.last_frame = frame
             self.visualize_frame_action.setEnabled(True)
@@ -278,11 +272,10 @@ def on_connect_button_clicked(self):
             self.camera_buttons.set_connection_status(False)
         else:
             assert self.settings is not None
-            self.camera = select_camera(self.zividApp.cameras())
+            self.camera = select_camera(self.zivid_app, connect=True)
             if self.camera is None:
                 self.camera_buttons.set_connection_status(False)
             else:
-                self.camera.connect()
                 self.camera_buttons.set_connection_status(self.camera.state.connected)
                 self.setup_settings()
                 if self.camera.state.connected:
@@ -361,7 +354,11 @@ def log_detection_result(
         log_message += f" (Engine: {self.settings.production.settings_2d3d.engine:>8}, Sampling: {self.settings.production.settings_2d3d.sampling.pixel:>20})"
         print(log_message)
 
+    def closeEvent(self, event: QCloseEvent) -> None:  # pylint: disable=C0103
+        self.live2d_widget.closeEvent(event)
+        super().closeEvent(event)
+
 
 if __name__ == "__main__":  # NOLINT
-    qtApp = ZividQtApplication()
-    qtApp.run(TestHandEyeCaptureSettings(), "Test Hand Eye Settings")
+    with ZividQtApplication() as qtApp:
+        qtApp.run(TestHandEyeCaptureSettings(qtApp.zivid_app), "Test Hand Eye Settings")

modules/zividsamples/gui/marker_widget.py

@@ -270,7 +270,7 @@ def select_marker_configuration(
 
 
 if __name__ == "__main__":  # NOLINT
-    qtApp = ZividQtApplication()
-    widget = MarkersWidget()
-    widget.show()
-    qtApp.exec_()
+    with ZividQtApplication(use_zivid_app=False) as qtApp:
+        widget = MarkersWidget()
+        widget.show()
+        qtApp.exec_()

modules/zividsamples/gui/qt_application.py

@@ -188,7 +188,7 @@ class ZividFonts:
 
 class ZividQtApplication(QApplication):
 
-    def __init__(self):
+    def __init__(self, use_zivid_app: bool = True):
         if "cv2" in sys.modules:
             raise RuntimeError(
                 "When using a ZividQtApplication you cannot directly load/import cv2. It has conflicting versions of Qt on some platforms. Instead, add functionality to zividsamples.cv2_handler"
@@ -207,6 +207,11 @@ def __init__(self):
         )
         self.setFont(ZividFonts.normal)
 
+        if use_zivid_app:
+            import zivid  # pylint: disable=import-outside-toplevel
+
+            self.zivid_app = zivid.Application()
+
     def run(self, win, title: str = "Zivid Qt Application"):
         icon_path = get_file_path("LogoZBlue.ico")
         self.setWindowIcon(QIcon(icon_path.absolute().as_posix()))
@@ -224,3 +229,10 @@ def run(self, win, title: str = "Zivid Qt Application"):
             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("zivid.app.qt_application")
 
         return self.exec_()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        if hasattr(self, "zivid_app"):
+            self.zivid_app.release()

modules/zividsamples/gui/rotation_format_configuration.py

@@ -267,7 +267,8 @@ def select_rotation_format(
 
 
 if __name__ == "__main__":  # NOLINT
-    qtApp = ZividQtApplication()
-    print(
-        f"Selected format: {select_rotation_format(current_rotation_format=ListOfRobotFormats[0].rotation_information)}"
-    )
+    with ZividQtApplication(use_zivid_app=False):
+        selected_rotation_format = select_rotation_format(
+            current_rotation_format=ListOfRobotFormats[0].rotation_information
+        )
+        print(f"Selected format: {selected_rotation_format}")

modules/zividsamples/gui/set_fixed_objects.py

@@ -365,36 +365,37 @@ def set_fixed_objects(
 
 
 if __name__ == "__main__":
-    qt_app = ZividQtApplication()
-
-    # Example usage
-    result = set_fixed_objects(
-        FixedCalibrationObjectsData(
-            hand_eye_configuration=HandEyeConfiguration(eye_in_hand=True, calibration_object=CalibrationObject.Markers),
-            marker_configuration=MarkerConfiguration(),
-            marker_positions_eye_in_hand={
-                0: [100.0, 1000.0, 0.0],
-                1: [150.0, 1050.0, 0.0],
-                2: [150.0, 1000.0, 0.0],
-                3: [100.0, 1050.0, 0.0],
-            },
-            marker_positions_eye_to_hand={
-                0: [100.0, 0.0, 0.0],
-                1: [150.0, 50.0, 0.0],
-                2: [150.0, 0.0, 0.0],
-                3: [100.0, 50.0, 0.0],
-            },
-            calibration_board_pose_eye_in_hand=TransformationMatrix(
-                translation=[-90.0, 1220.0, 0.0],
-            ),
-            calibration_board_pose_eye_to_hand=TransformationMatrix(
-                translation=[-90.0, 220.0, 0.0],
-            ),
-            use_rotation=True,
+    with ZividQtApplication():
+        # Example usage
+        result = set_fixed_objects(
+            FixedCalibrationObjectsData(
+                hand_eye_configuration=HandEyeConfiguration(
+                    eye_in_hand=True, calibration_object=CalibrationObject.Markers
+                ),
+                marker_configuration=MarkerConfiguration(),
+                marker_positions_eye_in_hand={
+                    0: [100.0, 1000.0, 0.0],
+                    1: [150.0, 1050.0, 0.0],
+                    2: [150.0, 1000.0, 0.0],
+                    3: [100.0, 1050.0, 0.0],
+                },
+                marker_positions_eye_to_hand={
+                    0: [100.0, 0.0, 0.0],
+                    1: [150.0, 50.0, 0.0],
+                    2: [150.0, 0.0, 0.0],
+                    3: [100.0, 50.0, 0.0],
+                },
+                calibration_board_pose_eye_in_hand=TransformationMatrix(
+                    translation=[-90.0, 1220.0, 0.0],
+                ),
+                calibration_board_pose_eye_to_hand=TransformationMatrix(
+                    translation=[-90.0, 220.0, 0.0],
+                ),
+                use_rotation=True,
+            )
         )
-    )
-    if result:
-        print("Fixed objects set successfully:")
-        print(result.to_fixed_calibration_objects())
-    else:
-        print("Fixed objects not set.")
+        if result:
+            print("Fixed objects set successfully:")
+            print(result.to_fixed_calibration_objects())
+        else:
+            print("Fixed objects not set.")

modules/zividsamples/gui/tutorial_widget.py

@@ -49,13 +49,11 @@ def add_steps(self, steps: Dict[str, bool]):
     def update_text(self):
         self.text_area.clear()
         text = f"<h2>{self.title}</h2>"
-        text += "<p><ol>"
+        text += "<table cellpadding='5' style='border-collapse: collapse; width: 100%;; margin-top: 10px;'>"
         for step, completed in self.steps.items():
-            if completed:
-                text += f"<li>&#10003; {step}</li>"  # HTML entity for checkmark (✓)
-            else:
-                text += f"<li>{step}</li>"
-        text += "</ol></p>"
+            checkmark = "&#x2705;" if completed else "&#x2610;"  # ✓ for checked, ☐ for unchecked
+            text += f"<tr><td>{checkmark}</td><td>{step}</td></tr>"
+        text += "</table>"
         text += "<p>" + "</p><p>".join(paragraph for paragraph in self.description) + "</p>"
         self.text_area.setText(text)
 

source/applications/advanced/hand_eye_calibration/hand_eye_gui.py

@@ -70,10 +70,11 @@ class HandEyeGUI(QMainWindow):  # pylint: disable=R0902, R0904
     rotation_information: RotationInformation = RotationInformation()
     common_instructions: Dict[str, bool] = {}
 
-    def __init__(self, parent=None):  # noqa: ANN001
+    def __init__(self, zivid_app: zivid.Application, parent=None):  # noqa: ANN001
         super().__init__(parent)
 
-        self.setup_camera()
+        self.zivid_app = zivid_app
+        self.camera = select_camera(self.zivid_app, connect=True)
         self.setup_settings()
         self.create_widgets()
         self.setup_layout()
@@ -86,14 +87,6 @@ def __init__(self, parent=None):  # noqa: ANN001
 
         QTimer.singleShot(0, self.update_tab_order)
 
-    def setup_camera(self) -> None:
-        self.zivid_app = zivid.Application()
-        cameras = self.zivid_app.cameras()
-        if len(cameras) > 0:
-            self.camera = select_camera(cameras)
-        if self.camera is not None:
-            self.camera.connect()
-
     def setup_settings(self) -> None:
         if self.camera:
             self.settings = select_settings_for_hand_eye(self.camera)
@@ -606,9 +599,11 @@ def on_connect_button_clicked(self) -> None:
             self.live2d_widget.stop_live_2d()
             self.live2d_widget.hide()
             self.camera.disconnect()
+            self.setup_instructions()
+            self.on_instructions_updated()
             self.camera_buttons.set_connection_status(False)
         else:
-            self.camera = select_camera(self.zivid_app.cameras())
+            self.camera = select_camera(self.zivid_app, connect=True)
             if self.camera is None:
                 self.camera_buttons.set_connection_status(False)
             else:
@@ -635,9 +630,8 @@ def closeEvent(self, event: QCloseEvent) -> None:  # pylint: disable=C0103
 
 
 def _main() -> None:
-    qt_app = ZividQtApplication()
-
-    sys.exit(qt_app.run(HandEyeGUI(), "Hand-Eye GUI"))
+    with ZividQtApplication() as qt_app:
+        sys.exit(qt_app.run(HandEyeGUI(qt_app.zivid_app), "Hand-Eye GUI"))
 
 
 if __name__ == "__main__":  # NOLINT