refactor: implement set_dark_theme function for application theming

feat: implement CvCamera class for OpenCV camera handling

controllers/main_controller.py

@@ -7,6 +7,8 @@ from ui.widgets.thumbnail_list_widget import ThumbnailListWidget
 from ui.widgets.split_view_widget import SplitView
 from .camera_controller import CameraController
 
+from core.camera.gphoto_camera import GPhotoCamera
+from core.camera.camera_manager import CameraManager
 
 class MainController:
     def __init__(self, view):
@@ -15,7 +17,11 @@ class MainController:
         self.media_repo = MediaRepository(self.db)
         self.media_repo.sync_media()
 
-        self.camera_controller = CameraController()
+        camera = GPhotoCamera()
+        self.manager = CameraManager(camera)
+
+
+        # self.camera_controller = CameraController()
 
         self.view = view
         self.color_list: ColorListWidget = view.color_list_widget
@@ -25,13 +31,20 @@ class MainController:
         self.photo_button: QPushButton = view.photo_button
         self.photo_button.clicked.connect(self.take_photo)
 
+        self.record_button: QPushButton = view.record_button
+        # self.record_button.clicked.connect(self.fun_test)
+
         self.color_list.colorSelected.connect(self.on_color_selected)
         self.color_list.editColor.connect(self.on_edit_color)
         self.thumbnail_list.selectedThumbnail.connect(self.on_thumbnail_selected)
 
-        self.camera_controller.errorOccurred.connect(self.split_view.widget_start.set_info_text)
-        self.camera_controller.frameReady.connect(self.split_view.set_live_image)
-        self.split_view.widget_start.camera_start_btn.clicked.connect(self.camera_controller.start)
+        # self.camera_controller.errorOccurred.connect(self.split_view.widget_start.set_info_text)
+        self.manager.error_occurred.connect(self.split_view.widget_start.set_info_text)
+        # self.camera_controller.frameReady.connect(self.split_view.set_live_image)
+        self.manager.frame_ready.connect(self.split_view.set_live_image)
+        # self.split_view.widget_start.camera_start_btn.clicked.connect(self.camera_controller.start)
+        self.split_view.widget_start.camera_start_btn.clicked.connect(self.start_liveview)
+
 
     def start_camera(self):
         pass
@@ -71,3 +84,10 @@ class MainController:
     def take_photo(self):
         print("Robienie zdjęcia...")
         self.split_view.toglle_live_view()
+
+    def start_liveview(self):
+        self.manager.start_camera()
+        # self.manager.start_stream()
+
+    def shutdown(self):
+        self.manager.stop()

core/camera/base_camera.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+
+
+class BaseCamera(ABC):
+    def __init__(self) -> None:
+        self.error_msg = None
+
+    @abstractmethod
+    def connect(self) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_frame(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_config_by_id(self, id: int) -> dict:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_config_by_name(self, name: str) -> dict:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_config_by_id(self, id: int, value) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_config_by_name(self, name: str, value) -> None:
+        raise NotImplementedError
+
+    def get_error_msg(self):
+        return str(self.error_msg)

core/camera/camera_manager.py

@@ -0,0 +1,88 @@
+from PySide6.QtCore import QObject, QThread, QTimer, Signal, Slot
+from PySide6.QtGui import QImage, QPixmap
+import cv2
+
+from .base_camera import BaseCamera
+
+
+class CameraManager(QThread):
+    frame_ready = Signal(QPixmap)
+    photo_ready = Signal(QPixmap)
+    error_occurred = Signal(str)
+
+    def __init__(self, camera: BaseCamera, fps: int = 15, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.camera = camera
+        self.fps = fps
+        self.timer = None
+        self.is_streaming = False
+
+        self.is_connected = False
+
+        self.timer = QTimer()
+        self.timer.setInterval(int(1000 / self.fps))
+        self.timer.timeout.connect(self._update_frame)
+        self.start()
+
+    def run(self) -> None:
+        # self.timer = QTimer()
+        # self.timer.setInterval(int(1000 / self.fps))
+        # self.timer.timeout.connect(self._update_frame)
+        self.exec()
+
+    def start_camera(self) -> None:
+        if self.is_connected:
+            return
+        
+        if self.camera.connect():
+            self.is_connected = True
+        else:
+            self.is_connected = False
+            self.error_occurred.emit(self.camera.get_error_msg())
+
+    def stop_camera(self) -> None:
+        self.is_streaming = False
+        self.is_connected = False
+        if self.timer:
+            self.timer.stop()
+        self.camera.disconnect()
+
+    def start_stream(self):
+        if not self.is_connected:
+            return
+        
+        if self.is_streaming:
+            return
+        
+        if self.timer:
+            self.is_streaming = True
+            self.timer.start()
+
+    def stop_stream(self) -> None:
+        if self.is_streaming:
+            self.is_streaming = False
+            if self.timer:
+                self.timer.stop()
+
+    def _update_frame(self) -> None:
+        if not self.is_streaming or not self.is_connected:
+            return
+
+        ret, frame = self.camera.get_frame()
+
+        if not ret:
+            self.error_occurred.emit(self.camera.get_error_msg())
+            return
+
+        if frame is not None:
+            rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            h, w, ch = rgb_image.shape
+            qimg = QImage(rgb_image.data, w, h, ch * w, QImage.Format.Format_RGB888)
+            pixmap = QPixmap.fromImage(qimg)
+
+            self.frame_ready.emit(pixmap)
+
+    def stop(self):
+        self.stop_camera()
+        self.quit()
+        self.wait()

core/camera/gphoto_camera.py

@@ -0,0 +1,122 @@
+from typing import Optional, List
+from dataclasses import dataclass, field
+import gphoto2 as gp
+import cv2
+import numpy as np
+
+from .base_camera import BaseCamera
+
+camera_widget_types = {
+    gp.GP_WIDGET_WINDOW: "GP_WIDGET_WINDOW",    # type: ignore
+    gp.GP_WIDGET_SECTION: "GP_WIDGET_SECTION",  # type: ignore
+    gp.GP_WIDGET_TEXT: "GP_WIDGET_TEXT",        # type: ignore
+    gp.GP_WIDGET_RANGE: "GP_WIDGET_RANGE",      # type: ignore
+    gp.GP_WIDGET_TOGGLE: "GP_WIDGET_TOGGLE",    # type: ignore
+    gp.GP_WIDGET_RADIO: "GP_WIDGET_RADIO",      # type: ignore
+    gp.GP_WIDGET_MENU: "GP_WIDGET_MENU",        # type: ignore
+    gp.GP_WIDGET_BUTTON: "GP_WIDGET_BUTTON",    # type: ignore
+    gp.GP_WIDGET_DATE: "GP_WIDGET_DATE",        # type: ignore
+}
+
+
+class GPhotoCamera(BaseCamera):
+    def __init__(self) -> None:
+        super().__init__()
+        self.camera = None
+        self.configs: List[dict] = []
+
+    def connect(self) -> bool:
+        self.error_msg = None
+        try:
+            self.camera = gp.Camera()   # type: ignore
+            self.camera.init()
+            config = self.camera.get_config()
+            self.read_config(config)
+            return True
+        except Exception as e:
+            self.error_msg = f"[GPHOTO2] {e}"
+            self.camera = None
+            return False
+
+    def disconnect(self) -> None:
+        if self.camera:
+            self.camera.exit()
+            self.camera = None
+            self.configs.clear()
+
+    def get_frame(self):
+        self.error_msg = None
+
+        if self.camera is None:
+            self.error_msg = "[GPHOTO2] Camera is not initialized."
+            return (False, None)
+
+        try:
+            file = self.camera.capture_preview()    # type: ignore
+            data = file.get_data_and_size()
+            frame = np.frombuffer(data, dtype=np.uint8)
+            frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+
+            return (True, frame)
+        except Exception as e:
+            self.error_msg = f"[GPHOTO2] {e}"
+            return (False, None)
+
+    def get_config_by_id(self, id: int):
+        return next(w for w in self.configs if w['id'] == id)
+
+    def get_config_by_name(self, name: str):
+        return next(w for w in self.configs if w['name'] == name)
+
+    def set_config(self, config, value):
+        if value not in config['choices']:
+            return
+
+        config['config'].set_value(value)  # type: ignore
+        if self._save_config(config):
+            config['value'] = value
+
+    def set_config_by_id(self, id: int, value: str):
+        config = self.get_config_by_id(id)
+
+        self.set_config(config, value)
+
+    def set_config_by_name(self, name: str, value: str):
+        config = self.get_config_by_name(name)
+
+        self.set_config(config, value)
+
+    def _save_config(self, config):
+        if not self.camera:
+            return False
+
+        self.camera.set_single.config(config['name'], config['widget'])
+        return True
+
+    def parse_config(self, config):
+        new_config = {
+            "id": config.get_id(),
+            "name": config.get_name(),
+            "label": config.get_label(),
+            "type": camera_widget_types[config.get_type()],
+            "widget": config
+        }
+
+        try:
+            new_config["value"] = config.get_value()
+        except gp.GPhoto2Error:
+            pass
+
+        try:
+            new_config["choices"] = list(config.get_choices())
+        except gp.GPhoto2Error:
+            pass
+
+        return new_config
+
+    def read_config(self, config):
+        self.configs.append(self.parse_config(config))
+
+        for i in range(config.count_children()):
+            child = config.get_child(i)
+            self.read_config(child)

core/camera/opencv_camera.py

@@ -0,0 +1,98 @@
+import cv2
+from typing import List
+
+from .base_camera import BaseCamera
+
+
+
+
+class CvCamera(BaseCamera):
+    """Kamera oparta na cv2.VideoCapture"""
+
+    config_map = {
+        0: {"name": "frame_width", "cv_prop": cv2.CAP_PROP_FRAME_WIDTH, "default": 640},
+        1: {"name": "frame_height", "cv_prop": cv2.CAP_PROP_FRAME_HEIGHT, "default": 480},
+        2: {"name": "fps", "cv_prop": cv2.CAP_PROP_FPS, "default": 30},
+        3: {"name": "brightness", "cv_prop": cv2.CAP_PROP_BRIGHTNESS, "default": 0.5},
+        4: {"name": "contrast", "cv_prop": cv2.CAP_PROP_CONTRAST, "default": 0.5},
+        5: {"name": "saturation", "cv_prop": cv2.CAP_PROP_SATURATION, "default": 0.5},
+    }
+
+    def __init__(self, device_index: int = 0) -> None:
+        super().__init__()
+        self.device_index = device_index
+        self.cap = None
+        self.configs: List[dict] = []
+
+    def connect(self) -> bool:
+        self.error_msg = None
+        try:
+            self.cap = cv2.VideoCapture(self.device_index)
+            if not self.cap.isOpened():
+                self.error_msg = f"[CV2] Could not open camera {self.device_index}"
+                return False
+
+            self.configs.clear()
+            for id, conf in self.config_map.items():
+                value = self.cap.get(conf["cv_prop"])
+                self.configs.append(
+                    {
+                        "id": id,
+                        "name": conf["name"],
+                        "label": conf["name"].capitalize(),
+                        "value": value,
+                        "choices": None,  # brak predefiniowanych wyborów
+                        "cv_prop": conf["cv_prop"],
+                    }
+                )
+            return True
+
+        except Exception as e:
+            self.error_msg = f"[CV2] {e}"
+            self.cap = None
+            return False
+
+    def disconnect(self) -> None:
+        if self.cap:
+            self.cap.release()
+            self.cap = None
+            self.configs.clear()
+
+    def get_frame(self):
+        self.error_msg = None
+        if self.cap is None or not self.cap.isOpened():
+            self.error_msg = "[CV2] Camera is not initialized."
+            return (False, None)
+
+        try:
+            ret, frame = self.cap.read()
+            if not ret:
+                self.error_msg = "[CV2] Failed to read frame."
+                return (False, None)
+            return (True, frame)
+        except Exception as e:
+            self.error_msg = f"[CV2] {e}"
+            return (False, None)
+
+    def get_config_by_id(self, id: int):
+        return next(w for w in self.configs if w["id"] == id)
+
+    def get_config_by_name(self, name: str):
+        return next(w for w in self.configs if w["name"] == name)
+
+    def set_config(self, config, value: float):
+        if not self.cap:
+            return
+        try:
+            self.cap.set(config["cv_prop"], value)
+            config["value"] = self.cap.get(config["cv_prop"])  # sprawdz co ustawiło
+        except Exception as e:
+            self.error_msg = f"[CV2] {e}"
+
+    def set_config_by_id(self, id: int, value: float):
+        config = self.get_config_by_id(id)
+        self.set_config(config, value)
+
+    def set_config_by_name(self, name: str, value: float):
+        config = self.get_config_by_name(name)
+        self.set_config(config, value)

main.py

@@ -1,6 +1,7 @@
 import sys
 from PySide6.QtWidgets import QApplication
 
+from ui.main_palette import set_dark_theme
 from ui.main_window import MainWindow
 from controllers.main_controller import MainController
 
@@ -8,10 +9,13 @@ from controllers.main_controller import MainController
 
 def main():
     app = QApplication(sys.argv)
-    app.setStyle("Fusion")
+    set_dark_theme(app)
+    # app.setStyle("Fusion")
     window = MainWindow()
     controller = MainController(window)
     controller.load_colors()
+
+    app.aboutToQuit.connect(controller.shutdown)
     window.show()
     sys.exit(app.exec())
 

ui/main_palette.py

@@ -0,0 +1,48 @@
+import sys
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QPalette, QColor
+from PySide6.QtCore import Qt
+
+def set_dark_theme(app: QApplication):
+    """Definiuje i stosuje ciemną paletę kolorów do aplikacji."""
+    
+    # 1. Upewnij się, że styl jest ustawiony na "Fusion"
+    app.setStyle('Fusion')
+    
+    # 2. Definicja kolorów dla ciemnego motywu
+    palette = QPalette()
+    
+    # Kolory tła
+    DARK_GRAY = QColor(45, 45, 45)    # Ogólne tło okien i widżetów (Base, Window)
+    LIGHT_GRAY = QColor(53, 53, 53)   # Tło elementów, np. toolbara, menu (Window)
+    VERY_DARK_GRAY = QColor(32, 32, 32) # Kolor tła dla kontrolek (Button)
+    
+    # Kolory tekstu i obramowań
+    WHITE = QColor(200, 200, 200)    # Główny kolor tekstu (Text, WindowText)
+    HIGHLIGHT = QColor(66, 135, 245) # Kolor podświetlenia (Highlight)
+
+    # Ustawienie głównej palety
+    # palette.setColor(QPalette.ColorRole.Window, LIGHT_GRAY)
+    palette.setColor(QPalette.ColorRole.Window, VERY_DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.WindowText, WHITE)
+    palette.setColor(QPalette.ColorRole.Base, DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.AlternateBase, LIGHT_GRAY)
+    palette.setColor(QPalette.ColorRole.ToolTipBase, WHITE)
+    palette.setColor(QPalette.ColorRole.ToolTipText, WHITE)
+    palette.setColor(QPalette.ColorRole.Text, WHITE)
+    palette.setColor(QPalette.ColorRole.Button, VERY_DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.ButtonText, WHITE)
+    palette.setColor(QPalette.ColorRole.BrightText, Qt.GlobalColor.red)
+    palette.setColor(QPalette.ColorRole.Link, QColor(42, 130, 218))
+    palette.setColor(QPalette.ColorRole.PlaceholderText, QColor(150, 150, 150))
+    
+    # Kolory zaznaczenia/interakcji
+    palette.setColor(QPalette.ColorRole.Highlight, HIGHLIGHT)
+    palette.setColor(QPalette.ColorRole.HighlightedText, Qt.GlobalColor.black)
+    
+    # Kontrolki wyłączone (Disabled)
+    # palette.setColor(QPalette.ColorRole.Disabled, QPalette.ColorGroup.Active, QPalette.ColorRole.Text, QColor(127, 127, 127))
+    # palette.setColor(QPalette.ColorRole.Disabled, QPalette.ColorGroup.Active, QPalette.ColorRole.ButtonText, QColor(127, 127, 127))
+
+    # 3. Zastosowanie palety do aplikacji
+    app.setPalette(palette)