def test_create_new_stack_dataset(self):
dock_mock = mock.Mock()
stack_visualiser_mock = mock.Mock()
dock_mock.widget.return_value = stack_visualiser_mock
dock_mock.windowTitle.return_value = "somename"
self.view.create_stack_window.return_value = dock_mock
self.view.active_stacks_changed.emit = mock.Mock()
ds = Dataset(sample=generate_images(automatic_free=False),
flat_before=generate_images(automatic_free=False),
flat_after=generate_images(automatic_free=False),
dark_before=generate_images(automatic_free=False),
dark_after=generate_images(automatic_free=False))
ds.flat_before.filenames = ["filename"] * 10
ds.dark_before.filenames = ["filename"] * 10
ds.flat_after.filenames = ["filename"] * 10
ds.dark_after.filenames = ["filename"] * 10
self.presenter.create_new_stack(ds, "My title")
self.assertEqual(5, len(self.presenter.model.stack_list))
self.view.active_stacks_changed.emit.assert_called_once()
ds.sample.free_memory()
ds.flat_before.free_memory()
ds.dark_before.free_memory()
ds.flat_after.free_memory()
ds.dark_after.free_memory()
def test_execute_wrapper_return_is_runnable(self):
"""
Test that the partial returned by execute_wrapper can be executed (kwargs are named correctly)
"""
fake_presenter = mock.MagicMock()
fake_presenter.presenter.images = th.generate_images()
flat_before_widget = mock.Mock()
flat_before_widget.main_window.get_stack_visualiser = mock.Mock()
flat_before_widget.main_window.get_stack_visualiser.return_value = fake_presenter
flat_after_widget = mock.Mock()
flat_after_widget.main_window.get_stack_visualiser = mock.Mock()
flat_after_widget.main_window.get_stack_visualiser.return_value = fake_presenter
dark_before_widget = mock.Mock()
dark_before_widget.main_window.get_stack_visualiser = mock.Mock()
dark_before_widget.main_window.get_stack_visualiser.return_value = fake_presenter
dark_after_widget = mock.Mock()
dark_after_widget.main_window.get_stack_visualiser = mock.Mock()
dark_after_widget.main_window.get_stack_visualiser.return_value = fake_presenter
selected_flat_fielding_widget = mock.Mock()
selected_flat_fielding_widget.currentText = mock.Mock(
return_value="Only Before")
use_dark_widget = mock.Mock()
execute_func = FlatFieldFilter.execute_wrapper(
flat_before_widget=flat_before_widget,
flat_after_widget=flat_before_widget,
dark_before_widget=dark_before_widget,
dark_after_widget=dark_after_widget,
selected_flat_fielding_widget=selected_flat_fielding_widget,
use_dark_widget=use_dark_widget)
images = th.generate_images()
execute_func(images)
def test_apply_filter_with_180deg_proj_loaded(self):
"""
When 180deg projection is loaded the filter is applied
to both the data and the 180deg projection
"""
images = th.generate_images()
images.proj180deg = th.generate_images(automatic_free=False)
stack_params = {'test': 123}
selected_filter_mock = mock.Mock()
selected_filter_mock.__name__ = mock.Mock()
selected_filter_mock.__name__.return_value = "Test filter"
selected_filter_mock.filter_name.return_value = "Test filter"
progress_mock = mock.Mock()
callback_mock = mock.Mock()
selected_filter_mock.execute_wrapper.return_value = partial(
callback_mock)
self.model.selected_filter = selected_filter_mock
self.model.apply_filter(images, stack_params, progress=progress_mock)
selected_filter_mock.validate_execute_kwargs.assert_called_once()
callback_mock.assert_has_calls([
mock.call(images, progress=progress_mock, **stack_params),
mock.call(images.proj180deg,
progress=progress_mock,
**stack_params)
])
images.proj180deg.free_memory()
def _make_images(self) -> Tuple[Images, Images, Images, Images, Images]:
images = th.generate_images()
flat_before = th.generate_images()
dark_before = th.generate_images()
flat_after = th.generate_images()
dark_after = th.generate_images()
return images, flat_before, dark_before, flat_after, dark_after
def test_create_new_stack_images_focuses_newest_tab(self, mock_QApp):
first_images = generate_images()
second_images = generate_images()
first_stack_window = mock.Mock()
second_stack_window = mock.Mock()
first_stack_window.id = first_images.id
second_stack_window.id = second_images.id
self.view.create_stack_window.side_effect = [
first_stack_window, second_stack_window
]
self.view.model_changed.emit = mock.Mock()
self.presenter.create_new_stack(first_images)
self.assertEqual(1, len(self.presenter.stacks))
self.view.model_changed.emit.assert_called_once()
self.presenter.create_new_stack(second_images)
assert self.view.tabifyDockWidget.call_count == 2
assert self.view.findChild.call_count == 1
mock_tab_bar = self.view.findChild.return_value
expected_position = 2
mock_tab_bar.setCurrentIndex.assert_called_once_with(expected_position)
mock_QApp.sendPostedEvents.assert_called_once()
def test_clear_proj180deg(self):
images = generate_images((10, 100, 350))
# expected without having a specific 180 deg projection
self.assertIsNone(images._proj180deg)
images._proj180deg = generate_images((1, 100, 350))
images.clear_proj180deg()
self.assertIsNone(images._proj180deg)
def test_presenter_doesnt_raise_lists_for_original_stack(self):
single_stack_uuid = uuid4()
original_stack = [(th.generate_images(), single_stack_uuid),
(th.generate_images(), uuid4())]
StackChoicePresenter(original_stack, mock.MagicMock(),
mock.MagicMock(), single_stack_uuid,
mock.MagicMock())
def test_presenter_throws_list_if_uuid_is_not_in_stack(self):
single_stack_uuid = uuid4()
original_stack = [(th.generate_images(), single_stack_uuid), (th.generate_images(), uuid4())]
self.assertRaises(expected_exception=RuntimeError,
callable=StackChoicePresenter,
args=(original_stack, mock.MagicMock(), mock.MagicMock(), single_stack_uuid,
mock.MagicMock()))
def test_set_images_by_uuid_success(self):
prev_images = generate_images()
new_data = generate_images().data
ds = Dataset(prev_images)
self.model.datasets[ds.id] = ds
self.model.set_image_data_by_uuid(prev_images.id, new_data)
assert_array_equal(ds.sample.data, new_data)
def test_add_recon_to_dataset(self):
sample = generate_images()
sample_id = sample.id
ds = Dataset(sample)
recon = generate_images()
self.model.add_dataset_to_model(ds)
self.model.add_recon_to_dataset(recon, sample_id)
self.assertIn(recon, ds.all)
def test_proj180deg(self):
images = generate_images((10, 100, 350))
# expected without having a specific 180 deg projection
self.assertIsNone(images._proj180deg)
expected_projection = images.projection(images.num_projections // 2)
# simulate a pre-loaded one
np.array_equal(images.proj180deg.data, expected_projection)
images._proj180deg = generate_images((1, 100, 350))
assert_not_equals(images.proj180deg.data, expected_projection)
def test_add_180_deg_to_dataset(self, load: mock.Mock):
_180_file = "180 file"
dataset_id = "id"
self.model.datasets[dataset_id] = dataset_mock = Dataset(
generate_images())
load.return_value.sample = _180_stack = generate_images()
self.model.add_180_deg_to_dataset(dataset_id=dataset_id,
_180_deg_file=_180_file)
load.assert_called_with(file_names=[_180_file])
self.assertEqual(_180_stack, dataset_mock.proj180deg)
def test_set_images_in_stack(self):
mock_stack = mock.Mock()
mock_stack.presenter.images = old_images = generate_images()
self.presenter.stacks[old_images.id] = mock_stack
new_images = generate_images()
self.presenter.set_images_in_stack(old_images.id, new_images)
mock_stack.image_view.clear.assert_called_once()
mock_stack.image_view.setImage.assert_called_once_with(new_images.data)
self.assertEqual(self.presenter.stacks[old_images.id].presenter.images,
new_images)
def setUp(self):
self.original_stack = th.generate_images()
self.new_stack = th.generate_images()
self.v = mock.MagicMock()
self.op_p = mock.MagicMock()
self.uuid = uuid4()
self.p = StackChoicePresenter(original_stack=self.original_stack,
new_stack=self.new_stack,
operations_presenter=self.op_p,
stack_uuid=self.uuid,
view=self.v)
def do_execute_xy(self, is_parallel: bool, val=(512, 512)):
if is_parallel:
images = th.generate_images((15, 8, 10))
else:
images = th.generate_images()
mode = 'reflect'
expected_x = int(val[0])
expected_y = int(val[1])
result = RebinFilter.filter_func(images, rebin_param=val, mode=mode)
npt.assert_equal(result.data.shape[1], expected_x)
npt.assert_equal(result.data.shape[2], expected_y)
def test_dataset_list(self):
dataset_1 = Dataset(generate_images())
dataset_1.name = "dataset-1"
dataset_2 = Dataset(generate_images())
dataset_2.name = "dataset-2"
stack_dataset = StackDataset([generate_images()])
self.model.datasets = {
"id1": dataset_1,
"id2": dataset_2,
"id3": stack_dataset
}
dataset_list = self.presenter.dataset_list
assert len(dataset_list) == 2
def test_init_sets_get_title(self):
with mock.patch(
"mantidimaging.gui.dialogs.cor_inspection.CORInspectionDialogModel"
):
presenter = CORInspectionDialogPresenter(self.view,
th.generate_images(), 5,
ScalarCoR(2),
self.recon_params, True)
assert "Iterations" in presenter.get_title(ImageType.CURRENT)
presenter = CORInspectionDialogPresenter(self.view,
th.generate_images(), 5,
ScalarCoR(2),
self.recon_params, False)
assert "COR" in presenter.get_title(ImageType.CURRENT)
def test_execute_wrapper_return_is_runnable(self):
"""
Test that the partial returned by execute_wrapper can be executed (kwargs are named correctly)
"""
fake_presenter = mock.MagicMock()
fake_presenter.presenter.images = th.generate_images()
flat_widget = mock.Mock()
flat_widget.main_window.get_stack_visualiser = mock.Mock()
flat_widget.main_window.get_stack_visualiser.return_value = fake_presenter
dark_widget = mock.Mock()
dark_widget.main_window.get_stack_visualiser = mock.Mock()
dark_widget.main_window.get_stack_visualiser.return_value = fake_presenter
execute_func = FlatFieldFilter.execute_wrapper(flat_widget, dark_widget)
images = th.generate_images()
execute_func(images)
def test_divide(self):
images = th.generate_images()
copy = np.copy(images.data)
result = self.do_divide(images, 0.005)
th.assert_not_equals(result.data, copy)
def test_memory_change_acceptable(self):
"""
Expected behaviour for the filter is to be done in place
without using more memory.
In reality the memory is increased by about 40MB (4 April 2017),
but this could change in the future.
The reason why a 10% window is given on the expected size is
to account for any library imports that may happen.
This will still capture if the data is doubled, which is the main goal.
"""
images = th.generate_images()
cached_memory = get_memory_usage_linux(kb=True)[0]
ClipValuesFilter().filter_func(images,
clip_min=0.2,
clip_max=0.8,
clip_min_new_value=0.1,
clip_max_new_value=0.9)
self.assertLess(
get_memory_usage_linux(kb=True)[0], cached_memory * 1.1)
def test_divide_with_zero_does_nothing(self):
images = th.generate_images()
copy = np.copy(images.data)
result = self.do_divide(images, 0.00)
npt.assert_equal(result.data, copy)
def test_raises_exception_for_invalid_method(self, _, method):
images = th.generate_images()
self.assertRaises(ValueError,
FlatFieldFilter.filter_func,
images,
selected_flat_fielding=method)
def test_apply_factors(self):
data = th.generate_images().data
data[:] = 2
roi = [4, 4, 8, 8]
result = self.alg.create_factors(data, roi, cores=1)
result = self.alg.apply_factor(data, result, 1)
npt.assert_equal(data, result)
def test_no_execute(self):
images = th.generate_images()
sample = np.copy(images.data)
result = MinusLogFilter.filter_func(images, minus_log=False)
npt.assert_equal(result.data, sample)
def test_adjust_cor(self):
images = generate_images()
m = CORInspectionDialogModel(
images, 5, ScalarCoR(20),
ReconstructionParameters('FBP_CUDA', 'ram-lak'), False)
m.centre_value = 5
m.step = 1
m.adjust(ImageType.CURRENT)
self.assertEqual(m.centre_value, 5)
self.assertEqual(m.step, 0.5)
m.adjust(ImageType.LESS)
self.assertEqual(m.centre_value, 4.5)
self.assertEqual(m.step, 0.5)
m.adjust(ImageType.CURRENT)
self.assertEqual(m.centre_value, 4.5)
self.assertEqual(m.step, 0.25)
m.adjust(ImageType.MORE)
self.assertEqual(m.centre_value, 4.75)
self.assertEqual(m.step, 0.25)
m.adjust(ImageType.CURRENT)
self.assertEqual(m.centre_value, 4.75)
self.assertEqual(m.step, 0.125)
def test_exception_raised_for_empty_roi_param(self):
images = th.generate_images()
air = None
npt.assert_raises(ValueError, RoiNormalisationFilter.filter_func,
images, air)
def test_executed_2d(self):
images = th.generate_images()
control = images.copy()
result = RemoveStripeFilteringFilter.filter_func(images, filtering_dim=2)
th.assert_not_equals(result.data, control.data)
def test_exception_raised_for_invalid_size(self, _, size):
images = th.generate_images()
mode = None
npt.assert_raises(ValueError, MedianFilter.filter_func, images, size,
mode)
def test_executed(self):
images = th.generate_images()
control = images.copy()
result = RemoveAllStripesFilter.filter_func(images)
th.assert_not_equals(result.data, control.data)
def test_free_memory(self):
images = generate_images(automatic_free=False)
self.assertIsNotNone(images.memory_filename)
self.assertIsNotNone(images.data)
images.free_memory()
self.assertIsNone(images.memory_filename)
self.assertIsNone(images.data)
