def get_template_match_results(structure, pattern_list, edc, rot_list, mask=None):
dp_library = get_template_library(structure, pattern_list, edc)
for key in dp_library['A']:
pattern = (dp_library['A'][key]['Sim'].as_signal(2 * half_side_length, 0.025, 1).data)
dp = pxm.ElectronDiffraction([[pattern, pattern], [pattern, pattern]])
library = get_template_library(structure, rot_list, edc)
indexer = IndexationGenerator(dp, library)
return indexer.correlate(mask=mask)
def test_masked_OM(default_structure, rot_list, pattern_list, edc):
dp_library = get_template_library(default_structure, pattern_list, edc)
for key in dp_library['A']:
pattern = (dp_library['A'][key]['Sim'].as_signal(2 * half_side_length, 0.025, 1).data)
dp = pxm.ElectronDiffraction([[pattern, pattern], [pattern, pattern]])
library = get_template_library(default_structure, rot_list, edc)
indexer = IndexationGenerator(dp, library)
mask = hs.signals.Signal1D(([[[1], [1]], [[0], [1]]]))
M = indexer.correlate(mask=mask)
assert np.all(np.isnan(M.inav[0, 1].data))
def test_orientation_mapping_physical(structure, rot_list, pattern_list, edc):
dp_library = get_template_library(structure, pattern_list, edc)
for key in dp_library['A']:
pattern = (dp_library['A'][key]['Sim'].as_signal(2 * half_side_length, 0.025, 1).data)
dp = pxm.ElectronDiffraction([[pattern, pattern], [pattern, pattern]])
library = get_template_library(structure, rot_list, edc)
indexer = IndexationGenerator(dp, library)
M = indexer.correlate()
assert np.all(M.inav[0, 0] == M.inav[1, 0])
assert np.allclose(M.inav[0, 0].isig[:4, 0].data, [0, 2, 0, 0], atol=1e-3)
def create_spot():
z = np.zeros((128, 128))
for r in [4, 3, 2]:
rr, cc = draw.circle(30, 90, radius=r, shape=z.shape)
z[rr, cc] = 1 / r
dp = pxm.ElectronDiffraction(np.asarray([[z, z],
[z,
z]])) # this needs to be in 2x2
return dp
def plot_lib_2d(library, size, scale, sigma, max_r, phase_name, rotation_list):
patterns = np.empty(
(rotation_list.shape[0], rotation_list.shape[1], size, size))
for i in range(rotation_list.shape[0]):
for j in range(rotation_list.shape[1]):
patterns[i, j] = library[phase_name][tuple(
np.rad2deg(mat2euler(rotation_list[i, j],
'rzxz')))]['Sim'].as_signal(
size, sigma, max_r)
pxm.ElectronDiffraction(patterns).plot(cmap='viridis_r')
def get_template_match_results(structure,
pattern_list,
edc,
rot_list,
mask=None,
inplane_rotations=[0]):
dp_library = get_template_library(structure, pattern_list, edc)
for sim in dp_library['A']['simulations']:
pattern = (sim.as_signal(2 * half_side_length, 0.025, 1).data)
dp = pxm.ElectronDiffraction([[pattern, pattern], [pattern, pattern]])
library = get_template_library(structure, rot_list, edc)
indexer = IndexationGenerator(dp, library)
return indexer.correlate(mask=mask, inplane_rotations=inplane_rotations)
def test_marker_placement_correct_beta():
dps = []
dp_cord_list = np.divide(generate_dp_cord_list(), 80)
max_r = np.max(dp_cord_list) + 0.1
for coords in dp_cord_list:
dp_sim = DiffractionSimulation(coordinates=coords,
intensities=np.ones_like(coords[:, 0]))
dps.append(dp_sim.as_signal(144, 0.025, max_r).data) # stores a numpy array of pattern
dp = pxm.ElectronDiffraction(np.array([dps[0:2], dps[2:]])) # now from a 2x2 array of patterns
dp.set_diffraction_calibration(2 * max_r / (144))
local_plotter(dp, dp_cord_list)
# This is human assessed, if you see this comment, you should check it
assert True
def test_marker_placement_correct_alpha():
dps = []
dp_cord_list = generate_dp_cord_list()
for coords in dp_cord_list:
back = np.zeros((144, 144))
x = coords.astype(int)[0, 0]
y = coords.astype(int)[0, 1]
back[x, y] = 1
dps.append(back.T) # stores a numpy array of pattern, This is dangerous (T everywhere)
dp = pxm.ElectronDiffraction(np.array([dps[0:2], dps[2:]]))
local_plotter(dp, dp_cord_list)
# This is human assessed, if you see this comment, you should check it
assert True
def create_sample(edc, structure, angle_start, angle_change):
dps = []
for orientation in create_pair(angle_start, angle_change):
axis, angle = euler2axangle(orientation[0], orientation[1],
orientation[2], 'rzxz')
rotation = RotationTransformation(axis, angle, angle_in_radians=True)
rotated_structure = rotation.apply_transformation(structure)
data = edc.calculate_ed_data(
rotated_structure,
reciprocal_radius=0.9, #avoiding a reflection issue
with_direct_beam=False)
dps.append(data.as_signal(2 * half_side_length, 0.025, 1).data)
dp = pxm.ElectronDiffraction([dps[0:2], dps[2:]])
dp.set_diffraction_calibration(1 / half_side_length)
return dp
def update_correlation_list(_=None):
reciprocal_angstrom_per_pixel = slider_scale.val
beam_energy = slider_energy.val
specimen_thickness = slider_thick.val
structure_info = structures[current_structure]
rotation_list_resolution = np.deg2rad(1)
phase_descriptions = [(structure_info['name'], structure_info['structure'],
structure_info['system'])]
inplane_rotations = [[np.deg2rad(103)]]
diffraction_library, structure_library = create_diffraction_library(
specimen_thickness, beam_energy, reciprocal_angstrom_per_pixel,
rotation_list_resolution, phase_descriptions, inplane_rotations,
target_pattern_dimension_pixels)
# Set up the indexer and get the indexation results
data_dir = r'D:\Dokumenter/MTNANO/Prosjektoppgave/Data/'
experimental_pattern_filename = data_dir + 'SPED_data_GaAs_NW/gen/Julie_180510_SCN45_FIB_a_three_phase_single_area.hdf5'
dp = pxm.load(experimental_pattern_filename, lazy=True).inav[0:1, 0:1]
dp = pxm.ElectronDiffraction(dp)
pattern_indexer = IndexationGenerator(dp, diffraction_library)
template_matching_results = pattern_indexer.correlate(
n_largest=structure_library.orientations[0].shape[0],
keys=[structure_info['name']],
parallel=False) # This is slower in parallel
global current_rotation_list
print(template_matching_results.data[0, 0].shape)
current_rotation_list = template_matching_results.isig[1:4, :].data[0, 0]
correlations = template_matching_results.isig[4, :].data[0, 0]
global current_rotation_list_signals
current_rotation_list_signals = []
print(correlations.argmax(), current_rotation_list[correlations.argmax()])
update_rotation(current_rotation_list, correlations)
fig.canvas.draw_idle()
def create_library():
dps = []
half_side_length = 72
half_shape = (half_side_length, half_side_length)
num_orientations = 11
simulations = np.empty(num_orientations, dtype='object')
orientations = np.empty(num_orientations, dtype='object')
pixel_coords = np.empty(num_orientations, dtype='object')
intensities = np.empty(num_orientations, dtype='object')
# Creating the matchresults.
for alpha in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
coords = (np.random.rand(5, 2) -
0.5) * 2 # zero mean, range from -1 to +1
dp_sim = DiffractionSimulation(coordinates=coords,
intensities=np.ones_like(coords[:, 0]),
calibration=1 / half_side_length)
simulations[alpha] = dp_sim
orientations[alpha] = (alpha, alpha, alpha)
pixel_coords[alpha] = (dp_sim.calibrated_coordinates[:, :2] +
half_shape).astype(int)
intensities[alpha] = dp_sim.intensities
if alpha < 4:
dps.append(
dp_sim.as_signal(2 * half_side_length, 0.075,
1).data) # stores a numpy array of pattern
library = DiffractionLibrary()
library["Phase"] = {
'simulations': simulations,
'orientations': orientations,
'pixel_coords': pixel_coords,
'intensities': intensities,
}
dp = pxm.ElectronDiffraction([dps[0:2],
dps[2:]]) # now from a 2x2 array of patterns
return dp, library
library = dict()
half_shape = (half_side_length, half_side_length)
library["Phase"] = {}
# Creating the matchresults.
for alpha in [0, 1, 2, 3]:
coords = (np.random.rand(5, 2) - 0.5) * 2 #zero mean, range from -1 to +1
dp_sim = DiffractionSimulation(coordinates=coords,
intensities=np.ones_like(coords[:, 0]),
calibration=1 / half_side_length)
dp_sim_list.append(dp_sim) #stores the simulations
dps.append(dp_sim.as_signal(2 * half_side_length, 0.075,
1).data) #stores a numpy array of pattern
dp = pxm.ElectronDiffraction([dps[0:2],
dps[2:]]) #now from a 2x2 array of patterns
for alpha in np.arange(0, 10, 1):
rotation = (alpha, 0, 0)
if rotation[0] < 4:
library = create_library_entry(library, rotation,
dp_sim_list[rotation[0]])
else:
local_cords = np.random.rand(5, 2)
pat = DiffractionSimulation(coordinates=local_cords,
intensities=np.ones_like(local_cords[:,
0]))
library = create_library_entry(library, rotation, pat)
indexer = IndexationGenerator(dp, library)
match_results = indexer.correlate()
