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

shinestacker/gui/gui_run.py

@@ -9,7 +9,7 @@ from PySide6.QtCore import Signal, Slot
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
 from .colors import RED_BUTTON_STYLE, BLUE_BUTTON_STYLE, BLUE_COMBO_STYLE
-from .. algorithms.utils import extension_tif_jpg, extension_pdf
+from .. algorithms.utils import extension_jpg_tif_png, extension_pdf
 from .gui_logging import LogWorker, QTextEditLogger
 from .gui_images import GuiPdfView, GuiImageView, GuiOpenApp
 from .colors import (
@@ -209,7 +209,7 @@ class RunWindow(QTextEditLogger):
         try:
             if extension_pdf(path):
                 image_view = GuiPdfView(path, self)
-            elif extension_tif_jpg(path):
+            elif extension_jpg_tif_png(path):
                 image_view = GuiImageView(path, self)
             else:
                 raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")

shinestacker/gui/main_window.py

@@ -134,19 +134,28 @@ class MainWindow(QMainWindow, LogManager):
             self.update_title()
 
         self.project_editor.modified_signal.connect(handle_modified)
-        self.project_editor.select_signal.connect(self.update_delete_action_state)
-        self.project_editor.refresh_ui_signal.connect(self.refresh_ui)
+        self.project_editor.select_signal.connect(
+            self.update_delete_action_state)
+        self.project_editor.refresh_ui_signal.connect(
+            self.refresh_ui)
         self.project_editor.enable_delete_action_signal.connect(
             self.menu_manager.delete_element_action.setEnabled)
         self.project_editor.undo_manager.set_enabled_undo_action_requested.connect(
             self.menu_manager.set_enabled_undo_action)
-        self.project_controller.update_title_requested.connect(self.update_title)
-        self.project_controller.refresh_ui_requested.connect(self.refresh_ui)
-        self.project_controller.activate_window_requested.connect(self.activateWindow)
+        self.project_controller.update_title_requested.connect(
+            self.update_title)
+        self.project_controller.refresh_ui_requested.connect(
+            self.refresh_ui)
+        self.project_controller.activate_window_requested.connect(
+            self.activateWindow)
         self.project_controller.enable_save_actions_requested.connect(
             self.menu_manager.save_actions_set_enabled)
         self.project_controller.enable_sub_actions_requested.connect(
             self.menu_manager.set_enabled_sub_actions_gui)
+        self.project_controller.add_recent_file_requested.connect(
+            self.menu_manager.add_recent_file)
+        self.menu_manager.open_file_requested.connect(
+            self.project_controller.open_project)
 
     def modified(self):
         return self.project_editor.modified()

shinestacker/gui/menu_manager.py

@@ -1,13 +1,20 @@
 # pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201
 import os
+from functools import partial
+from PySide6.QtCore import Signal, QObject
 from PySide6.QtGui import QAction, QIcon
 from PySide6.QtWidgets import QMenu, QComboBox
 from .. config.constants import constants
+from .recent_file_manager import RecentFileManager
 
 
-class MenuManager:
+class MenuManager(QObject):
+    open_file_requested = Signal(str)
+
     def __init__(self, menubar, actions, project_editor, parent):
+        super().__init__(parent)
         self.script_dir = os.path.dirname(__file__)
+        self._recent_file_manager = RecentFileManager("shinestacker-recent-project-files.txt")
         self.project_editor = project_editor
         self.parent = parent
         self.menubar = menubar
@@ -69,10 +76,27 @@ class MenuManager:
             action.triggered.connect(action_fun)
         return action
 
+    def update_recent_files(self):
+        self.recent_files_menu.clear()
+        recent_files = self._recent_file_manager.get_files_with_display_names()
+        for file_path, display_name in recent_files.items():
+            action = self.recent_files_menu.addAction(display_name)
+            action.setData(file_path)
+            action.triggered.connect(partial(self.open_file_requested.emit, file_path))
+        self.recent_files_menu.setEnabled(len(recent_files) > 0)
+
+    def add_recent_file(self, file_path):
+        self._recent_file_manager.add_file(file_path)
+        self.update_recent_files()
+
     def add_file_menu(self):
         menu = self.menubar.addMenu("&File")
-        for name in ["&New...", "&Open...", "&Close"]:
+        for name in ["&New...", "&Open..."]:
             menu.addAction(self.action(name))
+        self.recent_files_menu = QMenu("Open &Recent", menu)
+        menu.addMenu(self.recent_files_menu)
+        self.update_recent_files()
+        menu.addAction(self.action("&Close"))
         menu.addSeparator()
         self.save_action = self.action("&Save")
         menu.addAction(self.save_action)

shinestacker/gui/project_controller.py

@@ -20,6 +20,7 @@ class ProjectController(QObject):
     activate_window_requested = Signal()
     enable_save_actions_requested = Signal(bool)
     enable_sub_actions_requested = Signal(bool)
+    add_recent_file_requested = Signal(str)
 
     def __init__(self, parent):
         super().__init__(parent)
@@ -242,6 +243,7 @@ class ProjectController(QObject):
                 self.parent, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             try:
+                abs_file_path = os.path.abspath(file_path)
                 self.set_current_file_path(file_path)
                 with open(self.current_file_path(), 'r', encoding="utf-8") as file:
                     json_obj = json.load(file)
@@ -250,6 +252,7 @@ class ProjectController(QObject):
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_project(project)
                 self.mark_as_modified(False)
+                self.add_recent_file_requested.emit(abs_file_path)
                 self.project_editor.reset_undo()
                 self.refresh_ui(0, -1)
                 if self.job_list_count() > 0:
@@ -311,6 +314,7 @@ class ProjectController(QObject):
                 f.write(json_obj)
             self.mark_as_modified(False)
             self.update_title_requested.emit()
+            self.add_recent_file_requested.emit(file_path)
         except Exception as e:
             QMessageBox.critical(self.parent, "Error", f"Cannot save file:\n{str(e)}")
 

shinestacker/gui/recent_file_manager.py

@@ -0,0 +1,93 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+import os
+from PySide6.QtCore import QStandardPaths
+
+
+class RecentFileManager:
+    def __init__(self, filename, max_entries=10):
+        self.filename = filename
+        self.max_entries = max_entries
+        self._config_dir = None
+
+    def get_config_dir(self):
+        if self._config_dir is None:
+            config_dir = QStandardPaths.writableLocation(QStandardPaths.AppConfigLocation)
+            if not config_dir:
+                if os.name == 'nt':  # Windows
+                    config_dir = os.path.join(os.environ.get('APPDATA', ''), 'ShineStacker')
+                elif os.name == 'posix':  # macOS and Linux
+                    config_dir = os.path.expanduser('~/.config/shinestacker')
+                else:
+                    config_dir = os.path.join(os.path.expanduser('~'), '.shinestacker')
+            os.makedirs(config_dir, exist_ok=True)
+            self._config_dir = config_dir
+        return self._config_dir
+
+    def get_file_path(self):
+        return os.path.join(self.get_config_dir(), self.filename)
+
+    def get_files(self):
+        file_path = self.get_file_path()
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                files = [line.strip() for line in f.readlines()]
+                return [f for f in files if f and os.path.exists(f)]
+        except (FileNotFoundError, IOError):
+            return []
+
+    def get_files_with_display_names(self):
+        files = self.get_files()
+        basename_count = {}
+        for file_path in files:
+            basename = os.path.basename(file_path)
+            basename_count[basename] = basename_count.get(basename, 0) + 1
+        result = {}
+        for file_path in files:
+            basename = os.path.basename(file_path)
+            if basename_count[basename] == 1:
+                result[file_path] = basename
+            else:
+                parent_dir = os.path.basename(os.path.dirname(file_path))
+                result[file_path] = f"{basename} ({parent_dir})"
+                if list(result.values()).count(result[file_path]) > 1:
+                    path_components = file_path.split(os.sep)
+                    for i in range(2, min(5, len(path_components))):
+                        display_name = os.sep.join(path_components[-i:])
+                        if sum(1 for f in files
+                                if os.sep.join(os.path.normpath(f).split(os.sep)[-i:]) ==
+                                display_name) == 1:
+                            result[file_path] = display_name
+                            break
+                    else:
+                        if len(file_path) > 50:
+                            result[file_path] = "..." + file_path[-47:]
+                        else:
+                            result[file_path] = file_path
+        return result
+
+    def add_file(self, file_path):
+        file_path = os.path.abspath(file_path)
+        recent_files = self.get_files()
+        if file_path in recent_files:
+            recent_files.remove(file_path)
+        recent_files.insert(0, file_path)
+        recent_files = recent_files[:self.max_entries]
+        self._save_files(recent_files)
+
+    def remove_file(self, file_path):
+        file_path = os.path.normpath(file_path)
+        recent_files = self.get_files()
+        if file_path in recent_files:
+            recent_files.remove(file_path)
+        self._save_files(recent_files)
+
+    def _save_files(self, files):
+        file_path = self.get_file_path()
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write('\n'.join(files))
+        except IOError as e:
+            raise e
+
+    def clear(self):
+        self._save_files([])

shinestacker/retouch/base_filter.py

@@ -34,7 +34,6 @@ class BaseFilter(ABC):
     def run_with_preview(self, **kwargs):
         if self.editor.has_no_master_layer():
             return
-
         self.editor.copy_master_layer()
         dlg = QDialog(self.editor)
         layout = QVBoxLayout(dlg)
@@ -48,7 +47,7 @@ class BaseFilter(ABC):
             nonlocal active_worker, dialog_closed  # noqa
             dialog_closed = True
             self.editor.restore_master_layer()
-            self.editor.display_manager.display_master_layer()
+            self.editor.image_viewer.update_master_display()
             if active_worker and active_worker.isRunning():
                 active_worker.wait()
             initial_timer.stop()
@@ -62,10 +61,10 @@ class BaseFilter(ABC):
                 current_region = self.editor.image_viewer.get_visible_image_portion()[1]
                 if current_region == region:
                     self.editor.set_master_layer(img)
-                    self.editor.display_manager.display_master_layer()
+                    self.editor.image_viewer.update_master_display()
             else:
                 self.editor.set_master_layer(img)
-                self.editor.display_manager.display_master_layer()
+                self.editor.image_viewer.update_master_display()
             try:
                 dlg.activateWindow()
             except Exception:
@@ -125,7 +124,7 @@ class BaseFilter(ABC):
 
         def restore_original():
             self.editor.restore_master_layer()
-            self.editor.display_manager.display_master_layer()
+            self.editor.image_viewer.update_master_display()
             try:
                 dlg.activateWindow()
             except Exception:
@@ -143,19 +142,18 @@ class BaseFilter(ABC):
                 h, w = self.editor.master_layer().shape[:2]
             except Exception:
                 h, w = self.editor.master_layer_copy().shape[:2]
-            if hasattr(self.editor, "undo_manager"):
-                try:
-                    self.editor.undo_manager.extend_undo_area(0, 0, w, h)
-                    self.editor.undo_manager.save_undo_state(
-                        self.editor.master_layer_copy(),
-                        self.name
-                    )
-                except Exception:
-                    pass
+            try:
+                self.editor.undo_manager.extend_undo_area(0, 0, w, h)
+                self.editor.undo_manager.save_undo_state(
+                    self.editor.master_layer_copy(),
+                    self.name
+                )
+            except Exception:
+                pass
             final_img = self.apply(self.editor.master_layer_copy(), *params)
             self.editor.set_master_layer(final_img)
             self.editor.copy_master_layer()
-            self.editor.display_manager.display_master_layer()
+            self.editor.image_viewer.update_master_display()
             self.editor.display_manager.update_master_thumbnail()
             self.editor.mark_as_modified()
         else:

shinestacker/retouch/brush_preview.py

@@ -41,6 +41,7 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
         self.setVisible(False)
         self.setZValue(500)
         self.setTransformationMode(Qt.SmoothTransformation)
+        self.brush = None
 
     def get_layer_area(self, layer, x, y, w, h):
         if not isinstance(layer, np.ndarray):
@@ -64,6 +65,8 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
         raise RuntimeError("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
 
     def update(self, scene_pos, size):
+        if self.brush is None:
+            return
         try:
             if self.layer_collection is None or self.number_of_layers() == 0 or size <= 0:
                 self.hide()
@@ -110,7 +113,6 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
             self.setPixmap(final_pixmap)
             x_start, y_start = max(0, x), max(0, y)
             self.setPos(x_start, y_start)
-            self.show()
         except Exception:
             traceback.print_exc()
             self.hide()

shinestacker/retouch/brush_tool.py

@@ -12,7 +12,7 @@ from .brush_preview import create_brush_mask
 class BrushTool:
     def __init__(self):
         self.brush = None
-        self.brush_preview = None
+        self.brush_preview_widget = None
         self.image_viewer = None
         self.size_slider = None
         self.hardness_slider = None
@@ -21,11 +21,11 @@ class BrushTool:
         self._brush_mask_cache = {}
         self.brush_text = None
 
-    def setup_ui(self, brush, brush_preview, image_viewer, size_slider, hardness_slider,
+    def setup_ui(self, brush, brush_preview_widget, image_viewer, size_slider, hardness_slider,
                  opacity_slider, flow_slider):
         self.brush = brush
-        self.brush_preview = brush_preview
-        self.brush_text = QLabel(brush_preview.parent())
+        self.brush_preview_widget = brush_preview_widget
+        self.brush_text = QLabel(brush_preview_widget.parent())
         self.brush_text.setStyleSheet("color: navy; background: transparent;")
         self.brush_text.setAlignment(Qt.AlignLeft | Qt.AlignTop)
         self.brush_text.raise_()
@@ -96,13 +96,13 @@ class BrushTool:
         preview_size = min(self.brush.size, width + 30, height + 30)
         center_x, center_y = width // 2, height // 2
         radius = preview_size // 2
-        if self.image_viewer.cursor_style == 'preview':
+        if self.image_viewer.strategy.cursor_style == 'preview':
             gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
             painter.setBrush(QBrush(gradient))
             painter.setPen(
                 QPen(QColor(*gui_constants.BRUSH_COLORS['outer']),
                      gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
-        elif self.image_viewer.cursor_style == 'outline':
+        elif self.image_viewer.strategy.cursor_style == 'outline':
             painter.setBrush(Qt.NoBrush)
             painter.setPen(
                 QPen(QColor(*gui_constants.BRUSH_COLORS['outer']),
@@ -113,7 +113,7 @@ class BrushTool:
                 QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
                      gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
         painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
-        if self.image_viewer.cursor_style == 'preview':
+        if self.image_viewer.strategy.cursor_style == 'preview':
             painter.setPen(QPen(QColor(0, 0, 160)))
             font = QApplication.font()
             painter.setFont(font)
@@ -126,13 +126,13 @@ class BrushTool:
                 f"Flow: {self.brush.flow}%"
             )
             self.brush_text.adjustSize()
-            self.brush_text.move(10, self.brush_preview.height() // 2 + 125)
+            self.brush_text.move(10, self.brush_preview_widget.height() // 2 + 125)
             self.brush_text.show()
         else:
             self.brush_text.hide()
         painter.end()
-        self.brush_preview.setPixmap(pixmap)
-        self.image_viewer.update_brush_cursor()
+        self.brush_preview_widget.setPixmap(pixmap)
+        self.image_viewer.strategy.update_brush_cursor()
 
     def apply_brush_operation(self, master_layer, source_layer, dest_layer, mask_layer,
                               view_pos):
@@ -140,7 +140,7 @@ class BrushTool:
             return False
         if dest_layer is None:
             dest_layer = master_layer
-        scene_pos = self.image_viewer.mapToScene(view_pos)
+        scene_pos = self.image_viewer.strategy.map_to_scene(view_pos)
         x_center = int(round(scene_pos.x()))
         y_center = int(round(scene_pos.y()))
         radius = int(round(self.brush.size // 2))

shinestacker/retouch/display_manager.py

@@ -25,7 +25,6 @@ class ClickableLabel(QLabel):
 
 class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
-    cursor_preview_state_changed = Signal(bool)
 
     def __init__(self, layer_collection, image_viewer, master_thumbnail_label,
                  thumbnail_list, parent=None):
@@ -35,7 +34,6 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.master_thumbnail_label = master_thumbnail_label
         self.thumbnail_list = thumbnail_list
         self.view_mode = 'master'
-        self.temp_view_individual = False
         self.needs_update = False
         self.update_timer = QTimer()
         self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
@@ -44,29 +42,13 @@ class DisplayManager(QObject, LayerCollectionHandler):
 
     def process_pending_updates(self):
         if self.needs_update:
-            self.display_master_layer()
+            self.refresh_master_view()
             self.needs_update = False
 
-    def display_image(self, img):
-        if img is None:
-            self.image_viewer.clear_image()
-        else:
-            self.image_viewer.set_image(self.numpy_to_qimage(img))
-
-    def display_current_layer(self):
-        self.display_image(self.current_layer())
-
-    def display_master_layer(self):
-        self.display_image(self.master_layer())
-
-    def display_current_view(self):
-        if self.temp_view_individual or self.view_mode == 'individual':
-            self.display_current_layer()
-        else:
-            self.display_master_layer()
-
     def create_thumbnail(self, layer):
         source_layer = (layer // 256).astype(np.uint8) if layer.dtype == np.uint16 else layer
+        if not source_layer.flags.c_contiguous:
+            source_layer = np.ascontiguousarray(source_layer)
         height, width = source_layer.shape[:2]
         if layer.ndim == 3 and source_layer.shape[-1] == 3:
             qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
@@ -162,59 +144,61 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.thumbnail_list.scrollToItem(
             self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
 
+    def _master_refresh_and_thumb(self):
+        self.image_viewer.show_master()
+        self.refresh_master_view()
+        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
+
+    def _current_refresh_and_thumb(self):
+        self.image_viewer.show_current()
+        self.refresh_current_view()
+        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
+        self.highlight_thumbnail(self.current_layer_idx())
+
     def set_view_master(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'master'
-        self.temp_view_individual = False
-        self.display_master_layer()
-        self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self._master_refresh_and_thumb()
         self.status_message_requested.emit("View mode: Master")
-        self.cursor_preview_state_changed.emit(True)  # True = allow preview
 
     def set_view_individual(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'individual'
-        self.temp_view_individual = False
-        self.display_current_layer()
-        self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
-        self.highlight_thumbnail(self.current_layer_idx())
+        self._current_refresh_and_thumb()
         self.status_message_requested.emit("View mode: Individual layers")
-        self.cursor_preview_state_changed.emit(False)  # False = no preview
+
+    def refresh_master_view(self):
+        if self.has_no_master_layer():
+            return
+        self.image_viewer.update_master_display()
+        self.image_viewer.refresh_display()
+        self.update_master_thumbnail()
+
+    def refresh_current_view(self):
+        if self.number_of_layers() == 0:
+            return
+        self.image_viewer.update_current_display()
+        self.image_viewer.refresh_display()
 
     def start_temp_view(self):
-        if not self.temp_view_individual and self.view_mode == 'master':
-            self.temp_view_individual = True
-            self.image_viewer.update_brush_cursor()
-            self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
-            self.highlight_thumbnail(self.current_layer_idx())
-            self.display_current_layer()
-            self.status_message_requested.emit("Temporary view: Individual layer (hold X)")
+        if self.view_mode == 'master':
+            self._current_refresh_and_thumb()
+            self.status_message_requested.emit("Temporary view: Individual layer")
+        else:
+            self._master_refresh_and_thumb()
+            self.image_viewer.strategy.brush_preview.hide()
+            self.status_message_requested.emit("Temporary view: Master")
 
     def end_temp_view(self):
-        if self.temp_view_individual:
-            self.temp_view_individual = False
-            self.image_viewer.update_brush_cursor()
-            self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
-            self.highlight_thumbnail(self.current_layer_idx())
-            self.display_master_layer()
+        if self.view_mode == 'master':
+            self._master_refresh_and_thumb()
             self.status_message_requested.emit("View mode: Master")
-            self.cursor_preview_state_changed.emit(True)  # Restore preview
-
-    def numpy_to_qimage(self, array):
-        if array.dtype == np.uint16:
-            array = np.right_shift(array, 8).astype(np.uint8)
-        if array.ndim == 2:
-            height, width = array.shape
-            return QImage(memoryview(array), width, height, width, QImage.Format_Grayscale8)
-        if array.ndim == 3:
-            height, width, _ = array.shape
-            if not array.flags['C_CONTIGUOUS']:
-                array = np.ascontiguousarray(array)
-            return QImage(memoryview(array), width, height, 3 * width, QImage.Format_RGB888)
-        return QImage()
+        else:
+            self._current_refresh_and_thumb()
+            self.status_message_requested.emit("View: Individual layer")
 
     def allow_cursor_preview(self):
-        return self.view_mode == 'master' and not self.temp_view_individual
+        return self.view_mode == 'master'