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

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.2.0'
+__version__ = '1.2.1'

shinestacker/algorithms/align.py

@@ -5,7 +5,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import cv2
 from .. config.constants import constants
-from .. core.exceptions import AlignmentError, InvalidOptionError
+from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
 from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
@@ -130,7 +130,7 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
     return True, "Transformation within acceptable limits"
 
 
-def get_good_matches(des_0, des_1, matching_config=None):
+def get_good_matches(des_0, des_ref, matching_config=None):
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     match_method = matching_config['match_method']
     good_matches = []
@@ -139,12 +139,12 @@ def get_good_matches(des_0, des_1, matching_config=None):
             {'algorithm': matching_config['flann_idx_kdtree'],
              'trees': matching_config['flann_trees']},
             {'checks': matching_config['flann_checks']})
-        matches = flann.knnMatch(des_0, des_1, k=2)
+        matches = flann.knnMatch(des_0, des_ref, k=2)
         good_matches = [m for m, n in matches
                         if m.distance < matching_config['threshold'] * n.distance]
     elif match_method == constants.MATCHING_NORM_HAMMING:
         bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
-        good_matches = sorted(bf.match(des_0, des_1), key=lambda x: x.distance)
+        good_matches = sorted(bf.match(des_0, des_ref), key=lambda x: x.distance)
     else:
         raise InvalidOptionError(
             'match_method', match_method,
@@ -172,14 +172,14 @@ def validate_align_config(detector, descriptor, match_method):
                          " require matching method Hamming distance")
 
 
-def detect_and_compute(img_0, img_1, feature_config=None, matching_config=None):
+def detect_and_compute(img_0, img_ref, feature_config=None, matching_config=None):
     feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     feature_config_detector = feature_config['detector']
     feature_config_descriptor = feature_config['descriptor']
     match_method = matching_config['match_method']
     validate_align_config(feature_config_detector, feature_config_descriptor, match_method)
-    img_bw_0, img_bw_1 = img_bw_8bit(img_0), img_bw_8bit(img_1)
+    img_bw_0, img_bw_ref = img_bw_8bit(img_0), img_bw_8bit(img_ref)
     detector_map = {
         constants.DETECTOR_SIFT: cv2.SIFT_create,
         constants.DETECTOR_ORB: cv2.ORB_create,
@@ -199,12 +199,12 @@ def detect_and_compute(img_0, img_1, feature_config=None, matching_config=None):
                                    constants.DETECTOR_AKAZE,
                                    constants.DETECTOR_BRISK):
         kp_0, des_0 = detector.detectAndCompute(img_bw_0, None)
-        kp_1, des_1 = detector.detectAndCompute(img_bw_1, None)
+        kp_ref, des_ref = detector.detectAndCompute(img_bw_ref, None)
     else:
         descriptor = descriptor_map[feature_config_descriptor]()
         kp_0, des_0 = descriptor.compute(img_bw_0, detector.detect(img_bw_0, None))
-        kp_1, des_1 = descriptor.compute(img_bw_1, detector.detect(img_bw_1, None))
-    return kp_0, kp_1, get_good_matches(des_0, des_1, matching_config)
+        kp_ref, des_ref = descriptor.compute(img_bw_ref, detector.detect(img_bw_ref, None))
+    return kp_0, kp_ref, get_good_matches(des_0, des_ref, matching_config)
 
 
 def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
@@ -236,7 +236,7 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
     return result
 
 
-def align_images(img_1, img_0, feature_config=None, matching_config=None, alignment_config=None,
+def align_images(img_ref, img_0, feature_config=None, matching_config=None, alignment_config=None,
                  plot_path=None, callbacks=None,
                  affine_thresholds=_AFFINE_THRESHOLDS,
                  homography_thresholds=_HOMOGRAPHY_THRESHOLDS):
@@ -250,11 +250,11 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
     if callbacks and 'message' in callbacks:
         callbacks['message']()
-    h_ref, w_ref = img_1.shape[:2]
+    h_ref, w_ref = img_ref.shape[:2]
     h0, w0 = img_0.shape[:2]
     subsample = alignment_config['subsample']
     if subsample == 0:
-        img_res = (float(h0) / 1000) * (float(w0) / 1000)
+        img_res = (float(h0) / constants.ONE_KILO) * (float(w0) / constants.ONE_KILO)
         target_res = constants.DEFAULT_ALIGN_RES_TARGET_MPX
         subsample = int(1 + math.floor(img_res / target_res))
     fast_subsampling = alignment_config['fast_subsampling']
@@ -262,11 +262,11 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     while True:
         if subsample > 1:
             img_0_sub = img_subsample(img_0, subsample, fast_subsampling)
-            img_1_sub = img_subsample(img_1, subsample, fast_subsampling)
+            img_ref_sub = img_subsample(img_ref, subsample, fast_subsampling)
         else:
-            img_0_sub, img_1_sub = img_0, img_1
-        kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,
-                                                      feature_config, matching_config)
+            img_0_sub, img_ref_sub = img_0, img_ref
+        kp_0, kp_ref, good_matches = detect_and_compute(img_0_sub, img_ref_sub,
+                                                        feature_config, matching_config)
         n_good_matches = len(good_matches)
         if n_good_matches > min_good_matches or subsample == 1:
             break
@@ -282,7 +282,7 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     if n_good_matches >= min_matches:
         transform = alignment_config['transform']
         src_pts = np.float32([kp_0[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
-        dst_pts = np.float32([kp_1[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+        dst_pts = np.float32([kp_ref[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
         m, msk = find_transform(src_pts, dst_pts, transform, alignment_config['align_method'],
                                 *(alignment_config[k]
                                   for k in ['rans_threshold', 'max_iters',
@@ -290,11 +290,11 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
         if plot_path is not None:
             matches_mask = msk.ravel().tolist()
             img_match = cv2.cvtColor(cv2.drawMatches(
-                img_8bit(img_0_sub), kp_0, img_8bit(img_1_sub),
-                kp_1, good_matches, None, matchColor=(0, 255, 0),
+                img_8bit(img_0_sub), kp_0, img_8bit(img_ref_sub),
+                kp_ref, good_matches, None, matchColor=(0, 255, 0),
                 singlePointColor=None, matchesMask=matches_mask,
                 flags=2), cv2.COLOR_BGR2RGB)
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             plt.imshow(img_match, 'gray')
             save_plot(plot_path)
             if callbacks and 'save_plot' in callbacks:
@@ -330,7 +330,6 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
             if callbacks and 'warning' in callbacks:
                 callbacks['warning'](f"invalid transformation: {reason}")
             return n_good_matches, None, None
-
         if callbacks and 'align_message' in callbacks:
             callbacks['align_message']()
         img_mask = np.ones_like(img_0, dtype=np.uint8)
@@ -390,7 +389,7 @@ class AlignFrames(SubAction):
     def sub_msg(self, msg, color=constants.LOG_COLOR_LEVEL_3):
         self.process.sub_message_r(color_str(msg, color))
 
-    def align_images(self, idx, img_1, img_0):
+    def align_images(self, idx, img_ref, img_0):
         idx_str = f"{idx:04d}"
         callbacks = {
             'message': lambda: self.sub_msg(': find matches'),
@@ -416,7 +415,7 @@ class AlignFrames(SubAction):
             affine_thresholds = None
             homography_thresholds = None
         n_good_matches, _m, img = align_images(
-            img_1, img_0,
+            img_ref, img_0,
             feature_config=self.feature_config,
             matching_config=self.matching_config,
             alignment_config=self.alignment_config,
@@ -427,27 +426,29 @@ class AlignFrames(SubAction):
         )
         self.n_matches[idx] = n_good_matches
         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"Image not aligned, too few matches found: "
-                                 f"{n_good_matches} < {self.min_matches}")
+            self.process.sub_message(color_str(f": image not aligned, too few matches found: "
+                                     f"{n_good_matches}", constants.LOG_COLOR_WARNING),
+                                     level=logging.WARNING)
+            return None
         return img
 
     def begin(self, process):
         self.process = process
-        self.n_matches = np.zeros(process.counts)
+        self.n_matches = np.zeros(process.total_action_counts)
 
     def end(self):
         if self.plot_summary:
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             x = np.arange(1, len(self.n_matches) + 1, dtype=int)
             no_ref = x != self.process.ref_idx + 1
             x = x[no_ref]
             y = self.n_matches[no_ref]
-            y_max = y[1] \
-                if self.process.ref_idx == 0 \
-                else y[-1] if self.process.ref_idx == len(y) - 1 \
-                else (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+            if self.process.ref_idx == 0:
+                y_max = y[1]
+            elif self.process.ref_idx >= len(y):
+                y_max = y[-1]
+            else:
+                y_max = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
 
             plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
                      [0, y_max], color='cornflowerblue', linestyle='--', label='reference frame')

shinestacker/algorithms/balance.py

@@ -24,7 +24,6 @@ class BaseHistogrammer:
         self.plot_summary = plot_summary
         self.process = process
         self.corrections = None
-        self.figsize = (10, 5)
 
     def begin(self, size):
         self.corrections = np.ones((size, self.channels))
@@ -70,7 +69,7 @@ class LumiHistogrammer(BaseHistogrammer):
         self.colors = ("r", "g", "b")
 
     def generate_frame_plot(self, idx, hist, chans, calc_hist_func):
-        _fig, axs = plt.subplots(1, 2, figsize=self.figsize, sharey=True)
+        _fig, axs = plt.subplots(1, 2, figsize=constants.PLT_FIG_SIZE, sharey=True)
         self.histo_plot(axs[0], hist, "pixel luminosity", 'black')
         for (chan, color) in zip(chans, self.colors):
             hist_col = calc_hist_func(chan)
@@ -79,7 +78,7 @@ class LumiHistogrammer(BaseHistogrammer):
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
-        plt.figure(figsize=self.figsize)
+        plt.figure(figsize=constants.PLT_FIG_SIZE)
         x = np.arange(0, len(self.corrections), dtype=int)
         y = self.corrections
         plt.plot([ref_idx, ref_idx], [0, np.max(y)], color='cornflowerblue',
@@ -101,14 +100,14 @@ class RGBHistogrammer(BaseHistogrammer):
         self.colors = ("r", "g", "b")
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=self.figsize, sharey=True)
+        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in [2, 1, 0]:
             self.histo_plot(axs[c], hists[c], self.colors[c] + " luminosity", self.colors[c])
         plt.xlim(0, self.max_pixel_value)
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
-        plt.figure(figsize=self.figsize)
+        plt.figure(figsize=constants.PLT_FIG_SIZE)
         x = np.arange(0, len(self.corrections), dtype=int)
         y = self.corrections
         max_val = np.max(y) if np.any(y) else 1.0
@@ -134,14 +133,14 @@ class Ch1Histogrammer(BaseHistogrammer):
         self.colors = colors
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=self.figsize, sharey=True)
+        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in range(3):
             self.histo_plot(axs[c], hists[c], self.labels[c], self.colors[c])
         plt.xlim(0, self.max_pixel_value)
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
-        plt.figure(figsize=self.figsize)
+        plt.figure(figsize=constants.PLT_FIG_SIZE)
         x = np.arange(0, len(self.corrections), dtype=int)
         y = self.corrections
         max_val = np.max(y) if np.any(y) else 1.0
@@ -165,14 +164,14 @@ class Ch2Histogrammer(BaseHistogrammer):
         self.colors = colors
 
     def generate_frame_plot(self, idx, hists):
-        _fig, axs = plt.subplots(1, 3, figsize=self.figsize, sharey=True)
+        _fig, axs = plt.subplots(1, 3, figsize=constants.PLT_FIG_SIZE, sharey=True)
         for c in range(3):
             self.histo_plot(axs[c], hists[c], self.labels[c], self.colors[c])
         plt.xlim(0, self.max_pixel_value)
         self.save_plot(idx)
 
     def generate_summary_plot(self, ref_idx):
-        plt.figure(figsize=self.figsize)
+        plt.figure(figsize=constants.PLT_FIG_SIZE)
         x = np.arange(0, len(self.corrections), dtype=int)
         y = self.corrections
         max_val = np.max(y) if np.any(y) else 1.0
@@ -591,9 +590,9 @@ class BalanceFrames(SubAction):
     def begin(self, process):
         self.process = process
         self.correction.process = process
-        img = read_img(self.process.input_full_path + "/" + self.process.filenames[process.ref_idx])
+        img = read_img(self.process.input_filepath(process.ref_idx))
         self.shape = img.shape
-        self.correction.begin(img, self.process.counts, process.ref_idx)
+        self.correction.begin(img, self.process.total_action_counts, process.ref_idx)
 
     def end(self):
         self.process.print_message(' ' * 60)
@@ -603,7 +602,7 @@ class BalanceFrames(SubAction):
             img = np.zeros(shape)
             mask_radius = int(min(*shape) * self.mask_size / 2)
             cv2.circle(img, (shape[1] // 2, shape[0] // 2), mask_radius, 255, -1)
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             plt.title('Mask')
             plt.imshow(img, 'gray')
             self.correction.histogrammer.save_summary_plot("mask")

shinestacker/algorithms/multilayer.py

@@ -14,7 +14,7 @@ from .. config.config import config
 from .. core.colors import color_str
 from .. core.framework import JobBase
 from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
-from .stack_framework import FrameMultiDirectory
+from .stack_framework import FramePaths
 from .exif import exif_extra_tags_for_tif, get_exif
 
 
@@ -159,9 +159,9 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
                      compression=compression, metadata=None, **tiff_tags)
 
 
-class MultiLayer(JobBase, FrameMultiDirectory):
+class MultiLayer(JobBase, FramePaths):
     def __init__(self, name, enabled=True, **kwargs):
-        FrameMultiDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
         self.exif_path = kwargs.get('exif_path', '')
         self.reverse_order = kwargs.get(
@@ -170,16 +170,16 @@ class MultiLayer(JobBase, FrameMultiDirectory):
         )
 
     def init(self, job):
-        FrameMultiDirectory.init(self, job)
+        FramePaths.init(self, job)
         if self.exif_path == '':
             self.exif_path = job.paths[0]
         if self.exif_path != '':
             self.exif_path = self.working_path + "/" + self.exif_path
 
     def run_core(self):
-        if isinstance(self.input_full_path, str):
+        if isinstance(self.input_full_path(), str):
             paths = [self.input_path]
-        elif hasattr(self.input_full_path, "__len__"):
+        elif hasattr(self.input_full_path(), "__len__"):
             paths = self.input_path
         else:
             raise RuntimeError("input_path option must contain a path or an array of paths")
@@ -188,8 +188,8 @@ class MultiLayer(JobBase, FrameMultiDirectory):
                                          constants.LOG_COLOR_ALERT),
                                level=logging.WARNING)
             return
-        files = self.folder_filelist()
-        if len(files) == 0:
+        input_files = self.input_filepaths()
+        if len(input_files) == 0:
             self.print_message(
                 color_str(f"no input in {len(paths)} specified path" +
                           ('s' if len(paths) > 1 else '') + ": "
@@ -199,12 +199,11 @@ class MultiLayer(JobBase, FrameMultiDirectory):
             return
         self.print_message(color_str("merging frames in " + self.folder_list_str(),
                            constants.LOG_COLOR_LEVEL_2))
-        input_files = [f"{self.working_path}/{f}" for f in files]
         self.print_message(
-            color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]),
+            color_str("frames: " + ", ".join([os.path.basename(i) for i in input_files]),
                       constants.LOG_COLOR_LEVEL_2))
         self.print_message(color_str("reading files", constants.LOG_COLOR_LEVEL_2))
-        filename = ".".join(files[0].split("/")[-1].split(".")[:-1])
+        filename = ".".join(os.path.basename(input_files[0]).split(".")[:-1])
         output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
         callbacks = {
             'exif_msg': lambda path: self.print_message(

shinestacker/algorithms/noise_detection.py

@@ -12,7 +12,7 @@ from .. core.exceptions import ImageLoadError
 from .. core.framework import JobBase
 from .. core.core_utils import make_tqdm_bar
 from .. core.exceptions import RunStopException, ShapeError
-from .stack_framework import FrameMultiDirectory, SubAction
+from .stack_framework import FramePaths, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
 MAX_NOISY_PIXELS = 1000
@@ -45,9 +45,9 @@ 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, FrameMultiDirectory):
+class NoiseDetection(JobBase, FramePaths):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
-        FrameMultiDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__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)
@@ -76,8 +76,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
             f"map noisy pixels from frames in {self.folder_list_str()}",
             constants.LOG_COLOR_LEVEL_2
         ))
-        files = self.folder_filelist()
-        in_paths = [self.working_path + "/" + f for f in files]
+        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)
         if not config.DISABLE_TQDM:
@@ -90,7 +89,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
             message_callback=lambda path: self.print_message_r(
-                color_str(f"reading frame: {path.split('/')[-1]}", constants.LOG_COLOR_LEVEL_2)
+                color_str(f"reading frame: {os.path.basename(path)}", constants.LOG_COLOR_LEVEL_2)
             ),
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
@@ -123,7 +122,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
             plot_range[1] = max_th + 1
         th_range = np.arange(self.plot_range[0], self.plot_range[1] + 1)
         if self.plot_histograms:
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             x = np.array(list(th_range))
             ys = [[np.count_nonzero(self.hot_map(ch, th) > 0)
                   for th in th_range] for ch in channels]

shinestacker/algorithms/stack.py

@@ -6,14 +6,14 @@ from .. core.framework import JobBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
 from .utils import write_img, extension_tif_jpg
-from .stack_framework import FrameDirectory, ActionList
+from .stack_framework import FramePaths, ActionList
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
 
 
-class FocusStackBase(JobBase, FrameDirectory):
+class FocusStackBase(JobBase, FramePaths):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        FrameDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
         self.stack_algo = stack_algo
         self.exif_path = kwargs.pop('exif_path', '')
@@ -26,9 +26,10 @@ class FocusStackBase(JobBase, FrameDirectory):
     def focus_stack(self, filenames):
         self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
         stacked_img = self.stack_algo.focus_stack()
-        in_filename = filenames[0].split(".")
-        out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + \
-            '.'.join(in_filename[1:])
+        in_filename = os.path.basename(filenames[0]).split(".")
+        out_filename = os.path.join(
+            self.output_full_path(),
+            f"{self.prefix}{in_filename[0]}." + '.'.join(in_filename[1:]))
         if self.denoise_amount > 0:
             self.sub_message_r(': denoise image')
             stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
@@ -50,7 +51,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
-        FrameDirectory.init(self, job)
+        FramePaths.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
@@ -82,20 +83,19 @@ class FocusStackBunch(ActionList, FocusStackBase):
 
     def begin(self):
         ActionList.begin(self)
-        fnames = self.folder_filelist()
-        self._chunks = get_bunches(fnames, self.frames, self.overlap)
+        self._chunks = get_bunches(self.input_filepaths(), self.frames, self.overlap)
         self.set_counts(len(self._chunks))
 
     def end(self):
         ActionList.end(self)
 
     def run_step(self):
-        self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
-                                       constants.LOG_COLOR_LEVEL_2))
-        img_files = [os.path.join(self.input_full_path, name)
-                     for name in self._chunks[self.count - 1]]
+        self.print_message_r(
+            color_str(f"fusing bunch: {self.current_action_count + 1}/{self.total_action_counts}",
+                      constants.LOG_COLOR_LEVEL_2))
+        img_files = self._chunks[self.current_action_count - 1]
         self.stack_algo.init(img_files)
-        self.focus_stack(self._chunks[self.count - 1])
+        self.focus_stack(self._chunks[self.current_action_count - 1])
 
 
 class FocusStack(FocusStackBase):
@@ -106,11 +106,11 @@ class FocusStack(FocusStackBase):
 
     def run_core(self):
         self.set_filelist()
-        img_files = sorted([os.path.join(self.input_full_path, name) for name in self.filenames])
+        img_files = sorted(self.input_filepaths())
         self.stack_algo.init(img_files)
         self.callback('step_counts', self.id, self.name,
-                      self.stack_algo.total_steps(len(self.filenames)))
-        self.focus_stack(self.filenames)
+                      self.stack_algo.total_steps(self.num_input_filepaths()))
+        self.focus_stack(img_files)
 
     def init(self, job, _working_path=''):
         FocusStackBase.init(self, job, self.working_path)