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

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.3.6'
+__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/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/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

@@ -24,6 +24,7 @@ class _ConfigBase:
             raise AttributeError("Can't change config after initialization")
         super().__setattr__(name, value)
 
+
 class _Config(_ConfigBase):
 
     def __new__(cls):

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)

shinestacker/gui/action_config.py

@@ -206,7 +206,7 @@ class FieldBuilder:
             self.action.params.get(tag, ''),
             kwargs.get('placeholder', ''),
             tag.replace('_', ' ')
-        )
+        )[1]
 
     def create_rel_path_field(self, tag, **kwargs):
         value = self.action.params.get(tag, kwargs.get('default', ''))
@@ -316,7 +316,6 @@ class FieldBuilder:
                         QMessageBox.warning(None, "Error", "Could not compute relative path")
         return create_layout_widget_and_connect(button, edit, browse)
 
-
     def create_float_field(self, tag, default=0.0, min_val=0.0, max_val=1.0,
                            step=0.1, decimals=2):
         spin = QDoubleSpinBox()
@@ -593,7 +592,8 @@ class FocusStackConfigurator(FocusStackBaseConfigurator):
             self.builder.add_field('exif_path', FIELD_REL_PATH, 'Exif data path', required=False,
                                    placeholder='relative to working path')
             self.builder.add_field('prefix', FIELD_TEXT, 'Ouptut filename prefix', required=False,
-                                   default=constants.DEFAULT_STACK_PREFIX, placeholder="_stack")
+                                   default=constants.DEFAULT_STACK_PREFIX,
+                                   placeholder=constants.DEFAULT_STACK_PREFIX)
         self.builder.add_field('plot_stack', FIELD_BOOL, 'Plot stack', required=False,
                                default=constants.DEFAULT_PLOT_STACK)
         super().common_fields(layout)
@@ -616,10 +616,11 @@ class MultiLayerConfigurator(DefaultActionConfigurator):
         super().create_form(layout, action)
         if self.expert:
             self.builder.add_field('working_path', FIELD_ABS_PATH, 'Working path', required=False)
-            self.builder.add_field('input_path', FIELD_REL_PATH,
-                                   f'Input path (separate by {constants.PATH_SEPARATOR})',
-                                   required=False, multiple_entries=True,
-                                   placeholder='relative to working path')
+        self.builder.add_field('input_path', FIELD_REL_PATH,
+                               f'Input path (separate by {constants.PATH_SEPARATOR})',
+                               required=False, multiple_entries=True,
+                               placeholder='relative to working path')
+        if self.expert:
             self.builder.add_field('output_path', FIELD_REL_PATH, 'Output path', required=False,
                                    placeholder='relative to working path')
             self.builder.add_field('exif_path', FIELD_REL_PATH, 'Exif data path', required=False,
@@ -805,6 +806,9 @@ class AlignFramesConfigurator(DefaultActionConfigurator):
             rans_threshold = self.builder.add_field(
                 'rans_threshold', FIELD_FLOAT, 'RANSAC threshold (px)', required=False,
                 default=constants.DEFAULT_RANS_THRESHOLD, min_val=0, max_val=20, step=0.1)
+            self.builder.add_field(
+                'min_good_matches', FIELD_INT, "Min. good matches", required=False,
+                default=constants.DEFAULT_ALIGN_MIN_GOOD_MATCHES, min_val=0, max_val=500)
 
             def change_method():
                 text = method.currentText()

shinestacker/gui/gui_logging.py

@@ -17,6 +17,7 @@ class SimpleHtmlFormatter(logging.Formatter):
     FF = '80'
     OO = '00'
     MM = '40'
+    GG = 'FF'
     ANSI_COLORS = {
         # Reset
         '\x1b[0m': '</span>',
@@ -32,13 +33,13 @@ class SimpleHtmlFormatter(logging.Formatter):
         '\x1b[37m': f'<span style="color:#{FF}{FF}{FF}">',  # white
         # Brilliant colors (90-97)
         '\x1b[90m': f'<span style="color:#{MM}{MM}{MM}">',
-        '\x1b[91m': f'<span style="color:#{FF}{MM}{MM}">',
-        '\x1b[92m': f'<span style="color:#{MM}{FF}{MM}">',
-        '\x1b[93m': f'<span style="color:#{FF}{FF}{MM}">',
-        '\x1b[94m': f'<span style="color:#{MM}{MM}{FF}">',
-        '\x1b[95m': f'<span style="color:#{FF}{MM}{FF}">',
-        '\x1b[96m': f'<span style="color:#{MM}{FF}{FF}">',
-        '\x1b[97m': f'<span style="color:#{FF}{FF}{FF}">',
+        '\x1b[91m': f'<span style="color:#{GG}{MM}{MM}">',
+        '\x1b[92m': f'<span style="color:#{MM}{GG}{MM}">',
+        '\x1b[93m': f'<span style="color:#{GG}{GG}{MM}">',
+        '\x1b[94m': f'<span style="color:#{MM}{MM}{GG}">',
+        '\x1b[95m': f'<span style="color:#{GG}{MM}{GG}">',
+        '\x1b[96m': f'<span style="color:#{MM}{GG}{GG}">',
+        '\x1b[97m': f'<span style="color:#{GG}{GG}{GG}">',
         # Background (40-47)
         '\x1b[40m': f'<span style="background-color:#{OO}{OO}{OO}">',
         '\x1b[41m': f'<span style="background-color:#{FF}{OO}{OO}">',

shinestacker/gui/gui_run.py

@@ -13,6 +13,10 @@ from .gui_images import GuiPdfView, GuiImageView, GuiOpenApp
 from .colors import ColorPalette
 
 
+ACTION_RUNNING_COLOR = ColorPalette.MEDIUM_BLUE
+ACTION_DONE_COLOR = ColorPalette.MEDIUM_GREEN
+
+
 class ColorButton(QPushButton):
     def __init__(self, text, enabled, parent=None):
         super().__init__(text.replace(gui_constants.DISABLED_TAG, ''), parent)
@@ -36,10 +40,6 @@ class ColorButton(QPushButton):
         """)
 
 
-action_running_color = ColorPalette.MEDIUM_BLUE
-action_done_color = ColorPalette.MEDIUM_GREEN
-
-
 class TimerProgressBar(QProgressBar):
     light_background_color = ColorPalette.LIGHT_BLUE
     border_color = ColorPalette.DARK_BLUE
@@ -123,10 +123,10 @@ class TimerProgressBar(QProgressBar):
     # pylint: enable=C0103
 
     def set_running_style(self):
-        self.set_style(action_running_color)
+        self.set_style(ACTION_RUNNING_COLOR)
 
     def set_done_style(self):
-        self.set_style(action_done_color)
+        self.set_style(ACTION_DONE_COLOR)
 
 
 class RunWindow(QTextEditLogger):
@@ -246,7 +246,7 @@ class RunWindow(QTextEditLogger):
     @Slot(int, str)
     def handle_before_action(self, run_id, _name):
         if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][run_id].set_color(*action_running_color.tuple())
+            self.color_widgets[self.row_widget_id][run_id].set_color(*ACTION_RUNNING_COLOR.tuple())
             self.progress_bar.start(1)
         if run_id == -1:
             self.progress_bar.set_running_style()
@@ -254,7 +254,7 @@ class RunWindow(QTextEditLogger):
     @Slot(int, str)
     def handle_after_action(self, run_id, _name):
         if 0 <= run_id < len(self.color_widgets[self.row_widget_id]):
-            self.color_widgets[self.row_widget_id][run_id].set_color(*action_done_color.tuple())
+            self.color_widgets[self.row_widget_id][run_id].set_color(*ACTION_DONE_COLOR.tuple())
             self.progress_bar.stop()
         if run_id == -1:
             self.row_widget_id += 1

shinestacker/gui/main_window.py

@@ -163,11 +163,11 @@ class MainWindow(ActionsWindow, LogManager):
         self.action_list.itemDoubleClicked.connect(self.on_action_edit)
         vbox_left = QVBoxLayout()
         vbox_left.setSpacing(4)
-        vbox_left.addWidget(QLabel("Jobs"))
+        vbox_left.addWidget(QLabel("Job"))
         vbox_left.addWidget(self.job_list)
         vbox_right = QVBoxLayout()
         vbox_right.setSpacing(4)
-        vbox_right.addWidget(QLabel("Actions"))
+        vbox_right.addWidget(QLabel("Action"))
         vbox_right.addWidget(self.action_list)
         self.job_list.itemSelectionChanged.connect(self.update_delete_action_state)
         self.action_list.itemSelectionChanged.connect(self.update_delete_action_state)
@@ -615,7 +615,7 @@ class MainWindow(ActionsWindow, LogManager):
                 labels = [[(self.action_text(a), a.enabled()) for a in job.sub_actions]]
                 r = self.get_retouch_path(job)
                 retouch_paths = [] if len(r) == 0 else [(job_name, r)]
-                new_window, id_str = self.create_new_window("Job: " + job_name,
+                new_window, id_str = self.create_new_window(f"{job_name} [⚙️ Job]",
                                                             labels, retouch_paths)
                 worker = JobLogWorker(job, id_str)
                 self.connect_signals(worker, new_window)
@@ -638,7 +638,7 @@ class MainWindow(ActionsWindow, LogManager):
             r = self.get_retouch_path(job)
             if len(r) > 0:
                 retouch_paths.append((job.params["name"], r))
-        new_window, id_str = self.create_new_window("Project: " + project_name,
+        new_window, id_str = self.create_new_window(f"{project_name} [Project 📚]",
                                                     labels, retouch_paths)
         worker = ProjectLogWorker(self.project, id_str)
         self.connect_signals(worker, new_window)