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

shinestacker/_version.py

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

shinestacker/algorithms/align.py

@@ -6,8 +6,7 @@ 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 .utils import img_8bit, img_bw_8bit, save_plot, get_img_metadata, validate_image, img_subsample
 from .stack_framework import SubAction
 
 _DEFAULT_FEATURE_CONFIG = {
@@ -166,19 +165,12 @@ 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']
+    fast_subsampling = alignment_config['fast_subsampling']
     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)
+            img_0_sub = img_subsample(img_0, subsample, fast_subsampling)
+            img_1_sub = img_subsample(img_1, subsample, fast_subsampling)
         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,

shinestacker/algorithms/balance.py

@@ -7,7 +7,7 @@ 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 .utils import read_img, save_plot, img_subsample
 from .stack_framework import SubAction
 
 
@@ -122,13 +122,15 @@ class LinearMap(CorrectionMap):
 
 class Correction:
     def __init__(self, channels, mask_size=0, intensity_interval=None,
-                 subsample=-1, corr_map=constants.DEFAULT_CORR_MAP,
+                 subsample=-1, fast_subsampling=constants.DEFAULT_BALANCE_FAST_SUBSAMPLING,
+                 corr_map=constants.DEFAULT_CORR_MAP,
                  plot_histograms=False, plot_summary=False):
         self.mask_size = mask_size
         self.intensity_interval = intensity_interval
         self.plot_histograms = plot_histograms
         self.plot_summary = plot_summary
         self.subsample = constants.DEFAULT_BALANCE_SUBSAMPLE if subsample == -1 else subsample
+        self.fast_subsampling = fast_subsampling
         self.corr_map = corr_map
         self.channels = channels
         self.dtype = None
@@ -154,17 +156,18 @@ class Correction:
         self.corrections = np.ones((size, self.channels))
 
     def calc_hist_1ch(self, image):
-        img_subsample = image if self.subsample == 1 else image[::self.subsample, ::self.subsample]
+        img_sub = image if self.subsample == 1 \
+            else img_subsample(image, self.subsample, self.fast_subsampling)
         if self.mask_size == 0:
-            image_sel = img_subsample
+            image_sel = img_sub
         else:
-            height, width = img_subsample.shape[:2]
+            height, width = img_sub.shape[:2]
             xv, yv = np.meshgrid(
                 np.linspace(0, width - 1, width),
                 np.linspace(0, height - 1, height)
             )
             mask_radius = min(width, height) * self.mask_size / 2
-            image_sel = img_subsample[
+            image_sel = img_sub[
                 (xv - width / 2) ** 2 + (yv - height / 2) ** 2 <= mask_radius ** 2
             ]
         hist, _bins = np.histogram(
@@ -305,9 +308,6 @@ class Ch2Correction(Correction):
     def preprocess(self, image):
         assert False, 'abstract method'
 
-    def get_labels(self):
-        assert False, 'abstract method'
-
     def get_hist(self, image, idx):
         hist = [self.calc_hist_1ch(chan) for chan in cv2.split(image)]
         if self.plot_histograms:
@@ -370,6 +370,8 @@ class BalanceFrames(SubAction):
         self.shape = None
         corr_map = kwargs.get('corr_map', constants.DEFAULT_CORR_MAP)
         subsample = kwargs.get('subsample', constants.DEFAULT_BALANCE_SUBSAMPLE)
+        self.fast_subsampling = kwargs.get(
+            'fast_subsampling', constants.DEFAULT_BALANCE_FAST_SUBSAMPLING)
         channel = kwargs.pop('channel', constants.DEFAULT_CHANNEL)
         kwargs['subsample'] = (
             1 if corr_map == constants.BALANCE_MATCH_HIST

shinestacker/algorithms/depth_map.py

@@ -61,36 +61,6 @@ class DepthMapStack(BaseStackAlgo):
         raise InvalidOptionError("map_type", self.map_type, details=f" valid values are "
                                  f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
 
-    def pyramid_blend(self, images, weights):
-        blended = None
-        for i in range(images.shape[0]):
-            img = images[i].astype(self.float_type)
-            weight = weights[i]
-            gp_img = [img]
-            gp_weight = [weight]
-            for _ in range(self.levels - 1):
-                gp_img.append(cv2.pyrDown(gp_img[-1]))
-                gp_weight.append(cv2.pyrDown(gp_weight[-1]))
-            lp_img = [gp_img[-1]]
-            for j in range(self.levels - 1, 0, -1):
-                size = (gp_img[j - 1].shape[1], gp_img[j - 1].shape[0])
-                expanded = cv2.pyrUp(gp_img[j], dstsize=size)
-                lp_img.append(gp_img[j - 1] - expanded)
-            current_blend = []
-            for j in range(self.levels):
-                w = gp_weight[self.levels - 1 - j][..., np.newaxis]
-                current_blend.append(lp_img[j] * w)
-            if blended is None:
-                blended = current_blend
-            else:
-                for j in range(self.levels):
-                    blended[j] += current_blend[j]
-        result = blended[0]
-        for j in range(1, self.levels):
-            size = (blended[j].shape[1], blended[j].shape[0])
-            result = cv2.pyrUp(result, dstsize=size) + blended[j]
-        return result
-
     def focus_stack(self, filenames):
         gray_images = []
         metadata = None

shinestacker/algorithms/utils.py

@@ -74,3 +74,13 @@ def save_plot(filename):
     if config.JUPYTER_NOTEBOOK:
         plt.show()
     plt.close('all')
+
+
+def img_subsample(img, subsample, fast=True):
+    if fast:
+        img_sub = img[::subsample, ::subsample]
+    else:
+        img_sub = cv2.resize(img, (0, 0),
+                             fx=1 / subsample, fy=1 / subsample,
+                             interpolation=cv2.INTER_AREA)
+    return img_sub

shinestacker/algorithms/vignetting.py

@@ -1,4 +1,5 @@
-# pylint: disable=C0114, C0115, C0116, R0902, E1101, W0718, W0640
+# pylint: disable=C0114, C0115, C0116, R0902, E1101, W0718, W0640, R0913, R0917, R0914
+import traceback
 import logging
 import numpy as np
 import matplotlib.pyplot as plt
@@ -6,22 +7,108 @@ from scipy.optimize import curve_fit, fsolve
 import cv2
 from .. core.colors import color_str
 from .. config.constants import constants
-from .utils import img_8bit, save_plot
+from .utils import img_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
 
 CLIP_EXP = 10
 
 
+def sigmoid_model(r, i0, k, r0):
+    return i0 / (1.0 +
+                 np.exp(np.minimum(CLIP_EXP,
+                                   np.exp(np.clip(k * (r - r0),
+                                          -CLIP_EXP, CLIP_EXP)))))
+
+
+def radial_mean_intensity(image, r_steps):
+    if len(image.shape) > 2:
+        raise ValueError("The image must be grayscale")
+    h, w = image.shape
+    w_2, h_2 = w / 2, h / 2
+    r_max = np.sqrt((w / 2)**2 + (h / 2)**2)
+    radii = np.linspace(0, r_max, r_steps + 1)
+    mean_intensities = np.zeros(r_steps)
+    y, x = np.ogrid[:h, :w]
+    dist_from_center = np.sqrt((x - w_2)**2 + (y - h_2)**2)
+    for i in range(r_steps):
+        mask = (dist_from_center >= radii[i]) & (dist_from_center < radii[i + 1])
+        if np.any(mask):
+            mean_intensities[i] = np.mean(image[mask])
+        else:
+            mean_intensities[i] = np.nan
+    return (radii[1:] + radii[:-1]) / 2, mean_intensities
+
+
+def fit_sigmoid(radii, intensities):
+    valid_mask = ~np.isnan(intensities)
+    i_valid, r_valid = intensities[valid_mask], radii[valid_mask]
+    r_max = radii.max()
+    res = curve_fit(sigmoid_model, r_valid, i_valid,
+                    p0=[2 * np.max(i_valid), 10 / r_max, 0.8 * r_max],
+                    bounds=([0, 0, 0], ['inf', 'inf', 'inf']))[0]
+    return res
+
+
+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)
+
+
+def compute_fit_parameters(
+        image, r_steps, radii=None, intensities=None,
+        subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
+        fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    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)
+    params = fit_sigmoid(radii, intensities)
+    params[1] /= subsample  # k
+    params[2] *= subsample  # r0
+    return params
+
+
+def correct_vignetting(
+        image, max_correction=constants.DEFAULT_MAX_CORRECTION,
+        black_threshold=constants.DEFAULT_BLACK_THRESHOLD,
+        r_steps=constants.DEFAULT_R_STEPS, params=None, v0=None,
+        subsample=constants.DEFAULT_VIGN_SUBSAMPLE,
+        fast_subsampling=constants.DEFAULT_VIGN_FAST_SUBSAMPLING):
+    if params is None:
+        if r_steps is None:
+            raise RuntimeError("Either r_steps or pars must not be None")
+        params = compute_fit_parameters(
+            image, r_steps, subsample=subsample, fast_subsampling=fast_subsampling)
+    if v0 is None:
+        v0 = sigmoid_model(0, *params)
+    h, w = image.shape[:2]
+    y, x = np.ogrid[:h, :w]
+    r = np.sqrt((x - w / 2)**2 + (y - h / 2)**2)
+    vignette = np.clip(sigmoid_model(r, *params) / v0, 1e-6, 1)
+    if max_correction < 1:
+        vignette = (1.0 - max_correction) + vignette * max_correction
+    threshold = black_threshold if image.dtype == np.uint8 else black_threshold * 256
+    if len(image.shape) == 3:
+        vignette = vignette[:, :, np.newaxis]
+        vignette[np.min(image, axis=2) < threshold, :] = 1
+    else:
+        vignette[image < black_threshold] = 1
+    return np.clip(image / vignette, 0, 255
+                   if image.dtype == np.uint8 else 65535).astype(image.dtype)
+
+
 class Vignetting(SubAction):
     def __init__(self, enabled=True, percentiles=(0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95), **kwargs):
         super().__init__(enabled)
         self.r_steps = kwargs.get('r_steps', constants.DEFAULT_R_STEPS)
         self.black_threshold = kwargs.get('black_threshold', constants.DEFAULT_BLACK_THRESHOLD)
-        self.apply_correction = kwargs.get('apply_correction', True)
         self.plot_correction = kwargs.get('plot_correction', False)
         self.plot_summary = kwargs.get('plot_summary', False)
         self.max_correction = kwargs.get('max_correction', constants.DEFAULT_MAX_CORRECTION)
         self.percentiles = np.sort(percentiles)
+        self.subsample = kwargs.get('subsample', constants.DEFAULT_VIGN_SUBSAMPLE)
+        self.fast_subsampling = kwargs.get(
+            'fast_subsampling', constants.DEFAULT_VIGN_FAST_SUBSAMPLING)
         self.w_2 = None
         self.h_2 = None
         self.v0 = None
@@ -29,76 +116,35 @@ class Vignetting(SubAction):
         self.process = None
         self.corrections = None
 
-    def radial_mean_intensity(self, image):
-        if len(image.shape) > 2:
-            raise ValueError("The image must be grayscale")
-        h, w = image.shape
+    def run_frame(self, idx, _ref_idx, img_0):
+        self.process.sub_message_r(color_str(": compute vignetting", "cyan"))
+        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)
-        radii = np.linspace(0, self.r_max, self.r_steps + 1)
-        mean_intensities = np.zeros(self.r_steps)
-        y, x = np.ogrid[:h, :w]
-        dist_from_center = np.sqrt((x - self.w_2)**2 + (y - self.h_2)**2)
-        for i in range(self.r_steps):
-            mask = (dist_from_center >= radii[i]) & (dist_from_center < radii[i + 1])
-            if np.any(mask):
-                mean_intensities[i] = np.mean(image[mask])
-            else:
-                mean_intensities[i] = np.nan
-        return (radii[1:] + radii[:-1]) / 2, mean_intensities
-
-    @staticmethod
-    def sigmoid(r, i0, k, r0):
-        return i0 / (1.0 +
-                     np.exp(np.minimum(CLIP_EXP,
-                                       np.exp(np.clip(k * (r - r0),
-                                              -CLIP_EXP, CLIP_EXP)))))
-
-    def fit_sigmoid(self, radii, intensities):
-        valid_mask = ~np.isnan(intensities)
-        i_valid, r_valid = intensities[valid_mask], radii[valid_mask]
+        image_sub = img_subsampled(img_0, self.subsample, self.fast_subsampling)
+        radii, intensities = radial_mean_intensity(image_sub, self.r_steps)
         try:
-            res = curve_fit(Vignetting.sigmoid, r_valid, i_valid,
-                            p0=[np.max(i_valid), 0.01, np.median(r_valid)],
-                            bounds=([0, 0, 0], ['inf', 'inf', 'inf']))[0]
-        except Exception:
+            params = compute_fit_parameters(
+                img_0, self.r_steps, radii, intensities, self.subsample, self.fast_subsampling)
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
             self.process.sub_message(
-                color_str(": could not find vignetting model", "red"),
-                level=logging.WARNING)
-            res = None
-        return res
-
-    def correct_vignetting(self, image, params):
-        h, w = image.shape[:2]
-        y, x = np.ogrid[:h, :w]
-        r = np.sqrt((x - w / 2)**2 + (y - h / 2)**2)
-        vignette = np.clip(Vignetting.sigmoid(r, *params) / self.v0, 1e-6, 1)
-        if self.max_correction < 1:
-            vignette = (1.0 - self.max_correction) + vignette * self.max_correction
-        if len(image.shape) == 3:
-            vignette = vignette[:, :, np.newaxis]
-            vignette[np.min(image, axis=2) < self.black_threshold, :] = 1
-        else:
-            vignette[image < self.black_threshold] = 1
-        return np.clip(image / vignette, 0, 255
-                       if image.dtype == np.uint8 else 65535).astype(image.dtype)
-
-    def run_frame(self, idx, _ref_idx, img_0):
-        self.process.sub_message_r(": compute vignetting")
-        img = cv2.cvtColor(img_8bit(img_0), cv2.COLOR_BGR2GRAY)
-        radii, intensities = self.radial_mean_intensity(img)
-        pars = self.fit_sigmoid(radii, intensities)
-        if pars is None:
+                color_str(": could not find vignetting model", "red"), level=logging.WARNING)
+            params = None
+        if params is None:
             return img_0
-        self.v0 = Vignetting.sigmoid(0, *pars)
-        i0_fit, k_fit, r0_fit = pars
-        self.process.sub_message(
-            f": vignetting model parameters: i0={i0_fit:.4f}, k={k_fit:.4f}, r0={r0_fit:.4f}",
-            level=logging.DEBUG)
+        self.v0 = sigmoid_model(0, *params)
+        i0_fit, k_fit, r0_fit = params
+        self.process.sub_message(color_str(": vignetting model parameters: ", "cyan") +
+                                 color_str(f"i0={i0_fit / 2:.4f}, "
+                                           f"k={k_fit * self.r_max:.4f}, "
+                                           f"r0={r0_fit / self.r_max:.4f}",
+                                           "light_blue"),
+                                 level=logging.DEBUG)
         if self.plot_correction:
             plt.figure(figsize=(10, 5))
             plt.plot(radii, intensities, label="image mean intensity")
-            plt.plot(radii, Vignetting.sigmoid(radii, *pars), label="sigmoid fit")
+            plt.plot(radii, sigmoid_model(radii * self.subsample, *params), label="sigmoid fit")
             plt.xlabel('radius (pixels)')
             plt.ylabel('mean intensity')
             plt.legend()
@@ -114,12 +160,12 @@ class Vignetting(SubAction):
                 'save_plot', self.process.id,
                 f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
         for i, p in enumerate(self.percentiles):
-            self.corrections[i][idx] = fsolve(lambda x: Vignetting.sigmoid(x, *pars) /
+            self.corrections[i][idx] = fsolve(lambda x: sigmoid_model(x, *params) /
                                               self.v0 - p, r0_fit)[0]
-        if self.apply_correction:
-            self.process.sub_message_r(": correct vignetting")
-            return self.correct_vignetting(img_0, pars)
-        return img_0
+        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)
 
     def begin(self, process):
         self.process = process

shinestacker/app/about_dialog.py

@@ -1,17 +1,111 @@
-# pylint: disable=C0114, C0116, E0611
-from PySide6.QtWidgets import QMessageBox
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0903
+import json
+from urllib.request import urlopen, Request
+from urllib.error import URLError
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QLabel
 from PySide6.QtCore import Qt
 from .. import __version__
+from .. retouch.icon_container import icon_container
 from .. config.constants import constants
 
 
-def show_about_dialog():
+class AboutDialog(QDialog):
+    def __init__(self, parent=None, about_text=""):
+        super().__init__(parent)
+        self.setWindowTitle("About")
+        self.resize(400, 300)
+        layout = QVBoxLayout(self)
+        layout.setAlignment(Qt.AlignTop)
+        icon_widget = icon_container()
+        icon_layout = QHBoxLayout()
+        icon_layout.addStretch()
+        icon_layout.addWidget(icon_widget)
+        icon_layout.addStretch()
+        layout.addLayout(icon_layout)
+        about_label = QLabel(about_text)
+        about_label.setWordWrap(True)
+        about_label.setAlignment(Qt.AlignLeft)
+        layout.addWidget(about_label)
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        button = QPushButton("OK")
+        button.setFixedWidth(100)
+        button.clicked.connect(self.accept)
+        button_layout.addWidget(button)
+        button_layout.addStretch()
+        layout.addLayout(button_layout)
+
+
+def compare_versions(current, latest):
+    def parse_version(v):
+        v = v.lstrip('v')
+        parts = v.split('.')
+        result = []
+        for part in parts:
+            try:
+                result.append(int(part))
+            except ValueError:
+                result.append(part)
+        return result
+    current_parts = parse_version(current)
+    latest_parts = parse_version(latest)
+    for i in range(max(len(current_parts), len(latest_parts))):
+        c = current_parts[i] if i < len(current_parts) else 0
+        l = latest_parts[i] if i < len(latest_parts) else 0  # noqa: E741
+        if isinstance(c, int) and isinstance(l, int):
+            if c < l:
+                return -1
+            if c > l:
+                return 1
+        else:
+            if str(c) < str(l):
+                return -1
+            if str(c) > str(l):
+                return 1
+    return 0
+
+
+def get_latest_version():
+    try:
+        url = "https://api.github.com/repos/lucalista/shinestacker/releases/latest"
+        headers = {'User-Agent': 'ShineStacker'}
+        req = Request(url, headers=headers)
+        with urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data['tag_name']
+    except (URLError, ValueError, KeyError, TimeoutError):
+        return None
+
+
+def show_about_dialog(parent):
     version_clean = __version__.split("+", maxsplit=1)[0]
+    latest_version = None
+    try:
+        latest_version = get_latest_version()
+    except Exception:
+        pass
+    update_text = ""
+    if latest_version:
+        latest_clean = latest_version.lstrip('v')
+        if compare_versions(version_clean, latest_clean) < 0:
+            update_text = f"""
+            <p style="color: red; font-weight: bold;">
+                Update available! Latest version: {latest_version}
+                <br><a href="https://github.com/lucalista/shinestacker/releases/latest">Download here</a>
+            </p>
+            """ # noqa E501
+        else:
+            update_text = """
+            <p style="color: green; font-weight: bold;">
+                You are using the lastet version.
+            </p>
+            """
     about_text = f"""
     <h3>{constants.APP_TITLE}</h3>
     <h4>version: v{version_clean}</h4>
-    <p style='font-weight: normal;'>App and framework to combine multiple images
-    into a single focused image.</p>
+    {update_text}
+    <p style='font-weight: normal;'>Focus stackign applications and framework.<br>
+    Combine multiple frames into a single focused image.</p>
     <p>Author: Luca Lista<br/>
     Email: <a href="mailto:luka.lista@gmail.com">luka.lista@gmail.com</a></p>
     <ul>
@@ -19,10 +113,5 @@ def show_about_dialog():
     <li><a href="https://github.com/lucalista/shinestacker">GitHub project repository</a></li>
     </ul>
     """
-    msg = QMessageBox()
-    msg.setWindowTitle(f"About {constants.APP_STRING}")
-    msg.setIcon(QMessageBox.Icon.Information)
-    msg.setTextFormat(Qt.TextFormat.RichText)
-    msg.setText(about_text)
-    msg.setIcon(QMessageBox.Icon.NoIcon)
-    msg.exec_()
+    dialog = AboutDialog(parent, about_text)
+    dialog.exec()

shinestacker/app/gui_utils.py

@@ -42,7 +42,7 @@ def disable_macos_special_menu_items():
 
 def fill_app_menu(app, app_menu):
     about_action = QAction(f"About {constants.APP_STRING}", app)
-    about_action.triggered.connect(show_about_dialog)
+    about_action.triggered.connect(lambda: show_about_dialog(app))
     app_menu.addAction(about_action)
     app_menu.addSeparator()
     if config.DONT_USE_NATIVE_MENU:

shinestacker/app/help_menu.py

@@ -14,4 +14,4 @@ def add_help_action(app):
 
 
 def browse_website():
-    webbrowser.open("https://github.com/lucalista/shinestacker/blob/main/docs/gui.md")
+    webbrowser.open("https://shinestacker.readthedocs.io/en/latest/")

shinestacker/app/main.py

@@ -141,7 +141,7 @@ expert options are visible by default.
         filename = filenames[0]
         extension = filename.split('.')[-1]
         if len(filenames) == 1 and extension == 'fsp':
-            main_app.project_window.open_project(filename)
+            main_app.project_window.project_controller.open_project(filename)
             main_app.project_window.setFocus()
         else:
             main_app.switch_to_retouch()
@@ -152,7 +152,7 @@ expert options are visible by default.
             main_app.switch_to_retouch()
         else:
             main_app.switch_to_project()
-            QTimer.singleShot(100, main_app.project_window.new_project)
+            QTimer.singleShot(100, main_app.project_window.project_controller.new_project)
     QTimer.singleShot(100, main_app.setFocus)
     sys.exit(app.exec())
 

shinestacker/app/project.py

@@ -70,9 +70,9 @@ expert options are visible by default.
     window.show()
     filename = args['filename']
     if filename:
-        QTimer.singleShot(100, lambda: window.open_project(filename))
+        QTimer.singleShot(100, lambda: window.project_controller.open_project(filename))
     else:
-        QTimer.singleShot(100, window.new_project)
+        QTimer.singleShot(100, window.project_controller.new_project)
     sys.exit(app.exec())
 
 

shinestacker/config/constants.py

@@ -121,13 +121,16 @@ class _Constants:
     VALID_BALANCE_CHANNELS = [BALANCE_LUMI, BALANCE_RGB, BALANCE_HSV, BALANCE_HLS]
 
     DEFAULT_BALANCE_SUBSAMPLE = 8
+    DEFAULT_BALANCE_FAST_SUBSAMPLING = False
     DEFAULT_CORR_MAP = BALANCE_LINEAR
     DEFAULT_CHANNEL = BALANCE_LUMI
     DEFAULT_INTENSITY_INTERVAL = {'min': 0, 'max': -1}
 
     DEFAULT_R_STEPS = 100
-    DEFAULT_BLACK_THRESHOLD = 1
+    DEFAULT_BLACK_THRESHOLD = 1.0
     DEFAULT_MAX_CORRECTION = 1
+    DEFAULT_VIGN_SUBSAMPLE = 8
+    DEFAULT_VIGN_FAST_SUBSAMPLING = False
 
     FLOAT_32 = 'float-32'
     FLOAT_64 = 'float-64'

shinestacker/config/gui_constants.py

@@ -6,8 +6,9 @@ class _GuiConstants:
     GUI_IMG_WIDTH = 250  # px
     DISABLED_TAG = ""  # " <disabled>"
 
-    MIN_ZOOMED_IMG_WIDTH = 400
-    MAX_ZOOMED_IMG_PX_SIZE = 50
+    MIN_ZOOMED_IMG_WIDTH = 600
+    MIN_ZOOMED_IMG_HEIGHT = 600
+    MAX_ZOOMED_IMG_PX_SIZE = 40
     MAX_UNDO_SIZE = 65535
 
     NEW_PROJECT_NOISE_DETECTION = False
@@ -36,18 +37,18 @@ class _GuiConstants:
 
     THUMB_WIDTH = 120  # px
     THUMB_HEIGHT = 80  # px
-    IMG_WIDTH = 100  # px
-    IMG_HEIGHT = 80  # px
-    LABEL_HEIGHT = 20  # px
-
-    MAX_UNDO_STEPS = 50
+    THUMB_HI_COLOR = '#0000FF'
+    THUMB_LO_COLOR = '#0000FF'
+    THUMB_MASTER_HI_COLOR = '#0000FF'
+    THUMB_MASTER_LO_COLOR = 'transparent'
 
     BRUSH_SIZE_SLIDER_MAX = 1000
 
     UI_SIZES = {
         'brush_preview': (100, 80),
-        'thumbnail': (IMG_WIDTH, IMG_HEIGHT),
-        'master_thumb': (THUMB_WIDTH, THUMB_HEIGHT)
+        'thumbnail_width': 100,
+        'master_thumb': (THUMB_WIDTH, THUMB_HEIGHT),
+        'label_height': 20
     }
 
     DEFAULT_BRUSH_HARDNESS = 50