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

shinestacker/algorithms/utils.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0116, E1101
+# pylint: disable=C0114, C0116, E1101, R0914
 import os
 import logging
 import numpy as np
@@ -129,3 +129,177 @@ def img_subsample(img, subsample, fast=True):
                              fx=1 / subsample, fy=1 / subsample,
                              interpolation=cv2.INTER_AREA)
     return img_sub
+
+
+def bgr_to_hsv(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2HLS)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    v = np.max(bgr_normalized, axis=2)
+    m = np.min(bgr_normalized, axis=2)
+    delta = v - m
+    s = np.zeros_like(v)
+    nonzero_delta = delta != 0
+    s[nonzero_delta] = delta[nonzero_delta] / v[nonzero_delta]
+    h = np.zeros_like(v)
+    r_is_max = (v == r) & nonzero_delta
+    h[r_is_max] = (60 * (g[r_is_max] - b[r_is_max]) / delta[r_is_max]) % 360
+    g_is_max = (v == g) & nonzero_delta
+    h[g_is_max] = (60 * (b[g_is_max] - r[g_is_max]) / delta[g_is_max] + 120) % 360
+    b_is_max = (v == b) & nonzero_delta
+    h[b_is_max] = (60 * (r[b_is_max] - g[b_is_max]) / delta[b_is_max] + 240) % 360
+    h[h < 0] += 360
+    h_16bit = (h / 360 * 65535).astype(np.uint16)
+    s_16bit = (s * 65535).astype(np.uint16)
+    v_16bit = (v * 65535).astype(np.uint16)
+    return cv2.merge([h_16bit, s_16bit, v_16bit])
+
+
+def hsv_to_bgr(hsv_img):
+    if hsv_img.dtype == np.uint8:
+        return cv2.cvtColor(hsv_img, cv2.COLOR_HSV2BGR)
+    h, s, v = cv2.split(hsv_img)
+    h_normalized = h.astype(np.float32) / 65535.0 * 360
+    s_normalized = s.astype(np.float32) / 65535.0
+    v_normalized = v.astype(np.float32) / 65535.0
+    c = v_normalized * s_normalized
+    x = c * (1 - np.abs((h_normalized / 60) % 2 - 1))
+    m = v_normalized - c
+    r = np.zeros_like(h, dtype=np.float32)
+    g = np.zeros_like(h, dtype=np.float32)
+    b = np.zeros_like(h, dtype=np.float32)
+    mask = (h_normalized >= 0) & (h_normalized < 60)
+    r[mask], g[mask], b[mask] = c[mask], x[mask], 0
+    mask = (h_normalized >= 60) & (h_normalized < 120)
+    r[mask], g[mask], b[mask] = x[mask], c[mask], 0
+    mask = (h_normalized >= 120) & (h_normalized < 180)
+    r[mask], g[mask], b[mask] = 0, c[mask], x[mask]
+    mask = (h_normalized >= 180) & (h_normalized < 240)
+    r[mask], g[mask], b[mask] = 0, x[mask], c[mask]
+    mask = (h_normalized >= 240) & (h_normalized < 300)
+    r[mask], g[mask], b[mask] = x[mask], 0, c[mask]
+    mask = (h_normalized >= 300) & (h_normalized < 360)
+    r[mask], g[mask], b[mask] = c[mask], 0, x[mask]
+    r = np.clip((r + m) * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip((g + m) * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip((b + m) * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])
+
+
+def bgr_to_hls(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2HLS)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    max_val = np.max(bgr_normalized, axis=2)
+    min_val = np.min(bgr_normalized, axis=2)
+    delta = max_val - min_val
+    l = (max_val + min_val) / 2  # noqa
+    s = np.zeros_like(l)
+    mask = delta != 0
+    s[mask] = delta[mask] / (1 - np.abs(2 * l[mask] - 1))
+    h = np.zeros_like(l)
+    r_is_max = (max_val == r) & mask
+    h[r_is_max] = (60 * (g[r_is_max] - b[r_is_max]) / delta[r_is_max]) % 360
+    g_is_max = (max_val == g) & mask
+    h[g_is_max] = (60 * (b[g_is_max] - r[g_is_max]) / delta[g_is_max] + 120) % 360
+    b_is_max = (max_val == b) & mask
+    h[b_is_max] = (60 * (r[b_is_max] - g[b_is_max]) / delta[b_is_max] + 240) % 360
+    h[h < 0] += 360
+    h_16bit = (h / 360 * 65535).astype(np.uint16)
+    l_16bit = (l * 65535).astype(np.uint16)
+    s_16bit = (s * 65535).astype(np.uint16)
+    return cv2.merge([h_16bit, l_16bit, s_16bit])
+
+
+def hls_to_bgr(hls_img):
+    if hls_img.dtype == np.uint8:
+        return cv2.cvtColor(hls_img, cv2.COLOR_HLS2BGR)
+    h, l, s = cv2.split(hls_img)
+    h_normalized = h.astype(np.float32) / 65535.0 * 360
+    l_normalized = l.astype(np.float32) / 65535.0
+    s_normalized = s.astype(np.float32) / 65535.0
+    c = (1 - np.abs(2 * l_normalized - 1)) * s_normalized
+    x = c * (1 - np.abs((h_normalized / 60) % 2 - 1))
+    m = l_normalized - c / 2
+    r = np.zeros_like(h, dtype=np.float32)
+    g = np.zeros_like(h, dtype=np.float32)
+    b = np.zeros_like(h, dtype=np.float32)
+    mask = (h_normalized >= 0) & (h_normalized < 60)
+    r[mask], g[mask], b[mask] = c[mask], x[mask], 0
+    mask = (h_normalized >= 60) & (h_normalized < 120)
+    r[mask], g[mask], b[mask] = x[mask], c[mask], 0
+    mask = (h_normalized >= 120) & (h_normalized < 180)
+    r[mask], g[mask], b[mask] = 0, c[mask], x[mask]
+    mask = (h_normalized >= 180) & (h_normalized < 240)
+    r[mask], g[mask], b[mask] = 0, x[mask], c[mask]
+    mask = (h_normalized >= 240) & (h_normalized < 300)
+    r[mask], g[mask], b[mask] = x[mask], 0, c[mask]
+    mask = (h_normalized >= 300) & (h_normalized < 360)
+    r[mask], g[mask], b[mask] = c[mask], 0, x[mask]
+    r = np.clip((r + m) * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip((g + m) * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip((b + m) * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])
+
+
+def bgr_to_lab(bgr_img):
+    if bgr_img.dtype == np.uint8:
+        return cv2.cvtColor(bgr_img, cv2.COLOR_BGR2LAB)
+    if len(bgr_img.shape) == 2:
+        bgr_img = cv2.merge([bgr_img, bgr_img, bgr_img])
+    bgr_normalized = bgr_img.astype(np.float32) / 65535.0
+    b, g, r = cv2.split(bgr_normalized)
+    r_linear = np.where(r > 0.04045, ((r + 0.055) / 1.055) ** 2.4, r / 12.92)
+    g_linear = np.where(g > 0.04045, ((g + 0.055) / 1.055) ** 2.4, g / 12.92)
+    b_linear = np.where(b > 0.04045, ((b + 0.055) / 1.055) ** 2.4, b / 12.92)
+    x = r_linear * 0.4124564 + g_linear * 0.3575761 + b_linear * 0.1804375
+    y = r_linear * 0.2126729 + g_linear * 0.7151522 + b_linear * 0.0721750
+    z = r_linear * 0.0193339 + g_linear * 0.1191920 + b_linear * 0.9503041
+    x /= 0.950456
+    z /= 1.088754
+    x = np.where(x > 0.008856, x ** (1 / 3), (7.787 * x) + (16 / 116))
+    y = np.where(y > 0.008856, y ** (1 / 3), (7.787 * y) + (16 / 116))
+    z = np.where(z > 0.008856, z ** (1 / 3), (7.787 * z) + (16 / 116))
+    l = (116 * y) - 16  # noqa
+    a = 500 * (x - y)
+    b_val = 200 * (y - z)
+    l_16bit = np.clip(l * 65535 / 100, 0, 65535).astype(np.uint16)
+    a_16bit = np.clip((a + 128) * 65535 / 255, 0, 65535).astype(np.uint16)
+    b_16bit = np.clip((b_val + 128) * 65535 / 255, 0, 65535).astype(np.uint16)
+    return cv2.merge([l_16bit, a_16bit, b_16bit])
+
+
+def lab_to_bgr(lab_img):
+    if lab_img.dtype == np.uint8:
+        return cv2.cvtColor(lab_img, cv2.COLOR_LAB2BGR)
+    l, a, b = cv2.split(lab_img)
+    l_normalized = l.astype(np.float32) * 100 / 65535.0
+    a_normalized = a.astype(np.float32) * 255 / 65535.0 - 128
+    b_normalized = b.astype(np.float32) * 255 / 65535.0 - 128
+    y = (l_normalized + 16) / 116
+    x = a_normalized / 500 + y
+    z = y - b_normalized / 200
+    x = np.where(x > 0.206893, x ** 3, (x - 16 / 116) / 7.787)
+    y = np.where(y > 0.206893, y ** 3, (y - 16 / 116) / 7.787)
+    z = np.where(z > 0.206893, z ** 3, (z - 16 / 116) / 7.787)
+    x *= 0.950456
+    z *= 1.088754
+    r_linear = x * 3.2404542 + y * -1.5371385 + z * -0.4985314
+    g_linear = x * -0.9692660 + y * 1.8760108 + z * 0.0415560
+    b_linear = x * 0.0556434 + y * -0.2040259 + z * 1.0572252
+    r_linear = np.clip(r_linear, 0, 1)
+    g_linear = np.clip(g_linear, 0, 1)
+    b_linear = np.clip(b_linear, 0, 1)
+    r = np.where(r_linear > 0.0031308, 1.055 * (r_linear ** (1 / 2.4)) - 0.055, 12.92 * r_linear)
+    g = np.where(g_linear > 0.0031308, 1.055 * (g_linear ** (1 / 2.4)) - 0.055, 12.92 * g_linear)
+    b = np.where(b_linear > 0.0031308, 1.055 * (b_linear ** (1 / 2.4)) - 0.055, 12.92 * b_linear)
+    r = np.clip(r * 65535, 0, 65535).astype(np.uint16)
+    g = np.clip(g * 65535, 0, 65535).astype(np.uint16)
+    b = np.clip(b * 65535, 0, 65535).astype(np.uint16)
+    return cv2.merge([b, g, r])

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(
@@ -144,7 +162,7 @@ class Vignetting(SubAction):
         if self.plot_correction:
             plt.figure(figsize=(10, 5))
             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,7 +183,7 @@ 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

shinestacker/config/constants.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, C0103, R0903
 import sys
 import re
+import os
 
 
 class _Constants:
@@ -12,6 +13,9 @@ 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)
@@ -34,12 +38,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 +60,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 +116,11 @@ class _Constants:
     DEFAULT_REFINE_ITERS = 100
     DEFAULT_ALIGN_CONFIDENCE = 99.9
     DEFAULT_ALIGN_MAX_ITERS = 2000
+    DEFAULT_ALIGN_ABORT_ABNORMAL = True
     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 +133,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 +147,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 +180,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/gui/action_config.py

@@ -10,7 +10,6 @@ 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'
@@ -30,23 +29,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:
@@ -93,7 +92,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