def test_corner_size(self, corner_size):
size = 100
s = hs.signals.Signal2D(np.zeros((size, size)))
corner_slice_list = pst._get_corner_slices(s, corner_size=corner_size)
corner_shape = (round(size * corner_size), round(size * corner_size))
for corner_slice in corner_slice_list:
s_corner = s.isig[corner_slice]
assert s_corner.axes_manager.shape == corner_shape
def test_non_square_signal(self):
corner_size = 0.05
size_x, size_y = 100, 200
s = hs.signals.Signal2D(np.zeros((size_y, size_x)))
corner_slice_list = pst._get_corner_slices(s, corner_size=0.05)
corner_shape = (round(size_x * corner_size), round(size_y * corner_size))
for corner_slice in corner_slice_list:
s_corner = s.isig[corner_slice]
assert s_corner.axes_manager.shape == corner_shape
def correct_ramp(self, corner_size=0.05, only_offset=False, out=None):
"""Subtract a plane from the signal by fitting a plane to the corners.
Useful for removing the effects of the center of the diffraction
pattern shifting as a function of scan position.
The plane is calculated by fitting a plane to the corner values
of the signal. This will only work well when the property one
wants to measure is zero in these corners.
Parameters
----------
corner_size : number, optional
The size of the corners, as a percentage of the image's axis.
If corner_size is 0.05 (5%), and the image is 500 x 1000,
the size of the corners will be (500*0.05) x (1000*0.05) = 25 x 50.
Default 0.05
only_offset : bool, optional
If True, will subtract a "flat" plane, i.e. it will subtract the
mean value of the corners. Default False
out : optional, DPCSignal2D signal
Returns
-------
corrected_signal : Signal2D
Examples
--------
>>> s = pxm.dummy_data.get_square_dpc_signal(add_ramp=True)
>>> s_corr = s.correct_ramp()
>>> s_corr.plot()
Only correct offset
>>> s_corr = s.correct_ramp(only_offset=True)
>>> s_corr.plot()
"""
if out is None:
output = self.deepcopy()
else:
output = out
corner_slice_list = pst._get_corner_slices(self.inav[0],
corner_size=corner_size)
mask = np.ones_like(self.inav[0].data, dtype=np.bool)
for corner_slice in corner_slice_list:
mask[corner_slice] = False
for i, s in enumerate(self):
if only_offset:
plane = s.data[np.invert(mask)].mean()
else:
plane = pst._get_linear_plane_from_signal2d(s, mask=mask)
output.data[i, :, :] -= plane
if out is None:
return output
def test_signal_slice_values(self):
data = np.zeros((100, 200), dtype=np.uint16)
data[:20, :20] = 2
data[:20, -20:] = 5
data[-20:, :20] = 10
data[-20:, -20:] = 8
s = hs.signals.Signal2D(data)
corner_slice_list = pst._get_corner_slices(s, corner_size=0.05)
assert (s.isig[corner_slice_list[0]].data == 2).all()
assert (s.isig[corner_slice_list[1]].data == 10).all()
assert (s.isig[corner_slice_list[2]].data == 5).all()
assert (s.isig[corner_slice_list[3]].data == 8).all()
def test_wrong_input_dimensions(self):
s = hs.signals.Signal2D(np.ones((2, 10, 10)))
with pytest.raises(ValueError):
pst._get_corner_slices(s)
s = hs.signals.Signal2D(np.ones((2, 2, 10, 10)))
with pytest.raises(ValueError):
pst._get_corner_slices(s)
s = hs.signals.Signal1D(np.ones(10))
with pytest.raises(ValueError):
pst._get_corner_slices(s)
