shinestacker 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.3.5'
+__version__ = '0.4.0'

shinestacker/algorithms/align.py

@@ -5,6 +5,7 @@ import matplotlib.pyplot as plt
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import AlignmentError, InvalidOptionError
+from .. core.colors import color_str
 from .utils import img_8bit, img_bw_8bit, save_plot
 from .utils import get_img_metadata, validate_image
 from .stack_framework import SubAction
@@ -33,7 +34,8 @@ _DEFAULT_ALIGNMENT_CONFIG = {
     'border_value': constants.DEFAULT_BORDER_VALUE,
     'border_blur': constants.DEFAULT_BORDER_BLUR,
     'subsample': constants.DEFAULT_ALIGN_SUBSAMPLE,
-    'fast_subsampling': constants.DEFAULT_ALIGN_FAST_SUBSAMPLING
+    'fast_subsampling': constants.DEFAULT_ALIGN_FAST_SUBSAMPLING,
+    'min_good_matches': constants.DEFAULT_ALIGN_MIN_GOOD_MATCHES
 }
 
 
@@ -164,21 +166,31 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     if callbacks and 'message' in callbacks:
         callbacks['message']()
     subsample = alignment_config['subsample']
-    if subsample > 1:
-        if alignment_config['fast_subsampling']:
-            img_0_sub, img_1_sub = img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
+    min_good_matches = alignment_config['min_good_matches']
+    while True:
+        if subsample > 1:
+            if alignment_config['fast_subsampling']:
+                img_0_sub, img_1_sub = \
+                    img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
+            else:
+                img_0_sub = cv2.resize(img_0, (0, 0),
+                                       fx=1 / subsample, fy=1 / subsample,
+                                       interpolation=cv2.INTER_AREA)
+                img_1_sub = cv2.resize(img_1, (0, 0),
+                                       fx=1 / subsample, fy=1 / subsample,
+                                       interpolation=cv2.INTER_AREA)
         else:
-            img_0_sub = cv2.resize(img_0, (0, 0),
-                                   fx=1 / subsample, fy=1 / subsample,
-                                   interpolation=cv2.INTER_AREA)
-            img_1_sub = cv2.resize(img_1, (0, 0),
-                                   fx=1 / subsample, fy=1 / subsample,
-                                   interpolation=cv2.INTER_AREA)
-    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)
-    n_good_matches = len(good_matches)
+            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)
+        n_good_matches = len(good_matches)
+        if n_good_matches > min_good_matches or subsample == 1:
+            break
+        subsample = 1
+        if callbacks and 'warning' in callbacks:
+            callbacks['warning'](
+                f"only {n_good_matches} < {min_good_matches} matches found, "
+                "retrying without subsampling")
     if callbacks and 'matches_message' in callbacks:
         callbacks['matches_message'](n_good_matches)
     img_warp = None
@@ -277,14 +289,19 @@ class AlignFrames(SubAction):
         img_ref = self.process.img_ref(ref_idx)
         return self.align_images(idx, img_ref, img_0)
 
+    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):
         idx_str = f"{idx:04d}"
         callbacks = {
-            'message': lambda: self.process.sub_message_r(': find matches'),
-            'matches_message': lambda n: self.process.sub_message_r(f": matches: {n}"),
-            'align_message': lambda: self.process.sub_message_r(': align images'),
-            'ecc_message': lambda: self.process.sub_message_r(": ecc refinement"),
-            'blur_message': lambda: self.process.sub_message_r(': blur borders'),
+            'message': lambda: self.sub_msg(': find matches'),
+            'matches_message': lambda n: self.sub_msg(f": good matches: {n}"),
+            'align_message': lambda: self.sub_msg(': align images'),
+            'ecc_message': lambda: self.sub_msg(": ecc refinement"),
+            'blur_message': lambda: self.sub_msg(': blur borders'),
+            'warning': lambda msg: self.sub_msg(
+                f': {msg}', constants.LOG_COLOR_ALERT),
             'save_plot': lambda plot_path: self.process.callback(
                 'save_plot', self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)

shinestacker/algorithms/balance.py

@@ -6,6 +6,7 @@ from scipy.optimize import bisect
 from scipy.interpolate import interp1d
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
+from .. core.colors import color_str
 from .utils import read_img, save_plot
 from .stack_framework import SubAction
 
@@ -408,6 +409,6 @@ class BalanceFrames(SubAction):
 
     def run_frame(self, idx, _ref_idx, image):
         if idx != self.process.ref_idx:
-            self.process.sub_message_r(': balance image')
+            self.process.sub_message_r(color_str(': balance image', constants.LOG_COLOR_LEVEL_3))
             image = self.correction.apply_correction(idx, image)
         return image

shinestacker/algorithms/base_stack_algo.py

@@ -2,6 +2,7 @@
 import numpy as np
 from .. core.exceptions import InvalidOptionError, ImageLoadError
 from .. config.constants import constants
+from .. core.colors import color_str
 from .utils import read_img, get_img_metadata, validate_image
 
 
@@ -27,7 +28,7 @@ class BaseStackAlgo:
         return self._steps_per_frame
 
     def print_message(self, msg):
-        self.process.sub_message_r(msg)
+        self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
 
     def read_image_and_update_metadata(self, img_path, metadata):
         img = read_img(img_path)

shinestacker/algorithms/multilayer.py

@@ -176,7 +176,9 @@ class MultiLayer(JobBase, FrameMultiDirectory):
         else:
             raise RuntimeError("input_path option must contain a path or an array of paths")
         if len(paths) == 0:
-            self.print_message(color_str("no input paths specified", "red"), level=logging.WARNING)
+            self.print_message(color_str("no input paths specified",
+                                         constants.LOG_COLOR_LEVEL_ALERT),
+                               level=logging.WARNING)
             return
         files = self.folder_filelist()
         if len(files) == 0:
@@ -184,22 +186,23 @@ class MultiLayer(JobBase, FrameMultiDirectory):
                 color_str(f"no input in {len(paths)} specified path" +
                           ('s' if len(paths) > 1 else '') + ": "
                           ", ".join([f"'{p}'" for p in paths]),
-                          "red"),
+                          constants.LOG_COLOR_LEVEL_ALERT),
                 level=logging.WARNING)
             return
-        self.print_message(color_str("merging frames in " + self.folder_list_str(), "blue"))
+        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]), "blue"))
-        self.print_message(
-            color_str("reading files", "blue"))
+            color_str("frames: " + ", ".join([i.split("/")[-1] for i in 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])
         output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
         callbacks = {
             'exif_msg': lambda path: self.print_message(
-                color_str(f"copying exif data from path: {path}", "blue")),
+                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}", "blue"))
+                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2))
         }
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)

shinestacker/algorithms/noise_detection.py

@@ -73,7 +73,8 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
 
     def run_core(self):
         self.print_message(color_str(
-            f"map noisy pixels from frames in {self.folder_list_str()}", "blue"
+            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]
@@ -89,7 +90,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]}", "blue")
+                color_str(f"reading frame: {path.split('/')[-1]}", constants.LOG_COLOR_LEVEL_2)
             ),
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
@@ -103,13 +104,16 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
         hot_rgb = cv2.bitwise_or(hot_px[0], cv2.bitwise_or(hot_px[1], hot_px[2]))
         msg = []
         for ch, hot in zip(['rgb', *constants.RGB_LABELS], [hot_rgb] + hot_px):
-            msg.append(f"{ch}: {np.count_nonzero(hot > 0)}")
-        self.print_message("hot pixels: " + ", ".join(msg))
+            hpx = color_str(f"{ch}: {np.count_nonzero(hot > 0)}",
+                            {'rgb': 'black', 'r': 'red', 'g': 'green', 'b': 'blue'}[ch])
+            msg.append(hpx)
+        self.print_message(color_str("hot pixels: " + ", ".join(msg), constants.LOG_COLOR_LEVEL_2))
         path = "/".join(self.file_name.split("/")[:-1])
         if not os.path.exists(f"{self.working_path}/{path}"):
             self.print_message(f"create directory: {path}")
             os.mkdir(f"{self.working_path}/{path}")
-        self.print_message(f"writing hot pixels map file: {self.file_name}")
+        self.print_message(color_str(f"writing hot pixels map file: {self.file_name}",
+                                     constants.LOG_COLOR_LEVEL_2))
         cv2.imwrite(f"{self.working_path}/{self.file_name}", hot_rgb)
         plot_range = self.plot_range
         min_th, max_th = min(self.channel_thresholds), max(self.channel_thresholds)
@@ -155,7 +159,9 @@ class MaskNoise(SubAction):
         self.process = process
         path = f"{process.working_path}/{self.noise_mask}"
         if os.path.exists(path):
-            self.process.sub_message_r(f': reading noisy pixel mask file: {self.noise_mask}')
+            self.process.sub_message_r(color_str(
+                f': reading noisy pixel mask file: {self.noise_mask}',
+                constants.LOG_COLOR_LEVEL_3))
             self.noise_mask_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
             if self.noise_mask_img is None:
                 raise ImageLoadError(path, f"failed to load image file {self.noise_mask}.")
@@ -163,7 +169,7 @@ class MaskNoise(SubAction):
             raise ImageLoadError(path, "file not found.")
 
     def run_frame(self, _idx, _ref_idx, image):
-        self.process.sub_message_r(': mask noisy pixels')
+        self.process.sub_message_r(color_str(': mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
         if len(image.shape) == 3:
             corrected = image.copy()
             for c in range(3):

shinestacker/algorithms/pyramid.py

@@ -12,7 +12,7 @@ class PyramidBase(BaseStackAlgo):
                  kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
                  gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
                  float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__("pyramid", 1, float_type)
+        super().__init__("pyramid", 2, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
@@ -151,11 +151,11 @@ class PyramidStack(PyramidBase):
         metadata = None
         all_laplacians = []
         levels = None
+        n = len(filenames)
         for i, img_path in enumerate(filenames):
             self.print_message(f": validating file {img_path.split('/')[-1]}")
 
             img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
-
             if updated:
                 self.dtype = metadata[1]
                 self.num_pixel_values = constants.NUM_UINT8 \
@@ -163,14 +163,17 @@ class PyramidStack(PyramidBase):
                 self.max_pixel_value = constants.MAX_UINT8 \
                     if self.dtype == np.uint8 else constants.MAX_UINT16
                 levels = int(np.log2(min(img.shape[:2]) / self.min_size))
-
             if self.do_step_callback:
                 self.process.callback('after_step', self.process.id, self.process.name, i)
             if self.process.callback('check_running', self.process.id, self.process.name) is False:
                 raise RunStopException(self.name)
-        for img_path in filenames:
+        for i, img_path in enumerate(filenames):
             self.print_message(f": processing file {img_path.split('/')[-1]}")
             img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, levels))
+            if self.do_step_callback:
+                self.process.callback('after_step', self.process.id, self.process.name, i + n)
+            if self.process.callback('check_running', self.process.id, self.process.name) is False:
+                raise RunStopException(self.name)
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))
         return stacked_image.astype(self.dtype)

shinestacker/algorithms/stack.py

@@ -3,6 +3,7 @@ import os
 import numpy as np
 from .. config.constants import constants
 from .. core.framework import JobBase
+from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
 from .utils import write_img
 from .stack_framework import FrameDirectory, ActionList
@@ -23,7 +24,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         self.frame_count = -1
 
     def focus_stack(self, filenames):
-        self.sub_message_r(': reading input files')
+        self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
         img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
         stacked_img = self.stack_algo.focus_stack(img_files)
         in_filename = filenames[0].split(".")
@@ -42,7 +43,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
         if self.plot_stack:
-            idx_str = f"{self.frame_count:04d}" if self.frame_count >= 0 else ''
+            idx_str = f"{self.frame_count + 1:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"
             if idx_str != '':
                 name += f"\nbunch: {idx_str}"
@@ -91,9 +92,9 @@ class FocusStackBunch(ActionList, FocusStackBase):
         ActionList.end(self)
 
     def run_step(self):
-        self.print_message_r(f"fusing bunch: {self.count}")
+        self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
+                                       constants.LOG_COLOR_LEVEL_2))
         self.focus_stack(self._chunks[self.count - 1])
-        self.callback('after_step', self.id, self.name, self.count)
 
 
 class FocusStack(FocusStackBase):

shinestacker/algorithms/stack_framework.py

@@ -52,8 +52,7 @@ class FramePaths:
         self.filenames = self.folder_filelist()
         file_list = self.input_full_path.replace(self.working_path, '').lstrip('/')
         self.print_message(color_str(f": {len(self.filenames)} files in folder: {file_list}",
-                                     'blue'))
-        self.print_message(color_str("focus stacking", 'blue'))
+                                     constants.LOG_COLOR_LEVEL_2))
 
     def init(self, job):
         if self.working_path == '':
@@ -213,14 +212,14 @@ class FramesRefActions(ActionList, FrameDirectory):
         pass
 
     def run_step(self):
-        if self.count == 1:
+        if self.count == 0:
             self._idx = self.ref_idx if self.step_process else 0
             self._ref_idx = self.ref_idx
             self._idx_step = +1
         ll = len(self.filenames)
         self.print_message_r(
-            color_str(f"step {self.count}/{ll}: process file: {self.filenames[self._idx]}, "
-                      f"reference: {self.filenames[self._ref_idx]}", "blue"))
+            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.run_frame(self._idx, self._ref_idx)
         if self._idx < ll:
             if self.step_process:
@@ -269,7 +268,7 @@ class CombinedActions(FramesRefActions):
 
     def run_frame(self, idx, ref_idx):
         filename = self.filenames[idx]
-        self.sub_message_r(': read input image')
+        self.sub_message_r(color_str(': read input image', constants.LOG_COLOR_LEVEL_3))
         img = read_img(f"{self.input_full_path}/{filename}")
         if self.dtype is not None and img.dtype != self.dtype:
             raise BitDepthError(self.dtype, img.dtype, )
@@ -278,7 +277,8 @@ 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.", "red"), level=logging.WARNING)
+            self.sub_message(color_str(": no actions specified.", constants.LOG_COLOR_ALERT),
+                             level=logging.WARNING)
         for a in self._actions:
             if not a.enabled:
                 self.get_logger().warning(color_str(f"{self.base_message}: sub-action disabled",
@@ -287,12 +287,14 @@ class CombinedActions(FramesRefActions):
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
                 img = a.run_frame(idx, ref_idx, img)
-        self.sub_message_r(': write output image')
+        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("No output file resulted from processing input file: "
-                               f"{self.input_full_path}/{filename}", level=logging.WARNING)
+            self.print_message(color_str(
+                "No output file resulted from processing input file: "
+                f"{self.input_full_path}/{filename}",
+                constants.LOG_COLOR_ALERT), level=logging.WARNING)
 
     def end(self):
         for a in self._actions:

shinestacker/app/app_config.py

@@ -1,28 +1,15 @@
 # pylint: disable=C0114, C0115, C0116, C0103, W0201
-class _AppConfig:
-    _initialized = False
-    _instance = None
+from .. config.config import _ConfigBase
 
+
+class _AppConfig(_ConfigBase):
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._init_defaults()
-        return cls._instance
+        return _ConfigBase.__new__(cls)
 
     def _init_defaults(self):
         self._DONT_USE_NATIVE_MENU = True
         self._COMBINED_APP = False
 
-    def init(self, **kwargs):
-        if self._initialized:
-            raise RuntimeError("Config already initialized")
-        for k, v in kwargs.items():
-            if hasattr(self, f"_{k}"):
-                setattr(self, f"_{k}", v)
-            else:
-                raise AttributeError(f"Invalid config key: {k}")
-        self._initialized = True
-
     @property
     def DONT_USE_NATIVE_MENU(self):
         return self._DONT_USE_NATIVE_MENU
@@ -31,10 +18,5 @@ class _AppConfig:
     def COMBINED_APP(self):
         return self._COMBINED_APP
 
-    def __setattr__(self, name, value):
-        if self._initialized and name.startswith('_'):
-            raise AttributeError("Can't change config after initialization")
-        super().__setattr__(name, value)
-
 
 app_config = _AppConfig()

shinestacker/app/main.py

@@ -89,7 +89,7 @@ class MainApp(QMainWindow):
         if isinstance(filename, list):
             open_frames(self.retouch_window, None, ";".join(filename))
         else:
-            self.retouch_window.open_file(filename)
+            self.retouch_window.io_gui_handler.open_file(filename)
 
 
 class Application(QApplication):

shinestacker/config/config.py

@@ -1,5 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, C0103, R0903, W0718, W0104, W0201, E0602
-class _Config:
+class _ConfigBase:
     _initialized = False
     _instance = None
 
@@ -9,16 +9,6 @@ class _Config:
             cls._instance._init_defaults()
         return cls._instance
 
-    def _init_defaults(self):
-        self._DISABLE_TQDM = False
-        self._COMBINED_APP = False
-        self._DONT_USE_NATIVE_MENU = True
-        try:
-            __IPYTHON__ # noqa
-            self._JUPYTER_NOTEBOOK = True
-        except Exception:
-            self._JUPYTER_NOTEBOOK = False
-
     def init(self, **kwargs):
         if self._initialized:
             raise RuntimeError("Config already initialized")
@@ -29,6 +19,27 @@ class _Config:
                 raise AttributeError(f"Invalid config key: {k}")
         self._initialized = True
 
+    def __setattr__(self, name, value):
+        if self._initialized and name.startswith('_'):
+            raise AttributeError("Can't change config after initialization")
+        super().__setattr__(name, value)
+
+
+class _Config(_ConfigBase):
+
+    def __new__(cls):
+        return _ConfigBase.__new__(cls)
+
+    def _init_defaults(self):
+        self._DISABLE_TQDM = False
+        self._COMBINED_APP = False
+        self._DONT_USE_NATIVE_MENU = True
+        try:
+            __IPYTHON__ # noqa
+            self._JUPYTER_NOTEBOOK = True
+        except Exception:
+            self._JUPYTER_NOTEBOOK = False
+
     @property
     def DISABLE_TQDM(self):
         return self._DISABLE_TQDM
@@ -45,10 +56,5 @@ class _Config:
     def COMBINED_APP(self):
         return self._COMBINED_APP
 
-    def __setattr__(self, name, value):
-        if self._initialized and name.startswith('_'):
-            raise AttributeError("Can't change config after initialization")
-        super().__setattr__(name, value)
-
 
 config = _Config()

shinestacker/config/constants.py

@@ -41,6 +41,12 @@ class _Constants:
 
     PATH_SEPARATOR = ';'
 
+    LOG_COLOR_ALERT = 'red'
+    LOG_COLOR_LEVEL_JOB = 'green'
+    LOG_COLOR_LEVEL_1 = 'blue'
+    LOG_COLOR_LEVEL_2 = 'magenta'
+    LOG_COLOR_LEVEL_3 = 'cyan'
+
     DEFAULT_FILE_REVERSE_ORDER = False
     DEFAULT_MULTILAYER_FILE_REVERSE_ORDER = True
 
@@ -99,8 +105,9 @@ class _Constants:
     DEFAULT_ALIGN_MAX_ITERS = 2000
     DEFAULT_BORDER_VALUE = [0] * 4
     DEFAULT_BORDER_BLUR = 50
-    DEFAULT_ALIGN_SUBSAMPLE = 1
+    DEFAULT_ALIGN_SUBSAMPLE = 2
     DEFAULT_ALIGN_FAST_SUBSAMPLING = False
+    DEFAULT_ALIGN_MIN_GOOD_MATCHES = 100
 
     BALANCE_LINEAR = "LINEAR"
     BALANCE_GAMMA = "GAMMA"

shinestacker/core/framework.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, R0917, R0913, R0902
 import time
 import logging
+from .. config.constants import constants
 from .. config.config import config
 from .colors import color_str
 from .logging import setup_logging
@@ -89,13 +90,15 @@ class JobBase:
     def run(self):
         self._t0 = time.time()
         if not self.enabled:
-            self.get_logger().warning(color_str(self.name + ": entire job disabled", 'red'))
+            self.get_logger().warning(color_str(self.name + ": entire job disabled",
+                                                constants.LOG_COLOR_ALERT))
         self.callback('before_action', self.id, self.name)
         self.run_core()
         self.callback('after_action', self.id, self.name)
-        msg_name = color_str(self.name + ":", "green", "bold")
-        msg_time = color_str(f"elapsed time: {elapsed_time_str(self._t0)}", "green")
-        msg_completed = color_str("completed", "green")
+        msg_name = color_str(self.name + ":", constants.LOG_COLOR_LEVEL_JOB, "bold")
+        msg_time = color_str(f"elapsed time: {elapsed_time_str(self._t0)}",
+                             constants.LOG_COLOR_LEVEL_JOB)
+        msg_completed = color_str("completed", constants.LOG_COLOR_LEVEL_JOB)
         self.get_logger().info(msg=f"{msg_name} {msg_time}{TRAILING_SPACES}")
         self.get_logger().info(msg=f"{msg_name} {msg_completed}{TRAILING_SPACES}")
 
@@ -115,13 +118,14 @@ class JobBase:
     def print_message(self, msg='', level=logging.INFO, end=None, begin='', tqdm=False):
         if config.DISABLE_TQDM:
             tqdm = False
-        self.base_message = color_str(self.name, "blue", "bold")
+        self.base_message = color_str(self.name, constants.LOG_COLOR_LEVEL_1, "bold")
         if msg != '':
             self.base_message += (': ' + msg)
         self.set_terminator(tqdm, end)
+        col_str = color_str(self.base_message, constants.LOG_COLOR_LEVEL_1, "bold")
         self.get_logger(tqdm).log(
             level=level,
-            msg=f"{begin}{color_str(self.base_message, 'blue', 'bold')}{TRAILING_SPACES}"
+            msg=f"{begin}{col_str}{TRAILING_SPACES}"
         )
         self.set_terminator(tqdm)
 
@@ -176,7 +180,8 @@ class Job(JobBase):
                 if not self.enabled:
                     z.append("job")
                 msg = " and ".join(z)
-                self.get_logger().warning(color_str(a.name + f": {msg} disabled", 'red'))
+                self.get_logger().warning(color_str(a.name + f": {msg} disabled",
+                                                    constants.LOG_COLOR_ALERT))
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
@@ -200,14 +205,14 @@ class ActionList(JobBase):
         self.callback('end_steps', self.id, self.name)
 
     def __iter__(self):
-        self.count = 1
+        self.count = 0
         return self
 
     def run_step(self):
         pass
 
     def __next__(self):
-        if self.count <= self.counts:
+        if self.count < self.counts:
             self.run_step()
             x = self.count
             self.count += 1
@@ -215,7 +220,7 @@ class ActionList(JobBase):
         raise StopIteration
 
     def run_core(self):
-        self.print_message('begin run', end='\n')
+        self.print_message(color_str('begin run', constants.LOG_COLOR_LEVEL_2), end='\n')
         self.begin()
         for _ in iter(self):
             self.callback('after_step', self.id, self.name, self.count)