shinestacker 1.3.1__tar.gz → 1.4.0__tar.gz

{shinestacker-1.3.1 → shinestacker-1.4.0}/CHANGELOG.md

@@ -2,11 +2,35 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.4.0] - 2025-09-14
+**GUI improvements**
+
+### Added
+- added retouch view mode with master and frame side by side and top-bottom
+- implemented "Open Recent" menu entry for both projects and retouch images
+- expert options can be shown with a checkbox in each dialog
+- optional summary plots for alignment transformation parameters
+
+## Fixed
+- fixed bug in plot generation
+- fixes warning due to missing glyph in PDF generation on macOS
+- safer parallel plot generation using a thread locks
+
+### Changed
+- code refactoring in various areas
+
+---
+
+### Changed
+- code cleanup
+
 ## [v1.3.1] - 2025-09-08
+**Fixes and optimizations**
 
 ## Fixed
 - fixed input folder widget in job configuration
 - better management of patological alignments
+- restored alignment match plots
 
 ### Changed
 - improved automatic parameters for parallel alignment

{shinestacker-1.3.1/src/shinestacker.egg-info → shinestacker-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.3.1
+Version: 1.4.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.3.1 → shinestacker-1.4.0}/docs/alignment.md

@@ -100,12 +100,21 @@ This class has extra parameters, in addition to the above ones:
 
 * ```max_threads``` (optional, default: ```2```): number of parallel processes allowed. The number of actual threads will not be greater than the number of available CPU cores.
 * ```chunk_submit``` (optional, default: ```True```): submit at most ```max_threads``` parallel processes. If ```chunk_submit``` is greater than ```max_threads``` a moderate performance gain is achieved at the cost of a possibly large memory occupancy.
-* ```bw_matching``` (optional, default: ```False```): perform matches on black and white version of the images in order to save memory. Preliminary tests indicate that the gain with this option is marginal, and this option may be dropped in the future. 
+* ```bw_matching``` (optional, default: ```False```): perform matches on black and white version of the images in order to save memory. Preliminary tests indicate that the gain with this option is marginal, and this option may be dropped in the future.
+
+## Automatic selection of processing strategy
+
+A class ```AlignFramesAuto``` implements alignment with either sequential or parallel processing, and automatically tunes parallel processing parameters.
+This class has extra parameters, in addition to the above ones:
+
+* ```mode``` (optional, default: ```auto```): can be ```auto```, ```sequential``` or ```parallel```.
+* ```memory_limit``` (optional, default: 8×1024<sup>3</sup>sup>): memory limit to determine optimal running parameters
+
 
 ## Allowed configurations
 
 ⚠️ Not all combinations of detector, descriptor and match methods are allowed. Combinations that are not allowed
-give raise to an exception.
+give raise to an exception. This is automatically prevented if one works with the GUI, but may occur when using python scripting. Below the table of the allowed combination with a comparison of CPU performances.
 
 ## CPU performances
 

shinestacker-1.4.0/src/shinestacker/_version.py

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

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/align.py

@@ -5,13 +5,13 @@ import logging
 import numpy as np
 import cv2
 import matplotlib.pyplot as plt
-import matplotlib
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
+from .. core.core_utils import setup_matplotlib_mode
 from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
-matplotlib.use('Agg')
+setup_matplotlib_mode()
 
 _DEFAULT_FEATURE_CONFIG = {
     'detector': constants.DEFAULT_DETECTOR,
@@ -135,14 +135,14 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
         (area_ratio, aspect_ratio, max_angle_dev)
 
 
-def check_transform(m, img_0, transform_type,
+def check_transform(m, img_shape, transform_type,
                     affine_thresholds, homography_thresholds):
     if transform_type == constants.ALIGN_RIGID:
         return check_affine_matrix(
-            m, img_0.shape, affine_thresholds)
+            m, img_shape, affine_thresholds)
     if transform_type == constants.ALIGN_HOMOGRAPHY:
         return check_homography_distortion(
-            m, img_0.shape, homography_thresholds)
+            m, img_shape, homography_thresholds)
     return False, f'invalid transfrom option {transform_type}', None
 
 
@@ -251,7 +251,10 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
                                              confidence=align_confidence / 100.0,
                                              refineIters=refine_iters)
     else:
-        raise InvalidOptionError("transform", transform)
+        raise InvalidOptionError(
+            'transform', method,
+            f". Valid options are: {constants.ALIGN_HOMOGRAPHY}, {constants.ALIGN_RIGID}"
+        )
     return result
 
 
@@ -349,9 +352,11 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
             if m is None:
                 raise InvalidOptionError("transform", transform)
         transform_type = alignment_config['transform']
-        is_valid, reason, _result = check_transform(
-            m, img_0, transform_type,
+        is_valid, reason, result = check_transform(
+            m, img_0.shape, transform_type,
             affine_thresholds, homography_thresholds)
+        if callbacks and 'save_transform_result' in callbacks:
+            callbacks['save_transform_result'](result)
         if not is_valid:
             if callbacks and 'warning' in callbacks:
                 callbacks['warning'](f"invalid transformation: {reason}")
@@ -407,6 +412,18 @@ class AlignFramesBase(SubAction):
         for k in self.alignment_config:
             if k in kwargs:
                 self.alignment_config[k] = kwargs[k]
+        self._area_ratio = None
+        self._aspect_ratio = None
+        self._max_angle_dev = None
+        self._scale_x = None
+        self._scale_y = None
+        self._translation_x = None
+        self._translation_y = None
+        self._rotation = None
+        self._shear = None
+
+    def relative_transformation(self):
+        return None
 
     def align_images(self, idx, img_ref, img_0):
         pass
@@ -417,6 +434,15 @@ class AlignFramesBase(SubAction):
     def begin(self, process):
         self.process = process
         self._n_good_matches = np.zeros(process.total_action_counts)
+        self._area_ratio = np.ones(process.total_action_counts)
+        self._aspect_ratio = np.ones(process.total_action_counts)
+        self._max_angle_dev = np.zeros(process.total_action_counts)
+        self._scale_x = np.ones(process.total_action_counts)
+        self._scale_y = np.ones(process.total_action_counts)
+        self._translation_x = np.zeros(process.total_action_counts)
+        self._translation_y = np.zeros(process.total_action_counts)
+        self._rotation = np.zeros(process.total_action_counts)
+        self._shear = np.zeros(process.total_action_counts)
 
     def run_frame(self, idx, ref_idx, img_0):
         if idx == self.process.ref_idx:
@@ -432,24 +458,29 @@ class AlignFramesBase(SubAction):
                f"{os.path.basename(self.process.input_filepath(idx))}"
 
     def end(self):
-        if self.plot_summary:
-            plt.figure(figsize=constants.PLT_FIG_SIZE)
-            x = np.arange(1, len(self._n_good_matches) + 1, dtype=int)
+
+        def get_coordinates(items):
+            x = np.arange(1, len(items) + 1, dtype=int)
             no_ref = x != self.process.ref_idx + 1
             x = x[no_ref]
-            y = np.array(self._n_good_matches)[no_ref]
+            y = np.array(items)[no_ref]
             if self.process.ref_idx == 0:
-                y_max = y[1]
+                y_ref = y[1]
             elif self.process.ref_idx >= len(y):
-                y_max = y[-1]
+                y_ref = y[-1]
             else:
-                y_max = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+                y_ref = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+            return x, y, y_ref
 
+        if self.plot_summary:
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
+            x, y, y_ref = get_coordinates(self._n_good_matches)
             plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
-                     [0, y_max], color='cornflowerblue', linestyle='--', label='reference frame')
+                     [0, y_ref], color='cornflowerblue', linestyle='--', label='reference frame')
             plt.plot([x[0], x[-1]], [self.min_matches, self.min_matches], color='lightgray',
                      linestyle='--', label='min. matches')
             plt.plot(x, y, color='navy', label='matches')
+            plt.title("Number of matches")
             plt.xlabel('frame')
             plt.ylabel('# of matches')
             plt.legend()
@@ -458,15 +489,160 @@ class AlignFramesBase(SubAction):
             plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
                         f"{self.process.name}-matches.pdf"
             save_plot(plot_path)
-            plt.close('all')
             self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
                                   f"{self.process.name}: matches", plot_path)
+            transform = self.alignment_config['transform']
+            title = "Transformation parameters rel. to reference frame"
+            if transform == constants.ALIGN_RIGID:
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._rotation)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='rotation (°)')
+                y_lim = max(abs(y.min()), abs(y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('rotation angle (degrees)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-rotation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: rotation", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y_x, y_x_ref = get_coordinates(self._translation_x)
+                x, y_y, y_y_ref = get_coordinates(self._translation_y)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [y_x_ref, y_y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y_x, color='blue', label='translation, x (px)')
+                plt.plot(x, y_y, color='red', label='translation, y (px)')
+                y_lim = max(abs(y_x.min()), abs(y_x.max()), abs(y_y.min()), abs(y_y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('translation (pixels)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-translation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: translation", plot_path)
+
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._scale_x)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [1, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [1, 1], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='blue', label='scale factor')
+                d_max = max(abs(y.min() - 1), abs(y.max() - 1)) * 1.1
+                plt.ylim(1.0 - d_max, 1.0 + d_max)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('scale factor')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-scale.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: scale", plot_path)
+            elif transform == constants.ALIGN_HOMOGRAPHY:
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._area_ratio)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='area ratio')
+                d_max = max(abs(y.min() - 1), abs(y.max() - 1)) * 1.1
+                plt.ylim(1.0 - d_max, 1.0 + d_max)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('warped area ratio')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-area-ratio.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: area ratio", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._aspect_ratio)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='aspect ratio')
+                y_min, y_max = y.min(), y.max()
+                delta = y_max - y_min
+                plt.ylim(y_min - 0.05 * delta, y_max + 0.05 * delta)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('aspect ratio')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-aspect-ratio.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: aspect ratio", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._max_angle_dev)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='max. dev. ang. (°)')
+                y_lim = max(abs(y.min()), abs(y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('max deviation angle (degrees)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-rotation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: rotation", plot_path)
+
+    def save_transform_result(self, idx, result):
+        if result is None:
+            return
+        transform = self.alignment_config['transform']
+        if transform == constants.ALIGN_HOMOGRAPHY:
+            area_ratio, aspect_ratio, max_angle_dev = result
+            self._area_ratio[idx] = area_ratio
+            self._aspect_ratio[idx] = aspect_ratio
+            self._max_angle_dev[idx] = max_angle_dev
+        elif transform == constants.ALIGN_RIGID:
+            scale_x, scale_y, translation_x, translation_y, rotation, shear = result
+            self._scale_x[idx] = scale_x
+            self._scale_y[idx] = scale_y
+            self._translation_x[idx] = translation_x
+            self._translation_y[idx] = translation_y
+            self._rotation[idx] = rotation
+            self._shear[idx] = shear
+        else:
+            raise InvalidOptionError(
+                'transform', transform,
+                f". Valid options are: {constants.ALIGN_HOMOGRAPHY}, {constants.ALIGN_RIGID}"
+            )
 
 
 class AlignFrames(AlignFramesBase):
     def align_images(self, idx, img_ref, img_0):
         idx_str = f"{idx:04d}"
         idx_tot_str = self.process.idx_tot_str(idx)
+
         callbacks = {
             'message': lambda: self.print_message(f'{idx_tot_str}: find matches'),
             'matches_message': lambda n: self.print_message(f'{idx_tot_str}: good matches: {n}'),
@@ -476,7 +652,8 @@ class AlignFrames(AlignFramesBase):
                 f': {msg}', constants.LOG_COLOR_WARNING),
             'save_plot': lambda plot_path: self.process.callback(
                 constants.CALLBACK_SAVE_PLOT, self.process.id,
-                f"{self.process.name}: matches\nframe {idx_str}", plot_path)
+                f"{self.process.name}: matches\nframe {idx_str}", plot_path),
+            'save_transform_result': lambda result: self.save_transform_result(idx, result)
         }
         if self.plot_matches:
             plot_path = os.path.join(
@@ -504,5 +681,8 @@ class AlignFrames(AlignFramesBase):
             return None
         return img
 
+    def relative_transformation(self):
+        return False
+
     def sequential_processing(self):
         return True

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/align_parallel.py

@@ -39,6 +39,7 @@ class AlignFramesParallel(AlignFramesBase):
         self.chunk_submit = kwargs.get('chunk_submit', constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
         self.bw_matching = kwargs.get('bw_matching', constants.DEFAULT_ALIGN_BW_MATCHING)
         self._img_cache = None
+        self._img_shapes = None
         self._img_locks = None
         self._cache_locks = None
         self._target_indices = None
@@ -48,6 +49,9 @@ class AlignFramesParallel(AlignFramesBase):
         self._kp = None
         self._des = None
 
+    def relative_transformation(self):
+        return True
+
     def cache_img(self, idx):
         with self._cache_locks[idx]:
             self._img_locks[idx] += 1
@@ -56,6 +60,8 @@ class AlignFramesParallel(AlignFramesBase):
                 if self.bw_matching:
                     img = img_bw(img)
                 self._img_cache[idx] = img
+                if img is not None:
+                    self._img_shapes[idx] = img.shape
             return self._img_cache[idx]
 
     def submit_threads(self, idxs, imgs):
@@ -112,6 +118,7 @@ class AlignFramesParallel(AlignFramesBase):
                               self.process.id, self.process.name, 2 * n_frames)
         input_filepaths = self.process.input_filepaths()
         self._img_cache = [None] * n_frames
+        self._img_shapes = [None] * n_frames
         self._img_locks = [0] * n_frames
         self._cache_locks = [threading.Lock() for _ in range(n_frames)]
         self._target_indices = [None] * n_frames
@@ -168,9 +175,17 @@ class AlignFramesParallel(AlignFramesBase):
             self._transforms[idx] = None
         gc.collect()
         missing_transforms = 0
+        thresholds = self.get_transform_thresholds()
         for i in range(n_frames):
             if self._cumulative_transforms[i] is not None:
                 self._cumulative_transforms[i] = self._cumulative_transforms[i].astype(np.float32)
+                is_valid, _reason, result = check_transform(
+                    self._cumulative_transforms[i], self._img_shapes[i],
+                    transform_type, *thresholds)
+                if is_valid:
+                    self.save_transform_result(i, result)
+                else:
+                    self._cumulative_transforms[i] = None
             else:
                 missing_transforms += 1
         msg = "feature extaction completed"
@@ -277,7 +292,8 @@ class AlignFramesParallel(AlignFramesBase):
                 return self.extract_features(idx, delta + 1)
         transform_type = self.alignment_config['transform']
         thresholds = self.get_transform_thresholds()
-        is_valid, _reason, _result = check_transform(m, img_0, transform_type, *thresholds)
+        is_valid, _reason, _result = check_transform(m, img_0.shape, transform_type, *thresholds)
+        # self.save_transform_result(idx, result)
         if not is_valid:
             msg = f"invalid transformation for {self.image_str(idx)}"
             do_abort = self.alignment_config['abort_abnormal']

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/balance.py

@@ -8,9 +8,11 @@ from scipy.interpolate import interp1d
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
+from .. core.core_utils import setup_matplotlib_mode
 from .utils import (read_img, save_plot, img_subsample, bgr_to_hsv, bgr_to_hls,
                     hsv_to_bgr, hls_to_bgr, bgr_to_lab, lab_to_bgr)
 from .stack_framework import SubAction
+setup_matplotlib_mode()
 
 
 class BaseHistogrammer:
@@ -40,12 +42,11 @@ class BaseHistogrammer:
         x_values = np.linspace(0, self.max_pixel_value, len(hist))
         ax.plot(x_values, hist, color=color, alpha=alpha)
 
-    def save_plot(self, idx):
+    def save_plot(self, idx, fig=None):
         idx_str = f"{idx:04d}"
         plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
                     f"{self.process.name}-hist-{idx_str}.pdf"
-        save_plot(plot_path)
-        plt.close('all')
+        save_plot(plot_path, fig)
         self.process.callback(
             'save_plot',
             self.process.id, f"{self.process.name}: balance\nframe {idx_str}",
@@ -56,7 +57,6 @@ class BaseHistogrammer:
         plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
                     f"{self.process.name}-{name}.pdf"
         save_plot(plot_path)
-        plt.close('all')
         self.process.callback(
             'save_plot', self.process.id,
             f"{self.process.name}: {name}", plot_path
@@ -69,13 +69,14 @@ class LumiHistogrammer(BaseHistogrammer):
         self.colors = ("r", "g", "b")
 
     def generate_frame_plot(self, idx, hist, chans, calc_hist_func):
-        _fig, axs = plt.subplots(1, 2, figsize=constants.PLT_FIG_SIZE, sharey=True)
+        fig, axs = plt.subplots(1, 2, figsize=constants.PLT_FIG_SIZE, sharey=True)
         self.histo_plot(axs[0], hist, "pixel luminosity", 'black')
         for (chan, color) in zip(chans, self.colors):
             hist_col = calc_hist_func(chan)
             self.histo_plot(axs[1], hist_col, "R, G, B intensity", color, alpha=0.5)
+        fig.suptitle("Image histograms")
         plt.xlim(0, self.max_pixel_value)
-        self.save_plot(idx)
+        self.save_plot(idx, fig)
 
     def generate_summary_plot(self, ref_idx):
         plt.figure(figsize=constants.PLT_FIG_SIZE)
@@ -86,6 +87,7 @@ class LumiHistogrammer(BaseHistogrammer):
         plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--',
                  label='no correction')
         plt.plot(x, y, color='navy', label='luminosity correction')
+        plt.title("Image balance correction")
         plt.xlabel('frame')
         plt.ylabel('correction')
         plt.legend()
@@ -100,11 +102,12 @@ class RGBHistogrammer(BaseHistogrammer):
         self.colors = ("r", "g", "b")
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
+        fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in [2, 1, 0]:
             self.histo_plot(axs[c], hists[c], self.colors[c] + " luminosity", self.colors[c])
+        fig.suptitle("Image histograms")
         plt.xlim(0, self.max_pixel_value)
-        self.save_plot(idx)
+        self.save_plot(idx, fig)
 
     def generate_summary_plot(self, ref_idx):
         plt.figure(figsize=constants.PLT_FIG_SIZE)
@@ -118,6 +121,7 @@ class RGBHistogrammer(BaseHistogrammer):
         plt.plot(x, y[:, 0], color='r', label='R correction')
         plt.plot(x, y[:, 1], color='g', label='G correction')
         plt.plot(x, y[:, 2], color='b', label='B correction')
+        plt.title("Image balance correction")
         plt.xlabel('frame')
         plt.ylabel('correction')
         plt.legend()
@@ -133,10 +137,12 @@ class Ch1Histogrammer(BaseHistogrammer):
         self.colors = colors
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
+        fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in range(3):
             self.histo_plot(axs[c], hists[c], self.labels[c], self.colors[c])
-        plt.xlim(0, self.max_pixel_value)
+        fig.suptitle("Image histograms")
+        for ax in axs:
+            ax.set_xlim(0, self.max_pixel_value)
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
@@ -149,6 +155,7 @@ class Ch1Histogrammer(BaseHistogrammer):
         plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--',
                  label='no correction')
         plt.plot(x, y[:, 0], color=self.colors[0], label=self.labels[0] + ' correction')
+        plt.title("Image balance correction")
         plt.xlabel('frame')
         plt.ylabel('correction')
         plt.legend()
@@ -164,10 +171,12 @@ class Ch2Histogrammer(BaseHistogrammer):
         self.colors = colors
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
+        fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in range(3):
             self.histo_plot(axs[c], hists[c], self.labels[c], self.colors[c])
-        plt.xlim(0, self.max_pixel_value)
+        fig.suptitle("Image histograms")
+        for ax in axs:
+            ax.set_xlim(0, self.max_pixel_value)
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
@@ -181,6 +190,7 @@ class Ch2Histogrammer(BaseHistogrammer):
                  label='no correction')
         plt.plot(x, y[:, 0], color=self.colors[1], label=self.labels[1] + ' correction')
         plt.plot(x, y[:, 1], color=self.colors[2], label=self.labels[2] + ' correction')
+        plt.title("Image balance correction")
         plt.xlabel('frame')
         plt.ylabel('correction')
         plt.legend()
@@ -603,7 +613,7 @@ class BalanceFrames(SubAction):
             mask_radius = int(min(*shape) * self.mask_size / 2)
             cv2.circle(img, (shape[1] // 2, shape[0] // 2), mask_radius, 255, -1)
             plt.figure(figsize=constants.PLT_FIG_SIZE)
-            plt.title('Mask')
+            plt.title('Image balance mask')
             plt.imshow(img, 'gray')
             self.correction.histogrammer.save_summary_plot("mask")
 

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/noise_detection.py

@@ -10,10 +10,12 @@ from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.exceptions import ImageLoadError
 from .. core.framework import TaskBase
-from .. core.core_utils import make_tqdm_bar
+from .. core.core_utils import make_tqdm_bar, setup_matplotlib_mode
 from .. core.exceptions import RunStopException, ShapeError
 from .stack_framework import ImageSequenceManager, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
+setup_matplotlib_mode()
+
 
 MAX_NOISY_PIXELS = 1000
 

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/utils.py

@@ -1,6 +1,8 @@
 # pylint: disable=C0114, C0116, E1101, R0914
 import os
+import gc
 import logging
+import threading
 import numpy as np
 import cv2
 import matplotlib.pyplot as plt
@@ -50,6 +52,10 @@ def extension_jpg_png(path):
     return extension_in(path, EXTENSIONS_JPG + EXTENSIONS_PNG)
 
 
+def extension_jpg_tif_png(path):
+    return extension_in(path, EXTENSIONS_JPG + EXTENSIONS_TIF + EXTENSIONS_PNG)
+
+
 def read_img(file_path):
     if not os.path.isfile(file_path):
         raise RuntimeError("File does not exist: " + file_path)
@@ -124,17 +130,22 @@ def read_and_validate_img(filename, expected_shape=None, expected_dtype=None):
     return validate_image(read_img(filename), expected_shape, expected_dtype)
 
 
-def save_plot(filename):
+def save_plot(filename, fig=None):
     logging.getLogger(__name__).debug(msg=f"save plot file: {filename}")
-    dir_path = os.path.dirname(filename)
-    if not dir_path:
-        dir_path = '.'
-    if not os.path.isdir(dir_path):
-        os.makedirs(dir_path)
-    plt.savefig(filename, dpi=150)
-    if config.JUPYTER_NOTEBOOK:
-        plt.show()
-    plt.close('all')
+    save_lock = threading.Lock()
+    with save_lock:
+        dir_path = os.path.dirname(filename)
+        if not dir_path:
+            dir_path = '.'
+        if not os.path.isdir(dir_path):
+            os.makedirs(dir_path)
+        if fig is None:
+            fig = plt.gcf()
+        fig.savefig(filename, dpi=150)
+        if config.JUPYTER_NOTEBOOK:
+            plt.show()
+        plt.close(fig)
+    gc.collect()
 
 
 def img_subsample(img, subsample, fast=True):

{shinestacker-1.3.1 → shinestacker-1.4.0}/src/shinestacker/algorithms/vignetting.py

@@ -7,9 +7,11 @@ import matplotlib.pyplot as plt
 from scipy.optimize import curve_fit, fsolve
 import cv2
 from .. core.colors import color_str
+from .. core.core_utils import setup_matplotlib_mode
 from .. config.constants import constants
 from .utils import img_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
+setup_matplotlib_mode()
 
 CLIP_EXP = 10