def test_fit_single_ellipse_to_signal_rotation(self): rot_list = [ -np.pi / 16, -np.pi / 8, -np.pi / 4, -np.pi / 2, -0.1, 0.1, np.pi / 16, np.pi / 8, np.pi / 4, np.pi / 2, np.pi + 0.1, np.pi * 2 + 0.1, np.pi * 2.5, np.pi * 3 + 0.1, np.pi * 3.2, ] for rot in rot_list: s = Diffraction2D(np.zeros((200, 200))) s.axes_manager[0].offset, s.axes_manager[1].offset = -100, -100 xx, yy = np.meshgrid(s.axes_manager[0].axis, s.axes_manager[1].axis) s.data += mdtd._get_elliptical_ring(xx, yy, 0, 0, 70, 60, rot, lw_r=1) output = ra.fit_single_ellipse_to_signal(s, (50, 80), angleN=10, show_progressbar=False) output_rot = output[5] % np.pi assert approx(output_rot, abs=0.1) == (rot % np.pi) for rot in rot_list: s = Diffraction2D(np.zeros((200, 200))) s.axes_manager[0].offset, s.axes_manager[1].offset = -100, -100 xx, yy = np.meshgrid(s.axes_manager[0].axis, s.axes_manager[1].axis) s.data += mdtd._get_elliptical_ring(xx, yy, 0, 0, 60, 70, rot, lw_r=1) output = ra.fit_single_ellipse_to_signal(s, (50, 80), angleN=10, show_progressbar=False) output_rot = (output[5] + np.pi / 2) % np.pi assert approx(output_rot, abs=0.1) == (rot % np.pi)
def test_create(self): array0 = np.zeros(shape=(10, 10, 10, 10)) s0 = Diffraction2D(array0) assert array0.shape == s0.axes_manager.shape # This should fail due to Diffraction2D inheriting # signal2D, i.e. the data has to be at least # 2-dimensions with pytest.raises(ValueError): Diffraction2D(np.zeros(10)) array1 = np.zeros(shape=(10, 10)) s1 = Diffraction2D(array1) assert array1.shape == s1.axes_manager.shape
def test_axes_manager_copy(self): s = Diffraction2D(np.random.randint(100, size=(5, 5, 20, 20))) ax_sa = s.axes_manager.signal_axes ax_na = s.axes_manager.navigation_axes ax_sa[0].name, ax_sa[1].name = "Detector x", "Detector y" ax_sa[0].scale, ax_sa[1].scale = 0.2, 0.2 ax_sa[0].offset, ax_sa[1].offset = 10, 20 ax_sa[0].units, ax_sa[1].units = "mrad", "mrad" ax_na[0].name, ax_na[1].name = "Probe x", "Probe y" ax_na[0].scale, ax_na[1].scale = 35, 35 ax_na[0].offset, ax_na[1].offset = 54, 12 ax_na[0].units, ax_na[1].units = "nm", "nm" s_temp = s.template_match_disk() assert s.data.shape == s_temp.data.shape ax_sa_t = s_temp.axes_manager.signal_axes ax_na_t = s_temp.axes_manager.navigation_axes assert ax_sa[0].name == ax_sa_t[0].name assert ax_sa[1].name == ax_sa_t[1].name assert ax_sa[0].scale == ax_sa_t[0].scale assert ax_sa[1].scale == ax_sa_t[1].scale assert ax_sa[0].offset == ax_sa_t[0].offset assert ax_sa[1].offset == ax_sa_t[1].offset assert ax_sa[0].units == ax_sa_t[0].units assert ax_sa[1].units == ax_sa_t[1].units assert ax_na[0].name == ax_na_t[0].name assert ax_na[1].name == ax_na_t[1].name assert ax_na[0].scale == ax_na_t[0].scale assert ax_na[1].scale == ax_na_t[1].scale assert ax_na[0].offset == ax_na_t[0].offset assert ax_na[1].offset == ax_na_t[1].offset assert ax_na[0].units == ax_na_t[0].units assert ax_na[1].units == ax_na_t[1].units
def get_hot_pixel_signal(lazy=False): """Get Diffraction2D signal with a disk in the middle. Has 4 pixels with value equal to 50000, to simulate hot pixels. Example ------- >>> s = pxm.dummy_data.get_hot_pixel_signal() Lazy signal >>> s_lazy = pxm.dummy_data.get_hot_pixel_signal(lazy=True) """ data = mdtd.MakeTestData(size_x=128, size_y=128, default=False, blur=True) data.add_disk(64, 64, r=30, intensity=10000) s = data.signal s.change_dtype("int64") s.data += gaussian_filter(s.data, sigma=50) s.data[76, 4] = 50000 s.data[12, 102] = 50000 s.data[32, 10] = 50000 s.data[120, 61] = 50000 if lazy: s = LazyDiffraction2D(s) s.data = da.from_array(s.data, chunks=(64, 64)) else: s = Diffraction2D(s) return s
def setup_method(self, method): # Navigation dimension of the diffraction patterns diffraction_pattern = Diffraction2D( np.arange(2000).reshape(4, 5, 10, 10)) virtual_image_generator = VirtualImageGenerator(diffraction_pattern) self.virtual_image_generator = virtual_image_generator self.diffraction_pattern = diffraction_pattern
def test_simple(self): peak_dicts = {} peak_dicts["centre"] = randint(124, 132, size=(3, 4, 10, 2)) peak_dicts["rest"] = randint(204, 212, size=(3, 4, 5, 2)) peak_dicts["none"] = randint(10, 13, size=(3, 4, 2, 2)) s = Diffraction2D(np.zeros((3, 4, 256, 256))) ct._add_peak_dicts_to_signal(s, peak_dicts)
def test_size(self): size = 17 peak_array = np.zeros(shape=(3, 2, 3, 2)) s = Diffraction2D(np.zeros(shape=(3, 2, 10, 10))) mt.add_peak_array_to_signal_as_markers(s, peak_array, size=size) marker = list(s.metadata.Markers)[0][1] assert marker.get_data_position("size") == size
def test_get_angle_sector_mask_radial_average1(self): x, y = 4.5, 4.5 array = np.zeros((10, 10, 10, 10)) array[:, :, 0:5, 0:5] = 1 centre_x_array = np.ones_like(array) * x centre_y_array = np.ones_like(array) * y s = Diffraction2D(array) s.axes_manager.signal_axes[0].offset = -x s.axes_manager.signal_axes[1].offset = -y mask0 = s.angular_mask(0.0, 0.5 * np.pi) s_r0 = s.radial_average(centre_x=centre_x_array, centre_y=centre_y_array, mask_array=mask0) assert np.all(s_r0.isig[0:6].data == 1.0) mask1 = s.angular_mask(0, np.pi) s_r1 = s.radial_average(centre_x=centre_x_array, centre_y=centre_y_array, mask_array=mask1) assert np.all(s_r1.isig[0:6].data == 0.5) mask2 = s.angular_mask(0.0, 2 * np.pi) s_r2 = s.radial_average(centre_x=centre_x_array, centre_y=centre_y_array, mask_array=mask2) assert np.all(s_r2.isig[0:6].data == 0.25) mask3 = s.angular_mask(np.pi, 2 * np.pi) s_r3 = s.radial_average(centre_x=centre_x_array, centre_y=centre_y_array, mask_array=mask3) assert np.all(s_r3.data == 0.0)
def test_dask_input(self): s = Diffraction2D(np.zeros((2, 3, 20, 20))) peak_array = da.zeros((2, 3, 10, 2), chunks=(1, 1, 10, 2)) with pytest.raises(ValueError): s.add_peak_array_as_markers(peak_array) peak_array_computed = peak_array.compute() s.add_peak_array_as_markers(peak_array_computed)
def test_vi_generator_get_virtual_images_from_mesh(nav_shape): n = np.prod(nav_shape) * 32**2 s = Diffraction2D(np.arange(n).reshape((*nav_shape, 32, 32))) vi_generator = VirtualImageGenerator(s) with pytest.raises(ValueError): vi_generator.get_virtual_images_from_mesh() for axis in s.axes_manager.signal_axes: axis.scale = 0.1 axis.offset = -1.6 axis.units = "1/nm" vi_generator.set_ROI_mesh(0.5, 0.6, 1.4) vi = vi_generator.get_virtual_images_from_mesh() vi_nav_axis = vi.axes_manager.navigation_axes[0] assert vi_nav_axis.size == 21 assert vi_nav_axis.name == "ROI index" assert vi_nav_axis.scale == 1.0 assert len(vi_generator.roi_list) == 21 vi_generator.set_ROI_mesh(0.5, 0.6, 1.0) assert len(vi_generator.roi_list) == 11 vi = vi_generator.get_virtual_images_from_mesh(normalize=True)
def test_scale_offset(self): s = Diffraction2D(np.zeros((50, 60))) axis = s.axes_manager[-1] axis.scale = 0.5 axis.offset = 6 value = mt._pixel_to_scaled_value(axis, 4.5) assert value == 8.25
def test_nav_1(self): data_shape = (5, 40, 40) array0 = np.ones(shape=data_shape) s0 = Diffraction2D(array0) s0_r = s0.radial_average() assert s0_r.axes_manager.navigation_shape == data_shape[:1] assert (s0_r.data[:, :-1] == 1).all()
def test_bool_array(self): peak_array = np.empty((2, 3), dtype=object) bool_array = np.empty((2, 3), dtype=object) for ix, iy in np.ndindex(peak_array.shape): peak_array[ix, iy] = np.random.randint(9, size=(1, 2)) bool_array[ix, iy] = np.random.randint(0, 2, size=1, dtype=bool) s = Diffraction2D(np.zeros(shape=(2, 3, 10, 10))) marker_list = mt._get_4d_points_marker_list(peak_array, s.axes_manager.signal_axes, color="red", bool_array=bool_array) mt._add_permanent_markers_to_signal(s, marker_list) marker = marker_list[0] s.plot() for iy, ix in np.ndindex(peak_array.shape[:2]): peak = peak_array[iy, ix][0] boolean = bool_array[iy, ix][0] s.axes_manager.indices = (ix, iy) if boolean: assert marker.get_data_position("x1") == peak[1] assert marker.get_data_position("y1") == peak[0] else: assert marker.get_data_position("x1") == -1000.0 assert marker.get_data_position("y1") == -1000.0
def test_nav_0(self): data_shape = (40, 40) array0 = np.ones(shape=data_shape) s0 = Diffraction2D(array0) s0_r = s0.radial_average() assert s0_r.axes_manager.navigation_dimension == 0 assert (s0_r.data[:-1] == 1).all()
def test_threshold(self, x, y): s = Diffraction2D(np.random.randint(0, 10, size=(10, 10, 10, 10))) s.data[:, :, x, y] = 1000000 s1 = s.threshold_and_mask(threshold=1) assert (s1.data[:, :, x, y] == 1.0).all() s1.data[:, :, x, y] = 0 assert (s1.data == 0).all()
def test_color(self): color = "blue" peak_array = np.zeros(shape=(3, 2, 3, 2)) s = Diffraction2D(np.zeros(shape=(3, 2, 10, 10))) mt.add_peak_array_to_signal_as_markers(s, peak_array, color=color) marker = list(s.metadata.Markers)[0][1] assert marker.marker_properties["color"] == color
def test_simple(self): s = Diffraction2D(np.zeros((2, 3, 100, 100))) peak_array = np.empty((2, 3), dtype=object) for index in np.ndindex(peak_array.shape): islice = np.s_[index] peak_array[islice] = np.random.randint(20, 80, (100, 2)) s.add_peak_array_as_markers(peak_array)
def test_big_value(self): data_shape = (5, 40, 40) big_value = 50000000 array0 = np.ones(shape=data_shape) * big_value s0 = Diffraction2D(array0) s0_r = s0.radial_average() assert s0_r.axes_manager.navigation_shape == data_shape[:1] assert (s0_r.data[:, :-1] == big_value).all()
def test_inplace(self): s = Diffraction2D(np.zeros((10, 10, 30, 40))) x, y, shift_x, shift_y = 20, 10, 4, -3 s.data[:, :, y, x] = 1 s.shift_diffraction(shift_x=shift_x, shift_y=shift_y, inplace=True) assert s.data[0, 0, y - shift_y, x - shift_x] == 1 s.data[:, :, y - shift_y, x - shift_x] = 0 assert s.data.sum() == 0
def test_single_shift(self, shift_x, shift_y): s = Diffraction2D(np.zeros((10, 10, 30, 40))) x, y = 20, 10 s.data[:, :, y, x] = 1 s_shift = s.shift_diffraction(shift_x=shift_x, shift_y=shift_y) assert s_shift.data[0, 0, y - shift_y, x - shift_x] == 1 s_shift.data[:, :, y - shift_y, x - shift_x] = 0 assert s_shift.data.sum() == 0
def test_flip_y(self): array = np.zeros(shape=(3, 4, 6, 10)) array[:, :, 3:, :] = 1 s = Diffraction2D(array) assert (s.data[:, :, 3:, :] == 1).all() s_flip = s.flip_diffraction_y() assert (s_flip.data[:, :, 3:, :] == 0).all() assert (s_flip.data[:, :, :3, :] == 1).all()
def test_size(self): size = 12 peak_array = np.zeros(shape=(3, 2, 1, 2)) s = Diffraction2D(np.zeros(shape=(3, 2, 10, 10))) marker_list = mt._get_4d_points_marker_list(peak_array, s.axes_manager.signal_axes, size=size) assert marker_list[0].get_data_position("size") == size
def test_color(self): color = "blue" peak_array = np.zeros(shape=(3, 2, 1, 2)) s = Diffraction2D(np.zeros(shape=(3, 2, 10, 10))) marker_list = mt._get_4d_points_marker_list(peak_array, s.axes_manager.signal_axes, color=color) assert marker_list[0].marker_properties["color"] == "blue"
def test_full_ellipse_ransac_processing(): xf, yf, a, b, r, nt = 100, 115, 45, 35, 0, 15 data_points = ret.make_ellipse_data_points(xf, yf, a, b, r, nt) image = np.zeros(shape=(200, 210), dtype=np.float32) for x, y in data_points: image[int(round(x)), int(round(y))] = 100 disk = morphology.disk(5, np.uint16) image = convolve2d(image, disk, mode="same") data = np.zeros((2, 3, 210, 200), dtype=np.float32) data[:, :] = image.T s = Diffraction2D(data) s_t = s.template_match_disk(disk_r=5) peak_array = s_t.find_peaks_lazy(threshold=0.1, lazy_result=False) c = math.sqrt(math.pow(a, 2) - math.pow(b, 2)) xc, yc = xf - c * math.cos(r), yf - c * math.sin(r) for iy, ix in np.ndindex(peak_array.shape): peaks = peak_array[iy, ix] assert len(peaks) == 15 assert approx(peaks[:, 1].mean(), abs=2) == xc assert approx(peaks[:, 0].mean(), abs=2) == yc assert approx(peaks[:, 1].max(), abs=2) == xc + a assert approx(peaks[:, 0].max(), abs=2) == yc + b assert approx(peaks[:, 1].min(), abs=2) == xc - a assert approx(peaks[:, 0].min(), abs=2) == yc - b ellipse_array, inlier_array = ret.get_ellipse_model_ransac( peak_array, yf=yf, xf=xf, rf_lim=15, semi_len_min=min(a, b) - 5, semi_len_max=max(a, b) + 5, semi_len_ratio_lim=5, max_trails=50, min_samples=10, ) s.add_ellipse_array_as_markers(ellipse_array) for iy, ix in np.ndindex(ellipse_array.shape): ycf, xcf, bf, af, rf = ellipse_array[iy, ix] compare_model_params((xcf, ycf, af, bf, rf), (xc, yc, a, b, r), abs=0.1) assert inlier_array[iy, ix].all() s.add_ellipse_array_as_markers(ellipse_array) x_list, y_list = [], [] for _, marker in list(s.metadata.Markers): x_list.append(marker.data["x1"][()][0][0]) y_list.append(marker.data["y1"][()][0][0]) assert approx(np.mean(x_list), abs=1) == xc assert approx(np.mean(y_list), abs=1) == yc assert approx(np.max(x_list), abs=1) == xc + a assert approx(np.max(y_list), abs=1) == yc + b assert approx(np.min(x_list), abs=1) == xc - a assert approx(np.min(y_list), abs=1) == yc - b
def test_rotate_diffraction_keep_shape(self): shape = (7, 5, 4, 15) s = Diffraction2D(np.zeros(shape)) s_rot = s.rotate_diffraction(angle=45) assert s.axes_manager.shape == s_rot.axes_manager.shape s_lazy = LazyDiffraction2D(da.zeros(shape, chunks=(1, 1, 1, 1))) s_rot_lazy = s_lazy.rotate_diffraction(angle=45) assert s_lazy.axes_manager.shape == s_rot_lazy.axes_manager.shape
def test_size(self): s = Diffraction2D(np.zeros((2, 3, 100, 100))) peak_array = np.empty((2, 3), dtype=object) for index in np.ndindex(peak_array.shape): islice = np.s_[index] peak_array[islice] = np.random.randint(20, 80, (100, 2)) s.add_peak_array_as_markers(peak_array, size=13) marker0 = list(s.metadata.Markers)[9][1] assert marker0.get_data_position("size") == 13
def test_3d_nav_dims(self): s = Diffraction2D(np.zeros((2, 3, 4, 100, 100))) peak_array = np.empty((2, 3, 4), dtype=object) for index in np.ndindex(peak_array.shape): islice = np.s_[index] peak_array[islice] = np.random.randint(20, 80, (100, 2)) s.add_peak_array_as_markers(peak_array) marker = list(s.metadata.Markers)[0][1] assert marker.data["x1"][()].shape == (2, 3, 4)
def test_color(self): s = Diffraction2D(np.zeros((2, 3, 100, 100))) peak_array = np.empty((2, 3), dtype=object) for index in np.ndindex(peak_array.shape): islice = np.s_[index] peak_array[islice] = np.random.randint(20, 80, (100, 2)) s.add_peak_array_as_markers(peak_array, color="blue") marker0 = list(s.metadata.Markers)[9][1] assert marker0.marker_properties["color"] == "blue"
def test_several_markers_different_peak_array_size(self): peak_array = np.empty((2, 3), dtype=object) peak_array[0, 0] = [[2, 4], [1, 9]] peak_array[0, 1] = [[8, 2]] s = Diffraction2D(np.zeros(shape=(2, 3, 10, 10))) marker_list = mt._get_4d_points_marker_list(peak_array, s.axes_manager.signal_axes, color="red") assert len(marker_list) == 2
def test_get_angle_sector_mask_simple(self): array = np.zeros((10, 10, 10, 10)) array[:, :, 0:5, 0:5] = 1 s = Diffraction2D(array) s.axes_manager.signal_axes[0].offset = -4.5 s.axes_manager.signal_axes[1].offset = -4.5 mask = s.angular_mask(0.0, 0.5 * np.pi) assert mask[:, :, 0:5, 0:5].all() assert not mask[:, :, 5:, :].any() assert not mask[:, :, :, 5:].any()