def __init__(self, *args, **kwargs):
"""Create an :class:`~kikuchipy.signals.EBSDMasterPattern`
object from a :class:`hyperspy.signals.Signal2D` or a
:class:`numpy.ndarray`.
"""
Signal2D.__init__(self, *args, **kwargs)
self.phase = kwargs.pop("phase", Phase())
self.projection = kwargs.pop("projection", None)
self.hemisphere = kwargs.pop("hemisphere", None)
def __init__(self, *args, **kwargs):
"""Create an :class:`~kikuchipy.signals.EBSDMasterPattern`
instance from a :class:`hyperspy.signals.Signal2D` or a
:class:`numpy.ndarray`. See the docstring of
:class:`hyperspy.signal.BaseSignal` for optional input
parameters.
"""
Signal2D.__init__(self, *args, **kwargs)
self.phase = kwargs.pop("phase", Phase())
self.projection = kwargs.pop("projection", None)
self.hemisphere = kwargs.pop("hemisphere", None)
def test_save_load_permanent_marker_all_types(self):
x1, y1, x2, y2 = 5, 2, 1, 8
s = Signal2D(np.arange(100).reshape(10, 10))
m0_list = [
markers.point(x=x1, y=y1),
markers.horizontal_line(y=y1),
markers.horizontal_line_segment(x1=x1, x2=x2, y=y1),
markers.line_segment(x1=x1, x2=x2, y1=y1, y2=y2),
markers.rectangle(x1=x1, x2=x2, y1=y1, y2=y2),
markers.text(x=x1, y=y1, text="test"),
markers.vertical_line(x=x1),
markers.vertical_line_segment(x=x1, y1=y1, y2=y2),
]
for m in m0_list:
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testallmarkersfile.hdf5'
s.save(filename)
s1 = load(filename)
markers_dict = s1.metadata.Markers
m0_dict_list = []
m1_dict_list = []
for m in m0_list:
m0_dict_list.append(san_dict(m._to_dictionary()))
m1_dict_list.append(
san_dict(markers_dict.get_item(m.name)._to_dictionary()))
assert len(list(s1.metadata.Markers)) == 8
for m0_dict, m1_dict in zip(m0_dict_list, m1_dict_list):
assert m0_dict == m1_dict
def test_save_permanent_marker(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
def __init__(self, *args, **kwargs):
"""Create an :class:`~kikuchipy.signals.EBSDMasterPattern`
object from a :class:`hyperspy.signals.Signal2D` or a
:class:`numpy.ndarray`.
"""
Signal2D.__init__(self, *args, **kwargs)
# Update metadata if object is initialized from numpy array or
# with set_signal_type()
if not self.metadata.has_item(metadata_nodes("ebsd_master_pattern")):
md = self.metadata.as_dictionary()
md.update(ebsd_master_pattern_metadata().as_dictionary())
self.metadata = DictionaryTreeBrowser(md)
if not self.metadata.has_item("Sample.Phases"):
self.set_phase_parameters()
def setup_method(self, method):
ics = np.random.laplace(size=(3, 1024))
np.random.seed(1)
mixing_matrix = np.random.random((100, 3))
s = Signal2D(np.dot(mixing_matrix, ics).reshape((100, 32, 32)))
for (axis, name) in zip(s.axes_manager._axes, ("z", "y", "x")):
axis.name = name
s.decomposition()
self.s = s
def test_chunking_saving_lazy_specify(self, tmp_path, file):
filename = tmp_path / file
s = Signal2D(da.zeros((50, 100, 100))).as_lazy()
# specify chunks
chunks = (50, 10, 10)
s.data = s.data.rechunk([50, 25, 25])
s.save(filename, chunks=chunks)
s1 = load(filename, lazy=True)
assert tuple([c[0] for c in s1.data.chunks]) == chunks
def test_save_load_empty_metadata_markers(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
m.name = "test"
s.add_marker(m, permanent=True)
del s.metadata.Markers.test
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
s1 = load(filename)
assert len(s1.metadata.Markers) == 0
def get_diffraction(
self,
convergence_angle=.74,
accelerating_voltage=200,
k_rad=5.0,
simulation_size=(256, 256),
noise=False,
num_electrons=1000,
):
"""Returns an amorphous2d Diffraction pattern based on the clusters in one column.
Parameters
------------
convergence_angle: float
The convergence angle for the experiment
accelerating_voltage: float
The accelerating voltage for the experiment in kV
simulation_size: tuple
The size of the image for both the reciporical space image and the real space image.
Returns
------------
dataset: Amorphus2D
Returns a 4 dimensional dataset which represents the cube
"""
# dataset = Signal2D(np.ones(simulation_size))
dataset = np.ones(simulation_size)
for cluster in self:
speckles, observed_intensity = cluster.get_speckles(
img_size=k_rad * 2,
num_pixels=simulation_size[0],
accelerating_voltage=accelerating_voltage,
conv_angle=convergence_angle)
print(cluster)
for (sr, sc), inten in zip(speckles, observed_intensity):
dataset[sr, sc] = dataset[sr, sc] + inten
if noise:
dataset = dataset * num_electrons
noise = np.random.poisson(dataset)
dataset = dataset + noise
else:
dataset = dataset * num_electrons
dataset = Signal2D(dataset)
dataset.axes_manager.signal_axes[
0].scale = k_rad * 2 / simulation_size[0]
dataset.axes_manager.signal_axes[
1].scale = k_rad * 2 / simulation_size[1]
dataset.axes_manager.signal_axes[0].units = "$nm^-1$"
dataset.axes_manager.signal_axes[1].units = "$nm^-1$"
dataset.axes_manager.signal_axes[0].offset = -k_rad
dataset.axes_manager.signal_axes[1].offset = -k_rad
return dataset
def test_save_load_point_marker(self, mpl_cleanup):
x, y = 9, 8
color = 'purple'
name = "point test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_point_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_text_marker(self):
x, y = 3, 9.5
color = 'brown'
name = "text_test"
text = "a text"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.text(x=x, y=y, text=text, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_text_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_horizontal_line_marker(self, mpl_cleanup):
y = 8
color = 'blue'
linewidth = 2.5
name = "horizontal_line_test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.horizontal_line(y=y, color=color, linewidth=linewidth)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_horizontal_line_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_hyperspy_signal_metadata(self, tmp_path):
s = self.s
s.original_metadata.set_item("testarray1", BaseSignal([1.2, 2.3, 3.4]))
s.original_metadata.set_item("testarray2", (1, 2, 3, 4, 5))
s.original_metadata.set_item("testarray3",
Signal2D(np.ones((2, 3, 5, 4))))
fname = tmp_path / 'test.nxs'
s.save(fname)
lin = load(fname, nxdata_only=True)
np.testing.assert_allclose(lin.original_metadata.testarray1.data,
np.array([1.2, 2.3, 3.4]))
np.testing.assert_array_equal(lin.original_metadata.testarray2,
np.array([1, 2, 3, 4, 5]))
np.testing.assert_array_equal(lin.original_metadata.testarray3.data,
np.ones((2, 3, 5, 4)))
def test_save_load_vertical_line_marker(self):
x = 9
color = 'black'
linewidth = 3.5
name = "vertical_line_test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.vertical_line(x=x, color=color, linewidth=linewidth)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_vertical_line_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_line_segment_marker(self, mpl_cleanup):
x1, x2, y1, y2 = 1, 9, 4, 7
color = 'cyan'
linewidth = 0.7
name = "line_segment_test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.line_segment(
x1=x1, x2=x2, y1=y1, y2=y2, color=color, linewidth=linewidth)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_line_segment_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_horizontal_line_segment_marker(self):
x1, x2, y = 1, 5, 8
color = 'red'
linewidth = 1.2
name = "horizontal_line_segment_test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.horizontal_line_segment(
x1=x1, x2=x2, y=y, color=color, linewidth=linewidth)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_horizontal_line_segment_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_rectangle_marker(self):
x1, x2, y1, y2 = 2, 4, 1, 3
color = 'yellow'
linewidth = 5
name = "rectangle_test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.rectangle(
x1=x1, x2=x2, y1=y1, y2=y2, color=color, linewidth=linewidth)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_rectangle_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_permanent_marker(self):
x, y = 5, 2
color = 'red'
size = 10
name = 'testname'
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color, size=size)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testloadfile.hdf5'
s.save(filename)
s1 = load(filename)
assert s1.metadata.Markers.has_item(name)
m1 = s1.metadata.Markers.get_item(name)
assert m1.get_data_position('x1') == x
assert m1.get_data_position('y1') == y
assert m1.get_data_position('size') == size
assert m1.marker_properties['color'] == color
assert m1.name == name
def test_chunking_saving_lazy():
s = Signal2D(da.zeros((50, 100, 100))).as_lazy()
s.data = s.data.rechunk([50, 25, 25])
with tempfile.TemporaryDirectory() as tmp:
filename = os.path.join(tmp, 'test_chunking_saving_lazy.hspy')
filename2 = os.path.join(tmp, 'test_chunking_saving_lazy_chunks_True.hspy')
filename3 = os.path.join(tmp, 'test_chunking_saving_lazy_chunks_specified.hspy')
s.save(filename)
s1 = load(filename, lazy=True)
assert s.data.chunks == s1.data.chunks
# with chunks=True, use h5py chunking
s.save(filename2, chunks=True)
s2 = load(filename2, lazy=True)
assert tuple([c[0] for c in s2.data.chunks]) == (7, 25, 25)
# specify chunks
chunks = (50, 10, 10)
s.save(filename3, chunks=chunks)
s3 = load(filename3, lazy=True)
assert tuple([c[0] for c in s3.data.chunks]) == chunks
def test_chunking_saving_lazy(tmp_path, file):
s = Signal2D(da.zeros((50, 100, 100))).as_lazy()
s.data = s.data.rechunk([50, 25, 25])
filename = tmp_path / 'test_chunking_saving_lazy.hspy'
filename2 = tmp_path / 'test_chunking_saving_lazy_chunks_True.hspy'
filename3 = tmp_path / 'test_chunking_saving_lazy_chunks_specified.hspy'
s.save(filename)
s1 = load(filename, lazy=True)
assert s.data.chunks == s1.data.chunks
# with chunks=True, use h5py chunking
s.save(filename2, chunks=True)
s2 = load(filename2, lazy=True)
assert tuple([c[0] for c in s2.data.chunks]) == (7, 25, 25)
# specify chunks
chunks = (50, 10, 10)
s.save(filename3, chunks=chunks)
s3 = load(filename3, lazy=True)
assert tuple([c[0] for c in s3.data.chunks]) == chunks
def test_save_load_multidim_navigation_marker(self):
x, y = (1, 2, 3), (5, 6, 7)
name = 'test point'
s = Signal2D(np.arange(300).reshape(3, 10, 10))
m = markers.point(x=x, y=y)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_multidim_nav_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
assert m1.get_data_position('x1') == x[0]
assert m1.get_data_position('y1') == y[0]
s1.axes_manager.navigation_axes[0].index = 1
assert m1.get_data_position('x1') == x[1]
assert m1.get_data_position('y1') == y[1]
s1.axes_manager.navigation_axes[0].index = 2
assert m1.get_data_position('x1') == x[2]
assert m1.get_data_position('y1') == y[2]
def gradient(self):
""" Calculate the gradient of the phase.
Returns
-------
gradient : Signal2D
Notes
-----
Appendix D in Hytch et al. Ultramicroscopy 1998
"""
# Unfortunatelly, BaseSignal.map doesn't work in this case, axes_manager
# set wrongly, we need to workaround
axis = self.axes_manager.signal_indices_in_array
self._gradient = Signal2D(gradient_phase(self.data, axis=axis))
for ax1, ax2 in zip(self._gradient.axes_manager.signal_axes,
self.axes_manager.signal_axes):
ax1.scale = ax2.scale
ax1.offset = ax2.offset
ax1.units = ax2.units
return self._gradient
def test_save_load_multidim_navigation_marker(self, tmp_path, file, lazy):
filename = tmp_path / file
x, y = (1, 2, 3), (5, 6, 7)
name = 'test point'
s = Signal2D(np.arange(300).reshape(3, 10, 10))
if lazy:
s = s.as_lazy()
m = markers.point(x=x, y=y)
m.name = name
s.add_marker(m, permanent=True)
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
assert m1.get_data_position('x1') == x[0]
assert m1.get_data_position('y1') == y[0]
s1.axes_manager.navigation_axes[0].index = 1
assert m1.get_data_position('x1') == x[1]
assert m1.get_data_position('y1') == y[1]
s1.axes_manager.navigation_axes[0].index = 2
assert m1.get_data_position('x1') == x[2]
assert m1.get_data_position('y1') == y[2]
def setup_method(self, method):
rng = np.random.RandomState(123)
ics = rng.laplace(size=(3, 1024))
mixing_matrix = rng.random((100, 3))
s = Signal2D((mixing_matrix @ ics).reshape((100, 32, 32)))
for (axis, name) in zip(s.axes_manager._axes, ("z", "y", "x")):
axis.name = name
s.decomposition()
mask_sig = s._get_signal_signal(dtype="bool")
mask_sig.unfold()
mask_sig.isig[5] = True
mask_sig.fold()
mask_nav = s._get_navigation_signal(dtype="bool")
mask_nav.unfold()
mask_nav.isig[5] = True
mask_nav.fold()
self.s = s
self.mask_nav = mask_nav
self.mask_sig = mask_sig
def setup_method(self, method):
s = Signal2D(np.arange(100).reshape(10, 10))
self.s = s
def argand_diagram(self, size=[256, 256], range=None):
"""
Calculate and plot Argand diagram of complex signal
Parameters
----------
size : [int, int], optional
Size of the Argand plot in pixels
(Default: [256, 256])
range : array_like, shape(2,2) or shape(2,) optional
The position of the edges of the diagram
(if not specified explicitly in the bins parameters): [[xmin, xmax], [ymin, ymax]].
All values outside of this range will be considered outliers and not tallied in the histogram.
(Default: None)
Returns
-------
argand_diagram:
Argand diagram as Signal2D
Examples
--------
>>> import hyperspy.api as hs
>>> holo = hs.datasets.example_signals.object_hologram()
>>> ref = hs.datasets.example_signals.reference_hologram()
>>> w = holo.reconstruct_phase(ref)
>>> w.argand_diagram(range=[-3, 3]).plot()
"""
im = self.imag.data.ravel()
re = self.real.data.ravel()
if range:
if np.asarray(range).shape == (2,):
range = [[range[0], range[1]],
[range[0], range[1]]]
elif np.asarray(range).shape != (2, 2):
raise ValueError('display_range should be array_like, shape(2,2) or shape(2,).')
argand_diagram, real_edges, imag_edges = np.histogram2d(re, im, bins=size, range=range)
argand_diagram = Signal2D(argand_diagram.T)
argand_diagram.metadata = self.metadata.deepcopy()
argand_diagram.metadata.General.title = 'Argand diagram of {}'.format(self.metadata.General.title)
if self.real.metadata.Signal.has_item('quantity'):
quantity_real, units_real = parse_quantity(self.real.metadata.Signal.quantity)
argand_diagram.axes_manager.signal_axes[0].name = quantity_real
else:
argand_diagram.axes_manager.signal_axes[0].name = 'Real'
units_real = None
argand_diagram.axes_manager.signal_axes[0].offset = real_edges[0]
argand_diagram.axes_manager.signal_axes[0].scale = np.abs(real_edges[0] - real_edges[1])
if self.imag.metadata.Signal.has_item('quantity'):
quantity_imag, units_imag = parse_quantity(self.imag.metadata.Signal.quantity)
argand_diagram.axes_manager.signal_axes[1].name = quantity_imag
else:
argand_diagram.axes_manager.signal_axes[1].name = 'Imaginary'
units_imag = None
argand_diagram.axes_manager.signal_axes[1].offset = imag_edges[0]
argand_diagram.axes_manager.signal_axes[1].scale = np.abs(imag_edges[0] - imag_edges[1])
if units_real:
argand_diagram.axes_manager.signal_axes[0].units = units_real
if units_imag:
argand_diagram.axes_manager.signal_axes[1].units = units_imag
return argand_diagram
def _make_heatmap_subplot(spectra):
from hyperspy._signals.signal2d import Signal2D
im = Signal2D(spectra.data, axes=spectra.axes_manager._get_axes_dicts())
im.metadata.General.title = spectra.metadata.General.title
im.plot()
return im._plot.signal_plot.ax
def setup_method(self, method):
self.s = Signal2D(np.random.random((2, 3, 4, 5)))
def test_Component_fit_wrong_signal():
s = Signal2D(np.arange(2 * 3 * 4).reshape(2, 3, 4))
m = s.create_model()
with pytest.raises(SignalDimensionError):
ComponentFit(m, Gaussian())
def setup_method(self, method):
self.im = Signal2D(np.random.random((2, 3)))
