def test_different_radius_not_square_image(self):
x, y, r, px, py, iX, iY = 40, 55, 20, 6, 5, 120, 100
kwrds = {
"probe_size_x": px,
"probe_size_y": py,
"image_size_x": iX,
"image_size_y": iY,
"disk_I": 0,
"ring_x": x,
"ring_y": y,
"ring_r": r,
"ring_I": 5,
"blur": True,
"downscale": False,
}
r0, r1, r2, r3 = 20, 25, 30, 27
kwrds["ring_r"] = r0
s = mdtd.generate_4d_data(**kwrds)
kwrds["ring_r"] = r1
s1 = mdtd.generate_4d_data(**kwrds)
kwrds["ring_r"] = r2
s2 = mdtd.generate_4d_data(**kwrds)
kwrds["ring_r"] = r3
s3 = mdtd.generate_4d_data(**kwrds)
s.data[:, :, :y, x:] = s1.data[:, :, :y, x:]
s.data[:, :, y:, x:] = s2.data[:, :, y:, x:]
s.data[:, :, y:, :x] = s3.data[:, :, y:, :x]
s_ar = s.angular_slice_radial_average(centre_x=x, centre_y=y, angleN=4)
assert (s_ar.inav[:, :, 0].data.argmax(axis=-1) == r0).all()
assert (s_ar.inav[:, :, 1].data.argmax(axis=-1) == r1).all()
assert (s_ar.inav[:, :, 2].data.argmax(axis=-1) == r2).all()
assert (s_ar.inav[:, :, 3].data.argmax(axis=-1) == r3).all()
def test_disk_position_array(self):
ps_x, ps_y, intensity = 4, 7, 30
disk_x = np.random.randint(5, 35, size=(ps_y, ps_x))
disk_y = np.random.randint(5, 45, size=(ps_y, ps_x))
s = mdtd.generate_4d_data(
probe_size_x=ps_x,
probe_size_y=ps_y,
image_size_x=40,
image_size_y=50,
ring_x=None,
ring_e_x=None,
disk_x=disk_x,
disk_y=disk_y,
disk_r=1,
disk_I=intensity,
blur=False,
downscale=False,
)
for x in range(ps_x):
for y in range(ps_y):
cX, cY = disk_x[y, x], disk_y[y, x]
sl = np.s_[cY - 1:cY + 2, cX - 1:cX + 2]
im = s.inav[x, y].data[:]
assert (im[sl] == intensity).all()
im[sl] = 0
assert not im.any()
def test_center_of_mass_different_shapes2(self):
psX, psY = 11, 9
s = mdtd.generate_4d_data(probe_size_x=psX,
probe_size_y=psY,
ring_x=None)
s_com = s.center_of_mass()
assert s_com.axes_manager.shape == (2, psX, psY)
def test_threshold(self):
x, y = 60, 50
s = mdtd.generate_4d_data(
probe_size_x=4,
probe_size_y=3,
ring_x=None,
image_size_x=120,
image_size_y=100,
disk_x=x,
disk_y=y,
disk_r=20,
disk_I=20,
blur=False,
blur_sigma=1,
downscale=False,
)
s.data[:, :, 0:30, 0:30] = 5
# The extra values are ignored due to thresholding
s_com0 = s.center_of_mass(threshold=2)
assert (s_com0.inav[0].data == x).all()
assert (s_com0.inav[1].data == y).all()
# The extra values are not ignored
s_com1 = s.center_of_mass(threshold=1)
assert not (s_com1.inav[0].data == x).all()
assert not (s_com1.inav[1].data == y).all()
# The extra values are not ignored
s_com2 = s.center_of_mass()
assert not (s_com2.inav[0].data == x).all()
assert not (s_com2.inav[1].data == y).all()
def test_lazy(self):
y, x = np.mgrid[75:83:9j, 85:95:11j]
s = mdtd.generate_4d_data(
probe_size_x=11,
probe_size_y=9,
ring_x=None,
image_size_x=160,
image_size_y=140,
disk_x=x,
disk_y=y,
disk_r=40,
disk_I=20,
blur=True,
blur_sigma=1,
downscale=False,
)
s_lazy = LazyDiffraction2D(
da.from_array(s.data, chunks=(1, 1, 140, 160)))
s_lazy_com = s_lazy.center_of_mass()
np.testing.assert_allclose(s_lazy_com.inav[0].data, x)
np.testing.assert_allclose(s_lazy_com.inav[1].data, y)
s_lazy_1d = s_lazy.inav[0]
s_lazy_1d_com = s_lazy_1d.center_of_mass()
np.testing.assert_allclose(s_lazy_1d_com.inav[0].data, x[:, 0])
np.testing.assert_allclose(s_lazy_1d_com.inav[1].data, y[:, 0])
s_lazy_0d = s_lazy.inav[0, 0]
s_lazy_0d_com = s_lazy_0d.center_of_mass()
np.testing.assert_allclose(s_lazy_0d_com.inav[0].data, x[0, 0])
np.testing.assert_allclose(s_lazy_0d_com.inav[1].data, y[0, 0])
def test_compare_lazy_and_nonlazy(self):
y, x = np.mgrid[75:83:9j, 85:95:11j]
s = mdtd.generate_4d_data(
probe_size_x=11,
probe_size_y=9,
ring_x=None,
image_size_x=160,
image_size_y=140,
disk_x=x,
disk_y=y,
disk_r=40,
disk_I=20,
blur=True,
blur_sigma=1,
downscale=False,
)
s_lazy = LazyDiffraction2D(
da.from_array(s.data, chunks=(1, 1, 140, 160)))
s_com = s.center_of_mass()
s_lazy_com = s_lazy.center_of_mass()
np.testing.assert_equal(s_com.data, s_lazy_com.data)
com_nav_extent = s_com.axes_manager.navigation_extent
lazy_com_nav_extent = s_lazy_com.axes_manager.navigation_extent
assert com_nav_extent == lazy_com_nav_extent
com_sig_extent = s_com.axes_manager.signal_extent
lazy_com_sig_extent = s_lazy_com.axes_manager.signal_extent
assert com_sig_extent == lazy_com_sig_extent
def test_correct_disk_x_y_and_radius_random(self):
x, y, px, py = 56, 48, 4, 5
x, y = randint(45, 55, size=(py, px)), randint(45, 55, size=(py, px))
r = randint(20, 40, size=(py, px))
s = mdtd.generate_4d_data(
probe_size_x=px,
probe_size_y=py,
image_size_x=120,
image_size_y=100,
disk_x=x,
disk_y=y,
disk_r=5,
disk_I=20,
ring_x=x,
ring_y=y,
ring_r=r,
ring_I=5,
blur=True,
downscale=False,
)
dask_array = da.from_array(s.data, chunks=(4, 4, 50, 50))
s = LazyDiffraction2D(dask_array)
s_com = s.center_of_mass()
s_r = s.radial_average(centre_x=s_com.inav[0].data,
centre_y=s_com.inav[1].data)
s_r = s_r.isig[15:] # Do not include the disk
r -= 15 # Need to shift the radius, due to not including the disk
assert (s_r.data.argmax(axis=-1) == r).all()
def test_mask_2(self):
x, y = 60, 50
s = mdtd.generate_4d_data(
probe_size_x=5,
probe_size_y=5,
ring_x=None,
image_size_x=120,
image_size_y=100,
disk_x=x,
disk_y=y,
disk_r=20,
disk_I=20,
blur=False,
downscale=False,
)
# Add one large value
s.data[:, :, 50, 30] = 200000 # Large value to the left of the disk
# Center of mass should not be in center of the disk, due to the
# large value.
s_com0 = s.center_of_mass()
assert not (s_com0.inav[0].data == x).all()
assert (s_com0.inav[1].data == y).all()
# Here, the large value is masked
s_com1 = s.center_of_mass(mask=(60, 50, 25))
assert (s_com1.inav[0].data == x).all()
assert (s_com1.inav[1].data == y).all()
# Here, the large value is right inside the edge of the mask
s_com3 = s.center_of_mass(mask=(60, 50, 31))
assert not (s_com3.inav[0].data == x).all()
assert (s_com3.inav[1].data == y).all()
# Here, the large value is right inside the edge of the mask
s_com4 = s.center_of_mass(mask=(59, 50, 30))
assert not (s_com4.inav[0].data == x).all()
assert (s_com4.inav[1].data == y).all()
s.data[:, :, 50, 30] = 0
s.data[:, :, 80, 60] = 200000 # Large value under the disk
# The large value is masked
s_com5 = s.center_of_mass(mask=(60, 50, 25))
assert (s_com5.inav[0].data == x).all()
assert (s_com5.inav[1].data == y).all()
# The large value just not masked
s_com6 = s.center_of_mass(mask=(60, 50, 31))
assert (s_com6.inav[0].data == x).all()
assert not (s_com6.inav[1].data == y).all()
# The large value just not masked
s_com7 = s.center_of_mass(mask=(60, 55, 25))
assert (s_com7.inav[0].data == x).all()
assert not (s_com7.inav[1].data == y).all()
def test_slice_overlap(self):
x, y, r, px, py, iX, iY = 40, 55, 20, 6, 5, 120, 100
kwrds = {
"probe_size_x": px,
"probe_size_y": py,
"image_size_x": iX,
"image_size_y": iY,
"disk_I": 0,
"ring_x": x,
"ring_y": y,
"ring_r": r,
"ring_I": 5,
"blur": True,
"downscale": False,
}
r0, r1 = 20, 30
kwrds["ring_r"] = r0
s = mdtd.generate_4d_data(**kwrds)
kwrds["ring_r"] = r1
kwrds["ring_I"] = 500
s1 = mdtd.generate_4d_data(**kwrds)
s.data[:, :, y:, :] = s1.data[:, :, y:, :]
s_ar = s.angular_slice_radial_average(centre_x=x, centre_y=y, angleN=2)
assert (s_ar.inav[:, :, 0].data.argmax(axis=-1) == r0).all()
assert (s_ar.inav[:, :, 1].data.argmax(axis=-1) == r1).all()
s_ar1 = s.angular_slice_radial_average(centre_x=x,
centre_y=y,
angleN=2,
slice_overlap=0.1)
assert (s_ar1.inav[:, :, 0].data.argmax(axis=-1) == r1).all()
assert (s_ar1.inav[:, :, 1].data.argmax(axis=-1) == r1).all()
with pytest.raises(ValueError):
s.angular_slice_radial_average(slice_overlap=1.2)
with pytest.raises(ValueError):
s.angular_slice_radial_average(slice_overlap=-0.2)
def test_disk_outside_image(self):
s = mdtd.generate_4d_data(
probe_size_x=6,
probe_size_y=4,
image_size_x=40,
image_size_y=40,
ring_x=None,
ring_e_x=None,
disk_x=1000,
disk_y=1000,
disk_r=5,
)
assert (s.data == 0).all()
def test_input_numpy_array(self):
size = (20, 10)
disk_x = np.random.randint(5, 35, size=size)
disk_y = np.random.randint(5, 45, size=size)
disk_r = np.random.randint(5, 9, size=size)
disk_I = np.random.randint(50, 100, size=size)
ring_x = np.random.randint(5, 35, size=size)
ring_y = np.random.randint(5, 45, size=size)
ring_r = np.random.randint(10, 15, size=size)
ring_I = np.random.randint(1, 30, size=size)
ring_lw = np.random.randint(1, 5, size=size)
ring_e_x = np.random.randint(20, 30, size)
ring_e_y = np.random.randint(20, 30, size)
ring_e_semi_len0 = np.random.randint(10, 20, size)
ring_e_semi_len1 = np.random.randint(10, 20, size)
ring_e_r = np.random.random(size) * np.pi
ring_e_lw = np.random.randint(1, 3, size)
mdtd.generate_4d_data(
probe_size_x=10,
probe_size_y=20,
image_size_x=40,
image_size_y=50,
disk_x=disk_x,
disk_y=disk_y,
disk_I=disk_I,
disk_r=disk_r,
ring_x=ring_x,
ring_y=ring_y,
ring_r=ring_r,
ring_I=ring_I,
ring_lw=ring_lw,
ring_e_x=ring_e_x,
ring_e_y=ring_e_y,
ring_e_semi_len0=ring_e_semi_len0,
ring_e_semi_len1=ring_e_semi_len1,
ring_e_r=ring_e_r,
ring_e_lw=ring_e_lw,
)
def test_different_size(self):
s = mdtd.generate_4d_data(
probe_size_x=5,
probe_size_y=7,
ring_x=None,
ring_e_x=None,
image_size_x=30,
image_size_y=50,
)
ax = s.axes_manager
assert ax.navigation_dimension == 2
assert ax.signal_dimension == 2
assert ax.navigation_shape == (5, 7)
assert ax.signal_shape == (30, 50)
def get_holz_heterostructure_test_signal(lazy=False):
"""Get HyperSpy 2D signal with 2D navigation dimensions for HOLZ testing.
The centre, radius and intensity of the ring varies as a function of probe
position. The disk centre position varies as a function of probe position.
Parameters
----------
lazy : bool, default False
Returns
-------
holz_signal : HyperSpy 2D signal
Example
-------
>>> s = pxm.dummy_data.get_holz_heterostructure_test_signal()
>>> s.plot()
Load as lazy
>>> s = pxm.dummy_data.get_holz_heterostructure_test_signal(lazy=True)
"""
probe_size_x, probe_size_y = 40, 40
px, py = np.mgrid[0:probe_size_x:1, 0:probe_size_y:1]
x, y = np.mgrid[36:38:40j, 41:43:40j]
disk_r = 10
disk_I = np.ones_like(x) * 100 + np.random.random() * 20
g_r = Gaussian(A=20, centre=25, sigma=5)
ring_r = np.ones_like(x) * 30 + g_r.function(py)
g_I = Gaussian(A=30, centre=25, sigma=3)
ring_I = np.ones_like(x) * 20 + g_I.function(py)
s = mdtd.generate_4d_data(
probe_size_x=probe_size_x,
probe_size_y=probe_size_y,
image_size_x=80,
image_size_y=80,
disk_x=x,
disk_y=y,
disk_r=disk_r,
disk_I=disk_I,
ring_x=x,
ring_y=y,
ring_r=ring_r,
ring_I=ring_I,
add_noise=True,
lazy=lazy,
)
return s
def test_disk_cover_whole_image(self):
s = mdtd.generate_4d_data(
probe_size_x=6,
probe_size_y=4,
image_size_x=20,
image_size_y=20,
ring_x=None,
ring_e_x=None,
disk_x=10,
disk_y=10,
disk_r=40,
disk_I=50,
blur=False,
downscale=False,
)
assert (s.data == 50).all()
def test_ring_ellipse_center(self):
x, y = 40, 51
s = mdtd.generate_4d_data(
probe_size_x=4,
probe_size_y=5,
image_size_x=120,
image_size_y=100,
disk_x=None,
ring_x=None,
ring_e_x=x,
ring_e_y=y,
blur=False,
downscale=False,
)
s_com = s.center_of_mass()
assert (s_com.inav[0].data == x).all()
assert (s_com.inav[1].data == y).all()
def get_holz_simple_test_signal(lazy=False):
"""Get HyperSpy 2D signal with 2D navigation dimensions for HOLZ testing.
Probe size x/y (20, 20), and image size x/y (50, 50).
Contains a disk and a ring. The disk stays at x, y = 25, 25, with radius 2.
The ring has a radius of 20, and moves from x, y = 24-26, 24-26.
Parameters
----------
lazy : bool, default False
Returns
-------
holz_signal : Diffraction2D
Examples
--------
>>> s = pxm.dummy_data.get_holz_simple_test_signal()
>>> s.plot()
Load as lazy
>>> s = pxm.dummy_data.get_holz_simple_test_signal(lazy=True)
"""
ring_x, ring_y = np.mgrid[24:26:20j, 24:26:20j]
s = mdtd.generate_4d_data(
probe_size_x=20,
probe_size_y=20,
image_size_x=50,
image_size_y=50,
disk_x=25,
disk_y=25,
disk_r=2,
disk_I=20,
ring_x=ring_x,
ring_y=ring_y,
ring_r=15,
ring_I=10,
add_noise=True,
lazy=lazy,
)
return s
def test_0d_signal(self):
x, y = 40, 51
s = mdtd.generate_4d_data(
probe_size_x=1,
probe_size_y=1,
ring_x=None,
image_size_x=120,
image_size_y=100,
disk_x=x,
disk_y=y,
disk_r=20,
disk_I=20,
blur=False,
blur_sigma=1,
downscale=False,
)
s_com = s.inav[0, 0].center_of_mass()
assert (s_com.inav[0].data == x).all()
assert (s_com.inav[1].data == y).all()
def test_all_arguments(self):
s = mdtd.generate_4d_data(
probe_size_x=10,
probe_size_y=10,
image_size_x=50,
image_size_y=50,
disk_x=20,
disk_y=20,
disk_r=5,
disk_I=30,
ring_x=None,
ring_e_x=None,
blur=True,
blur_sigma=1,
downscale=True,
add_noise=True,
noise_amplitude=2,
)
assert s.axes_manager.shape == (10, 10, 50, 50)
def test_different_shape_no_downscale(self):
y, x = np.mgrid[75:83:9j, 85:95:11j]
s = mdtd.generate_4d_data(
probe_size_x=11,
probe_size_y=9,
ring_x=None,
image_size_x=160,
image_size_y=140,
disk_x=x,
disk_y=y,
disk_r=40,
disk_I=20,
blur=True,
blur_sigma=1,
downscale=False,
)
s_com = s.center_of_mass()
np.testing.assert_allclose(s_com.inav[0].data, x)
np.testing.assert_allclose(s_com.inav[1].data, y)
def test_same_radius(self):
x, y, r, px, py, angleN = 56, 48, 20, 4, 5, 20
s = mdtd.generate_4d_data(
probe_size_x=px,
probe_size_y=py,
image_size_x=120,
image_size_y=100,
disk_I=0,
ring_x=x,
ring_y=y,
ring_r=r,
ring_I=5,
blur=True,
downscale=False,
)
s_ar = s.angular_slice_radial_average(centre_x=x,
centre_y=y,
angleN=20)
assert s_ar.axes_manager.navigation_shape, (x, y, angleN)
assert (s_ar.data.argmax(-1) == r).all()
def test_correct_radius_random(self):
x, y, px, py = 56, 48, 4, 5
r = np.random.randint(20, 40, size=(py, px))
s = mdtd.generate_4d_data(
probe_size_x=px,
probe_size_y=py,
image_size_x=120,
image_size_y=100,
disk_I=0,
ring_x=x,
ring_y=y,
ring_r=r,
ring_I=5,
blur=True,
downscale=False,
)
s.axes_manager.signal_axes[0].offset = -x
s.axes_manager.signal_axes[1].offset = -y
s_r = s.radial_average()
assert (s_r.data.argmax(axis=-1) == r).all()
def test_correct_radius_simple(self):
x, y, r, px, py = 40, 51, 30, 4, 5
s = mdtd.generate_4d_data(
probe_size_x=px,
probe_size_y=py,
image_size_x=120,
image_size_y=100,
disk_I=0,
ring_x=x,
ring_y=y,
ring_r=r,
ring_I=5,
blur=True,
downscale=False,
)
s.axes_manager.signal_axes[0].offset = -x
s.axes_manager.signal_axes[1].offset = -y
s_r = s.radial_average()
assert s_r.axes_manager.navigation_shape == (px, py)
assert (s_r.data.argmax(axis=-1) == 30).all()
def test_1d_signal(self):
x = np.arange(45, 45 + 9).reshape((1, 9))
y = np.arange(55, 55 + 9).reshape((1, 9))
s = mdtd.generate_4d_data(
probe_size_x=9,
probe_size_y=1,
ring_x=None,
image_size_x=120,
image_size_y=100,
disk_x=x,
disk_y=y,
disk_r=20,
disk_I=20,
blur=False,
blur_sigma=1,
downscale=False,
)
s_com = s.inav[:, 0].center_of_mass()
assert (s_com.inav[0].data == x).all()
assert (s_com.inav[1].data == y).all()
def test_random_shifts(self, centre_x, centre_y):
y, x = np.mgrid[20:30:7j, 20:30:5j]
s = mdtd.generate_4d_data(
probe_size_x=5,
probe_size_y=7,
disk_x=x,
disk_y=y,
disk_r=1,
blur=True,
ring_x=None,
)
s_com = s.center_of_mass()
s_com.data[0] -= centre_x
s_com.data[1] -= centre_y
s_shift = s.shift_diffraction(shift_x=s_com.inav[0].data,
shift_y=s_com.inav[1].data)
s_shift_c = s_shift.center_of_mass()
np.testing.assert_allclose(s_shift_c.data[0],
np.ones_like(s_shift_c.data[0]) * centre_x)
np.testing.assert_allclose(s_shift_c.data[1],
np.ones_like(s_shift_c.data[1]) * centre_y)
def get_disk_shift_simple_test_signal(lazy=False):
"""Get HyperSpy 2D signal with 2D navigation dimensions for DPC testing.
Probe size x/y (20, 20), and image size x/y (50, 50).
Disk moves from 22-28 x/y.
Parameters
----------
lazy : bool, default False
Returns
-------
disk_shift_signal : Diffraction2D
Examples
--------
>>> s = pxm.dummy_data.get_disk_shift_simple_test_signal()
>>> s.plot()
Load as lazy
>>> s = pxm.dummy_data.get_disk_shift_simple_test_signal(lazy=True)
"""
disk_x, disk_y = np.mgrid[22:28:20j, 22:28:20j]
s = mdtd.generate_4d_data(
probe_size_x=20,
probe_size_y=20,
image_size_x=50,
image_size_y=50,
disk_x=disk_x,
disk_y=disk_y,
disk_r=2,
ring_x=None,
add_noise=True,
lazy=lazy,
)
return s
def test_mask(self):
y, x = np.mgrid[75:83:9j, 85:95:11j]
s = mdtd.generate_4d_data(
probe_size_x=11,
probe_size_y=9,
ring_x=None,
image_size_x=160,
image_size_y=140,
disk_x=x,
disk_y=y,
disk_r=40,
disk_I=20,
blur=False,
blur_sigma=1,
downscale=False,
)
s.data[:, :, 15, 10] = 1000000
s_com0 = s.center_of_mass()
s_com1 = s.center_of_mass(mask=(90, 79, 60))
assert not (s_com0.inav[0].data == x).all()
assert not (s_com0.inav[1].data == y).all()
assert (s_com1.inav[0].data == x).all()
assert (s_com1.inav[1].data == y).all()
def get_simple_fem_signal(lazy=False):
"""2D signal approximating a very small fluctuation electron microscopy (FEM) dataset.
Parameters
----------
lazy : bool, default False
If True, resulting signal will be lazy.
Returns
-------
fem_signal : Diffraction2D
Examples
--------
>>> s = pxm.dummy_data.get_simple_fem_signal()
>>> s.plot()
"""
radii1 = 10 * np.random.randint(0, 2, size=(2, 2))
intensities1 = np.random.randint(0, 5, size=(2, 2))
radii2 = 20 * np.random.randint(0, 2, size=(2, 2))
intensities2 = np.random.randint(0, 15, size=(2, 2))
test1 = mdtd.generate_4d_data(
probe_size_x=2,
probe_size_y=2,
image_size_x=50,
image_size_y=50,
disk_x=25,
disk_y=25,
disk_r=5,
disk_I=100,
ring_x=25,
ring_y=25,
ring_r=radii1,
ring_I=intensities1,
ring_lw=0,
blur=True,
blur_sigma=1,
downscale=True,
add_noise=True,
show_progressbar=False,
lazy=lazy,
)
test2 = mdtd.generate_4d_data(
probe_size_x=2,
probe_size_y=2,
image_size_x=50,
image_size_y=50,
disk_x=25,
disk_y=25,
disk_r=5,
disk_I=100,
ring_x=25,
ring_y=25,
ring_r=radii2,
ring_I=intensities2,
ring_lw=0,
blur=True,
blur_sigma=1,
downscale=True,
add_noise=True,
show_progressbar=False,
lazy=lazy,
)
fem_signal = test1 + test2
fem_signal.axes_manager.navigation_axes[0].name = "Probe position x"
fem_signal.axes_manager.navigation_axes[0].units = "nm"
fem_signal.axes_manager.navigation_axes[0].scale = 1.0
fem_signal.axes_manager.navigation_axes[0].offset = 0
fem_signal.axes_manager.navigation_axes[1].name = "Probe position y"
fem_signal.axes_manager.navigation_axes[1].units = "nm"
fem_signal.axes_manager.navigation_axes[1].scale = 1.0
fem_signal.axes_manager.navigation_axes[1].offset = 0
fem_signal.axes_manager.signal_axes[0].name = "Signal x"
fem_signal.axes_manager.signal_axes[0].units = "mrads"
fem_signal.axes_manager.signal_axes[0].scale = 0.25
fem_signal.axes_manager.signal_axes[0].offset = 0
fem_signal.axes_manager.signal_axes[1].name = "Signal y"
fem_signal.axes_manager.signal_axes[1].units = "mrads"
fem_signal.axes_manager.signal_axes[1].scale = 0.25
fem_signal.axes_manager.signal_axes[1].offset = 0
return fem_signal
def get_generic_fem_signal(probe_x=2, probe_y=2, image_x=50, image_y=50, lazy=False):
"""2D signal approximating a fluctuation electron microscopy (FEM) dataset with user defined dimensions.
Parameters
----------
probe_x : int, default 2
Horizontal dimension of the navigation axes
probe_y : int, default 2
Vertical dimension of the navigation axes
image_x : int, default 2
Horizontal dimension of the signal axes
image_y : int, default 2
Vertical dimension of the signal axes
lazy : bool, default False
If True, resulting signal will be lazy.
Returns
-------
fem_signal : Diffraction2D
Examples
--------
>>> s = pxm.dummy_data.get_generic_fem_signal(probe_x=5, probe_y=10,
... image_x=25, image_y=30, lazy=False)
>>> s.plot()
"""
image_center = [np.int(image_x / 2), np.int(image_y / 2)]
radii1 = 10 * np.random.randint(0, 2, size=(probe_y, probe_x))
intensities1 = np.random.randint(0, 5, size=(probe_y, probe_x))
radii2 = 20 * np.random.randint(0, 2, size=(probe_y, probe_x))
intensities2 = np.random.randint(0, 15, size=(probe_y, probe_x))
test1 = mdtd.generate_4d_data(
probe_size_x=probe_x,
probe_size_y=probe_y,
image_size_x=image_x,
image_size_y=image_y,
disk_x=image_center[0],
disk_y=image_center[1],
disk_r=5,
disk_I=100,
ring_x=image_center[0],
ring_y=image_center[1],
ring_r=radii1,
ring_I=intensities1,
ring_lw=0,
blur=True,
blur_sigma=1,
downscale=True,
add_noise=True,
show_progressbar=False,
lazy=lazy,
)
test2 = mdtd.generate_4d_data(
probe_size_x=probe_x,
probe_size_y=probe_y,
image_size_x=image_x,
image_size_y=image_y,
disk_x=image_center[0],
disk_y=image_center[1],
disk_r=5,
disk_I=100,
ring_x=image_center[0],
ring_y=image_center[1],
ring_r=radii2,
ring_I=intensities2,
ring_lw=0,
blur=True,
blur_sigma=1,
downscale=True,
add_noise=True,
show_progressbar=False,
lazy=lazy,
)
fem_signal = test1 + test2
fem_signal.axes_manager.navigation_axes[0].name = "Probe position x"
fem_signal.axes_manager.navigation_axes[0].units = "nm"
fem_signal.axes_manager.navigation_axes[0].scale = 1.0
fem_signal.axes_manager.navigation_axes[0].offset = 0
fem_signal.axes_manager.navigation_axes[1].name = "Probe position y"
fem_signal.axes_manager.navigation_axes[1].units = "nm"
fem_signal.axes_manager.navigation_axes[1].scale = 1.0
fem_signal.axes_manager.navigation_axes[1].offset = 0
fem_signal.axes_manager.signal_axes[0].name = "Signal x"
fem_signal.axes_manager.signal_axes[0].units = "mrads"
fem_signal.axes_manager.signal_axes[0].scale = 0.25
fem_signal.axes_manager.signal_axes[0].offset = 0
fem_signal.axes_manager.signal_axes[1].name = "Signal y"
fem_signal.axes_manager.signal_axes[1].units = "mrads"
fem_signal.axes_manager.signal_axes[1].scale = 0.25
fem_signal.axes_manager.signal_axes[1].offset = 0
return fem_signal
def test_simple0(self):
mdtd.generate_4d_data()