6982451274

Committed 24 Nov 2023 03:20PM UTC coverage: 75.739% (+0.3%) from 75.447%

Build # 6982451274

Build Type

Pull #1974

github

Committed by

web-flow

Commit Message

Merge 9eb533015 into a62130685

Pull Request Pull Request #1974: Liveview sub directory support

Run Details

1866 of 2925 branches covered (0.0%)

Branch coverage included in aggregate %.

41 of 52 new or added lines in 1 file covered. (78.85%)

100 existing lines in 4 files now uncovered.

9029 of 11460 relevant lines covered (78.79%)

0.79 hits per line

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

75.13

/mantidimaging/gui/windows/spectrum_viewer/presenter.py

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

from enum import Enum
from typing import TYPE_CHECKING, Optional

from logging import getLogger
from mantidimaging.core.data.dataset import StrictDataset
from mantidimaging.gui.mvp_base import BasePresenter
from mantidimaging.gui.windows.spectrum_viewer.model import SpectrumViewerWindowModel, SpecType, ROI_RITS

if TYPE_CHECKING:
    from mantidimaging.gui.windows.spectrum_viewer.view import SpectrumViewerWindowView  # pragma: no cover
    from mantidimaging.gui.windows.main.view import MainWindowView  # pragma: no cover
    from mantidimaging.core.data import ImageStack
    from uuid import UUID

LOG = getLogger(__name__)


class ExportMode(Enum):
    # Needs to match GUI tab order
    ROI_MODE = 0
    IMAGE_MODE = 1


class SpectrumViewerWindowPresenter(BasePresenter):
    """
    The presenter for the spectrum viewer window.

    This presenter is responsible for handling user interaction with the view and
    updating the model and view accordingly to look after the state of the window.
    """
    view: 'SpectrumViewerWindowView'
    model: SpectrumViewerWindowModel
    spectrum_mode: SpecType = SpecType.SAMPLE
    current_stack_uuid: Optional['UUID'] = None
    current_norm_stack_uuid: Optional['UUID'] = None
    export_mode: ExportMode

    def __init__(self, view: 'SpectrumViewerWindowView', main_window: 'MainWindowView'):
        super().__init__(view)

        self.view = view
        self.main_window = main_window
        self.model = SpectrumViewerWindowModel(self)
        self.export_mode = ExportMode.ROI_MODE

    def handle_sample_change(self, uuid: Optional['UUID']) -> None:
        if uuid == self.current_stack_uuid:
            return
        else:
            self.current_stack_uuid = uuid
        new_dataset_id = self.get_dataset_id_for_stack(uuid)

        if new_dataset_id:
            self.auto_find_flat_stack(new_dataset_id)
        else:
            self.view.current_dataset_id = None

        self.do_remove_roi()
        if uuid is None:
            self.model.set_stack(None)
            self.view.clear()
            return

        self.model.set_stack(self.main_window.get_stack(uuid))
        normalise_uuid = self.view.get_normalise_stack()
        if normalise_uuid is not None:
            try:
                norm_stack: Optional['ImageStack'] = self.main_window.get_stack(normalise_uuid)
            except RuntimeError:
                norm_stack = None
            self.model.set_normalise_stack(norm_stack)

        self.do_add_roi()
        self.add_rits_roi()
        self.view.set_normalise_error(self.model.normalise_issue())
        self.show_new_sample()

    def handle_normalise_stack_change(self, normalise_uuid: Optional['UUID']) -> None:
        if normalise_uuid == self.current_norm_stack_uuid:
            return
        else:
            self.current_norm_stack_uuid = normalise_uuid

        if normalise_uuid is None:
            self.model.set_normalise_stack(None)
            return
        self.model.set_normalise_stack(self.main_window.get_stack(normalise_uuid))
        self.view.set_normalise_error(self.model.normalise_issue())
        if self.view.normalisation_enabled():
            self.redraw_all_rois()

    def auto_find_flat_stack(self, new_dataset_id):
        if self.view.current_dataset_id != new_dataset_id:
            self.view.current_dataset_id = new_dataset_id

            new_dataset = self.main_window.get_dataset(new_dataset_id)
            if isinstance(new_dataset, StrictDataset):
                if new_dataset.flat_before is not None:
                    self.view.try_to_select_relevant_normalise_stack(new_dataset.flat_before.name)
                elif new_dataset.flat_after is not None:
                    self.view.try_to_select_relevant_normalise_stack(new_dataset.flat_after.name)

    def get_dataset_id_for_stack(self, stack_id: Optional['UUID']) -> Optional['UUID']:
        return None if stack_id is None else self.main_window.get_dataset_id_from_stack_uuid(stack_id)

    def show_new_sample(self) -> None:
        """
        Show the new sample in the view and update the spectrum and
        image view accordingly. Resets the ROIs.
        """

        self.view.set_image(self.model.get_averaged_image())
        self.view.spectrum.add_range(*self.model.tof_range)
        self.view.auto_range_image()

    def handle_range_slide_moved(self, tof_range) -> None:
        self.model.tof_range = tof_range
        self.view.set_image(self.model.get_averaged_image(), autoLevels=False)

    def handle_roi_moved(self, force_new_spectrums: bool = False) -> None:
        """
        Handle changes to any ROI position and size.
        """
        for name in self.model.get_list_of_roi_names():
            roi = self.view.spectrum.get_roi(name)
            if force_new_spectrums or roi != self.model.get_roi(name):
                self.model.set_roi(name, roi)
                self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))

    def redraw_spectrum(self, name: str) -> None:
        """
        Redraw the spectrum with the given name
        """
        self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))

    def redraw_all_rois(self) -> None:
        """
        Redraw all ROIs and spectrum plots
        """
        for name in self.model.get_list_of_roi_names():
            self.model.set_roi(name, self.view.spectrum.get_roi(name))
            self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))

    def handle_button_enabled(self) -> None:
        """
        Enable the export button if the current stack is not None and normalisation is valid
        """
        has_stack = self.model.has_stack()
        normalisation_on = self.view.normalisation_enabled()
        normalisation_no_error = (normalisation_on and self.model.normalise_issue() == "") or not normalisation_on

        self.view.exportButton.setEnabled(has_stack and normalisation_no_error)
        self.view.exportButtonRITS.setEnabled(has_stack and normalisation_on and normalisation_no_error)
        self.view.addBtn.setEnabled(has_stack)

    def handle_export_csv(self) -> None:
        path = self.view.get_csv_filename()
        if path is None:
            return

        if path.suffix != ".csv":
            path = path.with_suffix(".csv")

        self.model.save_csv(path, self.spectrum_mode == SpecType.SAMPLE_NORMED)

    def handle_rits_export(self) -> None:
        """
        Handle the export of the current spectrum to a RITS file format
        """
        path = self.view.get_rits_export_filename()
        if path is None:
            LOG.debug("No path selected, aborting export")
            return
        if path.suffix != ".dat":
            path = path.with_suffix(".dat")
        self.model.save_rits(path, self.spectrum_mode == SpecType.SAMPLE_NORMED)

    def handle_enable_normalised(self, enabled: bool) -> None:
        if enabled:
            self.spectrum_mode = SpecType.SAMPLE_NORMED
        else:
            self.spectrum_mode = SpecType.SAMPLE
        self.redraw_all_rois()
        self.view.display_normalise_error()

    def get_roi_names(self) -> list:
        """
        Return a list of ROI names

        @return: list of ROI names
        """
        return self.model.get_list_of_roi_names()

    def do_add_roi(self) -> None:
        """
        Add a new ROI to the spectrum
        """
        roi_name = self.model.roi_name_generator()
        self.model.set_new_roi(roi_name)
        self.view.spectrum.add_roi(self.model.get_roi(roi_name), roi_name)
        self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))
        self.view.auto_range_image()
        self.do_add_roi_to_table(roi_name)

    def add_rits_roi(self) -> None:
        roi_name = ROI_RITS
        self.model.set_new_roi(roi_name)
        self.view.spectrum.add_roi(self.model.get_roi(roi_name), roi_name)
        self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))
        self.view.set_roi_alpha(0, ROI_RITS)

    def do_add_roi_to_table(self, roi_name: str) -> None:
        """
        Add a given ROI to the table by ROI name

        @param roi_name: Name of the ROI to add
        """
        roi_colour = self.view.spectrum.roi_dict[roi_name].colour
        self.view.add_roi_table_row(roi_name, roi_colour)

    def rename_roi(self, old_name: str, new_name: str) -> None:
        """
        Rename a given ROI from the table by ROI name

        @param old_name: Name of the ROI to rename
        @param new_name: New name of the ROI
        """
        self.view.spectrum.rename_roi(old_name, new_name)
        self.model.rename_roi(old_name, new_name)

    def do_remove_roi(self, roi_name: str | None = None) -> None:
        """
        Remove a given ROI from the table by ROI name or all ROIs from
        the table if no name is passed as an argument

        @param roi_name: Name of the ROI to remove
        """
        if roi_name is None:
            self.view.clear_all_rois()
            for roi in self.get_roi_names():
                self.view.spectrum.remove_roi(roi)
            self.model.remove_all_roi()
        else:
            self.view.spectrum.remove_roi(roi_name)
            self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))
            self.model.remove_roi(roi_name)

    def handle_export_tab_change(self, index: int) -> None:
        self.export_mode = ExportMode(index)
        self.view.on_visibility_change()

1	# Copyright (C) 2023 ISIS Rutherford Appleton Laboratory UKRI
2	# SPDX - License - Identifier: GPL-3.0-or-later
3	from __future__ import annotations	1✔
4
5	from enum import Enum	1✔
6	from typing import TYPE_CHECKING, Optional	1✔
7
8	from logging import getLogger	1✔
9	from mantidimaging.core.data.dataset import StrictDataset	1✔
10	from mantidimaging.gui.mvp_base import BasePresenter	1✔
11	from mantidimaging.gui.windows.spectrum_viewer.model import SpectrumViewerWindowModel, SpecType, ROI_RITS	1✔
12
13	if TYPE_CHECKING:
14	from mantidimaging.gui.windows.spectrum_viewer.view import SpectrumViewerWindowView # pragma: no cover
15	from mantidimaging.gui.windows.main.view import MainWindowView # pragma: no cover
16	from mantidimaging.core.data import ImageStack
17	from uuid import UUID
18
19	LOG = getLogger(__name__)	1✔
20
21
22	class ExportMode(Enum):	1✔
23	# Needs to match GUI tab order
24	ROI_MODE = 0	1✔
25	IMAGE_MODE = 1	1✔
26
27
28	class SpectrumViewerWindowPresenter(BasePresenter):	1✔
29	"""
30	The presenter for the spectrum viewer window.
31
32	This presenter is responsible for handling user interaction with the view and
33	updating the model and view accordingly to look after the state of the window.
34	"""
35	view: 'SpectrumViewerWindowView'	1✔
36	model: SpectrumViewerWindowModel	1✔
37	spectrum_mode: SpecType = SpecType.SAMPLE	1✔
38	current_stack_uuid: Optional['UUID'] = None	1✔
39	current_norm_stack_uuid: Optional['UUID'] = None	1✔
40	export_mode: ExportMode	1✔
41
42	def __init__(self, view: 'SpectrumViewerWindowView', main_window: 'MainWindowView'):	1✔
43	super().__init__(view)	1✔
44
45	self.view = view	1✔
46	self.main_window = main_window	1✔
47	self.model = SpectrumViewerWindowModel(self)	1✔
48	self.export_mode = ExportMode.ROI_MODE	1✔
49
50	def handle_sample_change(self, uuid: Optional['UUID']) -> None:	1✔
51	if uuid == self.current_stack_uuid:	1!
52	return	×
53	else:
54	self.current_stack_uuid = uuid	1✔
55	new_dataset_id = self.get_dataset_id_for_stack(uuid)	1✔
56
57	if new_dataset_id:	1✔
58	self.auto_find_flat_stack(new_dataset_id)	1✔
59	else:
60	self.view.current_dataset_id = None	1✔
61
62	self.do_remove_roi()	1✔
63	if uuid is None:	1✔
64	self.model.set_stack(None)	1✔
65	self.view.clear()	1✔
66	return	1✔
67
68	self.model.set_stack(self.main_window.get_stack(uuid))	1✔
69	normalise_uuid = self.view.get_normalise_stack()	1✔
70	if normalise_uuid is not None:	1!
71	try:	1✔
72	norm_stack: Optional['ImageStack'] = self.main_window.get_stack(normalise_uuid)	1✔
73	except RuntimeError:	×
74	norm_stack = None	×
75	self.model.set_normalise_stack(norm_stack)	1✔
76
77	self.do_add_roi()	1✔
78	self.add_rits_roi()	1✔
79	self.view.set_normalise_error(self.model.normalise_issue())	1✔
80	self.show_new_sample()	1✔
81
82	def handle_normalise_stack_change(self, normalise_uuid: Optional['UUID']) -> None:	1✔
83	if normalise_uuid == self.current_norm_stack_uuid:	×
UNCOV 84	return	×
85	else:
UNCOV 86	self.current_norm_stack_uuid = normalise_uuid	×
87
88	if normalise_uuid is None:	×
89	self.model.set_normalise_stack(None)	×
90	return	×
91	self.model.set_normalise_stack(self.main_window.get_stack(normalise_uuid))	×
92	self.view.set_normalise_error(self.model.normalise_issue())	×
93	if self.view.normalisation_enabled():	×
UNCOV 94	self.redraw_all_rois()	×
95
96	def auto_find_flat_stack(self, new_dataset_id):	1✔
97	if self.view.current_dataset_id != new_dataset_id:	1✔
98	self.view.current_dataset_id = new_dataset_id	1✔
99
100	new_dataset = self.main_window.get_dataset(new_dataset_id)	1✔
101	if isinstance(new_dataset, StrictDataset):	1✔
102	if new_dataset.flat_before is not None:	1✔
103	self.view.try_to_select_relevant_normalise_stack(new_dataset.flat_before.name)	1✔
104	elif new_dataset.flat_after is not None:	1✔
105	self.view.try_to_select_relevant_normalise_stack(new_dataset.flat_after.name)	1✔
106
107	def get_dataset_id_for_stack(self, stack_id: Optional['UUID']) -> Optional['UUID']:	1✔
108	return None if stack_id is None else self.main_window.get_dataset_id_from_stack_uuid(stack_id)	1✔
109
110	def show_new_sample(self) -> None:	1✔
111	"""
112	Show the new sample in the view and update the spectrum and
113	image view accordingly. Resets the ROIs.
114	"""
115
116	self.view.set_image(self.model.get_averaged_image())	1✔
117	self.view.spectrum.add_range(*self.model.tof_range)	1✔
118	self.view.auto_range_image()	1✔
119
120	def handle_range_slide_moved(self, tof_range) -> None:	1✔
121	self.model.tof_range = tof_range	1✔
122	self.view.set_image(self.model.get_averaged_image(), autoLevels=False)	1✔
123
124	def handle_roi_moved(self, force_new_spectrums: bool = False) -> None:	1✔
125	"""
126	Handle changes to any ROI position and size.
127	"""
128	for name in self.model.get_list_of_roi_names():	×
129	roi = self.view.spectrum.get_roi(name)	×
130	if force_new_spectrums or roi != self.model.get_roi(name):	×
131	self.model.set_roi(name, roi)	×
UNCOV 132	self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))	×
133
134	def redraw_spectrum(self, name: str) -> None:	1✔
135	"""
136	Redraw the spectrum with the given name
137	"""
UNCOV 138	self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))	×
139
140	def redraw_all_rois(self) -> None:	1✔
141	"""
142	Redraw all ROIs and spectrum plots
143	"""
144	for name in self.model.get_list_of_roi_names():	×
145	self.model.set_roi(name, self.view.spectrum.get_roi(name))	×
UNCOV 146	self.view.set_spectrum(name, self.model.get_spectrum(name, self.spectrum_mode))	×
147
148	def handle_button_enabled(self) -> None:	1✔
149	"""
150	Enable the export button if the current stack is not None and normalisation is valid
151	"""
152	has_stack = self.model.has_stack()	1✔
153	normalisation_on = self.view.normalisation_enabled()	1✔
154	normalisation_no_error = (normalisation_on and self.model.normalise_issue() == "") or not normalisation_on	1✔
155
156	self.view.exportButton.setEnabled(has_stack and normalisation_no_error)	1✔
157	self.view.exportButtonRITS.setEnabled(has_stack and normalisation_on and normalisation_no_error)	1✔
158	self.view.addBtn.setEnabled(has_stack)	1✔
159
160	def handle_export_csv(self) -> None:	1✔
161	path = self.view.get_csv_filename()	1✔
162	if path is None:	1✔
163	return	1✔
164
165	if path.suffix != ".csv":	1✔
166	path = path.with_suffix(".csv")	1✔
167
168	self.model.save_csv(path, self.spectrum_mode == SpecType.SAMPLE_NORMED)	1✔
169
170	def handle_rits_export(self) -> None:	1✔
171	"""
172	Handle the export of the current spectrum to a RITS file format
173	"""
174	path = self.view.get_rits_export_filename()	1✔
175	if path is None:	1!
176	LOG.debug("No path selected, aborting export")	×
UNCOV 177	return	×
178	if path.suffix != ".dat":	1✔
179	path = path.with_suffix(".dat")	1✔
180	self.model.save_rits(path, self.spectrum_mode == SpecType.SAMPLE_NORMED)	1✔
181
182	def handle_enable_normalised(self, enabled: bool) -> None:	1✔
183	if enabled:	×
UNCOV 184	self.spectrum_mode = SpecType.SAMPLE_NORMED	×
185	else:
186	self.spectrum_mode = SpecType.SAMPLE	×
187	self.redraw_all_rois()	×
UNCOV 188	self.view.display_normalise_error()	×
189
190	def get_roi_names(self) -> list:	1✔
191	"""
192	Return a list of ROI names
193
194	@return: list of ROI names
195	"""
196	return self.model.get_list_of_roi_names()	1✔
197
198	def do_add_roi(self) -> None:	1✔
199	"""
200	Add a new ROI to the spectrum
201	"""
202	roi_name = self.model.roi_name_generator()	1✔
203	self.model.set_new_roi(roi_name)	1✔
204	self.view.spectrum.add_roi(self.model.get_roi(roi_name), roi_name)	1✔
205	self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))	1✔
206	self.view.auto_range_image()	1✔
207	self.do_add_roi_to_table(roi_name)	1✔
208
209	def add_rits_roi(self) -> None:	1✔
210	roi_name = ROI_RITS	1✔
211	self.model.set_new_roi(roi_name)	1✔
212	self.view.spectrum.add_roi(self.model.get_roi(roi_name), roi_name)	1✔
213	self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))	1✔
214	self.view.set_roi_alpha(0, ROI_RITS)	1✔
215
216	def do_add_roi_to_table(self, roi_name: str) -> None:	1✔
217	"""
218	Add a given ROI to the table by ROI name
219
220	@param roi_name: Name of the ROI to add
221	"""
222	roi_colour = self.view.spectrum.roi_dict[roi_name].colour	1✔
223	self.view.add_roi_table_row(roi_name, roi_colour)	1✔
224
225	def rename_roi(self, old_name: str, new_name: str) -> None:	1✔
226	"""
227	Rename a given ROI from the table by ROI name
228
229	@param old_name: Name of the ROI to rename
230	@param new_name: New name of the ROI
231	"""
232	self.view.spectrum.rename_roi(old_name, new_name)	1✔
233	self.model.rename_roi(old_name, new_name)	1✔
234
235	def do_remove_roi(self, roi_name: str \| None = None) -> None:	1✔
236	"""
237	Remove a given ROI from the table by ROI name or all ROIs from
238	the table if no name is passed as an argument
239
240	@param roi_name: Name of the ROI to remove
241	"""
242	if roi_name is None:	1✔
243	self.view.clear_all_rois()	1✔
244	for roi in self.get_roi_names():	1✔
245	self.view.spectrum.remove_roi(roi)	1✔
246	self.model.remove_all_roi()	1✔
247	else:
248	self.view.spectrum.remove_roi(roi_name)	1✔
249	self.view.set_spectrum(roi_name, self.model.get_spectrum(roi_name, self.spectrum_mode))	1✔
250	self.model.remove_roi(roi_name)	1✔
251
252	def handle_export_tab_change(self, index: int) -> None:	1✔
UNCOV 253	self.export_mode = ExportMode(index)	×
UNCOV 254	self.view.on_visibility_change()	×

mantidproject / mantidimaging / 6982451274

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