11841431673

Committed 14 Nov 2024 04:30PM UTC coverage: 74.22% (-0.04%) from 74.259%

Build # 11841431673

Build Type

push

github

Committed by

web-flow

Commit Message

2348 Pyright (#2349)

Run Details

2649 of 3905 branches covered (67.84%)

Branch coverage included in aggregate %.

47 of 61 new or added lines in 18 files covered. (77.05%)

1 existing line in 1 file now uncovered.

9561 of 12546 relevant lines covered (76.21%)

0.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.34

/mantidimaging/gui/windows/nexus_load_dialog/presenter.py

# Copyright (C) 2024 ISIS Rutherford Appleton Laboratory UKRI
# SPDX - License - Identifier: GPL-3.0-or-later
from __future__ import annotations
import enum
import traceback
from enum import auto, Enum
from logging import getLogger
from typing import TYPE_CHECKING

import h5py
import numpy as np

from mantidimaging.core.data import ImageStack
from mantidimaging.core.data.dataset import StrictDataset
from mantidimaging.core.io.utility import NEXUS_PROCESSED_DATA_PATH
from mantidimaging.core.parallel import utility as pu
from mantidimaging.core.utility.data_containers import ProjectionAngles

if TYPE_CHECKING:
    from mantidimaging.gui.windows.nexus_load_dialog.view import NexusLoadDialog  # pragma: no cover

logger = getLogger(__name__)


class Notification(Enum):
    NEXUS_FILE_SELECTED = auto()


class ImageKeys(enum.Enum):
    Projections = 0
    FlatField = 1
    DarkField = 2


IMAGE_TITLE_MAP = {ImageKeys.Projections: "Projections", ImageKeys.FlatField: "Flat", ImageKeys.DarkField: "Dark"}
BEFORE_TITLE_MAP = {True: "Before", False: "After"}

TOMO_ENTRY = "tomo_entry"
DATA_PATH = "instrument/detector/data"
IMAGE_KEY_PATH = "instrument/detector/image_key"
ROTATION_ANGLE_PATH = "sample/rotation_angle"
DEFINITION = "definition"
NXTOMOPROC = "NXtomoproc"


def _missing_data_message(data_string: str) -> str:
    """
    Creates a message for logging when certain data is missing in the NeXus file.
    :param data_string: The name of the missing data.
    :return: A string telling the user that the data is missing.
    """
    return f"The NeXus file does not contain the {data_string} data."


class NexusLoadPresenter:
    view: NexusLoadDialog

    def __init__(self, view: NexusLoadDialog):
        self.view = view
        self.nexus_file = None
        self.tomo_entry = None
        self.data = None
        self.tomo_path = ""
        self.image_key_dataset: np.ndarray | None = None
        self.rotation_angles: np.ndarray | None = None
        self.title = ""
        self.recon_data: list[np.ndarray] = []

        self.sample_array: np.ndarray | None = None
        self.dark_before_array: np.ndarray | None = None
        self.flat_before_array: np.ndarray | None = None
        self.flat_after_array: np.ndarray | None = None
        self.dark_after_array: np.ndarray | None = None

    def notify(self, n: Notification):
        try:
            if n == Notification.NEXUS_FILE_SELECTED:
                self.scan_nexus_file()
        except RuntimeError as err:
            self.view.show_exception(str(err), traceback.format_exc())

    def scan_nexus_file(self):
        """
        Try to open the NeXus file and display its contents on the view.
        """
        file_path = self.view.filePathLineEdit.text()
        try:
            with h5py.File(file_path, "r") as self.nexus_file:
                self.tomo_entry = self._look_for_nxtomo_entry()
                if self.tomo_entry is None:
                    return

                self.data = self._look_for_image_data_and_update_view()
                if self.data is None:
                    return

                self.image_key_dataset = self._look_for_tomo_data_and_update_view(IMAGE_KEY_PATH, 0)
                if self.image_key_dataset is None:
                    return

                self.image_key_dataset = self.image_key_dataset[:]

                self.rotation_angles = self._look_for_tomo_data_and_update_view(ROTATION_ANGLE_PATH, 1)
                if self.rotation_angles is None:
                    return

                if "units" not in self.rotation_angles.attrs.keys():
                    logger.warning("No unit information found for rotation angles. Will infer from array values.")
                    degrees = np.abs(self.rotation_angles).max() > 2 * np.pi
                else:
                    degrees = "deg" in str(self.rotation_angles.attrs["units"])
                if degrees:
                    self.rotation_angles = np.radians(self.rotation_angles)
                self.rotation_angles = self.rotation_angles[:]

                self._look_for_recon_entries()

                self._get_data_from_image_key()
                self.title = self._find_data_title()
        except OSError:
            unable_message = f"Unable to read NeXus data from {file_path}"
            logger.error(unable_message)
            self.view.show_data_error(unable_message)
            self.view.disable_ok_button()

    def _read_rotation_angles(self, image_key: int, before: bool | None = None) -> np.ndarray | None:
        """
        Reads the rotation angles array and coverts them to radians if needed.
        :param image_key: The image key for the angles to read.
        :param before: Whether the rotation angles are for before/after images. This is None when rotation angles
            for sample images are being read.
        :return: A numpy array of the rotation angles or None if all angles provided are 0.
        """
        assert self.image_key_dataset is not None and self.rotation_angles is not None
        if before is None:
            rotation_angles = self.rotation_angles[np.where(self.image_key_dataset[...] == image_key)]
        else:
            first_sample_image_index = np.where(self.image_key_dataset == 0)[0][0]
            if before:
                image_key_array = self.image_key_dataset[:first_sample_image_index]
                rotation_angles = self.rotation_angles[:first_sample_image_index][np.where(
                    image_key_array == image_key)]
            else:
                rotation_angles = self.rotation_angles[first_sample_image_index:][np.where(
                    self.image_key_dataset[first_sample_image_index:] == image_key)]

        return rotation_angles if np.any(rotation_angles) else None

    def _missing_data_error(self, field: str):
        """
        Create a missing data message and display it on the view.
        :param field: The name of the field that couldn't be found in the NeXus file.
        """
        if "rotation_angle" in field:
            error_msg = _missing_data_message(field)
            logger.warning(error_msg)
        else:
            error_msg = _missing_data_message("required " + field)
            logger.error(error_msg)

        self.view.show_data_error(error_msg)

    def _look_for_tomo_data_and_update_view(self, field: str, position: int) -> h5py.Group | h5py.Dataset | None:
        """
        Looks for the data in the NeXus file and adds information about it to the view if it's found.
        :param field: The name of the NeXus field.
        :param position: The position of the field information row in the view's QTreeWidget.
        :return: The h5py Group/Dataset if it could be found, None otherwise.
        """
        dataset = self._look_for_tomo_data(field)
        if dataset is None or not isinstance(dataset, h5py.Dataset):
            self._missing_data_error(field)
            self.view.set_data_found(position, False, "", ())
            self.view.disable_ok_button()
        else:
            self.view.set_data_found(position, True, self.tomo_path + "/" + field, dataset.shape)
        return dataset

    def _look_for_image_data_and_update_view(self) -> h5py.Dataset | None:
        position = 2
        dataset = self._look_for_tomo_data(DATA_PATH)
        if dataset is not None:
            self.view.set_data_found(position, True, self.tomo_path + "/" + DATA_PATH, dataset.shape)
            return dataset if isinstance(dataset, h5py.Dataset) else None
        else:
            assert self.nexus_file is not None
            if NEXUS_PROCESSED_DATA_PATH in self.nexus_file:
                dataset = self.nexus_file[NEXUS_PROCESSED_DATA_PATH]["data"]
                self.view.set_data_found(position, True, NEXUS_PROCESSED_DATA_PATH, dataset.shape)
                return dataset if isinstance(dataset, h5py.Dataset) else None

        self._missing_data_error(DATA_PATH)
        self.view.set_data_found(position, False, "", ())
        self.view.disable_ok_button()
        return None

    def _look_for_nxtomo_entry(self) -> h5py.Group | None:
        """
        Look for a tomo_entry field in the NeXus file. Generate an error and disable the view OK button if it can't be
        found.
        :return: The first tomo_entry group if one could be found, None otherwise.
        """
        assert self.nexus_file is not None
        for key in self.nexus_file.keys():
            if TOMO_ENTRY in self.nexus_file[key].keys():
                self.tomo_path = f"{key}/{TOMO_ENTRY}"
                entry = self.nexus_file[key][TOMO_ENTRY]
                if isinstance(entry, h5py.Group):
                    return entry
                return None

        self._missing_data_error(TOMO_ENTRY)
        self.view.disable_ok_button()
        return None

    def _look_for_recon_entries(self):
        """
        Tries to find recon entries in the NeXus file then stores the data in a list.
        """
        assert self.nexus_file is not None
        for key in self.nexus_file.keys():
            if DEFINITION in self.nexus_file[key].keys():
                definition_data = np.array(self.nexus_file[key].get(DEFINITION))
                if definition_data.tobytes().decode("utf-8") == NXTOMOPROC:
                    nexus_recon = self.nexus_file[key]
                    self.recon_data.append(np.array(nexus_recon["data"]["data"]))

    def _look_for_tomo_data(self, entry_path: str) -> h5py.Group | h5py.Dataset | None:
        """
        Retrieve data from the tomo entry field.
        :param entry_path: The path in which the data is found.
        :return: The Nexus Group/Dataset if it exists, None otherwise.
        """
        assert self.tomo_entry is not None
        try:
            data = self.tomo_entry[entry_path]
            if isinstance(data, h5py.Group | h5py.Dataset):
                return data
            return None
        except KeyError:
            return None

    def _get_data_from_image_key(self):
        """
        Looks for the projection and dark/flat before/after images and update the information on the view.
        """
        self.sample_array = self._get_images(ImageKeys.Projections)
        self.view.set_images_found(0, self.sample_array.size != 0, self.sample_array.shape)
        if self.sample_array.size == 0:
            self._missing_data_error("projection images")
            self.view.disable_ok_button()
            return
        self.view.set_projections_increment(self.sample_array.shape[0])

        self.flat_before_array = self._get_images(ImageKeys.FlatField, True)
        self.view.set_images_found(1, self.flat_before_array.size != 0, self.flat_before_array.shape)

        self.flat_after_array = self._get_images(ImageKeys.FlatField, False)
        self.view.set_images_found(2, self.flat_after_array.size != 0, self.flat_after_array.shape)

        self.dark_before_array = self._get_images(ImageKeys.DarkField, True)
        self.view.set_images_found(3, self.dark_before_array.size != 0, self.dark_before_array.shape)

        self.dark_after_array = self._get_images(ImageKeys.DarkField, False)
        self.view.set_images_found(4, self.dark_after_array.size != 0, self.dark_after_array.shape)

    def _get_images(self, image_key_number: ImageKeys, before: bool | None = None) -> np.ndarray:
        """
        Retrieve images from the data based on an image key number.
        :param image_key_number: The image key number.
        :param before: True if the function should return before images, False if the function should return after
                       images. Ignored when getting projection images.
        :return: The set of images that correspond with a given image key.
        """
        assert self.image_key_dataset is not None and self.image_key_dataset.size is not None
        assert self.data is not None
        if image_key_number is ImageKeys.Projections:
            indices = self.image_key_dataset[...] == image_key_number.value
        else:
            if before:
                indices = self.image_key_dataset[:self.image_key_dataset.size // 2] == image_key_number.value
            else:
                indices = self.image_key_dataset[:] == image_key_number.value
                indices[:self.image_key_dataset.size // 2] = False
        # Shouldn't have to use numpy.where but h5py doesn't allow indexing with bool arrays currently
        return self.data[np.where(indices)]

    def _find_data_title(self) -> str:
        """
        Find the title field in the tomo_entry.
        :return: The title if it was found, "NeXus Data" otherwise.
        """
        assert self.tomo_entry is not None
        try:
            return self.tomo_entry["title"][0].decode("UTF-8")
        except (KeyError, ValueError):
            logger.info("A valid title couldn't be found. Using 'NeXus Data' instead.")
            return "NeXus Data"

    def get_dataset(self) -> tuple[StrictDataset, str]:
        """
        Create a LoadingDataset and title using the arrays that have been retrieved from the NeXus file.
        :return: A tuple containing the Dataset and the data title string.
        """
        sample_images = self._create_sample_images()
        sample_images.name = self.title
        assert self.flat_before_array is not None and self.flat_after_array is not None
        assert self.dark_before_array is not None and self.dark_after_array is not None
        ds = StrictDataset(sample=sample_images,
                           flat_before=self._create_images_if_required(self.flat_before_array, "Flat Before",
                                                                       ImageKeys.FlatField.value),
                           flat_after=self._create_images_if_required(self.flat_after_array, "Flat After",
                                                                      ImageKeys.FlatField.value),
                           dark_before=self._create_images_if_required(self.dark_before_array, "Dark Before",
                                                                       ImageKeys.DarkField.value),
                           dark_after=self._create_images_if_required(self.dark_after_array, "Dark After",
                                                                      ImageKeys.DarkField.value),
                           name=self.title)

        self._add_recons_to_dataset(ds)

        return ds, self.title

    def _create_sample_images(self):
        """
        Creates the sample ImageStack object.
        :return: An ImageStack object containing projections. If given, projection angles, pixel size, and 180deg are
            also set.
        """
        assert self.sample_array is not None

        # Create sample array and ImageStack object
        self.sample_array = self.sample_array[self.view.start_widget.value():self.view.stop_widget.value():self.view.
                                              step_widget.value()]
        sample_images = self._create_images(self.sample_array, "Projections")

        # Set attributes
        sample_images.pixel_size = int(self.view.pixelSizeSpinBox.value())
        projection_angles = self._read_rotation_angles(ImageKeys.Projections.value)
        if projection_angles is not None:
            sample_images.set_projection_angles(
                ProjectionAngles(projection_angles[self.view.start_widget.value():self.view.stop_widget.value():self.
                                                   view.step_widget.value()]))
        return sample_images

    def _create_images(self, data_array: np.ndarray, name: str) -> ImageStack:
        """
        Use a data array to create an ImageStack object.
        :param data_array: The images array obtained from the NeXus file.
        :param name: The name of the image dataset.
        :return: An ImageStack object.
        """
        data = pu.create_array(data_array.shape, self.view.pixelDepthComboBox.currentText())
        data.array[:] = data_array
        return ImageStack(data, [f"{name} {self.title}"])

    def _create_images_if_required(self, data_array: np.ndarray, name: str, image_key: int) -> ImageStack | None:
        """
        Create the ImageStack objects if the corresponding data was found in the NeXus file, and the user checked the
        "Use?" checkbox.
        :param data_array: The images data array.
        :param name: The name of the images.
        :param image_key: The image key index for the image type.
        :return: An ImageStack object or None.
        """
        if data_array.size == 0 or not self.view.checkboxes[name].isChecked():
            return None
        image_stack = self._create_images(data_array, name)
        if image_stack is not None:
            projection_angles = self._read_rotation_angles(image_key, "Before" in name)
            if projection_angles is not None:
                image_stack.set_projection_angles(ProjectionAngles(projection_angles))
        return image_stack

    def _add_recons_to_dataset(self, ds: StrictDataset) -> None:
        for recon_array in self.recon_data:
            ds.add_recon(ImageStack(recon_array))

1	# Copyright (C) 2024 ISIS Rutherford Appleton Laboratory UKRI
2	# SPDX - License - Identifier: GPL-3.0-or-later
3	from __future__ import annotations	1✔
4	import enum	1✔
5	import traceback	1✔
6	from enum import auto, Enum	1✔
7	from logging import getLogger	1✔
8	from typing import TYPE_CHECKING	1✔
9
10	import h5py	1✔
11	import numpy as np	1✔
12
13	from mantidimaging.core.data import ImageStack	1✔
14	from mantidimaging.core.data.dataset import StrictDataset	1✔
15	from mantidimaging.core.io.utility import NEXUS_PROCESSED_DATA_PATH	1✔
16	from mantidimaging.core.parallel import utility as pu	1✔
17	from mantidimaging.core.utility.data_containers import ProjectionAngles	1✔
18
19	if TYPE_CHECKING:
20	from mantidimaging.gui.windows.nexus_load_dialog.view import NexusLoadDialog # pragma: no cover
21
22	logger = getLogger(__name__)	1✔
23
24
25	class Notification(Enum):	1✔
26	NEXUS_FILE_SELECTED = auto()	1✔
27
28
29	class ImageKeys(enum.Enum):	1✔
30	Projections = 0	1✔
31	FlatField = 1	1✔
32	DarkField = 2	1✔
33
34
35	IMAGE_TITLE_MAP = {ImageKeys.Projections: "Projections", ImageKeys.FlatField: "Flat", ImageKeys.DarkField: "Dark"}	1✔
36	BEFORE_TITLE_MAP = {True: "Before", False: "After"}	1✔
37
38	TOMO_ENTRY = "tomo_entry"	1✔
39	DATA_PATH = "instrument/detector/data"	1✔
40	IMAGE_KEY_PATH = "instrument/detector/image_key"	1✔
41	ROTATION_ANGLE_PATH = "sample/rotation_angle"	1✔
42	DEFINITION = "definition"	1✔
43	NXTOMOPROC = "NXtomoproc"	1✔
44
45
46	def _missing_data_message(data_string: str) -> str:	1✔
47	"""
48	Creates a message for logging when certain data is missing in the NeXus file.
49	:param data_string: The name of the missing data.
50	:return: A string telling the user that the data is missing.
51	"""
52	return f"The NeXus file does not contain the {data_string} data."	1✔
53
54
55	class NexusLoadPresenter:	1✔
56	view: NexusLoadDialog	1✔
57
58	def __init__(self, view: NexusLoadDialog):	1✔
59	self.view = view	1✔
60	self.nexus_file = None	1✔
61	self.tomo_entry = None	1✔
62	self.data = None	1✔
63	self.tomo_path = ""	1✔
64	self.image_key_dataset: np.ndarray \| None = None	1✔
65	self.rotation_angles: np.ndarray \| None = None	1✔
66	self.title = ""	1✔
67	self.recon_data: list[np.ndarray] = []	1✔
68
69	self.sample_array: np.ndarray \| None = None	1✔
70	self.dark_before_array: np.ndarray \| None = None	1✔
71	self.flat_before_array: np.ndarray \| None = None	1✔
72	self.flat_after_array: np.ndarray \| None = None	1✔
73	self.dark_after_array: np.ndarray \| None = None	1✔
74
75	def notify(self, n: Notification):	1✔
76	try:	×
77	if n == Notification.NEXUS_FILE_SELECTED:	×
78	self.scan_nexus_file()	×
79	except RuntimeError as err:	×
80	self.view.show_exception(str(err), traceback.format_exc())	×
81
82	def scan_nexus_file(self):	1✔
83	"""
84	Try to open the NeXus file and display its contents on the view.
85	"""
86	file_path = self.view.filePathLineEdit.text()	1✔
87	try:	1✔
88	with h5py.File(file_path, "r") as self.nexus_file:	1✔
89	self.tomo_entry = self._look_for_nxtomo_entry()	1✔
90	if self.tomo_entry is None:	1✔
91	return	1✔
92
93	self.data = self._look_for_image_data_and_update_view()	1✔
94	if self.data is None:	1✔
95	return	1✔
96
97	self.image_key_dataset = self._look_for_tomo_data_and_update_view(IMAGE_KEY_PATH, 0)	1✔
98	if self.image_key_dataset is None:	1✔
99	return	1✔
100
101	self.image_key_dataset = self.image_key_dataset[:]	1✔
102
103	self.rotation_angles = self._look_for_tomo_data_and_update_view(ROTATION_ANGLE_PATH, 1)	1✔
104	if self.rotation_angles is None:	1✔
105	return	1✔
106
107	if "units" not in self.rotation_angles.attrs.keys():	1✔
108	logger.warning("No unit information found for rotation angles. Will infer from array values.")	1✔
109	degrees = np.abs(self.rotation_angles).max() > 2 * np.pi	1✔
110	else:
111	degrees = "deg" in str(self.rotation_angles.attrs["units"])	1✔
112	if degrees:	1✔
113	self.rotation_angles = np.radians(self.rotation_angles)	1✔
114	self.rotation_angles = self.rotation_angles[:]	1✔
115
116	self._look_for_recon_entries()	1✔
117
118	self._get_data_from_image_key()	1✔
119	self.title = self._find_data_title()	1✔
120	except OSError:	1✔
121	unable_message = f"Unable to read NeXus data from {file_path}"	1✔
122	logger.error(unable_message)	1✔
123	self.view.show_data_error(unable_message)	1✔
124	self.view.disable_ok_button()	1✔
125
126	def _read_rotation_angles(self, image_key: int, before: bool \| None = None) -> np.ndarray \| None:	1✔
127	"""
128	Reads the rotation angles array and coverts them to radians if needed.
129	:param image_key: The image key for the angles to read.
130	:param before: Whether the rotation angles are for before/after images. This is None when rotation angles
131	for sample images are being read.
132	:return: A numpy array of the rotation angles or None if all angles provided are 0.
133	"""
134	assert self.image_key_dataset is not None and self.rotation_angles is not None	1✔
135	if before is None:	1✔
136	rotation_angles = self.rotation_angles[np.where(self.image_key_dataset[...] == image_key)]	1✔
137	else:
138	first_sample_image_index = np.where(self.image_key_dataset == 0)[0][0]	1✔
139	if before:	1✔
140	image_key_array = self.image_key_dataset[:first_sample_image_index]	1✔
141	rotation_angles = self.rotation_angles[:first_sample_image_index][np.where(	1✔
142	image_key_array == image_key)]
143	else:
144	rotation_angles = self.rotation_angles[first_sample_image_index:][np.where(	1✔
145	self.image_key_dataset[first_sample_image_index:] == image_key)]
146
147	return rotation_angles if np.any(rotation_angles) else None	1✔
148
149	def _missing_data_error(self, field: str):	1✔
150	"""
151	Create a missing data message and display it on the view.
152	:param field: The name of the field that couldn't be found in the NeXus file.
153	"""
154	if "rotation_angle" in field:	1✔
155	error_msg = _missing_data_message(field)	1✔
156	logger.warning(error_msg)	1✔
157	else:
158	error_msg = _missing_data_message("required " + field)	1✔
159	logger.error(error_msg)	1✔
160
161	self.view.show_data_error(error_msg)	1✔
162
163	def _look_for_tomo_data_and_update_view(self, field: str, position: int) -> h5py.Group \| h5py.Dataset \| None:	1✔
164	"""
165	Looks for the data in the NeXus file and adds information about it to the view if it's found.
166	:param field: The name of the NeXus field.
167	:param position: The position of the field information row in the view's QTreeWidget.
168	:return: The h5py Group/Dataset if it could be found, None otherwise.
169	"""
170	dataset = self._look_for_tomo_data(field)	1✔
171	if dataset is None or not isinstance(dataset, h5py.Dataset):	1✔
172	self._missing_data_error(field)	1✔
173	self.view.set_data_found(position, False, "", ())	1✔
174	self.view.disable_ok_button()	1✔
175	else:
176	self.view.set_data_found(position, True, self.tomo_path + "/" + field, dataset.shape)	1✔
177	return dataset	1✔
178
179	def _look_for_image_data_and_update_view(self) -> h5py.Dataset \| None:	1✔
180	position = 2	1✔
181	dataset = self._look_for_tomo_data(DATA_PATH)	1✔
182	if dataset is not None:	1✔
183	self.view.set_data_found(position, True, self.tomo_path + "/" + DATA_PATH, dataset.shape)	1✔
184	return dataset if isinstance(dataset, h5py.Dataset) else None	1✔
185	else:
186	assert self.nexus_file is not None	1✔
187	if NEXUS_PROCESSED_DATA_PATH in self.nexus_file:	1✔
188	dataset = self.nexus_file[NEXUS_PROCESSED_DATA_PATH]["data"]	1✔
189	self.view.set_data_found(position, True, NEXUS_PROCESSED_DATA_PATH, dataset.shape)	1✔
190	return dataset if isinstance(dataset, h5py.Dataset) else None	1✔
191
192	self._missing_data_error(DATA_PATH)	1✔
193	self.view.set_data_found(position, False, "", ())	1✔
194	self.view.disable_ok_button()	1✔
195	return None	1✔
196
197	def _look_for_nxtomo_entry(self) -> h5py.Group \| None:	1✔
198	"""
199	Look for a tomo_entry field in the NeXus file. Generate an error and disable the view OK button if it can't be
200	found.
201	:return: The first tomo_entry group if one could be found, None otherwise.
202	"""
203	assert self.nexus_file is not None	1✔
204	for key in self.nexus_file.keys():	1✔
205	if TOMO_ENTRY in self.nexus_file[key].keys():	1✔
206	self.tomo_path = f"{key}/{TOMO_ENTRY}"	1✔
207	entry = self.nexus_file[key][TOMO_ENTRY]	1✔
208	if isinstance(entry, h5py.Group):	1!
209	return entry	1✔
NEW 210	return None	×
211
212	self._missing_data_error(TOMO_ENTRY)	1✔
213	self.view.disable_ok_button()	1✔
214	return None	1✔
215
216	def _look_for_recon_entries(self):	1✔
217	"""
218	Tries to find recon entries in the NeXus file then stores the data in a list.
219	"""
220	assert self.nexus_file is not None	1✔
221	for key in self.nexus_file.keys():	1✔
222	if DEFINITION in self.nexus_file[key].keys():	1✔
223	definition_data = np.array(self.nexus_file[key].get(DEFINITION))	1✔
224	if definition_data.tobytes().decode("utf-8") == NXTOMOPROC:	1!
225	nexus_recon = self.nexus_file[key]	1✔
226	self.recon_data.append(np.array(nexus_recon["data"]["data"]))	1✔
227
228	def _look_for_tomo_data(self, entry_path: str) -> h5py.Group \| h5py.Dataset \| None:	1✔
229	"""
230	Retrieve data from the tomo entry field.
231	:param entry_path: The path in which the data is found.
232	:return: The Nexus Group/Dataset if it exists, None otherwise.
233	"""
234	assert self.tomo_entry is not None	1✔
235	try:	1✔
236	data = self.tomo_entry[entry_path]	1✔
237	if isinstance(data, h5py.Group \| h5py.Dataset):	1!
238	return data	1✔
NEW 239	return None	×
240	except KeyError:	1✔
241	return None	1✔
242
243	def _get_data_from_image_key(self):	1✔
244	"""
245	Looks for the projection and dark/flat before/after images and update the information on the view.
246	"""
247	self.sample_array = self._get_images(ImageKeys.Projections)	1✔
248	self.view.set_images_found(0, self.sample_array.size != 0, self.sample_array.shape)	1✔
249	if self.sample_array.size == 0:	1✔
250	self._missing_data_error("projection images")	1✔
251	self.view.disable_ok_button()	1✔
252	return	1✔
253	self.view.set_projections_increment(self.sample_array.shape[0])	1✔
254
255	self.flat_before_array = self._get_images(ImageKeys.FlatField, True)	1✔
256	self.view.set_images_found(1, self.flat_before_array.size != 0, self.flat_before_array.shape)	1✔
257
258	self.flat_after_array = self._get_images(ImageKeys.FlatField, False)	1✔
259	self.view.set_images_found(2, self.flat_after_array.size != 0, self.flat_after_array.shape)	1✔
260
261	self.dark_before_array = self._get_images(ImageKeys.DarkField, True)	1✔
262	self.view.set_images_found(3, self.dark_before_array.size != 0, self.dark_before_array.shape)	1✔
263
264	self.dark_after_array = self._get_images(ImageKeys.DarkField, False)	1✔
265	self.view.set_images_found(4, self.dark_after_array.size != 0, self.dark_after_array.shape)	1✔
266
267	def _get_images(self, image_key_number: ImageKeys, before: bool \| None = None) -> np.ndarray:	1✔
268	"""
269	Retrieve images from the data based on an image key number.
270	:param image_key_number: The image key number.
271	:param before: True if the function should return before images, False if the function should return after
272	images. Ignored when getting projection images.
273	:return: The set of images that correspond with a given image key.
274	"""
275	assert self.image_key_dataset is not None and self.image_key_dataset.size is not None	1✔
276	assert self.data is not None	1✔
277	if image_key_number is ImageKeys.Projections:	1✔
278	indices = self.image_key_dataset[...] == image_key_number.value	1✔
279	else:
280	if before:	1✔
281	indices = self.image_key_dataset[:self.image_key_dataset.size // 2] == image_key_number.value	1✔
282	else:
283	indices = self.image_key_dataset[:] == image_key_number.value	1✔
284	indices[:self.image_key_dataset.size // 2] = False	1✔
285	# Shouldn't have to use numpy.where but h5py doesn't allow indexing with bool arrays currently
286	return self.data[np.where(indices)]	1✔
287
288	def _find_data_title(self) -> str:	1✔
289	"""
290	Find the title field in the tomo_entry.
291	:return: The title if it was found, "NeXus Data" otherwise.
292	"""
293	assert self.tomo_entry is not None	1✔
294	try:	1✔
295	return self.tomo_entry["title"][0].decode("UTF-8")	1✔
296	except (KeyError, ValueError):	1✔
297	logger.info("A valid title couldn't be found. Using 'NeXus Data' instead.")	1✔
298	return "NeXus Data"	1✔
299
300	def get_dataset(self) -> tuple[StrictDataset, str]:	1✔
301	"""
302	Create a LoadingDataset and title using the arrays that have been retrieved from the NeXus file.
303	:return: A tuple containing the Dataset and the data title string.
304	"""
305	sample_images = self._create_sample_images()	1✔
306	sample_images.name = self.title	1✔
307	assert self.flat_before_array is not None and self.flat_after_array is not None	1✔
308	assert self.dark_before_array is not None and self.dark_after_array is not None	1✔
309	ds = StrictDataset(sample=sample_images,	1✔
310	flat_before=self._create_images_if_required(self.flat_before_array, "Flat Before",
311	ImageKeys.FlatField.value),
312	flat_after=self._create_images_if_required(self.flat_after_array, "Flat After",
313	ImageKeys.FlatField.value),
314	dark_before=self._create_images_if_required(self.dark_before_array, "Dark Before",
315	ImageKeys.DarkField.value),
316	dark_after=self._create_images_if_required(self.dark_after_array, "Dark After",
317	ImageKeys.DarkField.value),
318	name=self.title)
319
320	self._add_recons_to_dataset(ds)	1✔
321
322	return ds, self.title	1✔
323
324	def _create_sample_images(self):	1✔
325	"""
326	Creates the sample ImageStack object.
327	:return: An ImageStack object containing projections. If given, projection angles, pixel size, and 180deg are
328	also set.
329	"""
330	assert self.sample_array is not None	1✔
331
332	# Create sample array and ImageStack object
333	self.sample_array = self.sample_array[self.view.start_widget.value():self.view.stop_widget.value():self.view.	1✔
334	step_widget.value()]
335	sample_images = self._create_images(self.sample_array, "Projections")	1✔
336
337	# Set attributes
338	sample_images.pixel_size = int(self.view.pixelSizeSpinBox.value())	1✔
339	projection_angles = self._read_rotation_angles(ImageKeys.Projections.value)	1✔
340	if projection_angles is not None:	1✔
341	sample_images.set_projection_angles(	1✔
342	ProjectionAngles(projection_angles[self.view.start_widget.value():self.view.stop_widget.value():self.
343	view.step_widget.value()]))
344	return sample_images	1✔
345
346	def _create_images(self, data_array: np.ndarray, name: str) -> ImageStack:	1✔
347	"""
348	Use a data array to create an ImageStack object.
349	:param data_array: The images array obtained from the NeXus file.
350	:param name: The name of the image dataset.
351	:return: An ImageStack object.
352	"""
353	data = pu.create_array(data_array.shape, self.view.pixelDepthComboBox.currentText())	1✔
354	data.array[:] = data_array	1✔
355	return ImageStack(data, [f"{name} {self.title}"])	1✔
356
357	def _create_images_if_required(self, data_array: np.ndarray, name: str, image_key: int) -> ImageStack \| None:	1✔
358	"""
359	Create the ImageStack objects if the corresponding data was found in the NeXus file, and the user checked the
360	"Use?" checkbox.
361	:param data_array: The images data array.
362	:param name: The name of the images.
363	:param image_key: The image key index for the image type.
364	:return: An ImageStack object or None.
365	"""
366	if data_array.size == 0 or not self.view.checkboxes[name].isChecked():	1✔
367	return None	1✔
368	image_stack = self._create_images(data_array, name)	1✔
369	if image_stack is not None:	1!
370	projection_angles = self._read_rotation_angles(image_key, "Before" in name)	1✔
371	if projection_angles is not None:	1✔
372	image_stack.set_projection_angles(ProjectionAngles(projection_angles))	1✔
373	return image_stack	1✔
374
375	def _add_recons_to_dataset(self, ds: StrictDataset) -> None:	1✔
376	for recon_array in self.recon_data:	1✔
377	ds.add_recon(ImageStack(recon_array))	1✔

mantidproject / mantidimaging / 11841431673

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous