shinestacker 0.2.0.post1.dev1__py3-none-any.whl

shinestacker/algorithms/balance.py

@@ -0,0 +1,367 @@
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+from scipy.optimize import bisect
+from scipy.interpolate import interp1d
+from .. config.constants import constants
+from .. core.exceptions import InvalidOptionError
+from .utils import read_img, save_plot
+from .stack_framework import SubAction
+
+
+class CorrectionMapBase:
+    def __init__(self, dtype, ref_hist, intensity_interval=None):
+        intensity_interval = {**constants.DEFAULT_INTENSITY_INTERVAL, **(intensity_interval or {})}
+        self.dtype = dtype
+        self.num_pixel_values = constants.NUM_UINT8 if dtype == np.uint8 else constants.NUM_UINT16
+        self.max_pixel_value = self.num_pixel_values - 1
+        self.id_lut = np.array(list(range(self.num_pixel_values)))
+        i_min, i_max = intensity_interval['min'], intensity_interval['max']
+        self.i_min = i_min
+        self.i_end = i_max + 1 if i_max >= 0 else self.num_pixel_values
+        self.channels = len(ref_hist)
+        self.reference = None
+
+    def lut(self, correction, reference):
+        assert False, 'abstract method'
+
+    def apply_lut(self, correction, reference, img):
+        lut = self.lut(correction, reference)
+        return cv2.LUT(img, lut) if self.dtype == np.uint8 else np.take(lut, img)
+
+    def adjust(self, image, correction):
+        if self.channels == 1:
+            return self.apply_lut(correction[0], self.reference[0], image)
+        else:
+            chans = cv2.split(image)
+            if self.channels == 2:
+                ch_out = [chans[0]] + [self.apply_lut(correction[c - 1], self.reference[c - 1], chans[c]) for c in range(1, 3)]
+            elif self.channels == 3:
+                ch_out = [self.apply_lut(correction[c], self.reference[c], chans[c]) for c in range(3)]
+            return cv2.merge(ch_out)
+
+    def correction_size(self, correction):
+        return correction
+
+
+class MatchHist(CorrectionMapBase):
+    def __init__(self, dtype, ref_hist, intensity_interval=None):
+        CorrectionMapBase.__init__(self, dtype, ref_hist, intensity_interval)
+        self.reference = self.cumsum(ref_hist)
+        self.reference_mean = [r.mean() for r in self.reference]
+        self.values = [*range(self.num_pixel_values)]
+
+    def cumsum(self, hist):
+        return [np.cumsum(h) / h.sum() * self.max_pixel_value for h in hist]
+
+    def lut(self, correction, reference):
+        interp = interp1d(reference, self.values)
+        lut = np.array([interp(v) for v in np.clip(correction, reference.min(), reference.max())])
+        l0, l1 = lut[0], lut[-1]
+        ll = lut[(lut != l0) & (lut != l1)]
+        if ll.size > 0:
+            l_min, l_max = ll.min(), ll.max()
+            i0, i1 = self.id_lut[lut == l0], self.id_lut[lut == l1]
+            i0_max = i0.max()
+            lut[lut == l0] = (i0 / i0_max * l_min) if i0_max > 0 else 0
+            lut[lut == l1] = i1 + (i1 - self.max_pixel_value) * (self.max_pixel_value - l_max) / float(i1.size) if i1.size > 0 else self.max_pixel_value
+        return lut.astype(self.dtype)
+
+    def correction(self, hist):
+        return self.cumsum(hist)
+
+    def correction_size(self, correction):
+        return [c.mean() / m for c, m in zip(correction, self.reference_mean)]
+
+
+class CorrectionMap(CorrectionMapBase):
+    def __init__(self, dtype, ref_hist, intensity_interval=None):
+        CorrectionMapBase.__init__(self, dtype, ref_hist, intensity_interval)
+        self.reference = [self.mid_val(self.id_lut, h) for h in ref_hist]
+
+    def mid_val(self, lut, h):
+        return np.average(lut[self.i_min:self.i_end], weights=h.flatten()[self.i_min:self.i_end])
+
+
+class GammaMap(CorrectionMap):
+    def __init__(self, dtype, ref_hist, intensity_interval=None):
+        CorrectionMap.__init__(self, dtype, ref_hist, intensity_interval)
+
+    def correction(self, hist):
+        return [bisect(lambda x: self.mid_val(self.lut(x), h) - r, 0.1, 5) for h, r in zip(hist, self.reference)]
+
+    def lut(self, correction, reference=None):
+        gamma_inv = 1.0 / correction
+        return (((np.arange(0, self.num_pixel_values) / self.max_pixel_value) ** gamma_inv) * self.max_pixel_value).astype(self.dtype)
+
+
+class LinearMap(CorrectionMap):
+    def __init__(self, dtype, ref_hist, intensity_interval=None):
+        CorrectionMap.__init__(self, dtype, ref_hist, intensity_interval)
+
+    def lut(self, correction, reference=None):
+        return np.clip(np.arange(0, self.num_pixel_values) * correction, 0, self.max_pixel_value).astype(self.dtype)
+
+    def correction(self, hist):
+        return [r / self.mid_val(self.id_lut, h) for h, r in zip(hist, self.reference)]
+
+
+class Correction:
+    def __init__(self, channels, mask_size=0, intensity_interval=None, subsample=-1, 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.corr_map = corr_map
+        self.channels = channels
+
+    def begin(self, ref_image, size, ref_idx):
+        self.dtype = ref_image.dtype
+        self.num_pixel_values = constants.NUM_UINT8 if ref_image.dtype == np.uint8 else constants.NUM_UINT16
+        self.max_pixel_value = self.num_pixel_values - 1
+        hist = self.get_hist(self.preprocess(ref_image), ref_idx)
+        if self.corr_map == constants.BALANCE_LINEAR:
+            self.corr_map = LinearMap(self.dtype, hist, self.intensity_interval)
+        elif self.corr_map == constants.BALANCE_GAMMA:
+            self.corr_map = GammaMap(self.dtype, hist, self.intensity_interval)
+        elif self.corr_map == constants.BALANCE_MATCH_HIST:
+            self.corr_map = MatchHist(self.dtype, hist, self.intensity_interval)
+        else:
+            raise InvalidOptionError("corr_map", self.corr_map)
+        self.corrections = np.ones((size, self.channels))
+
+    def calc_hist_1ch(self, image):
+        if self.mask_size == 0:
+            image_sel = image
+        else:
+            height, width = image.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 = image[(xv - width / 2) ** 2 + (yv - height / 2) ** 2 <= mask_radius ** 2]
+        hist, bins = np.histogram((image_sel if self.subsample == 1
+                                   else image_sel[::self.subsample, ::self.subsample]),
+                                  bins=np.linspace(-0.5, self.num_pixel_values - 0.5,
+                                                   self.num_pixel_values + 1))
+        return hist
+
+    def balance(self, image, idx):
+        correction = self.corr_map.correction(self.get_hist(image, idx))
+        return correction, self.corr_map.adjust(image, correction)
+
+    def get_hist(self, image, idx):
+        assert False, 'abstract method'
+
+    def end(self):
+        assert False, 'abstract method'
+
+    def apply_correction(self, idx, image):
+        image = self.preprocess(image)
+        correction, image = self.balance(image, idx)
+        image = self.postprocess(image)
+        self.corrections[idx] = self.corr_map.correction_size(correction)
+        return image
+
+    def preprocess(self, image):
+        return image
+
+    def postprocess(self, image):
+        return image
+
+    def histo_plot(self, ax, hist, x_label, color, alpha=1):
+        ax.set_ylabel("# of pixels")
+        ax.set_xlabel(x_label)
+        ax.set_xlim([0, self.num_pixel_values])
+        ax.set_yscale('log')
+        ax.plot(hist, color=color, alpha=alpha)
+
+    def save_plot(self, idx):
+        idx_str = "{:04d}".format(idx)
+        plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-hist-{idx_str}.pdf"
+        save_plot(plot_path)
+        plt.close('all')
+        self.process.callback('save_plot', self.process.id, f"{self.process.name}: balance\nframe {idx_str}", plot_path)
+
+    def save_summary_plot(self, name='balance'):
+        plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-{name}.pdf"
+        save_plot(plot_path)
+        plt.close('all')
+        self.process.callback('save_plot', self.process.id, f"{self.process.name}: {name}", plot_path)
+
+
+class LumiCorrection(Correction):
+    def __init__(self, **kwargs):
+        Correction.__init__(self, 1, **kwargs)
+
+    def get_hist(self, image, idx):
+        hist = self.calc_hist_1ch(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
+        chans = cv2.split(image)
+        colors = ("r", "g", "b")
+        if self.plot_histograms:
+            fig, axs = plt.subplots(1, 2, figsize=(10, 5), sharey=True)
+            self.histo_plot(axs[0], hist, "pixel luminosity", 'black')
+            for (chan, color) in zip(chans, colors):
+                hist_col = self.calc_hist_1ch(chan)
+                self.histo_plot(axs[1], hist_col, "r,g,b luminosity", color, alpha=0.5)
+            plt.xlim(0, self.max_pixel_value)
+            self.save_plot(idx)
+        return [hist]
+
+    def end(self, ref_idx):
+        if self.plot_summary:
+            plt.figure(figsize=(10, 5))
+            x = np.arange(1, len(self.corrections) + 1, dtype=int)
+            y = self.corrections
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot(x, y, color='navy', label='luminosity correction')
+            plt.xlabel('frame')
+            plt.ylabel('correction')
+            plt.legend()
+            plt.xlim(x[0], x[-1])
+            plt.ylim(0)
+            self.save_summary_plot()
+
+
+class RGBCorrection(Correction):
+    def __init__(self, **kwargs):
+        Correction.__init__(self, 3, **kwargs)
+
+    def get_hist(self, image, idx):
+        hist = [self.calc_hist_1ch(chan) for chan in cv2.split(image)]
+        colors = ("r", "g", "b")
+        if self.plot_histograms:
+            fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
+            for c in [2, 1, 0]:
+                self.histo_plot(axs[c], hist[c], colors[c] + " luminosity", colors[c])
+            plt.xlim(0, self.max_pixel_value)
+            self.save_plot(idx)
+        return hist
+
+    def end(self, ref_idx):
+        if self.plot_summary:
+            plt.figure(figsize=(10, 5))
+            x = np.arange(1, len(self.corrections) + 1, dtype=int)
+            y = self.corrections
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot(x, y[:, 0], color='r', label='R correction')
+            plt.plot(x, y[:, 1], color='g', label='G correction')
+            plt.plot(x, y[:, 2], color='b', label='B correction')
+            plt.xlabel('frame')
+            plt.ylabel('correction')
+            plt.legend()
+            plt.xlim(x[0], x[-1])
+            plt.ylim(0)
+            self.save_summary_plot()
+
+
+class Ch2Correction(Correction):
+    def __init__(self, **kwargs):
+        Correction.__init__(self, 2, **kwargs)
+
+    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:
+            fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
+            for c in range(3):
+                self.histo_plot(axs[c], hist[c], self.labels[c], self.colors[c])
+            plt.xlim(0, self.max_pixel_value)
+            self.save_plot(idx)
+        return hist[1:]
+
+    def end(self, ref_idx):
+        if self.plot_summary:
+            plt.figure(figsize=(10, 5))
+            x = np.arange(1, len(self.corrections) + 1, dtype=int)
+            y = self.corrections
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot(x, y[:, 0], color=self.colors[1], label=self.labels[1] + ' correction')
+            plt.plot(x, y[:, 1], color=self.colors[2], label=self.labels[2] + ' correction')
+            plt.xlabel('frame')
+            plt.ylabel('correction')
+            plt.legend()
+            plt.xlim(x[0], x[-1])
+            plt.ylim(0)
+            self.save_summary_plot()
+
+
+class SVCorrection(Ch2Correction):
+    def __init__(self, **kwargs):
+        Ch2Correction.__init__(self, **kwargs)
+        self.labels = ("H", "S", "V")
+        self.colors = ("hotpink", "orange", "navy")
+
+    def preprocess(self, image):
+        return cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    def postprocess(self, image):
+        return cv2.cvtColor(image, cv2.COLOR_HSV2BGR)
+
+
+class LSCorrection(Ch2Correction):
+    def __init__(self, **kwargs):
+        Ch2Correction.__init__(self, **kwargs)
+        self.labels = ("H", "L", "S")
+        self.colors = ("hotpink", "navy", "orange")
+
+    def preprocess(self, image):
+        return cv2.cvtColor(image, cv2.COLOR_BGR2HLS)
+
+    def postprocess(self, image):
+        return cv2.cvtColor(image, cv2.COLOR_HLS2BGR)
+
+
+class BalanceFrames(SubAction):
+    def __init__(self, enabled=True, **kwargs):
+        super().__init__(enabled=enabled)
+        corr_map = kwargs.get('corr_map', constants.DEFAULT_CORR_MAP)
+        subsample = kwargs.get('subsample', constants.DEFAULT_BALANCE_SUBSAMPLE)
+        channel = kwargs.pop('channel', constants.DEFAULT_CHANNEL)
+        kwargs['subsample'] = (1 if corr_map == constants.BALANCE_MATCH_HIST else constants.DEFAULT_BALANCE_SUBSAMPLE) if subsample == -1 else subsample
+        self.mask_size = kwargs.get('mask_size', 0)
+        self.plot_summary = kwargs.get('plot_summary', False)
+        if channel == constants.BALANCE_LUMI:
+            self.correction = LumiCorrection(**kwargs)
+        elif channel == constants.BALANCE_RGB:
+            self.correction = RGBCorrection(**kwargs)
+        elif channel == constants.BALANCE_HSV:
+            self.correction = SVCorrection(**kwargs)
+        elif channel == constants.BALANCE_HLS:
+            self.correction = LSCorrection(**kwargs)
+        else:
+            raise InvalidOptionError("channel", channel)
+
+    def begin(self, process):
+        self.process = process
+        self.correction.process = process
+        img = read_img(self.process.input_full_path + "/" + self.process.filenames[process.ref_idx])
+        self.shape = img.shape
+        self.correction.begin(img, self.process.counts, process.ref_idx)
+
+    def end(self):
+        self.process.print_message(' ' * 60)
+        self.correction.end(self.process.ref_idx)
+        if self.plot_summary and self.mask_size > 0:
+            shape = self.shape[:2]
+            img = np.zeros(shape)
+            mask_radius = int(min(*shape) * self.mask_size / 2)
+            cv2.circle(img, (shape[1] // 2, shape[0] // 2), mask_radius, 255, -1)
+            plt.figure(figsize=(10, 5))
+            plt.title('Mask')
+            plt.imshow(img, 'gray')
+            self.correction.save_summary_plot("mask")
+
+    def run_frame(self, idx, ref_idx, image):
+        if idx != self.process.ref_idx:
+            self.process.sub_message_r(': balance image')
+            image = self.correction.apply_correction(idx, image)
+        return image

shinestacker/algorithms/core_utils.py

@@ -0,0 +1,22 @@
+import os
+from config.config import config
+
+if not config.DISABLE_TQDM:
+    from tqdm import tqdm
+    from tqdm.notebook import tqdm_notebook
+
+
+def check_path_exists(path):
+    if not os.path.exists(path):
+        raise Exception('Path does not exist: ' + path)
+
+
+def make_tqdm_bar(name, size, ncols=80):
+    if not config.DISABLE_TQDM:
+        if config.JUPYTER_NOTEBOOK:
+            bar = tqdm_notebook(desc=name, total=size)
+        else:
+            bar = tqdm(desc=name, total=size, ncols=ncols)
+        return bar
+    else:
+        return None

shinestacker/algorithms/depth_map.py

@@ -0,0 +1,164 @@
+import numpy as np
+import cv2
+from .. config.constants import constants
+from .. core.colors import color_str
+from .. core.exceptions import ImageLoadError, InvalidOptionError, RunStopException
+from .utils import read_img, get_img_metadata, validate_image, img_bw
+
+
+class DepthMapStack:
+    def __init__(self, map_type=constants.DEFAULT_DM_MAP, energy=constants.DEFAULT_DM_ENERGY,
+                 kernel_size=constants.DEFAULT_DM_KERNEL_SIZE, blur_size=constants.DEFAULT_DM_BLUR_SIZE,
+                 smooth_size=constants.DEFAULT_DM_SMOOTH_SIZE, temperature=constants.DEFAULT_DM_TEMPERATURE,
+                 levels=constants.DEFAULT_DM_LEVELS, float_type=constants.DEFAULT_DM_FLOAT):
+        self.map_type = map_type
+        self.energy = energy
+        self.kernel_size = kernel_size
+        self.blur_size = blur_size
+        self.smooth_size = smooth_size
+        self.temperature = temperature
+        self.levels = levels
+        if float_type == constants.FLOAT_32:
+            self.float_type = np.float32
+        elif float_type == constants.FLOAT_64:
+            self.float_type = np.float64
+        else:
+            raise InvalidOptionError("float_type", float_type, details=" valid values are FLOAT_32 and FLOAT_64")
+
+    def name(self):
+        return "depth map"
+
+    def steps_per_frame(self):
+        return 2
+
+    def print_message(self, msg):
+        self.process.sub_message_r(color_str(msg, "light_blue"))
+
+    def get_sobel_map(self, gray_images):
+        energies = np.zeros(gray_images.shape, dtype=self.float_type)
+        for i in range(gray_images.shape[0]):
+            img = gray_images[i]
+            energies[i] = np.abs(cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)) + \
+                np.abs(cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3))
+        return energies
+
+    def get_laplacian_map(self, gray_images):
+        laplacian = np.zeros(gray_images.shape, dtype=self.float_type)
+        for i in range(gray_images.shape[0]):
+            blurred = cv2.GaussianBlur(gray_images[i], (self.blur_size, self.blur_size), 0)
+            laplacian[i] = np.abs(cv2.Laplacian(blurred, cv2.CV_64F, ksize=self.kernel_size))
+        return laplacian
+
+    def smooth_energy(self, energy_map):
+        if self.smooth_size <= 0:
+            return energy_map
+        smoothed = np.zeros(energy_map.shape, dtype=np.float32)
+        for i in range(energy_map.shape[0]):
+            energy_32f = energy_map[i].astype(np.float32)
+            smoothed_32f = cv2.bilateralFilter(energy_32f, self.smooth_size, 25, 25)
+            smoothed[i] = smoothed_32f.astype(energy_map.dtype)
+        return smoothed
+
+    def get_focus_map(self, energies):
+        if self.map_type == constants.DM_MAP_AVERAGE:
+            sum_energies = np.sum(energies, axis=0)
+            return np.divide(energies, sum_energies, where=sum_energies != 0)
+        elif self.map_type == constants.DM_MAP_MAX:
+            max_energy = np.max(energies, axis=0)
+            relative = np.exp((energies - max_energy) / self.temperature)
+            return relative / np.sum(relative, axis=0)
+        else:
+            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
+        for i, img_path in enumerate(filenames):
+            self.print_message(': reading file (1/2) {}'.format(img_path.split('/')[-1]))
+            img = read_img(img_path)
+            if img is None:
+                raise ImageLoadError(img_path)
+            if metadata is None:
+                metadata = get_img_metadata(img)
+            else:
+                validate_image(img, *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)
+        dtype = metadata[1]
+        gray_images = np.array(gray_images, dtype=self.float_type)
+        if self.energy == constants.DM_ENERGY_SOBEL:
+            energies = self.get_sobel_map(gray_images)
+        elif self.energy == constants.DM_ENERGY_LAPLACIAN:
+            energies = self.get_laplacian_map(gray_images)
+        else:
+            raise InvalidOptionError('energy', self.energy, details=f" valid values are "
+                                     f"{constants.DM_ENERGY_SOBEL} and {constants.DM_ENERGY_LAPLACIAN}.")
+        max_energy = np.max(energies)
+        if max_energy > 0:
+            energies = energies / max_energy
+        if self.smooth_size > 0:
+            energies = self.smooth_energy(energies)
+        weights = self.get_focus_map(energies)
+        blended_pyramid = None
+        for i, img_path in enumerate(filenames):
+            self.print_message(': reading file (2/2) {}'.format(img_path.split('/')[-1]))
+            img = read_img(img_path).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 = [lp_img[j] * gp_weight[self.levels - 1 - j][..., np.newaxis]
+                             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)
+        result = blended_pyramid[0]
+        self.print_message(': blend levels')
+        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
+        return np.clip(np.absolute(result), 0, n_values).astype(dtype)