shinestacker 1.0.4.post2__tar.gz → 1.1.0__tar.gz

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/CHANGELOG.md

@@ -2,7 +2,20 @@
 
 This page reports the main releases only and the main changes therein.
 
-## [v-.-.-] - 2025-08-26
+## [v1.1.0] - 2025-08-28
+**New Pyramids algorith, some improvements and more fixes**
+
+### Changes
+
+* added Pyramids Tiles, that requires less RAM by fusing the image in tiles
+* the alignment module now tolerates images of different shapes
+* noisy pixel mask verifies that the mask has the same shape as input images
+* minor changes to default alignment parameters
+* some improvements to the GUI
+* some bug fixes
+---
+
+## [v1.0.4.pre2] - 2025-08-26
 **Bug fixes**
 
 ### Changes

{shinestacker-1.0.4.post2/src/shinestacker.egg-info → shinestacker-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.0.4.post2
+Version: 1.1.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -69,6 +69,25 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
 
+# Note for macOS users
+
+**The following note is only relevant if you download the application as compressed archive from the [release page](https://github.com/lucalista/shinestacker/releases).**
+
+The macOS system security protection prevent to run applications downloaded from the web that come from developers that don't hold an Apple Developer Certificate. 
+
+In order to prevent this, follow the instructions below:
+
+1. Download the compressed archive ```shinestacker-macos.tar.gz``` in your ```Download``` folder.
+2. Double-click the archive to uncompress it. You will find a new folder ```shinestacker```.
+3. Open a terminal (*Applications > Utilities > Terminal*)
+4. Type the folliwng command on the terminal:
+```bash
+xattr -cr ~/Downloads/shinestacker/shinestacker.app
+```
+5. Now you can double-click the Sine Stacker icon app in the ```shiestacker``` folder and it should run.
+
+macOS adds a quarantine flag to all files downloaded from the internet. The above command removes that flag while preserving all other application functionality.
+
 # Resources
 
  🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/README.md

@@ -38,6 +38,25 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
 
+# Note for macOS users
+
+**The following note is only relevant if you download the application as compressed archive from the [release page](https://github.com/lucalista/shinestacker/releases).**
+
+The macOS system security protection prevent to run applications downloaded from the web that come from developers that don't hold an Apple Developer Certificate. 
+
+In order to prevent this, follow the instructions below:
+
+1. Download the compressed archive ```shinestacker-macos.tar.gz``` in your ```Download``` folder.
+2. Double-click the archive to uncompress it. You will find a new folder ```shinestacker```.
+3. Open a terminal (*Applications > Utilities > Terminal*)
+4. Type the folliwng command on the terminal:
+```bash
+xattr -cr ~/Downloads/shinestacker/shinestacker.app
+```
+5. Now you can double-click the Sine Stacker icon app in the ```shiestacker``` folder and it should run.
+
+macOS adds a quarantine flag to all files downloaded from the internet. The above command removes that flag while preserving all other application functionality.
+
 # Resources
 
  🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/docs/focus_stacking.md

@@ -42,6 +42,11 @@ Arguments for the constructor are:
    * ```gen_kernel``` (optional, default: 0.4)
    * ```float_type``` (optional, default: ```FLOAT_32```, possible values: ```FLOAT_32```, ```FLOAT_64```): precision for internal image representation
 
+```PyramidTilesStack```, Laplacian pyramid with tile pyramid merging to optimize memory usage for large files
+
+Arguments for the constructor are the same ad for ```PyramidStack``` plus:
+   * ```tile_size``` (optional, default: 512): size of the tile used for partial image merging
+
 ```DepthMapStack```, Depth map focus stacking algorithm
 
 Arguments for the constructor are:

shinestacker-1.1.0/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.1.0'

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/align.py

@@ -6,7 +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, get_img_metadata, validate_image, img_subsample
+from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
 
 _DEFAULT_FEATURE_CONFIG = {
@@ -161,9 +161,10 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     except KeyError as e:
         raise InvalidOptionError("border_mode", alignment_config['border_mode']) from e
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
-    validate_image(img_0, *get_img_metadata(img_1))
     if callbacks and 'message' in callbacks:
         callbacks['message']()
+    h_ref, w_ref = img_1.shape[:2]
+    h0, w0 = img_0.shape[:2]
     subsample = alignment_config['subsample']
     fast_subsampling = alignment_config['fast_subsampling']
     min_good_matches = alignment_config['min_good_matches']
@@ -204,15 +205,14 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
                 flags=2), cv2.COLOR_BGR2RGB)
             plt.figure(figsize=(10, 5))
             plt.imshow(img_match, 'gray')
-            plt.savefig(plot_path)
+            save_plot(plot_path)
             if callbacks and 'save_plot' in callbacks:
                 callbacks['save_plot'](plot_path)
-        h, w = img_0.shape[:2]
         h_sub, w_sub = img_0_sub.shape[:2]
         if subsample > 1:
             if transform == constants.ALIGN_HOMOGRAPHY:
                 low_size = np.float32([[0, 0], [0, h_sub], [w_sub, h_sub], [w_sub, 0]])
-                high_size = np.float32([[0, 0], [0, h], [w, h], [w, 0]])
+                high_size = np.float32([[0, 0], [0, h0], [w0, h0], [w0, 0]])
                 scale_up = cv2.getPerspectiveTransform(low_size, high_size)
                 scale_down = cv2.getPerspectiveTransform(high_size, low_size)
                 m = scale_up @ m @ scale_down
@@ -230,17 +230,17 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
         img_mask = np.ones_like(img_0, dtype=np.uint8)
         if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY:
             img_warp = cv2.warpPerspective(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpPerspective(img_mask, m, (w, h),
+                mask = cv2.warpPerspective(img_mask, m, (w_ref, h_ref),
                                            borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         elif alignment_config['transform'] == constants.ALIGN_RIGID:
             img_warp = cv2.warpAffine(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpAffine(img_mask, m, (w, h),
+                mask = cv2.warpAffine(img_mask, m, (w_ref, h_ref),
                                       borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
             if callbacks and 'blur_message' in callbacks:
@@ -293,7 +293,7 @@ class AlignFrames(SubAction):
             'ecc_message': lambda: self.sub_msg(": ecc refinement"),
             'blur_message': lambda: self.sub_msg(': blur borders'),
             'warning': lambda msg: self.sub_msg(
-                f': {msg}', constants.LOG_COLOR_ALERT),
+                f': {msg}', constants.LOG_COLOR_WARNING),
             'save_plot': lambda plot_path: self.process.callback(
                 'save_plot', self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)
@@ -315,7 +315,7 @@ class AlignFrames(SubAction):
         if n_good_matches < self.min_matches:
             self.process.sub_message(f": image not aligned, too few matches found: "
                                      f"{n_good_matches}", level=logging.CRITICAL)
-            raise AlignmentError(idx, f"too few matches found: "
+            raise AlignmentError(idx, f"Image not aligned, too few matches found: "
                                  f"{n_good_matches} < {self.min_matches}")
         return img
 

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/base_stack_algo.py

@@ -1,9 +1,10 @@
 # pylint: disable=C0114, C0115, C0116, E0602, R0903
+import os
 import numpy as np
-from .. core.exceptions import InvalidOptionError, ImageLoadError
+from .. core.exceptions import InvalidOptionError, ImageLoadError, RunStopException
 from .. config.constants import constants
 from .. core.colors import color_str
-from .utils import read_img, get_img_metadata, validate_image
+from .utils import read_img, get_img_metadata, validate_image, get_img_file_shape, extension_tif_jpg
 
 
 class BaseStackAlgo:
@@ -11,6 +12,9 @@ class BaseStackAlgo:
         self._name = name
         self._steps_per_frame = steps_per_frame
         self.process = None
+        self.filenames = None
+        self.shape = None
+        self.do_step_callback = False
         if float_type == constants.FLOAT_32:
             self.float_type = np.float32
         elif float_type == constants.FLOAT_64:
@@ -24,8 +28,17 @@ class BaseStackAlgo:
     def name(self):
         return self._name
 
-    def steps_per_frame(self):
-        return self._steps_per_frame
+    def init(self, filenames):
+        self.filenames = filenames
+        first_img_file = ''
+        for filename in filenames:
+            if os.path.isfile(filename) and extension_tif_jpg(filename):
+                first_img_file = filename
+                break
+        self.shape = get_img_file_shape(first_img_file)
+
+    def total_steps(self, n_frames):
+        return self._steps_per_frame * n_frames
 
     def print_message(self, msg):
         self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
@@ -40,3 +53,13 @@ class BaseStackAlgo:
         else:
             validate_image(img, *metadata)
         return img, metadata, updated
+
+    def check_running(self, cleanup_callback=None):
+        if self.process.callback('check_running', self.process.id, self.process.name) is False:
+            if cleanup_callback is not None:
+                cleanup_callback()
+            raise RunStopException(self.name)
+
+    def after_step(self, step):
+        if self.do_step_callback:
+            self.process.callback('after_step', self.process.id, self.process.name, step)

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/depth_map.py

@@ -2,7 +2,7 @@
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.exceptions import InvalidOptionError, RunStopException
+from .. core.exceptions import InvalidOptionError
 from .utils import read_img, img_bw
 from .base_stack_algo import BaseStackAlgo
 
@@ -61,19 +61,18 @@ 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 focus_stack(self, filenames):
+    def focus_stack(self):
         gray_images = []
         metadata = None
-        for i, img_path in enumerate(filenames):
+        for i, img_path in enumerate(self.filenames):
             self.print_message(f": reading file (1/2) {img_path.split('/')[-1]}")
 
             img, metadata, _updated = self.read_image_and_update_metadata(img_path, metadata)
 
             gray = img_bw(img)
             gray_images.append(gray)
-            self.process.callback('after_step', self.process.id, self.process.name, i)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            self.after_step(i)
+            self.check_running()
         dtype = metadata[1]
         gray_images = np.array(gray_images, dtype=self.float_type)
         if self.energy == constants.DM_ENERGY_SOBEL:
@@ -92,7 +91,7 @@ class DepthMapStack(BaseStackAlgo):
             energies = self.smooth_energy(energies)
         weights = self.get_focus_map(energies)
         blended_pyramid = None
-        for i, img_path in enumerate(filenames):
+        for i, img_path in enumerate(self.filenames):
             self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
@@ -110,10 +109,8 @@ class DepthMapStack(BaseStackAlgo):
                              for j in range(self.levels)]
             blended_pyramid = current_blend if blended_pyramid is None \
                 else [np.add(bp, cb) for bp, cb in zip(blended_pyramid, current_blend)]
-            self.process.callback('after_step', self.process.id,
-                                  self.process.name, i + len(filenames))
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            self.after_step(i + len(self.filenames))
+            self.check_running()
         result = blended_pyramid[0]
         self.print_message(': blend levels')
         for j in range(1, self.levels):

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/noise_detection.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E1101, W0718, R0914, R0915
+# pylint: disable=C0114, C0115, C0116, E1101, W0718, R0914, R0915, R0902
 import os
 import errno
 import logging
@@ -11,7 +11,7 @@ from .. core.colors import color_str
 from .. core.exceptions import ImageLoadError
 from .. core.framework import JobBase
 from .. core.core_utils import make_tqdm_bar
-from .. core.exceptions import RunStopException
+from .. core.exceptions import RunStopException, ShapeError
 from .stack_framework import FrameMultiDirectory, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
@@ -154,6 +154,7 @@ class MaskNoise(SubAction):
         self.method = method
         self.process = None
         self.noise_mask_img = None
+        self.expected_shape = None
 
     def begin(self, process):
         self.process = process
@@ -163,6 +164,7 @@ class MaskNoise(SubAction):
                 f': reading noisy pixel mask file: {self.noise_mask}',
                 constants.LOG_COLOR_LEVEL_3))
             self.noise_mask_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+            self.expected_shape = self.noise_mask_img.shape[:2]
             if self.noise_mask_img is None:
                 raise ImageLoadError(path, f"failed to load image file {self.noise_mask}.")
         else:
@@ -170,6 +172,9 @@ class MaskNoise(SubAction):
 
     def run_frame(self, _idx, _ref_idx, image):
         self.process.sub_message_r(color_str(': mask noisy pixels', constants.LOG_COLOR_LEVEL_3))
+        shape = image.shape[:2]
+        if shape != self.expected_shape:
+            raise ShapeError(self.expected_shape, shape)
         if len(image.shape) == 3:
             corrected = image.copy()
             for c in range(3):

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/pyramid.py

@@ -1,25 +1,36 @@
-# pylint: disable=C0114, C0115, C0116, E1101
+# pylint: disable=C0114, C0115, C0116, E1101, R0913, R0917, R0902
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.exceptions import RunStopException
 from .utils import read_img
 from .base_stack_algo import BaseStackAlgo
 
 
 class PyramidBase(BaseStackAlgo):
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+    def __init__(self, name, min_size=constants.DEFAULT_PY_MIN_SIZE,
                  kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
                  gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
                  float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__("pyramid", 2, float_type)
+        super().__init__(name, 2, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
-        self.do_step_callback = False
         kernel = np.array([0.25 - gen_kernel / 2.0, 0.25,
                            gen_kernel, 0.25, 0.25 - gen_kernel / 2.0])
         self.gen_kernel = np.outer(kernel, kernel)
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
+        self.n_levels = 0
+        self.n_frames = 0
+
+    def init(self, filenames):
+        super().init(filenames)
+        self.n_levels = int(np.log2(min(self.shape) / self.min_size))
+
+    def total_steps(self, n_frames):
+        self.n_frames = n_frames
+        return self._steps_per_frame * n_frames + self.n_levels
 
     def convolve(self, image):
         return cv2.filter2D(image, -1, self.gen_kernel, borderType=cv2.BORDER_REFLECT101)
@@ -55,6 +66,7 @@ class PyramidBase(BaseStackAlgo):
         return fused
 
     def collapse(self, pyramid):
+        self.print_message(': collapsing pyramid')
         img = pyramid[-1]
         for layer in pyramid[-2::-1]:
             expanded = self.expand_layer(img)
@@ -110,19 +122,22 @@ class PyramidBase(BaseStackAlgo):
             fused += np.where(best_d[:, :, np.newaxis] == layer, img, 0)
         return (fused / 2).astype(images.dtype)
 
+    def focus_stack_validate(self, cleanup_callback=None):
+        metadata = None
+        for i, img_path in enumerate(self.filenames):
+            self.print_message(f": validating file {img_path.split('/')[-1]}")
 
-class PyramidStack(PyramidBase):
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
-                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
-                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
-                 float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__(min_size, kernel_size, gen_kernel, float_type)
-        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
-        self.dtype = None
-        self.num_pixel_values = None
-        self.max_pixel_value = None
+            _img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
+            if updated:
+                self.dtype = metadata[1]
+                self.num_pixel_values = constants.NUM_UINT8 \
+                    if self.dtype == np.uint8 else constants.NUM_UINT16
+                self.max_pixel_value = constants.MAX_UINT8 \
+                    if self.dtype == np.uint8 else constants.MAX_UINT16
+            self.after_step(i + 1)
+            self.check_running(cleanup_callback)
 
-    def process_single_image(self, img, levels):
+    def single_image_laplacian(self, img, levels):
         pyramid = [img.astype(self.float_type)]
         for _ in range(levels):
             next_layer = self.reduce_layer(pyramid[-1])
@@ -136,44 +151,43 @@ class PyramidStack(PyramidBase):
             h, w = pyr.shape[:2]
             expanded = expanded[:h, :w]
             laplacian.append(pyr - expanded)
+        return laplacian
+
+
+class PyramidStack(PyramidBase):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT):
+        super().__init__("pyramid", min_size, kernel_size, gen_kernel, float_type)
+        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
+
+    def process_single_image(self, img, levels):
+        laplacian = self.single_image_laplacian(img, levels)
         return laplacian[::-1]
 
     def fuse_pyramids(self, all_laplacians):
         fused = [self.get_fused_base(np.stack([p[-1] for p in all_laplacians], axis=0))]
+        count = 0
         for layer in range(len(all_laplacians[0]) - 2, -1, -1):
             self.print_message(f': fusing pyramids, layer: {layer + 1}')
             laplacians = np.stack([p[layer] for p in all_laplacians], axis=0)
             fused.append(self.fuse_laplacian(laplacians))
+            count += 1
+            self.after_step(self._steps_per_frame * self.n_frames + count)
+            self.check_running()
         self.print_message(': pyramids fusion completed')
         return fused[::-1]
 
-    def focus_stack(self, filenames):
-        metadata = None
+    def focus_stack(self):
+        n = len(self.filenames)
+        self.focus_stack_validate()
         all_laplacians = []
-        levels = None
-        n = len(filenames)
-        for i, img_path in enumerate(filenames):
-            self.print_message(f": validating file {img_path.split('/')[-1]}")
-
-            img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
-            if updated:
-                self.dtype = metadata[1]
-                self.num_pixel_values = constants.NUM_UINT8 \
-                    if self.dtype == np.uint8 else constants.NUM_UINT16
-                self.max_pixel_value = constants.MAX_UINT8 \
-                    if self.dtype == np.uint8 else constants.MAX_UINT16
-                levels = int(np.log2(min(img.shape[:2]) / self.min_size))
-            if self.do_step_callback:
-                self.process.callback('after_step', self.process.id, self.process.name, i)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
-        for i, img_path in enumerate(filenames):
+        for i, img_path in enumerate(self.filenames):
             self.print_message(f": processing file {img_path.split('/')[-1]}")
             img = read_img(img_path)
-            all_laplacians.append(self.process_single_image(img, levels))
-            if self.do_step_callback:
-                self.process.callback('after_step', self.process.id, self.process.name, i + n)
-            if self.process.callback('check_running', self.process.id, self.process.name) is False:
-                raise RunStopException(self.name)
+            all_laplacians.append(self.process_single_image(img, self.n_levels))
+            self.after_step(i + n + 1)
+            self.check_running()
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))
         return stacked_image.astype(self.dtype)

shinestacker-1.1.0/src/shinestacker/algorithms/pyramid_tiles.py

@@ -0,0 +1,109 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913, R0917, R0912, R0915
+import os
+import tempfile
+import numpy as np
+from .. config.constants import constants
+from .utils import read_img
+from .pyramid import PyramidBase
+
+
+class PyramidTilesStack(PyramidBase):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT,
+                 tile_size=constants.DEFAULT_PY_TILE_SIZE):
+        super().__init__("fast_pyramid", min_size, kernel_size, gen_kernel, float_type)
+        self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
+        self.tile_size = tile_size
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.n_tiles = 0
+
+    def init(self, filenames):
+        super().init(filenames)
+        self.n_tiles = (self.shape[0] // self.tile_size + 1) * (self.shape[1] // self.tile_size + 1)
+
+    def total_steps(self, n_frames):
+        n_steps = super().total_steps(n_frames)
+        return n_steps + self.n_tiles
+
+    def process_single_image(self, img, levels, img_index):
+        laplacian = self.single_image_laplacian(img, levels)
+        for i, level_data in enumerate(laplacian[::-1]):
+            np.save(os.path.join(self.temp_dir.name, f'img_{img_index}_level_{i}.npy'), level_data)
+        return len(laplacian)
+
+    def load_level(self, img_index, level):
+        return np.load(os.path.join(self.temp_dir.name, f'img_{img_index}_level_{level}.npy'))
+
+    def cleanup_temp_files(self):
+        self.temp_dir.cleanup()
+
+    def fuse_pyramids(self, all_level_counts, num_images):
+        max_levels = max(all_level_counts)
+        fused = []
+        count = self._steps_per_frame * self.n_frames
+        for level in range(max_levels - 1, -1, -1):
+            self.print_message(f': fusing pyramids, layer: {level + 1}')
+            if level == 0:
+                sample_level = self.load_level(0, 0)
+                h, w = sample_level.shape[:2]
+                del sample_level
+                fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+                for y in range(0, h, self.tile_size):
+                    for x in range(0, w, self.tile_size):
+                        y_end = min(y + self.tile_size, h)
+                        x_end = min(x + self.tile_size, w)
+                        self.print_message(f': fusing tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                        laplacians = []
+                        for img_index in range(num_images):
+                            if level < all_level_counts[img_index]:
+                                full_laplacian = self.load_level(img_index, level)
+                                tile = full_laplacian[y:y_end, x:x_end]
+                                laplacians.append(tile)
+                                del full_laplacian
+                        stacked = np.stack(laplacians, axis=0)
+                        fused_tile = self.fuse_laplacian(stacked)
+                        fused_level[y:y_end, x:x_end] = fused_tile
+                        del laplacians, stacked, fused_tile
+                        self.after_step(count)
+                        self.check_running(self.cleanup_temp_files)
+                        count += 1
+            else:
+                laplacians = []
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        laplacian = self.load_level(img_index, level)
+                        laplacians.append(laplacian)
+                if level == max_levels - 1:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.get_fused_base(stacked)
+                else:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_level = self.fuse_laplacian(stacked)
+                    self.check_running(self.cleanup_temp_files)
+            fused.append(fused_level)
+            count += 1
+            self.after_step(count)
+            self.check_running(self.cleanup_temp_files)
+        self.print_message(': pyramids fusion completed')
+        return fused[::-1]
+
+    def focus_stack(self):
+        n = len(self.filenames)
+        self.focus_stack_validate(self.cleanup_temp_files)
+        all_level_counts = []
+        for i, img_path in enumerate(self.filenames):
+            self.print_message(f": processing file {img_path.split('/')[-1]}")
+            img = read_img(img_path)
+            level_count = self.process_single_image(img, self.n_levels, i)
+            all_level_counts.append(level_count)
+            self.after_step(i + n + 1)
+            self.check_running(self.cleanup_temp_files)
+        fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+        stacked_image = self.collapse(fused_pyramid)
+        self.cleanup_temp_files()
+        return stacked_image.astype(self.dtype)

{shinestacker-1.0.4.post2 → shinestacker-1.1.0}/src/shinestacker/algorithms/stack.py

@@ -5,7 +5,7 @@ from .. config.constants import constants
 from .. core.framework import JobBase
 from .. core.colors import color_str
 from .. core.exceptions import InvalidOptionError
-from .utils import write_img
+from .utils import write_img, extension_tif_jpg
 from .stack_framework import FrameDirectory, ActionList
 from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
@@ -25,8 +25,7 @@ class FocusStackBase(JobBase, FrameDirectory):
 
     def focus_stack(self, filenames):
         self.sub_message_r(color_str(': reading input files', constants.LOG_COLOR_LEVEL_3))
-        img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
-        stacked_img = self.stack_algo.focus_stack(img_files)
+        stacked_img = self.stack_algo.focus_stack()
         in_filename = filenames[0].split(".")
         out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + \
             '.'.join(in_filename[1:])
@@ -37,8 +36,7 @@ class FocusStackBase(JobBase, FrameDirectory):
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')
             _dirpath, _, fnames = next(os.walk(self.exif_path))
-            fnames = [name for name in fnames
-                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            fnames = [name for name in fnames if extension_tif_jpg(name)]
             exif_filename = f"{self.exif_path}/{fnames[0]}"
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
@@ -52,6 +50,7 @@ class FocusStackBase(JobBase, FrameDirectory):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
+        FrameDirectory.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
@@ -79,7 +78,6 @@ class FocusStackBunch(ActionList, FocusStackBase):
                                      "overlap must be smaller than batch size")
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)
 
     def begin(self):
@@ -94,6 +92,9 @@ class FocusStackBunch(ActionList, FocusStackBase):
     def run_step(self):
         self.print_message_r(color_str(f"fusing bunch: {self.count + 1}/{self.counts}",
                                        constants.LOG_COLOR_LEVEL_2))
+        img_files = [os.path.join(self.input_full_path, name)
+                     for name in self._chunks[self.count - 1]]
+        self.stack_algo.init(img_files)
         self.focus_stack(self._chunks[self.count - 1])
 
 
@@ -101,13 +102,15 @@ class FocusStack(FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
         super().__init__(name, stack_algo, enabled, **kwargs)
         self.stack_algo.do_step_callback = True
+        self.shape = None
 
     def run_core(self):
         self.set_filelist()
+        img_files = sorted([os.path.join(self.input_full_path, name) for name in self.filenames])
+        self.stack_algo.init(img_files)
         self.callback('step_counts', self.id, self.name,
-                      self.stack_algo.steps_per_frame() * len(self.filenames))
+                      self.stack_algo.total_steps(len(self.filenames)))
         self.focus_stack(self.filenames)
 
     def init(self, job, _working_path=''):
-        FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)