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

shinestacker/algorithms/base_stack_algo.py

@@ -28,6 +28,12 @@ class BaseStackAlgo:
     def name(self):
         return self._name
 
+    def set_process(self, process):
+        self.process = process
+
+    def set_do_step_callback(self, enable):
+        self.do_step_callback = enable
+
     def init(self, filenames):
         self.filenames = filenames
         first_img_file = ''

shinestacker/algorithms/depth_map.py

@@ -116,5 +116,5 @@ class DepthMapStack(BaseStackAlgo):
         for j in range(1, self.levels):
             size = (blended_pyramid[j].shape[1], blended_pyramid[j].shape[0])
             result = cv2.pyrUp(result, dstsize=size) + blended_pyramid[j]
-        n_values = 255 if dtype == np.uint8 else 65535
+        n_values = constants.MAX_UINT8 if dtype == np.uint8 else constants.MAX_UINT16
         return np.clip(np.absolute(result), 0, n_values).astype(dtype)

shinestacker/algorithms/multilayer.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, E0606
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, E0606, R0912
 import os
 import logging
 import cv2
@@ -14,7 +14,7 @@ from .. config.config import config
 from .. core.colors import color_str
 from .. core.framework import JobBase
 from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
-from .stack_framework import FrameMultiDirectory
+from .stack_framework import FramePaths
 from .exif import exif_extra_tags_for_tif, get_exif
 
 
@@ -61,6 +61,13 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
     if len(dtypes) > 1:
         raise RuntimeError("All input files must all have 8 bit or 16 bit depth.")
     dtype = dtypes[0]
+    bytes_per_pixel = 3 * np.dtype(dtype).itemsize
+    est_memory = shape[0] * shape[1] * bytes_per_pixel * len(image_dict)
+    if est_memory > constants.MULTILAYER_WARNING_MEM_GB * constants.ONE_GIGA:
+        if callbacks:
+            callback = callbacks.get('memory_warning', None)
+            if callback:
+                callback(float(est_memory) / constants.ONE_GIGA)
     max_pixel_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
     transp = np.full_like(list(image_dict.values())[0][..., 0], max_pixel_value)
     compression_type = PsdCompressionType.ZIP_PREDICTED
@@ -152,9 +159,9 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
                      compression=compression, metadata=None, **tiff_tags)
 
 
-class MultiLayer(JobBase, FrameMultiDirectory):
+class MultiLayer(JobBase, FramePaths):
     def __init__(self, name, enabled=True, **kwargs):
-        FrameMultiDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
         self.exif_path = kwargs.get('exif_path', '')
         self.reverse_order = kwargs.get(
@@ -163,16 +170,16 @@ class MultiLayer(JobBase, FrameMultiDirectory):
         )
 
     def init(self, job):
-        FrameMultiDirectory.init(self, job)
+        FramePaths.init(self, job)
         if self.exif_path == '':
             self.exif_path = job.paths[0]
         if self.exif_path != '':
             self.exif_path = self.working_path + "/" + self.exif_path
 
     def run_core(self):
-        if isinstance(self.input_full_path, str):
+        if isinstance(self.input_full_path(), str):
             paths = [self.input_path]
-        elif hasattr(self.input_full_path, "__len__"):
+        elif hasattr(self.input_full_path(), "__len__"):
             paths = self.input_path
         else:
             raise RuntimeError("input_path option must contain a path or an array of paths")
@@ -181,8 +188,8 @@ class MultiLayer(JobBase, FrameMultiDirectory):
                                          constants.LOG_COLOR_ALERT),
                                level=logging.WARNING)
             return
-        files = self.folder_filelist()
-        if len(files) == 0:
+        input_files = self.input_filepaths()
+        if len(input_files) == 0:
             self.print_message(
                 color_str(f"no input in {len(paths)} specified path" +
                           ('s' if len(paths) > 1 else '') + ": "
@@ -192,18 +199,20 @@ class MultiLayer(JobBase, FrameMultiDirectory):
             return
         self.print_message(color_str("merging frames in " + self.folder_list_str(),
                            constants.LOG_COLOR_LEVEL_2))
-        input_files = [f"{self.working_path}/{f}" for f in files]
         self.print_message(
-            color_str("frames: " + ", ".join([i.split("/")[-1] for i in files]),
+            color_str("frames: " + ", ".join([os.path.basename(i) for i in input_files]),
                       constants.LOG_COLOR_LEVEL_2))
         self.print_message(color_str("reading files", constants.LOG_COLOR_LEVEL_2))
-        filename = ".".join(files[0].split("/")[-1].split(".")[:-1])
+        filename = ".".join(os.path.basename(input_files[0]).split(".")[:-1])
         output_file = f"{self.working_path}/{self.output_path}/{filename}.tif"
         callbacks = {
             'exif_msg': lambda path: self.print_message(
                 color_str(f"copying exif data from path: {path}", constants.LOG_COLOR_LEVEL_2)),
             'write_msg': lambda path: self.print_message(
-                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2))
+                color_str(f"writing multilayer tiff file: {path}", constants.LOG_COLOR_LEVEL_2)),
+            'memory_warning': lambda mem: self.print_message(
+                color_str(f"warning: estimated file size: {mem:.2f} GBytes",
+                          constants.LOG_COLOR_WARNING))
         }
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)

shinestacker/algorithms/noise_detection.py

@@ -12,7 +12,7 @@ from .. core.exceptions import ImageLoadError
 from .. core.framework import JobBase
 from .. core.core_utils import make_tqdm_bar
 from .. core.exceptions import RunStopException, ShapeError
-from .stack_framework import FrameMultiDirectory, SubAction
+from .stack_framework import FramePaths, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
 MAX_NOISY_PIXELS = 1000
@@ -45,11 +45,11 @@ def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callba
     return None if mean_img is None else (mean_img / counter).astype(np.uint8)
 
 
-class NoiseDetection(JobBase, FrameMultiDirectory):
+class NoiseDetection(JobBase, FramePaths):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
-        FrameMultiDirectory.__init__(self, name, **kwargs)
+        FramePaths.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
-        self.max_frames = kwargs.get('max_frames', -1)
+        self.max_frames = kwargs.get('max_frames', constants.DEFAULT_NOISE_MAX_FRAMES)
         self.blur_size = kwargs.get('blur_size', constants.DEFAULT_BLUR_SIZE)
         self.file_name = kwargs.get('file_name', constants.DEFAULT_NOISE_MAP_FILENAME)
         if self.file_name == '':
@@ -76,8 +76,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
             f"map noisy pixels from frames in {self.folder_list_str()}",
             constants.LOG_COLOR_LEVEL_2
         ))
-        files = self.folder_filelist()
-        in_paths = [self.working_path + "/" + f for f in files]
+        in_paths = self.input_filepaths()
         n_frames = min(len(in_paths), self.max_frames) if self.max_frames > 0 else len(in_paths)
         self.callback('step_counts', self.id, self.name, n_frames)
         if not config.DISABLE_TQDM:
@@ -90,7 +89,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
             message_callback=lambda path: self.print_message_r(
-                color_str(f"reading frame: {path.split('/')[-1]}", constants.LOG_COLOR_LEVEL_2)
+                color_str(f"reading frame: {os.path.basename(path)}", constants.LOG_COLOR_LEVEL_2)
             ),
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
@@ -123,7 +122,7 @@ class NoiseDetection(JobBase, FrameMultiDirectory):
             plot_range[1] = max_th + 1
         th_range = np.arange(self.plot_range[0], self.plot_range[1] + 1)
         if self.plot_histograms:
-            plt.figure(figsize=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             x = np.array(list(th_range))
             ys = [[np.count_nonzero(self.hot_map(ch, th) > 0)
                   for th in th_range] for ch in channels]

shinestacker/algorithms/pyramid.py

@@ -124,8 +124,9 @@ class PyramidBase(BaseStackAlgo):
 
     def focus_stack_validate(self, cleanup_callback=None):
         metadata = None
+        n = len(self.filenames)
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": validating file {img_path.split('/')[-1]}")
+            self.print_message(f": validating file {img_path.split('/')[-1]}, {i + 1}/{n}")
 
             _img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
             if updated:
@@ -184,7 +185,7 @@ class PyramidStack(PyramidBase):
         self.focus_stack_validate()
         all_laplacians = []
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": processing file {img_path.split('/')[-1]}")
+            self.print_message(f": processing file {img_path.split('/')[-1]} ({i + 1}/{n})")
             img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, self.n_levels))
             self.after_step(i + n + 1)

shinestacker/algorithms/pyramid_auto.py

@@ -0,0 +1,141 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0913, R0902, R0914, R0917
+import os
+import numpy as np
+from .. config.constants import constants
+from .utils import extension_tif_jpg
+from .base_stack_algo import BaseStackAlgo
+from .pyramid import PyramidStack
+from .pyramid_tiles import PyramidTilesStack
+
+
+class PyramidAutoStack(BaseStackAlgo):
+    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,
+                 n_tiled_layers=constants.DEFAULT_PY_N_TILED_LAYERS,
+                 memory_limit=constants.DEFAULT_PY_MEMORY_LIMIT_GB,
+                 max_threads=constants.DEFAULT_PY_MAX_THREADS,
+                 max_tile_size=2048,
+                 min_n_tiled_layers=1,
+                 mode='auto'):
+        super().__init__("auto_pyramid", 2, float_type)
+        self.min_size = min_size
+        self.kernel_size = kernel_size
+        self.gen_kernel = gen_kernel
+        self.float_type = float_type
+        self.tile_size = tile_size
+        self.n_tiled_layers = n_tiled_layers
+        self.memory_limit = memory_limit * constants.ONE_GIGA
+        self.max_threads = max_threads
+        available_cores = os.cpu_count() or 1
+        self.num_threads = min(max_threads, available_cores)
+        self.max_tile_size = max_tile_size
+        self.min_n_tiled_layers = min_n_tiled_layers
+        self.mode = mode
+        self._implementation = None
+        self.dtype = None
+        self.shape = None
+        self.n_levels = None
+        self.n_frames = 0
+        self.channels = 3
+        dtype = np.float32 if self.float_type == constants.FLOAT_32 else np.float64
+        self.bytes_per_pixel = self.channels * np.dtype(dtype).itemsize
+        self.overhead = 1.5
+
+    def init(self, 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")
+        _img, metadata, _ = self.read_image_and_update_metadata(first_img_file, None)
+        self.shape, self.dtype = metadata
+        self.n_levels = int(np.log2(min(self.shape) / self.min_size))
+        self.n_frames = len(filenames)
+        memory_required_memory = self._estimate_memory_memory()
+        if self.mode == 'memory' or (self.mode == 'auto' and
+                                     memory_required_memory <= self.memory_limit):
+            self._implementation = PyramidStack(
+                min_size=self.min_size,
+                kernel_size=self.kernel_size,
+                gen_kernel=self.gen_kernel,
+                float_type=self.float_type
+            )
+            self.print_message(": using memory-based pyramid stacking")
+        else:
+            optimal_params = self._find_optimal_tile_params()
+            self._implementation = PyramidTilesStack(
+                min_size=self.min_size,
+                kernel_size=self.kernel_size,
+                gen_kernel=self.gen_kernel,
+                float_type=self.float_type,
+                tile_size=optimal_params['tile_size'],
+                n_tiled_layers=optimal_params['n_tiled_layers'],
+                max_threads=self.num_threads
+            )
+            self.print_message(f": using tile-based pyramid stacking "
+                               f"(tile_size: {optimal_params['tile_size']}, "
+                               f"n_tiled_layers: {optimal_params['n_tiled_layers']}), "
+                               f"{self.num_threads} cores.")
+        self._implementation.init(filenames)
+        self._implementation.set_do_step_callback(self.do_step_callback)
+        if self.process is not None:
+            self._implementation.set_process(self.process)
+        else:
+            raise RuntimeError("self.process must be initialized.")
+
+    def _estimate_memory_memory(self):
+        h, w = self.shape[:2]
+        total_memory = 0
+        for _ in range(self.n_levels):
+            total_memory += h * w * self.bytes_per_pixel
+            h, w = max(1, h // 2), max(1, w // 2)
+        return self.overhead * total_memory * self.n_frames
+
+    def _find_optimal_tile_params(self):
+        tile_size_max = int(np.sqrt(self.memory_limit /
+                            (self.num_threads * self.n_frames *
+                             self.bytes_per_pixel * self.overhead)))
+        tile_size = min(self.max_tile_size, tile_size_max, self.shape[0], self.shape[1])
+        n_tiled_layers = 0
+        for layer in range(self.n_levels):
+            h = max(1, self.shape[0] // (2 ** layer))
+            w = max(1, self.shape[1] // (2 ** layer))
+            if h > tile_size or w > tile_size:
+                n_tiled_layers = layer + 1
+            else:
+                break
+        n_tiled_layers = max(n_tiled_layers, self.min_n_tiled_layers)
+        n_tiled_layers = min(n_tiled_layers, self.n_levels)
+        return {'tile_size': tile_size, 'n_tiled_layers': n_tiled_layers}
+
+    def set_process(self, process):
+        super().set_process(process)
+        if self._implementation is not None:
+            self._implementation.set_process(process)
+
+    def total_steps(self, n_frames):
+        if self._implementation is None:
+            return super().total_steps(n_frames)
+        return self._implementation.total_steps(n_frames)
+
+    def focus_stack(self):
+        if self._implementation is None:
+            raise RuntimeError("PyramidAutoStack not initialized")
+        return self._implementation.focus_stack()
+
+    def after_step(self, step):
+        if self._implementation is not None:
+            self._implementation.after_step(step)
+        else:
+            super().after_step(step)
+
+    def check_running(self, cleanup_callback=None):
+        if self._implementation is not None:
+            self._implementation.check_running(cleanup_callback)
+        else:
+            super().check_running(cleanup_callback)

shinestacker/algorithms/pyramid_tiles.py

@@ -1,8 +1,14 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913, R0917, R0912, R0915
+
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R1702, R1732, R0913
+# pylint: disable=R0917, R0912, R0915, R0902, W0718
 import os
+import time
+import shutil
 import tempfile
+import concurrent.futures
 import numpy as np
 from .. config.constants import constants
+from .. core.exceptions import RunStopException
 from .utils import read_img
 from .pyramid import PyramidBase
 
@@ -12,35 +18,144 @@ class PyramidTilesStack(PyramidBase):
                  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):
+                 tile_size=constants.DEFAULT_PY_TILE_SIZE,
+                 n_tiled_layers=constants.DEFAULT_PY_N_TILED_LAYERS,
+                 max_threads=constants.DEFAULT_PY_MAX_THREADS):
         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.n_tiled_layers = n_tiled_layers
         self.temp_dir = tempfile.TemporaryDirectory()
         self.n_tiles = 0
+        self.level_shapes = {}
+        available_cores = os.cpu_count() or 1
+        self.num_threads = max(1, min(max_threads, available_cores))
 
     def init(self, filenames):
         super().init(filenames)
-        self.n_tiles = (self.shape[0] // self.tile_size + 1) * (self.shape[1] // self.tile_size + 1)
+        self.n_tiles = 0
+        for layer in range(self.n_tiled_layers):
+            h, w = max(1, self.shape[0] // (2 ** layer)), max(1, self.shape[1] // (2 ** layer))
+            self.n_tiles += (h // self.tile_size + 1) * (w // 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_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
+
     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)
+        self.level_shapes[img_index] = [level.shape for level in laplacian[::-1]]
+        for level_idx, level_data in enumerate(laplacian[::-1]):
+            h, w = level_data.shape[:2]
+            if level_idx < self.n_tiled_layers:
+                for y in range(0, h, self.tile_size):
+                    for x in range(0, w, self.tile_size):
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        tile = level_data[y:y_end, x:x_end]
+                        np.save(
+                            os.path.join(
+                                self.temp_dir.name,
+                                f'img_{img_index}_level_{level_idx}_tile_{y}_{x}.npy'),
+                            tile
+                        )
+            else:
+                np.save(
+                    os.path.join(self.temp_dir.name,
+                                 f'img_{img_index}_level_{level_idx}.npy'), level_data)
         return len(laplacian)
 
+    def load_level_tile(self, img_index, level, y, x):
+        return np.load(
+            os.path.join(self.temp_dir.name,
+                         f'img_{img_index}_level_{level}_tile_{y}_{x}.npy'))
+
     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()
+        try:
+            self.temp_dir.cleanup()
+        except Exception:
+            try:
+                shutil.rmtree(self.temp_dir.name, ignore_errors=True)
+            except Exception:
+                pass
+
+    def _fuse_level_tiles_serial(self, level, num_images, all_level_counts, h, w, count):
+        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, x_end = min(y + self.tile_size, h), 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]:
+                        try:
+                            tile = self.load_level_tile(img_index, level, y, x)
+                            laplacians.append(tile)
+                        except FileNotFoundError:
+                            continue
+                if laplacians:
+                    stacked = np.stack(laplacians, axis=0)
+                    fused_tile = self.fuse_laplacian(stacked)
+                    fused_level[y:y_end, x:x_end] = fused_tile
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _fuse_level_tiles_parallel(self, level, num_images, all_level_counts, h, w, count):
+        fused_level = np.zeros((h, w, 3), dtype=self.float_type)
+        tiles = []
+        for y in range(0, h, self.tile_size):
+            for x in range(0, w, self.tile_size):
+                tiles.append((y, x))
+        self.print_message(f': starting parallel propcessging on {self.num_threads} cores')
+        with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads) as executor:
+            future_to_tile = {
+                executor.submit(
+                    self._process_tile, level, num_images, all_level_counts, y, x, h, w): (y, x)
+                for y, x in tiles
+            }
+            for future in concurrent.futures.as_completed(future_to_tile):
+                y, x = future_to_tile[future]
+                try:
+                    fused_tile = future.result()
+                    if fused_tile is not None:
+                        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+                        fused_level[y:y_end, x:x_end] = fused_tile
+                        self.print_message(f': fused tile [{x}, {x_end - 1}]×[{y}, {y_end - 1}]')
+                except Exception as e:
+                    self.print_message(f"Error processing tile ({y}, {x}): {str(e)}")
+                self.after_step(count)
+                self.check_running(self.cleanup_temp_files)
+                count += 1
+        return fused_level, count
+
+    def _process_tile(self, level, num_images, all_level_counts, y, x, h, w):
+        laplacians = []
+        for img_index in range(num_images):
+            if level < all_level_counts[img_index]:
+                try:
+                    tile = self.load_level_tile(img_index, level, y, x)
+                    laplacians.append(tile)
+                except FileNotFoundError:
+                    continue
+        if laplacians:
+            stacked = np.stack(laplacians, axis=0)
+            return self.fuse_laplacian(stacked)
+        y_end, x_end = min(y + self.tile_size, h), min(x + self.tile_size, w)
+        return np.zeros((y_end - y, x_end - x, 3), dtype=self.float_type)
 
     def fuse_pyramids(self, all_level_counts, num_images):
         max_levels = max(all_level_counts)
@@ -48,30 +163,20 @@ class PyramidTilesStack(PyramidBase):
         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
+            if level < self.n_tiled_layers:
+                h, w = None, None
+                for img_index in range(num_images):
+                    if level < all_level_counts[img_index]:
+                        h, w = self.level_shapes[img_index][level][:2]
+                        break
+                if h is None or w is None:
+                    continue
+                if self.num_threads > 1:
+                    fused_level, count = self._fuse_level_tiles_parallel(
+                        level, num_images, all_level_counts, h, w, count)
+                else:
+                    fused_level, count = self._fuse_level_tiles_serial(
+                        level, num_images, all_level_counts, h, w, count)
             else:
                 laplacians = []
                 for img_index in range(num_images):
@@ -84,26 +189,76 @@ class PyramidTilesStack(PyramidBase):
                 else:
                     stacked = np.stack(laplacians, axis=0)
                     fused_level = self.fuse_laplacian(stacked)
-                    self.check_running(self.cleanup_temp_files)
+                self.check_running(lambda: None)
             fused.append(fused_level)
             count += 1
             self.after_step(count)
-            self.check_running(self.cleanup_temp_files)
+            self.check_running(lambda: None)
         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)
+        all_level_counts = [0] * n
+        if self.num_threads > 1:
+            self.print_message(f': starting parallel image processing on {self.num_threads} cores')
+            args_list = [(file_path, i, n) for i, file_path in enumerate(self.filenames)]
+            executor = None
+            try:
+                executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads)
+                future_to_index = {
+                    executor.submit(self._process_single_image_wrapper, args): i
+                    for i, args in enumerate(args_list)
+                }
+                completed_count = 0
+                for future in concurrent.futures.as_completed(future_to_index):
+                    i = future_to_index[future]
+                    try:
+                        img_index, level_count = future.result()
+                        all_level_counts[img_index] = level_count
+                        completed_count += 1
+                        self.print_message(f': completed processing image {completed_count}/{n}')
+                    except Exception as e:
+                        self.print_message(f"Error processing image {i + 1}: {str(e)}")
+                    self.after_step(i + n + 1)
+                    self.check_running(lambda: None)
+            except RunStopException:
+                self.print_message(": stopping image processing...")
+                if executor:
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    time.sleep(0.5)
+                    self._safe_cleanup()
+                raise
+            finally:
+                if executor:
+                    executor.shutdown(wait=True)
+        else:
+            for i, file_path in enumerate(self.filenames):
+                self.print_message(f": processing file {file_path.split('/')[-1]}, {i + 1}/{n}")
+                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.check_running(lambda: None)
+        try:
+            self.check_running(lambda: None)
+            fused_pyramid = self.fuse_pyramids(all_level_counts, n)
+            stacked_image = self.collapse(fused_pyramid)
+            return stacked_image.astype(self.dtype)
+        except RunStopException:
+            self.print_message(": stopping pyramid fusion...")
+            raise
+        finally:
+            self._safe_cleanup()
+
+    def _safe_cleanup(self):
+        try:
+            self.cleanup_temp_files()
+        except Exception as e:
+            self.print_message(f": warning during cleanup: {str(e)}")
+            time.sleep(1)
+            try:
+                self.cleanup_temp_files()
+            except Exception:
+                self.print_message(": could not fully clean up temporary files")