shinestacker 0.2.0.post1.dev1__py3-none-any.whl

shinestacker/algorithms/vignetting.py

@@ -0,0 +1,137 @@
+import cv2
+import logging
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit, fsolve
+from .. core.colors import color_str
+from .. config.constants import constants
+from .utils import img_8bit, save_plot
+from .stack_framework import SubAction
+
+CLIP_EXP = 10
+
+
+class Vignetting(SubAction):
+    def __init__(self, enabled=True, percentiles=(0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95), **kwargs):
+        super().__init__(enabled)
+        self.r_steps = kwargs.get('r_steps', constants.DEFAULT_R_STEPS)
+        self.black_threshold = kwargs.get('black_threshold', constants.DEFAULT_BLACK_THRESHOLD)
+        self.apply_correction = kwargs.get('apply_correction', True)
+        self.plot_correction = kwargs.get('plot_correction', False)
+        self.plot_summary = kwargs.get('plot_summary', False)
+        self.max_correction = kwargs.get('max_correction', constants.DEFAULT_MAX_CORRECTION)
+        self.percentiles = np.sort(percentiles)
+
+    def radial_mean_intensity(self, image):
+        if len(image.shape) > 2:
+            raise ValueError("The image must be grayscale")
+        h, w = image.shape
+        self.w_2, self.h_2 = w / 2, h / 2
+        self.r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
+        radii = np.linspace(0, self.r_max, self.r_steps + 1)
+        mean_intensities = np.zeros(self.r_steps)
+        y, x = np.ogrid[:h, :w]
+        dist_from_center = np.sqrt((x - self.w_2)**2 + (y - self.h_2)**2)
+        for i in range(self.r_steps):
+            mask = (dist_from_center >= radii[i]) & (dist_from_center < radii[i + 1])
+            if np.any(mask):
+                mean_intensities[i] = np.mean(image[mask])
+            else:
+                mean_intensities[i] = np.nan
+        return (radii[1:] + radii[:-1]) / 2, mean_intensities
+
+    def sigmoid(r, i0, k, r0):
+        return i0 / (1.0 + np.exp(np.minimum(CLIP_EXP, np.exp(np.clip(k * (r - r0), -CLIP_EXP, CLIP_EXP)))))
+
+    def fit_sigmoid(self, radii, intensities):
+        valid_mask = ~np.isnan(intensities)
+        i_valid, r_valid = intensities[valid_mask], radii[valid_mask]
+        try:
+            res = curve_fit(Vignetting.sigmoid, r_valid, i_valid,
+                            p0=[np.max(i_valid), 0.01, np.median(r_valid)])[0]
+        except Exception:
+            self.process.sub_message(color_str(": could not find vignetting model", "red"), level=logging.WARNING)
+            res = None
+        return res
+
+    def correct_vignetting(self, image, params):
+        h, w = image.shape[:2]
+        y, x = np.ogrid[:h, :w]
+        r = np.sqrt((x - w / 2)**2 + (y - h / 2)**2)
+        vignette = np.clip(Vignetting.sigmoid(r, *params) / self.v0, 1e-6, 1)
+        if self.max_correction < 1:
+            vignette = (1.0 - self.max_correction) + vignette * self.max_correction
+        if len(image.shape) == 3:
+            vignette = vignette[:, :, np.newaxis]
+            vignette[np.min(image, axis=2) < self.black_threshold, :] = 1
+        else:
+            vignette[image < self.black_threshold] = 1
+        return np.clip(image / vignette, 0, 255 if image.dtype == np.uint8 else 65535).astype(image.dtype)
+
+    def run_frame(self, idx, ref_idx, img_0):
+        self.process.sub_message_r(color_str(": compute vignetting", "light_blue"))
+        img = cv2.cvtColor(img_8bit(img_0), cv2.COLOR_BGR2GRAY)
+        radii, intensities = self.radial_mean_intensity(img)
+        pars = self.fit_sigmoid(radii, intensities)
+        if pars is None:
+            return img_0
+        self.v0 = Vignetting.sigmoid(0, *pars)
+        i0_fit, k_fit, r0_fit = pars
+        self.process.sub_message(f": fit parameters: i0={i0_fit:.4f}, k={k_fit:.4f}, r0={r0_fit:.4f}",
+                                 level=logging.DEBUG)
+        if self.plot_correction:
+            plt.figure(figsize=(10, 5))
+            plt.plot(radii, intensities, label="image mean intensity")
+            plt.plot(radii, Vignetting.sigmoid(radii, *pars), label="sigmoid fit")
+            plt.xlabel('radius (pixels)')
+            plt.ylabel('mean intensity')
+            plt.legend()
+            plt.xlim(radii[0], radii[-1])
+            plt.ylim(0)
+            idx_str = "{:04d}".format(idx)
+            plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-radial-intensity-{idx_str}.pdf"
+            save_plot(plot_path)
+            plt.close('all')
+            self.process.callback('save_plot', self.process.id, f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
+        for i, p in enumerate(self.percentiles):
+            self.corrections[i][idx] = fsolve(lambda x: Vignetting.sigmoid(x, *pars) / self.v0 - p, r0_fit)[0]
+        if self.apply_correction:
+            self.process.sub_message_r(color_str(": correct vignetting", "light_blue"))
+            return self.correct_vignetting(img_0, pars)
+        else:
+            return img_0
+
+    def begin(self, process):
+        self.process = process
+        self.corrections = [np.full(self.process.counts, None, dtype=float) for p in self.percentiles]
+
+    def end(self):
+        if self.plot_summary:
+            plt.figure(figsize=(10, 5))
+            xs = np.arange(1, len(self.corrections[0]) + 1, dtype=int)
+            for i, p in enumerate(self.percentiles):
+                linestyle = 'solid'
+                if p == 0.5:
+                    linestyle = '-.'
+                elif i == 0 or i == len(self.percentiles) - 1:
+                    linestyle = 'dotted'
+                plt.plot(xs, self.corrections[i], label=f"{p:.0%} correction",
+                         linestyle=linestyle, color="blue")
+            plt.fill_between(xs, self.corrections[-1], self.corrections[0], color="#0000ff20")
+            iis = np.where(self.percentiles == 0.5)
+            if len(iis) > 0:
+                i = iis[0][0]
+                if i >= 1 and i < len(self.percentiles) - 1:
+                    plt.fill_between(xs, self.corrections[i - 1], self.corrections[i + 1], color="#0000ff20")
+            plt.plot(xs[[0, -1]], [self.r_max] * 2, linestyle="--", label="max. radius", color="darkred")
+            plt.plot(xs[[0, -1]], [self.w_2] * 2, linestyle="--", label="half width", color="limegreen")
+            plt.plot(xs[[0, -1]], [self.h_2] * 2, linestyle="--", label="half height", color="darkgreen")
+            plt.xlabel('frame')
+            plt.ylabel('distance from center (pixels)')
+            plt.legend(ncols=2)
+            plt.xlim(xs[0], xs[-1])
+            plt.ylim(0, self.r_max * 1.05)
+            plot_path = self.process.working_path + "/" + self.process.plot_path + "/" + self.process.name + "-r0.pdf"
+            save_plot(plot_path)
+            plt.close('all')
+            self.process.callback('save_plot', self.process.id, f"{self.process.name}: vignetting", plot_path)

shinestacker/app/about_dialog.py

@@ -0,0 +1,24 @@
+from PySide6.QtWidgets import QMessageBox
+from PySide6.QtCore import Qt
+from .. import __version__
+from .. config.constants import constants
+
+
+def show_about_dialog():
+    version_clean = __version__.split("+")[0]
+    about_text = f"""
+    <h3>{constants.APP_TITLE}</h3>
+    <h4>version: v{version_clean}</h4>
+    <p style='font-weight: normal;'>App and framework to combine multiple images
+    into a single focused image.</p>
+    <p>Author: Luca Lista<br/>
+    Email: <a href="mailto:luka.lista@gmail.com">luka.lista@gmail.com</a></p>
+    <p><a href="https://github.com/lucalista/shinestacker">GitHub homepage</a></p>
+    """
+    msg = QMessageBox()
+    msg.setWindowTitle(f"About {constants.APP_STRING}")
+    msg.setIcon(QMessageBox.Icon.Information)
+    msg.setTextFormat(Qt.TextFormat.RichText)
+    msg.setText(about_text)
+    msg.setIcon(QMessageBox.Icon.NoIcon)
+    msg.exec_()

shinestacker/app/app_config.py

@@ -0,0 +1,39 @@
+class _AppConfig:
+    _initialized = False
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._init_defaults()
+        return cls._instance
+
+    def _init_defaults(self):
+        self._DONT_USE_NATIVE_MENU = True
+        self._COMBINED_APP = False
+
+    def init(self, **kwargs):
+        if self._initialized:
+            raise RuntimeError("Config already initialized")
+        for k, v in kwargs.items():
+            if hasattr(self, f"_{k}"):
+                setattr(self, f"_{k}", v)
+            else:
+                raise AttributeError(f"Invalid config key: {k}")
+        self._initialized = True
+
+    @property
+    def DONT_USE_NATIVE_MENU(self):
+        return self._DONT_USE_NATIVE_MENU
+
+    @property
+    def COMBINED_APP(self):
+        return self._COMBINED_APP
+
+    def __setattr__(self, name, value):
+        if self._initialized and name.startswith('_'):
+            raise AttributeError("Can't change config after initialization")
+        super().__setattr__(name, value)
+
+
+app_config = _AppConfig()

shinestacker/app/gui_utils.py

@@ -0,0 +1,35 @@
+import os
+import sys
+from PySide6.QtCore import QCoreApplication, QProcess
+
+
+def disable_macos_special_menu_items():
+    if not (sys.platform == "darwin" and QCoreApplication.instance().platformName() == "cocoa"):
+        return
+    prefs = [
+        ("NSDisabledCharacterPaletteMenuItem", "YES"),
+        ("NSDisabledDictationMenuItem", "YES"),
+        ("NSDisabledInputMenu", "YES"),
+        ("NSDisabledServicesMenu", "YES"),
+        ("WebAutomaticTextReplacementEnabled", "NO"),
+        ("WebAutomaticSpellingCorrectionEnabled", "NO"),
+        ("WebContinuousSpellCheckingEnabled", "NO"),
+        ("NSTextReplacementEnabled", "NO"),
+        ("NSAllowCharacterPalette", "NO"),
+        ("NSDisabledHelpSearch", "YES"),
+        ("NSDisabledSpellingMenuItems", "YES"),
+        ("NSDisabledTextSubstitutionMenuItems", "YES"),
+        ("NSDisabledGrammarMenuItems", "YES"),
+        ("NSAutomaticPeriodSubstitutionEnabled", "NO"),
+        ("NSAutomaticQuoteSubstitutionEnabled", "NO"),
+        ("NSAutomaticDashSubstitutionEnabled", "NO"),
+        ("WebAutomaticFormCompletionEnabled", "NO"),
+        ("WebAutomaticPasswordAutoFillEnabled", "NO")
+    ]
+    for key, value in prefs:
+        QProcess.execute("defaults", ["write", "-g", key, "-bool", value])
+    QProcess.execute("defaults", ["write", "-g", "NSAutomaticTextCompletionEnabled", "-bool", "NO"])
+    user = os.getenv('USER') or os.getenv('LOGNAME')
+    if user:
+        QProcess.startDetached("pkill", ["-u", user, "-f", "cfprefsd"])
+        QProcess.startDetached("pkill", ["-u", user, "-f", "SystemUIServer"])

shinestacker/app/help_menu.py

@@ -0,0 +1,16 @@
+import webbrowser
+from PySide6.QtWidgets import QMenu
+from PySide6.QtGui import QAction
+
+
+def add_help_action(app):
+    help_menu = app.menuBar().findChild(QMenu, "Help")
+    if help_menu:
+        help_action = QAction("Online Help", app)
+        help_action.triggered.connect(browse_website)
+        help_menu.addSeparator()
+        help_menu.addAction(help_action)
+
+
+def browse_website():
+    webbrowser.open("https://github.com/lucalista/shinestacker/blob/main/README.md")

shinestacker/app/main.py

@@ -0,0 +1,176 @@
+import sys
+import os
+import logging
+import argparse
+import matplotlib
+import matplotlib.backends.backend_pdf
+matplotlib.use('agg')
+from PySide6.QtWidgets import QApplication, QMainWindow, QStackedWidget, QMenu
+from PySide6.QtGui import QAction, QIcon, QGuiApplication
+from PySide6.QtCore import Qt, QEvent, QTimer
+from shinestacker.config.config import config
+config.init(DISABLE_TQDM=True, COMBINED_APP=True, DONT_USE_NATIVE_MENU=True)
+from shinestacker.config.constants import constants
+from shinestacker.core.logging import setup_logging
+from shinestacker.core.core_utils import get_app_base_path
+from shinestacker.gui.main_window import MainWindow
+from shinestacker.retouch.image_editor_ui import ImageEditorUI
+from shinestacker.app.gui_utils import disable_macos_special_menu_items
+from shinestacker.app.help_menu import add_help_action
+from shinestacker.app.about_dialog import show_about_dialog
+from shinestacker.app.open_frames import open_frames
+
+
+class MainApp(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(constants.APP_TITLE)
+        self.resize(1400, 900)
+        center = QGuiApplication.primaryScreen().geometry().center()
+        self.move(center - self.rect().center())
+        self.stacked_widget = QStackedWidget()
+        self.setCentralWidget(self.stacked_widget)
+        self.project_window = MainWindow()
+        self.project_window.set_retouch_callback(self.retouch_callback)
+        self.retouch_window = ImageEditorUI()
+        self.stacked_widget.addWidget(self.project_window)
+        self.stacked_widget.addWidget(self.retouch_window)
+        self.app_menu = self.create_menu()
+        self.project_window.menuBar().insertMenu(self.project_window.menuBar().actions()[0], self.app_menu)
+        self.retouch_window.menuBar().insertMenu(self.retouch_window.menuBar().actions()[0], self.app_menu)
+        add_help_action(self.project_window)
+        add_help_action(self.retouch_window)
+
+    def switch_to_project(self):
+        self.switch_app(0)
+        self.switch_to_project_action.setChecked(True)
+        self.switch_to_retouch_action.setChecked(False)
+        self.switch_to_project_action.setEnabled(False)
+        self.switch_to_retouch_action.setEnabled(True)
+        self.project_window.update_title()
+        self.project_window.activateWindow()
+        self.project_window.setFocus()
+
+    def switch_to_retouch(self):
+        self.switch_app(1)
+        self.switch_to_project_action.setChecked(False)
+        self.switch_to_retouch_action.setChecked(True)
+        self.switch_to_project_action.setEnabled(True)
+        self.switch_to_retouch_action.setEnabled(False)
+        self.retouch_window.update_title()
+        self.retouch_window.activateWindow()
+        self.retouch_window.setFocus()
+
+    def create_menu(self):
+        app_menu = QMenu(constants.APP_STRING)
+        self.switch_to_project_action = QAction("Project", self)
+        self.switch_to_project_action.setCheckable(True)
+        self.switch_to_project_action.triggered.connect(self.switch_to_project)
+        self.switch_to_retouch_action = QAction("Retouch", self)
+        self.switch_to_retouch_action.setCheckable(True)
+        self.switch_to_retouch_action.triggered.connect(self.switch_to_retouch)
+        app_menu.addAction(self.switch_to_project_action)
+        app_menu.addAction(self.switch_to_retouch_action)
+        app_menu.addSeparator()
+        about_action = QAction(f"About {constants.APP_STRING}", self)
+        about_action.triggered.connect(show_about_dialog)
+        app_menu.addAction(about_action)
+        app_menu.addSeparator()
+        if config.DONT_USE_NATIVE_MENU:
+            quit_txt, quit_short = "&Quit", "Ctrl+Q"
+        else:
+            quit_txt, quit_short = "Shut dw&wn", "Ctrl+Q"
+        exit_action = QAction(quit_txt, self)
+        exit_action.setShortcut(quit_short)
+        exit_action.triggered.connect(self.quit)
+        app_menu.addAction(exit_action)
+        return app_menu
+
+    def quit(self):
+        self.retouch_window.quit()
+        self.project_window.quit()
+        self.close()
+
+    def switch_app(self, index):
+        self.stacked_widget.setCurrentIndex(index)
+
+    def retouch_callback(self, filename):
+        self.switch_to_retouch()
+        if isinstance(filename, list):
+            open_frames(self.retouch_window, None, ";".join(filename))
+        else:
+            self.retouch_window.open_file(filename)
+
+
+class Application(QApplication):
+    def event(self, event):
+        if event.type() == QEvent.Quit and event.spontaneous():
+            self.main_app.quit()
+        return super().event(event)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog=f'{constants.APP_STRING.lower()}-retouch',
+        description='Focus stacking App.',
+        epilog=f'This app is part of the {constants.APP_STRING} package.')
+    parser.add_argument('-f', '--filename', nargs='?', help='''
+if a single file is specified, it can be either a project or an image.
+Multiple frames can be specified as a list of files.
+Multiple files can be specified separated by ';'.
+''')
+    parser.add_argument('-p', '--path', nargs='?', help='''
+import frames from one or more directories.
+Multiple directories can be specified separated by ';'.
+''')
+    parser.add_argument('-r', '--retouch', action='store_true', help='''
+open retouch window at startup instead of project windows.
+''')
+    parser.add_argument('-x', '--expert', action='store_true', help='''
+expert options are visible by default.
+''')
+    args = vars(parser.parse_args(sys.argv[1:]))
+    filename = args['filename']
+    path = args['path']
+    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
+    app = Application(sys.argv)
+    if config.DONT_USE_NATIVE_MENU:
+        app.setAttribute(Qt.AA_DontUseNativeMenuBar)
+    else:
+        disable_macos_special_menu_items()
+    icon_path = f'{get_app_base_path()}'
+    if os.path.exists(f'{icon_path}/ico'):
+        icon_path = f'{icon_path}/ico'
+    else:
+        icon_path = f'{icon_path}/../ico'
+    icon_path = f'{icon_path}/shinestacker.png'
+    app.setWindowIcon(QIcon(icon_path))
+    main_app = MainApp()
+    app.main_app = main_app
+    main_app.show()
+    main_app.activateWindow()
+    if args['expert']:
+        main_app.project_window.set_expert_options()
+    if filename:
+        filenames = filename.split(';')
+        filename = filenames[0]
+        extension = filename.split('.')[-1]
+        if len(filenames) == 1 and extension == 'fsp':
+            main_app.project_window.open_project(filename)
+            main_app.project_window.setFocus()
+        else:
+            main_app.switch_to_retouch()
+            open_frames(main_app.retouch_window, filename, path)
+    else:
+        retouch = args['retouch']
+        if retouch:
+            main_app.switch_to_retouch()
+        else:
+            main_app.switch_to_project()
+            QTimer.singleShot(100, lambda: main_app.project_window.new_project())
+    QTimer.singleShot(100, lambda: main_app.setFocus())
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

shinestacker/app/open_frames.py

@@ -0,0 +1,39 @@
+import os
+import sys
+from PySide6.QtCore import QTimer
+
+
+def open_files(editor, filenames):
+    if len(filenames) == 1:
+        QTimer.singleShot(100, lambda: editor.open_file(filenames[0]))
+    else:
+        def check_thread():
+            if editor.loader_thread is None or editor.loader_thread.isRunning():
+                QTimer.singleShot(100, check_thread)
+            else:
+                editor.import_frames_from_files(filenames[1:])
+        QTimer.singleShot(100, lambda: (
+            editor.open_file(filenames[0]),
+            QTimer.singleShot(100, check_thread)
+        ))
+
+
+def open_frames(editor, filename, path):
+    if filename:
+        filenames = filename.split(';')
+        open_files(editor, filenames)
+    elif path:
+        reverse = False
+        paths = path.split(';')
+        filenames = []
+        for path in paths:
+            if os.path.exists(path) and os.path.isdir(path):
+                all_entries = os.listdir(path)
+                files = sorted([f for f in all_entries if os.path.isfile(os.path.join(path, f))],
+                               reverse=reverse)
+                full_paths = [os.path.join(path, f) for f in files]
+                filenames += full_paths
+            else:
+                print(f"path {path} is invalid", file=sys.stderr)
+                exit(1)
+        open_files(editor, filenames)

shinestacker/app/project.py

@@ -0,0 +1,91 @@
+import os
+import sys
+import logging
+import argparse
+import matplotlib
+import matplotlib.backends.backend_pdf
+matplotlib.use('agg')
+from PySide6.QtWidgets import QApplication, QMenu
+from PySide6.QtGui import QIcon, QAction
+from PySide6.QtCore import Qt, QTimer, QEvent
+from shinestacker.config.config import config
+config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
+from shinestacker.config.constants import constants
+from shinestacker.core.logging import setup_logging
+from shinestacker.core.core_utils import get_app_base_path
+from shinestacker.gui.main_window import MainWindow
+from shinestacker.app.gui_utils import disable_macos_special_menu_items
+from shinestacker.app.help_menu import add_help_action
+from shinestacker.app.about_dialog import show_about_dialog
+
+
+class ProjectApp(MainWindow):
+    def __init__(self):
+        super().__init__()
+        self.app_menu = self.create_menu()
+        self.menuBar().insertMenu(self.menuBar().actions()[0], self.app_menu)
+        add_help_action(self)
+        self.set_retouch_callback(self._retouch_callback)
+
+    def create_menu(self):
+        app_menu = QMenu(constants.APP_STRING)
+        about_action = QAction(f"About {constants.APP_STRING}", self)
+        about_action.triggered.connect(show_about_dialog)
+        app_menu.addAction(about_action)
+        app_menu.addSeparator()
+        if config.DONT_USE_NATIVE_MENU:
+            quit_txt, quit_short = "&Quit", "Ctrl+Q"
+        else:
+            quit_txt, quit_short = "Shut dw&wn", "Ctrl+Q"
+        exit_action = QAction(quit_txt, self)
+        exit_action.setShortcut(quit_short)
+        exit_action.triggered.connect(self.quit)
+        app_menu.addAction(exit_action)
+        return app_menu
+
+    def _retouch_callback(self, filename):
+        p = ";".join(filename)
+        os.system(f'{constants.RETOUCH_APP} -p "{p}" &')
+
+
+class Application(QApplication):
+    def event(self, event):
+        if event.type() == QEvent.Quit and event.spontaneous():
+            self.window.quit()
+        return super().event(event)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog=f'{constants.APP_STRING.lower()}-project',
+        description='Manage and run focus stack jobs.',
+        epilog=f'This app is part of the {constants.APP_STRING} package.')
+    parser.add_argument('-f', '--filename', nargs='?', help='''
+project filename.
+''')
+    parser.add_argument('-x', '--expert', action='store_true', help='''
+expert options are visible by default.
+''')
+    args = vars(parser.parse_args(sys.argv[1:]))
+    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
+    app = Application(sys.argv)
+    if config.DONT_USE_NATIVE_MENU:
+        app.setAttribute(Qt.AA_DontUseNativeMenuBar)
+    else:
+        disable_macos_special_menu_items()
+    app.setWindowIcon(QIcon(f'{get_app_base_path()}/ico/shinestacker.png'))
+    window = ProjectApp()
+    if args['expert']:
+        window.set_expert_options()
+    app.window = window
+    window.show()
+    filename = args['filename']
+    if filename:
+        QTimer.singleShot(100, lambda: window.open_project(filename))
+    else:
+        QTimer.singleShot(100, lambda: window.new_project())
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

shinestacker/app/retouch.py

@@ -0,0 +1,82 @@
+import sys
+import argparse
+from PySide6.QtWidgets import QApplication, QMenu
+from PySide6.QtGui import QIcon, QAction
+from PySide6.QtCore import Qt, QEvent
+from shinestacker.config.config import config
+config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
+from shinestacker.core.core_utils import get_app_base_path
+from shinestacker.config.config import config
+from shinestacker.config.constants import constants
+from shinestacker.retouch.image_editor_ui import ImageEditorUI
+from shinestacker.app.gui_utils import disable_macos_special_menu_items
+from shinestacker.app.help_menu import add_help_action
+from shinestacker.app.about_dialog import show_about_dialog
+from shinestacker.app.open_frames import open_frames
+
+
+class RetouchApp(ImageEditorUI):
+    def __init__(self):
+        super().__init__()
+        self.app_menu = self.create_menu()
+        self.menuBar().insertMenu(self.menuBar().actions()[0], self.app_menu)
+        add_help_action(self)
+
+    def create_menu(self):
+        app_menu = QMenu(constants.APP_STRING)
+        about_action = QAction(f"About {constants.APP_STRING}", self)
+        about_action.triggered.connect(show_about_dialog)
+        app_menu.addAction(about_action)
+        app_menu.addSeparator()
+        if config.DONT_USE_NATIVE_MENU:
+            quit_txt, quit_short = "&Quit", "Ctrl+Q"
+        else:
+            quit_txt, quit_short = "Shut dw&wn", "Ctrl+Q"
+        exit_action = QAction(quit_txt, self)
+        exit_action.setShortcut(quit_short)
+        exit_action.triggered.connect(self.quit)
+        app_menu.addAction(exit_action)
+        return app_menu
+
+
+class Application(QApplication):
+    def event(self, event):
+        if event.type() == QEvent.Quit and event.spontaneous():
+            self.editor.quit()
+        return super().event(event)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog=f'{constants.APP_STRING.lower()}-retouch',
+        description='Final retouch focus stack image from individual frames.',
+        epilog=f'This app is part of the {constants.APP_STRING} package.')
+    parser.add_argument('-f', '--filename', nargs='?', help='''
+import frames from files.
+Multiple files can be specified separated by ';'.
+''')
+    parser.add_argument('-p', '--path', nargs='?', help='''
+import frames from one or more directories.
+Multiple directories can be specified separated by ';'.
+''')
+    args = vars(parser.parse_args(sys.argv[1:]))
+    filename = args['filename']
+    path = args['path']
+    if filename and path:
+        print("can't specify both arguments --filename and --path", file=sys.stderr)
+        exit(1)
+    app = Application(sys.argv)
+    if config.DONT_USE_NATIVE_MENU:
+        app.setAttribute(Qt.AA_DontUseNativeMenuBar)
+    else:
+        disable_macos_special_menu_items()
+    app.setWindowIcon(QIcon(f'{get_app_base_path()}/ico/shinestacker.png'))
+    editor = RetouchApp()
+    app.editor = editor
+    editor.show()
+    open_frames(editor, filename, path)
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

shinestacker/config/__init__.py

@@ -0,0 +1,4 @@
+# flake8: noqa F401
+from .config import config
+from .constants import constants
+from .gui_constants import gui_constants