shinestacker 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

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/algorithms/base_stack_algo.py

@@ -1,10 +1,10 @@
-# pylint: disable=C0114, C0115, C0116, E0602, R0903
+# pylint: disable=C0114, C0115, C0116, E0602, R0903, R0902
 import os
 import numpy as np
-from .. core.exceptions import InvalidOptionError, ImageLoadError, RunStopException
+from .. core.exceptions import InvalidOptionError, RunStopException
 from .. config.constants import constants
 from .. core.colors import color_str
-from .utils import read_img, get_img_metadata, validate_image, get_img_file_shape, extension_tif_jpg
+from .utils import read_img, get_img_metadata, get_first_image_file
 
 
 class BaseStackAlgo:
@@ -14,6 +14,9 @@ class BaseStackAlgo:
         self.process = None
         self.filenames = None
         self.shape = None
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
         self.do_step_callback = False
         if float_type == constants.FLOAT_32:
             self.float_type = np.float32
@@ -41,14 +44,16 @@ class BaseStackAlgo:
         return f"image: {self.idx_tot_str(idx)}, " \
                f"{os.path.basename(self.filenames[idx])}"
 
+    def num_images(self):
+        return len(self.filenames)
+
     def init(self, filenames):
         self.filenames = filenames
-        first_img_file = ''
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        self.shape = get_img_file_shape(first_img_file)
+        self.shape, self.dtype = get_img_metadata(read_img(get_first_image_file(filenames)))
+        self.num_pixel_values = constants.NUM_UINT8 \
+            if self.dtype == np.uint8 else constants.NUM_UINT16
+        self.max_pixel_value = constants.MAX_UINT8 \
+            if self.dtype == np.uint8 else constants.MAX_UINT16
 
     def total_steps(self, n_frames):
         return self._steps_per_frame * n_frames
@@ -56,17 +61,6 @@ class BaseStackAlgo:
     def print_message(self, msg):
         self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
 
-    def read_image_and_update_metadata(self, img_path, metadata):
-        img = read_img(img_path)
-        if img is None:
-            raise ImageLoadError(img_path)
-        updated = metadata is None
-        if updated:
-            metadata = get_img_metadata(img)
-        else:
-            validate_image(img, *metadata)
-        return img, metadata, updated
-
     def check_running(self, cleanup_callback=None):
         if self.process.callback(constants.CALLBACK_CHECK_RUNNING,
                                  self.process.id, self.process.name) is False:

shinestacker/algorithms/depth_map.py

@@ -3,7 +3,7 @@ import numpy as np
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
-from .utils import read_img, img_bw
+from .utils import read_img, read_and_validate_img, img_bw
 from .base_stack_algo import BaseStackAlgo
 
 
@@ -62,19 +62,15 @@ class DepthMapStack(BaseStackAlgo):
                                  f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
 
     def focus_stack(self):
-        gray_images = []
-        metadata = None
+        n_images = len(self.filenames)
+        gray_images = np.empty((n_images, *self.shape), dtype=self.float_type)
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (1/2) {img_path.split('/')[-1]}")
-
-            img, metadata, _updated = self.read_image_and_update_metadata(img_path, metadata)
-
+            self.print_message(f": reading and validating {self.image_str(i)}")
+            img = read_and_validate_img(img_path, self.shape, self.dtype)
             gray = img_bw(img)
-            gray_images.append(gray)
+            gray_images[i] = gray.astype(self.float_type)
             self.after_step(i)
             self.check_running()
-        dtype = metadata[1]
-        gray_images = np.array(gray_images, dtype=self.float_type)
         if self.energy == constants.DM_ENERGY_SOBEL:
             energies = self.get_sobel_map(gray_images)
         elif self.energy == constants.DM_ENERGY_LAPLACIAN:
@@ -92,7 +88,7 @@ class DepthMapStack(BaseStackAlgo):
         weights = self.get_focus_map(energies)
         blended_pyramid = None
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
+            self.print_message(f": reading {self.image_str(i)}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
             gp_img = [img]
@@ -109,12 +105,11 @@ class DepthMapStack(BaseStackAlgo):
                              for j in range(self.levels)]
             blended_pyramid = current_blend if blended_pyramid is None \
                 else [np.add(bp, cb) for bp, cb in zip(blended_pyramid, current_blend)]
-            self.after_step(i + len(self.filenames))
+            self.after_step(i + n_images)
             self.check_running()
         result = blended_pyramid[0]
         self.print_message(': blend levels')
         for j in range(1, self.levels):
             size = (blended_pyramid[j].shape[1], blended_pyramid[j].shape[0])
             result = cv2.pyrUp(result, dstsize=size) + blended_pyramid[j]
-        n_values = constants.MAX_UINT8 if dtype == np.uint8 else constants.MAX_UINT16
-        return np.clip(np.absolute(result), 0, n_values).astype(dtype)
+        return np.clip(np.absolute(result), 0, self.num_pixel_values).astype(self.dtype)

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/algorithms/pyramid.py

@@ -2,7 +2,7 @@
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .utils import read_img
+from .utils import read_and_validate_img
 from .base_stack_algo import BaseStackAlgo
 
 
@@ -11,7 +11,7 @@ class PyramidBase(BaseStackAlgo):
                  kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
                  gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
                  float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__(name, 2, float_type)
+        super().__init__(name, 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
@@ -30,7 +30,7 @@ class PyramidBase(BaseStackAlgo):
 
     def total_steps(self, n_frames):
         self.n_frames = n_frames
-        return self._steps_per_frame * n_frames + self.n_levels
+        return super().total_steps(n_frames) + self.n_levels
 
     def convolve(self, image):
         return cv2.filter2D(image, -1, self.gen_kernel, borderType=cv2.BORDER_REFLECT101)
@@ -122,21 +122,6 @@ class PyramidBase(BaseStackAlgo):
             fused += np.where(best_d[:, :, np.newaxis] == layer, img, 0)
         return (fused / 2).astype(images.dtype)
 
-    def focus_stack_validate(self, cleanup_callback=None):
-        metadata = None
-        for i, img_path in enumerate(self.filenames):
-            self.print_message(
-                f": validating file {self.image_str(i)}")
-            _img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
-            if updated:
-                self.dtype = metadata[1]
-                self.num_pixel_values = constants.NUM_UINT8 \
-                    if self.dtype == np.uint8 else constants.NUM_UINT16
-                self.max_pixel_value = constants.MAX_UINT8 \
-                    if self.dtype == np.uint8 else constants.MAX_UINT16
-            self.after_step(i + 1)
-            self.check_running(cleanup_callback)
-
     def single_image_laplacian(self, img, levels):
         pyramid = [img.astype(self.float_type)]
         for _ in range(levels):
@@ -180,15 +165,16 @@ class PyramidStack(PyramidBase):
         return fused[::-1]
 
     def focus_stack(self):
-        n = len(self.filenames)
-        self.focus_stack_validate()
         all_laplacians = []
         for i, img_path in enumerate(self.filenames):
+            self.print_message(
+                f": reading and validating {self.image_str(i)}")
+            img = read_and_validate_img(img_path, self.shape, self.dtype)
+            self.check_running()
             self.print_message(
                 f": processing {self.image_str(i)}")
-            img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, self.n_levels))
-            self.after_step(i + n + 1)
+            self.after_step(i + 1)
             self.check_running()
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))
         return stacked_image.astype(self.dtype)

shinestacker/algorithms/pyramid_auto.py

@@ -2,7 +2,6 @@
 import os
 import numpy as np
 from .. config.constants import constants
-from .utils import extension_tif_jpg
 from .base_stack_algo import BaseStackAlgo
 from .pyramid import PyramidStack
 from .pyramid_tiles import PyramidTilesStack
@@ -21,7 +20,7 @@ class PyramidAutoStack(BaseStackAlgo):
                  min_tile_size=constants.DEFAULT_PY_MIN_TILE_SIZE,
                  min_n_tiled_layers=constants.DEFAULT_PY_MIN_N_TILED_LAYERS,
                  mode='auto'):
-        super().__init__("auto_pyramid", 2, float_type)
+        super().__init__("auto_pyramid", 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.gen_kernel = gen_kernel
@@ -47,15 +46,7 @@ class PyramidAutoStack(BaseStackAlgo):
         self.overhead = constants.PY_MEMORY_OVERHEAD
 
     def init(self, filenames):
-        first_img_file = None
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        if first_img_file is None:
-            raise ValueError("No valid image files found")
-        _img, metadata, _ = self.read_image_and_update_metadata(first_img_file, None)
-        self.shape, self.dtype = metadata
+        super().init(filenames)
         self.n_levels = int(np.log2(min(self.shape) / self.min_size))
         self.n_frames = len(filenames)
         memory_required_memory = self._estimate_memory_memory()
@@ -79,9 +70,9 @@ class PyramidAutoStack(BaseStackAlgo):
                 n_tiled_layers=optimal_params['n_tiled_layers'],
                 max_threads=self.num_threads
             )
-            self.print_message(f": using tile-based pyramid stacking "
-                               f"(tile_size: {optimal_params['tile_size']}, "
-                               f"n_tiled_layers: {optimal_params['n_tiled_layers']}), "
+            self.print_message(f": using tile-based pyramid stacking, "
+                               f"tile size: {optimal_params['tile_size']}, "
+                               f"n. tiled layers: {optimal_params['n_tiled_layers']}, "
                                f"{self.num_threads} cores.")
         self._implementation.init(filenames)
         self._implementation.set_do_step_callback(self.do_step_callback)

shinestacker/algorithms/pyramid_tiles.py

@@ -10,7 +10,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import numpy as np
 from .. config.constants import constants
 from .. core.exceptions import RunStopException
-from .utils import read_img
+from .utils import read_img, read_and_validate_img
 from .pyramid import PyramidBase
 
 
@@ -47,11 +47,11 @@ class PyramidTilesStack(PyramidBase):
         return n_steps + self.n_tiles
 
     def _process_single_image_wrapper(self, args):
-        img_path, img_index, _n = args
-        # self.print_message(f": processing file {img_path.split('/')[-1]}, {img_index + 1}/{n}")
-        img = read_img(img_path)
-        level_count = self.process_single_image(img, self.n_levels, img_index)
-        return img_index, level_count
+        img_path, idx, _n = args
+        img = read_and_validate_img(img_path, self.shape, self.dtype)
+        self.check_running(self.cleanup_temp_files)
+        level_count = self.process_single_image(img, self.n_levels, idx)
+        return idx, level_count
 
     def process_single_image(self, img, levels, img_index):
         laplacian = self.single_image_laplacian(img, levels)
@@ -160,10 +160,11 @@ class PyramidTilesStack(PyramidBase):
         gc.collect()
         return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
 
-    def fuse_pyramids(self, all_level_counts, num_images):
+    def fuse_pyramids(self, all_level_counts):
+        num_images = self.num_images()
         max_levels = max(all_level_counts)
         fused = []
-        count = self._steps_per_frame * self.n_frames
+        count = super().total_steps(num_images)
         for level in range(max_levels - 1, -1, -1):
             self.print_message(f': fusing pyramids, layer: {level + 1}')
             if level < self.n_tiled_layers:
@@ -201,12 +202,11 @@ class PyramidTilesStack(PyramidBase):
         return fused[::-1]
 
     def focus_stack(self):
-        n = len(self.filenames)
-        self.focus_stack_validate(self.cleanup_temp_files)
-        all_level_counts = [0] * n
+        all_level_counts = [0] * self.num_images()
         if self.num_threads > 1:
             self.print_message(f': starting parallel processing on {self.num_threads} cores')
-            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            args_list = [(file_path, i, self.num_images())
+                         for i, file_path in enumerate(self.filenames)]
             executor = None
             try:
                 executor = ThreadPoolExecutor(max_workers=self.num_threads)
@@ -222,12 +222,11 @@ class PyramidTilesStack(PyramidBase):
                         all_level_counts[img_index] = level_count
                         completed_count += 1
                         self.print_message(
-                            ": processing completed, image  "
-                            f"{self.idx_tot_str(completed_count - 1)}")
+                            f": processing completed, {self.image_str(completed_count - 1)}")
                     except Exception as e:
                         self.print_message(
-                            f"Error processing image  {self.idx_tot_str(i)}: {str(e)}")
-                    self.after_step(completed_count + n + 1)
+                            f"Error processing {self.image_str(i)}: {str(e)}")
+                    self.after_step(completed_count)
                     self.check_running(lambda: None)
             except RunStopException:
                 self.print_message(": stopping image processing...")
@@ -242,16 +241,15 @@ class PyramidTilesStack(PyramidBase):
         else:
             for i, file_path in enumerate(self.filenames):
                 self.print_message(
-                    f": processing file {os.path.basename(file_path)}, "
-                    f"{self.idx_tot_str(i)}")
+                    f": processing {self.image_str(i)}")
                 img = read_img(file_path)
                 level_count = self.process_single_image(img, self.n_levels, i)
                 all_level_counts[i] = level_count
-                self.after_step(i + n + 1)
+                self.after_step(i + 1)
                 self.check_running(lambda: None)
         try:
             self.check_running(lambda: None)
-            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            fused_pyramid = self.fuse_pyramids(all_level_counts)
             stacked_image = self.collapse(fused_pyramid)
             return stacked_image.astype(self.dtype)
         except RunStopException:

shinestacker/algorithms/stack_framework.py

@@ -117,7 +117,7 @@ class ImageSequenceManager:
         assert False, "this method should be overwritten"
 
     def set_filelist(self):
-        file_folder = self.input_full_path().replace(self.working_path, '').lstrip('/')
+        file_folder = os.path.relpath(self.input_full_path(), self.working_path)
         self.print_message(color_str(f"{self.num_input_filepaths()} files in folder: {file_folder}",
                                      constants.LOG_COLOR_LEVEL_2))
         self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")

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)
@@ -87,6 +93,17 @@ def img_bw(img):
     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
 
+def get_first_image_file(filenames):
+    first_img_file = None
+    for filename in filenames:
+        if os.path.isfile(filename) and extension_tif_jpg(filename):
+            first_img_file = filename
+            break
+    if first_img_file is None:
+        raise ValueError("No valid image files found")
+    return first_img_file
+
+
 def get_img_file_shape(file_path):
     img = read_img(file_path)
     return img.shape[:2]
@@ -106,19 +123,29 @@ def validate_image(img, expected_shape=None, expected_dtype=None):
         raise ShapeError(expected_shape, shape)
     if expected_dtype and dtype != expected_dtype:
         raise BitDepthError(expected_dtype, dtype)
+    return img
+
+
+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/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
 

shinestacker/app/gui_utils.py

@@ -53,3 +53,13 @@ def fill_app_menu(app, app_menu):
     exit_action.setShortcut(quit_short)
     exit_action.triggered.connect(app.quit)
     app_menu.addAction(exit_action)
+
+
+def set_css_style(app):
+    css_style = """
+        QToolTip {
+            color: black;
+            border: 1px solid black;
+        }
+"""
+    app.setStyleSheet(css_style)

shinestacker/app/main.py

@@ -16,7 +16,8 @@ from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
 
@@ -233,6 +234,7 @@ expert options are visible by default.
     app.setWindowIcon(QIcon(icon_path))
     main_app = MainApp()
     app.main_app = main_app
+    set_css_style(app)
     main_app.show()
     main_app.activateWindow()
     if args['expert']:

shinestacker/app/project.py

@@ -14,7 +14,8 @@ config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 
 
@@ -63,6 +64,7 @@ expert options are visible by default.
         disable_macos_special_menu_items()
     icon_path = f"{os.path.dirname(__file__)}/../gui/ico/shinestacker.png"
     app.setWindowIcon(QIcon(icon_path))
+    set_css_style(app)
     window = ProjectApp()
     if args['expert']:
         window.set_expert_options()

shinestacker/app/retouch.py

@@ -9,7 +9,8 @@ from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
 
@@ -60,6 +61,7 @@ Multiple directories can be specified separated by ';'.
         disable_macos_special_menu_items()
     icon_path = f"{os.path.dirname(__file__)}/../gui/ico/shinestacker.png"
     app.setWindowIcon(QIcon(icon_path))
+    set_css_style(app)
     editor = RetouchApp()
     app.editor = editor
     editor.show()

shinestacker/config/gui_constants.py

@@ -63,8 +63,8 @@ class _GuiConstants:
     DEFAULT_CURSOR_STYLE = 'preview'
     BRUSH_LINE_WIDTH = 2
     BRUSH_PREVIEW_LINE_WIDTH = 1.5
-    ZOOM_IN_FACTOR = 1.25
-    ZOOM_OUT_FACTOR = 0.80
+    ZOOM_IN_FACTOR = 1.10
+    ZOOM_OUT_FACTOR = 1 / ZOOM_IN_FACTOR
 
     def calculate_gamma(self):
         if self.BRUSH_SIZES['mid'] <= self.BRUSH_SIZES['min'] or self.BRUSH_SIZES['max'] <= 0: