shinestacker 0.4.0__tar.gz → 1.0.0__tar.gz

{shinestacker-0.4.0 → shinestacker-1.0.0}/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 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**
+
+### Changes
+
+* layer selection highlightted with a blue border
+* improved font rendering in brush preview
+* fixed thumbnail spacing
+* fixed and improved save strategy for retouched images
+* added checks for updated version in about dialog
+* disable "Save" and "Save As..." menus if do not apply to current status
+
 ---
 
 ## [v0.4.0] - 2025-08-19

{shinestacker-0.4.0/src/shinestacker.egg-info → shinestacker-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.4.0
+Version: 1.0.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -41,6 +41,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">
 
@@ -75,6 +76,14 @@ The GUI has two main working areas:
 
 The first version of the core focus stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author. The implementation in the latest releases was rewritten from the original code.
 
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png' width="256" referrerpolicy="no-referrer" alt="Shine Stacker Logo">
+
+## Logo attribution
+
+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.
+
 # Resources
 
 * [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
@@ -83,8 +92,11 @@ Pyramid methods in image processing
 
 # License
 
-<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+- **Code**: <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.
+- **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.4.0 → shinestacker-1.0.0}/README.md

@@ -10,6 +10,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">
 
@@ -44,6 +45,14 @@ The GUI has two main working areas:
 
 The first version of the core focus stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author. The implementation in the latest releases was rewritten from the original code.
 
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png' width="256" referrerpolicy="no-referrer" alt="Shine Stacker Logo">
+
+## Logo attribution
+
+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.
+
 # Resources
 
 * [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
@@ -52,8 +61,11 @@ Pyramid methods in image processing
 
 # License
 
-<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+- **Code**: <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.
+- **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.4.0 → shinestacker-1.0.0}/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.4.0 → shinestacker-1.0.0}/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.4.0 → shinestacker-1.0.0}/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.0/scripts/git-rev-list.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+git rev-list --objects --all |
+  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' |
+  awk '/^blob/ {print $3,$4}' |
+  sort -n -k1 |
+  tail -50

shinestacker-1.0.0/src/shinestacker/_version.py

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

{shinestacker-0.4.0 → shinestacker-1.0.0}/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.4.0 → shinestacker-1.0.0}/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.4.0 → shinestacker-1.0.0}/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.4.0 → shinestacker-1.0.0}/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.0/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-1.0.0/src/shinestacker/app/about_dialog.py

@@ -0,0 +1,117 @@
+# 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 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')
+        parts = v.split('.')
+        result = []
+        for part in parts:
+            try:
+                result.append(int(part))
+            except ValueError:
+                result.append(part)
+        return result
+    current_parts = parse_version(current)
+    latest_parts = parse_version(latest)
+    for i in range(max(len(current_parts), len(latest_parts))):
+        c = current_parts[i] if i < len(current_parts) else 0
+        l = latest_parts[i] if i < len(latest_parts) else 0  # noqa: E741
+        if isinstance(c, int) and isinstance(l, int):
+            if c < l:
+                return -1
+            if c > l:
+                return 1
+        else:
+            if str(c) < str(l):
+                return -1
+            if str(c) > str(l):
+                return 1
+    return 0
+
+
+def get_latest_version():
+    try:
+        url = "https://api.github.com/repos/lucalista/shinestacker/releases/latest"
+        headers = {'User-Agent': 'ShineStacker'}
+        req = Request(url, headers=headers)
+        with urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data['tag_name']
+    except (URLError, ValueError, KeyError, TimeoutError):
+        return None
+
+
+def show_about_dialog(parent):
+    version_clean = __version__.split("+", maxsplit=1)[0]
+    latest_version = None
+    try:
+        latest_version = get_latest_version()
+    except Exception:
+        pass
+    update_text = ""
+    if latest_version:
+        latest_clean = latest_version.lstrip('v')
+        if compare_versions(version_clean, latest_clean) < 0:
+            update_text = f"""
+            <p style="color: red; font-weight: bold;">
+                Update available! Latest version: {latest_version}
+                <br><a href="https://github.com/lucalista/shinestacker/releases/latest">Download here</a>
+            </p>
+            """ # noqa E501
+        else:
+            update_text = """
+            <p style="color: green; font-weight: bold;">
+                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;'>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>
+    <li><a href="https://shinestacker.wordpress.com/">Website on Wordpress</a></li>
+    <li><a href="https://github.com/lucalista/shinestacker">GitHub project repository</a></li>
+    </ul>
+    """
+    dialog = AboutDialog(parent, about_text)
+    dialog.exec()

{shinestacker-0.4.0 → shinestacker-1.0.0}/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: