def test_set_precalculated(self):
self.model.data_model._points = [
Point(50, 1),
Point(40, 2),
Point(30, 3),
Point(20, 4)
]
# a line with a slope of 'below' gives 4 degree tilt
expected_slope = -0.06992681194351041
self.model.set_precalculated(ScalarCoR(1000.0), Degrees(4.0))
cor, angle, slope = self.model.get_results()
self.assertEqual(cor.value, 1000.0)
self.assertEqual(angle.value, 4.0)
self.assertEqual(slope.value, expected_slope)
# pre-calculated by hand
expected_cors_with_this_gradient = [
996.5036594028245, 997.2029275222595, 997.9021956416947,
998.6014637611298
]
for i, point in enumerate(self.model.data_model._points):
self.assertEqual(point.cor, expected_cors_with_this_gradient[i])
some_cor = self.model.data_model.get_cor_from_regression(1555)
self.assertEqual(some_cor, 891.2638074278414)
def find_center(images: Images,
progress: Progress) -> Tuple[ScalarCoR, Degrees]:
# assume the ROI is the full image, i.e. the slices are ALL rows of the image
slices = np.arange(images.height)
shift = pu.create_array((images.height, ))
search_range = get_search_range(images.width)
min_correlation_error = pu.create_array((len(search_range), images.height))
shared_search_range = pu.create_array((len(search_range), ),
dtype=np.int32)
shared_search_range[:] = np.asarray(search_range, dtype=np.int32)
_calculate_correlation_error(images, shared_search_range,
min_correlation_error, progress)
# Originally the output of do_search is stored in dimensions
# corresponding to (search_range, square sum). This is awkward to navigate
# we transpose store to make the array hold (square sum, search range)
# so that each store[row] accesses the information for the row's square sum across all search ranges
_find_shift(images, search_range, min_correlation_error, shift)
par = np.polyfit(slices, shift, deg=1)
m = par[0]
q = par[1]
LOG.debug(f"m={m}, q={q}")
theta = Degrees(np.rad2deg(np.arctan(0.5 * m)))
offset = np.round(m * images.height * 0.5 + q) * 0.5
LOG.info(f"found offset: {-offset} and tilt {theta}")
return ScalarCoR(images.h_middle + -offset), theta
def find_center(images: Images,
progress: Progress) -> Tuple[ScalarCoR, Degrees]:
# assume the ROI is the full image, i.e. the slices are ALL rows of the image
slices = np.arange(images.height)
with pu.temp_shared_array((images.height, )) as shift:
# this is the area that is looked into for the shift after overlapping the images
search_range = get_search_range(images.width)
func = shared_mem.create_partial(do_search,
shared_mem.fwd_index_only,
image_width=images.width,
p0=images.projection(0),
p180=np.fliplr(
images.proj180deg.data[0]),
search_range=search_range)
shared_mem.execute(shift,
func,
progress=progress,
msg="Finding correlation on row")
par = np.polyfit(slices, shift, deg=1)
m = par[0]
q = par[1]
LOG.debug(f"m={m}, q={q}")
theta = Degrees(np.rad2deg(np.arctan(0.5 * m)))
offset = np.round(m * images.height * 0.5 + q) * 0.5
LOG.info(f"found offset: {-offset} and tilt {theta}")
return ScalarCoR(images.h_middle + -offset), theta
def setUp(self, model) -> None:
self.view = mock.MagicMock()
self.model = model.return_value
self.recon_params = ReconstructionParameters("", "", 0, ScalarCoR(2),
Degrees(2), 2, 2)
self.presenter = CORInspectionDialogPresenter(self.view,
th.generate_images(), 5,
ScalarCoR(2),
self.recon_params, False)
def recon_params(self) -> ReconstructionParameters:
return ReconstructionParameters(
algorithm=self.algorithm_name,
filter_name=self.filter_name,
num_iter=self.num_iter,
cor=ScalarCoR(self.rotation_centre),
tilt=Degrees(self.tilt),
pixel_size=self.pixel_size,
max_projection_angle=self.max_proj_angle)
def test_update_projection(self, _):
image_data = mock.Mock()
preview_slice_idx = 13
tilt_angle = Degrees(30)
self.view.previewSliceIndex = preview_slice_index_mock = mock.Mock()
self.view.update_projection(image_data, preview_slice_idx, tilt_angle)
preview_slice_index_mock.setValue.assert_called_once_with(preview_slice_idx)
self.image_view.update_projection.assert_called_once_with(image_data, preview_slice_idx, tilt_angle)
def test_recon_params(self, recon_params_mock):
self.view.recon_params()
recon_params_mock.assert_called_once_with(
algorithm=self.algorithmName.currentText.return_value,
filter_name=self.filterName.currentText.return_value,
num_iter=self.numIter.value.return_value,
cor=ScalarCoR(self.resultCor.value.return_value),
tilt=Degrees(self.resultTilt.value.return_value),
pixel_size=self.pixelSize.value.return_value,
max_projection_angle=self.maxProjAngle.value.return_value)
def test_initial_select_data(self):
test_cor = ScalarCoR(50)
test_tilt = Degrees(1.5)
self.model.preview_projection_idx = 150
self.model.preview_slice_idx = 150
self.model.set_precalculated(test_cor, test_tilt)
self.model.initial_select_data(self.stack)
self.assertNotEqual(test_cor, self.model.last_cor)
self.assertNotEqual(test_tilt, self.model.tilt_angle)
self.assertEqual(0, self.model.preview_projection_idx)
self.assertEqual(64, self.model.preview_slice_idx)
def test_get_me_a_cor(self):
self.assertEqual(15, self.model.get_me_a_cor(cor=15))
self.model.data_model.clear_results()
self.model.last_cor = ScalarCoR(26)
self.assertEqual(26, self.model.get_me_a_cor().value)
self.model.data_model.set_precalculated(ScalarCoR(150), Degrees(1.5))
self.model.preview_slice_idx = 5
cor = self.model.get_me_a_cor()
# expected cor value obtained by running the test
self.assertAlmostEqual(149.86, cor.value, delta=1e-2)
def test_set_results(self):
cor_val = 20
tilt_val = 30
slope_val = 40
cor = ScalarCoR(cor_val)
tilt = Degrees(tilt_val)
slope = Slope(slope_val)
self.view.set_results(cor, tilt, slope)
self.resultCor.setValue.assert_called_once_with(cor_val)
self.resultTilt.setValue.assert_called_once_with(tilt_val)
self.resultSlope.setValue.assert_called_once_with(slope_val)
self.image_view.set_tilt.assert_called_once_with(tilt)
def test_tilt_line_data(self):
# TODO move into data_model test
self.model.data_model._points = [
Point(50, 1),
Point(40, 2),
Point(30, 3),
Point(20, 4)
]
self.model.data_model._cached_cor = 1
self.model.data_model._cached_gradient = 2
data = self.model.tilt_angle
self.assertEqual(data, Degrees(-63.43494882292201))
def do_calculate_cors_from_manual_tilt(self):
cor = ScalarCoR(self.view.rotation_centre)
tilt = Degrees(self.view.tilt)
self._set_precalculated_cor_tilt(cor, tilt)
def test_tilt_angle(self):
self.assertIsNone(self.model.tilt_angle)
exp_deg = Degrees(1.5)
self.model.set_precalculated(ScalarCoR(1), exp_deg)
self.assertAlmostEqual(self.model.tilt_angle.value, exp_deg.value)
def recon_params(self) -> ReconstructionParameters:
return ReconstructionParameters(self.algorithm_name, self.filter_name,
self.num_iter,
ScalarCoR(self.rotation_centre),
Degrees(self.tilt))