Source code for mantidimaging.core.operations.rebin.rebin

# Copyright (C) 2024 ISIS Rutherford Appleton Laboratory UKRI
# SPDX - License - Identifier: GPL-3.0-or-later
from __future__ import annotations

from functools import partial
from typing import TYPE_CHECKING

import numpy as np
from skimage.transform import resize

from mantidimaging.core.operations.base_filter import BaseFilter
from mantidimaging.core.parallel import utility as pu, shared as ps
from mantidimaging.gui.utility import add_property_to_form
from mantidimaging.gui.utility.qt_helpers import Type

    from import ImageStack

[docs] class RebinFilter(BaseFilter): """Rebin the image to reduce the resolution. This filter temporarily increases memory usage, while the image is being rebinned. The memory usage will be lowered after the filter has finished executing. Intended to be used on: Any data When: If you want to reduce the data size and to smoothen the image. """ filter_name = "Rebin" link_histograms = True
[docs] @staticmethod def filter_func(images: ImageStack, rebin_param=0.5, mode=None, progress=None) -> ImageStack: """ :param images: Sample data which is to be processed. Expects radiograms :param rebin_param: int, float or tuple int - Percentage of current size. float - Fraction of current size. tuple - Size of the output image (x, y). :param mode: The mode with which to handle the edges. One of ('constant', 'edge', 'symmetric', 'reflect', 'wrap'). :return: The processed 3D numpy.ndarray """ if isinstance(rebin_param, tuple): new_shape = rebin_param elif isinstance(rebin_param, (int | float)): current_shape =[1:] new_shape = (int(current_shape[0] * rebin_param), int(current_shape[1] * rebin_param)) else: raise ValueError("Invalid type for rebin_param") output = _create_reshaped_array(images, rebin_param) params = {'new_shape': new_shape, 'mode': mode} ps.run_compute_func(RebinFilter.compute_function,[0], [images.shared_array, output], params, progress) images.shared_array = output return images
[docs] @staticmethod def compute_function(i: int, arrays: list[np.ndarray], params: dict): array = arrays[0] output = arrays[1] new_shape = params['new_shape'] mode = params['mode'] output[i] = resize(array[i], output_shape=new_shape, mode=mode, preserve_range=True)
[docs] @staticmethod def register_gui(form, on_change, view): # Rebin by uniform factor options _, factor = add_property_to_form('Factor', 'float', 0.5, (0.01, 4.0), on_change=on_change, tooltip="Factor by which the data will be rebinned, " "e.g. 0.5 is 50% reduced size", single_step_size=0.05) # Rebin to target shape options shape_range = (1, 9999) _, shape_x = add_property_to_form('X', Type.INT, 100, shape_range, on_change=on_change) _, shape_y = add_property_to_form('Y', Type.INT, 100, shape_range, on_change=on_change) from PyQt5.QtWidgets import QHBoxLayout, QRadioButton, QLabel, QComboBox shape_fields = QHBoxLayout() shape_fields.addWidget(shape_x) shape_fields.addWidget(shape_y) # Rebin dimension selection options rebin_by_factor_radio = QRadioButton("Rebin by Factor") def size_by_factor_toggled(enabled): factor.setEnabled(enabled) on_change() rebin_by_factor_radio.toggled.connect(size_by_factor_toggled) rebin_to_dimensions_radio = QRadioButton("Rebin to Dimensions") def size_by_dimensions_toggled(enabled): shape_x.setEnabled(enabled) shape_y.setEnabled(enabled) on_change() rebin_to_dimensions_radio.toggled.connect(size_by_dimensions_toggled) # Rebin mode options label_mode = QLabel("Mode") mode_field = QComboBox() mode_field.addItems(modes()) form.addRow(rebin_to_dimensions_radio, shape_fields) form.addRow(rebin_by_factor_radio, factor) form.addRow(label_mode, mode_field) # Ensure good default UI state rebin_to_dimensions_radio.setChecked(True) rebin_by_factor_radio.setChecked(True) return { "rebin_to_dimensions_radio": rebin_to_dimensions_radio, "shape_x": shape_x, "shape_y": shape_y, "rebin_by_factor_radio": rebin_by_factor_radio, "factor": factor, "mode_field": mode_field, }
[docs] @staticmethod def execute_wrapper(rebin_to_dimensions_radio=None, shape_x=None, shape_y=None, rebin_by_factor_radio=None, factor=None, mode_field=None): if rebin_to_dimensions_radio.isChecked(): params = (shape_x.value(), shape_y.value()) elif rebin_by_factor_radio.isChecked(): params = factor.value() else: raise ValueError('Unknown bin dimension mode') return partial(RebinFilter.filter_func, mode=mode_field.currentText(), rebin_param=params)
def _create_reshaped_array(images, rebin_param): old_shape = num_images = old_shape[0] # use SciPy's calculation to find the expected dimensions # int to avoid visible deprecation warning if isinstance(rebin_param, tuple): expected_dimy = int(rebin_param[0]) expected_dimx = int(rebin_param[1]) else: expected_dimy = int(rebin_param * old_shape[1]) expected_dimx = int(rebin_param * old_shape[2]) shape = (num_images, expected_dimy, expected_dimx) return pu.create_array(shape, images.dtype)
[docs] def modes(): return ["constant", "edge", "wrap", "reflect", "symmetric"]