shinestacker 1.3.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

shinestacker/retouch/sidebyside_view.py

@@ -0,0 +1,477 @@
+# pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
+from PySide6.QtCore import Qt, Signal, QEvent, QRectF
+from PySide6.QtGui import QPen, QColor, QCursor
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame, QGraphicsEllipseItem
+from .. config.gui_constants import gui_constants
+from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
+
+
+class ImageGraphicsView(ImageGraphicsViewBase):
+    mouse_pressed = Signal(QEvent)
+    mouse_moved = Signal(QEvent)
+    mouse_released = Signal(QEvent)
+    gesture_event = Signal(QEvent)
+    wheel_event = Signal(QEvent)
+
+    # pylint: disable=C0103
+    def event(self, event):
+        if event.type() == QEvent.Gesture:
+            self.gesture_event.emit(event)
+            return True
+        return super().event(event)
+
+    def mousePressEvent(self, event):
+        self.mouse_pressed.emit(event)
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        self.mouse_moved.emit(event)
+
+    def mouseReleaseEvent(self, event):
+        self.mouse_released.emit(event)
+        super().mouseReleaseEvent(event)
+
+    def wheelEvent(self, event):
+        self.wheel_event.emit(event)
+        event.accept()
+    # pylint: enable=C0103
+
+
+class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
+    def __init__(self, layer_collection, status, parent):
+        ViewStrategy.__init__(self, layer_collection, status)
+        QWidget.__init__(self, parent)
+        self.current_view = ImageGraphicsView(parent)
+        self.master_view = ImageGraphicsView(parent)
+        self.current_scene = self.create_scene(self.current_view)
+        self.master_scene = self.create_scene(self.master_view)
+        self.create_pixmaps()
+        self.master_scene.addItem(self.brush_preview)
+        self.setup_layout()
+        self._connect_signals()
+        self.panning_current = False
+        self.brush_cursor = None
+        self.setFocusPolicy(Qt.StrongFocus)
+        self.pan_start = None
+        self.pinch_start_scale = None
+        self.current_view.installEventFilter(self)
+        self.master_view.installEventFilter(self)
+        self.current_view.setFocusPolicy(Qt.NoFocus)
+        self.master_view.setFocusPolicy(Qt.NoFocus)
+        self.current_brush_cursor = None
+        self.setup_current_brush_cursor()
+
+    def setup_layout(self):
+        raise NotImplementedError("Subclasses must implement setup_layout")
+
+    def create_pixmaps(self):
+        self.pixmap_item_current = self.create_pixmap(self.current_scene)
+        self.pixmap_item_master = self.create_pixmap(self.master_scene)
+
+    def _connect_signals(self):
+        self.current_view.mouse_pressed.connect(self.handle_current_mouse_press)
+        self.current_view.mouse_moved.connect(self.handle_current_mouse_move)
+        self.current_view.mouse_released.connect(self.handle_current_mouse_release)
+        self.current_view.gesture_event.connect(self.handle_gesture_event)
+        self.master_view.mouse_pressed.connect(self.handle_master_mouse_press)
+        self.master_view.mouse_moved.connect(self.handle_master_mouse_move)
+        self.master_view.mouse_released.connect(self.handle_master_mouse_release)
+        self.master_view.gesture_event.connect(self.handle_gesture_event)
+        self.current_view.horizontalScrollBar().valueChanged.connect(
+            self.master_view.horizontalScrollBar().setValue)
+        self.current_view.verticalScrollBar().valueChanged.connect(
+            self.master_view.verticalScrollBar().setValue)
+        self.master_view.horizontalScrollBar().valueChanged.connect(
+            self.current_view.horizontalScrollBar().setValue)
+        self.master_view.verticalScrollBar().valueChanged.connect(
+            self.current_view.verticalScrollBar().setValue)
+        self.current_view.wheel_event.connect(self.handle_wheel_event)
+        self.master_view.wheel_event.connect(self.handle_wheel_event)
+        # pylint: disable=C0103, W0201
+        self.current_view.enterEvent = self.current_view_enter_event
+        self.current_view.leaveEvent = self.current_view_leave_event
+        self.master_view.enterEvent = self.master_view_enter_event
+        self.master_view.leaveEvent = self.master_view_leave_event
+        # pylint: enable=C0103, W0201
+
+    def current_view_enter_event(self, event):
+        self.activateWindow()
+        self.setFocus()
+        if not self.empty():
+            self.update_brush_cursor()
+        super(ImageGraphicsView, self.current_view).enterEvent(event)
+
+    def current_view_leave_event(self, event):
+        if not self.empty():
+            self.update_brush_cursor()
+        super(ImageGraphicsView, self.current_view).leaveEvent(event)
+
+    def master_view_enter_event(self, event):
+        self.activateWindow()
+        self.setFocus()
+        if not self.empty():
+            self.update_brush_cursor()
+        super(ImageGraphicsView, self.master_view).enterEvent(event)
+
+    def master_view_leave_event(self, event):
+        if not self.empty():
+            self.update_brush_cursor()
+        super(ImageGraphicsView, self.master_view).leaveEvent(event)
+
+    def get_master_view(self):
+        return self.master_view
+
+    def get_current_view(self):
+        return self.current_view
+
+    def get_master_scene(self):
+        return self.master_scene
+
+    def get_current_scene(self):
+        return self.current_scene
+
+    def get_master_pixmap(self):
+        return self.pixmap_item_master
+
+    def get_current_pixmap(self):
+        return self.pixmap_item_current
+
+    def get_views(self):
+        return [self.master_view, self.current_view]
+
+    def get_scenes(self):
+        return [self.master_scene, self.current_scene]
+
+    def get_pixmaps(self):
+        return {
+            self.pixmap_item_master: self.master_view,
+            self.pixmap_item_current: self.current_view
+        }
+
+    # pylint: disable=C0103
+    def focusInEvent(self, event):
+        super().focusInEvent(event)
+        self.activateWindow()
+        self.setFocus()
+
+    def eventFilter(self, obj, event):
+        if obj in [self.current_view, self.master_view]:
+            if event.type() == QEvent.KeyPress:
+                self.keyPressEvent(event)
+                return True
+            if event.type() == QEvent.KeyRelease:
+                self.keyReleaseEvent(event)
+                return True
+        return super().eventFilter(obj, event)
+
+    def showEvent(self, event):
+        super().showEvent(event)
+        self.update_brush_cursor()
+
+    def enterEvent(self, event):
+        self.activateWindow()
+        self.setFocus()
+        if self.empty():
+            self.setCursor(Qt.ArrowCursor)
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+        else:
+            if self.space_pressed:
+                self.master_view.setCursor(Qt.OpenHandCursor)
+                self.current_view.setCursor(Qt.OpenHandCursor)
+            else:
+                self.master_view.setCursor(Qt.BlankCursor)
+                self.current_view.setCursor(Qt.BlankCursor)
+                if self.brush_cursor:
+                    self.brush_cursor.show()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if self.empty():
+            self.setCursor(Qt.ArrowCursor)
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+        else:
+            if self.brush_cursor is not None:
+                self.brush_cursor.hide()
+            if self.current_brush_cursor is not None:
+                self.current_brush_cursor.hide()
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+        super().leaveEvent(event)
+
+    def keyPressEvent(self, event):
+        super().keyPressEvent(event)
+        if event.key() == Qt.Key_Space:
+            self.update_brush_cursor()
+
+    def keyReleaseEvent(self, event):
+        super().keyReleaseEvent(event)
+        if event.key() == Qt.Key_Space:
+            self.update_brush_cursor()
+    # pylint: enable=C0103
+
+    # pylint: enable=R0801
+    def handle_wheel_event(self, event):
+        if self.empty() or self.gesture_active:
+            return
+        if event.source() == Qt.MouseEventNotSynthesized:  # Physical mouse
+            if self.control_pressed:
+                self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
+            else:
+                if event.angleDelta().y() > 0:  # Zoom in
+                    self.zoom_in()
+                else:  # Zoom out
+                    self.zoom_out()
+        else:  # Touchpad event - handle scrolling
+            if not self.control_pressed:
+                delta = event.pixelDelta() or event.angleDelta() / 8
+                if delta:
+                    self.scroll_view(self.master_view, delta.x(), delta.y())
+                    self.scroll_view(self.current_view, delta.x(), delta.y())
+    # pylint: disable=R0801
+
+    def _apply_zoom_to_view(self, view, factor):
+        view.scale(factor, factor)
+        other_view = self.current_view if view == self.master_view else self.master_view
+        other_view.resetTransform()
+        other_view.scale(self.zoom_factor(), self.zoom_factor())
+
+    def show_master(self):
+        self.pixmap_item_master.setVisible(True)
+        self.pixmap_item_current.setVisible(True)
+
+    def show_current(self):
+        self.pixmap_item_master.setVisible(True)
+        self.pixmap_item_current.setVisible(True)
+
+    def setup_brush_cursor(self):
+        super().setup_brush_cursor()
+        self.setup_current_brush_cursor()
+        self.update_cursor_pen_width()
+
+    def setup_current_brush_cursor(self):
+        if not self.brush:
+            return
+        for item in self.current_scene.items():
+            if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
+                self.current_scene.removeItem(item)
+        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
+        pen = QPen(QColor(255, 0, 0), pen_width, Qt.DotLine)
+        brush = Qt.NoBrush
+        self.current_brush_cursor = self.current_scene.addEllipse(
+            0, 0, self.brush.size, self.brush.size, pen, brush)
+        self.current_brush_cursor.setZValue(1000)
+        self.current_brush_cursor.hide()
+
+    def update_current_brush_cursor(self, scene_pos):
+        if not self.current_brush_cursor or not self.isVisible():
+            return
+        size = self.brush.size
+        radius = size / 2
+        self.current_brush_cursor.setRect(
+            scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+        if self.brush_cursor and self.brush_cursor.isVisible():
+            self.current_brush_cursor.show()
+        else:
+            self.current_brush_cursor.hide()
+
+    def update_cursor_pen_width(self):
+        pen_width = super().update_cursor_pen_width()
+        if self.current_brush_cursor:
+            current_pen = self.current_brush_cursor.pen()
+            current_pen.setWidthF(pen_width)
+            self.current_brush_cursor.setPen(current_pen)
+        return pen_width
+
+    def update_brush_cursor(self):
+        if self.empty():
+            return
+        self.update_cursor_pen_width()
+        mouse_pos_global = QCursor.pos()
+        mouse_pos_current = self.current_view.mapFromGlobal(mouse_pos_global)
+        mouse_pos_master = self.master_view.mapFromGlobal(mouse_pos_global)
+        current_has_mouse = self.current_view.rect().contains(mouse_pos_current)
+        master_has_mouse = self.master_view.rect().contains(mouse_pos_master)
+        if master_has_mouse:
+            self.brush_preview.show()
+            super().update_brush_cursor()
+            self.sync_current_cursor_with_master()
+            if self.space_pressed:
+                cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
+                self.master_view.setCursor(cursor_style)
+                self.current_view.setCursor(cursor_style)
+            else:
+                self.master_view.setCursor(Qt.BlankCursor)
+                self.current_view.setCursor(Qt.BlankCursor)
+        elif current_has_mouse:
+            self.brush_preview.hide()
+            scene_pos = self.current_view.mapToScene(mouse_pos_current)
+            size = self.brush.size
+            radius = size / 2
+            self.current_brush_cursor.setRect(
+                scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+            self.current_brush_cursor.show()
+            if self.brush_cursor:
+                self.brush_cursor.setRect(
+                    scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+                self.brush_cursor.show()
+            if self.space_pressed:
+                cursor_style = Qt.OpenHandCursor \
+                    if not self.panning_current else Qt.ClosedHandCursor
+                self.current_view.setCursor(cursor_style)
+                self.master_view.setCursor(cursor_style)
+            else:
+                self.current_view.setCursor(Qt.BlankCursor)
+                self.master_view.setCursor(Qt.BlankCursor)
+        else:
+            if self.brush_cursor:
+                self.brush_cursor.hide()
+            if self.current_brush_cursor:
+                self.current_brush_cursor.hide()
+            self.master_view.setCursor(Qt.ArrowCursor)
+            self.current_view.setCursor(Qt.ArrowCursor)
+
+    def handle_master_mouse_press(self, event):
+        self.setFocus()
+        self.mouse_press_event(event)
+
+    def handle_master_mouse_move(self, event):
+        self.mouse_move_event(event)
+        self.update_brush_cursor()
+
+    def handle_master_mouse_release(self, event):
+        self.mouse_release_event(event)
+
+    def handle_current_mouse_press(self, event):
+        position = event.position()
+        if self.space_pressed:
+            self.pan_start = position
+            self.panning_current = True
+            self.update_brush_cursor()
+
+    def handle_current_mouse_move(self, event):
+        position = event.position()
+        if self.panning_current and self.space_pressed:
+            delta = position - self.pan_start
+            self.pan_start = position
+            self.scroll_view(self.current_view, delta.x(), delta.y())
+        else:
+            self.update_brush_cursor()
+
+    def handle_current_mouse_release(self, _event):
+        if self.panning_current:
+            self.panning_current = False
+            self.update_brush_cursor()
+
+    def handle_gesture_event(self, event):
+        if self.empty():
+            return
+        pinch_gesture = event.gesture(Qt.PinchGesture)
+        if pinch_gesture:
+            self.handle_pinch_gesture(pinch_gesture)
+            event.accept()
+
+    def set_master_image(self, qimage):
+        self.status.set_master_image(qimage)
+        pixmap = self.status.pixmap_master
+        self.master_view.setSceneRect(QRectF(pixmap.rect()))
+        self.pixmap_item_master.setPixmap(pixmap)
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.set_max_min_scales(img_width, img_height)
+        self.set_zoom_factor(1.0)
+        self.master_view.fitInView(self.pixmap_item_master, Qt.KeepAspectRatio)
+        self.set_zoom_factor(self.get_current_scale())
+        self.set_zoom_factor(max(self.min_scale(), min(self.max_scale(), self.zoom_factor())))
+        self.master_view.resetTransform()
+        self.master_scene.scale(self.zoom_factor(), self.zoom_factor())
+        self.master_view.centerOn(self.pixmap_item_master)
+        center = self.master_scene.sceneRect().center()
+        self.brush_preview.setPos(max(0, min(center.x(), img_width)),
+                                  max(0, min(center.y(), img_height)))
+        self.master_scene.setSceneRect(QRectF(self.pixmap_item_master.boundingRect()))
+        self.center_image(self.master_view)
+        self.update_cursor_pen_width()
+
+    def set_current_image(self, qimage):
+        self.status.set_current_image(qimage)
+        pixmap = self.status.pixmap_current
+        self.current_scene.setSceneRect(QRectF(pixmap.rect()))
+        self.pixmap_item_current.setPixmap(pixmap)
+        self.current_view.resetTransform()
+        self.current_scene.scale(self.zoom_factor(), self.zoom_factor())
+        self.current_scene.setSceneRect(QRectF(self.pixmap_item_current.boundingRect()))
+        self.center_image(self.current_view)
+        self.update_cursor_pen_width()
+
+    def arrange_images(self):
+        if self.status.empty():
+            return
+        if self.pixmap_item_master.pixmap().height() == 0:
+            self.update_master_display()
+            self.update_current_display()
+            self.reset_zoom()
+        else:
+            self.center_image(self.master_view)
+        self.apply_zoom()
+
+    def set_brush(self, brush):
+        super().set_brush(brush)
+        if self.brush_cursor:
+            self.master_scene.removeItem(self.brush_cursor)
+        self.setup_brush_cursor()
+        self.setup_current_brush_cursor()
+
+    def clear_image(self):
+        super().clear_image()
+        self.setCursor(Qt.ArrowCursor)
+        self.master_view.setCursor(Qt.ArrowCursor)
+        self.current_view.setCursor(Qt.ArrowCursor)
+        if self.current_brush_cursor:
+            self.current_scene.removeItem(self.current_brush_cursor)
+            self.current_brush_cursor = None
+
+    def sync_current_cursor_with_master(self):
+        if not self.brush_cursor or not self.current_brush_cursor:
+            return
+        master_rect = self.brush_cursor.rect()
+        scene_pos = master_rect.center()
+        size = self.brush.size
+        radius = size / 2
+        self.current_brush_cursor.setRect(
+            scene_pos.x() - radius,
+            scene_pos.y() - radius,
+            size, size
+        )
+        if self.brush_cursor.isVisible():
+            self.current_brush_cursor.show()
+        else:
+            self.current_brush_cursor.hide()
+
+
+class SideBySideView(DoubleViewBase):
+    def setup_layout(self):
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.addWidget(self.current_view, 1)
+        separator = QFrame()
+        separator.setFrameShape(QFrame.VLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        separator.setLineWidth(2)
+        layout.addWidget(separator, 0)
+        layout.addWidget(self.master_view, 1)
+
+
+class TopBottomView(DoubleViewBase):
+    def setup_layout(self):
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.addWidget(self.current_view, 1)
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        separator.setLineWidth(2)
+        layout.addWidget(separator, 0)
+        layout.addWidget(self.master_view, 1)

shinestacker/retouch/transformation_manager.py

@@ -0,0 +1,43 @@
+# pylint: disable=C0114, C0115, C0116, E1101, W0718
+import traceback
+import cv2
+from .. config.gui_constants import gui_constants
+from .layer_collection import LayerCollectionHandler
+
+
+class TransfromationManager(LayerCollectionHandler):
+    def __init__(self, editor):
+        super().__init__(editor.layer_collection)
+        self.editor = editor
+
+    def transform(self, transf_func, label, undoable=True):
+        if self.has_no_master_layer():
+            return
+        if undoable:
+            try:
+                undo = self.editor.undo_manager
+                undo.x_start, undo.x_stop = 0, 1
+                undo.y_start, undo.y_stop = 0, 1
+                undo.save_undo_state(self.editor.master_layer(), label)
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+        self.set_master_layer(transf_func(self.master_layer()))
+        self.set_layer_stack([transf_func(layer) for layer in self.layer_stack()])
+        self.copy_master_layer()
+        self.editor.image_viewer.update_master_display()
+        self.editor.image_viewer.update_current_display()
+        self.editor.image_viewer.refresh_display()
+        self.editor.display_manager.update_thumbnails()
+        self.editor.mark_as_modified()
+
+    def rotate_90_cw(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE),
+                       gui_constants.ROTATE_90_CW_LABEL, undoable)
+
+    def rotate_90_ccw(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE),
+                       gui_constants.ROTATE_90_CCW_LABEL, undoable)
+
+    def rotate_180(self, undoable=True):
+        self.transform(lambda img: cv2.rotate(img, cv2.ROTATE_180),
+                       gui_constants.ROTATE_180_LABEL, undoable)

shinestacker/retouch/undo_manager.py

@@ -6,8 +6,9 @@ from .. config.gui_constants import gui_constants
 class UndoManager(QObject):
     stack_changed = Signal(bool, str, bool, str)
 
-    def __init__(self):
+    def __init__(self, transformation_manager):
         super().__init__()
+        self.transformation_manager = transformation_manager
         self.x_start = None
         self.y_start = None
         self.x_end = None
@@ -59,7 +60,16 @@ class UndoManager(QObject):
             'description': undo_state['description']
         }
         self.redo_stack.append(redo_state)
-        layer[y_start:y_end, x_start:x_end] = undo_state['master']
+        descr = undo_state['description']
+        if descr.startswith(gui_constants.ROTATE_LABEL):
+            if descr == gui_constants.ROTATE_90_CW_LABEL:
+                self.transformation_manager.rotate_90_ccw(False)
+            elif descr == gui_constants.ROTATE_90_CCW_LABEL:
+                self.transformation_manager.rotate_90_cw(False)
+            elif descr == gui_constants.ROTATE_180_LABEL:
+                self.transformation_manager.rotate_180(False)
+        else:
+            layer[y_start:y_end, x_start:x_end] = undo_state['master']
         undo_desc = self.undo_stack[-1]['description'] if self.undo_stack else ""
         redo_desc = redo_state['description']
         self.stack_changed.emit(bool(self.undo_stack), undo_desc, bool(self.redo_stack), redo_desc)
@@ -76,7 +86,16 @@ class UndoManager(QObject):
             'description': redo_state['description']
         }
         self.undo_stack.append(undo_state)
-        layer[y_start:y_end, x_start:x_end] = redo_state['master']
+        descr = undo_state['description']
+        if descr.startswith(gui_constants.ROTATE_LABEL):
+            if descr == gui_constants.ROTATE_90_CW_LABEL:
+                self.transformation_manager.rotate_90_cw(False)
+            elif descr == gui_constants.ROTATE_90_CCW_LABEL:
+                self.transformation_manager.rotate_90_ccw(False)
+            elif descr == gui_constants.ROTATE_180_LABEL:
+                self.transformation_manager.rotate_180(False)
+        else:
+            layer[y_start:y_end, x_start:x_end] = redo_state['master']
         undo_desc = undo_state['description']
         redo_desc = self.redo_stack[-1]['description'] if self.redo_stack else ""
         self.stack_changed.emit(bool(self.undo_stack), undo_desc, bool(self.redo_stack), redo_desc)