shinestacker 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.0.4'
+__version__ = '1.1.0'

shinestacker/algorithms/align.py

@@ -6,7 +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, get_img_metadata, validate_image, img_subsample
+from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
 
 _DEFAULT_FEATURE_CONFIG = {
@@ -161,9 +161,10 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     except KeyError as e:
         raise InvalidOptionError("border_mode", alignment_config['border_mode']) from e
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
-    validate_image(img_0, *get_img_metadata(img_1))
     if callbacks and 'message' in callbacks:
         callbacks['message']()
+    h_ref, w_ref = img_1.shape[:2]
+    h0, w0 = img_0.shape[:2]
     subsample = alignment_config['subsample']
     fast_subsampling = alignment_config['fast_subsampling']
     min_good_matches = alignment_config['min_good_matches']
@@ -204,15 +205,14 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
                 flags=2), cv2.COLOR_BGR2RGB)
             plt.figure(figsize=(10, 5))
             plt.imshow(img_match, 'gray')
-            plt.savefig(plot_path)
+            save_plot(plot_path)
             if callbacks and 'save_plot' in callbacks:
                 callbacks['save_plot'](plot_path)
-        h, w = img_0.shape[:2]
         h_sub, w_sub = img_0_sub.shape[:2]
         if subsample > 1:
             if transform == constants.ALIGN_HOMOGRAPHY:
                 low_size = np.float32([[0, 0], [0, h_sub], [w_sub, h_sub], [w_sub, 0]])
-                high_size = np.float32([[0, 0], [0, h], [w, h], [w, 0]])
+                high_size = np.float32([[0, 0], [0, h0], [w0, h0], [w0, 0]])
                 scale_up = cv2.getPerspectiveTransform(low_size, high_size)
                 scale_down = cv2.getPerspectiveTransform(high_size, low_size)
                 m = scale_up @ m @ scale_down
@@ -230,17 +230,17 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
         img_mask = np.ones_like(img_0, dtype=np.uint8)
         if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY:
             img_warp = cv2.warpPerspective(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpPerspective(img_mask, m, (w, h),
+                mask = cv2.warpPerspective(img_mask, m, (w_ref, h_ref),
                                            borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         elif alignment_config['transform'] == constants.ALIGN_RIGID:
             img_warp = cv2.warpAffine(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpAffine(img_mask, m, (w, h),
+                mask = cv2.warpAffine(img_mask, m, (w_ref, h_ref),
                                       borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
             if callbacks and 'blur_message' in callbacks:
@@ -293,7 +293,7 @@ class AlignFrames(SubAction):
             'ecc_message': lambda: self.sub_msg(": ecc refinement"),
             'blur_message': lambda: self.sub_msg(': blur borders'),
             'warning': lambda msg: self.sub_msg(
-                f': {msg}', constants.LOG_COLOR_ALERT),
+                f': {msg}', constants.LOG_COLOR_WARNING),
             'save_plot': lambda plot_path: self.process.callback(
                 'save_plot', self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)
@@ -315,7 +315,7 @@ class AlignFrames(SubAction):
         if n_good_matches < self.min_matches:
             self.process.sub_message(f": image not aligned, too few matches found: "
                                      f"{n_good_matches}", level=logging.CRITICAL)
-            raise AlignmentError(idx, f"too few matches found: "
+            raise AlignmentError(idx, f"Image not aligned, too few matches found: "
                                  f"{n_good_matches} < {self.min_matches}")
         return img
 

shinestacker/algorithms/base_stack_algo.py

@@ -1,9 +1,10 @@
 # pylint: disable=C0114, C0115, C0116, E0602, R0903
+import os
 import numpy as np
-from .. core.exceptions import InvalidOptionError, ImageLoadError
+from .. core.exceptions import InvalidOptionError, ImageLoadError, RunStopException
 from .. config.constants import constants
 from .. core.colors import color_str
-from .utils import read_img, get_img_metadata, validate_image
+from .utils import read_img, get_img_metadata, validate_image, get_img_file_shape, extension_tif_jpg
 
 
 class BaseStackAlgo:
@@ -11,6 +12,9 @@ class BaseStackAlgo:
         self._name = name
         self._steps_per_frame = steps_per_frame
         self.process = None
+        self.filenames = None
+        self.shape = None
+        self.do_step_callback = False
         if float_type == constants.FLOAT_32:
             self.float_type = np.float32
         elif float_type == constants.FLOAT_64:
@@ -24,8 +28,17 @@ class BaseStackAlgo:
     def name(self):
         return self._name
 
-    def steps_per_frame(self):
-        return self._steps_per_frame
+    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)
+
+    def total_steps(self, n_frames):
+        return self._steps_per_frame * n_frames
 
     def print_message(self, msg):
         self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
@@ -40,3 +53,13 @@ class BaseStackAlgo:
         else:
             validate_image(img, *metadata)
         return img, metadata, updated
+
+    def check_running(self, cleanup_callback=None):
+        if self.process.callback('check_running', self.process.id, self.process.name) is False:
+            if cleanup_callback is not None:
+                cleanup_callback()
+            raise RunStopException(self.name)
+
+    def after_step(self, step):
+        if self.do_step_callback:
+            self.process.callback('after_step', self.process.id, self.process.name, step)

shinestacker/algorithms/depth_map.py

@@ -2,7 +2,7 @@
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.exceptions import InvalidOptionError, RunStopException
+from .. core.exceptions import InvalidOptionError
 from .utils import read_img, img_bw
 from .base_stack_algo import BaseStackAlgo
 
@@ -61,19 +61,18 @@ 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 focus_stack(self, filenames):
+    def focus_stack(self):
         gray_images = []
         metadata = None
-        for i, img_path in enumerate(filenames):
+        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)
 
             gray = img_bw(img)
             gray_images.append(gray)
-            self.process.callback('after_step', self.process.id, self.process.name, i)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            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:
@@ -92,7 +91,7 @@ class DepthMapStack(BaseStackAlgo):
             energies = self.smooth_energy(energies)
         weights = self.get_focus_map(energies)
         blended_pyramid = None
-        for i, img_path in enumerate(filenames):
+        for i, img_path in enumerate(self.filenames):
             self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
@@ -110,10 +109,8 @@ 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.process.callback('after_step', self.process.id,
-                                  self.process.name, i + len(filenames))
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            self.after_step(i + len(self.filenames))
+            self.check_running()
         result = blended_pyramid[0]
         self.print_message(': blend levels')
         for j in range(1, self.levels):

shinestacker/algorithms/noise_detection.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E1101, W0718, R0914, R0915
+# pylint: disable=C0114, C0115, C0116, E1101, W0718, R0914, R0915, R0902
 import os
 import errno
 import logging
@@ -11,7 +11,7 @@ from .. core.colors import color_str
 from .. core.exceptions import ImageLoadError
 from .. core.framework import JobBase
 from .. core.core_utils import make_tqdm_bar
-from .. core.exceptions import RunStopException
+from .. core.exceptions import RunStopException, ShapeError
 from .stack_framework import FrameMultiDirectory, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
@@ -154,6 +154,7 @@ class MaskNoise(SubAction):
         self.method = method
         self.process = None
         self.noise_mask_img = None
+        self.expected_shape = None
 
     def begin(self, process):
         self.process = process
@@ -163,6 +164,7 @@ class MaskNoise(SubAction):
                 f': reading noisy pixel mask file: {self.noise_mask}',
                 constants.LOG_COLOR_LEVEL_3))
             self.noise_mask_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            self.expected_shape = self.noise_mask_img.shape[:2]
             if self.noise_mask_img is None:
                 raise ImageLoadError(path, f"failed to load image file {self.noise_mask}.")
         else:
@@ -170,6 +172,9 @@ class MaskNoise(SubAction):
 
     def run_frame(self, _idx, _ref_idx, image):
         self.process.sub_message_r(color_str(': mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
+        shape = image.shape[:2]
+        if shape != self.expected_shape:
+            raise ShapeError(self.expected_shape, shape)
         if len(image.shape) == 3:
             corrected = image.copy()
             for c in range(3):

shinestacker/algorithms/pyramid.py

@@ -1,25 +1,36 @@
-# pylint: disable=C0114, C0115, C0116, E1101
+# pylint: disable=C0114, C0115, C0116, E1101, R0913, R0917, R0902
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.exceptions import RunStopException
 from .utils import read_img
 from .base_stack_algo import BaseStackAlgo
 
 
 class PyramidBase(BaseStackAlgo):
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+    def __init__(self, name, min_size=constants.DEFAULT_PY_MIN_SIZE,
                  kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
                  gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
                  float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__("pyramid", 2, float_type)
+        super().__init__(name, 2, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
-        self.do_step_callback = False
         kernel = np.array([0.25 - gen_kernel / 2.0, 0.25,
                            gen_kernel, 0.25, 0.25 - gen_kernel / 2.0])
         self.gen_kernel = np.outer(kernel, kernel)
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
+        self.n_levels = 0
+        self.n_frames = 0
+
+    def init(self, filenames):
+        super().init(filenames)
+        self.n_levels = int(np.log2(min(self.shape) / self.min_size))
+
+    def total_steps(self, n_frames):
+        self.n_frames = n_frames
+        return self._steps_per_frame * n_frames + self.n_levels
 
     def convolve(self, image):
         return cv2.filter2D(image, -1, self.gen_kernel, borderType=cv2.BORDER_REFLECT101)
@@ -55,6 +66,7 @@ class PyramidBase(BaseStackAlgo):
         return fused
 
     def collapse(self, pyramid):
+        self.print_message(': collapsing pyramid')
         img = pyramid[-1]
         for layer in pyramid[-2::-1]:
             expanded = self.expand_layer(img)
@@ -110,19 +122,22 @@ 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 {img_path.split('/')[-1]}")
 
-class PyramidStack(PyramidBase):
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
-                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
-                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
-                 float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__(min_size, kernel_size, gen_kernel, float_type)
-        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
-        self.dtype = None
-        self.num_pixel_values = None
-        self.max_pixel_value = None
+            _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 process_single_image(self, img, levels):
+    def single_image_laplacian(self, img, levels):
         pyramid = [img.astype(self.float_type)]
         for _ in range(levels):
             next_layer = self.reduce_layer(pyramid[-1])
@@ -136,44 +151,43 @@ class PyramidStack(PyramidBase):
             h, w = pyr.shape[:2]
             expanded = expanded[:h, :w]
             laplacian.append(pyr - expanded)
+        return laplacian
+
+
+class PyramidStack(PyramidBase):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT):
+        super().__init__("pyramid", min_size, kernel_size, gen_kernel, float_type)
+        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
+
+    def process_single_image(self, img, levels):
+        laplacian = self.single_image_laplacian(img, levels)
         return laplacian[::-1]
 
     def fuse_pyramids(self, all_laplacians):
         fused = [self.get_fused_base(np.stack([p[-1] for p in all_laplacians], axis=0))]
+        count = 0
         for layer in range(len(all_laplacians[0]) - 2, -1, -1):
             self.print_message(f': fusing pyramids, layer: {layer + 1}')
             laplacians = np.stack([p[layer] for p in all_laplacians], axis=0)
             fused.append(self.fuse_laplacian(laplacians))
+            count += 1
+            self.after_step(self._steps_per_frame * self.n_frames + count)
+            self.check_running()
         self.print_message(': pyramids fusion completed')
         return fused[::-1]
 
-    def focus_stack(self, filenames):
-        metadata = None
+    def focus_stack(self):
+        n = len(self.filenames)
+        self.focus_stack_validate()
         all_laplacians = []
-        levels = None
-        n = len(filenames)
-        for i, img_path in enumerate(filenames):
-            self.print_message(f": validating file {img_path.split('/')[-1]}")
-
-            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
-                levels = int(np.log2(min(img.shape[:2]) / self.min_size))
-            if self.do_step_callback:
-                self.process.callback('after_step', self.process.id, self.process.name, i)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
-        for i, img_path in enumerate(filenames):
+        for i, img_path in enumerate(self.filenames):
             self.print_message(f": processing file {img_path.split('/')[-1]}")
             img = read_img(img_path)
-            all_laplacians.append(self.process_single_image(img, levels))
-            if self.do_step_callback:
-                self.process.callback('after_step', self.process.id, self.process.name, i + n)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            all_laplacians.append(self.process_single_image(img, self.n_levels))
+            self.after_step(i + n + 1)
+            self.check_running()
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))
         return stacked_image.astype(self.dtype)

shinestacker/algorithms/pyramid_tiles.py

@@ -0,0 +1,109 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913, R0917, R0912, R0915
+import os
+import tempfile
+import numpy as np
+from .. config.constants import constants
+from .utils import read_img
+from .pyramid import PyramidBase
+
+
+class PyramidTilesStack(PyramidBase):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT,
+                 tile_size=constants.DEFAULT_PY_TILE_SIZE):
+        super().__init__("fast_pyramid", min_size, kernel_size, gen_kernel, float_type)
+        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
+        self.tile_size = tile_size
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.n_tiles = 0
+
+    def init(self, filenames):
+        super().init(filenames)
+        self.n_tiles = (self.shape[0] // self.tile_size + 1) * (self.shape[1] // self.tile_size + 1)
+
+    def total_steps(self, n_frames):
+        n_steps = super().total_steps(n_frames)
+        return n_steps + self.n_tiles
+
+    def process_single_image(self, img, levels, img_index):
+        laplacian = self.single_image_laplacian(img, levels)
+        for i, level_data in enumerate(laplacian[::-1]):
+            np.save(os.path.join(self.temp_dir.name, f'img_{img_index}_level_{i}.npy'), level_data)
+        return len(laplacian)
+
+    def load_level(self, img_index, level):
+        return np.load(os.path.join(self.temp_dir.name, f'img_{img_index}_level_{level}.npy'))
+
+    def cleanup_temp_files(self):
+        self.temp_dir.cleanup()
+
+    def fuse_pyramids(self, all_level_counts, num_images):
+        max_levels = max(all_level_counts)
+        fused = []
+        count = self._steps_per_frame * self.n_frames
+        for level in range(max_levels - 1, -1, -1):
+            self.print_message(f': fusing pyramids, layer: {level + 1}')
+            if level == 0:
+                sample_level = self.load_level(0, 0)
+                h, w = sample_level.shape[:2]
+                del sample_level
+                fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+                for y in range(0, h, self.tile_size):
+                    for x in range(0, w, self.tile_size):
+                        y_end = min(y + self.tile_size, h)
+                        x_end = min(x + self.tile_size, w)
+                        self.print_message(f': fusing tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                        laplacians = []
+                        for img_index in range(num_images):
+                            if level < all_level_counts[img_index]:
+                                full_laplacian = self.load_level(img_index, level)
+                                tile = full_laplacian[y:y_end, x:x_end]
+                                laplacians.append(tile)
+                                del full_laplacian
+                        stacked = np.stack(laplacians, axis=0)
+                        fused_tile = self.fuse_laplacian(stacked)
+                        fused_level[y:y_end, x:x_end] = fused_tile
+                        del laplacians, stacked, fused_tile
+                        self.after_step(count)
+                        self.check_running(self.cleanup_temp_files)
+                        count += 1
+            else:
+                laplacians = []
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        laplacian = self.load_level(img_index, level)
+                        laplacians.append(laplacian)
+                if level == max_levels - 1:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.get_fused_base(stacked)
+                else:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.fuse_laplacian(stacked)
+                    self.check_running(self.cleanup_temp_files)
+            fused.append(fused_level)
+            count += 1
+            self.after_step(count)
+            self.check_running(self.cleanup_temp_files)
+        self.print_message(': pyramids fusion completed')
+        return fused[::-1]
+
+    def focus_stack(self):
+        n = len(self.filenames)
+        self.focus_stack_validate(self.cleanup_temp_files)
+        all_level_counts = []
+        for i, img_path in enumerate(self.filenames):
+            self.print_message(f": processing file {img_path.split('/')[-1]}")
+            img = read_img(img_path)
+            level_count = self.process_single_image(img, self.n_levels, i)
+            all_level_counts.append(level_count)
+            self.after_step(i + n + 1)
+            self.check_running(self.cleanup_temp_files)
+        fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+        stacked_image = self.collapse(fused_pyramid)
+        self.cleanup_temp_files()
+        return stacked_image.astype(self.dtype)

shinestacker/algorithms/stack.py

@@ -5,7 +5,7 @@ from .. config.constants import constants
 from .. core.framework import JobBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
-from .utils import write_img
+from .utils import write_img, extension_tif_jpg
 from .stack_framework import FrameDirectory, ActionList
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
@@ -25,8 +25,7 @@ class FocusStackBase(JobBase, FrameDirectory):
 
     def focus_stack(self, filenames):
         self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
-        img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
-        stacked_img = self.stack_algo.focus_stack(img_files)
+        stacked_img = self.stack_algo.focus_stack()
         in_filename = filenames[0].split(".")
         out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + \
             '.'.join(in_filename[1:])
@@ -37,8 +36,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')
             _dirpath, _, fnames = next(os.walk(self.exif_path))
-            fnames = [name for name in fnames
-                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            fnames = [name for name in fnames if extension_tif_jpg(name)]
             exif_filename = f"{self.exif_path}/{fnames[0]}"
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
@@ -52,6 +50,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
+        FrameDirectory.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
@@ -79,7 +78,6 @@ class FocusStackBunch(ActionList, FocusStackBase):
                                      "overlap must be smaller than batch size")
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)
 
     def begin(self):
@@ -94,6 +92,9 @@ class FocusStackBunch(ActionList, FocusStackBase):
     def run_step(self):
         self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
                                        constants.LOG_COLOR_LEVEL_2))
+        img_files = [os.path.join(self.input_full_path, name)
+                     for name in self._chunks[self.count - 1]]
+        self.stack_algo.init(img_files)
         self.focus_stack(self._chunks[self.count - 1])
 
 
@@ -101,13 +102,15 @@ class FocusStack(FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
         super().__init__(name, stack_algo, enabled, **kwargs)
         self.stack_algo.do_step_callback = True
+        self.shape = None
 
     def run_core(self):
         self.set_filelist()
+        img_files = sorted([os.path.join(self.input_full_path, name) for name in self.filenames])
+        self.stack_algo.init(img_files)
         self.callback('step_counts', self.id, self.name,
-                      self.stack_algo.steps_per_frame() * len(self.filenames))
+                      self.stack_algo.total_steps(len(self.filenames)))
         self.focus_stack(self.filenames)
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)

shinestacker/algorithms/stack_framework.py

@@ -7,7 +7,7 @@ from .. core.colors import color_str
 from .. core.framework import Job, ActionList
 from .. core.core_utils import check_path_exists
 from .. core.exceptions import ShapeError, BitDepthError, RunStopException
-from .utils import read_img, write_img
+from .utils import read_img, write_img, extension_tif_jpg
 
 
 class StackJob(Job):
@@ -50,8 +50,8 @@ class FramePaths:
 
     def set_filelist(self):
         self.filenames = self.folder_filelist()
-        file_list = self.input_full_path.replace(self.working_path, '').lstrip('/')
-        self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_list}",
+        file_folder = self.input_full_path.replace(self.working_path, '').lstrip('/')
+        self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_folder}",
                                      constants.LOG_COLOR_LEVEL_2))
 
     def init(self, job):
@@ -113,8 +113,7 @@ class FrameDirectory(FramePaths):
     def folder_filelist(self):
         src_contents = os.walk(self.input_full_path)
         _dirpath, _, filenames = next(src_contents)
-        filelist = [name for name in filenames
-                    if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+        filelist = [name for name in filenames if extension_tif_jpg(name)]
         filelist.sort()
         if self.reverse_order:
             filelist.reverse()
@@ -159,9 +158,7 @@ class FrameMultiDirectory(FramePaths):
         for d, p in zip(dirs, paths):
             filelist = []
             for _dirpath, _, filenames in os.walk(d):
-                filelist = [p + "/" + name
-                            for name in filenames
-                            if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+                filelist = [f"{p}/{name}" for name in filenames if extension_tif_jpg(name)]
                 if self.reverse_order:
                     filelist.reverse()
                 if self.resample > 1:

shinestacker/algorithms/utils.py

@@ -87,6 +87,11 @@ def img_bw(img):
     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
 
+def get_img_file_shape(file_path):
+    img = read_img(file_path)
+    return img.shape[:2]
+
+
 def get_img_metadata(img):
     if img is None:
         return None, None

shinestacker/config/constants.py

@@ -34,14 +34,16 @@ class _Constants:
     SUB_ACTION_TYPES = [ACTION_MASKNOISE, ACTION_VIGNETTING, ACTION_ALIGNFRAMES,
                         ACTION_BALANCEFRAMES]
     STACK_ALGO_PYRAMID = 'Pyramid'
+    STACK_ALGO_PYRAMID_TILES = 'Pyramid Tiles'
     STACK_ALGO_DEPTH_MAP = 'Depth map'
-    STACK_ALGO_OPTIONS = [STACK_ALGO_PYRAMID, STACK_ALGO_DEPTH_MAP]
+    STACK_ALGO_OPTIONS = [STACK_ALGO_PYRAMID, STACK_ALGO_PYRAMID_TILES, STACK_ALGO_DEPTH_MAP]
     STACK_ALGO_DEFAULT = STACK_ALGO_PYRAMID
     DEFAULT_PLOTS_PATH = 'plots'
 
     PATH_SEPARATOR = ';'
 
     LOG_COLOR_ALERT = 'red'
+    LOG_COLOR_WARNING = 'yellow'
     LOG_COLOR_LEVEL_JOB = 'green'
     LOG_COLOR_LEVEL_1 = 'blue'
     LOG_COLOR_LEVEL_2 = 'magenta'
@@ -107,7 +109,7 @@ class _Constants:
     DEFAULT_BORDER_BLUR = 50
     DEFAULT_ALIGN_SUBSAMPLE = 2
     DEFAULT_ALIGN_FAST_SUBSAMPLING = False
-    DEFAULT_ALIGN_MIN_GOOD_MATCHES = 100
+    DEFAULT_ALIGN_MIN_GOOD_MATCHES = 50
 
     BALANCE_LINEAR = "LINEAR"
     BALANCE_GAMMA = "GAMMA"
@@ -160,6 +162,7 @@ class _Constants:
     DEFAULT_PY_MIN_SIZE = 32
     DEFAULT_PY_KERNEL_SIZE = 5
     DEFAULT_PY_GEN_KERNEL = 0.4
+    DEFAULT_PY_TILE_SIZE = 512
 
     DEFAULT_PLOT_STACK_BUNCH = False
     DEFAULT_PLOT_STACK = True

shinestacker/gui/action_config_dialog.py

@@ -156,8 +156,8 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
         combo = self.builder.add_field('stacker', FIELD_COMBO, 'Stacking algorithm', required=True,
                                        options=constants.STACK_ALGO_OPTIONS,
                                        default=constants.STACK_ALGO_DEFAULT)
-        q_pyramid, q_depthmap = QWidget(), QWidget()
-        for q in [q_pyramid, q_depthmap]:
+        q_pyramid, q_pyramid_tiles, q_depthmap = QWidget(), QWidget(), QWidget()
+        for q in [q_pyramid, q_pyramid_tiles, q_depthmap]:
             layout = QFormLayout()
             layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
             layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
@@ -166,13 +166,16 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             q.setLayout(layout)
         stacked = QStackedWidget()
         stacked.addWidget(q_pyramid)
+        stacked.addWidget(q_pyramid_tiles)
         stacked.addWidget(q_depthmap)
 
         def change():
             text = combo.currentText()
-            if text == 'Pyramid':
+            if text == constants.STACK_ALGO_PYRAMID:
                 stacked.setCurrentWidget(q_pyramid)
-            elif text == 'Depth map':
+            if text == constants.STACK_ALGO_PYRAMID_TILES:
+                stacked.setCurrentWidget(q_pyramid_tiles)
+            elif text == constants.STACK_ALGO_DEPTH_MAP:
                 stacked.setCurrentWidget(q_depthmap)
         change()
         if self.expert:
@@ -191,6 +194,25 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
                                    options=self.FLOAT_OPTIONS, values=constants.VALID_FLOATS,
                                    default=dict(zip(constants.VALID_FLOATS,
                                                 self.FLOAT_OPTIONS))[constants.DEFAULT_PY_FLOAT])
+            self.builder.add_field('tiles_pyramid_min_size', FIELD_INT, 'Minimum size (px)',
+                                   required=False, add_to_layout=q_pyramid_tiles.layout(),
+                                   default=constants.DEFAULT_PY_MIN_SIZE, min_val=2, max_val=256)
+            self.builder.add_field('tiles_pyramid_kernel_size', FIELD_INT, 'Kernel size (px)',
+                                   required=False, add_to_layout=q_pyramid_tiles.layout(),
+                                   default=constants.DEFAULT_PY_KERNEL_SIZE, min_val=3, max_val=21)
+            self.builder.add_field('tiles_pyramid_gen_kernel', FIELD_FLOAT, 'Gen. kernel',
+                                   required=False, add_to_layout=q_pyramid_tiles.layout(),
+                                   default=constants.DEFAULT_PY_GEN_KERNEL,
+                                   min_val=0.0, max_val=2.0)
+            self.builder.add_field('tiles_pyramid_float_type', FIELD_COMBO, 'Precision',
+                                   required=False, add_to_layout=q_pyramid_tiles.layout(),
+                                   options=self.FLOAT_OPTIONS, values=constants.VALID_FLOATS,
+                                   default=dict(zip(constants.VALID_FLOATS,
+                                                self.FLOAT_OPTIONS))[constants.DEFAULT_PY_FLOAT])
+            self.builder.add_field('tiles_pyramid_tile_size', FIELD_INT, 'Tile size (px)',
+                                   required=False, add_to_layout=q_pyramid_tiles.layout(),
+                                   default=constants.DEFAULT_PY_TILE_SIZE,
+                                   min_val=128, max_val=2048)
         self.builder.add_field('depthmap_energy', FIELD_COMBO, 'Energy', required=False,
                                add_to_layout=q_depthmap.layout(),
                                options=self.ENERGY_OPTIONS, values=constants.VALID_DM_ENERGY,

shinestacker/gui/flow_layout.py

@@ -0,0 +1,105 @@
+# pylint: disable=C0114, C0115, C0116, E0611, C0103, R0914
+from PySide6.QtWidgets import QLayout
+from PySide6.QtCore import Qt, QRect, QSize, QPoint
+
+
+class FlowLayout(QLayout):
+    def __init__(self, parent=None, margin=0, spacing=-1, justify=True):
+        super().__init__(parent)
+        self._item_list = []
+        self._justify = justify
+        self.setContentsMargins(margin, margin, margin, margin)
+        self.setSpacing(spacing)
+
+    def addItem(self, item):
+        self._item_list.append(item)
+
+    def count(self):
+        return len(self._item_list)
+
+    def itemAt(self, index):
+        if 0 <= index < len(self._item_list):
+            return self._item_list[index]
+        return None
+
+    def takeAt(self, index):
+        if 0 <= index < len(self._item_list):
+            return self._item_list.pop(index)
+        return None
+
+    def expandingDirections(self):
+        return Qt.Orientations(0)
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        return self._do_layout(QRect(0, 0, width, 0), True)
+
+    def setGeometry(self, rect):
+        super().setGeometry(rect)
+        self._do_layout(rect, False)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+        for item in self._item_list:
+            size = size.expandedTo(item.minimumSize())
+        margins = self.contentsMargins()
+        size += QSize(margins.left() + margins.right(), margins.top() + margins.bottom())
+        return size
+
+    def setJustify(self, justify):
+        self._justify = justify
+        self.invalidate()
+
+    def justify(self):
+        return self._justify
+
+    def _do_layout(self, rect, test_only):
+        x = rect.x()
+        y = rect.y()
+        line_height = 0
+        spacing = self.spacing()
+        lines = []
+        current_line = []
+        current_line_width = 0
+        for item in self._item_list:
+            space_x = spacing
+            next_x = x + item.sizeHint().width() + space_x
+            if next_x - space_x > rect.right() and line_height > 0:
+                lines.append((current_line, current_line_width, line_height))
+                x = rect.x()
+                y = y + line_height + spacing
+                next_x = x + item.sizeHint().width() + space_x
+                current_line = []
+                current_line_width = 0
+                line_height = 0
+            current_line.append(item)
+            current_line_width += item.sizeHint().width()
+            x = next_x
+            line_height = max(line_height, item.sizeHint().height())
+        if current_line:
+            lines.append((current_line, current_line_width, line_height))
+        y_offset = rect.y()
+        for line, line_width, line_height in lines:
+            if not test_only:
+                available_width = rect.width() - (len(line) - 1) * spacing
+                if self._justify and len(line) > 1:
+                    stretch_factor = available_width / line_width if line_width > 0 else 1
+                    x_offset = rect.x()
+                    for item in line:
+                        item_width = int(item.sizeHint().width() * stretch_factor)
+                        item.setGeometry(QRect(QPoint(x_offset, y_offset),
+                                               QSize(item_width, line_height)))
+                        x_offset += item_width + spacing
+                else:
+                    x_offset = rect.x()
+                    for item in line:
+                        item.setGeometry(QRect(QPoint(x_offset, y_offset),
+                                         item.sizeHint()))
+                        x_offset += item.sizeHint().width() + spacing
+            y_offset += line_height + spacing
+        return y_offset - spacing - rect.y()

shinestacker/gui/gui_run.py

@@ -1,5 +1,6 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0903, R0915, R0914, R0917, R0913, R0902
 import os
+import traceback
 from PySide6.QtWidgets import (QWidget, QPushButton, QVBoxLayout, QHBoxLayout,
                                QMessageBox, QScrollArea, QSizePolicy, QFrame, QLabel, QComboBox)
 from PySide6.QtGui import QColor
@@ -16,6 +17,7 @@ from .colors import (
     ACTION_RUNNING_COLOR, ACTION_COMPLETED_COLOR,
     ACTION_STOPPED_COLOR, ACTION_FAILED_COLOR)
 from .time_progress_bar import TimerProgressBar
+from .flow_layout import FlowLayout
 
 
 class ColorButton(QPushButton):
@@ -55,12 +57,12 @@ class RunWindow(QTextEditLogger):
             for label_row in labels:
                 self.color_widgets.append([])
                 row = QWidget(self)
-                h_layout = QHBoxLayout(row)
+                h_layout = FlowLayout(row)  # QHBoxLayout(row)
                 h_layout.setContentsMargins(0, 0, 0, 0)
                 h_layout.setSpacing(2)
                 for label, enabled in label_row:
                     widget = ColorButton(label, enabled)
-                    h_layout.addWidget(widget, stretch=1)
+                    h_layout.addWidget(widget)  # addWidget(widget, stretch=1)
                     self.color_widgets[-1].append(widget)
                 layout.addWidget(row)
         self.progress_bar = TimerProgressBar()
@@ -202,23 +204,26 @@ class RunWindow(QTextEditLogger):
         label = QLabel(name, self)
         label.setStyleSheet("QLabel {margin-top: 5px; font-weight: bold;}")
         self.image_layout.addWidget(label)
-        if extension_pdf(path):
-            image_view = GuiPdfView(path, self)
-        elif extension_tif_jpg(path):
-            image_view = GuiImageView(path, self)
-        else:
-            raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
-        self.image_views.append(image_view)
-        self.image_layout.addWidget(image_view)
-        max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
-        needed_width = max_width + 20
-        self.right_area.setFixedWidth(needed_width)
-        self.image_area_widget.setFixedWidth(needed_width)
-        self.right_area.updateGeometry()
-        self.image_area_widget.updateGeometry()
-        QTimer.singleShot(
-            0, lambda: self.right_area.verticalScrollBar().setValue(
-                self.right_area.verticalScrollBar().maximum()))
+        try:
+            if extension_pdf(path):
+                image_view = GuiPdfView(path, self)
+            elif extension_tif_jpg(path):
+                image_view = GuiImageView(path, self)
+            else:
+                raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
+            self.image_views.append(image_view)
+            self.image_layout.addWidget(image_view)
+            max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
+            needed_width = max_width + 20
+            self.right_area.setFixedWidth(needed_width)
+            self.image_area_widget.setFixedWidth(needed_width)
+            self.right_area.updateGeometry()
+            self.image_area_widget.updateGeometry()
+            QTimer.singleShot(
+                0, lambda: self.right_area.verticalScrollBar().setValue(
+                    self.right_area.verticalScrollBar().maximum()))
+        except RuntimeError as e:
+            traceback.print_tb(e.__traceback__)
 
     @Slot(int, str, str, str)
     def handle_open_app(self, _run_id, name, app, path):

shinestacker/gui/main_window.py

@@ -406,8 +406,8 @@ class MainWindow(QMainWindow, LogManager):
         if self.job_list_count() == 0:
             self.menu_manager.add_action_entry_action.setEnabled(False)
             self.menu_manager.action_selector.setEnabled(False)
-            self.run_job_action.setEnabled(False)
-            self.run_all_jobs_action.setEnabled(False)
+            self.menu_manager.run_job_action.setEnabled(False)
+            self.menu_manager.run_all_jobs_action.setEnabled(False)
         else:
             self.menu_manager.add_action_entry_action.setEnabled(True)
             self.menu_manager.action_selector.setEnabled(True)

shinestacker/gui/new_project.py

@@ -110,6 +110,7 @@ class NewProjectDialog(BaseFormDialog):
             self.layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
         else:
             self.layout.addRow("Focus stack:", self.focus_stack_pyramid)
+        if self.expert():
             self.layout.addRow("Save multi layer TIFF:", self.multi_layer)
         self.add_label("")
         self.add_bold_label("3️⃣ Push 🆗 for further options, then press ▶️ to run.")

shinestacker/gui/project_controller.py

@@ -290,6 +290,7 @@ class ProjectController(QObject):
             with open(file_path, 'w', encoding="utf-8") as f:
                 f.write(json_obj)
             self.mark_as_modified(False)
+            self.update_title_requested.emit()
         except Exception as e:
             QMessageBox.critical(self.parent, "Error", f"Cannot save file:\n{str(e)}")
 

shinestacker/gui/project_converter.py

@@ -10,6 +10,7 @@ from .. algorithms.align import AlignFrames
 from .. algorithms.balance import BalanceFrames
 from .. algorithms.stack import FocusStack, FocusStackBunch
 from .. algorithms.pyramid import PyramidStack
+from .. algorithms.pyramid_tiles import PyramidTilesStack
 from .. algorithms.depth_map import DepthMapStack
 from .. algorithms.multilayer import MultiLayer
 from .project_model import Project, ActionConfig
@@ -104,21 +105,26 @@ class ProjectConverter:
                                        constants.ACTION_FOCUSSTACKBUNCH):
             stacker = action_config.params.get('stacker', constants.STACK_ALGO_DEFAULT)
             if stacker == constants.STACK_ALGO_PYRAMID:
-                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'pyramid_')
+                algo_dict, module_dict = self.filter_dict_keys(
+                    action_config.params, 'pyramid_')
                 stack_algo = PyramidStack(**algo_dict)
+            elif stacker == constants.STACK_ALGO_PYRAMID_TILES:
+                algo_dict, module_dict = self.filter_dict_keys(
+                    action_config.params, 'tiles_pyramid_')
+                stack_algo = PyramidTilesStack(**algo_dict)
             elif stacker == constants.STACK_ALGO_DEPTH_MAP:
-                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'depthmap_')
+                algo_dict, module_dict = self.filter_dict_keys(
+                    action_config.params, 'depthmap_')
                 stack_algo = DepthMapStack(**algo_dict)
             else:
                 raise InvalidOptionError('stacker', stacker, f"valid options are: "
                                          f"{constants.STACK_ALGO_PYRAMID}, "
+                                         f"{constants.STACK_ALGO_PYRAMID_TILES}, "
                                          f"{constants.STACK_ALGO_DEPTH_MAP}")
             if action_config.type_name == constants.ACTION_FOCUSSTACK:
                 return FocusStack(**module_dict, stack_algo=stack_algo)
             if action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
                 return FocusStackBunch(**module_dict, stack_algo=stack_algo)
-            raise InvalidOptionError(
-                "stracker", stacker, details="valid values are: Pyramid, Depth map.")
         if action_config.type_name == constants.ACTION_MULTILAYER:
             input_path = list(filter(lambda p: p != '',
                               action_config.params.get('input_path', '').split(";")))

shinestacker/gui/time_progress_bar.py

@@ -39,8 +39,8 @@ class TimerProgressBar(QProgressBar):
         """)
 
     def time_str(self, secs):
-        ss = int(secs)
-        x = secs - ss
+        x = secs % 1
+        ss = int(secs // 1)
         s = ss % 60
         mm = ss // 60
         m = mm % 60

{shinestacker-1.0.4.dist-info → shinestacker-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.0.4
+Version: 1.1.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -69,6 +69,25 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
 
+# Note for macOS users
+
+**The following note is only relevant if you download the application as compressed archive from the [release page](https://github.com/lucalista/shinestacker/releases).**
+
+The macOS system security protection prevent to run applications downloaded from the web that come from developers that don't hold an Apple Developer Certificate. 
+
+In order to prevent this, follow the instructions below:
+
+1. Download the compressed archive ```shinestacker-macos.tar.gz``` in your ```Download``` folder.
+2. Double-click the archive to uncompress it. You will find a new folder ```shinestacker```.
+3. Open a terminal (*Applications > Utilities > Terminal*)
+4. Type the folliwng command on the terminal:
+```bash
+xattr -cr ~/Downloads/shinestacker/shinestacker.app
+```
+5. Now you can double-click the Sine Stacker icon app in the ```shiestacker``` folder and it should run.
+
+macOS adds a quarantine flag to all files downloaded from the internet. The above command removes that flag while preserving all other application functionality.
+
 # Resources
 
  🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 

{shinestacker-1.0.4.dist-info → shinestacker-1.1.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
 shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
-shinestacker/_version.py,sha256=Oi2b5pm3sFbESQW0xgj8kqwDPX_Hxmx4gNILYpLzYqI,21
+shinestacker/_version.py,sha256=XIz3qAg9G9YysQi3Ryp0CN3rtc_JiecHZ9L2vEzcM6s,21
 shinestacker/algorithms/__init__.py,sha256=c4kRrdTLlVI70Q16XkI1RSmz5MD7npDqIpO_02jTG6g,747
-shinestacker/algorithms/align.py,sha256=XT4DJoD5ZvpkC1-J3W3GWmWRsXJg3qJ-3zr9erT8oW0,17514
+shinestacker/algorithms/align.py,sha256=EhsV50QtpLSJG0uDMfOJw89u8CGFJvBC2sYuJg5cv6g,17516
 shinestacker/algorithms/balance.py,sha256=iSjO-pl0vQv58iEQ077EUcDTAExMKDBdtXmJXbMhazk,16721
-shinestacker/algorithms/base_stack_algo.py,sha256=AFV2QkcFNaTcnISpsWHuAVy2De9hhaPcBNjE1O0h50I,1430
+shinestacker/algorithms/base_stack_algo.py,sha256=O7pDXqLM8MBdLR634Vk3UNV6cEV2q0U7CNcnpC_AOig,2363
 shinestacker/algorithms/denoise.py,sha256=GL3Z4_6MHxSa7Wo4ZzQECZS87tHBFqO0sIVF_jPuYQU,426
-shinestacker/algorithms/depth_map.py,sha256=FOR5M0brO5-9NnXDY7TWpc3OtKKSuzrOSoBMe0cP6Ho,6076
+shinestacker/algorithms/depth_map.py,sha256=KVThrnynPKuijlh-DrenSkdkZ0Qm6TaNMYKhRByhcN4,5682
 shinestacker/algorithms/exif.py,sha256=SM4ZDDe8hCJ3xY6053FNndOiwzEStzdp0WrXurlcHVc,9429
 shinestacker/algorithms/multilayer.py,sha256=-pQXDlooSMGKPhMgF-_naXdkGdolclYvSD-RrjwLiyI,9328
-shinestacker/algorithms/noise_detection.py,sha256=CDnN8pglxufY5Y-dT3mVooD4zPySdSq9CMgtDGMXBnA,8970
-shinestacker/algorithms/pyramid.py,sha256=_Pk19lRQ21b3W3aHQ6DgAe9VVOfbsi2a9jrynF0qFVw,8610
+shinestacker/algorithms/noise_detection.py,sha256=CJb57mE7ePJBgrwnsEkeK8xVIl2Hrzti11ZEI6JQczs,9218
+shinestacker/algorithms/pyramid.py,sha256=cxwA6gf02009dFv5-m79NpJkD58-Wbu3im4bfA5HVUc,8822
+shinestacker/algorithms/pyramid_tiles.py,sha256=967L42MfwSOewisqpAzuXivZgVoKZbIjDIQVWP1_rHk,5094
 shinestacker/algorithms/sharpen.py,sha256=h7PMJBYxucg194Usp_6pvItPUMFYbT-ebAc_-7XBFUw,949
-shinestacker/algorithms/stack.py,sha256=FCU89Of-s6C_DuMleG06c8V6fnIm9MFInvkkKtTsGBo,4906
-shinestacker/algorithms/stack_framework.py,sha256=peAlUUl7y8OcquhjQoXpiwsEhZw6zgZnzwt1IDpf4aU,12466
-shinestacker/algorithms/utils.py,sha256=0AeMVaFuhpUiIpUUFqrqAJ_-ohGVdX7-EdMyLoVflbg,3279
+shinestacker/algorithms/stack.py,sha256=T1y-qoYUNzcIpnhKcou_4ifiKtGC2ZA1bOZXlfnKB6A,5045
+shinestacker/algorithms/stack_framework.py,sha256=fHdU8uYZquRut6NW_1vHbTCjPD99gQfOhVDdaaLZH34,12334
+shinestacker/algorithms/utils.py,sha256=GSKPUxU98Q8F0k4TgY9ydEgBul1gf2I0ypdmyDm--Mg,3371
 shinestacker/algorithms/vignetting.py,sha256=yW-1TF4tesLWfKQOS0XxRkOEN82U-YDmMaj09C9cH4M,9552
 shinestacker/algorithms/white_balance.py,sha256=PMKsBtxOSn5aRr_Gkx1StHS4eN6kBN2EhNnhg4UG24g,501
 shinestacker/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -26,7 +27,7 @@ shinestacker/app/project.py,sha256=W0u715LZne_PNJvg9msSy27ybIjgDXiEAQdJ7_6BjYI,2
 shinestacker/app/retouch.py,sha256=ZQ-nRKnHo6xurcP34RNqaAWkmuGBjJ5jE05hTQ_ycis,2482
 shinestacker/config/__init__.py,sha256=aXxi-LmAvXd0daIFrVnTHE5OCaYeK1uf1BKMr7oaXQs,197
 shinestacker/config/config.py,sha256=eBko2D3ADhLTIm9X6hB_a_WsIjwgfE-qmBVkhP1XSvc,1636
-shinestacker/config/constants.py,sha256=l7RcRxXlIThkBXcy2GVRBWFZQRXNgqYShNEVfDpgjEU,6096
+shinestacker/config/constants.py,sha256=X9e0fXr7ZHN9DCEMiObpanNJfZ5cMgWJdm3Xybmh-Wk,6232
 shinestacker/config/gui_constants.py,sha256=5DR-ET1oeMMD7lIsjvAwSuln89A7I9wy9VuAeRo2G64,2575
 shinestacker/core/__init__.py,sha256=IUEIx6SQ3DygDEHN3_E6uKpHjHtUa4a_U_1dLd_8yEU,484
 shinestacker/core/colors.py,sha256=kr_tJA1iRsdck2JaYDb2lS-codZ4Ty9gdu3kHfiWvuM,1340
@@ -36,22 +37,23 @@ shinestacker/core/framework.py,sha256=zCnJuQrHNpwEgJW23_BgS7iQrLolRWTAMB1oRp_a7K
 shinestacker/core/logging.py,sha256=9SuSSy9Usbh7zqmLYMqkmy-VBkOJW000lwqAR0XQs30,3067
 shinestacker/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shinestacker/gui/action_config.py,sha256=yXNDv0MyONbHk4iUrkvMkLKKaDvpJyzA5Yr0Eikgo0c,16986
-shinestacker/gui/action_config_dialog.py,sha256=6Xjbtj7oHGXBNiogcnPoFHqcuTOnZFlMzWCZXv8eBAI,32623
+shinestacker/gui/action_config_dialog.py,sha256=Xb8DryEQt9R3VvM2DVoT_SdlJMU_qzJs2Z7NdLeqsgY,34520
 shinestacker/gui/base_form_dialog.py,sha256=yYqMee1mzw9VBx8siBS0jDk1qqsTIKJUgdjh92aprQk,687
 shinestacker/gui/colors.py,sha256=m0pQQ-uvtIN1xmb_-N06BvC7pZYZZnq59ZSEJwutHuk,1432
+shinestacker/gui/flow_layout.py,sha256=3yBU_z7VtvHKpx1H97CHVd81eq9pe1Dcja2EZBGGKcI,3791
 shinestacker/gui/gui_images.py,sha256=e0KAXSPruZoRHrajfdlmOKBYoRJJQBDan1jgs7YFltY,5678
 shinestacker/gui/gui_logging.py,sha256=kiZcrC2AFYCWgPZo0O5SKw-E5cFrezwf4anS3HjPuNw,8168
-shinestacker/gui/gui_run.py,sha256=Lf_hXWPk1bgAYumxqjPHSK8UfiAIUR7A047ECGKD_uU,15183
-shinestacker/gui/main_window.py,sha256=l5iMk5aIi5nXPccnibB1tswc0agatrYgXULVkXo7OV0,24254
+shinestacker/gui/gui_run.py,sha256=ahbl6xMFR78QrcBbEDMuaQpkxw6DBFtSX8DCMIyr_7I,15439
+shinestacker/gui/main_window.py,sha256=KVr3ApbQSjJgmhHnrcqTjGQNTj1LoTN2PD6bWLBjsh8,24280
 shinestacker/gui/menu_manager.py,sha256=_L6LOikB3impEYqilqwXc0WJuunishjz57ozZlrBn7Q,9616
-shinestacker/gui/new_project.py,sha256=DbndYiaxwjW0OJGJ3N9JwpwLrXVsdtoSSlFRf6T8yEA,10781
-shinestacker/gui/project_controller.py,sha256=QJSQlwEJeXJyJnkp42D9NSqWBb8q2kLf_GvLfe3pe_c,15076
-shinestacker/gui/project_converter.py,sha256=_AFfU2HYKPX78l6iX6bXJrlKpdjSl63pmKzrc6kQpn8,7348
+shinestacker/gui/new_project.py,sha256=c0y2BjnAVaf5Z88UDmuOGR5rdju0Q72ltqiE7T3QivY,10807
+shinestacker/gui/project_controller.py,sha256=zVMH8kcNJ75dXPjaTa0IQiavqcWxG1URlVVYWnnu1C0,15123
+shinestacker/gui/project_converter.py,sha256=8ko3D4D7x4hhwENxwpTeElnLtEex3lpR51nZbq30Uco,7655
 shinestacker/gui/project_editor.py,sha256=uouzmUkrqouQlq-dqPOgSO16r1WOnGNV2v8jTcZlRXU,23749
 shinestacker/gui/project_model.py,sha256=eRUmH3QmRzDtPtZoxgT6amKzN8_5XzwjHgEJeL-_JOE,4263
 shinestacker/gui/select_path_widget.py,sha256=OfQImOmkzbvl5BBshmb7ePWrSGDJQ8VvyaAOypHAGd4,1023
 shinestacker/gui/tab_widget.py,sha256=6iUifK-wu0EzjVFccKHirhA2fENglVi6xREKiD96aaY,2950
-shinestacker/gui/time_progress_bar.py,sha256=Ty7pNTfbKU44Y_0YQNYtgEcxpOD-Bbi4lC8g-u9bno0,3012
+shinestacker/gui/time_progress_bar.py,sha256=4_5DT_EzFdVJi5bgd9TEpoTJXeU3M08CF91cZLi75Wc,3016
 shinestacker/gui/ico/focus_stack_bkg.png,sha256=Q86TgqvKEi_IzKI8m6aZB2a3T40UkDtexf2PdeBM9XE,163151
 shinestacker/gui/ico/shinestacker.icns,sha256=3IshIOv0uFexYsAEPkE9xiyuw8mB5X5gffekOUhFlt0,45278
 shinestacker/gui/ico/shinestacker.ico,sha256=8IMRk-toObWUz8iDXA-zHBWQ8Ps3vXN5u5ZEyw7sP3c,109613
@@ -83,9 +85,9 @@ shinestacker/retouch/undo_manager.py,sha256=_ekbcOLcPbQLY7t-o8wf-b1uA6OPY9rRyLM-
 shinestacker/retouch/unsharp_mask_filter.py,sha256=uFnth8fpZFGhdIgJCnS8x5v6lBQgJ3hX0CBke9pFXeM,3510
 shinestacker/retouch/vignetting_filter.py,sha256=3WuoF38lQOIaU1MWmqviItuQn8NnbMN0nwV7pM9IJqU,3453
 shinestacker/retouch/white_balance_filter.py,sha256=glMBYlmrF-i_OrB3sGUpjZE6X4FQdyLC4GBy2bWtaFc,6056
-shinestacker-1.0.4.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-shinestacker-1.0.4.dist-info/METADATA,sha256=tKyo0ogsBjWAHk4lAshkSqx62swN-s01hXEO2mJkHOg,5903
-shinestacker-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-1.0.4.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-1.0.4.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-1.0.4.dist-info/RECORD,,
+shinestacker-1.1.0.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.1.0.dist-info/METADATA,sha256=cg9TAx9qmIME39z02b5lLxjbtXhf_sT0aGNsfHh296E,6951
+shinestacker-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.1.0.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.1.0.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.1.0.dist-info/RECORD,,