def get_reduced_intensity(self):
"""Obtains a reduced intensity profile from the radial profile.
Parameters
----------
s_cutoff : list of float
A list of the form [s_min, s_max] to change the s_cutoff
from the fit.
Returns
-------
ri : ReducedIntensity1D
"""
s_scale = self.signal.axes_manager.signal_axes[0].scale
s = np.arange(self.signal.axes_manager.signal_axes[0].size,
dtype='float64')
s *= self.signal.axes_manager.signal_axes[0].scale
reduced_intensity = (2 * np.pi * s * np.divide(
(self.signal.data - self.background_fit), self.normalisation))
ri = ReducedIntensity1D(reduced_intensity)
ri = transfer_navigation_axes(ri, self.signal)
ri = transfer_signal_axes(ri, self.signal)
return ri
def rotate_strain_basis(self, x_new):
""" Rotates a strain map to a new basis.
Parameters
----------
x_new : list
The coordinates of a point on the new 'x' axis
Returns
-------
StrainMap :
StrainMap in the new (rotated) basis.
Notes
-----
Conventions are described in the class documentation.
We follow mathmatical formalism described in:
"https://www.continuummechanics.org/stressxforms.html" (August 2019)
"""
def apply_rotation(transposed_strain_map, R):
""" Rotates a strain matrix to a new basis, for which R maps x_old to x_new """
sigmaxx_old = transposed_strain_map[0]
sigmayy_old = transposed_strain_map[1]
sigmaxy_old = transposed_strain_map[2]
z = np.asarray([[sigmaxx_old, sigmaxy_old],
[sigmaxy_old, sigmayy_old]])
new = np.matmul(R.T, np.matmul(z, R))
return [new[0, 0], new[1, 1], new[0, 1], transposed_strain_map[3]]
def apply_rotation_complete(self, R):
""" Mapping solution to return a (unclassed) strain map in a new basis """
from hyperspy.api import transpose
transposed = transpose(self)[0]
transposed_to_new_basis = transposed.map(apply_rotation,
R=R,
inplace=False)
return transposed_to_new_basis.T
""" Core functionality """
if self.current_basis_x != [1, 0]:
# this takes us back to [1,0] if our current map is in a diferent basis
R = _get_rotation_matrix(self.current_basis_x).T
strain_map_core = apply_rotation_complete(self, R)
else:
strain_map_core = self
R = _get_rotation_matrix(x_new)
transposed_to_new_basis = apply_rotation_complete(strain_map_core, R)
meta_dict = self.metadata.as_dictionary()
strainmap = StrainMap(transposed_to_new_basis,
current_basis_x=x_new,
metadata=meta_dict)
return transfer_signal_axes(strainmap, self)
def get_diffraction_variance(self, dqe, set_data_type=None):
"""Calculates the variance in scattered intensity as a function of
scattering vector.
Parameters
----------
dqe : float
Detective quantum efficiency of the detector for Poisson noise
correction.
data_type : numpy data type.
For numpy data types, see
https://docs.scipy.org/doc/numpy-1.13.0/user/basics.types.html.
This is incorporated as squaring the numbers in meansq_dp results
in considerably larger than the ones in the original array. This can
result in an overflow error that is difficult to distinguish. Hence
the data can be converted to a different data type to accommodate.
Returns
-------
vardps : DiffractionVariance2D
A DiffractionVariance2D object containing the mean DP, mean
squared DP, and variance DP.
"""
dp = self.signal
mean_dp = dp.mean((0, 1))
if set_data_type is None:
meansq_dp = Signal2D(np.square(dp.data)).mean((0, 1))
else:
meansq_dp = Signal2D(np.square(
dp.data.astype(set_data_type))).mean((0, 1))
normvar = (meansq_dp.data / np.square(mean_dp.data)) - 1.
var_dp = Signal2D(normvar)
corr_var_array = var_dp.data - (np.divide(dqe, mean_dp.data))
corr_var_array[np.isinf(corr_var_array)] = 0
corr_var_array[np.isnan(corr_var_array)] = 0
corr_var = Signal2D(corr_var_array)
vardps = stack((mean_dp, meansq_dp, var_dp, corr_var))
sig_x = vardps.data.shape[1]
sig_y = vardps.data.shape[2]
dv = DiffractionVariance2D(vardps.data.reshape((2, 2, sig_x, sig_y)))
dv = transfer_signal_axes(dv, self.signal)
return dv
def get_vector_vdf_images(self, radius, normalize=False):
"""Obtain the intensity scattered to each diffraction vector at each
navigation position in an ElectronDiffraction2D Signal by summation in a
circular window of specified radius.
Parameters
----------
radius : float
Radius of the integration window in reciprocal angstroms.
normalize : boolean
If True each VDF image is normalized so that the maximum intensity
in each VDF is 1.
Returns
-------
vdfs : VDFImage
VDFImage object containing virtual dark field images for all unique
vectors.
"""
if self.vectors:
vdfs = []
for v in self.vectors.data:
disk = roi.CircleROI(cx=v[0], cy=v[1], r=radius, r_inner=0)
vdf = disk(self.signal,
axes=self.signal.axes_manager.signal_axes)
vdfs.append(vdf.sum((2, 3)).as_signal2D((0, 1)).data)
vdfim = VDFImage(np.asarray(vdfs))
if normalize:
vdfim.map(normalize_vdf)
else:
raise ValueError(
"DiffractionVectors not specified by user. Please "
"initialize VDFGenerator with some vectors. ")
# Set calibration to same as signal
vdfim = transfer_navigation_axes_to_signal_axes(vdfim, self.signal)
# Assign vectors used to generate images to vdfim attribute.
vdfim.vectors = self.vectors
vdfim.vectors = transfer_signal_axes(vdfim.vectors, self.vectors)
return vdfim
def get_vdf_segments(
self,
min_distance=1,
min_size=1,
max_size=np.inf,
max_number_of_grains=np.inf,
marker_radius=1,
threshold=False,
exclude_border=False,
):
"""Separate segments from each of the VDF images using
edge-detection by the Sobel transform and the watershed
segmentation method implemented in scikit-image [1,2]. Obtain a
VDFSegment, similar to VDFImage, but where each image is a
segment of a VDF and the vectors correspond to each segment and
are not necessarily unique.
Parameters
----------
min_distance: int
Minimum distance (in pixels) between grains required for
them to be considered as separate grains.
min_size : float
Grains with size (i.e. total number of pixels) below
min_size are discarded.
max_size : float
Grains with size (i.e. total number of pixels) above
max_size are discarded.
max_number_of_grains : int
Maximum number of grains included in the returned separated
grains. If it is exceeded, those with highest peak
intensities will be returned.
marker_radius : float
If 1 or larger, each marker for watershed is expanded to a disk
of radius marker_radius. marker_radius should not exceed
2*min_distance.
threshold: bool
If True, a mask is calculated by thresholding the VDF image
by the Li threshold method in scikit-image. If False
(default), the mask is the boolean VDF image.
exclude_border : int or True, optional
If non-zero integer, peaks within a distance of
exclude_border from the boarder will be discarded. If True,
peaks at or closer than min_distance of the boarder, will be
discarded.
References
----------
[1] http://scikit-image.org/docs/dev/auto_examples/segmentation/
plot_watershed.html
[2] http://scikit-image.org/docs/dev/auto_examples/xx_applications/
plot_coins_segmentation.html#sphx-glr-auto-examples-xx-
applications-plot-coins-segmentation-py
Returns
-------
vdfsegs : VDFSegment
VDFSegment object containing segments (i.e. grains) of
single virtual dark field images with corresponding vectors.
"""
vdfs = self.copy()
vectors = self.vectors.data
# TODO : Add aperture radius as an attribute of VDFImage?
# Create an array of length equal to the number of vectors where each
# element is a np.object with shape (n: number of segments for this
# VDFImage, VDFImage size x, VDFImage size y).
vdfsegs = np.array(
vdfs.map(
separate_watershed,
show_progressbar=True,
inplace=False,
min_distance=min_distance,
min_size=min_size,
max_size=max_size,
max_number_of_grains=max_number_of_grains,
marker_radius=marker_radius,
threshold=threshold,
exclude_border=exclude_border,
),
dtype=np.object,
)
segments, vectors_of_segments = [], []
for i, vector in zip(np.arange(vectors.size), vectors):
segments = np.append(segments, vdfsegs[i])
num_segs = np.shape(vdfsegs[i])[0]
vectors_of_segments = np.append(
vectors_of_segments, np.broadcast_to(vector, (num_segs, 2))
)
vectors_of_segments = vectors_of_segments.reshape((-1, 2))
segments = segments.reshape(
(
np.shape(vectors_of_segments)[0],
vdfs.axes_manager.signal_shape[0],
vdfs.axes_manager.signal_shape[1],
)
)
# Calculate the total intensities of each segment
segment_intensities = np.array(
[[np.sum(x, axis=(0, 1))] for x in segments], dtype="object"
)
# if TraitError is raised, it is likely no segments were found
segments = Signal2D(segments).transpose(navigation_axes=[0], signal_axes=[2, 1])
# Create VDFSegment and transfer axes calibrations
vdfsegs = VDFSegment(
segments, DiffractionVectors(vectors_of_segments), segment_intensities
)
vdfsegs.segments = transfer_signal_axes(vdfsegs.segments, vdfs)
n = vdfsegs.segments.axes_manager.navigation_axes[0]
n.name = "n"
n.units = "number"
vdfsegs.vectors_of_segments.axes_manager.set_signal_dimension(1)
vdfsegs.vectors_of_segments = transfer_signal_axes(
vdfsegs.vectors_of_segments, self.vectors
)
n = vdfsegs.vectors_of_segments.axes_manager.navigation_axes[0]
n.name = "n"
n.units = "number"
return vdfsegs
def correlate_vdf_segments(self,
corr_threshold=0.7,
vector_threshold=4,
segment_threshold=3):
"""Iterates through VDF segments and sums those that are
associated with the same segment. Summation will be done for
those segments that have a normalised cross correlation above
corr_threshold. The vectors of each segment sum will be updated
accordingly, so that the vectors of each resulting segment sum
are all the vectors of the original individual segments. Each
vector is assigned an intensity that is the integrated intensity
of the segment it originates from.
Parameters
----------
corr_threshold : float
Segments will be summed if they have a normalized cross-
correlation above corr_threshold. Must be between 0 and 1.
vector_threshold : int, optional
Correlated segments having a number of vectors less than
vector_threshold will be discarded.
segment_threshold : int, optional
Correlated segment intensities that lie in a region where
a number of segments less than segment_thresholdhave been
found, are set to 0, i.e. the resulting segment will only
have intensities above 0 where at least a number of
segment_threshold segments have intensitives above 0.
Returns
-------
vdfseg : VDFSegment
The VDFSegment instance updated according to the image
correlation results.
"""
vectors = self.vectors_of_segments.data
if segment_threshold > vector_threshold:
raise ValueError("segment_threshold must be smaller than or "
"equal to vector_threshold.")
segments = self.segments.data.copy()
num_vectors = np.shape(vectors)[0]
gvectors = np.array(np.empty(num_vectors, dtype=object))
vector_indices = np.array(np.empty(num_vectors, dtype=object))
for i in np.arange(num_vectors):
gvectors[i] = np.array(vectors[i].copy())
vector_indices[i] = np.array([i], dtype=int)
correlated_segments = np.zeros_like(segments[:1])
correlated_vectors = np.array([0.0], dtype=object)
correlated_vectors[0] = np.array(np.zeros_like(vectors[:1]))
correlated_vector_indices = np.array([0], dtype=object)
correlated_vector_indices[0] = np.array([0])
i = 0
pbar = tqdm(total=np.shape(segments)[0])
while np.shape(segments)[0] > i:
# For each segment, calculate the normalized cross-correlation to
# all other segments, and define add_indices for those with a value
# above corr_threshold.
corr_list = list(
map(lambda x: norm_cross_corr(x, template=segments[i]),
segments))
corr_add = list(map(lambda x: x > corr_threshold, corr_list))
add_indices = np.where(corr_add)
# If there are more add_indices than vector_threshold,
# sum segments and add their vectors. Otherwise, discard segment.
if (np.shape(add_indices[0])[0] >= vector_threshold
and np.shape(add_indices[0])[0] > 1):
new_segment = np.array([np.sum(segments[add_indices], axis=0)])
if segment_threshold > 1:
segment_check = np.zeros_like(segments[add_indices],
dtype=int)
segment_check[np.where(segments[add_indices])] = 1
segment_check = np.sum(segment_check, axis=0, dtype=int)
segment_mask = np.zeros_like(segments[0], dtype=bool)
segment_mask[np.where(
segment_check >= segment_threshold)] = 1
new_segment = new_segment * segment_mask
correlated_segments = np.append(correlated_segments,
new_segment,
axis=0)
add_indices = add_indices[0]
new_vectors = np.array([0], dtype=object)
new_vectors[0] = np.concatenate(gvectors[add_indices],
axis=0).reshape(-1, 2)
correlated_vectors = np.append(correlated_vectors,
new_vectors,
axis=0)
new_indices = np.array([0], dtype=object)
new_indices[0] = np.concatenate(vector_indices[add_indices],
axis=0).reshape(-1, 1)
correlated_vector_indices = np.append(
correlated_vector_indices, new_indices, axis=0)
elif np.shape(add_indices[0])[0] >= vector_threshold:
add_indices = add_indices[0]
correlated_segments = np.append(correlated_segments,
segments[add_indices],
axis=0)
correlated_vectors = np.append(correlated_vectors,
gvectors[add_indices],
axis=0)
correlated_vector_indices = np.append(
correlated_vector_indices,
vector_indices[add_indices],
axis=0)
else:
add_indices = i
segments = np.delete(segments, add_indices, axis=0)
gvectors = np.delete(gvectors, add_indices, axis=0)
vector_indices = np.delete(vector_indices, add_indices, axis=0)
pbar.close()
correlated_segments = np.delete(correlated_segments, 0, axis=0)
correlated_vectors = np.delete(correlated_vectors, 0, axis=0)
correlated_vector_indices = np.delete(correlated_vector_indices,
0,
axis=0)
correlated_vector_intensities = np.array(np.empty(
len(correlated_vectors)),
dtype=object)
# Sum the intensities in the original segments and assign those to the
# correct vectors by referring to vector_indices.
# If segment_mask has been used, use the segments as masks too.
if segment_threshold > 1:
for i in range(len(correlated_vectors)):
correlated_vector_intensities[i] = np.zeros(
len(correlated_vector_indices[i]))
segment_mask = np.zeros_like(segment_mask)
segment_mask[np.where(correlated_segments[i])] = 1
segment_intensities = np.sum(self.segments.data * segment_mask,
axis=(1, 2))
for n, index in zip(
range(len(correlated_vector_indices[i])),
correlated_vector_indices[i],
):
correlated_vector_intensities[i][n] = np.sum(
segment_intensities[index])
else:
segment_intensities = np.sum(self.segments.data, axis=(1, 2))
for i in range(len(correlated_vectors)):
correlated_vector_intensities[i] = np.zeros(
len(correlated_vector_indices[i]))
for n, index in zip(
range(len(correlated_vector_indices[i])),
correlated_vector_indices[i],
):
correlated_vector_intensities[i][n] = np.sum(
segment_intensities[index])
vdfseg = VDFSegment(
Signal2D(correlated_segments),
DiffractionVectors(correlated_vectors),
correlated_vector_intensities,
)
# Transfer axes properties of segments
vdfseg.segments = transfer_signal_axes(vdfseg.segments, self.segments)
n = vdfseg.segments.axes_manager.navigation_axes[0]
n.name = "n"
n.units = "number"
return vdfseg
