shinestacker 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

shinestacker/algorithms/pyramid_tiles.py

@@ -10,7 +10,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import numpy as np
 from .. config.constants import constants
 from .. core.exceptions import RunStopException
-from .utils import read_img
+from .utils import read_img, read_and_validate_img
 from .pyramid import PyramidBase
 
 
@@ -47,11 +47,11 @@ class PyramidTilesStack(PyramidBase):
         return n_steps + self.n_tiles
 
     def _process_single_image_wrapper(self, args):
-        img_path, img_index, _n = args
-        # self.print_message(f": processing file {img_path.split('/')[-1]}, {img_index + 1}/{n}")
-        img = read_img(img_path)
-        level_count = self.process_single_image(img, self.n_levels, img_index)
-        return img_index, level_count
+        img_path, idx, _n = args
+        img = read_and_validate_img(img_path, self.shape, self.dtype)
+        self.check_running(self.cleanup_temp_files)
+        level_count = self.process_single_image(img, self.n_levels, idx)
+        return idx, level_count
 
     def process_single_image(self, img, levels, img_index):
         laplacian = self.single_image_laplacian(img, levels)
@@ -160,10 +160,11 @@ class PyramidTilesStack(PyramidBase):
         gc.collect()
         return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
 
-    def fuse_pyramids(self, all_level_counts, num_images):
+    def fuse_pyramids(self, all_level_counts):
+        num_images = self.num_images()
         max_levels = max(all_level_counts)
         fused = []
-        count = self._steps_per_frame * self.n_frames
+        count = super().total_steps(num_images)
         for level in range(max_levels - 1, -1, -1):
             self.print_message(f': fusing pyramids, layer: {level + 1}')
             if level < self.n_tiled_layers:
@@ -201,12 +202,11 @@ class PyramidTilesStack(PyramidBase):
         return fused[::-1]
 
     def focus_stack(self):
-        n = len(self.filenames)
-        self.focus_stack_validate(self.cleanup_temp_files)
-        all_level_counts = [0] * n
+        all_level_counts = [0] * self.num_images()
         if self.num_threads > 1:
             self.print_message(f': starting parallel processing on {self.num_threads} cores')
-            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            args_list = [(file_path, i, self.num_images())
+                         for i, file_path in enumerate(self.filenames)]
             executor = None
             try:
                 executor = ThreadPoolExecutor(max_workers=self.num_threads)
@@ -222,12 +222,11 @@ class PyramidTilesStack(PyramidBase):
                         all_level_counts[img_index] = level_count
                         completed_count += 1
                         self.print_message(
-                            ": processing completed, image  "
-                            f"{self.idx_tot_str(completed_count - 1)}")
+                            f": processing completed, {self.image_str(completed_count - 1)}")
                     except Exception as e:
                         self.print_message(
-                            f"Error processing image  {self.idx_tot_str(i)}: {str(e)}")
-                    self.after_step(completed_count + n + 1)
+                            f"Error processing {self.image_str(i)}: {str(e)}")
+                    self.after_step(completed_count)
                     self.check_running(lambda: None)
             except RunStopException:
                 self.print_message(": stopping image processing...")
@@ -242,16 +241,15 @@ class PyramidTilesStack(PyramidBase):
         else:
             for i, file_path in enumerate(self.filenames):
                 self.print_message(
-                    f": processing file {os.path.basename(file_path)}, "
-                    f"{self.idx_tot_str(i)}")
+                    f": processing {self.image_str(i)}")
                 img = read_img(file_path)
                 level_count = self.process_single_image(img, self.n_levels, i)
                 all_level_counts[i] = level_count
-                self.after_step(i + n + 1)
+                self.after_step(i + 1)
                 self.check_running(lambda: None)
         try:
             self.check_running(lambda: None)
-            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            fused_pyramid = self.fuse_pyramids(all_level_counts)
             stacked_image = self.collapse(fused_pyramid)
             return stacked_image.astype(self.dtype)
         except RunStopException:

shinestacker/algorithms/stack_framework.py

@@ -117,7 +117,7 @@ class ImageSequenceManager:
         assert False, "this method should be overwritten"
 
     def set_filelist(self):
-        file_folder = self.input_full_path().replace(self.working_path, '').lstrip('/')
+        file_folder = os.path.relpath(self.input_full_path(), self.working_path)
         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")

shinestacker/algorithms/utils.py

@@ -87,6 +87,17 @@ def img_bw(img):
     return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
 
+def get_first_image_file(filenames):
+    first_img_file = None
+    for filename in filenames:
+        if os.path.isfile(filename) and extension_tif_jpg(filename):
+            first_img_file = filename
+            break
+    if first_img_file is None:
+        raise ValueError("No valid image files found")
+    return first_img_file
+
+
 def get_img_file_shape(file_path):
     img = read_img(file_path)
     return img.shape[:2]
@@ -106,6 +117,11 @@ def validate_image(img, expected_shape=None, expected_dtype=None):
         raise ShapeError(expected_shape, shape)
     if expected_dtype and dtype != expected_dtype:
         raise BitDepthError(expected_dtype, dtype)
+    return img
+
+
+def read_and_validate_img(filename, expected_shape=None, expected_dtype=None):
+    return validate_image(read_img(filename), expected_shape, expected_dtype)
 
 
 def save_plot(filename):

shinestacker/app/gui_utils.py

@@ -53,3 +53,13 @@ def fill_app_menu(app, app_menu):
     exit_action.setShortcut(quit_short)
     exit_action.triggered.connect(app.quit)
     app_menu.addAction(exit_action)
+
+
+def set_css_style(app):
+    css_style = """
+        QToolTip {
+            color: black;
+            border: 1px solid black;
+        }
+"""
+    app.setStyleSheet(css_style)

shinestacker/app/main.py

@@ -16,7 +16,8 @@ from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
 
@@ -233,6 +234,7 @@ expert options are visible by default.
     app.setWindowIcon(QIcon(icon_path))
     main_app = MainApp()
     app.main_app = main_app
+    set_css_style(app)
     main_app.show()
     main_app.activateWindow()
     if args['expert']:

shinestacker/app/project.py

@@ -14,7 +14,8 @@ config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 
 
@@ -63,6 +64,7 @@ expert options are visible by default.
         disable_macos_special_menu_items()
     icon_path = f"{os.path.dirname(__file__)}/../gui/ico/shinestacker.png"
     app.setWindowIcon(QIcon(icon_path))
+    set_css_style(app)
     window = ProjectApp()
     if args['expert']:
         window.set_expert_options()

shinestacker/app/retouch.py

@@ -9,7 +9,8 @@ from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
-from shinestacker.app.gui_utils import disable_macos_special_menu_items, fill_app_menu
+from shinestacker.app.gui_utils import (
+    disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
 
@@ -60,6 +61,7 @@ Multiple directories can be specified separated by ';'.
         disable_macos_special_menu_items()
     icon_path = f"{os.path.dirname(__file__)}/../gui/ico/shinestacker.png"
     app.setWindowIcon(QIcon(icon_path))
+    set_css_style(app)
     editor = RetouchApp()
     app.editor = editor
     editor.show()