Source code for mantidimaging.gui.windows.image_load_dialog.presenter

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

from logging import getLogger
from pathlib import Path
from typing import TYPE_CHECKING

from mantidimaging.core.io.filenames import FilenameGroup
from mantidimaging.core.io.loader import load_log
from mantidimaging.core.io.loader.loader import LoadingParameters, ImageParameters, read_image_dimensions
from mantidimaging.core.utility.data_containers import FILE_TYPES, log_for_file_type, shuttercounts_for_file_type
from mantidimaging.gui.windows.image_load_dialog.field import Field

if TYPE_CHECKING:
    from mantidimaging.gui.windows.image_load_dialog import ImageLoadDialog  # pragma: no cover

logger = getLogger(__name__)


[docs] class LoadPresenter: view: ImageLoadDialog sample_fg: FilenameGroup | None = None def __init__(self, view: ImageLoadDialog): self.view = view self.image_format = '' self.single_mem = 0 self.dtype = '32'
[docs] def do_update_field(self, field: Field) -> None: """ Called when user clicks select button. Does nothing if the select file dialog is canceled. """ name = field.file_info.fname is_image_file = field.file_info.mode not in ["log", "ShutterCount"] selected_file = self.view.select_file(name, is_image_file) if selected_file is None: # When select file is canceled return if field.file_info.mode == "sample": self.do_update_sample(selected_file) elif field.file_info.mode == "images": self.do_update_flat_or_dark(field, selected_file) elif field.file_info.fname == "Sample Log": self.do_update_sample_log(field, selected_file) elif field.file_info.mode in ["Sample Shutter Counts", "ShutterCount"]: self.do_update_shutter_counts(field, selected_file) elif field.file_info.mode in ["log", "180"]: self._update_field_action(field, selected_file)
[docs] def do_update_sample(self, selected_file: str) -> None: """ Updates the memory usage and the indices in the dialog. """ sample_field = self.view.fields[FILE_TYPES.SAMPLE.fname] sample = FilenameGroup.from_file(Path(selected_file)) self.sample_fg = sample self.update_field_with_filegroup(FILE_TYPES.SAMPLE, sample) sample_field.widget.setExpanded(True) sample_shape = read_image_dimensions(Path(selected_file)) self.view.sample.update_indices(len(sample.all_indexes)) self.view.sample.update_shape(sample_shape) self.view.enable_preview_all_buttons() self.view.ok_button.setEnabled(True) for file_info in FILE_TYPES: if file_info.mode in ["images", "180"]: related_group = sample.find_related(file_info) if related_group: self.update_field_with_filegroup(file_info, related_group)
[docs] def update_field_with_filegroup(self, file_info: FILE_TYPES, file_group: FilenameGroup): """ Update the field with the given file group by finding all files in the group and setting them in the field. :param file_info (FILE_TYPES): The file information. :param file_group (FilenameGroup): The file group containing the files. :return None """ file_group.find_all_files() # find all files in the group to register related file parsers self.view.fields[file_info.fname].set_images(list(file_group.all_files())) self._update_field(file_info, file_group, log_for_file_type, 'find_log_file', 'log_path') self._update_field(file_info, file_group, shuttercounts_for_file_type, 'find_shutter_count_file', 'shutter_count_path')
def _update_field(self, file_info, file_group, file_type_dict, find_file_method, file_path_attr): if file_info in file_type_dict: getattr(file_group, find_file_method)() if getattr(file_group, file_path_attr): field = self.view.fields[file_type_dict[file_info].fname] field.path = getattr(file_group, file_path_attr) field.use = True
[docs] def do_update_shutter_counts(self, field: Field, selected_file: str) -> None: """ Updates the shutter counts for the selected file. :param field (Field): The field to update with the shutter counts. :param selected_file (str): The path of the selected file. :return None """ filename_group = FilenameGroup.from_file(Path(selected_file)) filename_group.find_shutter_count_file() field.set_images(list(filename_group.all_files())) self._update_field_action(field, selected_file) self.ensure_sample_shuttercount_consistency(field, selected_file)
[docs] def ensure_sample_shuttercount_consistency(self, field: Field, file_name: str) -> None: if file_name is None or file_name == "": return self._update_field_action(field, file_name)
[docs] def do_update_flat_or_dark(self, field: Field, selected_file: str) -> None: """ Update the field with the images from the selected file. :param field (Field): The field to update. :param selected_file (str): The path of the selected file. :return None """ filename_group = FilenameGroup.from_file(Path(selected_file)) filename_group.find_all_files() field.set_images(list(filename_group.all_files()))
[docs] def get_parameters(self) -> LoadingParameters: """ Get the loading parameters for the selected sample. :return LoadingParameters: The loading parameters for the selected sample. :raises RuntimeError: If no sample is selected. """ sample_field = self.view.fields[FILE_TYPES.SAMPLE.fname] if sample_field.path is None: raise RuntimeError("No sample selected") loading_param = LoadingParameters() for file_type in FILE_TYPES: self._update_loading_param(file_type, loading_param) loading_param.name = sample_field.path.name loading_param.pixel_size = self.view.pixelSize.value() loading_param.dtype = self.view.pixel_bit_depth.currentText() loading_param.sinograms = self.view.images_are_sinograms.isChecked() return loading_param
def _update_loading_param(self, file_type: FILE_TYPES, loading_param: LoadingParameters): """ Update the loading parameters for a specific file type. :param file_type: The type of the file being loaded. :param loading_param: The loading parameters object. :return None """ if file_type.mode in ["log", "ShutterCount"]: return field = self.view.fields[file_type.fname] if not field.use.isChecked() or field.path is None: return file_group = FilenameGroup.from_file(field.path) file_group.find_all_files() image_param = ImageParameters(file_group) if file_type in log_for_file_type: self._update_image_param(file_type, image_param, log_for_file_type, 'log_file') if file_type in shuttercounts_for_file_type: self._update_image_param(file_type, image_param, shuttercounts_for_file_type, 'shutter_count_file') if file_type == FILE_TYPES.SAMPLE: image_param.indices = field.indices loading_param.image_stacks[file_type] = image_param def _update_image_param(self, file_type: FILE_TYPES, image_param: ImageParameters, file_type_dict: dict, attr_name: str) -> None: """ Update the image parameter based on the selected file type. :param file_type: The selected file type. :param image_param (ImageParam): The image parameter object to update. :param file_type_dict: A dictionary mapping file types to their corresponding attributes. :param attr_name: The name of the attribute to update in the image parameter. :return None """ field = self.view.fields[file_type_dict[file_type].fname] if field.use.isChecked(): setattr(image_param, attr_name, field.path) def _update_field_action(self, field: Field, file_name) -> None: if file_name is not None: field.path = Path(file_name) field.use = True # type: ignore
[docs] def do_update_sample_log(self, field: Field, file_name: str) -> None: """ Update the sample log if a sample is set. Also check log is consistent with sample """ if self.sample_fg is None: raise RuntimeError("Please select sample data to be loaded first!") sample_names = [p.name for p in self.sample_fg.all_files()] self.ensure_sample_log_consistency(field, file_name, sample_names)
[docs] def ensure_sample_log_consistency(self, field: Field, file_name: str, image_filenames: list[str]) -> None: if file_name is None or file_name == "": return log = load_log(Path(file_name)) log.raise_if_angle_missing(image_filenames) self._update_field_action(field, file_name)