def test_template_get_crystallographic_map(dp_template_match_result,
sp_template_match_result):
# Assertion free test, as the tests in test_indexation_utils do the heavy
# lifting
match_results = np.array(
np.vstack((dp_template_match_result[0], sp_template_match_result[0])))
match_results = TemplateMatchingResults(match_results)
cryst_map = match_results.get_crystallographic_map()
assert cryst_map.method == "template_matching"
def correlate(self, n_largest=5, mask=None, *args, **kwargs):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values are returned.
mask : Array
Array with the same size as signal (in navigation) or None
*args : arguments
Arguments passed to map().
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
Navigation axes of the electron diffraction signal containing
correlation results for each diffraction pattern, in the form
[Library Number , [z, x, z], Correlation Score]
"""
signal = self.signal
library = self.library
if mask is None:
# Index at all real space pixels
mask = 1
# TODO: Add extra methods
no_extra_methods_yet = True
if no_extra_methods_yet:
# adds a normalisation to library
for phase in library.keys():
norm_array = np.ones(
library[phase]
['intensities'].shape[0]) # will store the norms
for i, intensity_array in enumerate(
library[phase]['intensities']):
norm_array[i] = np.linalg.norm(intensity_array)
library[phase][
'pattern_norms'] = norm_array # puts this normalisation into the library
matches = signal.map(correlate_library,
library=library,
n_largest=n_largest,
mask=mask,
inplace=False,
**kwargs)
matching_results = TemplateMatchingResults(matches)
matching_results = transfer_navigation_axes(matching_results, signal)
return matching_results
def correlate(self, n_largest=5, keys=[], mask=None, *args, **kwargs):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values are returned.
keys : list
If more than one phase present in library it is recommended that
these are submitted. This allows a mapping from the number to the
phase. For example, keys = ['si','ga'] will have an output with 0
for 'si' and 1 for 'ga'.
mask : Array
Array with the same size as signal (in navigation) True False
*args : arguments
Arguments passed to map().
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
Navigation axes of the electron diffraction signal containing
correlation results for each diffraction pattern, in the form
[Library Number , [z, x, z], Correlation Score]
"""
signal = self.signal
library = self.library
if mask is None:
# index at all real space pixels
sig_shape = signal.axes_manager.navigation_shape
mask = hs.signals.Signal1D(np.ones(
(sig_shape[0], sig_shape[1], 1)))
matches = signal.map(correlate_library,
library=library,
n_largest=n_largest,
keys=keys,
mask=mask,
inplace=False,
**kwargs)
matching_results = TemplateMatchingResults(matches)
matching_results = transfer_navigation_axes(matching_results, signal)
return matching_results
def correlate(
self,
n_largest=5,
method="fast_correlation",
mask=None,
print_help=False,
**kwargs,
):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values for each phase are returned.
method : str
Name of method used to compute correlation between templates and diffraction patterns. Can be
'fast_correlation' or 'zero_mean_normalized_correlation'.
mask : Array
Array with the same size as signal (in navigation) or None
print_help : bool
Display information about the method used.
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
"""
signal = self.signal
library = self.library
method_dict = {
"fast_correlation": fast_correlation,
"zero_mean_normalized_correlation":
zero_mean_normalized_correlation,
}
if mask is None:
# Index at all real space pixels
mask = 1
# tests if selected method is valid and can print help for selected method.
chosen_function = select_method_from_method_dict(
method, method_dict, print_help)
# adds a normalisation to library #TODO: Port to diffsims
for phase in library.keys():
# initialise a container for the norms
norm_array = np.ones(library[phase]["intensities"].shape[0])
for i, intensity_array in enumerate(library[phase]["intensities"]):
norm_array[i] = np.linalg.norm(intensity_array)
library[phase]["pattern_norms"] = norm_array
matches = signal.map(
_correlate_templates,
library=library,
n_largest=n_largest,
method=method,
mask=mask,
inplace=False,
**kwargs,
)
matching_results = TemplateMatchingResults(matches)
return matching_results
def test_TemplateMatchingResults_to_crystal_map():
t = TemplateMatchingResults(np.empty((10,10,10,5)))
return t.to_crystal_map()
def correlate(
self,
n_largest=5,
method="fast_correlation",
mask=None,
print_help=False,
*args,
**kwargs,
):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values are returned.
method : str
Name of method used to compute correlation between templates and diffraction patterns. Can be
'fast_correlation', 'full_frame_correlation' or 'zero_mean_normalized_correlation'.
mask : Array
Array with the same size as signal (in navigation) or None
print_help : bool
Display information about the method used.
*args : arguments
Arguments passed to map().
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
Navigation axes of the electron diffraction signal containing
correlation results for each diffraction pattern, in the form
[Library Number , [z, x, z], Correlation Score]
"""
signal = self.signal
library = self.library
method_dict = {
"fast_correlation": fast_correlation,
"zero_mean_normalized_correlation":
zero_mean_normalized_correlation,
"full_frame_correlation": full_frame_correlation,
}
if mask is None:
# Index at all real space pixels
mask = 1
# tests if selected method is a valid argument, and can print help for selected method.
chosen_function = select_method_from_method_dict(
method, method_dict, print_help)
if method in ["fast_correlation", "zero_mean_normalized_correlation"]:
# adds a normalisation to library
for phase in library.keys():
norm_array = np.ones(
library[phase]
["intensities"].shape[0]) # will store the norms
for i, intensity_array in enumerate(
library[phase]["intensities"]):
norm_array[i] = np.linalg.norm(intensity_array)
library[phase][
"pattern_norms"] = norm_array # puts this normalisation into the library
matches = signal.map(
correlate_library,
library=library,
n_largest=n_largest,
method=method,
mask=mask,
inplace=False,
**kwargs,
)
elif method in ["full_frame_correlation"]:
shape = signal.data.shape[-2:]
size = 2 * np.array(shape) - 1
fsize = [optimal_fft_size(a, real=True) for a in (size)]
if not (np.asarray(size) + 1 == np.asarray(fsize)).all():
raise ValueError(
"Please select input signal and templates of dimensions 2**n X 2**n"
)
library_FT_dict = get_library_FT_dict(library, shape, fsize)
matches = signal.map(
correlate_library_from_dict,
template_dict=library_FT_dict,
n_largest=n_largest,
method=method,
mask=mask,
inplace=False,
**kwargs,
)
matching_results = TemplateMatchingResults(matches)
matching_results = transfer_navigation_axes(matching_results, signal)
return matching_results
def correlate(self,
n_largest=5,
method='fast_correlation',
mask=None,
print_help=False,
*args,
**kwargs):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values are returned.
method : str
Name of method used to compute correlation between templates and diffraction patterns. Can be
'fast_correlation' or 'zero_mean_normalized_correlation'.
mask : Array
Array with the same size as signal (in navigation) or None
print_help : bool
Display information about the method used.
*args : arguments
Arguments passed to map().
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
Navigation axes of the electron diffraction signal containing
correlation results for each diffraction pattern, in the form
[Library Number , [z, x, z], Correlation Score]
"""
signal = self.signal
library = self.library
method_dict = {
'fast_correlation': fast_correlation,
'zero_mean_normalized_correlation':
zero_mean_normalized_correlation
}
if mask is None:
# Index at all real space pixels
mask = 1
#tests if selected method is a valid argument, and can print help for selected method.
chosen_function = select_method_from_method_dict(
method, method_dict, print_help)
# adds a normalisation to library
for phase in library.keys():
norm_array = np.ones(
library[phase]['intensities'].shape[0]) # will store the norms
for i, intensity_array in enumerate(library[phase]['intensities']):
norm_array[i] = np.linalg.norm(intensity_array)
library[phase][
'pattern_norms'] = norm_array # puts this normalisation into the library
matches = signal.map(correlate_library,
library=library,
n_largest=n_largest,
method=method,
mask=mask,
inplace=False,
**kwargs)
matching_results = TemplateMatchingResults(matches)
matching_results = transfer_navigation_axes(matching_results, signal)
return matching_results
def correlate(self,
n_largest=5,
mask=None,
inplane_rotations=np.arange(0, 360, 1),
max_peaks=100,
*args,
**kwargs):
"""Correlates the library of simulated diffraction patterns with the
electron diffraction signal.
Parameters
----------
n_largest : int
The n orientations with the highest correlation values are returned.
mask : Array
Array with the same size as signal (in navigation) True False
inplane_rotations : ndarray
Array of inplane rotation angles in degrees. Defaults to 0-360 degrees
at 1 degree resolution.
max_peaks : int
Maximum number of peaks to consider when comparing a template to
the diffraction pattern. The strongest peaks are kept.
*args : arguments
Arguments passed to map().
**kwargs : arguments
Keyword arguments passed map().
Returns
-------
matching_results : TemplateMatchingResults
Navigation axes of the electron diffraction signal containing
correlation results for each diffraction pattern, in the form
[Library Number , [z, x, z], Correlation Score]
"""
signal = self.signal
library = self.library
inplane_rotations = np.deg2rad(inplane_rotations)
num_inplane_rotations = inplane_rotations.shape[0]
sig_shape = signal.axes_manager.signal_shape
signal_half_width = sig_shape[0] / 2
if mask is None:
# Index at all real space pixels
mask = 1
# Create a copy of the library, cropping and padding the peaks to match
# max_peaks. Also create rotated pixel coordinates according to
# inplane_rotations
rotation_matrices_2d = np.array([[[np.cos(t), np.sin(t)],
[-np.sin(t), np.cos(t)]]
for t in inplane_rotations])
cropped_library = {}
for phase_name, phase_entry in library.items():
num_orientations = len(phase_entry['orientations'])
intensities_jagged = phase_entry['intensities']
intensities = np.zeros((num_orientations, max_peaks))
pixel_coords_jagged = phase_entry['pixel_coords']
pixel_coords = np.zeros(
(num_inplane_rotations, num_orientations, max_peaks, 2))
for i in range(num_orientations):
num_peaks = min(pixel_coords_jagged[i].shape[0], max_peaks)
highest_intensity_indices = np.argpartition(
intensities_jagged[i], -num_peaks)[-num_peaks:]
intensities[i, :num_peaks] = intensities_jagged[i][
highest_intensity_indices]
# Get and compute pixel coordinates for all rotations about the
# center, clipped to the detector size and rounded to integer positions.
pixel_coords[:, i, :num_peaks] = np.clip(
(signal_half_width + rotation_matrices_2d
@ (pixel_coords_jagged[i][highest_intensity_indices].T -
signal_half_width)).transpose(0, 2, 1),
a_min=0,
a_max=np.array(sig_shape) - 1)
np.rint(pixel_coords, out=pixel_coords)
cropped_library[phase_name] = {
'orientations': phase_entry['orientations'],
'pixel_coords': pixel_coords.astype('int'),
'intensities': intensities,
'pattern_norms': np.linalg.norm(intensities, axis=1),
}
matches = signal.map(correlate_library,
library=cropped_library,
n_largest=n_largest,
mask=mask,
inplace=False,
**kwargs)
matching_results = TemplateMatchingResults(matches)
matching_results = transfer_navigation_axes(matching_results, signal)
return matching_results