7034485151

Committed 29 Nov 2023 03:04PM UTC coverage: 75.543% (+0.2%) from 75.338%

Build # 7034485151

Build Type

Pull #1987

github

Committed by

web-flow

Commit Message

Merge 552947de7 into 2c47b8972

Pull Request Pull Request #1987: Rits transmission error WIP

Run Details

1848 of 2902 branches covered (0.0%)

Branch coverage included in aggregate %.

29 of 30 new or added lines in 3 files covered. (96.67%)

3 existing lines in 1 file now uncovered.

9006 of 11466 relevant lines covered (78.55%)

0.79 hits per line

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

93.64

/mantidimaging/gui/windows/spectrum_viewer/model.py

# Copyright (C) 2023 ISIS Rutherford Appleton Laboratory UKRI
# SPDX - License - Identifier: GPL-3.0-or-later
from __future__ import annotations
import csv
from enum import Enum
from pathlib import Path
from typing import TYPE_CHECKING, Optional

import numpy as np

from logging import getLogger
from mantidimaging.core.data import ImageStack
from mantidimaging.core.io.csv_output import CSVOutput
from mantidimaging.core.io import saver
from mantidimaging.core.io.instrument_log import LogColumn
from mantidimaging.core.utility.sensible_roi import SensibleROI

if TYPE_CHECKING:
    from mantidimaging.gui.windows.spectrum_viewer.presenter import SpectrumViewerWindowPresenter

LOG = getLogger(__name__)

ROI_ALL = "all"
ROI_RITS = "rits_roi"


class SpecType(Enum):
    SAMPLE = 1
    OPEN = 2
    SAMPLE_NORMED = 3


class ErrorMode(Enum):
    STANDARD_DEVIATION = 1
    PROPAGATED = 2


class SpectrumViewerWindowModel:
    """
    The model for the spectrum viewer window.
    This model is responsible for storing the state of the window and providing
    the presenter with the data it needs to update the view.
    The model is also responsible for saving ROI data to a csv file.
    """
    presenter: 'SpectrumViewerWindowPresenter'
    _stack: Optional[ImageStack] = None
    _normalise_stack: Optional[ImageStack] = None
    tof_range: tuple[int, int] = (0, 0)
    _roi_ranges: dict[str, SensibleROI]

    def __init__(self, presenter: 'SpectrumViewerWindowPresenter'):
        self.presenter = presenter
        self._roi_id_counter = 0
        self._roi_ranges = {}
        self.special_roi_list = [ROI_ALL]

    def roi_name_generator(self) -> str:
        """
        Returns a new Unique ID for newly created ROIs

        :return: A new unique ID
        """
        new_name = f"roi_{self._roi_id_counter}" if self._roi_id_counter > 0 else "roi"
        self._roi_id_counter += 1
        return new_name

    def get_list_of_roi_names(self) -> list[str]:
        """
        Get a list of rois available in the model
        """
        return list(self._roi_ranges.keys())

    def set_stack(self, stack: Optional[ImageStack]) -> None:
        """
        Sets the stack to be used by the model
        If that stack is None, then the model will be reset
        If the stack has changed, then the ROI ranges will be reset
        and additional ROIs excluding default ROIs will be removed

        @param stack: The new stack to be used by the model
        """

        self._stack = stack
        if stack is None:
            return
        self._roi_id_counter = 0
        self.tof_range = (0, stack.data.shape[0] - 1)
        self.set_new_roi(ROI_ALL)

    def set_new_roi(self, name: str) -> None:
        """
        Sets a new ROI with the given name

        @param name: The name of the new ROI
        """
        height, width = self.get_image_shape()
        self.set_roi(name, SensibleROI.from_list([0, 0, width, height]))

    def set_normalise_stack(self, normalise_stack: Optional[ImageStack]) -> None:
        self._normalise_stack = normalise_stack

    def set_roi(self, roi_name: str, roi: SensibleROI):
        self._roi_ranges[roi_name] = roi

    def get_roi(self, roi_name: str) -> SensibleROI:
        """
        Get the ROI with the given name from the model

        @param roi_name: The name of the ROI to get
        @return: The ROI with the given name
        """
        if roi_name not in self._roi_ranges.keys():
            raise KeyError(f"ROI {roi_name} does not exist in roi_ranges {self._roi_ranges.keys()}")
        return self._roi_ranges[roi_name]

    def get_averaged_image(self) -> Optional['np.ndarray']:
        """
        Get the averaged image from the stack in the model returning as a numpy array
        or None if it does not
        """
        if self._stack is not None:
            tof_slice = slice(self.tof_range[0], self.tof_range[1] + 1)
            return self._stack.data[tof_slice].mean(axis=0)
        return None

    @staticmethod
    def get_stack_spectrum(stack: ImageStack, roi: SensibleROI):
        left, top, right, bottom = roi
        roi_data = stack.data[:, top:bottom, left:right]
        return roi_data.mean(axis=(1, 2))

    @staticmethod
    def get_stack_spectrum_summed(stack: ImageStack, roi: SensibleROI):
        left, top, right, bottom = roi
        roi_data = stack.data[:, top:bottom, left:right]
        return roi_data.sum(axis=(1, 2))

    def normalise_issue(self) -> str:
        if self._stack is None or self._normalise_stack is None:
            return "Need 2 selected stacks"
        if self._stack is self._normalise_stack:
            return "Need 2 different stacks"
        if self._stack.data.shape != self._normalise_stack.data.shape:
            return "Stack shapes must match"
        return ""

    def get_spectrum(self, roi_name: str, mode: SpecType) -> 'np.ndarray':
        if self._stack is None:
            return np.array([])

        roi = self.get_roi(roi_name)
        if mode == SpecType.SAMPLE:
            return self.get_stack_spectrum(self._stack, roi)

        if self._normalise_stack is None:
            return np.array([])

        if mode == SpecType.OPEN:
            return self.get_stack_spectrum(self._normalise_stack, roi)
        elif mode == SpecType.SAMPLE_NORMED:
            if self.normalise_issue():
                return np.array([])
            roi_spectrum = self.get_stack_spectrum(self._stack, roi)
            roi_norm_spectrum = self.get_stack_spectrum(self._normalise_stack, roi)
        return np.divide(roi_spectrum, roi_norm_spectrum, out=np.zeros_like(roi_spectrum), where=roi_norm_spectrum != 0)

    def get_transmission_error_standard_dev(self, roi_name: str) -> np.ndarray:
        """
        Get the transmission error standard deviation for a given roi
        @param: roi_name The roi name
        @return: a numpy array representing the standard deviation of the transmission
        """
        if self._stack is None or self._normalise_stack is None:
            raise RuntimeError("Sample and open beam must be selected")
        left, top, right, bottom = self.get_roi(roi_name)
        sample = self._stack.data[:, top:bottom, left:right]
        normed = self._normalise_stack.data[:, top:bottom, left:right]
        safe_divide = np.divide(sample, normed, out=np.zeros_like(sample), where=normed != 0)
        return np.std(safe_divide, axis=(1, 2))

    def get_image_shape(self) -> tuple[int, int]:
        if self._stack is not None:
            return self._stack.data.shape[1:]
        else:
            return 0, 0

    def has_stack(self) -> bool:
        """
        Check if data is available to export
        @return: True if data is available to export and False otherwise
        """
        return self._stack is not None

    def save_csv(self, path: Path, normalized: bool) -> None:
        """
        Iterates over all ROIs and saves the spectrum for each one to a CSV file.

        @param path: The path to save the CSV file to.
        @param normalized: Whether to save the normalized spectrum.
        """
        if self._stack is None:
            raise ValueError("No stack selected")

        csv_output = CSVOutput()
        csv_output.add_column("tof_index", np.arange(self._stack.data.shape[0]))

        for roi_name in self.get_list_of_roi_names():
            csv_output.add_column(roi_name, self.get_spectrum(roi_name, SpecType.SAMPLE))
            if normalized:
                if self._normalise_stack is None:
                    raise RuntimeError("No normalisation stack selected")
                csv_output.add_column(roi_name + "_open", self.get_spectrum(roi_name, SpecType.OPEN))
                csv_output.add_column(roi_name + "_norm", self.get_spectrum(roi_name, SpecType.SAMPLE_NORMED))

        with path.open("w") as outfile:
            csv_output.write(outfile)
            self.save_roi_coords(self.get_roi_coords_filename(path))

    def save_rits(self, path: Path, normalized: bool, error_mode: ErrorMode) -> None:
        """
        Saves the spectrum for one ROI to a RITS file.

        @param path: The path to save the CSV file to.
        @param normalized: Whether to save the normalized spectrum.
        @param error_mode: Which version (standard deviation or propagated) of the error to use in the RITS export
        """
        if self._stack is None:
            raise ValueError("No stack selected")

        if not normalized or self._normalise_stack is None:
            raise ValueError("Normalisation must be enabled, and a normalise stack must be selected")
        tof = self.get_stack_time_of_flight()
        if tof is None:
            raise ValueError("No Time of Flights for sample. Make sure spectra log has been loaded")

        tof *= 1e6  # RITS expects ToF in μs
        transmission = self.get_spectrum(ROI_RITS, SpecType.SAMPLE_NORMED)

        if error_mode == ErrorMode.STANDARD_DEVIATION:
            transmission_error = self.get_transmission_error_standard_dev(ROI_RITS)
        elif error_mode == ErrorMode.PROPAGATED:
            transmission_error = np.full_like(tof, 0.1)
        else:
            raise ValueError("Invalid error_mode given")

        self.export_spectrum_to_rits(path, tof, transmission, transmission_error)

    def get_stack_time_of_flight(self) -> np.array | None:
        if self._stack is None or self._stack.log_file is None:
            return None
        try:
            time_of_flights = self._stack.log_file.get_column(LogColumn.TIME_OF_FLIGHT)
        except KeyError:
            return None
        return np.array(time_of_flights)

    def get_roi_coords_filename(self, path: Path) -> Path:
        """
        Get the path to save the ROI coordinates to.
        @param path: The path to save the CSV file to.
        @return: The path to save the ROI coordinates to.
        """
        return path.with_stem(f"{path.stem}_roi_coords")

    def save_roi_coords(self, path: Path) -> None:
        """
        Save the coordinates of the ROIs to a csv file (ROI name, x_min, x_max, y_min, y_max)
        following Pascal VOC format.
        @param path: The path to save the CSV file to.
        """
        with open(path, encoding='utf-8', mode='w') as f:
            csv_writer = csv.DictWriter(f, fieldnames=["ROI", "X Min", "X Max", "Y Min", "Y Max"])
            csv_writer.writeheader()
            for roi_name, coords in self._roi_ranges.items():
                csv_writer.writerow({
                    "ROI": roi_name,
                    "X Min": coords.left,
                    "X Max": coords.right,
                    "Y Min": coords.top,
                    "Y Max": coords.bottom
                })

    def export_spectrum_to_rits(self, path: Path, tof, transmission, absorption) -> None:
        """
        Export spectrum to RITS format
        """
        rits_data = saver.create_rits_format(tof, transmission, absorption)
        saver.export_to_dat_rits_format(rits_data, path)

    def remove_roi(self, roi_name) -> None:
        """
        Remove the selected ROI from the model

        @param roi_name: The name of the ROI to remove
        """
        if roi_name in self._roi_ranges.keys():
            if roi_name in self.special_roi_list:
                raise RuntimeError(f"Cannot remove ROI: {roi_name}")
            del self._roi_ranges[roi_name]
        else:
            raise KeyError(
                f"Cannot remove ROI {roi_name} as it does not exist. \n Available ROIs: {self._roi_ranges.keys()}")

    def rename_roi(self, old_name: str, new_name: str) -> None:
        """
        Rename the selected ROI from the model

        @param old_name: The current name of the ROI
        @param new_name: The new name of the ROI
        @raises KeyError: If the ROI does not exist
        @raises RuntimeError: If the ROI is 'all'
        """
        if old_name in self._roi_ranges.keys() and new_name not in self._roi_ranges.keys():
            if old_name in self.special_roi_list:
                raise RuntimeError(f"Cannot remove ROI: {old_name}")
            self._roi_ranges[new_name] = self._roi_ranges.pop(old_name)
        else:
            raise KeyError(f"Cannot rename {old_name} to {new_name} Available:{self._roi_ranges.keys()}")

    def remove_all_roi(self) -> None:
        """
        Remove all ROIs from the model
        """
        self._roi_ranges = {}

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	import csv	1✔
5	from enum import Enum	1✔
6	from pathlib import Path	1✔
7	from typing import TYPE_CHECKING, Optional	1✔
8
9	import numpy as np	1✔
10
11	from logging import getLogger	1✔
12	from mantidimaging.core.data import ImageStack	1✔
13	from mantidimaging.core.io.csv_output import CSVOutput	1✔
14	from mantidimaging.core.io import saver	1✔
15	from mantidimaging.core.io.instrument_log import LogColumn	1✔
16	from mantidimaging.core.utility.sensible_roi import SensibleROI	1✔
17
18	if TYPE_CHECKING:
19	from mantidimaging.gui.windows.spectrum_viewer.presenter import SpectrumViewerWindowPresenter
20
21	LOG = getLogger(__name__)	1✔
22
23	ROI_ALL = "all"	1✔
24	ROI_RITS = "rits_roi"	1✔
25
26
27	class SpecType(Enum):	1✔
28	SAMPLE = 1	1✔
29	OPEN = 2	1✔
30	SAMPLE_NORMED = 3	1✔
31
32
33	class ErrorMode(Enum):	1✔
34	STANDARD_DEVIATION = 1	1✔
35	PROPAGATED = 2	1✔
36
37
38	class SpectrumViewerWindowModel:	1✔
39	"""
40	The model for the spectrum viewer window.
41	This model is responsible for storing the state of the window and providing
42	the presenter with the data it needs to update the view.
43	The model is also responsible for saving ROI data to a csv file.
44	"""
45	presenter: 'SpectrumViewerWindowPresenter'	1✔
46	_stack: Optional[ImageStack] = None	1✔
47	_normalise_stack: Optional[ImageStack] = None	1✔
48	tof_range: tuple[int, int] = (0, 0)	1✔
49	_roi_ranges: dict[str, SensibleROI]	1✔
50
51	def __init__(self, presenter: 'SpectrumViewerWindowPresenter'):	1✔
52	self.presenter = presenter	1✔
53	self._roi_id_counter = 0	1✔
54	self._roi_ranges = {}	1✔
55	self.special_roi_list = [ROI_ALL]	1✔
56
57	def roi_name_generator(self) -> str:	1✔
58	"""
59	Returns a new Unique ID for newly created ROIs
60
61	:return: A new unique ID
62	"""
63	new_name = f"roi_{self._roi_id_counter}" if self._roi_id_counter > 0 else "roi"	1✔
64	self._roi_id_counter += 1	1✔
65	return new_name	1✔
66
67	def get_list_of_roi_names(self) -> list[str]:	1✔
68	"""
69	Get a list of rois available in the model
70	"""
71	return list(self._roi_ranges.keys())	1✔
72
73	def set_stack(self, stack: Optional[ImageStack]) -> None:	1✔
74	"""
75	Sets the stack to be used by the model
76	If that stack is None, then the model will be reset
77	If the stack has changed, then the ROI ranges will be reset
78	and additional ROIs excluding default ROIs will be removed
79
80	@param stack: The new stack to be used by the model
81	"""
82
83	self._stack = stack	1✔
84	if stack is None:	1✔
85	return	1✔
86	self._roi_id_counter = 0	1✔
87	self.tof_range = (0, stack.data.shape[0] - 1)	1✔
88	self.set_new_roi(ROI_ALL)	1✔
89
90	def set_new_roi(self, name: str) -> None:	1✔
91	"""
92	Sets a new ROI with the given name
93
94	@param name: The name of the new ROI
95	"""
96	height, width = self.get_image_shape()	1✔
97	self.set_roi(name, SensibleROI.from_list([0, 0, width, height]))	1✔
98
99	def set_normalise_stack(self, normalise_stack: Optional[ImageStack]) -> None:	1✔
100	self._normalise_stack = normalise_stack	1✔
101
102	def set_roi(self, roi_name: str, roi: SensibleROI):	1✔
103	self._roi_ranges[roi_name] = roi	1✔
104
105	def get_roi(self, roi_name: str) -> SensibleROI:	1✔
106	"""
107	Get the ROI with the given name from the model
108
109	@param roi_name: The name of the ROI to get
110	@return: The ROI with the given name
111	"""
112	if roi_name not in self._roi_ranges.keys():	1✔
113	raise KeyError(f"ROI {roi_name} does not exist in roi_ranges {self._roi_ranges.keys()}")	1✔
114	return self._roi_ranges[roi_name]	1✔
115
116	def get_averaged_image(self) -> Optional['np.ndarray']:	1✔
117	"""
118	Get the averaged image from the stack in the model returning as a numpy array
119	or None if it does not
120	"""
121	if self._stack is not None:	1✔
122	tof_slice = slice(self.tof_range[0], self.tof_range[1] + 1)	1✔
123	return self._stack.data[tof_slice].mean(axis=0)	1✔
124	return None	1✔
125
126	@staticmethod	1✔
127	def get_stack_spectrum(stack: ImageStack, roi: SensibleROI):	1✔
128	left, top, right, bottom = roi	1✔
129	roi_data = stack.data[:, top:bottom, left:right]	1✔
130	return roi_data.mean(axis=(1, 2))	1✔
131
132	@staticmethod	1✔
133	def get_stack_spectrum_summed(stack: ImageStack, roi: SensibleROI):	1✔
134	left, top, right, bottom = roi	1✔
135	roi_data = stack.data[:, top:bottom, left:right]	1✔
136	return roi_data.sum(axis=(1, 2))	1✔
137
138	def normalise_issue(self) -> str:	1✔
139	if self._stack is None or self._normalise_stack is None:	1✔
140	return "Need 2 selected stacks"	1✔
141	if self._stack is self._normalise_stack:	1✔
142	return "Need 2 different stacks"	1✔
143	if self._stack.data.shape != self._normalise_stack.data.shape:	1✔
144	return "Stack shapes must match"	1✔
145	return ""	1✔
146
147	def get_spectrum(self, roi_name: str, mode: SpecType) -> 'np.ndarray':	1✔
148	if self._stack is None:	1!
149	return np.array([])	×
150
151	roi = self.get_roi(roi_name)	1✔
152	if mode == SpecType.SAMPLE:	1✔
153	return self.get_stack_spectrum(self._stack, roi)	1✔
154
155	if self._normalise_stack is None:	1!
156	return np.array([])	×
157
158	if mode == SpecType.OPEN:	1✔
159	return self.get_stack_spectrum(self._normalise_stack, roi)	1✔
160	elif mode == SpecType.SAMPLE_NORMED:	1!
161	if self.normalise_issue():	1✔
162	return np.array([])	1✔
163	roi_spectrum = self.get_stack_spectrum(self._stack, roi)	1✔
164	roi_norm_spectrum = self.get_stack_spectrum(self._normalise_stack, roi)	1✔
165	return np.divide(roi_spectrum, roi_norm_spectrum, out=np.zeros_like(roi_spectrum), where=roi_norm_spectrum != 0)	1✔
166
167	def get_transmission_error_standard_dev(self, roi_name: str) -> np.ndarray:	1✔
168	"""
169	Get the transmission error standard deviation for a given roi
170	@param: roi_name The roi name
171	@return: a numpy array representing the standard deviation of the transmission
172	"""
173	if self._stack is None or self._normalise_stack is None:	1!
NEW 174	raise RuntimeError("Sample and open beam must be selected")	×
175	left, top, right, bottom = self.get_roi(roi_name)	1✔
176	sample = self._stack.data[:, top:bottom, left:right]	1✔
177	normed = self._normalise_stack.data[:, top:bottom, left:right]	1✔
178	safe_divide = np.divide(sample, normed, out=np.zeros_like(sample), where=normed != 0)	1✔
179	return np.std(safe_divide, axis=(1, 2))	1✔
180
181	def get_image_shape(self) -> tuple[int, int]:	1✔
182	if self._stack is not None:	1!
183	return self._stack.data.shape[1:]	1✔
184	else:
185	return 0, 0	×
186
187	def has_stack(self) -> bool:	1✔
188	"""
189	Check if data is available to export
190	@return: True if data is available to export and False otherwise
191	"""
192	return self._stack is not None	1✔
193
194	def save_csv(self, path: Path, normalized: bool) -> None:	1✔
195	"""
196	Iterates over all ROIs and saves the spectrum for each one to a CSV file.
197
198	@param path: The path to save the CSV file to.
199	@param normalized: Whether to save the normalized spectrum.
200	"""
201	if self._stack is None:	1!
UNCOV 202	raise ValueError("No stack selected")	×
203
204	csv_output = CSVOutput()	1✔
205	csv_output.add_column("tof_index", np.arange(self._stack.data.shape[0]))	1✔
206
207	for roi_name in self.get_list_of_roi_names():	1✔
208	csv_output.add_column(roi_name, self.get_spectrum(roi_name, SpecType.SAMPLE))	1✔
209	if normalized:	1✔
210	if self._normalise_stack is None:	1✔
211	raise RuntimeError("No normalisation stack selected")	1✔
212	csv_output.add_column(roi_name + "_open", self.get_spectrum(roi_name, SpecType.OPEN))	1✔
213	csv_output.add_column(roi_name + "_norm", self.get_spectrum(roi_name, SpecType.SAMPLE_NORMED))	1✔
214
215	with path.open("w") as outfile:	1✔
216	csv_output.write(outfile)	1✔
217	self.save_roi_coords(self.get_roi_coords_filename(path))	1✔
218
219	def save_rits(self, path: Path, normalized: bool, error_mode: ErrorMode) -> None:	1✔
220	"""
221	Saves the spectrum for one ROI to a RITS file.
222
223	@param path: The path to save the CSV file to.
224	@param normalized: Whether to save the normalized spectrum.
225	@param error_mode: Which version (standard deviation or propagated) of the error to use in the RITS export
226	"""
227	if self._stack is None:	1!
UNCOV 228	raise ValueError("No stack selected")	×
229
230	if not normalized or self._normalise_stack is None:	1✔
231	raise ValueError("Normalisation must be enabled, and a normalise stack must be selected")	1✔
232	tof = self.get_stack_time_of_flight()	1✔
233	if tof is None:	1✔
234	raise ValueError("No Time of Flights for sample. Make sure spectra log has been loaded")	1✔
235
236	tof *= 1e6 # RITS expects ToF in μs	1✔
237	transmission = self.get_spectrum(ROI_RITS, SpecType.SAMPLE_NORMED)	1✔
238
239	if error_mode == ErrorMode.STANDARD_DEVIATION:	1✔
240	transmission_error = self.get_transmission_error_standard_dev(ROI_RITS)	1✔
241	elif error_mode == ErrorMode.PROPAGATED:	1✔
242	transmission_error = np.full_like(tof, 0.1)	1✔
243	else:
244	raise ValueError("Invalid error_mode given")	1✔
245
246	self.export_spectrum_to_rits(path, tof, transmission, transmission_error)	1✔
247
248	def get_stack_time_of_flight(self) -> np.array \| None:	1✔
249	if self._stack is None or self._stack.log_file is None:	1✔
250	return None	1✔
251	try:	1✔
252	time_of_flights = self._stack.log_file.get_column(LogColumn.TIME_OF_FLIGHT)	1✔
253	except KeyError:	1✔
254	return None	1✔
255	return np.array(time_of_flights)	1✔
256
257	def get_roi_coords_filename(self, path: Path) -> Path:	1✔
258	"""
259	Get the path to save the ROI coordinates to.
260	@param path: The path to save the CSV file to.
261	@return: The path to save the ROI coordinates to.
262	"""
263	return path.with_stem(f"{path.stem}_roi_coords")	1✔
264
265	def save_roi_coords(self, path: Path) -> None:	1✔
266	"""
267	Save the coordinates of the ROIs to a csv file (ROI name, x_min, x_max, y_min, y_max)
268	following Pascal VOC format.
269	@param path: The path to save the CSV file to.
270	"""
271	with open(path, encoding='utf-8', mode='w') as f:	1✔
272	csv_writer = csv.DictWriter(f, fieldnames=["ROI", "X Min", "X Max", "Y Min", "Y Max"])	1✔
273	csv_writer.writeheader()	1✔
274	for roi_name, coords in self._roi_ranges.items():	1!
UNCOV 275	csv_writer.writerow({	×
276	"ROI": roi_name,
277	"X Min": coords.left,
278	"X Max": coords.right,
279	"Y Min": coords.top,
280	"Y Max": coords.bottom
281	})
282
283	def export_spectrum_to_rits(self, path: Path, tof, transmission, absorption) -> None:	1✔
284	"""
285	Export spectrum to RITS format
286	"""
287	rits_data = saver.create_rits_format(tof, transmission, absorption)	1✔
288	saver.export_to_dat_rits_format(rits_data, path)	1✔
289
290	def remove_roi(self, roi_name) -> None:	1✔
291	"""
292	Remove the selected ROI from the model
293
294	@param roi_name: The name of the ROI to remove
295	"""
296	if roi_name in self._roi_ranges.keys():	1✔
297	if roi_name in self.special_roi_list:	1✔
298	raise RuntimeError(f"Cannot remove ROI: {roi_name}")	1✔
299	del self._roi_ranges[roi_name]	1✔
300	else:
301	raise KeyError(	1✔
302	f"Cannot remove ROI {roi_name} as it does not exist. \n Available ROIs: {self._roi_ranges.keys()}")
303
304	def rename_roi(self, old_name: str, new_name: str) -> None:	1✔
305	"""
306	Rename the selected ROI from the model
307
308	@param old_name: The current name of the ROI
309	@param new_name: The new name of the ROI
310	@raises KeyError: If the ROI does not exist
311	@raises RuntimeError: If the ROI is 'all'
312	"""
313	if old_name in self._roi_ranges.keys() and new_name not in self._roi_ranges.keys():	1✔
314	if old_name in self.special_roi_list:	1✔
315	raise RuntimeError(f"Cannot remove ROI: {old_name}")	1✔
316	self._roi_ranges[new_name] = self._roi_ranges.pop(old_name)	1✔
317	else:
318	raise KeyError(f"Cannot rename {old_name} to {new_name} Available:{self._roi_ranges.keys()}")	1✔
319
320	def remove_all_roi(self) -> None:	1✔
321	"""
322	Remove all ROIs from the model
323	"""
324	self._roi_ranges = {}	1✔

mantidproject / mantidimaging / 7034485151

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