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

shinestacker/retouch/sidebyside_view.py

@@ -1,6 +1,6 @@
 # pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
 from PySide6.QtCore import Qt, Signal, QEvent, QRectF
-from PySide6.QtGui import QPixmap, QPen, QColor, QCursor
+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
@@ -11,6 +11,7 @@ class ImageGraphicsView(ImageGraphicsViewBase):
     mouse_moved = Signal(QEvent)
     mouse_released = Signal(QEvent)
     gesture_event = Signal(QEvent)
+    wheel_event = Signal(QEvent)
 
     # pylint: disable=C0103
     def event(self, event):
@@ -29,6 +30,10 @@ class ImageGraphicsView(ImageGraphicsViewBase):
     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
 
 
@@ -46,7 +51,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self._connect_signals()
         self.panning_current = False
         self.brush_cursor = None
-        self.setup_brush_cursor()
         self.setFocusPolicy(Qt.StrongFocus)
         self.pan_start = None
         self.pinch_start_scale = None
@@ -58,12 +62,11 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.setup_current_brush_cursor()
 
     def setup_layout(self):
-        """To be implemented by subclasses - creates layout and adds widgets"""
         raise NotImplementedError("Subclasses must implement setup_layout")
 
     def create_pixmaps(self):
-        self.current_pixmap_item = self.create_pixmap(self.current_scene)
-        self.master_pixmap_item = self.create_pixmap(self.master_scene)
+        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)
@@ -82,6 +85,8 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             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
@@ -92,31 +97,44 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def current_view_enter_event(self, event):
         self.activateWindow()
         self.setFocus()
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.current_view).enterEvent(event)
 
     def current_view_leave_event(self, event):
-        self.update_brush_cursor()
+        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()
-        self.update_brush_cursor()
+        if not self.empty():
+            self.update_brush_cursor()
         super(ImageGraphicsView, self.master_view).enterEvent(event)
 
     def master_view_leave_event(self, event):
-        self.update_brush_cursor()
+        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.master_pixmap_item
+        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]
@@ -126,8 +144,8 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
 
     def get_pixmaps(self):
         return {
-            self.master_pixmap_item: self.master_view,
-            self.current_pixmap_item: self.current_view
+            self.pixmap_item_master: self.master_view,
+            self.pixmap_item_current: self.current_view
         }
 
     # pylint: disable=C0103
@@ -153,22 +171,33 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def enterEvent(self, event):
         self.activateWindow()
         self.setFocus()
-        if not self.empty():
+        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.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)
+        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):
@@ -182,6 +211,40 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             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()
@@ -194,7 +257,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             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)
+        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)
@@ -214,15 +277,12 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.current_brush_cursor.hide()
 
     def update_cursor_pen_width(self):
-        if not self.brush_cursor or not self.current_brush_cursor:
-            return
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        master_pen = self.brush_cursor.pen()
-        master_pen.setWidthF(pen_width)
-        self.brush_cursor.setPen(master_pen)
-        current_pen = self.current_brush_cursor.pen()
-        current_pen.setWidthF(pen_width)
-        self.current_brush_cursor.setPen(current_pen)
+        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():
@@ -234,6 +294,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         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:
@@ -244,21 +305,16 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
                 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
-            )
+                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
-                )
+                    scene_pos.x() - radius, scene_pos.y() - radius, size, size)
                 self.brush_cursor.show()
             if self.space_pressed:
                 cursor_style = Qt.OpenHandCursor \
@@ -316,93 +372,48 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.handle_pinch_gesture(pinch_gesture)
             event.accept()
 
-    def handle_pinch_gesture(self, pinch):
-        if pinch.state() == Qt.GestureStarted:
-            self.pinch_start_scale = self.zoom_factor()
-            self.pinch_center_view = pinch.centerPoint()
-            self.pinch_center_scene = self.master_view.mapToScene(self.pinch_center_view.toPoint())
-        elif pinch.state() == Qt.GestureUpdated:
-            new_scale = self.pinch_start_scale * pinch.totalScaleFactor()
-            new_scale = max(self.min_scale(), min(new_scale, self.max_scale()))
-            if abs(new_scale - self.zoom_factor()) > 0.01:
-                self.set_zoom_factor(new_scale)
-                self._apply_zoom()
-                new_center = self.master_view.mapToScene(self.pinch_center_view.toPoint())
-                delta = self.pinch_center_scene - new_center
-                h_scroll = self.master_view.horizontalScrollBar().value()
-                v_scroll = self.master_view.verticalScrollBar().value()
-                self.master_view.horizontalScrollBar().setValue(
-                    h_scroll + int(delta.x() * self.zoom_factor()))
-                self.master_view.verticalScrollBar().setValue(
-                    v_scroll + int(delta.y() * self.zoom_factor()))
-
     def set_master_image(self, qimage):
         self.status.set_master_image(qimage)
         pixmap = self.status.pixmap_master
-        img_width, img_height = pixmap.width(), pixmap.height()
         self.master_view.setSceneRect(QRectF(pixmap.rect()))
-        self.master_pixmap_item.setPixmap(pixmap)
-        self.set_min_scale(min(gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width,
-                               gui_constants.MIN_ZOOMED_IMG_HEIGHT / img_height))
-        self.set_max_scale(gui_constants.MAX_ZOOMED_IMG_PX_SIZE)
+        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.master_pixmap_item, Qt.KeepAspectRatio)
+        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.master_pixmap_item)
+        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.master_pixmap_item.boundingRect()))
+        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.current_pixmap_item.setPixmap(pixmap)
+        self.pixmap_item_current.setPixmap(pixmap)
         self.current_view.resetTransform()
         self.current_scene.scale(self.zoom_factor(), self.zoom_factor())
-        # self.current_view.centerOn(self.current_pixmap_item)
-        self.current_scene.setSceneRect(QRectF(self.current_pixmap_item.boundingRect()))
+        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):
+    def arrange_images(self):
         if self.status.empty():
             return
-        if self.master_pixmap_item.pixmap().height() == 0:
+        if self.pixmap_item_master.pixmap().height() == 0:
             self.update_master_display()
             self.update_current_display()
             self.reset_zoom()
-        self._apply_zoom()
-
-    def update_master_display(self):
-        if not self.status.empty():
-            master_qimage = self.numpy_to_qimage(self.master_layer())
-            if master_qimage:
-                pixmap = QPixmap.fromImage(master_qimage)
-                self.master_pixmap_item.setPixmap(pixmap)
-                self.master_scene.setSceneRect(QRectF(pixmap.rect()))
-                self._arrange_images()
-
-    def update_current_display(self):
-        if not self.status.empty() and self.number_of_layers() > 0:
-            current_qimage = self.numpy_to_qimage(self.current_layer())
-            if current_qimage:
-                pixmap = QPixmap.fromImage(current_qimage)
-                self.current_pixmap_item.setPixmap(pixmap)
-                self.current_scene.setSceneRect(QRectF(pixmap.rect()))
-                self._arrange_images()
-
-    def _apply_zoom(self):
-        if not self.current_pixmap_item.pixmap().isNull():
-            self.current_view.resetTransform()
-            self.current_view.scale(self.zoom_factor(), self.zoom_factor())
-            # self.current_view.centerOn(self.current_pixmap_item)
-        if not self.master_pixmap_item.pixmap().isNull():
-            self.master_view.resetTransform()
-            self.master_view.scale(self.zoom_factor(), self.zoom_factor())
-            # self.master_view.centerOn(self.master_pixmap_item)
+        else:
+            self.center_image(self.master_view)
+        self.apply_zoom()
 
     def set_brush(self, brush):
         super().set_brush(brush)
@@ -413,6 +424,9 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
 
     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
@@ -434,22 +448,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         else:
             self.current_brush_cursor.hide()
 
-    def zoom_in(self):
-        super().zoom_in()
-        self.update_cursor_pen_width()
-
-    def zoom_out(self):
-        super().zoom_out()
-        self.update_cursor_pen_width()
-
-    def reset_zoom(self):
-        super().reset_zoom()
-        self.update_cursor_pen_width()
-
-    def actual_size(self):
-        super().actual_size()
-        self.update_cursor_pen_width()
-
 
 class SideBySideView(DoubleViewBase):
     def setup_layout(self):

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)