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

shinestacker/algorithms/vignetting.py

@@ -1,4 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, R0902, E1101, W0718, W0640, R0913, R0917, R0914
+import math
 import traceback
 import logging
 import numpy as np
@@ -49,16 +50,30 @@ def fit_sigmoid(radii, intensities):
     return res
 
 
+def subsample_factor(subsample, image):
+    if subsample == 0:
+        h, w = image.shape[:2]
+        img_res = (float(h) / 1000) * (float(w) / 1000)
+        target_res = constants.DEFAULT_BALANCE_RES_TARGET_MPX
+        subsample = int(1 + math.floor(img_res / target_res))
+    return subsample
+
+
 def img_subsampled(image, subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
                    fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
     image_bw = cv2.cvtColor(img_8bit(image), cv2.COLOR_BGR2GRAY)
-    return image_bw if subsample == 1 else img_subsample(image_bw, subsample, fast_subsampling)
+    if subsample == 0:
+        subsample = subsample_factor(subsample, image)
+    img_sub = image_bw if subsample == 1 else img_subsample(image_bw, subsample, fast_subsampling)
+    return img_sub
 
 
 def compute_fit_parameters(
         image, r_steps, radii=None, intensities=None,
         subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
         fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    if subsample == 0:
+        subsample = subsample_factor(subsample, image)
     image_sub = img_subsampled(image, subsample, fast_subsampling)
     if radii is None and intensities is None:
         radii, intensities = radial_mean_intensity(image_sub, r_steps)
@@ -77,6 +92,8 @@ def correct_vignetting(
     if params is None:
         if r_steps is None:
             raise RuntimeError("Either r_steps or pars must not be None")
+        if subsample == 0:
+            subsample = subsample_factor(subsample, image)
         params = compute_fit_parameters(
             image, r_steps, subsample=subsample, fast_subsampling=fast_subsampling)
     if v0 is None:
@@ -121,11 +138,12 @@ class Vignetting(SubAction):
         h, w = img_0.shape[:2]
         self.w_2, self.h_2 = w / 2, h / 2
         self.r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
-        image_sub = img_subsampled(img_0, self.subsample, self.fast_subsampling)
+        subsample = subsample_factor(self.subsample, img_0)
+        image_sub = img_subsampled(img_0, subsample, self.fast_subsampling)
         radii, intensities = radial_mean_intensity(image_sub, self.r_steps)
         try:
             params = compute_fit_parameters(
-                img_0, self.r_steps, radii, intensities, self.subsample, self.fast_subsampling)
+                img_0, self.r_steps, radii, intensities, subsample, self.fast_subsampling)
         except Exception as e:
             traceback.print_tb(e.__traceback__)
             self.process.sub_message(
@@ -142,9 +160,9 @@ 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 * self.subsample, *params), label="sigmoid fit")
+            plt.plot(radii, sigmoid_model(radii * subsample, *params), label="sigmoid fit")
             plt.xlabel('radius (pixels)')
             plt.ylabel('mean intensity')
             plt.legend()
@@ -165,16 +183,16 @@ class Vignetting(SubAction):
         self.process.sub_message_r(color_str(": correct vignetting", "cyan"))
         return correct_vignetting(
             img_0, self.max_correction, self.black_threshold, None, params, self.v0,
-            self.subsample, self.fast_subsampling)
+            subsample, self.fast_subsampling)
 
     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

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, C0103, R0903
 import sys
 import re
+import os
 
 
 class _Constants:
@@ -12,12 +13,17 @@ class _Constants:
     NUM_UINT16 = 65536
     MAX_UINT8 = 255
     MAX_UINT16 = 65535
+    ONE_KILO = 1024
+    ONE_MEGA = ONE_KILO**2
+    ONE_GIGA = ONE_KILO**3
 
     LOG_FONTS = ['Monaco', 'Menlo', ' Lucida Console', 'Courier New', 'Courier', 'monospace']
     LOG_FONTS_STR = ", ".join(LOG_FONTS)
 
     ANSI_ESCAPE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
+    PLT_FIG_SIZE = (10, 5)
+
     ACTION_JOB = "Job"
     ACTION_COMBO = "CombinedActions"
     ACTION_NOISEDETECTION = "NoiseDetection"
@@ -34,12 +40,17 @@ class _Constants:
     SUB_ACTION_TYPES = [ACTION_MASKNOISE, ACTION_VIGNETTING, ACTION_ALIGNFRAMES,
                         ACTION_BALANCEFRAMES]
     STACK_ALGO_PYRAMID = 'Pyramid'
-    STACK_ALGO_PYRAMID_TILES = 'Pyramid Tiles'
     STACK_ALGO_DEPTH_MAP = 'Depth map'
-    STACK_ALGO_OPTIONS = [STACK_ALGO_PYRAMID, STACK_ALGO_PYRAMID_TILES, STACK_ALGO_DEPTH_MAP]
+    STACK_ALGO_OPTIONS = [STACK_ALGO_PYRAMID, STACK_ALGO_DEPTH_MAP]
     STACK_ALGO_DEFAULT = STACK_ALGO_PYRAMID
     DEFAULT_PLOTS_PATH = 'plots'
 
+    FIELD_SUBSAMPLE_VALUES_1 = [2, 3, 4, 6, 8, 12, 16, 24, 32]
+    FIELD_SUBSAMPLE_OPTIONS_1 = [f"1/{n} × 1/{n}" for n in FIELD_SUBSAMPLE_VALUES_1]
+    FIELD_SUBSAMPLE_VALUES = [0, 1] + FIELD_SUBSAMPLE_VALUES_1
+    FIELD_SUBSAMPLE_OPTIONS = ['Auto', 'Full resolution'] + FIELD_SUBSAMPLE_OPTIONS_1
+    FIELD_SUBSAMPLE_DEFAULT = FIELD_SUBSAMPLE_VALUES[0]
+
     PATH_SEPARATOR = ';'
 
     LOG_COLOR_ALERT = 'red'
@@ -51,8 +62,10 @@ class _Constants:
 
     DEFAULT_FILE_REVERSE_ORDER = False
     DEFAULT_MULTILAYER_FILE_REVERSE_ORDER = True
+    MULTILAYER_WARNING_MEM_GB = 1
 
     DEFAULT_NOISE_MAP_FILENAME = "noise-map/hot_pixels.png"
+    DEFAULT_NOISE_MAX_FRAMES = 10
     DEFAULT_MN_KERNEL_SIZE = 3
     INTERPOLATE_MEAN = 'MEAN'
     INTERPOLATE_MEDIAN = 'MEDIAN'
@@ -105,9 +118,11 @@ class _Constants:
     DEFAULT_REFINE_ITERS = 100
     DEFAULT_ALIGN_CONFIDENCE = 99.9
     DEFAULT_ALIGN_MAX_ITERS = 2000
+    DEFAULT_ALIGN_ABORT_ABNORMAL = False
     DEFAULT_BORDER_VALUE = [0] * 4
     DEFAULT_BORDER_BLUR = 50
-    DEFAULT_ALIGN_SUBSAMPLE = 2
+    DEFAULT_ALIGN_SUBSAMPLE = 0
+    DEFAULT_ALIGN_RES_TARGET_MPX = 2
     DEFAULT_ALIGN_FAST_SUBSAMPLING = False
     DEFAULT_ALIGN_MIN_GOOD_MATCHES = 50
 
@@ -120,9 +135,12 @@ class _Constants:
     BALANCE_RGB = "RGB"
     BALANCE_HSV = "HSV"
     BALANCE_HLS = "HLS"
-    VALID_BALANCE_CHANNELS = [BALANCE_LUMI, BALANCE_RGB, BALANCE_HSV, BALANCE_HLS]
+    BALANCE_LAB = "LAB"
+    VALID_BALANCE_CHANNELS = [BALANCE_LUMI, BALANCE_RGB, BALANCE_HSV, BALANCE_HLS,
+                              BALANCE_LAB]
 
-    DEFAULT_BALANCE_SUBSAMPLE = 8
+    DEFAULT_BALANCE_SUBSAMPLE = 0
+    DEFAULT_BALANCE_RES_TARGET_MPX = 2
     DEFAULT_BALANCE_FAST_SUBSAMPLING = False
     DEFAULT_CORR_MAP = BALANCE_LINEAR
     DEFAULT_CHANNEL = BALANCE_LUMI
@@ -131,7 +149,8 @@ class _Constants:
     DEFAULT_R_STEPS = 100
     DEFAULT_BLACK_THRESHOLD = 1.0
     DEFAULT_MAX_CORRECTION = 1
-    DEFAULT_VIGN_SUBSAMPLE = 8
+    DEFAULT_VIGN_SUBSAMPLE = 0
+    DEFAULT_VIGN_RES_TARGET_MPX = 2
     DEFAULT_VIGN_FAST_SUBSAMPLING = False
 
     FLOAT_32 = 'float-32'
@@ -163,6 +182,12 @@ class _Constants:
     DEFAULT_PY_KERNEL_SIZE = 5
     DEFAULT_PY_GEN_KERNEL = 0.4
     DEFAULT_PY_TILE_SIZE = 512
+    DEFAULT_PY_N_TILED_LAYERS = 2
+    DEFAULT_PY_MEMORY_LIMIT_GB = 8
+    DEFAULT_PY_MAX_THREADS = min(os.cpu_count() or 4, 8)
+    DEFAULT_PY_MODE = 'auto'
+    PY_VALID_MODES = ['auto', 'memory', 'tiled']
+    MIN_PY_TILE_SIZE = 256
 
     DEFAULT_PLOT_STACK_BUNCH = False
     DEFAULT_PLOT_STACK = True

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

@@ -10,19 +10,22 @@ from PySide6.QtWidgets import (QPushButton, QHBoxLayout, QFileDialog, QLabel, QC
 from .. config.constants import constants
 from .select_path_widget import (create_select_file_paths_widget, create_layout_widget_no_margins,
                                  create_layout_widget_and_connect)
-from .project_model import ActionConfig
 
 FIELD_TEXT = 'text'
 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):
@@ -30,23 +33,23 @@ class ActionConfigurator(ABC):
         self.current_wd = current_wd
 
     @abstractmethod
-    def create_form(self, layout, action: ActionConfig, tag="Action"):
+    def create_form(self, layout, action, tag="Action"):
         pass
 
     @abstractmethod
-    def update_params(self, params: Dict[str, Any]) -> bool:
+    def update_params(self, params):
         pass
 
 
 class FieldBuilder:
     def __init__(self, layout, action, current_wd):
-        self.layout = layout
+        self.main_layout = layout
         self.action = action
         self.current_wd = current_wd
         self.fields = {}
 
-    def add_field(self, tag: str, field_type: str, label: str,
-                  required: bool = False, add_to_layout=None, **kwargs):
+    def add_field(self, tag, field_type, label,
+                  required=False, add_to_layout=None, **kwargs):
         if field_type == FIELD_TEXT:
             widget = self.create_text_field(tag, **kwargs)
         elif field_type == FIELD_ABS_PATH:
@@ -57,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:
@@ -76,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:
@@ -93,7 +100,7 @@ class FieldBuilder:
             **kwargs
         }
         if add_to_layout is None:
-            add_to_layout = self.layout
+            add_to_layout = self.main_layout
         add_to_layout.addRow(f"{label}:", widget)
         return widget
 
@@ -113,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()
@@ -147,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'])]
@@ -328,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):