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"),
