def test_load_energy( self, energy, energy_slice, desired_shape, desired_mean_energies ): """Ensure desired energy parameters can be passed.""" s = load(EMSOFT_FILE, energy=energy, hemisphere="both") assert s.data.shape == desired_shape s2 = load(EMSOFT_FILE, projection="lambert", energy=energy, hemisphere="north") sig_indx = s2.axes_manager.signal_indices_in_array assert np.allclose(s2.nanmean(axis=sig_indx).data, desired_mean_energies) with File(EMSOFT_FILE, mode="r") as f: mp_lambert_north = f["EMData/EBSDmaster/mLPNH"][:][0][energy_slice] assert np.allclose(s2.data, mp_lambert_north)
def test_get_rgb_image_rois(self): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) # Get channels by ROIs rois1 = [ vbse_gen.roi_from_grid(i) for i in np.ndindex(vbse_gen.grid_shape) ][:3] vbse_rgb_img1 = vbse_gen.get_rgb_image(r=rois1[0], g=rois1[1], b=rois1[2]) # Get channels from grid tile indices rois2 = [(0, 0), (0, 1), (0, 2)] vbse_rgb_img2 = vbse_gen.get_rgb_image(r=rois2[0], g=rois2[1], b=rois2[2]) assert isinstance(vbse_rgb_img1, VirtualBSEImage) assert vbse_rgb_img1.data.dtype == np.dtype([("R", "u1"), ("G", "u1"), ("B", "u1")]) vbse_rgb_img1.change_dtype(np.uint8) vbse_rgb_img2.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img1.data, vbse_rgb_img2.data)
def test_versions(self, oxford_binary_file, ver, desired_nav_shape): """Ensure that versions 0, 1 and > 1 can be read.""" s = kp.load(oxford_binary_file.name) assert s.axes_manager.navigation_shape[::-1] == desired_nav_shape if ver > 0: assert s.original_metadata.has_item("beam_x") assert s.original_metadata.has_item("beam_y")
def test_get_decomposition_model_write( self, dummy_signal, components, mean_intensity, tmp_path ): lazy_signal = dummy_signal.as_lazy() dtype_in = lazy_signal.data.dtype # Decomposition lazy_signal.change_dtype(np.float32) lazy_signal.decomposition(algorithm="PCA", output_dimension=9) lazy_signal.change_dtype(dtype_in) with pytest.raises(AttributeError, match="Output directory has to be"): lazy_signal.get_decomposition_model_write() # Current time stamp is added to output file name lazy_signal.get_decomposition_model_write(dir_out=tmp_path) # Reload file to check... fname_out = "tests.h5" lazy_signal.get_decomposition_model_write( components=components, dir_out=tmp_path, fname_out=fname_out ) s_reload = load(os.path.join(tmp_path, fname_out)) # ... data type, data shape and mean intensity assert s_reload.data.dtype == lazy_signal.data.dtype assert s_reload.data.shape == lazy_signal.data.shape assert np.allclose(s_reload.data.mean(), mean_intensity, atol=1e-1)
def test_compressed_patterns_raises(self, oxford_binary_file): """Ensure explanatory error message is raised when a file we cannot read is tried to be read from. """ with pytest.raises(NotImplementedError, match="Cannot read compressed"): _ = kp.load(oxford_binary_file.name)
def test_not_all_patterns_present(self, oxford_binary_file): """Ensure files with only non-indexed patterns can be read.""" s = kp.load(oxford_binary_file.name) assert s.axes_manager.navigation_shape == (5, ) # (2, 2) is missing assert np.allclose(s.original_metadata.beam_y, [0, 1, 1, 1, 0]) assert np.allclose(s.original_metadata.beam_x, [2, 0, 1, 2, 0])
def test_load(self): """Load into memory.""" s = kp.load(OXFORD_FILE) s2 = kp.data.nickel_ebsd_small() assert isinstance(s, kp.signals.EBSD) assert np.allclose(s.data, s2.data)
def test_projection_lambert(self): s = load(EMSOFT_FILE, projection="lambert", hemisphere="both") axes_manager = setup_axes_manager() assert s.data.shape == (2, 11, 13, 13) assert s.axes_manager.as_dictionary() == axes_manager
def test_set_grid_shape(self, grid_shape, desired_rows, desired_cols): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_gen.grid_shape = grid_shape assert vbse_gen.grid_shape == grid_shape assert np.allclose(vbse_gen.grid_rows, desired_rows) assert np.allclose(vbse_gen.grid_cols, desired_cols)
def test_init_xmap(self, dummy_signal): """The attribute is set correctly.""" assert dummy_signal.xmap is None ssim = load(EMSOFT_FILE) xmap = ssim.xmap assert isinstance(xmap, CrystalMap) assert xmap.phases[0].name == "ni"
def test_plot_grid_text_color(self, color): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) p = vbse_gen.plot_grid(color=color) assert p.metadata.Markers["text"].marker._color == color close("all")
def test_background_file_not_found(self): fname_orig = "Background calibration pattern.bmp" file_orig = os.path.join(NORDIF_DIR, fname_orig) file_new = os.path.join(NORDIF_DIR, file_orig + ".bak") os.rename(file_orig, file_new) with pytest.warns(UserWarning, match="Could not read static"): _ = load(os.path.join(NORDIF_DIR, "Setting.txt")) os.rename(file_new, file_orig)
def test_get_rgb_image_lazy(self): s = load(KIKUCHIPY_FILE, lazy=True) vbse_gen = VirtualBSEGenerator(s) assert isinstance(vbse_gen.signal, LazyEBSD) vbse_rgb_img = vbse_gen.get_rgb_image(r=(0, 0), g=(0, 1), b=(0, 2)) assert isinstance(vbse_rgb_img.data, np.ndarray)
def test_load_lazy(self): """Load lazily.""" s = kp.load(OXFORD_FILE, lazy=True) s2 = kp.data.nickel_ebsd_small() assert isinstance(s, kp.signals.LazyEBSD) assert isinstance(s.data, da.Array) s.compute() assert np.allclose(s.data, s2.data)
def test_get_rgb_image_dtype(self): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_rgb_img = vbse_gen.get_rgb_image(r=(0, 0), g=(0, 1), b=(0, 2), dtype_out=np.uint16) assert vbse_rgb_img.data.dtype == np.dtype([("R", "u2"), ("G", "u2"), ("B", "u2")])
def test_load_lazy(self, projection): """The Lambert projection's southern hemisphere is stored chunked. """ s = load(EMSOFT_FILE, projection=projection, hemisphere="south", lazy=True) assert isinstance(s, LazyEBSDMasterPattern) s.compute() assert isinstance(s, EBSDMasterPattern)
def test_file_reader(self): s = load(EMSOFT_FILE) axes_manager = setup_axes_manager(["energy", "height", "width"]) assert s.data.shape == (11, 13, 13) assert_dictionary(s.axes_manager.as_dictionary(), axes_manager) assert_dictionary(s.metadata.as_dictionary(), METADATA) signal_indx = s.axes_manager.signal_indices_in_array assert np.allclose(s.max(axis=signal_indx).data, s.axes_manager["energy"].axis)
def test_get_rgb_image_contrast_stretching(self, percentile, desired_mean_intensity): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_rgb_img = vbse_gen.get_rgb_image(r=(0, 0), g=(0, 1), b=(0, 2), percentiles=percentile) vbse_rgb_img.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img.data.mean(), desired_mean_intensity)
def test_get_rgb_alpha(self, alpha_add, desired_mean_intensity): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) alpha = np.arange(9).reshape((3, 3)) alpha[0] += alpha_add vbse_rgb_img = vbse_gen.get_rgb_image( r=(0, 0), g=(0, 1), b=(0, 2), alpha=alpha ) vbse_rgb_img.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img.data.mean(), desired_mean_intensity)
def test_axes_manager_transfer(self): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_img = vbse_gen.get_images_from_grid() s_nav_axes = s.axes_manager.navigation_axes vbse_sig_axes = vbse_img.axes_manager.signal_axes assert all( [vbse_sig_axes[i].scale == s_nav_axes[i].scale for i in range(2)]) assert all( [vbse_sig_axes[i].name == s_nav_axes[i].name for i in range(2)]) assert all( [vbse_sig_axes[i].units == s_nav_axes[i].units for i in range(2)])
def test_adaptive_histogram_equalization(self): """Test setup of equalization only. Tests of the result of the actual equalization are found elsewhere. """ s = load(KIKUCHIPY_FILE) # These window sizes should work without issue for kernel_size in [None, 10]: s.adaptive_histogram_equalization(kernel_size=kernel_size) # These window sizes should throw errors with pytest.raises(ValueError, match="invalid literal for int()"): s.adaptive_histogram_equalization(kernel_size=("wrong", "size")) with pytest.raises(ValueError, match="Incorrect value of `shape"): s.adaptive_histogram_equalization(kernel_size=(10, 10, 10))
def test_get_rgb_alpha_signal(self): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_img = s.get_virtual_bse_intensity(roi=RectangularROI(0, 0, 10, 10)) vbse_rgb_img1 = vbse_gen.get_rgb_image( r=(0, 1), g=(0, 2), b=(0, 3), alpha=vbse_img ) vbse_rgb_img2 = vbse_gen.get_rgb_image( r=(0, 1), g=(0, 2), b=(0, 3), alpha=vbse_img.data, ) vbse_rgb_img1.change_dtype(np.uint8) vbse_rgb_img2.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img1.data, vbse_rgb_img2.data)
def test_get_rgb_multiple_rois_per_channel(self, r, g, b, desired_mean_intensity): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_rgb_img1 = vbse_gen.get_rgb_image(r=r, g=g, b=b) vbse_rgb_img1.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img1.data.mean(), desired_mean_intensity) roi_r = vbse_gen.roi_from_grid(r) roi_g = vbse_gen.roi_from_grid(g) roi_b = vbse_gen.roi_from_grid(b) vbse_rgb_img2 = vbse_gen.get_rgb_image(r=roi_r, g=roi_g, b=roi_b) vbse_rgb_img2.change_dtype(np.uint8) assert np.allclose(vbse_rgb_img1.data, vbse_rgb_img2.data)
async def preview_dictionary(req: DictionaryIndexingIn): if req.ebsd_info.uid not in kp_signals: raise HTTPException(status_code=404, detail="Patterns not found") s = kp_signals[req.ebsd_info.uid] detector = kp.detectors.EBSDDetector( shape=s.axes_manager.signal_shape[::-1], pc=req.detector.pc, sample_tilt=req.detector.sample_tilt, convention=req.detector.pc_convention, tilt=req.detector.camera_tilt, ) res = PreviewDictionary(patterns=[]) if req.preview_angles: euler = np.array(req.preview_angles) else: euler = np.array([0.0, 0.0, 0.0]) for mp_req in req.masterpatterns: mp = kp.load( mp_req.filepath, projection=mp_req.projection, hemisphere="both", energy=mp_req.energy, ) sim = mp.get_patterns( rotations=Rotation.from_euler(np.deg2rad(euler)), detector=detector, energy=mp_req.energy, compute=True, ) svg_string = io.StringIO() plt.figure() plt.imshow(sim.data[0], cmap="gray") plt.title( f"{mp.phase.name.capitalize()}\n($\phi_1, \Phi, \phi_2)$ = {np.array_str(euler, precision=1)}" ) plt.axis("off") plt.savefig(svg_string, format="svg", bbox_inches="tight", transparent=True) svg_string.seek(0) res.patterns.append(svg_string.getvalue()) return res
def test_save_load_hspy(self, save_path_hdf5): s = load(EMSOFT_FILE) axes_manager = setup_axes_manager(["energy", "height", "width"]) assert isinstance(s, EBSDMasterPattern) assert s.axes_manager.as_dictionary() == axes_manager assert_dictionary(s.metadata.as_dictionary(), METADATA) s.save(save_path_hdf5) s2 = hs_load(save_path_hdf5, signal_type="EBSDMasterPattern") assert isinstance(s2, EBSDMasterPattern) assert s2.axes_manager.as_dictionary() == axes_manager assert_dictionary(s2.metadata.as_dictionary(), METADATA) s3 = hs_load(save_path_hdf5) assert isinstance(s3, Signal2D) s3.set_signal_type("EBSDMasterPattern") assert isinstance(s3, EBSDMasterPattern) assert s3.axes_manager.as_dictionary() == axes_manager assert_dictionary(s.metadata.as_dictionary(), METADATA)
def test_plot_grid(self, grid_shape, desired_n_markers): s = load(KIKUCHIPY_FILE) vbse_gen = VirtualBSEGenerator(s) vbse_gen.grid_shape = grid_shape rgb_channels = [(0, 0), (0, 1), (1, 0)] pattern_idx = (2, 2) p = vbse_gen.plot_grid(pattern_idx=pattern_idx, rgb_channels=rgb_channels) p2 = vbse_gen.plot_grid() # Check data type and values assert isinstance(p, EBSD) assert np.allclose(p.data, s.inav[pattern_idx].data) assert np.allclose(p2.data, s.inav[0, 0].data) # Check markers assert len(p.metadata.Markers) == desired_n_markers assert p.metadata.Markers.has_item("text") assert p.metadata.Markers["text"].marker._color == "r" assert p.metadata.Markers["horizontal_line"].marker._color == "w" assert p.metadata.Markers["rectangle"].marker._edgecolor == (1, 0, 0, 1) close("all")
def test_get_patterns(self): # Ni Test EMSOFT_EBSD_FILE = os.path.join( DIR_PATH, "../../data/emsoft_ebsd/EBSD_TEST_Ni.h5") emsoft_key = load(EMSOFT_EBSD_FILE) emsoft_key = emsoft_key.data[0] angles = np.array((120, 45, 60)) r = Rotation.from_euler(np.radians(angles)) kp_mp = nickel_ebsd_master_pattern_small(projection="lambert", hemisphere="both") kp_pattern = kp_mp.get_patterns(rotations=r, detector=self.detector, energy=20, dtype_out=np.uint8) kp_pat = kp_pattern.data[0].compute() ncc1 = ncc(kp_pat, emsoft_key) ndp1 = ndp(kp_pat, emsoft_key) assert ncc1 >= 0.935 assert ndp1 >= 0.935 detector_shape = self.detector.shape r2 = Rotation.from_euler(((0, 0, 0), (1, 1, 1), (2, 2, 2))) mp_a = EBSDMasterPattern(np.zeros((2, 10, 11, 11))) print(mp_a.axes_manager) mp_a.axes_manager[0].name = "hemisphere" mp_a.axes_manager[1].name = "energy" mp_a.projection = "lambert" mp_a.phase = Phase("Ni", 225) out_a = mp_a.get_patterns(r2, self.detector, 5) assert isinstance(out_a, LazyEBSD) desired_data_shape = (3, ) + detector_shape[::-1] assert out_a.axes_manager.shape == desired_data_shape mp_b = EBSDMasterPattern(np.zeros((10, 11, 11))) mp_b.axes_manager[0].name = "energy" mp_b.projection = "lambert" mp_b.phase = Phase("Ni", 225) out_b = mp_b.get_patterns(r2, self.detector, 5) assert isinstance(out_b, LazyEBSD) assert out_b.axes_manager.shape == desired_data_shape mp_c = EBSDMasterPattern(np.zeros((11, 11))) mp_c.projection = "lambert" mp_c.phase = Phase("Ni", 225) out_c = mp_c.get_patterns(r2, self.detector, 5) out_c_2 = mp_c.get_patterns(r2, self.detector, 5, compute=True) assert isinstance(out_c, LazyEBSD) assert isinstance(out_c_2, EBSD) assert out_c.axes_manager.shape == desired_data_shape mp_c2 = EBSDMasterPattern(np.zeros((11, 11))) mp_c2.projection = "lambert" mp_c2.phase = Phase("!Ni", 220) with pytest.raises(AttributeError): mp_c2.get_patterns(r2, self.detector, 5) mp_d = EBSDMasterPattern(np.zeros((2, 11, 11))) with pytest.raises(NotImplementedError): mp_d.get_patterns(r2, self.detector, 5) mp_e = EBSDMasterPattern(np.zeros((10, 11, 11))) mp_e.axes_manager[0].name = "energy" mp_e.projection = "lambert" mp_e.phase = Phase("!Ni", 220) with pytest.raises(AttributeError): mp_e.get_patterns(r2, self.detector, 5) # More than one Projection center is currently not supported so # it should fail d2 = EBSDDetector( shape=(10, 10), px_size=50, pc=((0, 0, 15000), (0, 0, 15000)), convention="emsoft4", tilt=0, sample_tilt=70, ) with pytest.raises(NotImplementedError): mp_c.get_patterns(r2, d2, 5)
# along with kikuchipy. If not, see <http://www.gnu.org/licenses/>. import os import matplotlib.pyplot as plt from kikuchipy.detectors import EBSDDetector from kikuchipy import load data = "/home/hakon/kode/kikuchipy/kikuchipy/data/kikuchipy/patterns.h5" outdir = "/home/hakon/kode/kikuchipy/doc/_static/image" refframe_dir = os.path.join(outdir, "reference_frames") datadir, fname = os.path.split(data) fname, ext = os.path.splitext(fname) s = load(data) s.remove_static_background() s.remove_dynamic_background() s.rescale_intensity(percentiles=(0.5, 99.5)) det = EBSDDetector(shape=(60, 60), pc=[0.4210, 0.2206, 0.5049]) fig, ax = det.plot(coordinates="detector", pattern=s.inav[0, 0].data, show_pc=True, return_fig_ax=True) arrow_dict1 = { "x": 0, "y": 0, "width": det.nrows * 0.01, "head_width": 3,
def _load(filename: str, **kwargs) -> Union[EBSD, EBSDMasterPattern]: allow_download = kwargs.pop("allow_download", False) return load(_fetch(filename, allow_download=allow_download), **kwargs)
matplotlib.rcParams["backend"] = "qt5agg" import matplotlib.pyplot as plt import numpy as np from numpy.fft import fftshift import kikuchipy as kp data = "/home/hakon/kode/kikuchipy/kikuchipy/data/kikuchipy/patterns.h5" data2 = "/home/hakon/phd/data/ni/2020/1/nordif/Pattern.dat" outdir = "/home/hakon/kode/kikuchipy/doc/_static/image" featdir = os.path.join(outdir, "feature_maps") datadir, fname = os.path.split(data) fname, ext = os.path.splitext(fname) s = kp.load(data, lazy=False) s2 = kp.load(data2, lazy=False) # Image quality s3 = s2.deepcopy() s3.remove_static_background() s3.remove_dynamic_background() # Image quality map iq = s3.get_image_quality() x, y = 157, 80 iq_perc = np.percentile(iq, q=(0, 99.8)) plt.figure() plt.imshow(iq, vmin=iq_perc[0], vmax=iq_perc[1], cmap="gray") plt.colorbar(label="Image quality") plt.savefig( os.path.join(featdir, "iq.png"),