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

shinestacker/algorithms/pyramid_auto.py

@@ -2,7 +2,6 @@
 import os
 import numpy as np
 from .. config.constants import constants
-from .utils import extension_tif_jpg
 from .base_stack_algo import BaseStackAlgo
 from .pyramid import PyramidStack
 from .pyramid_tiles import PyramidTilesStack
@@ -17,10 +16,11 @@ 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)
+        super().__init__("auto_pyramid", 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.gen_kernel = gen_kernel
@@ -32,6 +32,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,21 +40,13 @@ 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
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        if first_img_file is None:
-            raise ValueError("No valid image files found")
-        _img, metadata, _ = self.read_image_and_update_metadata(first_img_file, None)
-        self.shape, self.dtype = metadata
+        super().init(filenames)
         self.n_levels = int(np.log2(min(self.shape) / self.min_size))
         self.n_frames = len(filenames)
         memory_required_memory = self._estimate_memory_memory()
@@ -77,9 +70,9 @@ class PyramidAutoStack(BaseStackAlgo):
                 n_tiled_layers=optimal_params['n_tiled_layers'],
                 max_threads=self.num_threads
             )
-            self.print_message(f": using tile-based pyramid stacking "
-                               f"(tile_size: {optimal_params['tile_size']}, "
-                               f"n_tiled_layers: {optimal_params['n_tiled_layers']}), "
+            self.print_message(f": using tile-based pyramid stacking, "
+                               f"tile size: {optimal_params['tile_size']}, "
+                               f"n. tiled layers: {optimal_params['n_tiled_layers']}, "
                                f"{self.num_threads} cores.")
         self._implementation.init(filenames)
         self._implementation.set_do_step_callback(self.do_step_callback)
@@ -97,15 +90,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,14 +2,15 @@
 # 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
-from .utils import read_img
+from .utils import read_img, read_and_validate_img
 from .pyramid import PyramidBase
 
 
@@ -46,11 +47,11 @@ class PyramidTilesStack(PyramidBase):
         return n_steps + self.n_tiles
 
     def _process_single_image_wrapper(self, args):
-        img_path, img_index, _n = args
-        # self.print_message(f": processing file {img_path.split('/')[-1]}, {img_index + 1}/{n}")
-        img = read_img(img_path)
-        level_count = self.process_single_image(img, self.n_levels, img_index)
-        return img_index, level_count
+        img_path, idx, _n = args
+        img = read_and_validate_img(img_path, self.shape, self.dtype)
+        self.check_running(self.cleanup_temp_files)
+        level_count = self.process_single_image(img, self.n_levels, idx)
+        return idx, level_count
 
     def process_single_image(self, img, levels, img_index):
         laplacian = self.single_image_laplacian(img, levels)
@@ -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,13 +155,16 @@ 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):
+    def fuse_pyramids(self, all_level_counts):
+        num_images = self.num_images()
         max_levels = max(all_level_counts)
         fused = []
-        count = self._steps_per_frame * self.n_frames
+        count = super().total_steps(num_images)
         for level in range(max_levels - 1, -1, -1):
             self.print_message(f': fusing pyramids, layer: {level + 1}')
             if level < self.n_tiled_layers:
@@ -198,30 +202,31 @@ class PyramidTilesStack(PyramidBase):
         return fused[::-1]
 
     def focus_stack(self):
-        n = len(self.filenames)
-        self.focus_stack_validate(self.cleanup_temp_files)
-        all_level_counts = [0] * n
+        all_level_counts = [0] * self.num_images()
         if self.num_threads > 1:
-            self.print_message(f': starting parallel image processing on {self.num_threads} cores')
-            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            self.print_message(f': starting parallel processing on {self.num_threads} cores')
+            args_list = [(file_path, i, self.num_images())
+                         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(
+                            f": processing completed, {self.image_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 {self.image_str(i)}: {str(e)}")
+                    self.after_step(completed_count)
                     self.check_running(lambda: None)
             except RunStopException:
                 self.print_message(": stopping image processing...")
@@ -235,15 +240,16 @@ 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 {self.image_str(i)}")
                 img = read_img(file_path)
                 level_count = self.process_single_image(img, self.n_levels, i)
                 all_level_counts[i] = level_count
-                self.after_step(i + n + 1)
+                self.after_step(i + 1)
                 self.check_running(lambda: None)
         try:
             self.check_running(lambda: None)
-            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            fused_pyramid = self.fuse_pyramids(all_level_counts)
             stacked_image = self.collapse(fused_pyramid)
             return stacked_image.astype(self.dtype)
         except RunStopException:

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

shinestacker/algorithms/utils.py

@@ -87,6 +87,17 @@ def img_bw(img):
     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
 
+def get_first_image_file(filenames):
+    first_img_file = None
+    for filename in filenames:
+        if os.path.isfile(filename) and extension_tif_jpg(filename):
+            first_img_file = filename
+            break
+    if first_img_file is None:
+        raise ValueError("No valid image files found")
+    return first_img_file
+
+
 def get_img_file_shape(file_path):
     img = read_img(file_path)
     return img.shape[:2]
@@ -106,6 +117,11 @@ def validate_image(img, expected_shape=None, expected_dtype=None):
         raise ShapeError(expected_shape, shape)
     if expected_dtype and dtype != expected_dtype:
         raise BitDepthError(expected_dtype, dtype)
+    return img
+
+
+def read_and_validate_img(filename, expected_shape=None, expected_dtype=None):
+    return validate_image(read_img(filename), expected_shape, expected_dtype)
 
 
 def save_plot(filename):

shinestacker/algorithms/vignetting.py

@@ -134,7 +134,8 @@ class Vignetting(SubAction):
         self.corrections = None
 
     def run_frame(self, idx, _ref_idx, img_0):
-        self.process.sub_message_r(color_str(": compute vignetting", "cyan"))
+        self.process.print_message(
+            color_str(f"{self.process.idx_tot_str(idx)}: compute vignetting", "cyan"))
         h, w = img_0.shape[:2]
         self.w_2, self.h_2 = w / 2, h / 2
         self.r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
@@ -153,12 +154,13 @@ class Vignetting(SubAction):
             return img_0
         self.v0 = sigmoid_model(0, *params)
         i0_fit, k_fit, r0_fit = params
-        self.process.sub_message(color_str(": vignetting model parameters: ", "cyan") +
-                                 color_str(f"i0={i0_fit / 2:.4f}, "
-                                           f"k={k_fit * self.r_max:.4f}, "
-                                           f"r0={r0_fit / self.r_max:.4f}",
-                                           "light_blue"),
-                                 level=logging.DEBUG)
+        self.process.print_message(
+            color_str(f"{self.process.idx_tot_str(idx)}: vignetting model parameters: ", "cyan") +
+            color_str(f"i0={i0_fit / 2:.4f}, "
+                      f"k={k_fit * self.r_max:.4f}, "
+                      f"r0={r0_fit / self.r_max:.4f}",
+                      "light_blue"),
+            level=logging.DEBUG)
         if self.plot_correction:
             plt.figure(figsize=constants.PLT_FIG_SIZE)
             plt.plot(radii, intensities, label="image mean intensity")
@@ -175,12 +177,13 @@ class Vignetting(SubAction):
             save_plot(plot_path)
             plt.close('all')
             self.process.callback(
-                'save_plot', self.process.id,
+                constants.CALLBACK_SAVE_PLOT, self.process.id,
                 f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
         for i, p in enumerate(self.percentiles):
             self.corrections[i][idx] = fsolve(lambda x: sigmoid_model(x, *params) /
                                               self.v0 - p, r0_fit)[0]
-        self.process.sub_message_r(color_str(": correct vignetting", "cyan"))
+        self.process.print_message(
+            color_str(f"{self.process.idx_tot_str(idx)}: correct vignetting", "cyan"))
         return correct_vignetting(
             img_0, self.max_correction, self.black_threshold, None, params, self.v0,
             subsample, self.fast_subsampling)
@@ -224,5 +227,5 @@ class Vignetting(SubAction):
                         f"{self.process.name}-r0.pdf"
             save_plot(plot_path)
             plt.close('all')
-            self.process.callback('save_plot', self.process.id,
+            self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
                                   f"{self.process.name}: vignetting", plot_path)