shinestacker 1.5.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

shinestacker/gui/action_config_dialog.py

@@ -2,87 +2,29 @@
 # pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302
 import os
 import traceback
-from PySide6.QtCore import Qt, QTimer
-from PySide6.QtWidgets import (QWidget, QPushButton, QHBoxLayout, QLabel, QScrollArea, QMessageBox,
-                               QStackedWidget, QFormLayout, QDialog)
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QWidget, QLabel, QMessageBox, QStackedWidget
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.align import validate_align_config
-from .base_form_dialog import create_form_layout
 from . action_config import (
     DefaultActionConfigurator,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
 from .folder_file_selection import FolderFileSelectionWidget
+from .config_dialog import ConfigDialog
 
 
-class ActionConfigDialog(QDialog):
+class ActionConfigDialog(ConfigDialog):
     def __init__(self, action, current_wd, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle(f"Configure {action.type_name}")
-        self.form_layout = create_form_layout(self)
-        self.current_wd = current_wd
         self.action = action
-        scroll_area = QScrollArea()
-        scroll_area.setWidgetResizable(True)
-        container_widget = QWidget()
-        self.container_layout = QFormLayout(container_widget)
-        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        self.container_layout.setLabelAlignment(Qt.AlignLeft)
-        self.configurator = self.get_configurator(action.type_name)
-        self.configurator.create_form(self.container_layout, action)
-        scroll_area.setWidget(container_widget)
-        button_box = QHBoxLayout()
-        ok_button = QPushButton("OK")
-        ok_button.setFocus()
-        cancel_button = QPushButton("Cancel")
-        reset_button = QPushButton("Reset")
-        button_box.addWidget(ok_button)
-        button_box.addWidget(cancel_button)
-        button_box.addWidget(reset_button)
-        reset_button.clicked.connect(self.reset_to_defaults)
-        self.form_layout.addRow(scroll_area)
-        self.form_layout.addRow(button_box)
-        QTimer.singleShot(0, self.adjust_dialog_size)
-        ok_button.clicked.connect(self.accept)
-        cancel_button.clicked.connect(self.reject)
-
-    def adjust_dialog_size(self):
-        screen_geometry = self.screen().availableGeometry()
-        screen_height = screen_geometry.height()
-        screen_width = screen_geometry.width()
-        scroll_area = self.findChild(QScrollArea)
-        container_widget = scroll_area.widget()
-        container_size = container_widget.sizeHint()
-        container_height = container_size.height()
-        container_width = container_size.width()
-        button_row_height = 50  # Approx height of button row
-        margins_height = 40  # Approx. height of margins
-        total_height_needed = container_height + button_row_height + margins_height
-        if total_height_needed < screen_height * 0.8:
-            width = max(container_width + 40, 600)
-            height = total_height_needed
-            self.resize(width, height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        else:
-            max_height = int(screen_height * 0.9)
-            width = max(container_width + 40, 600)
-            width = min(width, int(screen_width * 0.9))
-            self.resize(width, max_height)
-            self.setMaximumHeight(max_height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-            self.setMinimumHeight(min(max_height, 500))
-            self.setMinimumWidth(width)
-        self.center_on_screen()
-
-    def center_on_screen(self):
-        screen_geometry = self.screen().availableGeometry()
-        center_point = screen_geometry.center()
-        frame_geometry = self.frameGeometry()
-        frame_geometry.moveCenter(center_point)
-        self.move(frame_geometry.topLeft())
+        self.current_wd = current_wd
+        super().__init__(f"Configure {action.type_name}", parent)
+
+    def create_form_content(self):
+        self.configurator = self.get_configurator(self.action.type_name)
+        self.configurator.create_form(self.container_layout, self.action)
 
     def get_configurator(self, action_type):
         configurators = {
@@ -102,7 +44,8 @@ class ActionConfigDialog(QDialog):
 
     def accept(self):
         if self.configurator.update_params(self.action.params):
-            self.parent().mark_as_modified(True, "Modify Configuration")
+            if hasattr(self.parent(), 'mark_as_modified'):
+                self.parent().mark_as_modified(True, "Modify Configuration")
             super().accept()
 
     def reset_to_defaults(self):
@@ -111,7 +54,7 @@ class ActionConfigDialog(QDialog):
             builder.reset_to_defaults()
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
 
 class JobConfigurator(DefaultActionConfigurator):
@@ -329,7 +272,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
         max_threads = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_max_threads', FIELD_INT, 'Max num. of cores',
             expert=True,
-            required=False, default=constants.DEFAULT_PY_MAX_THREADS,
+            required=False, default=AppConfig.get('focus_stack_params')['max_threads'],
             min_val=1, max_val=64)
         tile_size = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_tile_size', FIELD_INT, 'Tile size (px)',
@@ -490,7 +433,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             default=True)
         self.add_field(
             'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_MAX_FWK_THREADS,
+            required=False, default=AppConfig.get('combined_actions_params')['max_threads'],
             expert=True,
             min_val=1, max_val=64)
         self.add_field(
@@ -757,7 +700,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             layout, 'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_ALIGN_MAX_THREADS,
+            required=False, default=AppConfig.get('align_frames_params')['max_threads'],
             min_val=1, max_val=64)
         chunk_submit = self.add_field_to_layout(
             layout, 'chunk_submit', FIELD_BOOL, 'Submit in chunks',

shinestacker/gui/config_dialog.py

@@ -0,0 +1,78 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+from abc import abstractmethod
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import QWidget, QPushButton, QHBoxLayout, QScrollArea, QFormLayout, QDialog
+from .base_form_dialog import create_form_layout
+
+
+class ConfigDialog(QDialog):
+    def __init__(self, title, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.form_layout = create_form_layout(self)
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        container_widget = QWidget()
+        self.container_layout = QFormLayout(container_widget)
+        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.container_layout.setLabelAlignment(Qt.AlignLeft)
+        scroll_area.setWidget(container_widget)
+        button_box = QHBoxLayout()
+        self.ok_button = QPushButton("OK")
+        self.ok_button.setFocus()
+        self.cancel_button = QPushButton("Cancel")
+        self.reset_button = QPushButton("Reset")
+        button_box.addWidget(self.ok_button)
+        button_box.addWidget(self.cancel_button)
+        button_box.addWidget(self.reset_button)
+        self.reset_button.clicked.connect(self.reset_to_defaults)
+        self.ok_button.clicked.connect(self.accept)
+        self.cancel_button.clicked.connect(self.reject)
+        self.form_layout.addRow(scroll_area)
+        self.form_layout.addRow(button_box)
+        QTimer.singleShot(0, self.adjust_dialog_size)
+        self.create_form_content()
+
+    @abstractmethod
+    def create_form_content(self):
+        pass
+
+    def adjust_dialog_size(self):
+        screen_geometry = self.screen().availableGeometry()
+        screen_height = screen_geometry.height()
+        screen_width = screen_geometry.width()
+        scroll_area = self.findChild(QScrollArea)
+        container_widget = scroll_area.widget()
+        container_size = container_widget.sizeHint()
+        container_height = container_size.height()
+        container_width = container_size.width()
+        button_row_height = 50  # Approx height of button row
+        margins_height = 40  # Approx. height of margins
+        total_height_needed = container_height + button_row_height + margins_height
+        if total_height_needed < screen_height * 0.8:
+            width = max(container_width + 40, 600)
+            height = total_height_needed
+            self.resize(width, height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        else:
+            max_height = int(screen_height * 0.9)
+            width = max(container_width + 40, 600)
+            width = min(width, int(screen_width * 0.9))
+            self.resize(width, max_height)
+            self.setMaximumHeight(max_height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setMinimumHeight(min(max_height, 500))
+            self.setMinimumWidth(width)
+        self.center_on_screen()
+
+    def center_on_screen(self):
+        screen_geometry = self.screen().availableGeometry()
+        center_point = screen_geometry.center()
+        frame_geometry = self.frameGeometry()
+        frame_geometry.moveCenter(center_point)
+        self.move(frame_geometry.topLeft())
+
+    def reset_to_defaults(self):
+        pass

shinestacker/gui/main_window.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QGuiApplication, QAction, QIcon
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
                                QSplitter, QToolBar, QMenu, QMainWindow)
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. core.core_utils import running_under_windows, running_under_macos
 from .colors import ColorPalette
 from .project_model import Project
@@ -86,7 +87,6 @@ class MainWindow(QMainWindow, LogManager):
         self._windows = []
         self._workers = []
         self.retouch_callback = None
-        self.expert_options = False
         self.job_list().setStyleSheet(LIST_STYLE_SHEET)
         self.action_list().setStyleSheet(LIST_STYLE_SHEET)
         self.menu_manager.add_menus()
@@ -154,9 +154,14 @@ class MainWindow(QMainWindow, LogManager):
             self.menu_manager.set_enabled_sub_actions_gui)
         self.project_controller.add_recent_file_requested.connect(
             self.menu_manager.add_recent_file)
+        self.project_controller.set_enabled_file_open_close_actions_requested.connect(
+            self.set_enabled_file_open_close_actions)
+
         self.menu_manager.open_file_requested.connect(
             self.project_controller.open_project)
 
+        self.set_enabled_file_open_close_actions(False)
+
     def modified(self):
         return self.project_editor.modified()
 
@@ -436,12 +441,12 @@ class MainWindow(QMainWindow, LogManager):
             return True
         return False
 
-    def toggle_expert_options(self):
-        self.expert_options = self.menu_manager.expert_options_action.isChecked()
+    def handle_config(self):
+        self.menu_manager.expert_options_action.setChecked(
+            AppConfig.get('expert_options'))
 
-    def set_expert_options(self):
-        self.menu_manager.expert_options_action.setChecked(True)
-        self.expert_options = True
+    def toggle_expert_options(self):
+        AppConfig.set('expert_options', self.menu_manager.expert_options_action.isChecked())
 
     def before_thread_begins(self):
         self.menu_manager.run_job_action.setEnabled(False)
@@ -571,3 +576,8 @@ class MainWindow(QMainWindow, LogManager):
                 self.menu_manager.set_enabled_sub_actions_gui(enable_sub_actions)
         else:
             self.menu_manager.set_enabled_sub_actions_gui(False)
+
+    def set_enabled_file_open_close_actions(self, enabled):
+        for action in self.findChildren(QAction):
+            if action.property("requires_file"):
+                action.setEnabled(enabled)

shinestacker/gui/menu_manager.py

@@ -5,6 +5,7 @@ from PySide6.QtCore import Signal, QObject
 from PySide6.QtGui import QAction, QIcon
 from PySide6.QtWidgets import QMenu, QComboBox
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .recent_file_manager import RecentFileManager
 
 
@@ -60,8 +61,10 @@ class MenuManager(QObject):
     def get_icon(self, icon):
         return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
 
-    def action(self, name):
+    def action(self, name, requires_file=False):
         action = QAction(name, self.parent)
+        if requires_file:
+            action.setProperty("requires_file", True)
         shortcut = self.shortcuts.get(name, '')
         if shortcut:
             action.setShortcut(shortcut)
@@ -110,36 +113,37 @@ class MenuManager(QObject):
         self.undo_action.setEnabled(False)
         menu.addAction(self.undo_action)
         for name in ["&Cut", "Cop&y", "&Paste", "Duplicate"]:
-            menu.addAction(self.action(name))
-        self.delete_element_action = self.action("Delete")
+            menu.addAction(self.action(name, requires_file=True))
+        self.delete_element_action = self.action("Delete", requires_file=True)
         self.delete_element_action.setEnabled(False)
         menu.addAction(self.delete_element_action)
         menu.addSeparator()
         for name in ["Move &Up", "Move &Down"]:
-            menu.addAction(self.action(name))
+            menu.addAction(self.action(name, requires_file=True))
         menu.addSeparator()
-        self.enable_action = self.action("E&nable")
+        self.enable_action = self.action("E&nable", requires_file=True)
         menu.addAction(self.enable_action)
-        self.disable_action = self.action("Di&sable")
+        self.disable_action = self.action("Di&sable", requires_file=True)
         menu.addAction(self.disable_action)
         for name in ["Enable All", "Disable All"]:
-            menu.addAction(self.action(name))
+            menu.addAction(self.action(name, requires_file=True))
 
     def add_view_menu(self):
         menu = self.menubar.addMenu("&View")
         self.expert_options_action = self.action("Expert Options")
         self.expert_options_action.setCheckable(True)
+        self.expert_options_action.setChecked(AppConfig.get('expert_options'))
         menu.addAction(self.expert_options_action)
 
     def add_job_menu(self):
         menu = self.menubar.addMenu("&Jobs")
-        self.add_job_action = self.action("Add Job")
+        self.add_job_action = self.action("Add Job", requires_file=True)
         menu.addAction(self.add_job_action)
         menu.addSeparator()
-        self.run_job_action = self.action("Run Job")
+        self.run_job_action = self.action("Run Job", requires_file=True)
         self.run_job_action.setEnabled(False)
         menu.addAction(self.run_job_action)
-        self.run_all_jobs_action = self.action("Run All Jobs")
+        self.run_all_jobs_action = self.action("Run All Jobs", requires_file=True)
         self.set_enabled_run_all_jobs(False)
         menu.addAction(self.run_all_jobs_action)
 
@@ -148,6 +152,7 @@ class MenuManager(QObject):
         add_action_menu = QMenu("Add Action", self.parent)
         for action in constants.ACTION_TYPES:
             entry_action = QAction(action, self.parent)
+            entry_action.setProperty("requires_file", True)
             entry_action.triggered.connect({
                 constants.ACTION_COMBO: self.add_action_combined_actions,
                 constants.ACTION_NOISEDETECTION: self.add_action_noise_detection,
@@ -161,6 +166,7 @@ class MenuManager(QObject):
         self.sub_action_menu_entries = []
         for action in constants.SUB_ACTION_TYPES:
             entry_action = QAction(action, self.parent)
+            entry_action.setProperty("requires_file", True)
             entry_action.triggered.connect({
                 constants.ACTION_MASKNOISE: self.add_sub_action_make_noise,
                 constants.ACTION_VIGNETTING: self.add_sub_action_vignetting,

shinestacker/gui/new_project.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.utils import read_img, extension_tif_jpg
 from .. algorithms.stack import get_bunches
 from .folder_file_selection import FolderFileSelectionWidget
@@ -31,7 +32,7 @@ class NewProjectDialog(BaseFormDialog):
         self.selected_filenames = []
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
     def add_bold_label(self, label):
         label = QLabel(label)

shinestacker/gui/project_controller.py

@@ -21,6 +21,7 @@ class ProjectController(QObject):
     enable_save_actions_requested = Signal(bool)
     enable_sub_actions_requested = Signal(bool)
     add_recent_file_requested = Signal(str)
+    set_enabled_file_open_close_actions_requested = Signal(bool)
 
     def __init__(self, parent):
         super().__init__(parent)
@@ -138,6 +139,7 @@ class ProjectController(QObject):
             self.clear_action_list()
             self.mark_as_modified(False)
             self.project_editor.reset_undo()
+            self.set_enabled_file_open_close_actions_requested.emit(False)
 
     def new_project(self):
         if not self.check_unsaved_changes():
@@ -153,9 +155,9 @@ class ProjectController(QObject):
         if dialog.exec() == QDialog.Accepted:
             self.save_actions_set_enabled(True)
             self.project_editor.reset_undo()
-            input_folder = dialog.get_input_folder().split('/')
-            working_path = '/'.join(input_folder[:-1])
-            input_path = input_folder[-1]
+            input_folder = dialog.get_input_folder()
+            working_path = os.path.dirname(input_folder)
+            input_path = os.path.basename(input_folder)
             selected_filenames = dialog.get_selected_filenames()
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
@@ -208,13 +210,15 @@ class ProjectController(QObject):
                 focus_pyramid_name = f'{input_path}-focus-stack-pyramid'
                 focus_pyramid = ActionConfig(constants.ACTION_FOCUSSTACK,
                                              {'name': focus_pyramid_name,
-                                              'stacker': constants.STACK_ALGO_PYRAMID})
+                                              'stacker': constants.STACK_ALGO_PYRAMID,
+                                              'exif_path': input_path})
                 job.add_sub_action(focus_pyramid)
             if dialog.get_focus_stack_depth_map():
                 focus_depth_map_name = f'{input_path}-focus-stack-depth-map'
                 focus_depth_map = ActionConfig(constants.ACTION_FOCUSSTACK,
                                                {'name': focus_depth_map_name,
-                                                'stacker': constants.STACK_ALGO_DEPTH_MAP})
+                                                'stacker': constants.STACK_ALGO_DEPTH_MAP,
+                                                'exif_path': input_path})
                 job.add_sub_action(focus_depth_map)
             if dialog.get_multi_layer():
                 multi_input_path = []
@@ -229,7 +233,7 @@ class ProjectController(QObject):
                 multi_layer = ActionConfig(
                     constants.ACTION_MULTILAYER,
                     {'name': f'{input_path}-multi-layer',
-                        'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
+                     'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
                 job.add_sub_action(multi_layer)
             self.add_job_to_project(job)
             self.project_editor.set_modified(True)
@@ -250,6 +254,7 @@ class ProjectController(QObject):
                 project = Project.from_dict(json_obj['project'])
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
+                self.set_enabled_file_open_close_actions_requested.emit(True)
                 self.set_project(project)
                 self.mark_as_modified(False)
                 self.add_recent_file_requested.emit(abs_file_path)

shinestacker/gui/project_model.py

@@ -1,12 +1,27 @@
 # pylint: disable=C0114, C0115, C0116, R0911
 from copy import deepcopy
 from .. config.constants import constants
+from .. config.app_config import AppConfig
+
+
+TYPE_NAME_APP_CONFIG_MAP = {
+    constants.ACTION_COMBO: 'combined_actions_params',
+    constants.ACTION_ALIGNFRAMES: 'align_frames_params',
+    constants.ACTION_FOCUSSTACK: 'focus_stack_params',
+    constants.ACTION_FOCUSSTACKBUNCH: 'focus_stack_bunch_params'
+}
 
 
 class ActionConfig:
     def __init__(self, type_name: str, params=None, parent=None):
         self.type_name = type_name
-        self.params = params or {}
+        app_config_params_key = TYPE_NAME_APP_CONFIG_MAP.get(type_name, '')
+        if app_config_params_key != '':
+            self.params = AppConfig.get(app_config_params_key, {})
+        else:
+            self.params = {}
+        if params:
+            self.params = {**self.params, **params}
         self.parent = parent
         self.sub_actions: list[ActionConfig] = []
 

shinestacker/gui/recent_file_manager.py

@@ -1,30 +1,12 @@
 # pylint: disable=C0114, C0115, C0116, E0611
 import os
-from PySide6.QtCore import QStandardPaths
+from .. config.settings import StdPathFile
 
 
-class RecentFileManager:
+class RecentFileManager(StdPathFile):
     def __init__(self, filename, max_entries=10):
-        self.filename = filename
+        super().__init__(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()

shinestacker/retouch/display_manager.py

@@ -3,8 +3,9 @@ import numpy as np
 from PySide6.QtWidgets import (QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog,
                                QAbstractItemView)
 from PySide6.QtGui import QPixmap, QImage
-from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal
+from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal, QThread
 from .. config.gui_constants import gui_constants
+from .. config.app_config import AppConfig
 from .layer_collection import LayerCollectionHandler
 
 
@@ -23,6 +24,32 @@ class ClickableLabel(QLabel):
     # pylint: enable=C0103
 
 
+class ThumbnailWorker(QThread):
+    thumbnail_ready = Signal(object)
+
+    def __init__(self, layer_data):
+        super().__init__()
+        self.layer_data = layer_data
+
+    def run(self):
+        if self.layer_data is None:
+            self.thumbnail_ready.emit(None)
+            return
+        source_layer = (self.layer_data // 256).astype(np.uint8) \
+            if self.layer_data.dtype == np.uint16 else self.layer_data
+        if not source_layer.flags.c_contiguous:
+            source_layer = np.ascontiguousarray(source_layer)
+        height, width = source_layer.shape[:2]
+        if self.layer_data.ndim == 3 and source_layer.shape[-1] == 3:
+            qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
+        else:
+            qimg = QImage(source_layer.data, width, height, width, QImage.Format_Grayscale8)
+        thumbnail = QPixmap.fromImage(
+            qimg.scaledToWidth(
+                gui_constants.UI_SIZES['thumbnail_width'], Qt.SmoothTransformation))
+        self.thumbnail_ready.emit(thumbnail)
+
+
 class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
 
@@ -36,8 +63,10 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.view_mode = 'master'
         self.needs_update = False
         self.update_timer = QTimer()
-        self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
+        self.update_timer.setInterval(AppConfig.get('display_refresh_time'))
         self.update_timer.timeout.connect(self.process_pending_updates)
+        self.thumbnail_worker = None
+        self.thumbnail_update_pending = False
 
     def process_pending_updates(self):
         if self.needs_update:
@@ -77,7 +106,22 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if self.has_no_master_layer():
             self._clear_master_thumbnail()
         else:
-            self._set_master_thumbnail(self.create_thumbnail(self.master_layer()))
+            self._start_async_thumbnail_generation()
+
+    def _start_async_thumbnail_generation(self):
+        if self.thumbnail_worker and self.thumbnail_worker.isRunning():
+            self.thumbnail_update_pending = True
+            return
+        self.thumbnail_worker = ThumbnailWorker(self.master_layer())
+        self.thumbnail_worker.thumbnail_ready.connect(self._on_thumbnail_ready)
+        self.thumbnail_worker.start()
+
+    def _on_thumbnail_ready(self, thumbnail):
+        if thumbnail is not None:
+            self._set_master_thumbnail(thumbnail)
+        if self.thumbnail_update_pending:
+            self.thumbnail_update_pending = False
+            self._start_async_thumbnail_generation()
 
     def _clear_master_thumbnail(self):
         self.master_thumbnail_label.clear()
@@ -172,14 +216,12 @@ class DisplayManager(QObject, LayerCollectionHandler):
         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 self.view_mode == 'master':