shinestacker 1.0.4__tar.gz → 1.1.0__tar.gz

{shinestacker-1.0.4 → shinestacker-1.1.0}/.github/workflows/release.yml

@@ -44,8 +44,8 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: shinestacker-${{ matrix.os }}
-          path: dist/shinestacker-release.zip
-
+          path: |
+            ${{ matrix.os == 'windows-latest' && 'dist/shinestacker-release.zip' || 'dist/shinestacker-release.tar.gz' }}
   create-release:
     needs: publish-release
     runs-on: ubuntu-latest
@@ -58,9 +58,9 @@ jobs:
       - name: Prepare release assets
         run: |
           mkdir -p release_assets
-          cp artifacts/shinestacker-ubuntu-latest/shinestacker-release.zip release_assets/shinestacker-ubuntu.zip
+          cp artifacts/shinestacker-ubuntu-latest/shinestacker-release.tar.gz release_assets/shinestacker-ubuntu.tar.gz
+          cp artifacts/shinestacker-macos-latest/shinestacker-release.tar.gz release_assets/shinestacker-macos.tar.gz
           cp artifacts/shinestacker-windows-latest/shinestacker-release.zip release_assets/shinestacker-windows.zip
-          cp artifacts/shinestacker-macos-latest/shinestacker-release.zip release_assets/shinestacker-macos.zip
           ls -la release_assets/
 
       - name: Create release
@@ -68,6 +68,6 @@ jobs:
         with:
           draft: true
           files: |
-            release_assets/shinestacker-ubuntu.zip
+            release_assets/shinestacker-ubuntu.tar.gz
+            release_assets/shinestacker-macos.tar.gz
             release_assets/shinestacker-windows.zip
-            release_assets/shinestacker-macos.zip

{shinestacker-1.0.4 → shinestacker-1.1.0}/CHANGELOG.md

@@ -2,13 +2,35 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.1.0] - 2025-08-28
+**New Pyramids algorith, some improvements and more fixes**
+
+### Changes
+
+* added Pyramids Tiles, that requires less RAM by fusing the image in tiles
+* the alignment module now tolerates images of different shapes
+* noisy pixel mask verifies that the mask has the same shape as input images
+* minor changes to default alignment parameters
+* some improvements to the GUI
+* some bug fixes
+---
+
+## [v1.0.4.pre2] - 2025-08-26
+**Bug fixes**
+
+### Changes
+
+* fixed release build script changing format from zip to tar.gz for macOs and Linux
+
+---
+
 ## [v1.0.4] - 2025-08-26
 **Bug fixes**
 
 ### Changes
 
 * extensions are treated in lower case (e.g.: both jpg and JPG)
-* added retouch menu action: import frames from current project
+* added missing retouch menu action: import frames from current project
 
 ---
 ## [v1.0.3] - 2025-08-26

{shinestacker-1.0.4/src/shinestacker.egg-info → shinestacker-1.1.0}/PKG-INFO

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

@@ -38,6 +38,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 → shinestacker-1.1.0}/docs/focus_stacking.md

@@ -42,6 +42,11 @@ Arguments for the constructor are:
    * ```gen_kernel``` (optional, default: 0.4)
    * ```float_type``` (optional, default: ```FLOAT_32```, possible values: ```FLOAT_32```, ```FLOAT_64```): precision for internal image representation
 
+```PyramidTilesStack```, Laplacian pyramid with tile pyramid merging to optimize memory usage for large files
+
+Arguments for the constructor are the same ad for ```PyramidStack``` plus:
+   * ```tile_size``` (optional, default: 512): size of the tile used for partial image merging
+
 ```DepthMapStack```, Depth map focus stacking algorithm
 
 Arguments for the constructor are:

{shinestacker-1.0.4 → shinestacker-1.1.0}/scripts/build_release.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+import tarfile
 import subprocess
 from pathlib import Path
 import platform
@@ -35,9 +36,19 @@ for project_file in ["complete-project.fsp", "stack-from-frames.fsp"]:
     shutil.copy(examples_dir / project_file, target_examples)
     shutil.copytree(examples_dir / 'input', target_examples / 'input', dirs_exist_ok=True)
 
-shutil.make_archive(
-    base_name=str(dist_dir / "shinestacker-release"),
-    format="zip",
-    root_dir=dist_dir,
-    base_dir=package_dir
-)
+if sys_name == 'windows':
+    shutil.make_archive(
+        base_name=str(dist_dir / "shinestacker-release"),
+        format="zip",
+        root_dir=dist_dir,
+        base_dir=package_dir
+    )
+else:
+    archive_path = dist_dir / "shinestacker-release.tar.gz"
+    with tarfile.open(archive_path, "w:gz") as tar:
+        tar.add(
+            dist_dir / package_dir,
+            arcname=package_dir,
+            recursive=True,
+            filter=lambda info: info
+        )

shinestacker-1.1.0/src/shinestacker/_version.py

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

{shinestacker-1.0.4 → shinestacker-1.1.0}/src/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-1.0.4 → shinestacker-1.1.0}/src/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-1.0.4 → shinestacker-1.1.0}/src/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-1.0.4 → shinestacker-1.1.0}/src/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-1.0.4 → shinestacker-1.1.0}/src/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)