shinestacker 1.8.0__py3-none-any.whl → 1.9.3__py3-none-any.whl

shinestacker/algorithms/multilayer.py

@@ -13,7 +13,7 @@ from .. config.constants import constants
 from .. config.config import config
 from .. core.colors import color_str
 from .. core.framework import TaskBase
-from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
+from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG, EXTENSIONS_SUPPORTED
 from .stack_framework import ImageSequenceManager
 from .exif import exif_extra_tags_for_tif, get_exif
 
@@ -142,14 +142,16 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
         elif os.path.isdir(exif_path):
             _dirpath, _, fnames = next(os.walk(exif_path))
             fnames = [name for name in fnames
-                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
-            extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(exif_path + '/' + fnames[0]))
+                      if os.path.splitext(name)[-1][1:].lower() in EXTENSIONS_SUPPORTED]
+            file_path = os.path.join(exif_path, fnames[0])
+            extra_tags, exif_tags = exif_extra_tags_for_tif(get_exif(file_path))
+        extra_tags = [tag for tag in extra_tags if isinstance(tag[0], int)]
         tiff_tags['extratags'] += extra_tags
         tiff_tags = {**tiff_tags, **exif_tags}
     if callbacks:
         callback = callbacks.get('write_msg', None)
         if callback:
-            callback(output_file.split('/')[-1])
+            callback(os.path.basename(output_file))
     compression = 'adobe_deflate'
     overlayed_images = overlay(
         *((np.concatenate((image, np.expand_dims(transp, axis=-1)),

shinestacker/algorithms/noise_detection.py

@@ -109,13 +109,14 @@ class NoiseDetection(TaskBase, ImageSequenceManager):
                             {'rgb': 'black', 'r': 'red', 'g': 'green', 'b': 'blue'}[ch])
             msg.append(hpx)
         self.print_message(color_str("hot pixels: " + ", ".join(msg), constants.LOG_COLOR_LEVEL_2))
-        path = "/".join(self.file_name.split("/")[:-1])
-        if not os.path.exists(f"{self.working_path}/{path}"):
-            self.print_message(f"create directory: {path}")
-            os.mkdir(f"{self.working_path}/{path}")
-        self.print_message(color_str(f"writing hot pixels map file: {self.file_name}",
+        output_full_path = os.path.join(self.working_path, self.output_path)
+        if not os.path.exists(output_full_path):
+            self.print_message(f"create directory: {self.output_path}")
+            os.mkdir(output_full_path)
+        file_path = os.path.join(self.output_path, self.file_name)
+        self.print_message(color_str(f"writing hot pixels map file: {file_path}",
                                      constants.LOG_COLOR_LEVEL_2))
-        cv2.imwrite(f"{self.working_path}/{self.file_name}", hot_rgb)
+        cv2.imwrite(os.path.join(output_full_path, self.file_name), hot_rgb)
         plot_range = self.plot_range
         min_th, max_th = min(self.channel_thresholds), max(self.channel_thresholds)
         if min_th < plot_range[0]:
@@ -171,8 +172,9 @@ class MaskNoise(SubAction):
         else:
             raise ImageLoadError(path, "file not found.")
 
-    def run_frame(self, _idx, _ref_idx, image):
-        self.process.sub_message_r(color_str(': mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
+    def run_frame(self, idx, _ref_idx, image):
+        self.process.print_message(color_str(
+            f'{self.process.frame_str(idx)}: mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
         shape = image.shape[:2]
         if shape != self.expected_shape:
             raise ShapeError(self.expected_shape, shape)

shinestacker/algorithms/pyramid_tiles.py

@@ -222,7 +222,7 @@ class PyramidTilesStack(PyramidBase):
                         all_level_counts[img_index] = level_count
                         completed_count += 1
                         self.print_message(
-                            f": processing completed, {self.image_str(completed_count - 1)}")
+                            f": preprocessing completed, {self.image_str(completed_count - 1)}")
                     except Exception as e:
                         self.print_message(
                             f"Error processing {self.image_str(i)}: {str(e)}")

shinestacker/algorithms/stack.py

@@ -1,11 +1,13 @@
-# pylint: disable=C0114, C0115, C0116, R0913, R0917
+# pylint: disable=C0114, C0115, C0116, R0913, R0917, W0718
 import os
 import traceback
+import logging
+import numpy as np
 from .. config.constants import constants
 from .. core.framework import TaskBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
-from .utils import write_img, extension_tif_jpg
+from .utils import write_img, extension_supported
 from .stack_framework import ImageSequenceManager, SequentialTask
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
@@ -35,18 +37,28 @@ class FocusStackBase(TaskBase, ImageSequenceManager):
             stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
         write_img(out_filename, stacked_img)
         if self.exif_path != '':
-            self.sub_message_r(color_str(': copy exif data', constants.LOG_COLOR_LEVEL_3))
-            if not os.path.exists(self.exif_path):
-                raise RuntimeError(f"Path {self.exif_path} does not exist.")
-            try:
-                _dirpath, _, fnames = next(os.walk(self.exif_path))
-                fnames = [name for name in fnames if extension_tif_jpg(name)]
-                exif_filename = os.path.join(self.exif_path, fnames[0])
-                copy_exif_from_file_to_file(exif_filename, out_filename)
-                self.sub_message_r(' ' * 60)
-            except Exception as e:
-                traceback.print_tb(e.__traceback__)
-                raise RuntimeError("Can't copy EXIF data") from e
+            if stacked_img.dtype == np.uint16 and \
+               os.path.splitext(out_filename)[-1].lower() == '.png':
+                self.sub_message_r(color_str(': exif not supported for 16-bit PNG format',
+                                             constants.LOG_COLOR_WARNING),
+                                   level=logging.WARNING)
+            else:
+                self.sub_message_r(color_str(': copy exif data', constants.LOG_COLOR_LEVEL_3))
+                if not os.path.exists(self.exif_path):
+                    raise RuntimeError(f"path {self.exif_path} does not exist.")
+                try:
+                    _dirpath, _, fnames = next(os.walk(self.exif_path))
+                    fnames = [name for name in fnames if extension_supported(name)]
+                    if len(fnames) == 0:
+                        raise RuntimeError(f"path {self.exif_path} does not contain image files.")
+                    exif_filename = os.path.join(self.exif_path, fnames[0])
+                    copy_exif_from_file_to_file(exif_filename, out_filename)
+                    self.sub_message_r(' ' * 60)
+                except Exception as e:
+                    traceback.print_tb(e.__traceback__)
+                    self.sub_message_r(color_str(f': failed to copy EXIF data: {str(e)}',
+                                                 constants.LOG_COLOR_WARNING),
+                                       level=logging.WARNING)
         if self.plot_stack:
             idx_str = f"{self.frame_count + 1:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"
@@ -70,6 +82,10 @@ class FocusStackBase(TaskBase, ImageSequenceManager):
 
 
 def get_bunches(collection, n_frames, n_overlap):
+    if n_frames == n_overlap:
+        raise RuntimeError(
+            f"Can't get bunch collection, total number of frames ({n_frames}) "
+            "is equal to the number of overlapping grames")
     bunches = [collection[x:x + n_frames]
                for x in range(0, len(collection) - n_overlap, n_frames - n_overlap)]
     return bunches
@@ -97,7 +113,7 @@ class FocusStackBunch(SequentialTask, FocusStackBase):
 
     def begin(self):
         SequentialTask.begin(self)
-        self._chunks = get_bunches(self.input_filepaths(), self.frames, self.overlap)
+        self._chunks = get_bunches(sorted(self.input_filepaths()), self.frames, self.overlap)
         self.set_counts(len(self._chunks))
 
     def end(self):
@@ -110,9 +126,9 @@ class FocusStackBunch(SequentialTask, FocusStackBase):
         self.print_message(
             color_str(f"fusing bunch: {action_count + 1}/{self.total_action_counts}",
                       constants.LOG_COLOR_LEVEL_2))
-        img_files = self._chunks[action_count - 1]
+        img_files = self._chunks[action_count]
         self.stack_algo.init(img_files)
-        self.focus_stack(self._chunks[action_count - 1])
+        self.focus_stack(self._chunks[action_count])
         return True
 
 

shinestacker/algorithms/stack_framework.py

@@ -7,7 +7,7 @@ from .. core.colors import color_str
 from .. core.framework import Job, SequentialTask
 from .. core.core_utils import check_path_exists
 from .. core.exceptions import RunStopException
-from .utils import read_img, write_img, extension_tif_jpg, get_img_metadata, validate_image
+from .utils import read_img, write_img, extension_supported, get_img_metadata, validate_image
 
 
 class StackJob(Job):
@@ -95,7 +95,7 @@ class ImageSequenceManager:
                 filelist = []
                 for _dirpath, _, filenames in os.walk(d):
                     filelist = [os.path.join(_dirpath, name)
-                                for name in filenames if extension_tif_jpg(name)]
+                                for name in filenames if extension_supported(name)]
                     filelist.sort()
                     if self.reverse_order:
                         filelist.reverse()
@@ -191,7 +191,8 @@ class ImageSequenceManager:
 
 
 class ReferenceFrameTask(SequentialTask, ImageSequenceManager):
-    def __init__(self, name, enabled=True, reference_index=0, step_process=False, **kwargs):
+    def __init__(self, name, enabled=True, reference_index=0,
+                 step_process=constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS, **kwargs):
         ImageSequenceManager.__init__(self, name, **kwargs)
         SequentialTask.__init__(self, name, enabled)
         self.ref_idx = reference_index
@@ -276,7 +277,8 @@ class SubAction:
 
 class CombinedActions(ReferenceFrameTask):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
-        ReferenceFrameTask.__init__(self, name, enabled, **kwargs)
+        step_process = kwargs.pop('step_process', constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS)
+        ReferenceFrameTask.__init__(self, name, enabled, step_process=step_process, **kwargs)
         self._actions = actions
         self._metadata = (None, None)
 
@@ -294,11 +296,15 @@ class CombinedActions(ReferenceFrameTask):
         self._metadata = get_img_metadata(img)
         return img
 
+    def frame_str(self, idx=-1):
+        if self.run_sequential():
+            idx = self.current_action_count
+        return f"frame {idx + 1}/{self.total_action_counts}"
+
     def run_frame(self, idx, ref_idx):
         input_path = self.input_filepath(idx)
         self.print_message(
-            color_str(f'read input image '
-                      f'{idx + 1}/{self.total_action_counts}, '
+            color_str(f'read input {self.frame_str(idx)}, '
                       f'{os.path.basename(input_path)}', constants.LOG_COLOR_LEVEL_3))
         img = read_img(input_path)
         validate_image(img, *(self._metadata))
@@ -317,20 +323,19 @@ class CombinedActions(ReferenceFrameTask):
                 if img is not None:
                     img = a.run_frame(idx, ref_idx, img)
                 else:
-                    self.sub_message(
-                        color_str(": null input received, action skipped",
+                    self.print_message(
+                        color_str("null input received, action skipped",
                                   constants.LOG_COLOR_ALERT),
                         level=logging.WARNING)
         if img is not None:
             output_path = os.path.join(self.output_full_path(), os.path.basename(input_path))
             self.print_message(
-                color_str(f'write output image '
-                          f'{idx + 1}/{self.total_action_counts}, '
+                color_str(f'write output {self.frame_str(idx)}, '
                           f'{os.path.basename(output_path)}', constants.LOG_COLOR_LEVEL_3))
             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)}",
+            f"no output resulted from processing input file: {os.path.basename(input_path)}",
             constants.LOG_COLOR_ALERT), level=logging.WARNING)
         return None
 

shinestacker/algorithms/utils.py

@@ -18,6 +18,15 @@ EXTENSIONS_TIF = ['tif', 'tiff']
 EXTENSIONS_JPG = ['jpg', 'jpeg']
 EXTENSIONS_PNG = ['png']
 EXTENSIONS_PDF = ['pdf']
+EXTENSIONS_SUPPORTED = EXTENSIONS_TIF + EXTENSIONS_JPG + EXTENSIONS_PNG
+EXTENSIONS_GUI_STR = " ".join([f"*.{ext}" for ext in EXTENSIONS_SUPPORTED])
+EXTENSION_GUI_TIF = " ".join([f"*.{ext}" for ext in EXTENSIONS_TIF])
+EXTENSION_GUI_JPG = " ".join([f"*.{ext}" for ext in EXTENSIONS_JPG])
+EXTENSION_GUI_PNG = " ".join([f"*.{ext}" for ext in EXTENSIONS_PNG])
+EXTENSIONS_GUI_SAVE_STR = f"TIFF Files ({EXTENSION_GUI_TIF});;" \
+                          f"JPEG Files ({EXTENSION_GUI_JPG});;" \
+                          f"PNG Files ({EXTENSION_GUI_PNG});;" \
+                          "All Files (*)"
 
 
 def extension_in(path, exts):
@@ -56,6 +65,10 @@ def extension_jpg_tif_png(path):
     return extension_in(path, EXTENSIONS_JPG + EXTENSIONS_TIF + EXTENSIONS_PNG)
 
 
+def extension_supported(path):
+    return extension_in(path, EXTENSIONS_SUPPORTED)
+
+
 def read_img(file_path):
     if not os.path.isfile(file_path):
         raise RuntimeError("File does not exist: " + file_path)
@@ -73,7 +86,10 @@ def write_img(file_path, img):
     elif extension_tif(file_path):
         cv2.imwrite(file_path, img, [int(cv2.IMWRITE_TIFF_COMPRESSION), 1])
     elif extension_png(file_path):
-        cv2.imwrite(file_path, img)
+        cv2.imwrite(file_path, img, [
+            int(cv2.IMWRITE_PNG_COMPRESSION), 9,
+            int(cv2.IMWRITE_PNG_STRATEGY), cv2.IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY
+        ])
 
 
 def img_8bit(img):
@@ -96,7 +112,7 @@ def img_bw(img):
 def get_first_image_file(filenames):
     first_img_file = None
     for filename in filenames:
-        if os.path.isfile(filename) and extension_tif_jpg(filename):
+        if os.path.isfile(filename) and extension_supported(filename):
             first_img_file = filename
             break
     if first_img_file is None:

shinestacker/algorithms/vignetting.py

@@ -4,7 +4,7 @@ import traceback
 import logging
 import numpy as np
 import matplotlib.pyplot as plt
-from scipy.optimize import curve_fit, fsolve
+from scipy.optimize import curve_fit, bisect
 import cv2
 from .. core.colors import color_str
 from .. core.core_utils import setup_matplotlib_mode
@@ -181,9 +181,22 @@ class Vignetting(SubAction):
             self.process.callback(
                 constants.CALLBACK_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: sigmoid_model(x, *params) /
-                                              self.v0 - p, r0_fit)[0]
+            s1 = sigmoid_model(0, *params) / self.v0
+            s2 = sigmoid_model(self.r_max, *params) / self.v0
+            if s1 > p > s2:
+                try:
+                    c = bisect(lambda x: sigmoid_model(x, *params) / self.v0 - p, 0, self.r_max)
+                except Exception as e:
+                    traceback.print_tb(e.__traceback__)
+                    self.process.sub_message(color_str(f": {str(e).lower()}", "yellow"),
+                                             level=logging.WARNING)
+            elif s1 <= p:
+                c = 0
+            else:
+                c = self.r_max
+            self.corrections[i][idx] = c
         self.process.print_message(
             color_str(f"{self.process.idx_tot_str(idx)}: correct vignetting", "cyan"))
         return correct_vignetting(

shinestacker/app/main.py

@@ -199,7 +199,7 @@ class MainApp(QMainWindow):
 class Application(QApplication):
     def event(self, event):
         if event.type() == QEvent.Quit and event.spontaneous():
-            if not self.quit():
+            if not self.main_app.quit():
                 return True
         return super().event(event)