temporary commit

controllers/camera_controller.py

@@ -0,0 +1,31 @@
+from PySide6.QtCore import QObject, QThread, Signal
+from ..core.base import BaseImageSource, BaseControlSource
+
+
+class CameraController(QObject):
+    new_frame = Signal(object)
+    errorOccurred = Signal(str)
+
+    def __init__(self, image_source: BaseImageSource, control_source: BaseControlSource, parent=None):
+        super().__init__(parent)
+        self.image_source = image_source
+        self.control_source = control_source
+
+        self.camera_thread = QThread()
+        self.moveToThread(self.camera_thread)
+
+        self.image_source.moveToThread(self.camera_thread)
+        self.control_source.moveToThread(self.camera_thread)
+
+        self.image_source.new_frame.connect(self.new_frame)
+        self.image_source.errorOccurred.connect(self.errorOccurred)
+        self.control_source.errorOccurred.connect(self.errorOccurred)
+
+    def start(self):
+        self.camera_thread.start()
+        self.image_source.start()
+
+    def stop(self):
+        self.image_source.stop()
+        self.camera_thread.quit()
+        self.camera_thread.wait()

controllers/main_controller.py

@@ -1,9 +1,13 @@
+from PySide6.QtWidgets import QPushButton
 from pathlib import Path
 from core.database import DatabaseManager
 from core.media import MediaRepository
 from ui.widgets.color_list_widget import ColorListWidget
 from ui.widgets.thumbnail_list_widget import ThumbnailListWidget
-
+from ui.widgets.split_view_widget import SplitView
+from .camera_controller import CameraController
+from ..core.gphoto_adapter import GPhotoImageSource, GPhotoControlSource
+import gphoto2 as gp
 
 class MainController:
     def __init__(self, view):
@@ -12,15 +16,31 @@ class MainController:
         self.media_repo = MediaRepository(self.db)
         self.media_repo.sync_media()
 
+        camera = gp.Camera()
+        camera.init()
+        stream = GPhotoImageSource(camera=camera, fps=15)
+        controll = GPhotoControlSource(camera=camera)
+        self.camera_controller = CameraController(stream, controll)
+
         self.view = view
         self.color_list: ColorListWidget = view.color_list_widget
         self.thumbnail_list: ThumbnailListWidget = view.thumbnail_widget
+        self.split_view: SplitView = view.preview_widget
 
+        self.photo_button: QPushButton = view.photo_button
+        self.photo_button.clicked.connect(self.take_photo)
 
         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.new_frame.connect(self.split_view.set_live_image)
+        self.split_view.widget_start.camera_start_btn.clicked.connect(self.camera_controller.start)
+
+    def start_camera(self):
+        pass
+
     def load_colors(self) -> None:
         colors = self.db.get_all_colors()
         print("Loaded colors:", colors)
@@ -49,5 +69,10 @@ class MainController:
         media = self.db.get_media(media_id)
         if media:
             print(f"Wybrano miniaturę o ID: {media_id}, ścieżka: {media['media_path']}")
+            self.split_view.set_reference_image(media['media_path'])
         else:
             print(f"Nie znaleziono mediów o ID: {media_id}")
+
+    def take_photo(self):
+        print("Robienie zdjęcia...")
+        self.split_view.toglle_live_view()

controllers/mock_gphoto.py

@@ -0,0 +1,64 @@
+import cv2
+import numpy as np
+
+class GPhoto2Error(Exception):
+    pass
+
+
+class CameraFileMock:
+    """Mock obiektu zwracanego przez gphoto2.Camera.capture_preview()"""
+
+    def __init__(self, frame: np.ndarray):
+        # Kodowanie do JPEG, żeby symulować prawdziwe dane z kamery
+        success, buf = cv2.imencode(".jpg", frame)
+        if not success:
+            raise GPhoto2Error("Nie udało się zakodować ramki testowej.")
+        self._data = buf.tobytes()
+
+    def get_data_and_size(self):
+        return self._data
+        return self._data, len(self._data)
+
+
+class Camera:
+    def __init__(self):
+        self._frame_counter = 0
+        self._running = False
+
+    def init(self):
+        self._running = True
+        print("[my_gphoto] Kamera MOCK zainicjalizowana")
+
+    def exit(self):
+        self._running = False
+        print("[my_gphoto] Kamera MOCK wyłączona")
+
+    def capture_preview(self):
+        if not self._running:
+            raise GPhoto2Error("Kamera MOCK nie jest uruchomiona")
+
+        # przykład 1: wczytaj stały obrazek z pliku
+        # frame = cv2.imread("test_frame.jpg")
+        # if frame is None:
+        #     raise GPhoto2Error("Nie znaleziono test_frame.jpg")
+
+        # przykład 2: wygeneruj kolorową planszę
+        h, w = 480, 640
+        color = (self._frame_counter % 255, 100, 200)
+        frame = np.full((h, w, 3), color, dtype=np.uint8)
+
+        # dodanie napisu
+        text = "OBRAZ TESTOWY"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        scale = 1.5
+        thickness = 3
+        color_text = (255, 255, 255)
+
+        (text_w, text_h), _ = cv2.getTextSize(text, font, scale, thickness)
+        x = (w - text_w) // 2
+        y = (h + text_h) // 2
+        cv2.putText(frame, text, (x, y), font, scale, color_text, thickness, cv2.LINE_AA)
+
+
+        self._frame_counter += 1
+        return CameraFileMock(frame)

core/base.py

@@ -0,0 +1,26 @@
+from PySide6.QtCore import QObject, Signal
+from PySide6.QtGui import QPixmap
+
+
+class BaseImageSource(QObject):
+    new_frame = Signal(QPixmap)
+    errorOccurred = Signal(str)
+
+    def start(self):
+        raise NotImplementedError
+    
+    def stop(self):
+        raise NotImplementedError
+
+class BaseControlSource(QObject):
+    errorOccurred = Signal(str)
+    parameterChanged = Signal(str, object)
+
+    def set_parameter(self, name: str, value):
+        raise NotImplementedError
+    
+    def get_parameter(self, name: str):
+        raise NotImplementedError
+    
+    def list_parameters(self) -> dict:
+        raise NotImplementedError

core/camera_manager.py

@@ -0,0 +1,69 @@
+import cv2
+import gphoto2 as gp
+
+from controllers.camera_controller import CameraController
+from .gphoto_adapter import GPhotoImageSource, GPhotoControlSource
+from .opencv_adapter import OpenCVImageSource, OpenCVControlSource
+
+
+class CameraManager:
+    def __init__(self):
+        self.devices = []  # lista wykrytych kamer
+
+    def detect_devices(self):
+        self.devices.clear()
+
+        # --- Wykrywanie webcamów / grabberów HDMI
+        for index in range(5):  # sprawdź kilka indeksów
+            cap = cv2.VideoCapture(index)
+            if cap.isOpened():
+                self.devices.append({
+                    "id": f"opencv:{index}",
+                    "name": f"Webcam / HDMI Grabber #{index}",
+                    "type": "opencv",
+                    "index": index
+                })
+                cap.release()
+
+        # --- Wykrywanie kamer gphoto2
+        cameras = gp.Camera.autodetect()    # type: ignore
+        for i, (name, addr) in enumerate(cameras):
+            self.devices.append({
+                "id": f"gphoto:{i}",
+                "name": f"{name} ({addr})",
+                "type": "gphoto",
+                "addr": addr
+            })
+
+        return self.devices
+
+    def create_controller(self, device_id, hybrid_with=None):
+        """
+        Tworzy CameraController na podstawie id urządzenia.
+        Można podać hybrid_with="opencv" albo "gphoto" żeby zbudować hybrydę.
+        """
+        device = next((d for d in self.devices if d["id"] == device_id), None)
+        if not device:
+            raise ValueError(f"Nie znaleziono urządzenia {device_id}")
+
+        # Webcam / grabber
+        if device["type"] == "opencv":
+            cap = cv2.VideoCapture(device["index"])
+            img = OpenCVImageSource(device["index"])
+            ctrl = OpenCVControlSource(cap)
+            return CameraController(img, ctrl)
+
+        # GPhoto camera
+        elif device["type"] == "gphoto":
+            cam = gp.Camera()   # type: ignore
+            cam.init()
+            img = GPhotoImageSource(cam)
+            ctrl = GPhotoControlSource(cam)
+            return CameraController(img, ctrl)
+
+        # Hybrydowy tryb
+        elif device["type"] == "hybrid":
+            raise NotImplementedError("Tu możesz połączyć OpenCV + GPhoto w hybrydę")
+
+        else:
+            raise ValueError(f"Nieobsługiwany typ urządzenia: {device['type']}")

core/gphoto_adapter.py

@@ -0,0 +1,84 @@
+import numpy as np
+import cv2
+
+from PySide6.QtCore import QObject, QThread, Signal, QTimer
+from PySide6.QtGui import QImage, QPixmap
+
+from .base import  BaseImageSource, BaseControlSource
+
+import gphoto2 as gp
+
+# try:
+#     import gphoto2 as gp
+# except:
+#     from . import mock_gphoto as gp
+
+class GPhotoImageSource(BaseImageSource):
+
+    def __init__(self, camera: gp.Camera, fps=10, parent=None): # type: ignore
+        super().__init__(parent)
+        self.camera = camera
+        self.fps = fps
+        self.timer = None
+
+    def start(self):
+        self.timer = QTimer()
+        self.timer.timeout.connect(self._grab_frame)
+        self.timer.start(int(1000 / self.fps))
+
+    def stop(self):
+        if self.timer:
+            self.timer.stop()
+
+    def _grab_frame(self):
+        try:
+            file = self.camera.capture_preview()
+            data = file.get_data_and_size()
+            frame = np.frombuffer(data, dtype=np.uint8)
+            frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+            if frame is None:
+                return
+
+            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.new_frame.emit(pixmap)
+        except gp.GPhoto2Error as e:
+            self.errorOccurred.emit(f"GPhoto2 error: {e}")
+
+
+class GPhotoControlSource(BaseControlSource):
+
+    def __init__(self, camera: gp.Camera, parent=None): # type: ignore
+        super().__init__(parent)
+        self.camera = camera
+
+    def set_parameter(self, name, value):
+        try:
+            config = self.camera.get_config()
+            child = config.get_child_by_name(name)
+            child.set_value(value)
+            self.camera.set_config(config)
+            self.parameterChanged.emit(name, value)
+        except gp.GPhoto2Error as e:
+            self.errorOccurred.emit(str(e))
+
+    def get_parameter(self, name):
+        try:
+            config = self.camera.get_config()
+            child = config.get_child_by_name(name)
+            return child.get_value()
+        except gp.GPhoto2Error as e:
+            self.errorOccurred.emit(str(e))
+            return None
+
+    def list_parameters(self):
+        params = {}
+        try:
+            config = self.camera.get_config()
+            for child in config.get_children():
+                params[child.get_name()] = child.get_value()
+        except gp.GPhoto2Error as e:
+            self.errorOccurred.emit(str(e))
+        return params

core/mock_gphoto.py

@@ -0,0 +1,64 @@
+import cv2
+import numpy as np
+
+class GPhoto2Error(Exception):
+    pass
+
+
+class CameraFileMock:
+    """Mock obiektu zwracanego przez gphoto2.Camera.capture_preview()"""
+
+    def __init__(self, frame: np.ndarray):
+        # Kodowanie do JPEG, żeby symulować prawdziwe dane z kamery
+        success, buf = cv2.imencode(".jpg", frame)
+        if not success:
+            raise GPhoto2Error("Nie udało się zakodować ramki testowej.")
+        self._data = buf.tobytes()
+
+    def get_data_and_size(self):
+        return self._data
+        return self._data, len(self._data)
+
+
+class Camera:
+    def __init__(self):
+        self._frame_counter = 0
+        self._running = False
+
+    def init(self):
+        self._running = True
+        print("[my_gphoto] Kamera MOCK zainicjalizowana")
+
+    def exit(self):
+        self._running = False
+        print("[my_gphoto] Kamera MOCK wyłączona")
+
+    def capture_preview(self):
+        if not self._running:
+            raise GPhoto2Error("Kamera MOCK nie jest uruchomiona")
+
+        # przykład 1: wczytaj stały obrazek z pliku
+        # frame = cv2.imread("test_frame.jpg")
+        # if frame is None:
+        #     raise GPhoto2Error("Nie znaleziono test_frame.jpg")
+
+        # przykład 2: wygeneruj kolorową planszę
+        h, w = 480, 640
+        color = (self._frame_counter % 255, 100, 200)
+        frame = np.full((h, w, 3), color, dtype=np.uint8)
+
+        # dodanie napisu
+        text = "OBRAZ TESTOWY"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        scale = 1.5
+        thickness = 3
+        color_text = (255, 255, 255)
+
+        (text_w, text_h), _ = cv2.getTextSize(text, font, scale, thickness)
+        x = (w - text_w) // 2
+        y = (h + text_h) // 2
+        cv2.putText(frame, text, (x, y), font, scale, color_text, thickness, cv2.LINE_AA)
+
+
+        self._frame_counter += 1
+        return CameraFileMock(frame)

core/opencv_adapter.py

@@ -0,0 +1,83 @@
+from PySide6.QtCore import QObject, Signal, QTimer
+from PySide6.QtGui import QImage, QPixmap
+import cv2
+import numpy as np
+
+
+from .base import BaseImageSource, BaseControlSource
+
+
+
+
+
+class OpenCVImageSource(BaseImageSource):
+
+    def __init__(self, device_index=0, fps=30, parent=None):
+        super().__init__(parent)
+        self.device_index = device_index
+        self.fps = fps
+        self.cap = None
+        self.timer = None
+
+    def start(self):
+        self.cap = cv2.VideoCapture(self.device_index)
+        if not self.cap.isOpened():
+            self.errorOccurred.emit(f"Nie mogę otworzyć kamery {self.device_index}")
+            return
+
+        self.timer = QTimer()
+        self.timer.timeout.connect(self._grab_frame)
+        self.timer.start(int(1000 / self.fps))
+
+    def stop(self):
+        if self.timer:
+            self.timer.stop()
+        if self.cap:
+            self.cap.release()
+
+    def _grab_frame(self):
+        if self.cap is None:
+            self.errorOccurred.emit(f"Kamera niezaincjalizowana!")
+            return
+        
+        ret, frame = self.cap.read()
+        if not ret:
+            self.errorOccurred.emit("Brak obrazu z kamery OpenCV")
+            return
+
+        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.new_frame.emit(pixmap)
+
+
+class OpenCVControlSource(BaseControlSource):
+
+    def __init__(self, cap: cv2.VideoCapture, parent=None):
+        super().__init__(parent)
+        self.cap = cap
+
+    def set_parameter(self, name, value):
+        prop_id = getattr(cv2, name, None)
+        if prop_id is None:
+            self.errorOccurred.emit(f"Nieznany parametr {name}")
+            return
+        self.cap.set(prop_id, value)
+        self.parameterChanged.emit(name, value)
+
+    def get_parameter(self, name):
+        prop_id = getattr(cv2, name, None)
+        if prop_id is None:
+            self.errorOccurred.emit(f"Nieznany parametr {name}")
+            return None
+        return self.cap.get(prop_id)
+
+    def list_parameters(self):
+        return {
+            "CAP_PROP_BRIGHTNESS": self.cap.get(cv2.CAP_PROP_BRIGHTNESS),
+            "CAP_PROP_CONTRAST": self.cap.get(cv2.CAP_PROP_CONTRAST),
+            "CAP_PROP_SATURATION": self.cap.get(cv2.CAP_PROP_SATURATION),
+            "CAP_PROP_GAIN": self.cap.get(cv2.CAP_PROP_GAIN),
+            "CAP_PROP_EXPOSURE": self.cap.get(cv2.CAP_PROP_EXPOSURE),
+        }

main.py

@@ -8,6 +8,7 @@ from controllers.main_controller import MainController
 
 def main():
     app = QApplication(sys.argv)
+    app.setStyle("Fusion")
     window = MainWindow()
     controller = MainController(window)
     controller.load_colors()

requirements.txt

@@ -0,0 +1,6 @@
+numpy==2.2.6
+opencv-python==4.12.0.88
+PySide6==6.9.2
+PySide6_Addons==6.9.2
+PySide6_Essentials==6.9.2
+shiboken6==6.9.2

ui/main_window.py

@@ -9,6 +9,7 @@ from PySide6.QtGui import QPalette, QColor
 from ui.widgets.placeholder_widget import PlaceholderWidget
 from ui.widgets.color_list_widget import ColorListWidget
 from ui.widgets.thumbnail_list_widget import ThumbnailListWidget
+from ui.widgets.split_view_widget import SplitView
 
 class MainWindow(QMainWindow):
     def __init__(self):
@@ -23,9 +24,7 @@ class MainWindow(QMainWindow):
         main_layout = QHBoxLayout(central_widget)
         self.setCentralWidget(central_widget)
 
-        self.preview_widget = QSplitter(Qt.Orientation.Vertical)
+        self.preview_widget = SplitView()
-        self.preview_widget.addWidget(PlaceholderWidget("Camera View", "#750466"))
-        self.preview_widget.addWidget(PlaceholderWidget("Image View", "#007981"))
 
         self.thumbnail_widget = ThumbnailListWidget()
         self.thumbnail_widget.setFixedWidth(200)
@@ -39,23 +38,24 @@ class MainWindow(QMainWindow):
 
         control_layout = QVBoxLayout(self.control_widget)
         control_layout.setContentsMargins(0, 0, 0, 0)
+
         histogram_view = PlaceholderWidget("Histogram View", "#FF5733")
         histogram_view.setFixedHeight(200)
-        control_layout.addWidget(histogram_view)
 
         self.color_list_widget = ColorListWidget(self.control_widget)
+
+        self.record_button = QPushButton("Nagraj Wideo")
+        self.record_button.setMinimumHeight(40)
+        self.record_button.setStyleSheet("font-size: 12pt;")
+
+        self.photo_button = QPushButton("Zrób zdjęcie")
+        self.photo_button.setMinimumHeight(40)
+        self.photo_button.setStyleSheet("font-size: 12pt;")
+        
+        control_layout.addWidget(histogram_view)
         control_layout.addWidget(self.color_list_widget)
-
+        control_layout.addWidget(self.record_button)
-        record_button = QPushButton("Nagraj Wideo")
+        control_layout.addWidget(self.photo_button)
-        record_button.setMinimumHeight(40)
-        record_button.setStyleSheet("font-size: 12pt;")
-        control_layout.addWidget(record_button)
-
-        photo_button = QPushButton("Zrób zdjęcie")
-        photo_button.setMinimumHeight(40)
-        photo_button.setStyleSheet("font-size: 12pt;")
-        control_layout.addWidget(photo_button)
-        
 
 
 

ui/widgets/split_view_widget.py

@@ -0,0 +1,164 @@
+from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, QApplication, QMainWindow, QWidget, QVBoxLayout, QSplitter, QStackedWidget, QPushButton, QLabel
+from PySide6.QtGui import QPixmap, QWheelEvent, QPainter, QBrush, QColor
+from PySide6.QtCore import Qt
+import sys
+from ui.widgets.placeholder_widget import PlaceholderWidget
+
+class ZoomableImageView(QGraphicsView):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Scena i element obrazu
+        self._scene = QGraphicsScene(self)
+        self.setScene(self._scene)
+        self._scene.setBackgroundBrush(QBrush(QColor(20, 20, 20)))  # ciemne tło
+
+        self._pixmap_item = QGraphicsPixmapItem()
+        self._scene.addItem(self._pixmap_item)
+
+        # Ustawienia widoku
+        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)  # przesuwanie myszą
+        self.setRenderHint(QPainter.RenderHint.Antialiasing)
+        self.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+
+        # Wyłączenie suwaków
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        # Parametry zoomu
+        self._zoom_factor = 1.25
+        self._current_scale = 1.0
+
+    def set_image(self, pixmap: QPixmap):
+        # pixmap = QPixmap(image_path)
+        self._pixmap_item.setPixmap(pixmap)
+        self._scene.setSceneRect(pixmap.rect())
+        # self.reset_transform()
+
+    def reset_transform(self):
+        """Resetuje skalowanie i ustawia 1:1"""
+        self._current_scale = 1.0
+        self.setTransform(self.transform().fromScale(1, 1))
+
+    def wheelEvent(self, event: QWheelEvent):
+        """Zoom kółkiem myszy"""
+        if event.modifiers() & Qt.KeyboardModifier.ControlModifier:  # zoom tylko z CTRL
+            if event.angleDelta().y() > 0:
+                zoom = self._zoom_factor
+            else:
+                zoom = 1 / self._zoom_factor
+
+            self._current_scale *= zoom
+            self.scale(zoom, zoom)
+        else:
+            return
+            super().wheelEvent(event)  # normalne przewijanie
+
+class CameraPlaceholder(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.setAutoFillBackground(True)
+        self.setStyleSheet("background-color: #141414;")
+
+        layout = QVBoxLayout(self)
+        layout.setSpacing(20)
+
+        self.camera_start_btn = QPushButton("Start Camera")
+        self.camera_start_btn.setFixedSize(200, 50)
+        style_sheet = """
+                        QPushButton {
+                /* --- Styl podstawowy --- */
+                background-color: transparent;
+                border: 2px solid #CECECE; /* Grubość, styl i kolor obramowania */
+                border-radius: 25px; /* Kluczowa właściwość do zaokrąglenia rogów! */
+                color: #CECECE;
+                padding: 10px 20px; /* Wewnętrzny margines */
+                font-size: 16px;
+            }
+
+            QPushButton:hover {
+                /* --- Styl po najechaniu myszką --- */
+                color: #F0F0F0;
+                border: 2px solid #F0F0F0;
+            }
+
+            QPushButton:pressed {
+                /* --- Styl po naciśnięciu --- */
+                background-color: #e0e0e0; /* Ciemniejsze tło w momencie kliknięcia */
+                border: 2px solid #e0e0e0; /* Zmiana koloru ramki dla sygnalizacji akcji */
+            }
+        """
+        self.camera_start_btn.setStyleSheet(style_sheet)
+
+        self.info_label = QLabel("Kliknij, aby uruchomić kamerę")
+        self.info_label.setStyleSheet("background-color: transparent; color: #CECECE; font-size: 18px;")
+        self.info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        layout.addStretch()
+        layout.addWidget(self.camera_start_btn, alignment=Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.info_label)
+        layout.addStretch()
+        self.setLayout(layout)
+
+    def set_info_text(self, text: str):
+        self.info_label.setText(text)
+
+class SplitView(QSplitter):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        print("Inicjalizacja SplitView2")
+        self.setOrientation(Qt.Orientation.Vertical)
+
+        self.widget_start = CameraPlaceholder()
+        self.widget_live = ZoomableImageView()
+        # self.widget_live = PlaceholderWidget("Camera View", "#750466")
+        self.widget_ref = ZoomableImageView()
+        # self.widget_ref = PlaceholderWidget("Image View", "#007981")
+
+        self.stack = QStackedWidget()
+        self.stack.addWidget(self.widget_start)
+        self.stack.addWidget(self.widget_live)
+        self.stack.setCurrentWidget(self.widget_start)
+
+        self.addWidget(self.stack)
+        self.addWidget(self.widget_ref)
+
+        self.setSizes([self.height(), 0])
+
+        pixmap = QPixmap("media/empty_guitar_h.jpg")
+        # pixmap.fill(Qt.GlobalColor.lightGray)
+        self.widget_live.set_image(pixmap)
+
+    def toggle_orientation(self):
+        if self.orientation() == Qt.Orientation.Vertical:
+            self.setOrientation(Qt.Orientation.Horizontal)
+            self.setSizes([self.width()//2, self.width()//2])
+        else:
+            self.setOrientation(Qt.Orientation.Vertical)
+            self.setSizes([self.height()//2, self.height()//2])
+    
+    # def set_live_image(self, path_image: str):
+    #     """Ustawienie obrazu na żywo"""
+    #     pixmap = QPixmap(path_image)
+    #     self.widget_live.set_image(pixmap)
+
+    def set_live_image(self,  pixmap: QPixmap):
+        """Ustawienie obrazu na żywo"""
+        self.widget_live.set_image(pixmap)
+        if self.stack.currentWidget() != self.widget_live:
+            self.stack.setCurrentWidget(self.widget_live)
+
+    def set_reference_image(self, path_image: str):
+        """Ustawienie obrazu referencyjnego"""
+        pixmap = QPixmap(path_image)
+        self.widget_ref.set_image(pixmap)
+
+    def toglle_live_view(self):
+        """Przełączanie widoku na żywo"""
+        if self.stack.currentWidget() == self.widget_start:
+            self.stack.setCurrentWidget(self.widget_live)
+        else:
+            self.stack.setCurrentWidget(self.widget_start)
+
+    
+