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)