def get_distortion_residuals(self, mask_radius, spread):
"""Obtain residuals for experimental data and distortion corrected data
with respect to a simulated symmetric ring pattern.
Parameters
----------
mask_radius : int
Radius, in pixels, for a mask over the direct beam disc.
spread : float
Gaussian spread of each ring in the simulated pattern.
Returns
-------
diff_init : ElectronDiffraction2D
Difference between experimental data and simulated symmetric ring
pattern.
diff_end : ElectronDiffraction2D
Difference between distortion corrected data and simulated symmetric
ring pattern.
"""
# Check all required parameters are defined as attributes
if self.diffraction_pattern is None:
raise ValueError(
"This method requires an Au X-grating diffraction "
"pattern to be provided. Please update the "
"CalibrationDataLibrary.")
if self.affine_matrix is None:
raise ValueError(
"This method requires a distortion matrix to have "
"been determined. Use get_elliptical_distortion "
"to determine this matrix.")
# Set name for experimental data pattern
dpeg = self.diffraction_pattern
ringP = self.ring_params
size = dpeg.data.shape[0]
dpref = generate_ring_pattern(
image_size=size,
mask=True,
mask_radius=mask_radius,
scale=ringP[0],
amplitude=ringP[1],
spread=spread,
direct_beam_amplitude=ringP[3],
asymmetry=1,
rotation=ringP[5],
)
# Apply distortion corrections to experimental data
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.affine_matrix,
preserve_range=True,
inplace=True)
# Calculate residuals to be returned
diff_init = ElectronDiffraction2D(dpeg.data - dpref.data)
diff_end = ElectronDiffraction2D(dpegs.inav[0, 0].data - dpref.data)
residuals = stack_method([diff_init, diff_end])
return ElectronDiffraction2D(residuals)
def diffraction_pattern(z):
"""A simple, multiuse diffraction pattern, with dimensions:
ElectronDiffraction2D <2,2|8,8>
"""
dp = ElectronDiffraction2D(z)
dp.metadata.Signal.found_from = "conftest" # dummy metadata
return dp
def test_set_data_type(self):
# set 8 bit data type which will result in an incorrect mean square
# pattern if not changed.
dp_array = np.array([
[[[10, 10], [50, 30]], [[8, 20], [50, 30]]],
[[[12, 30], [0, 30]], [[10, 10], [50, 30]]],
]).astype(np.uint8)
variance_test_diffraction_pattern = ElectronDiffraction2D(dp_array)
vargen = VarianceGenerator(variance_test_diffraction_pattern)
vardps_8 = vargen.get_diffraction_variance(dqe=1)
assert isinstance(vardps_8, DiffractionVariance2D)
corr_var_dp_8 = np.array([[-0.08, -0.66857143],
[-0.92213333, -0.88666667]])
assert np.allclose(vardps_8.data[1, 1],
corr_var_dp_8,
atol=1e-6,
equal_nan=True)
vardps_16 = vargen.get_diffraction_variance(dqe=1,
set_data_type=np.uint16)
assert isinstance(vardps_16, DiffractionVariance2D)
corr_var_dp_16 = np.array([[-0.08, 0.16734694],
[0.30666667, -0.0333333]])
assert np.allclose(vardps_16.data[1, 1],
corr_var_dp_16,
atol=1e-6,
equal_nan=True)
def test_out_of_range_vectors_DiffractionVectors(self):
"""Test that putting vectors that lie outside of the
diffraction patterns raises a ValueError"""
vectors = DiffractionVectors(np.array([[1, -100]]))
dp = ElectronDiffraction2D(np.ones((20, 20)))
with pytest.raises(ValueError):
_ = SubpixelrefinementGenerator(dp, vectors)
def test_out_of_range_vectors_numpy(self):
"""Test that putting vectors that lie outside of the
diffraction patterns raises a ValueError"""
vector = np.array([[1, -100]])
dp = ElectronDiffraction2D(np.ones((20, 20)))
with pytest.raises(
ValueError,
match="Some of your vectors do not lie within your diffraction pattern",
):
_ = SubpixelrefinementGenerator(dp, vector)
def test_AcceleratedIndexationGenerator(good_library):
signal = ElectronDiffraction2D((np.ones((2, 2, 256, 256)))).as_lazy()
library = generate_library(good_library=good_library)
if good_library:
acgen = AcceleratedIndexationGenerator(signal, library)
d = acgen.correlate(n_largest=2)
elif not good_library:
with pytest.raises(ValueError):
acgen = AcceleratedIndexationGenerator(signal, library)
return None
def test_wrong_navigation_dimensions(self):
"""Tests that navigation dimensions must be appropriate too."""
dp = ElectronDiffraction2D(np.zeros((2, 2, 8, 8)))
vectors = DiffractionVectors(np.zeros((1, 2)))
dp.axes_manager.set_signal_dimension(2)
vectors.axes_manager.set_signal_dimension(0)
# Note - uses regex via re.search()
with pytest.raises(
ValueError,
match=r"Vectors with shape .* must have the same navigation shape as .*",
):
_ = SubpixelrefinementGenerator(dp, vectors)
def test_2d_data_as_lazy(self):
data = np.random.random((100, 150))
s = ElectronDiffraction2D(data)
scale0, scale1, metadata_string = 0.5, 1.5, "test"
s.axes_manager[0].scale = scale0
s.axes_manager[1].scale = scale1
s.metadata.Test = metadata_string
s_lazy = s.as_lazy()
assert isinstance(s_lazy, LazyElectronDiffraction2D)
assert hasattr(s_lazy.data, "compute")
assert s_lazy.axes_manager[0].scale == scale0
assert s_lazy.axes_manager[1].scale == scale1
assert s_lazy.metadata.Test == metadata_string
assert data.shape == s_lazy.data.shape
def variance_generator():
diffraction_pattern = ElectronDiffraction2D(
np.array([
[
[
[0.66, 0.5, 0.01, 0.54, 0.83, 0.23, 0.92, 0.14],
[0.61, 0.45, 0.01, 0.42, 0.33, 0.48, 0.35, 0.19],
[0.87, 0.98, 0.58, 0.51, 0.75, 0.95, 0.22, 0.52],
[0.29, 0.13, 0.22, 0.98, 0.04, 0.12, 0.26, 0.67],
[0.59, 0.55, 0.63, 0.57, 0.89, 0.39, 0.81, 0.43],
[0.9, 0.54, 0.24, 0.92, 0.77, 0.33, 0.22, 0.7],
[0.7, 0.3, 0.76, 0.27, 0.93, 0.28, 0.73, 0.22],
[0.33, 0.7, 0.32, 0.54, 0.27, 0.87, 0.97, 0.7],
],
[
[0.68, 0.33, 0.11, 0.26, 0.88, 0.02, 0.71, 0.98],
[0.62, 0.55, 0.22, 0.43, 0.17, 0.77, 0.42, 0.52],
[0.45, 0.2, 0.21, 0.53, 0.38, 0.64, 0.32, 0.38],
[0.5, 0.23, 0.25, 0.91, 0.64, 1.0, 0.69, 0.16],
[0.11, 0.82, 0.23, 0.91, 0.46, 0.08, 0.55, 0.86],
[0.95, 0.68, 0.74, 0.44, 0.65, 0.92, 0.04, 0.62],
[0.59, 0.08, 0.2, 0.33, 0.94, 0.67, 0.31, 0.62],
[0.77, 0.01, 0.46, 0.81, 0.92, 0.72, 0.38, 0.25],
],
],
[
[
[0.07, 0.63, 0.89, 0.71, 0.65, 0.1, 0.58, 0.78],
[0.05, 0.35, 0.02, 0.87, 0.06, 0.06, 0.23, 0.52],
[0.44, 0.77, 0.93, 0.94, 0.22, 0.29, 0.22, 0.03],
[0.9, 0.79, 0.82, 0.61, 0.6, 0.96, 0.13, 0.63],
[0.57, 0.63, 0.53, 0.81, 0.38, 0.92, 0.92, 0.07],
[0.01, 0.33, 0.69, 0.36, 0.91, 0.24, 0.05, 0.85],
[0.81, 0.38, 0.74, 0.12, 0.33, 0.29, 0.25, 0.06],
[0.28, 0.61, 0.37, 0.17, 0.38, 0.52, 0.36, 0.69],
],
[
[0.77, 0.68, 0.76, 0.62, 0.52, 0.69, 0.63, 0.11],
[0.6, 0.96, 0.17, 0.58, 0.12, 0.23, 0.1, 0.2],
[0.4, 0.24, 0.25, 0.61, 0.27, 0.02, 0.03, 0.12],
[0.83, 0.66, 0.15, 0.74, 0.91, 0.19, 0.97, 0.58],
[0.5, 0.27, 0.93, 0.1, 0.78, 0.73, 0.56, 0.82],
[0.49, 0.35, 0.9, 0.48, 0.04, 0.46, 0.16, 0.1],
[1.0, 0.13, 0.56, 0.12, 0.16, 0.49, 0.63, 0.5],
[0.97, 0.71, 0.78, 0.38, 0.08, 0.79, 0.41, 0.07],
],
],
]))
return VarianceGenerator(diffraction_pattern)
def ring_pattern(input_parameters):
x0 = input_parameters
ring_data = generate_ring_pattern(
image_size=256,
mask=True,
mask_radius=10,
scale=x0[0],
amplitude=x0[1],
spread=x0[2],
direct_beam_amplitude=x0[3],
asymmetry=x0[4],
rotation=x0[5],
)
return ElectronDiffraction2D(ring_data)
def test_xy_errors_in_conventional_xc_method_as_per_issue_490():
""" This was the MWE example code for the issue """
dp = get_simulated_disc(100, 20)
# translate y by +4
shifted = np.pad(dp, ((0, 4), (0, 0)), "constant")[4:].reshape(1, 1, *dp.shape)
signal = ElectronDiffraction2D(shifted)
spg = SubpixelrefinementGenerator(signal, np.array([[0, 0]]))
peaks = spg.conventional_xc(100, 20, 1).data[0, 0, 0] # as quoted in the issue
np.testing.assert_allclose([0, -4], peaks)
""" we also test com method for clarity """
peaks = spg.center_of_mass_method(60).data[0, 0, 0]
np.testing.assert_allclose([0, -4], peaks, atol=1.5)
""" we also test reference_xc """
peaks = spg.reference_xc(100, dp, 1).data[0, 0, 0] # as quoted in the issue
np.testing.assert_allclose([0, -4], peaks)
def test_integration_generator(radius, offset):
pixel_positions = np.array([[0, 0], [15, -15], [-15, 15]])
pattern = np.zeros((50, 50))
center = np.array(pattern.shape) / 2
i, j = (pixel_positions + center + offset).T.astype(int)
pattern[i, j] = 1
dv = DiffractionVectors(pixel_positions)
dp = ElectronDiffraction2D(pattern)
ig = IntegrationGenerator(dp, dv)
assert isinstance(ig, IntegrationGenerator)
inties = ig.extract_intensities(radius=radius)
assert isinstance(inties, BaseSignal)
assert np.allclose(inties.data, [1, 1, 1])
def test_apply_affine_transformation_with_casting(self, diffraction_pattern):
diffraction_pattern.change_dtype("uint8")
with pytest.warns(
UserWarning,
match="Bi-quadratic interpolation behavior has changed due to a bug in the implementation of scikit-image",
):
transformed_dp = ElectronDiffraction2D(
diffraction_pattern
).apply_affine_transformation(
D=np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.2]]),
order=2,
keep_dtype=True,
inplace=False,
)
assert transformed_dp.data.dtype == "uint8"
def plot_corrected_diffraction_pattern(self,
reference_circle=True,
*args,
**kwargs):
"""Plot the distortion corrected diffraction pattern with an optional
reference circle.
Parameters
----------
reference_circle : bool
If True a CircleROI widget is added to the plot for reference.
*args : arguments
Arguments to be passed to the plot method.
**kwargs : keyword arguments
Keyword arguments to be passed to the plot method.
"""
# Check all required parameters are defined as attributes
if self.diffraction_pattern is None:
raise ValueError(
"This method requires an Au X-grating diffraction "
"pattern to be provided. Please update the "
"CalibrationDataLibrary.")
if self.affine_matrix is None:
raise ValueError(
"This method requires a distortion matrix to have "
"been determined. Use get_elliptical_distortion "
"to determine this matrix.")
# Set name for experimental data pattern
dpeg = self.diffraction_pattern
# Apply distortion corrections to experimental data
size = dpeg.data.shape[0]
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.affine_matrix,
preserve_range=True,
inplace=True)
dpegm = dpegs.mean((0, 1))
# Plot distortion corrected data
dpegm.plot(*args, **kwargs)
# add reference circle if specified
if reference_circle is True:
circ = CircleROI(cx=size / 2, cy=size / 2, r=size / 5, r_inner=0)
circ.add_widget(dpegm)
def create_spot(self):
z1, z1a = np.zeros((128, 128)), np.zeros((128, 128))
z2, z2a = np.zeros((128, 128)), np.zeros((128, 128))
rr, cc = draw.disk((30, 90), radius=4, shape=z1.shape) # 30 is y!
z1[rr, cc], z2[rr, cc] = 1, 1
rr2, cc2 = draw.disk((100, 60), radius=4, shape=z2.shape)
z2[rr2, cc2] = 1
rr, cc = draw.disk((30, 90 + 3), radius=4, shape=z1.shape) # 30 is y!
z1a[rr, cc], z2a[rr, cc] = 1, 1
rr2, cc2 = draw.disk((100 - 2, 60), radius=4, shape=z2.shape)
z2a[rr2, cc2] = 1
# marks centers for local com and local_gaussian_method
z1[30, 90], z2[30, 90], z2[100, 60] = 2, 2, 2
z1a[30, 93], z2a[30, 93], z2a[98, 60] = 10, 10, 10
dp = ElectronDiffraction2D(np.asarray([[z1, z1a], [z2, z2a]
])) # this needs to be in 2x2
return dp
def test_integration_generator_summation_method():
pixel_positions = np.array([[0, 0], [25, -25], [-25, 25]])
pattern = np.zeros((100, 100))
center = np.array(pattern.shape) / 2
i, j = (pixel_positions + center).T.astype(int)
pattern[i, j] = 1.0
pattern = gaussian_filter(pattern, 2)
dv = DiffractionVectors(pixel_positions)
dp = ElectronDiffraction2D(pattern)
ig = IntegrationGenerator(dp, dv)
assert isinstance(ig, IntegrationGenerator)
vectors = ig.extract_intensities_summation_method()
assert np.allclose(pixel_positions, vectors.data, atol=0.05)
assert np.allclose(vectors.data, pixel_positions, atol=0.05)
assert np.allclose(vectors.intensities.data[0], 1.0, atol=0.05)
assert np.allclose(vectors.sigma.data[0], 0.0, atol=0.05)
assert isinstance(vectors, DiffractionVectors)
def test_TemplateIndexationGenerator(default_structure, method):
identifiers = ["a", "b"]
structures = [default_structure, default_structure]
orientations = [
[(0, 0, 0), (0, 1, 0), (1, 0, 0)],
[(0, 0, 1), (0, 0, 2), (0, 0, 3)],
]
structure_library = StructureLibrary(identifiers, structures, orientations)
libgen = DiffractionLibraryGenerator(DiffractionGenerator(300))
library = libgen.get_diffraction_library(structure_library, 0.017, 0.02,
(100, 100), False)
edp = ElectronDiffraction2D(np.random.rand(2, 2, 200, 200))
indexer = TemplateIndexationGenerator(edp, library)
mask_signal = hs.signals.Signal2D(np.array([[1, 0], [1, 1]])).T
z = indexer.correlate(method=method, n_largest=2, mask=mask_signal)
assert isinstance(z, TemplateMatchingResults)
assert isinstance(z.data, Signal2D)
assert z.data.data.shape[0:2] == edp.data.shape[0:2]
assert z.data.data.shape[3] == 5
def signal_data():
s = ElectronDiffraction2D(np.zeros((4, 5, 6, 6)))
s.inav[:2, :2].data[..., 0, 0] = 2
s.inav[:2, :2].data[..., 0, 3] = 2
s.inav[:2, :2].data[..., 3, 5] = 2
s.inav[2:, :3].data[..., 3, 3] = 2
s.inav[2:, :3].data[..., 3, 0] = 2
s.inav[2, :2].data[..., 0, 0] = 1
s.inav[2, :2].data[..., 0, 3] = 1
s.inav[2, :2].data[..., 3, 5] = 1
s.inav[2, :2].data[..., 3, 3] = 1
s.inav[2, :2].data[..., 3, 0] = 1
s.inav[:2, 2:].data[..., 5, 5] = 3
s.inav[:2, 2:].data[..., 5, 0] = 3
s.inav[:2, 2:].data[..., 5, 3] = 3
s.inav[3:, 2:].data[..., 5, 5] = 3
s.inav[3:, 2:].data[..., 5, 0] = 3
return s
def ones(self):
ones_diff = ElectronDiffraction2D(data=np.ones(shape=(5, 5)))
ones_diff.axes_manager.signal_axes[0].name = "kx"
ones_diff.axes_manager.signal_axes[1].name = "ky"
ones_diff.unit = "2th_rad"
return ones_diff
def plot_calibrated_data(self,
data_to_plot,
line=None,
unwrap=False,
*args,
**kwargs): # pragma: no cover
"""Plot calibrated data for visual inspection.
Parameters
----------
data_to_plot : str
Specify the calibrated data to be plotted. Valid options are:
{'au_x_grating_dp', 'au_x_grating_im', 'moo3_dp', 'moo3_im',
'rotation_overlay'}
line : :obj:`hyperspy.roi.Line2DROI`
An optional Line2DROI object, as detailed in HyperSpy, to be added
as a widget to the calibration data plot and the trace plotted
interactively.
*args : arguments
Arguments to be passed to the plot method.
**kwargs : keyword arguments
Keyword arguments to be passed to the plot method.
"""
# Construct object containing user defined data to plot and set the
# calibration checking that it is defined.
if data_to_plot == "au_x_grating_dp":
dpeg = self.diffraction_pattern
size = dpeg.data.shape[0]
if self.correction_matrix is None:
self.get_correction_matrix()
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(
dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.correction_matrix,
preserve_range=True,
inplace=True)
data = dpegs.mean((0, 1))
data.set_diffraction_calibration(self.diffraction_calibration)
# Plot the calibrated diffraction data
data.plot(*args, **kwargs)
elif data_to_plot == "au_x_grating_im":
data = self.diffraction_pattern
# Plot the calibrated image data
data.plot(*args, **kwargs)
elif data_to_plot == "moo3_dp":
dpeg = self.calibration_data.moo3_dp
size = dpeg.data.shape[0]
if self.correction_matrix is None:
self.get_correction_matrix()
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(
dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.correction_matrix,
preserve_range=True,
inplace=True)
data = dpegs.mean((0, 1))
data.set_diffraction_calibration(self.diffraction_calibration)
# Plot the calibrated diffraction data
data.plot(*args, **kwargs)
elif data_to_plot == "moo3_im":
data = self.calibration_data.moo3_im
# Plot the calibrated image data
data.plot(*args, **kwargs)
elif data_to_plot == "rotation_overlay":
dpeg = self.calibration_data.moo3_dp
size = dpeg.data.shape[0]
if self.correction_matrix is None:
self.get_correction_matrix()
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(
dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.correction_matrix,
preserve_range=True,
inplace=True)
dp = dpegs.mean((0, 1))
im = self.calibration_data.moo3_im.rebin(dp.data.shape)
stack1 = np.zeros((dp.data.shape[0], dp.data.shape[1], 3))
stack1[:, :, 0] = dp.data / (0.05 * dp.data.max())
stack1[:, :, 2] = im.data / im.data.max()
plt.figure(1)
plt.imshow(stack1)
if line:
line.add_widget(data, axes=data.axes_manager.signal_axes)
trace = line.interactive(data, navigation_signal="same")
trace.plot()
return trace
def get_diffraction_calibration(self, mask_length, linewidth):
"""Determine the diffraction pattern pixel size calibration in units of
reciprocal Angstroms per pixel.
Parameters
----------
mask_length : float
Halfwidth of the region excluded from peak finding around the
diffraction pattern center.
linewidth : float
Width of Line2DROI used to obtain line trace from distortion
corrected diffraction pattern.
Returns
-------
diff_cal : float
Diffraction calibration in reciprocal Angstroms per pixel.
"""
# Check that necessary calibration data is provided
if self.diffraction_pattern is None:
raise ValueError(
"This method requires an Au X-grating diffraction "
"pattern to be provided. Please update the "
"CalibrationDataLibrary.")
if self.affine_matrix is None:
raise ValueError(
"This method requires a distortion matrix to have "
"been determined. Use get_elliptical_distortion "
"to determine this matrix.")
dpeg = self.diffraction_pattern
size = dpeg.data.shape[0]
dpegs = stack_method([dpeg, dpeg, dpeg, dpeg])
dpegs = ElectronDiffraction2D(dpegs.data.reshape((2, 2, size, size)))
dpegs.apply_affine_transformation(self.affine_matrix,
preserve_range=True,
inplace=True)
dpegm = dpegs.mean((0, 1))
# Define line roi along which to take trace for calibration
line = Line2DROI(x1=5,
y1=5,
x2=size - 6,
y2=size - 6,
linewidth=linewidth)
# Obtain line trace
trace = line(dpegm)
trace = trace.as_signal1D(0)
# Find peaks in line trace either side of direct beam
db = (np.sqrt(2) * (size / 2)) - (5 * np.sqrt(2))
pka = trace.isig[db +
mask_length:].find_peaks1D_ohaver()[0]["position"]
pkb = trace.isig[:db -
mask_length].find_peaks1D_ohaver()[0]["position"]
# Define Au 220 interplanar spacing (in Angstroms)
d220 = 1.442
# Determine predicted position of Au 220 peak
au_pre = db - (self.ring_params[0] / d220)
au_post = db + (self.ring_params[0] / d220)
# Calculate differences between predicted and measured positions
prediff = np.abs(pkb - au_pre)
postdiff = np.abs(pka - au_post)
# Calculate new calibration value based on most accurate peak positions
dc = (2 / d220) / (pka[postdiff == min(postdiff)] -
pkb[prediff == min(prediff)])
# Store diffraction calibration value as attribute
self.diffraction_calibration = dc[0]
return dc[0]
def test_init():
z = np.zeros((2, 2, 2, 2))
_ = ElectronDiffraction2D(
z, metadata={"Acquisition_instrument": {
"SEM": "Expensive-SEM"
}})
def test_4d_data_as_lazy(self):
data = np.random.random((4, 10, 15))
s = ElectronDiffraction2D(data)
s_lazy = s.as_lazy()
assert isinstance(s_lazy, LazyElectronDiffraction2D)
assert data.shape == s_lazy.data.shape
def get_virtual_electron_diffraction(self, calibration, shape, sigma):
"""Obtain a virtual electron diffraction signal that consists
of one virtual diffraction pattern for each segment. The virtual
diffraction pattern is composed of Gaussians centered at each
vector position. If given, the integrated intensities of each
vector will be taken into account by multiplication with the
Gaussians.
Parameters
----------
calibration : float
Reciprocal space calibration in inverse Angstrom per pixel.
shape : tuple
Shape of the signal, (shape_x, shape_y) in pixels, where
shape_x and shape_y are integers.
sigma : float
The standard deviation of the Gaussians in inverse Angstrom
per pixel. 'calibration' is a decent starting value.
Returns
-------
virtual_ed : ElectronDiffraction2D
Virtual electron diffraction signal consisting of one
virtual diffraction pattern for each segment.
"""
vectors = self.vectors_of_segments.data
segments = self.segments.data
num_segments = np.shape(segments)[0]
if self.intensities is None:
raise ValueError("The VDFSegment does not have the attribute "
"intensities, required for this method.")
else:
intensities = self.intensities
# TODO: Refactor this to use the diffsims simulation to plot functionality
size_x, size_y = shape[0], shape[1]
cx, cy = -size_x / 2 * calibration, -size_y / 2 * calibration
x, y = np.indices((size_x, size_y))
x, y = x * calibration + cx, y * calibration + cy
virtual_ed = np.zeros((size_x, size_y, num_segments))
for i in range(num_segments):
# Allow plotting for segments that are only associated with
# one vector.
if np.shape(np.shape(vectors[i]))[0] <= 1:
virtual_ed[..., i] = get_gaussian2d(
intensities[i],
vectors[i][..., 0],
vectors[i][..., 1],
x=x,
y=y,
sigma=sigma,
)
# Allow plotting for segments associated with several vectors.
else:
virtual_ed[..., i] = sum(
list(
map(
lambda a, xo, yo: get_gaussian2d(
a, xo, yo, x=x, y=y, sigma=sigma),
intensities[i],
vectors[i][..., 0],
vectors[i][..., 1],
)))
virtual_ed = ElectronDiffraction2D(virtual_ed.T)
return virtual_ed
def dp_single(request):
"""
1D (in navigation space) diffraction pattern <1|8,8>
"""
return ElectronDiffraction2D(request.param)
def test_set_diffraction_calibration(self):
ones = ElectronDiffraction2D(data=np.ones((3, 3, 3, 3)))
ones.diffraction_calibration = 0.9
assert ones.axes_manager.signal_axes[0].scale == 0.9
assert ones.axes_manager.signal_axes[1].scale == 0.9
assert ones.diffraction_calibration == 0.9
