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

shinestacker/algorithms/stack_framework.py

@@ -6,8 +6,8 @@ from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.framework import Job, ActionList
 from .. core.core_utils import check_path_exists
-from .. core.exceptions import ShapeError, BitDepthError, RunStopException
-from .utils import read_img, write_img, extension_tif_jpg
+from .. core.exceptions import RunStopException
+from .utils import read_img, write_img, extension_tif_jpg, get_img_metadata, validate_image
 
 
 class StackJob(Job):
@@ -33,26 +33,73 @@ class FramePaths:
         self.working_path = working_path
         self.plot_path = plot_path
         self.input_path = input_path
-        self.output_path = output_path
-        self.output_dir = None
+        self.output_path = self.name if output_path == '' else output_path
         self.resample = resample
         self.reverse_order = reverse_order
         self.scratch_output_dir = scratch_output_dir
-        self.input_full_path = None
         self.enabled = None
-        self.filenames = None
         self.base_message = ''
-
-    def folder_filelist(self):
-        assert False, "this method should be overwritten"
+        self._input_full_path = None
+        self._output_full_path = None
+        self._input_filepaths = None
+
+    def output_full_path(self):
+        if self._output_full_path is None:
+            self._output_full_path = os.path.join(self.working_path, self.output_path)
+        return self._output_full_path
+
+    def input_full_path(self):
+        if self._input_full_path is None:
+            if isinstance(self.input_path, str):
+                self._input_full_path = os.path.join(self.working_path, self.input_path)
+                check_path_exists(self._input_full_path)
+            elif hasattr(self.input_path, "__len__"):
+                self._input_full_path = [os.path.join(self.working_path, path)
+                                         for path in self.input_path]
+                for path in self._input_full_path:
+                    check_path_exists(path)
+        return self._input_full_path
+
+    def input_filepaths(self):
+        if self._input_filepaths is None:
+            if isinstance(self.input_full_path(), str):
+                dirs = [self.input_full_path()]
+            elif hasattr(self.input_full_path(), "__len__"):
+                dirs = self.input_full_path()
+            else:
+                raise RuntimeError("input_full_path option must contain "
+                                   "a path or an array of paths")
+            files = []
+            for d in dirs:
+                filelist = []
+                for _dirpath, _, filenames in os.walk(d):
+                    filelist = [os.path.join(_dirpath, name)
+                                for name in filenames if extension_tif_jpg(name)]
+                    filelist.sort()
+                    if self.reverse_order:
+                        filelist.reverse()
+                    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",
+                                                 constants.LOG_COLOR_WARNING),
+                                       level=logging.WARNING)
+            self._input_filepaths = files
+        return self._input_filepaths
+
+    def input_filepath(self, index):
+        return self.input_filepaths()[index]
+
+    def num_input_filepaths(self):
+        return len(self.input_filepaths())
 
     def print_message(self, msg='', level=logging.INFO, end=None, begin='', tqdm=False):
         assert False, "this method should be overwritten"
 
     def set_filelist(self):
-        self.filenames = self.folder_filelist()
-        file_folder = self.input_full_path.replace(self.working_path, '').lstrip('/')
-        self.print_message(color_str(f"{len(self.filenames)} files in folder: {file_folder}",
+        file_folder = self.input_full_path().replace(self.working_path, '').lstrip('/')
+        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")
 
@@ -60,20 +107,16 @@ class FramePaths:
         if self.working_path == '':
             self.working_path = job.working_path
         check_path_exists(self.working_path)
-        if self.output_path == '':
-            self.output_path = self.name
-        self.output_dir = self.working_path + \
-            ('' if self.working_path[-1] == '/' else '/') + \
-            self.output_path
-        if not os.path.exists(self.output_dir):
-            os.makedirs(self.output_dir)
+        output_dir = self.output_full_path()
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
         else:
-            list_dir = os.listdir(self.output_dir)
+            list_dir = os.listdir(output_dir)
             if len(list_dir) > 0:
                 if self.scratch_output_dir:
                     if self.enabled:
                         for filename in list_dir:
-                            file_path = os.path.join(self.output_dir, filename)
+                            file_path = os.path.join(output_dir, filename)
                             if os.path.isfile(file_path):
                                 os.remove(file_path)
                         self.print_message(
@@ -100,136 +143,69 @@ class FramePaths:
             self.input_path = job.paths[-1]
         job.paths.append(self.output_path)
 
-
-class FrameDirectory(FramePaths):
-    def __init__(self, name, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-
     def folder_list_str(self):
-        if isinstance(self.input_full_path, list):
+        if isinstance(self.input_full_path(), list):
             file_list = ", ".join(
-                list(self.input_full_path.replace(self.working_path, '').lstrip('/')))
-            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
-        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
-
-    def folder_filelist(self):
-        src_contents = os.walk(self.input_full_path)
-        _dirpath, _, filenames = next(src_contents)
-        filelist = [name for name in filenames if extension_tif_jpg(name)]
-        filelist.sort()
-        if self.reverse_order:
-            filelist.reverse()
-        if self.resample > 1:
-            filelist = filelist[0::self.resample]
-        return filelist
+                [path.replace(self.working_path, '').lstrip('/')
+                 for path in self.input_full_path()])
+            return "folder" + ('s' if len(self.input_full_path()) > 1 else '') + f": {file_list}"
+        return "folder: " + self.input_full_path().replace(self.working_path, '').lstrip('/')
 
-    def init(self, job, _working_path=''):
-        FramePaths.init(self, job)
-        self.input_full_path = self.working_path + \
-            ('' if self.working_path[-1] == '/' else '/') + self.input_path
-        check_path_exists(self.input_full_path)
-        job.paths.append(self.output_path)
-
-
-class FrameMultiDirectory(FramePaths):
-    def __init__(self, name, input_path='', output_path='', working_path='',
-                 plot_path=constants.DEFAULT_PLOTS_PATH,
-                 scratch_output_dir=True, resample=1,
-                 reverse_order=constants.DEFAULT_FILE_REVERSE_ORDER, **_kwargs):
-        FramePaths.__init__(self, name, input_path, output_path, working_path, plot_path,
-                            scratch_output_dir, resample, reverse_order)
-        self.input_full_path = None
 
-    def folder_list_str(self):
-        if isinstance(self.input_full_path, list):
-            file_list = ", ".join([d.replace(self.working_path, '').lstrip('/')
-                                   for d in self.input_full_path])
-            return "folder" + ('s' if len(self.input_full_path) > 1 else '') + f": {file_list}"
-        return "folder: " + self.input_full_path.replace(self.working_path, '').lstrip('/')
-
-    def folder_filelist(self):
-        if isinstance(self.input_full_path, str):
-            dirs = [self.input_full_path]
-            paths = [self.input_path]
-        elif hasattr(self.input_full_path, "__len__"):
-            dirs = self.input_full_path
-            paths = self.input_path
-        else:
-            raise RuntimeError("input_full_path option must contain a path or an array of paths")
-        files = []
-        for d, p in zip(dirs, paths):
-            filelist = []
-            for _dirpath, _, filenames in os.walk(d):
-                filelist = [f"{p}/{name}" for name in filenames if extension_tif_jpg(name)]
-                if self.reverse_order:
-                    filelist.reverse()
-                if self.resample > 1:
-                    filelist = filelist[0::self.resample]
-                files += filelist
-            if len(files) == 0:
-                self.print_message(color_str(f"input folder {p} does not contain any image", "red"),
-                                   level=logging.WARNING)
-        return files
-
-    def init(self, job):
-        FramePaths.init(self, job)
-        if isinstance(self.input_path, str):
-            self.input_full_path = self.working_path + \
-                ('' if self.working_path[-1] == '/' else '/') + \
-                self.input_path
-            check_path_exists(self.input_full_path)
-        elif hasattr(self.input_path, "__len__"):
-            self.input_full_path = []
-            for path in self.input_path:
-                self.input_full_path.append(self.working_path +
-                                            ('' if self.working_path[-1] == '/' else '/') +
-                                            path)
-        job.paths.append(self.output_path)
-
-
-class FramesRefActions(ActionList, FrameDirectory):
-    def __init__(self, name, enabled=True, ref_idx=-1, step_process=False, **kwargs):
-        FrameDirectory.__init__(self, name, **kwargs)
+class FramesRefActions(ActionList, FramePaths):
+    def __init__(self, name, enabled=True, reference_index=0, step_process=False, **kwargs):
+        FramePaths.__init__(self, name, **kwargs)
         ActionList.__init__(self, name, enabled)
-        self.ref_idx = ref_idx
+        self.ref_idx = reference_index
         self.step_process = step_process
-        self._idx = None
-        self._ref_idx = None
-        self._idx_step = None
+        self.current_idx = None
+        self.current_ref_idx = None
+        self.current_idx_step = None
 
     def begin(self):
         ActionList.begin(self)
         self.set_filelist()
-        self.set_counts(len(self.filenames))
-        if self.ref_idx == -1:
-            self.ref_idx = len(self.filenames) // 2
+        n = self.num_input_filepaths()
+        self.set_counts(n)
+        if self.ref_idx == 0:
+            self.ref_idx = n // 2
+        elif self.ref_idx == -1:
+            self.ref_idx = n - 1
+        else:
+            self.ref_idx -= 1
+            if not 0 <= self.ref_idx < n:
+                msg = f"reference index {self.ref_idx} out of range [1, {n}]"
+                self.print_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_2))
+                raise IndexError(msg)
 
     def end(self):
         ActionList.end(self)
 
     def run_frame(self, _idx, _ref_idx):
-        pass
+        return None
 
     def run_step(self):
-        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)
+        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.count + 1}/{ll}: process file: {self.filenames[self._idx]}, "
-                      f"reference: {self.filenames[self._ref_idx]}", constants.LOG_COLOR_LEVEL_2))
+            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")
-        self.run_frame(self._idx, self._ref_idx)
-        if self._idx < ll:
-            if self.step_process:
-                self._ref_idx = self._idx
-            self._idx += self._idx_step
-        if self._idx == ll:
-            self._idx = self.ref_idx - 1
+        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:
-                self._ref_idx = self.ref_idx
-            self._idx_step = -1
+                self.current_ref_idx = self.ref_idx
+            self.current_idx_step = -1
 
 
 class SubAction:
@@ -247,8 +223,7 @@ class CombinedActions(FramesRefActions):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
         FramesRefActions.__init__(self, name, enabled, **kwargs)
         self._actions = actions
-        self.dtype = None
-        self.shape = None
+        self._metadata = (None, None)
 
     def begin(self):
         FramesRefActions.begin(self)
@@ -257,32 +232,27 @@ class CombinedActions(FramesRefActions):
                 a.begin(self)
 
     def img_ref(self, idx):
-        filename = self.filenames[idx]
-        img = read_img((self.output_dir
-                        if self.step_process else self.input_full_path) + f"/{filename}")
+        input_path = self.input_filepath(idx)
+        img = read_img(input_path)
         if img is None:
-            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
-        self.dtype = img.dtype
-        self.shape = img.shape
+            raise RuntimeError(f"Invalid file: {os.path.basename(input_path)}")
+        self._metadata = get_img_metadata(img)
         return img
 
     def run_frame(self, idx, ref_idx):
-        filename = self.filenames[idx]
+        input_path = self.input_filepath(idx)
         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, )
-        if self.shape is not None and img.shape != self.shape:
-            raise ShapeError(self.shape, img.shape)
+        img = read_img(input_path)
+        validate_image(img, *(self._metadata))
         if img is None:
-            raise RuntimeError(f"Invalid file: {self.input_full_path}/{filename}")
+            raise RuntimeError(f"Invalid file:  {os.path.basename(input_path)}")
         if len(self._actions) == 0:
             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",
-                                                    'red'))
+                                                    constants.LOG_COLOR_ALERT))
             else:
                 if self.callback('check_running', self.id, self.name) is False:
                     raise RunStopException(self.name)
@@ -293,14 +263,15 @@ class CombinedActions(FramesRefActions):
                         color_str(": null input received, action skipped",
                                   constants.LOG_COLOR_ALERT),
                         level=logging.WARNING)
-        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(color_str(
-                "no output file resulted from processing input file: "
-                f"{self.input_full_path}/{filename}",
-                constants.LOG_COLOR_ALERT), level=logging.WARNING)
+            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))
+            write_img(output_path, img)
+            return img
+        self.print_message(color_str(
+            f"no output file resulted from processing input file: {os.path.basename(input_path)}",
+            constants.LOG_COLOR_ALERT), level=logging.WARNING)
+        return None
 
     def end(self):
         for a in self._actions:

shinestacker/algorithms/vignetting.py

@@ -160,7 +160,7 @@ class Vignetting(SubAction):
                                            "light_blue"),
                                  level=logging.DEBUG)
         if self.plot_correction:
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             plt.plot(radii, intensities, label="image mean intensity")
             plt.plot(radii, sigmoid_model(radii * subsample, *params), label="sigmoid fit")
             plt.xlabel('radius (pixels)')
@@ -187,12 +187,12 @@ class Vignetting(SubAction):
 
     def begin(self, process):
         self.process = process
-        self.corrections = [np.full(self.process.counts, None, dtype=float)
+        self.corrections = [np.full(self.process.total_action_counts, None, dtype=float)
                             for p in self.percentiles]
 
     def end(self):
         if self.plot_summary:
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             xs = np.arange(1, len(self.corrections[0]) + 1, dtype=int)
             for i, p in enumerate(self.percentiles):
                 linestyle = 'solid'

shinestacker/config/constants.py

@@ -22,6 +22,8 @@ class _Constants:
 
     ANSI_ESCAPE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
+    PLT_FIG_SIZE = (10, 5)
+
     ACTION_JOB = "Job"
     ACTION_COMBO = "CombinedActions"
     ACTION_NOISEDETECTION = "NoiseDetection"
@@ -116,7 +118,7 @@ class _Constants:
     DEFAULT_REFINE_ITERS = 100
     DEFAULT_ALIGN_CONFIDENCE = 99.9
     DEFAULT_ALIGN_MAX_ITERS = 2000
-    DEFAULT_ALIGN_ABORT_ABNORMAL = True
+    DEFAULT_ALIGN_ABORT_ABNORMAL = False
     DEFAULT_BORDER_VALUE = [0] * 4
     DEFAULT_BORDER_BLUR = 50
     DEFAULT_ALIGN_SUBSAMPLE = 0

shinestacker/core/framework.py

@@ -24,7 +24,7 @@ class TqdmCallbacks:
 
     def __init__(self):
         self.tbar = None
-        self.counts = -1
+        self.total_action_counts = -1
 
     @classmethod
     def instance(cls):
@@ -33,8 +33,8 @@ class TqdmCallbacks:
         return cls._instance
 
     def step_counts(self, name, counts):
-        self.counts = counts
-        self.tbar = make_tqdm_bar(name, self.counts)
+        self.total_action_counts = counts
+        self.tbar = make_tqdm_bar(name, self.total_action_counts)
 
     def begin_steps(self, name):
         pass
@@ -191,12 +191,12 @@ class Job(JobBase):
 class ActionList(JobBase):
     def __init__(self, name, enabled=True, **kwargs):
         JobBase.__init__(self, name, enabled, **kwargs)
-        self.counts = None
-        self.count = None
+        self.total_action_counts = None
+        self.current_action_count = None
 
     def set_counts(self, counts):
-        self.counts = counts
-        self.callback('step_counts', self.id, self.name, self.counts)
+        self.total_action_counts = counts
+        self.callback('step_counts', self.id, self.name, self.total_action_counts)
 
     def begin(self):
         self.callback('begin_steps', self.id, self.name)
@@ -205,17 +205,17 @@ class ActionList(JobBase):
         self.callback('end_steps', self.id, self.name)
 
     def __iter__(self):
-        self.count = 0
+        self.current_action_count = 0
         return self
 
     def run_step(self):
         pass
 
     def __next__(self):
-        if self.count < self.counts:
+        if self.current_action_count < self.total_action_counts:
             self.run_step()
-            x = self.count
-            self.count += 1
+            x = self.current_action_count
+            self.current_action_count += 1
             return x
         raise StopIteration
 
@@ -223,7 +223,7 @@ class ActionList(JobBase):
         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)
+            self.callback('after_step', self.id, self.name, self.current_action_count)
             if self.callback('check_running', self.id, self.name) is False:
                 raise RunStopException(self.name)
         self.end()

shinestacker/gui/action_config.py

@@ -16,12 +16,16 @@ FIELD_ABS_PATH = 'abs_path'
 FIELD_REL_PATH = 'rel_path'
 FIELD_FLOAT = 'float'
 FIELD_INT = 'int'
+FIELD_REF_IDX = 'ref_idx'
 FIELD_INT_TUPLE = 'int_tuple'
 FIELD_BOOL = 'bool'
 FIELD_COMBO = 'combo'
 FIELD_TYPES = [FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
                FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO]
 
+FIELD_REF_IDX_OPTIONS = ['Median frame', 'First frame', 'Last frame', 'Specify index']
+FIELD_REF_IDX_MAX = 1000
+
 
 class ActionConfigurator(ABC):
     def __init__(self, expert, current_wd):
@@ -56,6 +60,8 @@ class FieldBuilder:
             widget = self.create_float_field(tag, **kwargs)
         elif field_type == FIELD_INT:
             widget = self.create_int_field(tag, **kwargs)
+        elif field_type == FIELD_REF_IDX:
+            widget = self.create_ref_idx_field(tag, **kwargs)
         elif field_type == FIELD_INT_TUPLE:
             widget = self.create_int_tuple_field(tag, **kwargs)
         elif field_type == FIELD_BOOL:
@@ -75,6 +81,8 @@ class FieldBuilder:
                 default_value = kwargs.get('default', 0.0)
             elif field_type == FIELD_INT:
                 default_value = kwargs.get('default', 0)
+            elif field_type == FIELD_REF_IDX:
+                default_value = kwargs.get('default', 0)
             elif field_type == FIELD_INT_TUPLE:
                 default_value = kwargs.get('default', [0] * kwargs.get('size', 1))
             elif field_type == FIELD_BOOL:
@@ -112,6 +120,9 @@ class FieldBuilder:
                     widget.setChecked(default)
                 elif field['type'] == FIELD_INT:
                     widget.setValue(default)
+                elif field['type'] == FIELD_REF_IDX:
+                    widget.layout().itemAt(2).widget().setValue(default)
+                    widget.layout().itemAt(0).widget().setCurrentText(FIELD_REF_IDX_OPTIONS[0])
                 elif field['type'] == FIELD_INT_TUPLE:
                     for i in range(field['size']):
                         spinbox = widget.layout().itemAt(1 + i * 2).widget()
@@ -146,6 +157,17 @@ class FieldBuilder:
                 params[tag] = field['widget'].isChecked()
             elif field['type'] == FIELD_INT:
                 params[tag] = field['widget'].value()
+            elif field['type'] == FIELD_REF_IDX:
+                wl = field['widget'].layout()
+                txt = wl.itemAt(0).widget().currentText()
+                if txt == FIELD_REF_IDX_OPTIONS[0]:
+                    params[tag] = 0
+                elif txt == FIELD_REF_IDX_OPTIONS[1]:
+                    params[tag] = 1
+                elif txt == FIELD_REF_IDX_OPTIONS[2]:
+                    params[tag] = -1
+                else:
+                    params[tag] = wl.itemAt(2).widget().value()
             elif field['type'] == FIELD_INT_TUPLE:
                 params[tag] = [field['widget'].layout().itemAt(1 + i * 2).widget().value()
                                for i in range(field['size'])]
@@ -327,6 +349,37 @@ class FieldBuilder:
         spin.setValue(self.action.params.get(tag, default))
         return spin
 
+    def create_ref_idx_field(self, tag, default=0):
+        layout = QHBoxLayout()
+        combo = QComboBox()
+        combo.addItems(FIELD_REF_IDX_OPTIONS)
+        label = QLabel("index [1, ..., N]: ")
+        spin = QSpinBox()
+        spin.setRange(1, FIELD_REF_IDX_MAX)
+        value = self.action.params.get(tag, default)
+        if value == 0:
+            combo.setCurrentText(FIELD_REF_IDX_OPTIONS[0])
+            spin.setValue(1)
+        elif value == 1:
+            combo.setCurrentText(FIELD_REF_IDX_OPTIONS[1])
+            spin.setValue(1)
+        elif value == -1:
+            combo.setCurrentText(FIELD_REF_IDX_OPTIONS[2])
+            spin.setValue(1)
+        else:
+            combo.setCurrentText(FIELD_REF_IDX_OPTIONS[3])
+            spin.setValue(value)
+
+        def set_enabled():
+            spin.setEnabled(combo.currentText() == FIELD_REF_IDX_OPTIONS[-1])
+
+        combo.currentTextChanged.connect(set_enabled)
+        set_enabled()
+        layout.addWidget(combo)
+        layout.addWidget(label)
+        layout.addWidget(spin)
+        return create_layout_widget_no_margins(layout)
+
     def create_int_tuple_field(self, tag, size=1,
                                default=[0] * 100, min_val=[0] * 100, max_val=[100] * 100,
                                **kwargs):

shinestacker/gui/action_config_dialog.py

@@ -12,7 +12,7 @@ from .base_form_dialog import create_form_layout
 from . action_config import (
     FieldBuilder, ActionConfigurator,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
-    FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO
+    FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
 
 
@@ -101,9 +101,8 @@ class ActionConfigDialog(QDialog):
             action_type, DefaultActionConfigurator)(self.expert(), self.current_wd)
 
     def accept(self):
-        self.parent().project_editor.add_undo(self.parent().project().clone())
         if self.configurator.update_params(self.action.params):
-            self.parent().mark_as_modified()
+            self.parent().mark_as_modified(True, "Modify Configuration")
             super().accept()
         else:
             self.parent().project_editor.pop_undo()
@@ -431,8 +430,8 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
                 'resample', FIELD_INT, 'Resample frame stack', required=False,
                 default=1, min_val=1, max_val=100)
             self.add_field(
-                'ref_idx', FIELD_INT, 'Reference frame index', required=False,
-                default=-1, min_val=-1, max_val=1000)
+                'reference_index', FIELD_REF_IDX, 'Reference frame', required=False,
+                default=0)
             self.add_field(
                 'step_process', FIELD_BOOL, 'Step process', required=False,
                 default=True)

shinestacker/gui/gui_images.py

@@ -67,13 +67,13 @@ class GuiImageView(QWidget):
         super().__init__(parent)
         self.file_path = file_path
         self.setFixedWidth(gui_constants.GUI_IMG_WIDTH)
-        self.layout = QVBoxLayout()
-        self.layout.setContentsMargins(0, 0, 0, 0)
-        self.layout.setSpacing(0)
+        self.main_layout = QVBoxLayout()
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
         self.image_label = QLabel()
         self.image_label.setAlignment(Qt.AlignCenter)
-        self.layout.addWidget(self.image_label)
-        self.setLayout(self.layout)
+        self.main_layout.addWidget(self.image_label)
+        self.setLayout(self.main_layout)
         pixmap = QPixmap(file_path)
         if pixmap:
             scaled_pixmap = pixmap.scaledToWidth(
@@ -105,13 +105,13 @@ class GuiOpenApp(QWidget):
         self.file_path = file_path
         self.app = app
         self.setFixedWidth(gui_constants.GUI_IMG_WIDTH)
-        self.layout = QVBoxLayout()
-        self.layout.setContentsMargins(0, 0, 0, 0)
-        self.layout.setSpacing(0)
+        self.main_layout = QVBoxLayout()
+        self.main_layout.setContentsMargins(0, 0, 0, 0)
+        self.main_layout.setSpacing(0)
         self.image_label = QLabel()
         self.image_label.setAlignment(Qt.AlignCenter)
-        self.layout.addWidget(self.image_label)
-        self.setLayout(self.layout)
+        self.main_layout.addWidget(self.image_label)
+        self.setLayout(self.main_layout)
         pixmap = QPixmap(file_path)
         if pixmap:
             scaled_pixmap = pixmap.scaledToWidth(

shinestacker/gui/gui_run.py

@@ -328,7 +328,7 @@ class RunWorker(LogWorker):
         self.status_signal.emit(f"{self.tag} running...", constants.RUN_ONGOING, "", 0)
         self.html_signal.emit(f'''
         <div style="margin: 2px 0; font-family: {constants.LOG_FONTS_STR};">
-        <span style="color: #{ColorPalette.DARK_BLUE.hex()}; font-style: italic; font-weigt: bold;">{self.tag} begins</span>
+        <span style="color: #{ColorPalette.DARK_BLUE.hex()}; font-style: italic; font-weight: bold;">{self.tag} begins</span>
         </div>
         ''') # noqa
         status, error_message = self.do_run()