def test_passing_results_from_get_patterns(self):
s = nickel_ebsd_small()
print(s)
s.remove_static_background()
s.remove_dynamic_background()
mp = nickel_ebsd_master_pattern_small(projection="lambert")
r = Rotation([
[0.9522, -0.0151, -0.2883, 0.1001], # Left grain
[0.9534, 0.0465, -0.2187, -0.2026], # Right grain
[0.8876, -0.2312, 0.3364, -0.2131], # 50th best match
])
detector = EBSDDetector(
shape=s.axes_manager.signal_shape[::-1],
pc=[0.421, 0.7794, 0.5049],
convention="tsl",
sample_tilt=70,
)
sim = mp.get_patterns(rotations=r, detector=detector, energy=20)
xmap = s.match_patterns(sim, keep_n=1)
scores = xmap.scores.reshape(xmap.size, )
sim_idx = xmap.simulation_indices.reshape(xmap.size, )
assert np.allclose(
scores,
[0.197, 0.188, 0.207, 0.198, 0.186, 0.225, 0.191, 0.191, 0.206],
atol=1e-3,
)
assert np.allclose(sim_idx, [0, 1, 1, 0, 1, 1, 0, 1, 1])
def test_detector_azimuthal(self):
"""Test that setting an azimuthal angle of a detector results in
different patterns.
"""
det1 = self.detector
# Looking from the detector toward the sample, the left part of
# the detector is closer to the sample than the right part
det2 = det1.deepcopy()
det2.azimuthal = 10
# Looking from the detector toward the sample, the right part of
# the detector is closer to the sample than the left part
det3 = det1.deepcopy()
det3.azimuthal = -10
mp = nickel_ebsd_master_pattern_small(projection="lambert")
r = Rotation.identity()
kwargs = dict(rotations=r, energy=20, compute=True, dtype_out=np.uint8)
sim1 = mp.get_patterns(detector=det1, **kwargs)
sim2 = mp.get_patterns(detector=det2, **kwargs)
sim3 = mp.get_patterns(detector=det3, **kwargs)
assert not np.allclose(sim1.data, sim2.data)
assert np.allclose(sim2.data.mean(), 43.56, atol=1e-2)
assert np.allclose(sim3.data.mean(), 43.39, atol=1e-2)
def test_get_patterns_navigation_shape_raises(self):
mp = nickel_ebsd_master_pattern_small(projection="lambert")
r = Rotation(np.random.uniform(low=0, high=1, size=(1, 2, 3, 4)))
detector = kp.detectors.EBSDDetector(shape=(60, 60))
with pytest.raises(ValueError,
match="`rotations` can only have one or two "):
_ = mp.get_patterns(rotations=r, detector=detector, energy=20)
def test_load_nickel_ebsd_master_pattern_small_kwargs(
self, projection, hemisphere, desired_shape):
"""Master patterns in both stereographic and Lambert projections
can be loaded as expected.
"""
mp = data.nickel_ebsd_master_pattern_small(projection=projection,
hemisphere=hemisphere)
assert isinstance(mp, EBSDMasterPattern)
assert mp.data.shape == desired_shape
assert np.issubdtype(mp.data.dtype, np.uint8)
assert mp.projection == projection
assert mp.hemisphere == hemisphere
mp_lazy = data.nickel_ebsd_master_pattern_small(lazy=True)
assert isinstance(mp_lazy, LazyEBSDMasterPattern)
assert isinstance(mp_lazy.data, Array)
def test_get_patterns_dtype(self):
r = Rotation.identity()
mp = nickel_ebsd_master_pattern_small(projection="lambert")
dtype_out = np.dtype("float64")
pattern = mp.get_patterns(rotations=r,
detector=self.detector,
energy=20,
dtype_out=dtype_out)
assert pattern.data.dtype == dtype_out
def test_simulated_patterns_xmap_detector(self):
mp = nickel_ebsd_master_pattern_small(projection="lambert")
r = Rotation.from_euler([[0, 0, 0], [0, np.pi / 2, 0]])
detector = EBSDDetector(
shape=(60, 60),
pc=[0.5, 0.5, 0.5],
sample_tilt=70,
convention="tsl",
)
s = mp.get_patterns(rotations=r, detector=detector, energy=20)
assert np.allclose(s.xmap.rotations.to_euler(), r.to_euler())
assert s.xmap.phases.names == [mp.phase.name]
assert s.xmap.phases[0].point_group.name == mp.phase.point_group.name
assert s.detector.shape == detector.shape
assert np.allclose(s.detector.pc, detector.pc)
assert s.detector.sample_tilt == detector.sample_tilt
def test_properties(self, projection, hemisphere):
mp = nickel_ebsd_master_pattern_small(projection=projection,
hemisphere=hemisphere,
lazy=True)
assert mp.projection == projection
assert mp.hemisphere == hemisphere
# Deepcopy
mp2 = mp.deepcopy()
assert mp2.projection == projection
mp2.projection = "gnomonic"
assert mp2.projection != projection
assert mp2.hemisphere == hemisphere
mp2.hemisphere = "west"
assert mp2.hemisphere != hemisphere
assert mp2.phase.point_group.name == mp.phase.point_group.name
mp2.phase.space_group = 220
assert mp2.phase.point_group.name != mp.phase.point_group.name
def test_original_metadata_save_load_cycle(self, save_path_hdf5):
s = nickel_ebsd_master_pattern_small()
omd_dict_keys = s.original_metadata.as_dictionary().keys()
desired_keys = [
"BetheList",
"EBSDMasterNameList",
"MCCLNameList",
"AtomData",
"Atomtypes",
"CrystalSystem",
"LatticeParameters",
"Natomtypes",
]
assert [k in omd_dict_keys for k in desired_keys]
s.save(save_path_hdf5)
s2 = hs_load(save_path_hdf5, signal_type="EBSDMasterPattern")
assert isinstance(s2, EBSDMasterPattern)
omd_dict_keys2 = s2.original_metadata.as_dictionary().keys()
assert [k in omd_dict_keys2 for k in desired_keys]
def test_get_patterns_navigation_shape(self, nav_shape):
mp = nickel_ebsd_master_pattern_small(projection="lambert")
r = Rotation(np.random.uniform(low=0, high=1, size=nav_shape + (4, )))
detector = EBSDDetector(shape=(60, 60))
sim = mp.get_patterns(rotations=r, detector=detector, energy=20)
assert sim.axes_manager.navigation_shape[::-1] == nav_shape
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)
def test_properties(self, projection, hemisphere):
mp = nickel_ebsd_master_pattern_small(projection=projection,
hemisphere=hemisphere)
assert mp.projection == projection
assert mp.hemisphere == hemisphere
def test_load_nickel_ebsd_master_pattern_small(self):
"""Can be read."""
mp = data.nickel_ebsd_master_pattern_small()
assert mp.data.shape == (401, 401)
def test_get_patterns(self):
emsoft_key = load(EMSOFT_EBSD_FILE)
emsoft_key = emsoft_key.data[0]
r = Rotation.from_euler(np.radians([120, 45, 60]))
mp1 = nickel_ebsd_master_pattern_small(projection="lambert",
hemisphere="both")
kp_pattern = mp1.get_patterns(rotations=r,
detector=self.detector,
energy=20,
dtype_out=emsoft_key.dtype)
kp_pat = kp_pattern.data[0].compute()
assert kp_pat.dtype == emsoft_key.dtype
ncc = NormalizedCrossCorrelationMetric(1, 1)
ncc1 = ncc(kp_pat, emsoft_key)
assert ncc1 >= 0.935
ndp = NormalizedDotProductMetric(1, 1)
ndp1 = ndp(kp_pat, emsoft_key)
assert ndp1 >= 0.935
detector_shape = self.detector.shape
r2 = Rotation.from_euler(((0, 0, 0), (1, 1, 1), (2, 2, 2)))
mp2 = kp.signals.EBSDMasterPattern(np.zeros((2, 10, 11, 11)))
mp2.axes_manager[0].name = "hemisphere"
mp2.axes_manager[1].name = "energy"
mp2.projection = "lambert"
mp2.phase = Phase("Ni", 225)
out2 = mp2.get_patterns(r2, self.detector, 5)
assert isinstance(out2, kp.signals.LazyEBSD)
desired_data_shape = (3, ) + detector_shape[::-1]
assert out2.axes_manager.shape == desired_data_shape
mp3 = kp.signals.EBSDMasterPattern(np.zeros((10, 11, 11)))
mp3.axes_manager[0].name = "energy"
mp3.projection = "lambert"
mp3.phase = Phase("Ni", 225)
out3 = mp3.get_patterns(r2, self.detector, 5)
assert isinstance(out3, kp.signals.LazyEBSD)
assert out3.axes_manager.shape == desired_data_shape
mp4 = kp.signals.EBSDMasterPattern(np.zeros((11, 11)))
mp4.projection = "lambert"
mp4.phase = Phase("Ni", 225)
out41 = mp4.get_patterns(r2, self.detector, 5)
out42 = mp4.get_patterns(r2, self.detector, 5, compute=True)
assert isinstance(out41, kp.signals.LazyEBSD)
assert isinstance(out42, kp.signals.EBSD)
assert out41.axes_manager.shape == desired_data_shape
mp5 = kp.signals.EBSDMasterPattern(np.zeros((11, 11)))
mp5.projection = "lambert"
mp5.phase = Phase("!Ni", 220)
with pytest.raises(AttributeError):
_ = mp5.get_patterns(r2, self.detector, 5)
mp6 = kp.signals.EBSDMasterPattern(np.zeros((2, 11, 11)))
with pytest.raises(AttributeError,
match="Master pattern `phase` attribute"):
_ = mp6.get_patterns(r2, self.detector, 5)
mp7 = kp.signals.EBSDMasterPattern(np.zeros((10, 11, 11)))
mp7.axes_manager[0].name = "energy"
mp7.projection = "lambert"
mp7.phase = Phase("!Ni", 220)
with pytest.raises(AttributeError,
match="For point groups without inversion"):
_ = mp7.get_patterns(r2, self.detector, 5)
# More than one PC is currently not supported so should fail
d2 = kp.detectors.EBSDDetector(
shape=(10, 10),
px_size=50,
pc=((0, 0, 15000), (0, 0, 15000)),
convention="emsoft4",
sample_tilt=70,
)
with pytest.raises(NotImplementedError):
_ = mp4.get_patterns(r2, d2, 5)
