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

shinestacker/algorithms/balance.py

@@ -609,6 +609,8 @@ class BalanceFrames(SubAction):
 
     def run_frame(self, idx, _ref_idx, image):
         if idx != self.process.ref_idx:
-            self.process.sub_message_r(color_str(': balance image', constants.LOG_COLOR_LEVEL_3))
+            self.process.print_message(
+                color_str(f'{self.process.idx_tot_str(idx)}: balance image',
+                          constants.LOG_COLOR_LEVEL_3))
         image = self.correction.apply_correction(idx, image)
         return image

shinestacker/algorithms/base_stack_algo.py

@@ -34,6 +34,13 @@ class BaseStackAlgo:
     def set_do_step_callback(self, enable):
         self.do_step_callback = enable
 
+    def idx_tot_str(self, idx):
+        return f"{idx + 1}/{len(self.filenames)}"
+
+    def image_str(self, idx):
+        return f"image: {self.idx_tot_str(idx)}, " \
+               f"{os.path.basename(self.filenames[idx])}"
+
     def init(self, filenames):
         self.filenames = filenames
         first_img_file = ''
@@ -61,11 +68,13 @@ class BaseStackAlgo:
         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 self.process.callback(constants.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)
+            self.process.callback(constants.CALLBACK_AFTER_STEP,
+                                  self.process.id, self.process.name, step)

shinestacker/algorithms/multilayer.py

@@ -12,9 +12,9 @@ from psdtags import (PsdBlendMode, PsdChannel, PsdChannelId, PsdClippingType, Ps
 from .. config.constants import constants
 from .. config.config import config
 from .. core.colors import color_str
-from .. core.framework import JobBase
+from .. core.framework import TaskBase
 from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
-from .stack_framework import FramePaths
+from .stack_framework import ImageSequenceManager
 from .exif import exif_extra_tags_for_tif, get_exif
 
 
@@ -159,10 +159,10 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
                      compression=compression, metadata=None, **tiff_tags)
 
 
-class MultiLayer(JobBase, FramePaths):
+class MultiLayer(TaskBase, ImageSequenceManager):
     def __init__(self, name, enabled=True, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        TaskBase.__init__(self, name, enabled)
         self.exif_path = kwargs.get('exif_path', '')
         self.reverse_order = kwargs.get(
             'reverse_order',
@@ -170,9 +170,9 @@ class MultiLayer(JobBase, FramePaths):
         )
 
     def init(self, job):
-        FramePaths.init(self, job)
+        ImageSequenceManager.init(self, job)
         if self.exif_path == '':
-            self.exif_path = job.paths[0]
+            self.exif_path = job.action_path(0)
         if self.exif_path != '':
             self.exif_path = self.working_path + "/" + self.exif_path
 
@@ -217,4 +217,4 @@ class MultiLayer(JobBase, FramePaths):
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)
         app = 'internal_retouch_app' if config.COMBINED_APP else f'{constants.RETOUCH_APP}'
-        self.callback('open_app', self.id, self.name, app, output_file)
+        self.callback(constants.CALLBACK_OPEN_APP, self.id, self.name, app, output_file)

shinestacker/algorithms/noise_detection.py

@@ -9,10 +9,10 @@ from .. config.config import config
 from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.exceptions import ImageLoadError
-from .. core.framework import JobBase
+from .. core.framework import TaskBase
 from .. core.core_utils import make_tqdm_bar
 from .. core.exceptions import RunStopException, ShapeError
-from .stack_framework import FramePaths, SubAction
+from .stack_framework import ImageSequenceManager, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
 MAX_NOISY_PIXELS = 1000
@@ -45,10 +45,10 @@ def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callba
     return None if mean_img is None else (mean_img / counter).astype(np.uint8)
 
 
-class NoiseDetection(JobBase, FramePaths):
+class NoiseDetection(TaskBase, ImageSequenceManager):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        TaskBase.__init__(self, name, enabled)
         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)
@@ -65,10 +65,10 @@ class NoiseDetection(JobBase, FramePaths):
         return cv2.threshold(ch, th, 255, cv2.THRESH_BINARY)[1]
 
     def progress(self, i):
-        self.callback('after_step', self.id, self.name, i)
+        self.callback(constants.CALLBACK_AFTER_STEP, self.id, self.name, i)
         if not config.DISABLE_TQDM:
             self.tbar.update(1)
-            if self.callback('check_running', self.id, self.name) is False:
+            if self.callback(constants.CALLBACK_CHECK_RUNNING, self.id, self.name) is False:
                 raise RunStopException(self.name)
 
     def run_core(self):
@@ -78,13 +78,13 @@ class NoiseDetection(JobBase, FramePaths):
         ))
         in_paths = self.input_filepaths()
         n_frames = min(len(in_paths), self.max_frames) if self.max_frames > 0 else len(in_paths)
-        self.callback('step_counts', self.id, self.name, n_frames)
+        self.callback(constants.CALLBACK_STEP_COUNTS, self.id, self.name, n_frames)
         if not config.DISABLE_TQDM:
             self.tbar = make_tqdm_bar(self.name, n_frames)
 
         def progress_callback(i):
             self.progress(i)
-            if self.callback('check_running', self.id, self.name) is False:
+            if self.callback(constants.CALLBACK_CHECK_RUNNING, self.id, self.name) is False:
                 raise RunStopException(self.name)
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
@@ -137,7 +137,7 @@ class NoiseDetection(JobBase, FramePaths):
             plt.ylim(0)
             plot_path = f"{self.working_path}/{self.plot_path}/{self.name}-hot-pixels.pdf"
             save_plot(plot_path)
-            self.callback('save_plot', self.id, f"{self.name}: noise", plot_path)
+            self.callback(constants.CALLBACK_SAVE_PLOT, self.id, f"{self.name}: noise", plot_path)
             plt.close('all')
 
 

shinestacker/algorithms/pyramid.py

@@ -124,10 +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]}, {i + 1}/{n}")
-
+            self.print_message(
+                f": validating file {self.image_str(i)}")
             _img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
             if updated:
                 self.dtype = metadata[1]
@@ -185,7 +184,8 @@ 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]} ({i + 1}/{n})")
+            self.print_message(
+                f": processing {self.image_str(i)}")
             img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, self.n_levels))
             self.after_step(i + n + 1)

shinestacker/algorithms/pyramid_auto.py

@@ -17,8 +17,9 @@ class PyramidAutoStack(BaseStackAlgo):
                  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,
+                 max_tile_size=constants.DEFAULT_PY_MAX_TILE_SIZE,
+                 min_tile_size=constants.DEFAULT_PY_MIN_TILE_SIZE,
+                 min_n_tiled_layers=constants.DEFAULT_PY_MIN_N_TILED_LAYERS,
                  mode='auto'):
         super().__init__("auto_pyramid", 2, float_type)
         self.min_size = min_size
@@ -32,6 +33,7 @@ class PyramidAutoStack(BaseStackAlgo):
         available_cores = os.cpu_count() or 1
         self.num_threads = min(max_threads, available_cores)
         self.max_tile_size = max_tile_size
+        self.min_tile_size = min_tile_size
         self.min_n_tiled_layers = min_n_tiled_layers
         self.mode = mode
         self._implementation = None
@@ -39,10 +41,10 @@ class PyramidAutoStack(BaseStackAlgo):
         self.shape = None
         self.n_levels = None
         self.n_frames = 0
-        self.channels = 3
+        self.channels = 3  # r, g, b
         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
+        self.overhead = constants.PY_MEMORY_OVERHEAD
 
     def init(self, filenames):
         first_img_file = None
@@ -97,15 +99,19 @@ class PyramidAutoStack(BaseStackAlgo):
         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)))
+        h, w = self.shape[:2]
+        base_level_memory = h * w * self.bytes_per_pixel
+        available_memory = self.memory_limit - base_level_memory
+        available_memory /= self.overhead
+        tile_size_max = int(np.sqrt(available_memory /
+                            (self.num_threads * self.n_frames * self.bytes_per_pixel)))
         tile_size = min(self.max_tile_size, tile_size_max, self.shape[0], self.shape[1])
+        tile_size = max(self.min_tile_size, tile_size)
         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:
+            h_layer = max(1, self.shape[0] // (2 ** layer))
+            w_layer = max(1, self.shape[1] // (2 ** layer))
+            if h_layer > tile_size or w_layer > tile_size:
                 n_tiled_layers = layer + 1
             else:
                 break

shinestacker/algorithms/pyramid_tiles.py

@@ -2,10 +2,11 @@
 # pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913
 # pylint: disable=R0917, R0912, R0915, R0902, W0718
 import os
+import gc
 import time
 import shutil
 import tempfile
-import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor, as_completed
 import numpy as np
 from .. config.constants import constants
 from .. core.exceptions import RunStopException
@@ -121,13 +122,13 @@ class PyramidTilesStack(PyramidBase):
             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:
+        with 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):
+            for future in as_completed(future_to_tile):
                 y, x = future_to_tile[future]
                 try:
                     fused_tile = future.result()
@@ -154,7 +155,9 @@ class PyramidTilesStack(PyramidBase):
         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)
+        y_end = min(y + self.tile_size, h)
+        x_end = min(x + self.tile_size, w)
+        gc.collect()
         return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
 
     def fuse_pyramids(self, all_level_counts, num_images):
@@ -202,26 +205,29 @@ class PyramidTilesStack(PyramidBase):
         self.focus_stack_validate(self.cleanup_temp_files)
         all_level_counts = [0] * n
         if self.num_threads > 1:
-            self.print_message(f': starting parallel image processing on {self.num_threads} cores')
+            self.print_message(f': starting parallel processing on {self.num_threads} cores')
             args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
             executor = None
             try:
-                executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads)
+                executor = 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):
+                for future in 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}')
+                        self.print_message(
+                            ": processing completed, image  "
+                            f"{self.idx_tot_str(completed_count - 1)}")
                     except Exception as e:
-                        self.print_message(f"Error processing image {i + 1}: {str(e)}")
-                    self.after_step(i + n + 1)
+                        self.print_message(
+                            f"Error processing image  {self.idx_tot_str(i)}: {str(e)}")
+                    self.after_step(completed_count + n + 1)
                     self.check_running(lambda: None)
             except RunStopException:
                 self.print_message(": stopping image processing...")
@@ -235,7 +241,9 @@ class PyramidTilesStack(PyramidBase):
                     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}")
+                self.print_message(
+                    f": processing file {os.path.basename(file_path)}, "
+                    f"{self.idx_tot_str(i)}")
                 img = read_img(file_path)
                 level_count = self.process_single_image(img, self.n_levels, i)
                 all_level_counts[i] = level_count

shinestacker/algorithms/stack.py

@@ -2,19 +2,19 @@
 import os
 import numpy as np
 from .. config.constants import constants
-from .. core.framework import JobBase
+from .. core.framework import TaskBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
 from .utils import write_img, extension_tif_jpg
-from .stack_framework import FramePaths, ActionList
+from .stack_framework import ImageSequenceManager, SequentialTask
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
 
 
-class FocusStackBase(JobBase, FramePaths):
+class FocusStackBase(TaskBase, ImageSequenceManager):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        TaskBase.__init__(self, name, enabled)
         self.stack_algo = stack_algo
         self.exif_path = kwargs.pop('exif_path', '')
         self.prefix = kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX)
@@ -46,14 +46,14 @@ class FocusStackBase(JobBase, FramePaths):
             name = f"{self.name}: {self.stack_algo.name()}"
             if idx_str != '':
                 name += f"\nbunch: {idx_str}"
-            self.callback('save_plot', self.id, name, out_filename)
+            self.callback(constants.CALLBACK_SAVE_PLOT, self.id, name, out_filename)
         if self.frame_count >= 0:
             self.frame_count += 1
 
     def init(self, job, working_path=''):
-        FramePaths.init(self, job)
+        ImageSequenceManager.init(self, job)
         if self.exif_path is None:
-            self.exif_path = job.paths[0]
+            self.exif_path = job.action_path(0)
         if self.exif_path != '':
             self.exif_path = working_path + "/" + self.exif_path
 
@@ -64,9 +64,9 @@ def get_bunches(collection, n_frames, n_overlap):
     return bunches
 
 
-class FocusStackBunch(ActionList, FocusStackBase):
+class FocusStackBunch(SequentialTask, FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        ActionList.__init__(self, name, enabled)
+        SequentialTask.__init__(self, name, enabled)
         FocusStackBase.__init__(self, name, stack_algo, enabled, **kwargs)
         self._chunks = None
         self.frame_count = 0
@@ -78,24 +78,28 @@ class FocusStackBunch(ActionList, FocusStackBase):
             raise InvalidOptionError("overlap", self.overlap,
                                      "overlap must be smaller than batch size")
 
+    def sequential_processing(self):
+        return True
+
     def init(self, job, _working_path=''):
         FocusStackBase.init(self, job, self.working_path)
 
     def begin(self):
-        ActionList.begin(self)
+        SequentialTask.begin(self)
         self._chunks = get_bunches(self.input_filepaths(), self.frames, self.overlap)
         self.set_counts(len(self._chunks))
 
     def end(self):
-        ActionList.end(self)
+        SequentialTask.end(self)
 
-    def run_step(self):
-        self.print_message_r(
-            color_str(f"fusing bunch: {self.current_action_count + 1}/{self.total_action_counts}",
+    def run_step(self, action_count=-1):
+        self.print_message(
+            color_str(f"fusing bunch: {action_count + 1}/{self.total_action_counts}",
                       constants.LOG_COLOR_LEVEL_2))
-        img_files = self._chunks[self.current_action_count - 1]
+        img_files = self._chunks[action_count - 1]
         self.stack_algo.init(img_files)
-        self.focus_stack(self._chunks[self.current_action_count - 1])
+        self.focus_stack(self._chunks[action_count - 1])
+        return True
 
 
 class FocusStack(FocusStackBase):

shinestacker/algorithms/stack_framework.py

@@ -1,30 +1,49 @@
-# pylint: disable=C0114, C0115, C0116, W0102, R0902, R0903
+# pylint: disable=C0114, C0115, C0116, W0102, R0902, R0903, E1128
 # pylint: disable=R0917, R0913, R1702, R0912, E1111, E1121, W0613
 import logging
 import os
 from .. config.constants import constants
 from .. core.colors import color_str
-from .. core.framework import Job, ActionList
+from .. core.framework import Job, SequentialTask
 from .. core.core_utils import check_path_exists
 from .. core.exceptions import RunStopException
 from .utils import read_img, write_img, extension_tif_jpg, get_img_metadata, validate_image
 
 
 class StackJob(Job):
-    def __init__(self, name, working_path, input_path='', **kwargs):
+    def __init__(self, name, working_path, input_path='', input_filepaths=[], **kwargs):
         check_path_exists(working_path)
         self.working_path = working_path
-        if input_path == '':
-            self.paths = []
-        else:
-            self.paths = [input_path]
+        self._input_path = input_path
+        self._action_paths = [] if input_path == '' else [input_path]
+        self._input_filepaths = []
+        self._input_full_path = None
+        self._input_filepaths = input_filepaths
         Job.__init__(self, name, **kwargs)
 
     def init(self, a):
         a.init(self)
 
+    def input_filepaths(self):
+        return self._input_filepaths
+
+    def num_input_filepaths(self):
+        return len(self._input_filepaths)
+
+    def action_paths(self):
+        return self._action_paths
+
+    def add_action_path(self, path):
+        self._action_paths.append(path)
+
+    def num_action_paths(self):
+        return len(self._action_paths)
 
-class FramePaths:
+    def action_path(self, i):
+        return self._action_paths[i]
+
+
+class ImageSequenceManager:
     def __init__(self, name, input_path='', output_path='', working_path='',
                  plot_path=constants.DEFAULT_PLOTS_PATH,
                  scratch_output_dir=True, resample=1,
@@ -34,7 +53,7 @@ class FramePaths:
         self.plot_path = plot_path
         self.input_path = input_path
         self.output_path = self.name if output_path == '' else output_path
-        self.resample = resample
+        self._resample = resample
         self.reverse_order = reverse_order
         self.scratch_output_dir = scratch_output_dir
         self.enabled = None
@@ -78,8 +97,8 @@ class FramePaths:
                     filelist.sort()
                     if self.reverse_order:
                         filelist.reverse()
-                    if self.resample > 1:
-                        filelist = filelist[0::self.resample]
+                    if self._resample > 1:
+                        filelist = filelist[0::self._resample]
                     files += filelist
                 if len(files) == 0:
                     self.print_message(color_str(f"input folder {d} does not contain any image",
@@ -138,10 +157,16 @@ class FramePaths:
             if not os.path.exists(self.plot_path):
                 os.makedirs(self.plot_path)
         if self.input_path in ['', []]:
-            if len(job.paths) == 0:
+            if job.num_action_paths() == 0:
                 raise RuntimeError(f"Job {job.name} does not have any configured path")
-            self.input_path = job.paths[-1]
-        job.paths.append(self.output_path)
+            self.input_path = job.action_path(-1)
+            if job.num_input_filepaths() > 0:
+                self._input_filepaths = []
+                for filepath in job.input_filepaths():
+                    if not os.path.isabs(filepath):
+                        filepath = os.path.join(self.input_full_path(), filepath)
+                    self._input_filepaths.append(filepath)
+        job.add_action_path(self.output_path)
 
     def folder_list_str(self):
         if isinstance(self.input_full_path(), list):
@@ -152,10 +177,10 @@ class FramePaths:
         return "folder: " + self.input_full_path().replace(self.working_path, '').lstrip('/')
 
 
-class FramesRefActions(ActionList, FramePaths):
+class ReferenceFrameTask(SequentialTask, ImageSequenceManager):
     def __init__(self, name, enabled=True, reference_index=0, step_process=False, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        ActionList.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        SequentialTask.__init__(self, name, enabled)
         self.ref_idx = reference_index
         self.step_process = step_process
         self.current_idx = None
@@ -163,7 +188,7 @@ class FramesRefActions(ActionList, FramePaths):
         self.current_idx_step = None
 
     def begin(self):
-        ActionList.begin(self)
+        SequentialTask.begin(self)
         self.set_filelist()
         n = self.num_input_filepaths()
         self.set_counts(n)
@@ -179,33 +204,44 @@ class FramesRefActions(ActionList, FramePaths):
                 raise IndexError(msg)
 
     def end(self):
-        ActionList.end(self)
+        SequentialTask.end(self)
 
     def run_frame(self, _idx, _ref_idx):
         return None
 
-    def run_step(self):
-        if self.current_action_count == 0:
-            self.current_idx = self.ref_idx if self.step_process else 0
-            self.current_ref_idx = self.ref_idx
-            self.current_idx_step = +1
-        ll = self.num_input_filepaths()
-        self.print_message_r(
-            color_str(f"step {self.current_action_count + 1}/{ll}: process file: "
-                      f"{os.path.basename(self.input_filepath(self.current_idx))}, "
-                      f"reference: {os.path.basename(self.input_filepath(self.current_ref_idx))}",
-                      constants.LOG_COLOR_LEVEL_2))
-        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
-        success = self.run_frame(self.current_idx, self.current_ref_idx) is not None
-        if self.current_idx < ll:
-            if self.step_process and success:
-                self.current_ref_idx = self.current_idx
-            self.current_idx += self.current_idx_step
-        if self.current_idx == ll:
-            self.current_idx = self.ref_idx - 1
-            if self.step_process:
+    def run_step(self, action_count=-1):
+        num_files = self.num_input_filepaths()
+        if self.run_sequential():
+            if action_count == 0:
+                self.current_idx = self.ref_idx if self.step_process else 0
                 self.current_ref_idx = self.ref_idx
-            self.current_idx_step = -1
+                self.current_idx_step = +1
+            idx, ref_idx = self.current_idx, self.current_ref_idx
+            self.print_message_r(
+                color_str(f"step {action_count + 1}/{num_files}: process file: "
+                          f"{os.path.basename(self.input_filepath(idx))}, "
+                          f"reference: "
+                          f"{os.path.basename(self.input_filepath(self.current_ref_idx))}",
+                          constants.LOG_COLOR_LEVEL_2))
+        else:
+            idx, ref_idx = action_count, -1
+            self.print_message_r(
+                color_str(f"step {idx + 1}/{num_files}: process file: "
+                          f"{os.path.basename(self.input_filepath(idx))}, "
+                          "parallel thread", constants.LOG_COLOR_LEVEL_2))
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
+        img = self.run_frame(idx, ref_idx)
+        if self.run_sequential():
+            if self.current_idx < num_files:
+                if self.step_process and img is not None:
+                    self.current_ref_idx = self.current_idx
+                self.current_idx += self.current_idx_step
+            if self.current_idx == num_files:
+                self.current_idx = self.ref_idx - 1
+                if self.step_process:
+                    self.current_ref_idx = self.ref_idx
+                self.current_idx_step = -1
+        return img is not None
 
 
 class SubAction:
@@ -218,15 +254,18 @@ class SubAction:
     def end(self):
         pass
 
+    def sequential_processing(self):
+        return False
+
 
-class CombinedActions(FramesRefActions):
+class CombinedActions(ReferenceFrameTask):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
-        FramesRefActions.__init__(self, name, enabled, **kwargs)
+        ReferenceFrameTask.__init__(self, name, enabled, **kwargs)
         self._actions = actions
         self._metadata = (None, None)
 
     def begin(self):
-        FramesRefActions.begin(self)
+        ReferenceFrameTask.begin(self)
         for a in self._actions:
             if a.enabled:
                 a.begin(self)
@@ -241,7 +280,10 @@ class CombinedActions(FramesRefActions):
 
     def run_frame(self, idx, ref_idx):
         input_path = self.input_filepath(idx)
-        self.sub_message_r(color_str(': read input image', constants.LOG_COLOR_LEVEL_3))
+        self.print_message(
+            color_str(f'read input image '
+                      f'{idx + 1}/{self.total_action_counts}, '
+                      f'{os.path.basename(input_path)}', constants.LOG_COLOR_LEVEL_3))
         img = read_img(input_path)
         validate_image(img, *(self._metadata))
         if img is None:
@@ -254,7 +296,7 @@ class CombinedActions(FramesRefActions):
                 self.get_logger().warning(color_str(f"{self.base_message}: sub-action disabled",
                                                     constants.LOG_COLOR_ALERT))
             else:
-                if self.callback('check_running', self.id, self.name) is False:
+                if self.callback(constants.CALLBACK_CHECK_RUNNING, self.id, self.name) is False:
                     raise RunStopException(self.name)
                 if img is not None:
                     img = a.run_frame(idx, ref_idx, img)
@@ -264,8 +306,11 @@ class CombinedActions(FramesRefActions):
                                   constants.LOG_COLOR_ALERT),
                         level=logging.WARNING)
         if img is not None:
-            self.sub_message_r(color_str(': write output image', constants.LOG_COLOR_LEVEL_3))
             output_path = os.path.join(self.output_full_path(), os.path.basename(input_path))
+            self.print_message(
+                color_str(f'write output image '
+                          f'{idx + 1}/{self.total_action_counts}, '
+                          f'{os.path.basename(output_path)}', constants.LOG_COLOR_LEVEL_3))
             write_img(output_path, img)
             return img
         self.print_message(color_str(
@@ -277,3 +322,9 @@ class CombinedActions(FramesRefActions):
         for a in self._actions:
             if a.enabled:
                 a.end()
+
+    def sequential_processing(self):
+        for a in self._actions:
+            if a.sequential_processing():
+                return True
+        return False