shinestacker 0.5.0__tar.gz → 1.0.1__tar.gz

{shinestacker-0.5.0 → shinestacker-1.0.1}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.0.0] - 2025-08-25
+**First stable release**
+
+### Changes
+
+* implemented vignetting correction filter
+* improved vignetting performance using subsampling
+* implemented fast subsample option in balance algorithms
+* implemented hex color line editin white balance filter
+* new application logo
+* interface improvements: implemented master/layer toggle
+* more informative GUI messages and colors
+* code refactoring and various cleanup 
+* bug fixes
+
+---
+
 ## [v0.5.0] - 2025-08-20
 **GUI and robustness improvements**
 

{shinestacker-0.5.0/src/shinestacker.egg-info → shinestacker-1.0.1}/PKG-INFO

@@ -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-0.5.0 → shinestacker-1.0.1}/README.md

@@ -1,3 +1,5 @@
+<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
@@ -10,6 +12,7 @@
 [![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">
 
@@ -53,7 +56,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-0.5.0 → shinestacker-1.0.1}/docs/balancing.md

@@ -16,6 +16,7 @@ intensity_interval = {
 ```
 Note that for 8-bit images the maximum intensity is 255, while for 16-bit images the maximum intensity is 65536.
 * ```subsample``` (optional, default: 8): extracts intensity histogram using every n-th pixel in each dimension in order to reduce processing time. By default, it takes one every 8 pixels in horizontal and vertical directions, i.e.: one every 100 pixels in total. This option is not ised if ```corr_map``` is equal to ```BALANCE_MATCH_HIST```.
+* ```fast_subsampling``` (optional, default: ```False```): perform fast image subsampling without interpolation. Used if ```subsample``` is set to ```True```.
 * ```corr_map``` (optional, default: ```BALANCE_LINEAR```, possible values: ```BALANCE_LINEAR```, ```BALANCE_GAMMA``` and ```MATCH_HIST```): specifies the type of intensity correction.
    * ```BALANCE_LINEAR```: a linear correction is applied in order to balance the average intensity of the corrected images to the reference image in the specified channels.
    * ```BALANCE_GAMMA```: a gamma correction, i.e.: a power law, is applied in order to balance the average intensity of the corrected images to reference image in the specified channels. The gamma correction avoids saturation of low or high intensity pixels which may occur for a linear coorection, but may introduce more distortion than a linear mapping.

{shinestacker-0.5.0 → shinestacker-1.0.1}/docs/gui.md

@@ -107,13 +107,14 @@ Adjust in the top toolbar:
 
 | Action              | Shortcut                  |
 |---------------------|---------------------------|
-| Zoom in/out         | `Ctrl` + `+`/`- or mouse wheel          |
+| Zoom in/out         | `Ctrl` + `+`/`- or mouse wheel or pinch on touchpad |
 | Reset view          | `Ctrl` + `0`              |
-| Pan                 | `Space` + mouse drag      |
+| Pan                 | `Space` + mouse drag or two fingers on touchpad   |
 | Prev./next layer    | `Up`/`Down` arrows        |
 | View master layer   | `M`                       |
 | View source layer   | `L`                       |
-| Toggle master ↔ source | `X`                    |
+| Toggle master ↔ layer | `T`                       |
+| Temp. toggle master ↔ source | `X`                    |
 
 See help menu for complete list of shortcuts.
 

{shinestacker-0.5.0 → shinestacker-1.0.1}/docs/vignetting.md

@@ -14,7 +14,6 @@ Arguments for the constructor of ```Vignetting``` are:
 * ```r_steps``` (optional, default: 100): number of radial steps to determine mean pixel luminosity.
 * ```black_threshold``` (optional, default: 1): apply correction only on pixels with luminosity greater than.
 * ```max_correction``` (optional, default: 1): if less than one, the correction is rescaled in order to be at most the specified valye.
-* ```apply_correction``` (optional, default: ```True```): if ```False```, the correction is computed but not applied to the image. It may be useful in order to determine a value of the parameter ```mask_size``` for the action ```BalanceFrames``` by looking at the output curve plot.
 * ```plot_correction```  (optional, default: ```False```): if ```True```, plot vignetting correction curve for each frame.
 * ```plot_summary```  (optional, default: ```False```): if ```True```, plot a summary histogram with the vignetting correction levels.
 * ```enabled``` (optional, default: ```True```): allows to switch on and off this module.

shinestacker-1.0.1/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.0.1'

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/algorithms/align.py

@@ -6,8 +6,7 @@ import cv2
 from .. config.constants import constants
 from .. core.exceptions import AlignmentError, InvalidOptionError
 from .. core.colors import color_str
-from .utils import img_8bit, img_bw_8bit, save_plot
-from .utils import get_img_metadata, validate_image
+from .utils import img_8bit, img_bw_8bit, save_plot, get_img_metadata, validate_image, img_subsample
 from .stack_framework import SubAction
 
 _DEFAULT_FEATURE_CONFIG = {
@@ -166,19 +165,12 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     if callbacks and 'message' in callbacks:
         callbacks['message']()
     subsample = alignment_config['subsample']
+    fast_subsampling = alignment_config['fast_subsampling']
     min_good_matches = alignment_config['min_good_matches']
     while True:
         if subsample > 1:
-            if alignment_config['fast_subsampling']:
-                img_0_sub, img_1_sub = \
-                    img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
-            else:
-                img_0_sub = cv2.resize(img_0, (0, 0),
-                                       fx=1 / subsample, fy=1 / subsample,
-                                       interpolation=cv2.INTER_AREA)
-                img_1_sub = cv2.resize(img_1, (0, 0),
-                                       fx=1 / subsample, fy=1 / subsample,
-                                       interpolation=cv2.INTER_AREA)
+            img_0_sub = img_subsample(img_0, subsample, fast_subsampling)
+            img_1_sub = img_subsample(img_1, subsample, fast_subsampling)
         else:
             img_0_sub, img_1_sub = img_0, img_1
         kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/algorithms/balance.py

@@ -7,7 +7,7 @@ from scipy.interpolate import interp1d
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
-from .utils import read_img, save_plot
+from .utils import read_img, save_plot, img_subsample
 from .stack_framework import SubAction
 
 
@@ -122,13 +122,15 @@ class LinearMap(CorrectionMap):
 
 class Correction:
     def __init__(self, channels, mask_size=0, intensity_interval=None,
-                 subsample=-1, corr_map=constants.DEFAULT_CORR_MAP,
+                 subsample=-1, fast_subsampling=constants.DEFAULT_BALANCE_FAST_SUBSAMPLING,
+                 corr_map=constants.DEFAULT_CORR_MAP,
                  plot_histograms=False, plot_summary=False):
         self.mask_size = mask_size
         self.intensity_interval = intensity_interval
         self.plot_histograms = plot_histograms
         self.plot_summary = plot_summary
         self.subsample = constants.DEFAULT_BALANCE_SUBSAMPLE if subsample == -1 else subsample
+        self.fast_subsampling = fast_subsampling
         self.corr_map = corr_map
         self.channels = channels
         self.dtype = None
@@ -154,17 +156,18 @@ class Correction:
         self.corrections = np.ones((size, self.channels))
 
     def calc_hist_1ch(self, image):
-        img_subsample = image if self.subsample == 1 else image[::self.subsample, ::self.subsample]
+        img_sub = image if self.subsample == 1 \
+            else img_subsample(image, self.subsample, self.fast_subsampling)
         if self.mask_size == 0:
-            image_sel = img_subsample
+            image_sel = img_sub
         else:
-            height, width = img_subsample.shape[:2]
+            height, width = img_sub.shape[:2]
             xv, yv = np.meshgrid(
                 np.linspace(0, width - 1, width),
                 np.linspace(0, height - 1, height)
             )
             mask_radius = min(width, height) * self.mask_size / 2
-            image_sel = img_subsample[
+            image_sel = img_sub[
                 (xv - width / 2) ** 2 + (yv - height / 2) ** 2 <= mask_radius ** 2
             ]
         hist, _bins = np.histogram(
@@ -305,9 +308,6 @@ class Ch2Correction(Correction):
     def preprocess(self, image):
         assert False, 'abstract method'
 
-    def get_labels(self):
-        assert False, 'abstract method'
-
     def get_hist(self, image, idx):
         hist = [self.calc_hist_1ch(chan) for chan in cv2.split(image)]
         if self.plot_histograms:
@@ -370,6 +370,8 @@ class BalanceFrames(SubAction):
         self.shape = None
         corr_map = kwargs.get('corr_map', constants.DEFAULT_CORR_MAP)
         subsample = kwargs.get('subsample', constants.DEFAULT_BALANCE_SUBSAMPLE)
+        self.fast_subsampling = kwargs.get(
+            'fast_subsampling', constants.DEFAULT_BALANCE_FAST_SUBSAMPLING)
         channel = kwargs.pop('channel', constants.DEFAULT_CHANNEL)
         kwargs['subsample'] = (
             1 if corr_map == constants.BALANCE_MATCH_HIST

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/algorithms/depth_map.py

@@ -61,36 +61,6 @@ class DepthMapStack(BaseStackAlgo):
         raise InvalidOptionError("map_type", self.map_type, details=f" valid values are "
                                  f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
 
-    def pyramid_blend(self, images, weights):
-        blended = None
-        for i in range(images.shape[0]):
-            img = images[i].astype(self.float_type)
-            weight = weights[i]
-            gp_img = [img]
-            gp_weight = [weight]
-            for _ in range(self.levels - 1):
-                gp_img.append(cv2.pyrDown(gp_img[-1]))
-                gp_weight.append(cv2.pyrDown(gp_weight[-1]))
-            lp_img = [gp_img[-1]]
-            for j in range(self.levels - 1, 0, -1):
-                size = (gp_img[j - 1].shape[1], gp_img[j - 1].shape[0])
-                expanded = cv2.pyrUp(gp_img[j], dstsize=size)
-                lp_img.append(gp_img[j - 1] - expanded)
-            current_blend = []
-            for j in range(self.levels):
-                w = gp_weight[self.levels - 1 - j][..., np.newaxis]
-                current_blend.append(lp_img[j] * w)
-            if blended is None:
-                blended = current_blend
-            else:
-                for j in range(self.levels):
-                    blended[j] += current_blend[j]
-        result = blended[0]
-        for j in range(1, self.levels):
-            size = (blended[j].shape[1], blended[j].shape[0])
-            result = cv2.pyrUp(result, dstsize=size) + blended[j]
-        return result
-
     def focus_stack(self, filenames):
         gray_images = []
         metadata = None

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/algorithms/utils.py

@@ -74,3 +74,13 @@ def save_plot(filename):
     if config.JUPYTER_NOTEBOOK:
         plt.show()
     plt.close('all')
+
+
+def img_subsample(img, subsample, fast=True):
+    if fast:
+        img_sub = img[::subsample, ::subsample]
+    else:
+        img_sub = cv2.resize(img, (0, 0),
+                             fx=1 / subsample, fy=1 / subsample,
+                             interpolation=cv2.INTER_AREA)
+    return img_sub

shinestacker-1.0.1/src/shinestacker/algorithms/vignetting.py

@@ -0,0 +1,210 @@
+# pylint: disable=C0114, C0115, C0116, R0902, E1101, W0718, W0640, R0913, R0917, R0914
+import traceback
+import logging
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit, fsolve
+import cv2
+from .. core.colors import color_str
+from .. config.constants import constants
+from .utils import img_8bit, save_plot, img_subsample
+from .stack_framework import SubAction
+
+CLIP_EXP = 10
+
+
+def sigmoid_model(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 radial_mean_intensity(image, r_steps):
+    if len(image.shape) > 2:
+        raise ValueError("The image must be grayscale")
+    h, w = image.shape
+    w_2, h_2 = w / 2, h / 2
+    r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
+    radii = np.linspace(0, r_max, r_steps + 1)
+    mean_intensities = np.zeros(r_steps)
+    y, x = np.ogrid[:h, :w]
+    dist_from_center = np.sqrt((x - w_2)**2 + (y - h_2)**2)
+    for i in range(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 fit_sigmoid(radii, intensities):
+    valid_mask = ~np.isnan(intensities)
+    i_valid, r_valid = intensities[valid_mask], radii[valid_mask]
+    r_max = radii.max()
+    res = curve_fit(sigmoid_model, r_valid, i_valid,
+                    p0=[2 * np.max(i_valid), 10 / r_max, 0.8 * r_max],
+                    bounds=([0, 0, 0], ['inf', 'inf', 'inf']))[0]
+    return res
+
+
+def img_subsampled(image, subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
+                   fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    image_bw = cv2.cvtColor(img_8bit(image), cv2.COLOR_BGR2GRAY)
+    return image_bw if subsample == 1 else img_subsample(image_bw, subsample, fast_subsampling)
+
+
+def compute_fit_parameters(
+        image, r_steps, radii=None, intensities=None,
+        subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
+        fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    image_sub = img_subsampled(image, subsample, fast_subsampling)
+    if radii is None and intensities is None:
+        radii, intensities = radial_mean_intensity(image_sub, r_steps)
+    params = fit_sigmoid(radii, intensities)
+    params[1] /= subsample  # k
+    params[2] *= subsample  # r0
+    return params
+
+
+def correct_vignetting(
+        image, max_correction=constants.DEFAULT_MAX_CORRECTION,
+        black_threshold=constants.DEFAULT_BLACK_THRESHOLD,
+        r_steps=constants.DEFAULT_R_STEPS, params=None, v0=None,
+        subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
+        fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    if params is None:
+        if r_steps is None:
+            raise RuntimeError("Either r_steps or pars must not be None")
+        params = compute_fit_parameters(
+            image, r_steps, subsample=subsample, fast_subsampling=fast_subsampling)
+    if v0 is None:
+        v0 = sigmoid_model(0, *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(sigmoid_model(r, *params) / v0, 1e-6, 1)
+    if max_correction < 1:
+        vignette = (1.0 - max_correction) + vignette * max_correction
+    threshold = black_threshold if image.dtype == np.uint8 else black_threshold * 256
+    if len(image.shape) == 3:
+        vignette = vignette[:, :, np.newaxis]
+        vignette[np.min(image, axis=2) < threshold, :] = 1
+    else:
+        vignette[image < black_threshold] = 1
+    return np.clip(image / vignette, 0, 255
+                   if image.dtype == np.uint8 else 65535).astype(image.dtype)
+
+
+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.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)
+        self.subsample = kwargs.get('subsample', constants.DEFAULT_VIGN_SUBSAMPLE)
+        self.fast_subsampling = kwargs.get(
+            'fast_subsampling', constants.DEFAULT_VIGN_FAST_SUBSAMPLING)
+        self.w_2 = None
+        self.h_2 = None
+        self.v0 = None
+        self.r_max = None
+        self.process = None
+        self.corrections = None
+
+    def run_frame(self, idx, _ref_idx, img_0):
+        self.process.sub_message_r(color_str(": compute vignetting", "cyan"))
+        h, w = img_0.shape[:2]
+        self.w_2, self.h_2 = w / 2, h / 2
+        self.r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
+        image_sub = img_subsampled(img_0, self.subsample, self.fast_subsampling)
+        radii, intensities = radial_mean_intensity(image_sub, self.r_steps)
+        try:
+            params = compute_fit_parameters(
+                img_0, self.r_steps, radii, intensities, self.subsample, self.fast_subsampling)
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            self.process.sub_message(
+                color_str(": could not find vignetting model", "red"), level=logging.WARNING)
+            params = None
+        if params is None:
+            return img_0
+        self.v0 = sigmoid_model(0, *params)
+        i0_fit, k_fit, r0_fit = params
+        self.process.sub_message(color_str(": vignetting model parameters: ", "cyan") +
+                                 color_str(f"i0={i0_fit / 2:.4f}, "
+                                           f"k={k_fit * self.r_max:.4f}, "
+                                           f"r0={r0_fit / self.r_max:.4f}",
+                                           "light_blue"),
+                                 level=logging.DEBUG)
+        if self.plot_correction:
+            plt.figure(figsize=(10, 5))
+            plt.plot(radii, intensities, label="image mean intensity")
+            plt.plot(radii, sigmoid_model(radii * self.subsample, *params), label="sigmoid fit")
+            plt.xlabel('radius (pixels)')
+            plt.ylabel('mean intensity')
+            plt.legend()
+            plt.xlim(radii[0], radii[-1])
+            plt.ylim(0)
+            idx_str = f"{idx:04d}"
+            plot_path = f"{self.process.working_path}/" \
+                f"{self.process.plot_path}/{self.process.name}-" \
+                f"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: sigmoid_model(x, *params) /
+                                              self.v0 - p, r0_fit)[0]
+        self.process.sub_message_r(color_str(": correct vignetting", "cyan"))
+        return correct_vignetting(
+            img_0, self.max_correction, self.black_threshold, None, params, self.v0,
+            self.subsample, self.fast_subsampling)
+
+    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 in (0, 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 1 <= 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 = f"{self.process.working_path}/{self.process.plot_path}/" \
+                        f"{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-0.5.0 → shinestacker-1.0.1}/src/shinestacker/app/about_dialog.py

@@ -1,13 +1,41 @@
-# pylint: disable=C0114, C0116, E0611, W0718
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0903
 import json
 from urllib.request import urlopen, Request
 from urllib.error import URLError
-from PySide6.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QLabel
 from PySide6.QtCore import Qt
 from .. import __version__
+from .. retouch.icon_container import icon_container
 from .. config.constants import constants
 
 
+class AboutDialog(QDialog):
+    def __init__(self, parent=None, about_text=""):
+        super().__init__(parent)
+        self.setWindowTitle("About")
+        self.resize(400, 300)
+        layout = QVBoxLayout(self)
+        layout.setAlignment(Qt.AlignTop)
+        icon_widget = icon_container()
+        icon_layout = QHBoxLayout()
+        icon_layout.addStretch()
+        icon_layout.addWidget(icon_widget)
+        icon_layout.addStretch()
+        layout.addLayout(icon_layout)
+        about_label = QLabel(about_text)
+        about_label.setWordWrap(True)
+        about_label.setAlignment(Qt.AlignLeft)
+        layout.addWidget(about_label)
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        button = QPushButton("OK")
+        button.setFixedWidth(100)
+        button.clicked.connect(self.accept)
+        button_layout.addWidget(button)
+        button_layout.addStretch()
+        layout.addLayout(button_layout)
+
+
 def compare_versions(current, latest):
     def parse_version(v):
         v = v.lstrip('v')
@@ -49,7 +77,7 @@ def get_latest_version():
         return None
 
 
-def show_about_dialog():
+def show_about_dialog(parent):
     version_clean = __version__.split("+", maxsplit=1)[0]
     latest_version = None
     try:
@@ -57,7 +85,6 @@ def show_about_dialog():
     except Exception:
         pass
     update_text = ""
-    # pyling: disable=XXX
     if latest_version:
         latest_clean = latest_version.lstrip('v')
         if compare_versions(version_clean, latest_clean) < 0:
@@ -68,17 +95,17 @@ def show_about_dialog():
             </p>
             """ # noqa E501
         else:
-            update_text = f"""
+            update_text = """
             <p style="color: green; font-weight: bold;">
-                You are using the lastet version: {latest_version}.
+                You are using the lastet version.
             </p>
             """
     about_text = f"""
     <h3>{constants.APP_TITLE}</h3>
     <h4>version: v{version_clean}</h4>
     {update_text}
-    <p style='font-weight: normal;'>App and framework to combine multiple images
-    into a single focused image.</p>
+    <p style='font-weight: normal;'>Focus stackign applications and framework.<br>
+    Combine multiple frames 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>
     <ul>
@@ -86,11 +113,5 @@ def show_about_dialog():
     <li><a href="https://github.com/lucalista/shinestacker">GitHub project repository</a></li>
     </ul>
     """
-    # pyling: enable=XXX
-    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_()
+    dialog = AboutDialog(parent, about_text)
+    dialog.exec()

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/app/gui_utils.py

@@ -42,7 +42,7 @@ def disable_macos_special_menu_items():
 
 def fill_app_menu(app, app_menu):
     about_action = QAction(f"About {constants.APP_STRING}", app)
-    about_action.triggered.connect(show_about_dialog)
+    about_action.triggered.connect(lambda: show_about_dialog(app))
     app_menu.addAction(about_action)
     app_menu.addSeparator()
     if config.DONT_USE_NATIVE_MENU:

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/app/help_menu.py

@@ -14,4 +14,4 @@ def add_help_action(app):
 
 
 def browse_website():
-    webbrowser.open("https://github.com/lucalista/shinestacker/blob/main/docs/gui.md")
+    webbrowser.open("https://shinestacker.readthedocs.io/en/latest/")

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/app/main.py

@@ -141,7 +141,7 @@ expert options are visible by default.
         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.project_controller.open_project(filename)
             main_app.project_window.setFocus()
         else:
             main_app.switch_to_retouch()
@@ -152,7 +152,7 @@ expert options are visible by default.
             main_app.switch_to_retouch()
         else:
             main_app.switch_to_project()
-            QTimer.singleShot(100, main_app.project_window.new_project)
+            QTimer.singleShot(100, main_app.project_window.project_controller.new_project)
     QTimer.singleShot(100, main_app.setFocus)
     sys.exit(app.exec())
 

{shinestacker-0.5.0 → shinestacker-1.0.1}/src/shinestacker/app/project.py

@@ -70,9 +70,9 @@ expert options are visible by default.
     window.show()
     filename = args['filename']
     if filename:
-        QTimer.singleShot(100, lambda: window.open_project(filename))
+        QTimer.singleShot(100, lambda: window.project_controller.open_project(filename))
     else:
-        QTimer.singleShot(100, window.new_project)
+        QTimer.singleShot(100, window.project_controller.new_project)
     sys.exit(app.exec())