shinestacker 0.5.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

shinestacker/retouch/unsharp_mask_filter.py

@@ -6,8 +6,8 @@ from .base_filter import BaseFilter
 
 
 class UnsharpMaskFilter(BaseFilter):
-    def __init__(self, editor):
-        super().__init__(editor)
+    def __init__(self, name, editor):
+        super().__init__(name, editor, preview_at_startup=True)
         self.max_range = 500.0
         self.max_radius = 4.0
         self.max_amount = 3.0
@@ -46,14 +46,14 @@ class UnsharpMaskFilter(BaseFilter):
             elif name == "Threshold":
                 self.threshold_slider = slider
             value_labels[name] = value_label
-        preview_check, preview_timer, button_box = self.create_base_widgets(
-            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200)
+        self.create_base_widgets(
+            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200, dlg)
 
         def update_value(name, value, max_val, fmt):
             float_value = max_val * value / self.max_range
             value_labels[name].setText(fmt.format(float_value))
-            if preview_check.isChecked():
-                preview_timer.start()
+            if self.preview_check.isChecked():
+                self.preview_timer.start()
 
         self.radius_slider.valueChanged.connect(
             lambda v: update_value("Radius", v, self.max_radius, params["Radius"][2]))
@@ -61,10 +61,10 @@ class UnsharpMaskFilter(BaseFilter):
             lambda v: update_value("Amount", v, self.max_amount, params["Amount"][2]))
         self.threshold_slider.valueChanged.connect(
             lambda v: update_value("Threshold", v, self.max_threshold, params["Threshold"][2]))
-        preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(preview_check, do_preview, restore_original)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
+        self.preview_timer.timeout.connect(do_preview)
+        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
+        self.button_box.accepted.connect(dlg.accept)
+        self.button_box.rejected.connect(dlg.reject)
         QTimer.singleShot(0, do_preview)
 
     def get_params(self):

shinestacker/retouch/vignetting_filter.py

@@ -0,0 +1,69 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QSpinBox, QCheckBox, QLabel, QHBoxLayout, QSlider
+from .. config.constants import constants
+from .. algorithms.vignetting import correct_vignetting
+from .base_filter import OneSliderBaseFilter
+
+
+class VignettingFilter(OneSliderBaseFilter):
+    def __init__(self, name, editor):
+        super().__init__(name, editor, 1.0, 0.90, "Vignetting correction",
+                         allow_partial_preview=False, preview_at_startup=False)
+        self.subsample_box = None
+        self.fast_subsampling_check = None
+        self.r_steps_box = None
+        self.threshold_slider = None
+        self.threshold_label = None
+        self.threshold_max_range = 500
+        self.threshold_max_value = 128.0
+        self.threshold_initial_value = constants.DEFAULT_BLACK_THRESHOLD
+        self.threshold_format = "{:.1f}"
+
+    def apply(self, image, strength):
+        return correct_vignetting(image, max_correction=strength,
+                                  black_threshold=self.threshold_slider.value(),
+                                  r_steps=self.r_steps_box.value(),
+                                  subsample=self.subsample_box.value(),
+                                  fast_subsampling=True)
+
+    def add_widgets(self, layout, dlg):
+        threshold_layout = QHBoxLayout()
+        threshold_layout.addWidget(QLabel("Threshold:"))
+        self.threshold_slider = QSlider(Qt.Horizontal)
+        self.threshold_slider.setRange(0, self.threshold_max_range)
+        self.threshold_slider.setValue(
+            int(self.threshold_initial_value /
+                self.threshold_max_value * self.threshold_max_range))
+        self.threshold_slider.valueChanged.connect(self.threshold_changed)
+        self.threshold_label = QLabel(self.threshold_format.format(self.threshold_initial_value))
+        threshold_layout.addWidget(self.threshold_slider)
+        threshold_layout.addWidget(self.threshold_label)
+        layout.addLayout(threshold_layout)
+        subsample_layout = QHBoxLayout()
+        subsample_label = QLabel("Subsample:")
+        self.subsample_box = QSpinBox()
+        self.subsample_box.setFixedWidth(50)
+        self.subsample_box.setRange(1, 50)
+        self.subsample_box.setValue(constants.DEFAULT_VIGN_SUBSAMPLE)
+        self.subsample_box.valueChanged.connect(self.threshold_changed)
+        self.fast_subsampling_check = QCheckBox("Fast subsampling")
+        self.fast_subsampling_check.setChecked(constants.DEFAULT_VIGN_FAST_SUBSAMPLING)
+        r_steps_label = QLabel("Radial steps:")
+        self.r_steps_box = QSpinBox()
+        self.r_steps_box.setFixedWidth(50)
+        self.r_steps_box.setRange(1, 200)
+        self.r_steps_box.setValue(constants.DEFAULT_R_STEPS)
+        self.r_steps_box.valueChanged.connect(self.param_changed)
+        subsample_layout.addWidget(subsample_label)
+        subsample_layout.addWidget(self.subsample_box)
+        subsample_layout.addWidget(r_steps_label)
+        subsample_layout.addWidget(self.r_steps_box)
+        subsample_layout.addStretch(1)
+        layout.addLayout(subsample_layout)
+        layout.addWidget(self.fast_subsampling_check)
+
+    def threshold_changed(self, val):
+        float_val = self.threshold_max_value * float(val) / self.threshold_max_range
+        self.threshold_label.setText(self.threshold_format.format(float_val))
+        self.param_changed(val)

shinestacker/retouch/white_balance_filter.py

@@ -1,6 +1,6 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0914, R0917
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0914, R0917, R0902
 from PySide6.QtWidgets import (QHBoxLayout, QPushButton, QFrame, QVBoxLayout, QLabel, QDialog,
-                               QApplication, QSlider, QDialogButtonBox)
+                               QApplication, QSlider, QDialogButtonBox, QLineEdit)
 from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QCursor
 from .. algorithms.white_balance import white_balance_from_rgb
@@ -8,12 +8,13 @@ from .base_filter import BaseFilter
 
 
 class WhiteBalanceFilter(BaseFilter):
-    def __init__(self, editor):
-        super().__init__(editor)
+    def __init__(self, name, editor):
+        super().__init__(name, editor, preview_at_startup=True)
         self.max_range = 255
         self.initial_val = (128, 128, 128)
         self.sliders = {}
         self.value_labels = {}
+        self.rgb_hex = None
         self.color_preview = None
         self.preview_timer = None
         self.original_mouse_press = None
@@ -45,29 +46,60 @@ class WhiteBalanceFilter(BaseFilter):
             self.value_labels[name] = val_label
         row_layout.addLayout(sliders_layout)
         layout.addLayout(row_layout)
+
+        rbg_layout = QHBoxLayout()
+        rbg_layout.addWidget(QLabel("RBG hex:"))
+        self.rgb_hex = QLineEdit(self.hex_color(self.initial_val))
+        self.rgb_hex.setFixedWidth(60)
+        self.rgb_hex.textChanged.connect(self.on_rgb_change)
+        rbg_layout.addWidget(self.rgb_hex)
+        rbg_layout.addStretch(1)
+        layout.addLayout(rbg_layout)
+
         pick_button = QPushButton("Pick Color")
         layout.addWidget(pick_button)
-        preview_check, self.preview_timer, button_box = self.create_base_widgets(
+        self.create_base_widgets(
             layout,
             QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel,
-            200)
+            200, dlg)
         for slider in self.sliders.values():
             slider.valueChanged.connect(self.on_slider_change)
         self.preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(preview_check, do_preview, restore_original)
+        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
         pick_button.clicked.connect(self.start_color_pick)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
-        button_box.button(QDialogButtonBox.Reset).clicked.connect(self.reset_rgb)
+        self.button_box.accepted.connect(dlg.accept)
+        self.button_box.rejected.connect(dlg.reject)
+        self.button_box.button(QDialogButtonBox.Reset).clicked.connect(self.reset_rgb)
         QTimer.singleShot(0, do_preview)
 
+    def hex_color(self, val):
+        return "".join([f"{int(c):0>2X}" for c in val])
+
+    def apply_preview(self, rgb):
+        self.color_preview.setStyleSheet(f"background-color: rgb{tuple(rgb)};")
+        if self.preview_timer:
+            self.preview_timer.start()
+
     def on_slider_change(self):
         for name in ("R", "G", "B"):
             self.value_labels[name].setText(str(self.sliders[name].value()))
         rgb = tuple(self.sliders[n].value() for n in ("R", "G", "B"))
-        self.color_preview.setStyleSheet(f"background-color: rgb{rgb};")
-        if self.preview_timer:
-            self.preview_timer.start()
+        self.rgb_hex.blockSignals(True)
+        self.rgb_hex.setText(self.hex_color(rgb))
+        self.rgb_hex.blockSignals(False)
+        self.apply_preview(rgb)
+
+    def on_rgb_change(self):
+        txt = self.rgb_hex.text()
+        if len(txt) != 6:
+            return
+        rgb = [int(txt[i:i + 2], 16) for i in range(0, 6, 2)]
+        for name, c in zip(("R", "G", "B"), rgb):
+            self.sliders[name].blockSignals(True)
+            self.sliders[name].setValue(c)
+            self.sliders[name].blockSignals(False)
+            self.value_labels[name].setText(str(c))
+        self.apply_preview(rgb)
 
     def start_color_pick(self):
         for widget in QApplication.topLevelWidgets():
@@ -94,7 +126,7 @@ class WhiteBalanceFilter(BaseFilter):
             self.editor.image_viewer.mousePressEvent = self.original_mouse_press
             self.editor.image_viewer.brush_cursor.show()
             self.editor.brush_preview.show()
-            new_filter = WhiteBalanceFilter(self.editor)
+            new_filter = WhiteBalanceFilter(self.name, self.editor)
             new_filter.run_with_preview(init_val=rgb)
 
     def reset_rgb(self):

{shinestacker-0.5.0.dist-info → shinestacker-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.5.0
+Version: 1.0.1
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -29,6 +29,8 @@ Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Dynamic: license-file
 
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png' width="150" referrerpolicy="no-referrer" alt="Shine Stacker Logo">
+
 # Shine Stacker
 
 ## Focus Stacking Processing Framework and GUI
@@ -41,6 +43,7 @@ Dynamic: license-file
 [![codecov](https://codecov.io/github/lucalista/shinestacker/graph/badge.svg?token=Y5NKW6VH5G)](https://codecov.io/github/lucalista/shinestacker)
 [![Documentation Status](https://readthedocs.org/projects/shinestacker/badge/?version=latest)](https://shinestacker.readthedocs.io/en/latest/?badge=latest)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![PyPI Downloads](https://static.pepy.tech/badge/shinestacker)](https://pepy.tech/projects/shinestacker)
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400" referrerpolicy="no-referrer">
 
@@ -84,7 +87,10 @@ Pyramid methods in image processing
 # License
 
 <img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
-The software is provided as is under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html). See [LICENSE](https://github.com/lucalista/shinestacker/blob/main/LICENSE) for details.
+- **Code**: The software is provided as is under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html). See [LICENSE](https://github.com/lucalista/shinestacker/blob/main/LICENSE) for details.
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png' width="150" referrerpolicy="no-referrer" alt="Shine Stacker Logo">
+
+- **Logo**: The Shine Stacker logo was designed by [Alessandro Lista](https://linktr.ee/alelista). Copyright © Alessandro Lista. All rights reserved. The logo is not covered by the LGPL-3.0 license of this project.
 
 # Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as:

shinestacker-1.0.1.dist-info/RECORD

@@ -0,0 +1,91 @@
+shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
+shinestacker/_version.py,sha256=bMIenWosteoeUs51RbaWVZetIuzRhWymuyy-n0rfK0I,21
+shinestacker/algorithms/__init__.py,sha256=c4kRrdTLlVI70Q16XkI1RSmz5MD7npDqIpO_02jTG6g,747
+shinestacker/algorithms/align.py,sha256=XT4DJoD5ZvpkC1-J3W3GWmWRsXJg3qJ-3zr9erT8oW0,17514
+shinestacker/algorithms/balance.py,sha256=iSjO-pl0vQv58iEQ077EUcDTAExMKDBdtXmJXbMhazk,16721
+shinestacker/algorithms/base_stack_algo.py,sha256=AFV2QkcFNaTcnISpsWHuAVy2De9hhaPcBNjE1O0h50I,1430
+shinestacker/algorithms/denoise.py,sha256=GL3Z4_6MHxSa7Wo4ZzQECZS87tHBFqO0sIVF_jPuYQU,426
+shinestacker/algorithms/depth_map.py,sha256=FOR5M0brO5-9NnXDY7TWpc3OtKKSuzrOSoBMe0cP6Ho,6076
+shinestacker/algorithms/exif.py,sha256=gY9s6Cd4g4swo5qEjSbzuVIvl1GImCYu6ytOO9WrV0I,9435
+shinestacker/algorithms/multilayer.py,sha256=5JA6TW8oO_R3mu6cOvPno9by4md8q5sXUb8ZfsRRpmY,9259
+shinestacker/algorithms/noise_detection.py,sha256=CDnN8pglxufY5Y-dT3mVooD4zPySdSq9CMgtDGMXBnA,8970
+shinestacker/algorithms/pyramid.py,sha256=_Pk19lRQ21b3W3aHQ6DgAe9VVOfbsi2a9jrynF0qFVw,8610
+shinestacker/algorithms/sharpen.py,sha256=h7PMJBYxucg194Usp_6pvItPUMFYbT-ebAc_-7XBFUw,949
+shinestacker/algorithms/stack.py,sha256=FCU89Of-s6C_DuMleG06c8V6fnIm9MFInvkkKtTsGBo,4906
+shinestacker/algorithms/stack_framework.py,sha256=frw7sbc9qOfVBYP3ZOFZEaIn9O27Wms8j_mxSW79uI0,12460
+shinestacker/algorithms/utils.py,sha256=2XFa16Q8JVq4C2iXZFOvv98GVKqxceFG73yFZNHJSqI,2475
+shinestacker/algorithms/vignetting.py,sha256=yW-1TF4tesLWfKQOS0XxRkOEN82U-YDmMaj09C9cH4M,9552
+shinestacker/algorithms/white_balance.py,sha256=PMKsBtxOSn5aRr_Gkx1StHS4eN6kBN2EhNnhg4UG24g,501
+shinestacker/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shinestacker/app/about_dialog.py,sha256=pkH7nnxUP8yc0D3vRGd1jRb5cwi1nDVbQRk_OC9yLk8,4144
+shinestacker/app/gui_utils.py,sha256=08TrCj2gFGsNsF6hG7ySO2y7wcQakM5PzERkeplqNFs,2344
+shinestacker/app/help_menu.py,sha256=g8lKG_xZmXtNQaC3SIRzyROKVWva_PLEgZsQWh6zUcQ,499
+shinestacker/app/main.py,sha256=geZwxShTDg8dDOnsGu9TvWMw2Wru6MaX9CvlGHMnRvQ,6474
+shinestacker/app/open_frames.py,sha256=bsu32iJSYJQLe_tQQbvAU5DuMDVX6MRuNdE7B5lojZc,1488
+shinestacker/app/project.py,sha256=W0u715LZne_PNJvg9msSy27ybIjgDXiEAQdJ7_6BjYI,2774
+shinestacker/app/retouch.py,sha256=ZQ-nRKnHo6xurcP34RNqaAWkmuGBjJ5jE05hTQ_ycis,2482
+shinestacker/config/__init__.py,sha256=aXxi-LmAvXd0daIFrVnTHE5OCaYeK1uf1BKMr7oaXQs,197
+shinestacker/config/config.py,sha256=eBko2D3ADhLTIm9X6hB_a_WsIjwgfE-qmBVkhP1XSvc,1636
+shinestacker/config/constants.py,sha256=l7RcRxXlIThkBXcy2GVRBWFZQRXNgqYShNEVfDpgjEU,6096
+shinestacker/config/gui_constants.py,sha256=5DR-ET1oeMMD7lIsjvAwSuln89A7I9wy9VuAeRo2G64,2575
+shinestacker/core/__init__.py,sha256=IUEIx6SQ3DygDEHN3_E6uKpHjHtUa4a_U_1dLd_8yEU,484
+shinestacker/core/colors.py,sha256=kr_tJA1iRsdck2JaYDb2lS-codZ4Ty9gdu3kHfiWvuM,1340
+shinestacker/core/core_utils.py,sha256=ulJhzen5McAb5n6wWNA_KB4U_PdTEr-H2TCQkVKUaOw,1421
+shinestacker/core/exceptions.py,sha256=2-noG-ORAGdvDhL8jBQFs0xxZS4fI6UIkMqrWekgk2c,1618
+shinestacker/core/framework.py,sha256=zCnJuQrHNpwEgJW23_BgS7iQrLolRWTAMB1oRp_a7Kk,7447
+shinestacker/core/logging.py,sha256=9SuSSy9Usbh7zqmLYMqkmy-VBkOJW000lwqAR0XQs30,3067
+shinestacker/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shinestacker/gui/action_config.py,sha256=yXNDv0MyONbHk4iUrkvMkLKKaDvpJyzA5Yr0Eikgo0c,16986
+shinestacker/gui/action_config_dialog.py,sha256=6Xjbtj7oHGXBNiogcnPoFHqcuTOnZFlMzWCZXv8eBAI,32623
+shinestacker/gui/base_form_dialog.py,sha256=yYqMee1mzw9VBx8siBS0jDk1qqsTIKJUgdjh92aprQk,687
+shinestacker/gui/colors.py,sha256=m0pQQ-uvtIN1xmb_-N06BvC7pZYZZnq59ZSEJwutHuk,1432
+shinestacker/gui/gui_images.py,sha256=e0KAXSPruZoRHrajfdlmOKBYoRJJQBDan1jgs7YFltY,5678
+shinestacker/gui/gui_logging.py,sha256=kiZcrC2AFYCWgPZo0O5SKw-E5cFrezwf4anS3HjPuNw,8168
+shinestacker/gui/gui_run.py,sha256=jGrtXNT3Gn53qMPSU74aEY6PP7UQfc85SD3XIesWLuY,15147
+shinestacker/gui/main_window.py,sha256=6zGFZkgBh3_UNWjCfNzciPeiCvBsZnjJiPy62U4ldAw,23988
+shinestacker/gui/menu_manager.py,sha256=_L6LOikB3impEYqilqwXc0WJuunishjz57ozZlrBn7Q,9616
+shinestacker/gui/new_project.py,sha256=zHmGrT27L7I6YHM1L8wjt7DzukLFPddFsbVyGVHfJoc,11004
+shinestacker/gui/project_controller.py,sha256=jjM8JuPlIsQohmiqzuV1EndGVvqO4tOEdoMEUJ37SNU,15049
+shinestacker/gui/project_converter.py,sha256=_AFfU2HYKPX78l6iX6bXJrlKpdjSl63pmKzrc6kQpn8,7348
+shinestacker/gui/project_editor.py,sha256=uouzmUkrqouQlq-dqPOgSO16r1WOnGNV2v8jTcZlRXU,23749
+shinestacker/gui/project_model.py,sha256=eRUmH3QmRzDtPtZoxgT6amKzN8_5XzwjHgEJeL-_JOE,4263
+shinestacker/gui/select_path_widget.py,sha256=OfQImOmkzbvl5BBshmb7ePWrSGDJQ8VvyaAOypHAGd4,1023
+shinestacker/gui/tab_widget.py,sha256=6iUifK-wu0EzjVFccKHirhA2fENglVi6xREKiD96aaY,2950
+shinestacker/gui/time_progress_bar.py,sha256=Ty7pNTfbKU44Y_0YQNYtgEcxpOD-Bbi4lC8g-u9bno0,3012
+shinestacker/gui/ico/focus_stack_bkg.png,sha256=Q86TgqvKEi_IzKI8m6aZB2a3T40UkDtexf2PdeBM9XE,163151
+shinestacker/gui/ico/shinestacker.icns,sha256=3IshIOv0uFexYsAEPkE9xiyuw8mB5X5gffekOUhFlt0,45278
+shinestacker/gui/ico/shinestacker.ico,sha256=8IMRk-toObWUz8iDXA-zHBWQ8Ps3vXN5u5ZEyw7sP3c,109613
+shinestacker/gui/ico/shinestacker.png,sha256=VybGY-nig_-wMW8g_uImGxRYvcnltWcAVEPSX6AZUHM,22448
+shinestacker/gui/ico/shinestacker.svg,sha256=r8jx5aiIT9K70MRP0ANWniFE0ctRCqH7LMQ7vcGJ8ss,6571
+shinestacker/gui/img/close-round-line-icon.png,sha256=9HZwCjgni1s_JGUPUb_MoOfoe4tRZgM5OWzk92XFZlE,8019
+shinestacker/gui/img/forward-button-icon.png,sha256=lNw86T4TOEd_uokHYF8myGSGUXzdsHvmDAjlbE18Pgo,4788
+shinestacker/gui/img/play-button-round-icon.png,sha256=9j6Ks9mOGa-2cXyRFpimepAAvSaHzqJKBfxShRb4_dE,4595
+shinestacker/gui/img/plus-round-line-icon.png,sha256=LS068Hlu-CeBvJuB3dwwdJg1lZq6D5MUIv53lu1yKJA,7534
+shinestacker/retouch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shinestacker/retouch/base_filter.py,sha256=7UfuhZV3wEZefQbExVIHJ6IqKnXlMF2MelxswTMaqOo,10356
+shinestacker/retouch/brush.py,sha256=dzD2FzSpBIPdJRmTZobcrQ1FrVd3tF__ZPnUplNE72s,357
+shinestacker/retouch/brush_gradient.py,sha256=F5SFhyzl8YTMqjJU3jK8BrIlLCYLUvITd5wz3cQE4xk,1453
+shinestacker/retouch/brush_preview.py,sha256=QKD3pL7n7YJbIibinUFYKv7lkyq_AWLpt6oyqnltrwQ,4893
+shinestacker/retouch/brush_tool.py,sha256=nxnEuvTioPNw1WeWsT20X1zl-LNZ8i-1ExOcihikEjk,8618
+shinestacker/retouch/denoise_filter.py,sha256=TDUHzhRKlKvCa3D5SCYCZKTpjcl81kGwmONsgSDtO1k,440
+shinestacker/retouch/display_manager.py,sha256=XPbOBmoYc_jNA791WkWkOSaFHb0ztCZechl2p2KSlwQ,9597
+shinestacker/retouch/exif_data.py,sha256=giqoIaMlhN6H3x8BAd73ghVHODmWIcD_QbSoDymQycU,1864
+shinestacker/retouch/file_loader.py,sha256=x8lzKShlgElcJYLFiDoeszeVEToUUiUbUrozAeF5SMU,4812
+shinestacker/retouch/filter_manager.py,sha256=SdYIZkZBUvuB6wDG0moGWav5sfEvIcB9ioUJR5wJFts,388
+shinestacker/retouch/icon_container.py,sha256=6gw1HO1bC2FrdB4dc_iH81DQuLjzuvRGksZ2hKLT9yA,585
+shinestacker/retouch/image_editor_ui.py,sha256=GNozK_P7orgl8EioemJeyR4e_LLMbKVZi4xhYW9m38U,29893
+shinestacker/retouch/image_viewer.py,sha256=3ebrLHTDtGd_EbIT2nNFRUjH836rblmmK7jZ62YcJ2U,19564
+shinestacker/retouch/io_gui_handler.py,sha256=M9rlfqiIaP1wWCm6p-Ew15w0_pH8-DoBXJdEkTUeVCU,11525
+shinestacker/retouch/io_manager.py,sha256=JUAA--AK0mVa1PTErJTnBFjaXIle5Qs7Ow0Wkd8at0o,2437
+shinestacker/retouch/layer_collection.py,sha256=Q7zoCYRn__jYkfrEC2lY1uKHWfOUbsJ27xaYHIoKVxo,5730
+shinestacker/retouch/shortcuts_help.py,sha256=SN4vNa_6yRAFaWxt5HpWn8FHgwmHrIs_wYwjl4iyDmg,3769
+shinestacker/retouch/undo_manager.py,sha256=_ekbcOLcPbQLY7t-o8wf-b1uA6OPY9rRyLM-KqMlQRo,3257
+shinestacker/retouch/unsharp_mask_filter.py,sha256=uFnth8fpZFGhdIgJCnS8x5v6lBQgJ3hX0CBke9pFXeM,3510
+shinestacker/retouch/vignetting_filter.py,sha256=3WuoF38lQOIaU1MWmqviItuQn8NnbMN0nwV7pM9IJqU,3453
+shinestacker/retouch/white_balance_filter.py,sha256=glMBYlmrF-i_OrB3sGUpjZE6X4FQdyLC4GBy2bWtaFc,6056
+shinestacker-1.0.1.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.0.1.dist-info/METADATA,sha256=txWeQBvdot0jMY-eCpwlZTqMataYiQn8MpSZECcxaUw,5902
+shinestacker-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.0.1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.0.1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.0.1.dist-info/RECORD,,

shinestacker/app/app_config.py

@@ -1,22 +0,0 @@
-# pylint: disable=C0114, C0115, C0116, C0103, W0201
-from .. config.config import _ConfigBase
-
-
-class _AppConfig(_ConfigBase):
-    def __new__(cls):
-        return _ConfigBase.__new__(cls)
-
-    def _init_defaults(self):
-        self._DONT_USE_NATIVE_MENU = True
-        self._COMBINED_APP = False
-
-    @property
-    def DONT_USE_NATIVE_MENU(self):
-        return self._DONT_USE_NATIVE_MENU
-
-    @property
-    def COMBINED_APP(self):
-        return self._COMBINED_APP
-
-
-app_config = _AppConfig()

shinestacker/retouch/image_editor.py

@@ -1,197 +0,0 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902
-from PySide6.QtWidgets import QMainWindow, QMessageBox
-from .. config.constants import constants
-from .undo_manager import UndoManager
-from .layer_collection import LayerCollection
-from .io_gui_handler import IOGuiHandler
-from .display_manager import DisplayManager
-from .brush_tool import BrushTool
-from .layer_collection import LayerCollectionHandler
-
-
-class ImageEditor(QMainWindow, LayerCollectionHandler):
-    def __init__(self):
-        QMainWindow.__init__(self)
-        LayerCollectionHandler.__init__(self, LayerCollection())
-        self.undo_manager = UndoManager()
-        self.undo_action = None
-        self.redo_action = None
-        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
-        self.io_gui_handler = None
-        self.display_manager = None
-        self.brush_tool = BrushTool()
-        self.modified = False
-        self.installEventFilter(self)
-        self.mask_layer = None
-
-    def setup_ui(self):
-        self.display_manager = DisplayManager(
-            self.layer_collection, self.image_viewer,
-            self.master_thumbnail_label, self.thumbnail_list, parent=self)
-        self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
-        self.display_manager.status_message_requested.connect(self.show_status_message)
-        self.display_manager.cursor_preview_state_changed.connect(
-            lambda state: setattr(self.image_viewer, 'allow_cursor_preview', state))
-        self.io_gui_handler.status_message_requested.connect(self.show_status_message)
-        self.io_gui_handler.update_title_requested.connect(self.update_title)
-        self.brush_tool.setup_ui(self.brush, self.brush_preview, self.image_viewer,
-                                 self.brush_size_slider, self.hardness_slider, self.opacity_slider,
-                                 self.flow_slider)
-        self.image_viewer.brush = self.brush_tool.brush
-        self.brush_tool.update_brush_thumb()
-        self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
-        self.image_viewer.display_manager = self.display_manager
-
-    def show_status_message(self, message):
-        self.statusBar().showMessage(message)
-
-    # pylint: disable=C0103
-    def keyPressEvent(self, event):
-        if self.image_viewer.empty:
-            return
-        if event.text() == '[':
-            self.brush_tool.decrease_brush_size()
-            return
-        if event.text() == ']':
-            self.brush_tool.increase_brush_size()
-            return
-        if event.text() == '{':
-            self.brush_tool.decrease_brush_hardness()
-            return
-        if event.text() == '}':
-            self.brush_tool.increase_brush_hardness()
-            return
-        super().keyPressEvent(event)
-    # pylint: enable=C0103
-
-    def check_unsaved_changes(self) -> bool:
-        if self.modified:
-            reply = QMessageBox.question(
-                self, "Unsaved Changes",
-                "The image stack has unsaved changes. Do you want to continue?",
-                QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
-            )
-            if reply == QMessageBox.Save:
-                self.save_file()
-                return True
-            if reply == QMessageBox.Discard:
-                return True
-            return False
-        return True
-
-    def sort_layers(self, order):
-        self.sort_layers(order)
-        self.display_manager.update_thumbnails()
-        self.change_layer(self.current_layer())
-
-    def update_title(self):
-        title = constants.APP_TITLE
-        if self.io_gui_handler is not None:
-            path = self.io_gui_handler.current_file_path()
-            if path != '':
-                title += f" - {path.split('/')[-1]}"
-                if self.modified:
-                    title += " *"
-        self.window().setWindowTitle(title)
-
-    def mark_as_modified(self):
-        self.modified = True
-        self.save_actions_set_enabled(True)
-        self.update_title()
-
-    def change_layer(self, layer_idx):
-        if 0 <= layer_idx < self.number_of_layers():
-            view_state = self.image_viewer.get_view_state()
-            self.set_current_layer_idx(layer_idx)
-            self.display_manager.display_current_view()
-            self.image_viewer.set_view_state(view_state)
-            self.thumbnail_list.setCurrentRow(layer_idx)
-            self.thumbnail_list.setFocus()
-            self.image_viewer.update_brush_cursor()
-            self.image_viewer.setFocus()
-
-    def prev_layer(self):
-        if self.layer_stack() is not None:
-            new_idx = max(0, self.current_layer_idx() - 1)
-            if new_idx != self.current_layer_idx():
-                self.change_layer(new_idx)
-                self.display_manager.highlight_thumbnail(new_idx)
-
-    def next_layer(self):
-        if self.layer_stack() is not None:
-            new_idx = min(self.number_of_layers() - 1, self.current_layer_idx() + 1)
-            if new_idx != self.current_layer_idx():
-                self.change_layer(new_idx)
-                self.display_manager.highlight_thumbnail(new_idx)
-
-    def copy_layer_to_master(self):
-        if self.layer_stack() is None or self.master_layer() is None:
-            return
-        reply = QMessageBox.question(
-            self,
-            "Confirm Copy",
-            "Warning: the current master layer will be erased\n\nDo you want to continue?",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No
-        )
-        if reply == QMessageBox.Yes:
-            self.set_master_layer(self.current_layer().copy())
-            self.master_layer().setflags(write=True)
-            self.display_manager.display_current_view()
-            self.display_manager.update_thumbnails()
-            self.mark_as_modified()
-            self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
-
-    def copy_brush_area_to_master(self, view_pos):
-        if self.layer_stack() is None or self.number_of_layers() == 0 \
-           or not self.display_manager.allow_cursor_preview():
-            return
-        area = self.brush_tool.apply_brush_operation(
-            self.master_layer_copy(),
-            self.current_layer(),
-            self.master_layer(), self.mask_layer,
-            view_pos, self.image_viewer)
-        self.undo_manager.extend_undo_area(*area)
-
-    def begin_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
-            self.mask_layer = self.io_gui_handler.blank_layer.copy()
-            self.copy_master_layer()
-            self.undo_manager.reset_undo_area()
-            self.copy_brush_area_to_master(pos)
-            self.display_manager.needs_update = True
-            if not self.display_manager.update_timer.isActive():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
-
-    def continue_copy_brush_area(self, pos):
-        if self.display_manager.allow_cursor_preview():
-            self.copy_brush_area_to_master(pos)
-            self.display_manager.needs_update = True
-            if not self.display_manager.update_timer.isActive():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
-
-    def end_copy_brush_area(self):
-        if self.display_manager.update_timer.isActive():
-            self.display_manager.display_master_layer()
-            self.display_manager.update_master_thumbnail()
-            self.undo_manager.save_undo_state(self.master_layer_copy(), 'Brush Stroke')
-            self.display_manager.update_timer.stop()
-            self.mark_as_modified()
-
-    def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
-        if self.undo_action:
-            if has_undo:
-                self.undo_action.setText(f"Undo {undo_desc}")
-                self.undo_action.setEnabled(True)
-            else:
-                self.undo_action.setText("Undo")
-                self.undo_action.setEnabled(False)
-        if self.redo_action:
-            if has_redo:
-                self.redo_action.setText(f"Redo {redo_desc}")
-                self.redo_action.setEnabled(True)
-            else:
-                self.redo_action.setText("Redo")
-                self.redo_action.setEnabled(False)

shinestacker/retouch/image_filters.py

@@ -1,69 +0,0 @@
-# pylint: disable=C0114, C0115, C0116, R0914
-import numpy as np
-from .image_editor import ImageEditor
-from .filter_manager import FilterManager
-from .denoise_filter import DenoiseFilter
-from .unsharp_mask_filter import UnsharpMaskFilter
-from .white_balance_filter import WhiteBalanceFilter
-
-
-class ImageFilters(ImageEditor):
-    def __init__(self):
-        super().__init__()
-        self.filter_manager = FilterManager(self)
-        self.filter_manager.register_filter("denoise", DenoiseFilter)
-        self.filter_manager.register_filter("unsharp_mask", UnsharpMaskFilter)
-        self.filter_manager.register_filter("white_balance", WhiteBalanceFilter)
-
-    def denoise_filter(self):
-        self.filter_manager.apply("denoise")
-
-    def unsharp_mask(self):
-        self.filter_manager.apply("unsharp_mask")
-
-    def white_balance(self, init_val=None):
-        self.filter_manager.apply("white_balance", init_val=init_val or (128, 128, 128))
-
-    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
-        def on_toggled(checked):
-            if checked:
-                do_preview()
-            else:
-                restore_original()
-        preview_check.toggled.connect(on_toggled)
-
-    def get_pixel_color_at(self, pos, radius=None):
-        item_pos = self.image_viewer.position_on_image(pos)
-        x = int(item_pos.x())
-        y = int(item_pos.y())
-        master_layer = self.master_layer()
-        if (0 <= x < self.master_layer().shape[1]) and \
-           (0 <= y < self.master_layer().shape[0]):
-            if radius is None:
-                radius = int(self.brush.size)
-            if radius > 0:
-                y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
-                mask = x_indices**2 + y_indices**2 <= radius**2
-                x0 = max(0, x - radius)
-                x1 = min(master_layer.shape[1], x + radius + 1)
-                y0 = max(0, y - radius)
-                y1 = min(master_layer.shape[0], y + radius + 1)
-                mask = mask[radius - (y - y0): radius + (y1 - y),
-                            radius - (x - x0): radius + (x1 - x)]
-                region = master_layer[y0:y1, x0:x1]
-                if region.size == 0:
-                    pixel = master_layer[y, x]
-                else:
-                    if region.ndim == 3:
-                        pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
-                    else:
-                        pixel = region[mask].mean()
-            else:
-                pixel = self.master_layer()[y, x]
-            if np.isscalar(pixel):
-                pixel = [pixel, pixel, pixel]
-            pixel = [np.float32(x) for x in pixel]
-            if master_layer.dtype == np.uint16:
-                pixel = [x / 256.0 for x in pixel]
-            return tuple(int(v) for v in pixel)
-        return (0, 0, 0)