Implemented Aspect of takam's suggestions

- Black Formatting with line length = 120
- Added FPS indicator color for preview tab
- Added updates to valid exposure times when fps is modified
- Implemented proper deinitialisation of the camera api from the preview window. This was causing conflicts of which camera pointer was getting the frames i wanted.
 - Removed unused libraries from requirements.txt
- Added default config values for missing values in the .json camera settings

Author: alifuaziz

.gitignore

@@ -2,10 +2,12 @@
 *.pyc
 vscode/
 .vscode/*
+pyproject.toml
+
 ErrorLog.txt
 todo.md
 test_notebook.ipynb
 _installation/SDK/*
 _installation/miniconda.exe
 _installation/spinview/spinnakerSDK.exe
-config/camera_configs.json
+config/camera_configs.json

GUI/GUI_main.py

@@ -49,10 +49,10 @@ def __init__(self, parsed_args):
         self.show()
 
     def on_tab_change(self):
-        """Function that is run on tab change"""
+        """Function that is run on tab change: Deselect the tab you are in before selecting a new tab"""
         if self.tab_widget.currentIndex() == 0:
-            self.video_capture_tab.tab_selected()
             self.camera_setup_tab.tab_deselected()
+            self.video_capture_tab.tab_selected()
         else:
             self.video_capture_tab.tab_deselected()
             self.camera_setup_tab.tab_selected()

GUI/camera_setup_tab.py

@@ -15,9 +15,16 @@
 from PyQt6.QtCore import QTimer
 from dataclasses import asdict
 
-from config.config import ffmpeg_config, paths_config
-from .utility import CameraSettingsConfig, find_all_cameras, load_saved_setups, load_camera_dict, init_camera_api,  get_valid_supported_encoder_formats
-from .preview_dialog import CameraPreviewDialog
+from config.config import ffmpeg_config, paths_config, default_camera_config
+from .utility import (
+    CameraSettingsConfig,
+    find_all_cameras,
+    load_saved_setups,
+    load_camera_dict,
+    init_camera_api,
+    get_valid_supported_encoder_formats,
+)
+from .preview_dialog import CameraPreviewWidget
 
 
 class CamerasTab(QWidget):
@@ -61,6 +68,11 @@ def tab_selected(self):
     def tab_deselected(self):
         """Called when tab deselected."""
         self.refresh_timer.stop()
+        # Deinitialise all camera apis on tab being deselected
+        for unique_id in self.setups:
+            if self.GUI.preview_showing:
+                self.setups[unique_id].close_preview_camera()
+            self.setups[unique_id].camera_api.stop_capturing()
 
     def get_saved_setups(self, unique_id: str = None, name: str = None) -> CameraSettingsConfig:
         """Get a saved Setup_info object from a name or unique_id from self.saved_setups."""
@@ -117,11 +129,11 @@ def refresh(self):
                         setups_table=self.camera_table,
                         name=None,
                         unique_id=unique_id,
-                        fps="30",
-                        pxl_fmt="Mono8",
-                        downsampling_factor=1,
-                        exposure_time=15000,
-                        gain=0,
+                        fps=default_camera_config["fps"],
+                        pxl_fmt=default_camera_config["pxl_fmt"],
+                        downsampling_factor=default_camera_config["downsampling_factor"],
+                        exposure_time=default_camera_config["exposure_time"],
+                        gain=default_camera_config["gain"],
                     )
 
                 self.update_saved_setups(self.setups[unique_id])
@@ -196,7 +208,17 @@ def remove(self, unique_id):
 class Camera_table_item:
     """Class representing single camera in the Camera Tab table."""
 
-    def __init__(self, setups_table, name, unique_id, fps, exposure_time, gain, pxl_fmt, downsampling_factor):
+    def __init__(
+        self,
+        setups_table,
+        name,
+        unique_id,
+        fps,
+        exposure_time,
+        gain,
+        pxl_fmt,
+        downsampling_factor,
+    ):
         self.setups_table = setups_table
         self.setups_tab = setups_table.setups_tab
         self.GUI = self.setups_tab.GUI
@@ -211,6 +233,7 @@ def __init__(self, setups_table, name, unique_id, fps, exposure_time, gain, pxl_
         self.label = self.label if self.label is not None else self.unique_id
         self.GUI.preview_showing = False
         self.camera_api = init_camera_api(_id=self.unique_id)
+
         # Name edit
         self.name_edit = QLineEdit()
         if self.label:
@@ -232,6 +255,7 @@ def __init__(self, setups_table, name, unique_id, fps, exposure_time, gain, pxl_
             self.fps = str(self.fps[0])
             self.fps_edit.setValue(int(self.fps))
         self.fps_edit.valueChanged.connect(self.camera_fps_changed)
+        self.fps_edit.setEnabled(False)
 
         # Exposure time edit
         self.exposure_time_edit = QSpinBox()
@@ -241,6 +265,8 @@ def __init__(self, setups_table, name, unique_id, fps, exposure_time, gain, pxl_
         if self.exposure_time:
             self.exposure_time_edit.setValue(int(self.exposure_time))
         self.exposure_time_edit.valueChanged.connect(self.camera_exposure_time_changed)
+        self.exposure_time_edit.setEnabled(False)
+
         # Gain edit
         self.gain_edit = QSpinBox()
         self.gain_edit.setRange(*self.camera_api.get_gain_range())
@@ -290,7 +316,7 @@ def camera_fps_changed(self):
         self.setups_tab.update_saved_setups(setup=self)
         if self.GUI.preview_showing is True:
             self.setups_tab.camera_preview.camera_api.set_frame_rate(self.fps)
-        # reset the range of the exposure time
+
         self.exposure_time_edit.setRange(*self.camera_api.get_exposure_time_range())
 
     def camera_pxl_fmt_changed(self):
@@ -325,13 +351,23 @@ def camera_downsampling_factor(self):
     def open_preview_camera(self):
         """Button to preview the camera in the row"""
         if self.GUI.preview_showing:
-            self.setups_tab.camera_preview.close()
-            self.GUI.preview_showing = False
-        self.setups_tab.camera_preview = CameraPreviewDialog(gui=self.GUI, unique_id=self.unique_id)
+            self.close_preview_camera()
+        self.setups_tab.camera_preview = CameraPreviewWidget(
+            gui=self.GUI, camera_table_item=self, unique_id=self.unique_id
+        )  # camera_api=self.camera_api)
         self.setups_tab.page_layout.addWidget(self.setups_tab.camera_preview)
         self.GUI.preview_showing = True
-        # refresh timer off
-        
+
+        self.fps_edit.setEnabled(self.GUI.preview_showing)
+        self.exposure_time_edit.setEnabled(self.GUI.preview_showing)
+
+    def close_preview_camera(self):
+        self.setups_tab.camera_preview.close()
+        self.GUI.preview_showing = False
+
+        self.fps_edit.setEnabled(self.GUI.preview_showing)
+        self.exposure_time_edit.setEnabled(self.GUI.preview_showing)
+
     def getCameraSettingsConfig(self):
         """Get the camera settings config datastruct from the setups table."""
         return CameraSettingsConfig(

GUI/camera_widget.py

@@ -20,7 +20,12 @@
     QWidget,
 )
 
-from .utility import cbox_update_options, CameraSetupConfig, init_camera_api, validate_ffmpeg_path
+from .utility import (
+    cbox_update_options,
+    CameraSetupConfig,
+    init_camera_api,
+    validate_ffmpeg_path,
+)
 from .message_dialogs import show_warning_message
 from config.config import ffmpeg_config, paths_config
 
@@ -39,7 +44,9 @@ def __init__(self, parent, label, subject_id):
             self.paths["FFMPEG"]
             if validate_ffmpeg_path(self.paths["FFMPEG"])
             else show_warning_message(
-                f"FFMPEG path {self.paths['FFMPEG']} not valid", okayButtonPresent=False, ignoreButtonPresent=True
+                f"FFMPEG path {self.paths['FFMPEG']} not valid",
+                okayButtonPresent=False,
+                ignoreButtonPresent=True,
             )
         )
 

GUI/message_dialogs.py

@@ -1,5 +1,6 @@
 from PyQt6.QtWidgets import QMessageBox
 
+
 def show_info_message(input_text: str):
     """
     Display an information message dialog box.
@@ -13,9 +14,7 @@ def show_info_message(input_text: str):
     info_dialog.exec()
 
 
-def show_warning_message(
-    input_text: str, okayButtonPresent: bool, ignoreButtonPresent: bool
-    ) -> bool:
+def show_warning_message(input_text: str, okayButtonPresent: bool, ignoreButtonPresent: bool) -> bool:
     """
     Displays a warning message with Ignore button.
     Returns True if ignore button clicked else False.

GUI/preview_dialog.py

@@ -1,6 +1,6 @@
 import os
 from collections import deque
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QPushButton
+from PyQt6.QtWidgets import QVBoxLayout, QPushButton, QWidget
 from PyQt6.QtCore import QTimer
 from PyQt6.QtGui import QIcon, QFont
 import pyqtgraph as pg
@@ -10,21 +10,23 @@
 from config.config import paths_config, gui_config
 
 
-class CameraPreviewDialog(QDialog):
+class CameraPreviewWidget(QWidget):
     """Dialog for previewing the video feed from the setups tab"""
 
-    def __init__(self, gui, unique_id: str):
+    def __init__(self, gui, camera_table_item, unique_id):  # camera_api):
         super().__init__()
         # self.setups_tab = parent
-        self.main_gui = gui
-        self.window_title = f"Camera {unique_id}"
+        self.GUI = gui
+        self.camera_table_item = camera_table_item
         self.unique_id = unique_id
+        # self.unique_id = self.camera_api.unique_id
+        self.window_title = f"Camera {self.unique_id}"
         self.paths = paths_config
 
         self.setWindowTitle(self.window_title)
         icon = QIcon(os.path.join(self.paths["assets_dir"], "logo.svg"))
         self.setWindowIcon(icon)
-        main_gui_geometry = self.main_gui.geometry()
+        main_gui_geometry = self.GUI.geometry()
         self.setGeometry(
             main_gui_geometry.x() + main_gui_geometry.width() + 10,
             main_gui_geometry.y(),
@@ -84,8 +86,8 @@ def display_data(self):
         self.frame_timestamps.extend(self.buffered_data["timestamps"])
         avg_time_diff = (self.frame_timestamps[-1] - self.frame_timestamps[0]) / (self.frame_timestamps.maxlen - 1)
         calculated_framerate = 1e9 / avg_time_diff
-        # Display timestamps data
-        self.frame_rate_text.setText(f"FPS: {calculated_framerate:.2f}", color="r")
+        color = "r" if (abs(calculated_framerate - int(self.camera_table_item.fps)) > 1) else "g"
+        self.frame_rate_text.setText(f"FPS: {calculated_framerate:.2f}", color=color)
         self.exposure_time_text.setText(
             f"Exposure Time (us) : {self.camera_api.get_exposure_time():.2f}",
             color="magenta",
@@ -102,14 +104,18 @@ def start_timer(self):
 
     def closeEvent(self, event):
         """Handle the close event to stop the timer and release resources"""
-        if hasattr(self, "timer"):
-            self.display_update_timer.stop()
         self.camera_api.stop_capturing()
-        self.main_gui.preview_showing = False
+        self.display_update_timer.stop()
+        self.GUI.preview_showing = False
+        self.camera_table_item.exposure_time_edit.setEnabled(False)
+        self.camera_table_item.fps_edit.setEnabled(False)
+        self.close()
+        super().closeEvent(event)
         event.accept()
 
     def resizeEvent(self, event, scale_factor=0.02):
         """Scale the font size to the window"""
+        super().resizeEvent(event)
         font_size = int(min(self.width(), self.height()) * scale_factor)
         self.frame_rate_text.setFont(QFont("Arial", font_size))
         self.exposure_time_text.setFont(QFont("Arial", font_size))

GUI/utility.py

@@ -7,7 +7,7 @@
 from typing import Dict, Any
 from dataclasses import dataclass
 
-from config.config import ffmpeg_config
+from config.config import ffmpeg_config, default_camera_config
 
 # Custom data classes -----------------------------------------------------------------
 
@@ -84,6 +84,7 @@ def get_valid_ffmpeg_encoders() -> list:
             valid_encoders_keys.append(key)
     return valid_encoders_keys
 
+
 def get_valid_supported_encoder_formats(camera_formats: list[str]) -> list[str]:
     """Get the list of supported encoder formats by comparing the camera formats to the config pxl_fmt keys"""
     supported_formats = []
@@ -92,6 +93,7 @@ def get_valid_supported_encoder_formats(camera_formats: list[str]) -> list[str]:
             supported_formats.append(fmt)
     return supported_formats
 
+
 def validate_ffmpeg_path(ffmpeg_path):
     """Validate the provided ffmpeg path."""
     if type(ffmpeg_path) is type(None):
@@ -194,13 +196,13 @@ def load_saved_setups(camera_data) -> list[CameraSettingsConfig]:
     for cam in camera_data:
         setups_from_database.append(
             CameraSettingsConfig(
-                name=cam["name"],
-                unique_id=cam["unique_id"],
-                fps=cam["fps"],
-                pxl_fmt=cam["pxl_fmt"],
-                downsample_factor=cam["downsample_factor"],
-                exposure_time=cam["exposure_time"],
-                gain=cam["gain"],
+                name=cam.get("name", None),
+                unique_id=cam.get("unique_id"),
+                fps=cam.get("fps", default_camera_config["fps"]),
+                pxl_fmt=cam.get("pxl_fmt", default_camera_config["pxl_fmt"]),
+                downsample_factor=cam.get("downsample_factor", default_camera_config["downsample_factor"]),
+                exposure_time=cam.get("exposure_time", default_camera_config["exposure_time"]),
+                gain=cam.get("gain", default_camera_config["gain"]),
             )
         )
     return setups_from_database

camera_api/spinnaker.py

@@ -16,8 +16,6 @@ def __init__(self, unique_id: str, CameraConfig=None):
         self.serial_number, self.api = unique_id.split("-")
         self.cam = self.system.GetCameras().GetBySerial(self.serial_number)
         self.camera_model = self.cam.TLDevice.DeviceModelName.GetValue()[:10]
-        if self.cam.IsInitialized():
-            self.cam.DeInit()
         self.cam.Init()
         self.nodemap = self.cam.GetNodeMap()
         self.stream_nodemap = self.cam.GetTLStreamNodeMap()
@@ -131,7 +129,7 @@ def get_available_pixel_fmt(self) -> list[str]:
 
     # Functions to set camera paramteters.
 
-    def set_frame_rate(self, frame_rate: isinstance) -> None:
+    def set_frame_rate(self, frame_rate: float) -> None:
         """Set the frame rate of the camera in Hz."""
         PySpin.CFloatPtr(self.nodemap.GetNode("AcquisitionFrameRate")).SetValue(int(frame_rate))
 

config/config.py

@@ -22,10 +22,7 @@
             "CPU (H264)": "libx264",
             "CPU (H265)": "libx265",
         },
-        "pxl_fmt": {
-            "Mono8": "yuv420p",
-            "Mono16": "yuv420p"
-            }
+        "pxl_fmt": {"Mono8": "yuv420p", "Mono16": "yuv420p"},
     },
 }
 
@@ -42,3 +39,13 @@
     "config_dir": os.path.join(ROOT, "config"),
     "assets_dir": os.path.join(ROOT, "assets", "icons"),
 }
+
+# Default Camera Settings -------------------------------------------------------------
+
+default_camera_config = {
+    "fps": "60",
+    "pxl_fmt": "Mono8",
+    "downsample_factor": 1,
+    "exposure_time": 15000,
+    "gain": 0,
+}

pyMultiVideo_GUI.pyw

@@ -24,10 +24,7 @@ def check_module(module_name):
 
 check_module("PyQt6")
 check_module("pyqtgraph")
-# check_module("ffmpeg")
 check_module("PySpin")
-check_module("cv2_enumerate_cameras")
-check_module("cv2")
 
 # Import GUI now that dependancies are verified.
 import PyQt6.QtWidgets as QtWidgets

readme.md

@@ -1,5 +1,3 @@
 # pyMultiVideo
 
-See description in docs
-
- I have added a change
+See description in docs

requirements.txt

@@ -1,7 +1,5 @@
-cv2_enumerate_cameras==1.1.17
 ffmpeg_python==0.2.0
 numpy==1.26.4
-opencv_python==4.10.0.84
 PyQt6==6.7.1
 PyQt6_sip==13.8.0
 pyqtgraph==0.13.7

test/.gitignore

@@ -0,0 +1,3 @@
+# Ignore all contents of folder except .gitignore needed to ensure folder is version controlled.
+*
+!.gitignore