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

shinestacker/algorithms/base_stack_algo.py

@@ -28,6 +28,12 @@ class BaseStackAlgo:
     def name(self):
         return self._name
 
+    def set_process(self, process):
+        self.process = process
+
+    def set_do_step_callback(self, enable):
+        self.do_step_callback = enable
+
     def init(self, filenames):
         self.filenames = filenames
         first_img_file = ''

shinestacker/algorithms/depth_map.py

@@ -116,5 +116,5 @@ class DepthMapStack(BaseStackAlgo):
         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 = 255 if dtype == np.uint8 else 65535
+        n_values = constants.MAX_UINT8 if dtype == np.uint8 else constants.MAX_UINT16
         return np.clip(np.absolute(result), 0, n_values).astype(dtype)

shinestacker/algorithms/multilayer.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, E0606
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, E0606, R0912
 import os
 import logging
 import cv2
@@ -61,6 +61,13 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
     if len(dtypes) > 1:
         raise RuntimeError("All input files must all have 8 bit or 16 bit depth.")
     dtype = dtypes[0]
+    bytes_per_pixel = 3 * np.dtype(dtype).itemsize
+    est_memory = shape[0] * shape[1] * bytes_per_pixel * len(image_dict)
+    if est_memory > constants.MULTILAYER_WARNING_MEM_GB * constants.ONE_GIGA:
+        if callbacks:
+            callback = callbacks.get('memory_warning', None)
+            if callback:
+                callback(float(est_memory) / constants.ONE_GIGA)
     max_pixel_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
     transp = np.full_like(list(image_dict.values())[0][..., 0], max_pixel_value)
     compression_type = PsdCompressionType.ZIP_PREDICTED
@@ -203,7 +210,10 @@ class MultiLayer(JobBase, FrameMultiDirectory):
             'exif_msg': lambda path: self.print_message(
                 color_str(f"copying exif data from path: {path}", constants.LOG_COLOR_LEVEL_2)),
             'write_msg': lambda path: self.print_message(
-                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2))
+                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2)),
+            'memory_warning': lambda mem: self.print_message(
+                color_str(f"warning: estimated file size: {mem:.2f} GBytes",
+                          constants.LOG_COLOR_WARNING))
         }
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)

shinestacker/algorithms/noise_detection.py

@@ -49,7 +49,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
         FrameMultiDirectory.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
-        self.max_frames = kwargs.get('max_frames', -1)
+        self.max_frames = kwargs.get('max_frames', constants.DEFAULT_NOISE_MAX_FRAMES)
         self.blur_size = kwargs.get('blur_size', constants.DEFAULT_BLUR_SIZE)
         self.file_name = kwargs.get('file_name', constants.DEFAULT_NOISE_MAP_FILENAME)
         if self.file_name == '':

shinestacker/algorithms/pyramid.py

@@ -124,8 +124,9 @@ class PyramidBase(BaseStackAlgo):
 
     def focus_stack_validate(self, cleanup_callback=None):
         metadata = None
+        n = len(self.filenames)
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": validating file {img_path.split('/')[-1]}")
+            self.print_message(f": validating file {img_path.split('/')[-1]}, {i + 1}/{n}")
 
             _img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
             if updated:
@@ -184,7 +185,7 @@ class PyramidStack(PyramidBase):
         self.focus_stack_validate()
         all_laplacians = []
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": processing file {img_path.split('/')[-1]}")
+            self.print_message(f": processing file {img_path.split('/')[-1]} ({i + 1}/{n})")
             img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, self.n_levels))
             self.after_step(i + n + 1)

shinestacker/algorithms/pyramid_auto.py

@@ -0,0 +1,141 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0913, R0902, R0914, R0917
+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
+
+
+class PyramidAutoStack(BaseStackAlgo):
+    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,
+                 n_tiled_layers=constants.DEFAULT_PY_N_TILED_LAYERS,
+                 memory_limit=constants.DEFAULT_PY_MEMORY_LIMIT_GB,
+                 max_threads=constants.DEFAULT_PY_MAX_THREADS,
+                 max_tile_size=2048,
+                 min_n_tiled_layers=1,
+                 mode='auto'):
+        super().__init__("auto_pyramid", 2, float_type)
+        self.min_size = min_size
+        self.kernel_size = kernel_size
+        self.gen_kernel = gen_kernel
+        self.float_type = float_type
+        self.tile_size = tile_size
+        self.n_tiled_layers = n_tiled_layers
+        self.memory_limit = memory_limit * constants.ONE_GIGA
+        self.max_threads = max_threads
+        available_cores = os.cpu_count() or 1
+        self.num_threads = min(max_threads, available_cores)
+        self.max_tile_size = max_tile_size
+        self.min_n_tiled_layers = min_n_tiled_layers
+        self.mode = mode
+        self._implementation = None
+        self.dtype = None
+        self.shape = None
+        self.n_levels = None
+        self.n_frames = 0
+        self.channels = 3
+        dtype = np.float32 if self.float_type == constants.FLOAT_32 else np.float64
+        self.bytes_per_pixel = self.channels * np.dtype(dtype).itemsize
+        self.overhead = 1.5
+
+    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
+        self.n_levels = int(np.log2(min(self.shape) / self.min_size))
+        self.n_frames = len(filenames)
+        memory_required_memory = self._estimate_memory_memory()
+        if self.mode == 'memory' or (self.mode == 'auto' and
+                                     memory_required_memory <= self.memory_limit):
+            self._implementation = PyramidStack(
+                min_size=self.min_size,
+                kernel_size=self.kernel_size,
+                gen_kernel=self.gen_kernel,
+                float_type=self.float_type
+            )
+            self.print_message(": using memory-based pyramid stacking")
+        else:
+            optimal_params = self._find_optimal_tile_params()
+            self._implementation = PyramidTilesStack(
+                min_size=self.min_size,
+                kernel_size=self.kernel_size,
+                gen_kernel=self.gen_kernel,
+                float_type=self.float_type,
+                tile_size=optimal_params['tile_size'],
+                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']}), "
+                               f"{self.num_threads} cores.")
+        self._implementation.init(filenames)
+        self._implementation.set_do_step_callback(self.do_step_callback)
+        if self.process is not None:
+            self._implementation.set_process(self.process)
+        else:
+            raise RuntimeError("self.process must be initialized.")
+
+    def _estimate_memory_memory(self):
+        h, w = self.shape[:2]
+        total_memory = 0
+        for _ in range(self.n_levels):
+            total_memory += h * w * self.bytes_per_pixel
+            h, w = max(1, h // 2), max(1, w // 2)
+        return self.overhead * total_memory * self.n_frames
+
+    def _find_optimal_tile_params(self):
+        tile_size_max = int(np.sqrt(self.memory_limit /
+                            (self.num_threads * self.n_frames *
+                             self.bytes_per_pixel * self.overhead)))
+        tile_size = min(self.max_tile_size, tile_size_max, self.shape[0], self.shape[1])
+        n_tiled_layers = 0
+        for layer in range(self.n_levels):
+            h = max(1, self.shape[0] // (2 ** layer))
+            w = max(1, self.shape[1] // (2 ** layer))
+            if h > tile_size or w > tile_size:
+                n_tiled_layers = layer + 1
+            else:
+                break
+        n_tiled_layers = max(n_tiled_layers, self.min_n_tiled_layers)
+        n_tiled_layers = min(n_tiled_layers, self.n_levels)
+        return {'tile_size': tile_size, 'n_tiled_layers': n_tiled_layers}
+
+    def set_process(self, process):
+        super().set_process(process)
+        if self._implementation is not None:
+            self._implementation.set_process(process)
+
+    def total_steps(self, n_frames):
+        if self._implementation is None:
+            return super().total_steps(n_frames)
+        return self._implementation.total_steps(n_frames)
+
+    def focus_stack(self):
+        if self._implementation is None:
+            raise RuntimeError("PyramidAutoStack not initialized")
+        return self._implementation.focus_stack()
+
+    def after_step(self, step):
+        if self._implementation is not None:
+            self._implementation.after_step(step)
+        else:
+            super().after_step(step)
+
+    def check_running(self, cleanup_callback=None):
+        if self._implementation is not None:
+            self._implementation.check_running(cleanup_callback)
+        else:
+            super().check_running(cleanup_callback)

shinestacker/algorithms/pyramid_tiles.py

@@ -1,8 +1,14 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913, R0917, R0912, R0915
+
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913
+# pylint: disable=R0917, R0912, R0915, R0902, W0718
 import os
+import time
+import shutil
 import tempfile
+import concurrent.futures
 import numpy as np
 from .. config.constants import constants
+from .. core.exceptions import RunStopException
 from .utils import read_img
 from .pyramid import PyramidBase
 
@@ -12,35 +18,144 @@ class PyramidTilesStack(PyramidBase):
                  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):
+                 tile_size=constants.DEFAULT_PY_TILE_SIZE,
+                 n_tiled_layers=constants.DEFAULT_PY_N_TILED_LAYERS,
+                 max_threads=constants.DEFAULT_PY_MAX_THREADS):
         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.n_tiled_layers = n_tiled_layers
         self.temp_dir = tempfile.TemporaryDirectory()
         self.n_tiles = 0
+        self.level_shapes = {}
+        available_cores = os.cpu_count() or 1
+        self.num_threads = max(1, min(max_threads, available_cores))
 
     def init(self, filenames):
         super().init(filenames)
-        self.n_tiles = (self.shape[0] // self.tile_size + 1) * (self.shape[1] // self.tile_size + 1)
+        self.n_tiles = 0
+        for layer in range(self.n_tiled_layers):
+            h, w = max(1, self.shape[0] // (2 ** layer)), max(1, self.shape[1] // (2 ** layer))
+            self.n_tiles += (h // self.tile_size + 1) * (w // 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_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
+
     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)
+        self.level_shapes[img_index] = [level.shape for level in laplacian[::-1]]
+        for level_idx, level_data in enumerate(laplacian[::-1]):
+            h, w = level_data.shape[:2]
+            if level_idx < self.n_tiled_layers:
+                for y in range(0, h, self.tile_size):
+                    for x in range(0, w, self.tile_size):
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        tile = level_data[y:y_end, x:x_end]
+                        np.save(
+                            os.path.join(
+                                self.temp_dir.name,
+                                f'img_{img_index}_level_{level_idx}_tile_{y}_{x}.npy'),
+                            tile
+                        )
+            else:
+                np.save(
+                    os.path.join(self.temp_dir.name,
+                                 f'img_{img_index}_level_{level_idx}.npy'), level_data)
         return len(laplacian)
 
+    def load_level_tile(self, img_index, level, y, x):
+        return np.load(
+            os.path.join(self.temp_dir.name,
+                         f'img_{img_index}_level_{level}_tile_{y}_{x}.npy'))
+
     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()
+        try:
+            self.temp_dir.cleanup()
+        except Exception:
+            try:
+                shutil.rmtree(self.temp_dir.name, ignore_errors=True)
+            except Exception:
+                pass
+
+    def _fuse_level_tiles_serial(self, level, num_images, all_level_counts, h, w, count):
+        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, x_end = min(y + self.tile_size, h), 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]:
+                        try:
+                            tile = self.load_level_tile(img_index, level, y, x)
+                            laplacians.append(tile)
+                        except FileNotFoundError:
+                            continue
+                if laplacians:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_tile = self.fuse_laplacian(stacked)
+                    fused_level[y:y_end, x:x_end] = fused_tile
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _fuse_level_tiles_parallel(self, level, num_images, all_level_counts, h, w, count):
+        fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+        tiles = []
+        for y in range(0, h, self.tile_size):
+            for x in range(0, w, self.tile_size):
+                tiles.append((y, x))
+        self.print_message(f': starting parallel propcessging on {self.num_threads} cores')
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads) as executor:
+            future_to_tile = {
+                executor.submit(
+                    self._process_tile, level, num_images, all_level_counts, y, x, h, w): (y, x)
+                for y, x in tiles
+            }
+            for future in concurrent.futures.as_completed(future_to_tile):
+                y, x = future_to_tile[future]
+                try:
+                    fused_tile = future.result()
+                    if fused_tile is not None:
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        fused_level[y:y_end, x:x_end] = fused_tile
+                        self.print_message(f': fused tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                except Exception as e:
+                    self.print_message(f"Error processing tile ({y}, {x}): {str(e)}")
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _process_tile(self, level, num_images, all_level_counts, y, x, h, w):
+        laplacians = []
+        for img_index in range(num_images):
+            if level < all_level_counts[img_index]:
+                try:
+                    tile = self.load_level_tile(img_index, level, y, x)
+                    laplacians.append(tile)
+                except FileNotFoundError:
+                    continue
+        if laplacians:
+            stacked = np.stack(laplacians, axis=0)
+            return self.fuse_laplacian(stacked)
+        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+        return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
 
     def fuse_pyramids(self, all_level_counts, num_images):
         max_levels = max(all_level_counts)
@@ -48,30 +163,20 @@ class PyramidTilesStack(PyramidBase):
         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
+            if level < self.n_tiled_layers:
+                h, w = None, None
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        h, w = self.level_shapes[img_index][level][:2]
+                        break
+                if h is None or w is None:
+                    continue
+                if self.num_threads > 1:
+                    fused_level, count = self._fuse_level_tiles_parallel(
+                        level, num_images, all_level_counts, h, w, count)
+                else:
+                    fused_level, count = self._fuse_level_tiles_serial(
+                        level, num_images, all_level_counts, h, w, count)
             else:
                 laplacians = []
                 for img_index in range(num_images):
@@ -84,26 +189,76 @@ class PyramidTilesStack(PyramidBase):
                 else:
                     stacked = np.stack(laplacians, axis=0)
                     fused_level = self.fuse_laplacian(stacked)
-                    self.check_running(self.cleanup_temp_files)
+                self.check_running(lambda: None)
             fused.append(fused_level)
             count += 1
             self.after_step(count)
-            self.check_running(self.cleanup_temp_files)
+            self.check_running(lambda: None)
         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)
+        all_level_counts = [0] * n
+        if self.num_threads > 1:
+            self.print_message(f': starting parallel image processing on {self.num_threads} cores')
+            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            executor = None
+            try:
+                executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads)
+                future_to_index = {
+                    executor.submit(self._process_single_image_wrapper, args): i
+                    for i, args in enumerate(args_list)
+                }
+                completed_count = 0
+                for future in concurrent.futures.as_completed(future_to_index):
+                    i = future_to_index[future]
+                    try:
+                        img_index, level_count = future.result()
+                        all_level_counts[img_index] = level_count
+                        completed_count += 1
+                        self.print_message(f': completed processing image {completed_count}/{n}')
+                    except Exception as e:
+                        self.print_message(f"Error processing image {i + 1}: {str(e)}")
+                    self.after_step(i + n + 1)
+                    self.check_running(lambda: None)
+            except RunStopException:
+                self.print_message(": stopping image processing...")
+                if executor:
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    time.sleep(0.5)
+                    self._safe_cleanup()
+                raise
+            finally:
+                if executor:
+                    executor.shutdown(wait=True)
+        else:
+            for i, file_path in enumerate(self.filenames):
+                self.print_message(f": processing file {file_path.split('/')[-1]}, {i + 1}/{n}")
+                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.check_running(lambda: None)
+        try:
+            self.check_running(lambda: None)
+            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            stacked_image = self.collapse(fused_pyramid)
+            return stacked_image.astype(self.dtype)
+        except RunStopException:
+            self.print_message(": stopping pyramid fusion...")
+            raise
+        finally:
+            self._safe_cleanup()
+
+    def _safe_cleanup(self):
+        try:
+            self.cleanup_temp_files()
+        except Exception as e:
+            self.print_message(f": warning during cleanup: {str(e)}")
+            time.sleep(1)
+            try:
+                self.cleanup_temp_files()
+            except Exception:
+                self.print_message(": could not fully clean up temporary files")

shinestacker/algorithms/stack.py

@@ -20,7 +20,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         self.prefix = kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX)
         self.denoise_amount = kwargs.pop('denoise_amount', 0)
         self.plot_stack = kwargs.pop('plot_stack', constants.DEFAULT_PLOT_STACK)
-        self.stack_algo.process = self
+        self.stack_algo.set_process(self)
         self.frame_count = -1
 
     def focus_stack(self, filenames):
@@ -72,7 +72,7 @@ class FocusStackBunch(ActionList, FocusStackBase):
         self.frames = kwargs.get('frames', constants.DEFAULT_FRAMES)
         self.overlap = kwargs.get('overlap', constants.DEFAULT_OVERLAP)
         self.denoise_amount = kwargs.get('denoise_amount', 0)
-        self.stack_algo.do_step_callback = False
+        self.stack_algo.set_do_step_callback(False)
         if self.overlap >= self.frames:
             raise InvalidOptionError("overlap", self.overlap,
                                      "overlap must be smaller than batch size")
@@ -101,7 +101,7 @@ class FocusStackBunch(ActionList, FocusStackBase):
 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.stack_algo.set_do_step_callback(True)
         self.shape = None
 
     def run_core(self):

shinestacker/algorithms/stack_framework.py

@@ -41,6 +41,7 @@ class FramePaths:
         self.input_full_path = None
         self.enabled = None
         self.filenames = None
+        self.base_message = ''
 
     def folder_filelist(self):
         assert False, "this method should be overwritten"
@@ -51,8 +52,9 @@ class FramePaths:
     def set_filelist(self):
         self.filenames = self.folder_filelist()
         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}",
+        self.print_message(color_str(f"{len(self.filenames)} files in folder: {file_folder}",
                                      constants.LOG_COLOR_LEVEL_2))
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
 
     def init(self, job):
         if self.working_path == '':
@@ -217,6 +219,7 @@ class FramesRefActions(ActionList, FrameDirectory):
         self.print_message_r(
             color_str(f"step {self.count + 1}/{ll}: process file: {self.filenames[self._idx]}, "
                       f"reference: {self.filenames[self._ref_idx]}", constants.LOG_COLOR_LEVEL_2))
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
         self.run_frame(self._idx, self._ref_idx)
         if self._idx < ll:
             if self.step_process:
@@ -274,7 +277,7 @@ class CombinedActions(FramesRefActions):
         if img is None:
             raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
         if len(self._actions) == 0:
-            self.sub_message(color_str(": no actions specified.", constants.LOG_COLOR_ALERT),
+            self.sub_message(color_str(": no actions specified", constants.LOG_COLOR_ALERT),
                              level=logging.WARNING)
         for a in self._actions:
             if not a.enabled:
@@ -283,13 +286,19 @@ class CombinedActions(FramesRefActions):
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
-                img = a.run_frame(idx, ref_idx, img)
+                if img is not None:
+                    img = a.run_frame(idx, ref_idx, img)
+                else:
+                    self.sub_message(
+                        color_str(": null input received, action skipped",
+                                  constants.LOG_COLOR_ALERT),
+                        level=logging.WARNING)
         self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
         if img is not None:
             write_img(self.output_dir + "/" + filename, img)
         else:
             self.print_message(color_str(
-                "No output file resulted from processing input file: "
+                "no output file resulted from processing input file: "
                 f"{self.input_full_path}/{filename}",
                 constants.LOG_COLOR_ALERT), level=logging.WARNING)