def test_load_acquire(self):
fname0 = os.path.join(self.dirpathold, '64x64_TEM_images_acquire.emi')
s0 = load(fname0)
assert s0.axes_manager.signal_dimension == 2
assert (
s0.metadata.Acquisition_instrument.TEM.acquisition_mode == 'TEM')
assert_allclose(s0.axes_manager[0].scale, 6.281833, atol=1E-5)
assert s0.axes_manager[0].units == 'nm'
assert_allclose(s0.axes_manager[1].scale, 6.281833, atol=1E-5)
assert s0.axes_manager[1].units == 'nm'
assert (s0.axes_manager[0].name == 'x')
assert (s0.axes_manager[1].name == 'y')
fname1 = os.path.join(self.dirpathold, '16x16_STEM_BF_DF_acquire.emi')
s1 = load(fname1)
assert len(s1) == 2
for s in s1:
assert s.data.shape == (16, 16)
assert (
s.metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(
s.axes_manager[0].scale, 21.510044, atol=1E-5)
assert s.axes_manager[0].units == 'nm'
assert_allclose(
s.axes_manager[1].scale, 21.510044, atol=1E-5)
assert s.axes_manager[1].units == 'nm'
assert (s.axes_manager[0].name == 'x')
assert (s.axes_manager[1].name == 'y')
def test_load_spectrum_line_scan(self):
fname0 = os.path.join(
self.dirpathold, '16x16-line_profile_horizontal_10x1024.emi')
s0 = load(fname0)
assert s0.data.shape == (10, 1024)
assert s0.axes_manager.signal_dimension == 1
assert (
s0.metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(s0.axes_manager[0].scale, 0.12303, atol=1E-5)
assert s0.axes_manager[0].units == 'nm'
assert_allclose(s0.axes_manager[1].scale, 0.2, atol=1E-5)
assert s0.axes_manager[1].units == 'eV'
assert (s0.axes_manager[0].name == 'x')
assert (s0.axes_manager[1].name == 'Energy')
fname1 = os.path.join(
self.dirpathold, '16x16-line_profile_diagonal_10x1024.emi')
s1 = load(fname1)
assert s1.data.shape == (10, 1024)
assert s1.axes_manager.signal_dimension == 1
assert (
s1.metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(s1.axes_manager[0].scale, 0.166318, atol=1E-5)
assert s1.axes_manager[0].units == 'nm'
assert_allclose(s1.axes_manager[1].scale, 0.2, atol=1E-5)
assert s1.axes_manager[1].units == 'eV'
assert (s0.axes_manager[0].name == 'x')
def test_load_emi_old_new_format(self):
# TIA old format
fname0 = os.path.join(self.dirpathold, '64x64_TEM_images_acquire.emi')
load(fname0)
# TIA new format
fname1 = os.path.join(self.dirpathnew, '128x128_TEM_acquire-sum1.emi')
load(fname1)
def test_load_spectrum_point(self):
fname0 = os.path.join(
self.dirpathold, '16x16-point_spectrum-1x1024.emi')
s0 = load(fname0)
nt.assert_equal(s0.data.shape, (1, 1024))
nt.assert_equal(s0.axes_manager.signal_dimension, 1)
nt.assert_equal(
s0.metadata.Acquisition_instrument.TEM.acquisition_mode, 'STEM')
# single spectrum should be imported as 1D data, not 2D
nt.assert_almost_equal(
s0.axes_manager[0].scale, 1000000000.0, places=5)
nt.assert_equal(s0.axes_manager[0].units, 'nm')
nt.assert_almost_equal(s0.axes_manager[1].scale, 0.2, places=5)
nt.assert_equal(s0.axes_manager[1].units, 'eV')
fname1 = os.path.join(
self.dirpathold, '16x16-2_point-spectra-2x1024.emi')
s1 = load(fname1)
nt.assert_equal(s1.data.shape, (2, 1024))
nt.assert_equal(s1.axes_manager.signal_dimension, 1)
nt.assert_equal(
s1.metadata.Acquisition_instrument.TEM.acquisition_mode, 'STEM')
nt.assert_almost_equal(
s0.axes_manager[0].scale, 1000000000.0, places=5)
nt.assert_equal(s0.axes_manager[0].units, 'nm')
nt.assert_almost_equal(s0.axes_manager[1].scale, 0.2, places=5)
nt.assert_equal(s0.axes_manager[1].units, 'eV')
def test_load_multisignal_stack(self):
fname0 = os.path.join(
self.dirpathnew, '16x16-line_profile_horizontal_5x128x128_EDS.emi')
fname1 = os.path.join(
self.dirpathnew,
'16x16-line_profile_horizontal_5x128x128_EDS_copy.emi')
load([fname0, fname1], stack=True)
def test_load_spectrum_point(self):
fname0 = os.path.join(
self.dirpathold, '16x16-point_spectrum-1x1024.emi')
s0 = load(fname0)
assert s0.data.shape == (1, 1024)
assert s0.axes_manager.signal_dimension == 1
assert (
s0.metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
# single spectrum should be imported as 1D data, not 2D
# TODO: the following calibration is wrong because it parse the
# 'Dim-1_CalibrationDelta' from the ser header, which is not correct in
# case of point spectra. However, the position seems to be saved in
# 'PositionX' and 'PositionY' arrays of the ser header, so it should
# be possible to workaround using the position arrays.
# nt.assert_almost_equal(
# s0.axes_manager[0].scale, 1.0, places=5)
# nt.assert_equal(s0.axes_manager[0].units, '')
# nt.assert_is(s0.axes_manager[0].name, 'Position index')
assert_allclose(s0.axes_manager[1].scale, 0.2, atol=1E-5)
assert s0.axes_manager[1].units == 'eV'
assert (s0.axes_manager[1].name == 'Energy')
fname1 = os.path.join(
self.dirpathold, '16x16-2_point-spectra-2x1024.emi')
s1 = load(fname1)
assert s1.data.shape == (2, 1024)
assert s1.axes_manager.signal_dimension == 1
assert (
s1.metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(s0.axes_manager[1].scale, 0.2, atol=1E-5)
assert s0.axes_manager[1].units == 'eV'
assert (s0.axes_manager[1].name == 'Energy')
def test_load_with_dataset_name(self):
s = load(self.hdf5_dataset_path)
assert len(s) == len(self.dataset_name_list)
for dataset_name, data_size in zip(
self.dataset_name_list, self.data_size_list):
s = load(self.hdf5_dataset_path, dataset_name=dataset_name)
assert s.metadata.General.title == dataset_name
assert s.data.shape == data_size
def test_load_multisignal_stack_mismatch(self):
fname0 = os.path.join(
self.dirpathnew, '16x16-diffraction_imagel_5x5x256x256_EDS.emi')
fname1 = os.path.join(
self.dirpathnew,
'16x16-diffraction_imagel_5x5x256x256_EDS_copy.emi')
with pytest.raises(ValueError) as cm:
load([fname0, fname1], stack=True)
cm.match("The number of sub-signals per file does not match*")
def test_date_time(self):
fname0 = os.path.join(self.dirpathold, '64x64_TEM_images_acquire.emi')
s = load(fname0)
assert s.metadata.General.date == "2016-02-21"
assert s.metadata.General.time == "17:50:18"
fname1 = os.path.join(self.dirpathold,
'16x16-line_profile_horizontal_10x1024.emi')
s = load(fname1)
assert (s.metadata.General.date == "2016-02-22")
assert (s.metadata.General.time == "11:50:36")
def test_load_multisignal_stack_mismatch(self):
fname0 = os.path.join(
self.dirpathnew, '16x16-diffraction_imagel_5x5x256x256_EDS.emi')
fname1 = os.path.join(
self.dirpathnew,
'16x16-diffraction_imagel_5x5x256x256_EDS_copy.emi')
with nt.assert_raises(ValueError) as cm:
load([fname0, fname1], stack=True)
nt.assert_true(str(cm.exception).startswith(
"The number of sub-signals per file does not match"))
def _run_test(dtype, shape, dim, tmpdir):
s = _create_signal(shape=shape, dim=dim, dtype=dtype)
filename = _get_filename(s)
s.save(os.path.join(tmpdir, filename))
s_just_saved = load(os.path.join(tmpdir, filename))
s_ref = load(os.path.join(MYPATH, "ripple_files", filename))
try:
for stest in (s_just_saved, s_ref):
npt.assert_array_equal(s.data, stest.data)
nt.assert_equal(s.data.dtype, stest.data.dtype)
nt.assert_equal(s.axes_manager.signal_dimension,
stest.axes_manager.signal_dimension)
mdpaths = (
"General.date",
"General.time",
"Signal.signal_type")
if s.metadata.Signal.signal_type == "EELS":
mdpaths += (
"Acquisition_instrument.TEM.convergence_angle",
"Acquisition_instrument.TEM.beam_energy",
"Acquisition_instrument.TEM.Detector.EELS.collection_angle"
)
elif "EDS" in s.metadata.Signal.signal_type:
mdpaths += (
"Acquisition_instrument.TEM.tilt_stage",
"Acquisition_instrument.TEM.Detector.EDS.azimuth_angle",
"Acquisition_instrument.TEM.Detector.EDS.elevation_angle",
"Acquisition_instrument.TEM.Detector."
"EDS.energy_resolution_MnKa",
"Acquisition_instrument.TEM.Detector.EDS.live_time",
)
for mdpath in mdpaths:
nt.assert_equal(
s.metadata.get_item(mdpath),
stest.metadata.get_item(mdpath),)
for saxis, taxis in zip(
s.axes_manager._axes, stest.axes_manager._axes):
nt.assert_equal(saxis.scale, taxis.scale)
nt.assert_equal(saxis.offset, taxis.offset)
nt.assert_equal(saxis.units, taxis.units)
nt.assert_equal(saxis.name, taxis.name)
except:
raise
finally:
# As of v0.8.5 the data in the ripple files are loaded as memmaps
# instead of array. In Windows the garbage collector doesn't close
# the file before attempting to delete it making the test fail.
# The following lines simply make sure that the memmap is closed.
# del s_just_saved.data
# del s_ref.data
del s_just_saved
del s_ref
gc.collect()
def test_location():
fname_list = ['Fei HAADF-DE_location.dm3', 'Fei HAADF-FR_location.dm3',
'Fei HAADF-MX_location.dm3', 'Fei HAADF-UK_location.dm3']
s = load(os.path.join(MY_PATH, "dm3_locale", fname_list[0]))
assert s.metadata.General.date == "2016-08-27"
assert s.metadata.General.time == "20:54:33"
s = load(os.path.join(MY_PATH, "dm3_locale", fname_list[1]))
assert s.metadata.General.date == "2016-08-27"
assert s.metadata.General.time == "20:55:20"
s = load(os.path.join(MY_PATH, "dm3_locale", fname_list[2]))
assert s.metadata.General.date == "2016-08-27"
# assert_equal(s.metadata.General.time, "20:55:20") # MX not working
s = load(os.path.join(MY_PATH, "dm3_locale", fname_list[3]))
assert s.metadata.General.date == "2016-08-27"
assert s.metadata.General.time == "20:52:30"
def test_save_and_load_model(self):
m = self.m
m.save("tmp.hdf5")
l = load("tmp.hdf5")
nt.assert_true(hasattr(l.models, "a"))
n = l.models.restore("a")
nt.assert_equal(n.components.something.A.value, 13)
def test_save_and_load_model(self):
m = self.m
m.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
nt.assert_true(hasattr(l.models, 'a'))
n = l.models.restore('a')
nt.assert_equal(n.components.something.A.value, 13)
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_and_load_model(self):
m = self.m
m.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
assert hasattr(l.models, 'a')
n = l.models.restore('a')
assert n[0].fine_structure_width == 50
def test_quantity(self, tmpfilepath):
s = self.s
quantity = "Intensity (electron)"
s.metadata.Signal.quantity = quantity
s.save(tmpfilepath)
l = load(tmpfilepath + ".hspy")
assert l.metadata.Signal.quantity == quantity
def open_file(self, *args, **kw):
S = LoadSpectrum()
S.edit_traits()
if S.sp_file is not t.Undefined:
s = io.load(S.sp_file)
s.plot()
interactive_ns['s'] = s
def test_read_EDS_metadata():
fname = os.path.join(my_path, "dm3_1D_data", "test-EDS_spectrum.dm3")
s = load(fname)
md = s.metadata
nt.assert_equal(md.Acquisition_instrument.TEM.acquisition_mode, "STEM")
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EDS.azimuth_angle, 45.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EDS.elevation_angle, 18.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EDS.energy_resolution_MnKa, 130.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EDS.live_time, 3.806)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EDS.real_time, 4.233)
nt.assert_almost_equal(md.Acquisition_instrument.TEM.tilt_stage, 24.95,
places=2)
nt.assert_almost_equal(md.Acquisition_instrument.TEM.beam_energy, 200.0)
nt.assert_equal(md.Acquisition_instrument.TEM.microscope, "FEI Titan")
nt.assert_almost_equal(md.Acquisition_instrument.TEM.camera_length, 135.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.magnification,
320000.0)
nt.assert_equal(md.General.date, "2016-08-08")
nt.assert_equal(md.General.original_filename, "test-EDS_spectrum.dm3")
nt.assert_equal(md.General.title, "EDS Spectrum")
nt.assert_equal(md.General.time, "21:46:19")
nt.assert_equal(md.Signal.quantity, "X-rays (Counts)")
nt.assert_equal(md.Signal.signal_type, "EDS_TEM")
def test_metadata_update_to_v3_0(self):
md = {'Acquisition_instrument': {'SEM': {'Stage': {'tilt_alpha': 5.0}},
'TEM': {'Detector': {'Camera': {'exposure': 0.20000000000000001}},
'Stage': {'tilt_alpha': 10.0},
'acquisition_mode': 'TEM',
'beam_current': 0.0,
'beam_energy': 200.0,
'camera_length': 320.00000000000006,
'microscope': 'FEI Tecnai'}},
'General': {'date': '2014-07-09',
'original_filename': 'test_diffraction_pattern.dm3',
'time': '18:56:37',
'title': 'test_diffraction_pattern'},
'Signal': {'Noise_properties': {'Variance_linear_model': {'gain_factor': 1.0,
'gain_offset': 0.0}},
'binned': False,
'quantity': 'Intensity',
'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
s = load(os.path.join(
my_path,
"hdf5_files",
'example2_v2.2.hspy'))
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_quantity(self):
s = self.s
quantity = "Intensity (electron)"
s.metadata.Signal.quantity = quantity
s.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
nt.assert_equal(l.metadata.Signal.quantity, quantity)
def test_read_EELS_metadata():
fname = os.path.join(my_path, "dm3_1D_data", "test-EELS_spectrum.dm3")
s = load(fname)
md = s.metadata
nt.assert_equal(md.Acquisition_instrument.TEM.acquisition_mode, "STEM")
nt.assert_almost_equal(md.Acquisition_instrument.TEM.beam_energy, 200.0)
nt.assert_equal(md.Acquisition_instrument.TEM.microscope, "FEI Titan")
nt.assert_almost_equal(md.Acquisition_instrument.TEM.camera_length, 135.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.magnification,
640000.0)
nt.assert_almost_equal(md.Acquisition_instrument.TEM.tilt_stage, 24.95,
places=2)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.convergence_angle, 21.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EELS.collection_angle, 0.0)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EELS.exposure,
0.00349999)
nt.assert_almost_equal(
md.Acquisition_instrument.TEM.Detector.EELS.frame_number, 50)
nt.assert_equal(
md.Acquisition_instrument.TEM.Detector.EELS.spectrometer,
'GIF Quantum ER')
nt.assert_equal(
md.Acquisition_instrument.TEM.Detector.EELS.aperture_size,
5.0)
nt.assert_equal(md.General.date, "2016-08-08")
nt.assert_equal(md.General.original_filename, "test-EELS_spectrum.dm3")
nt.assert_equal(md.General.title, "EELS Acquire")
nt.assert_equal(md.General.time, "19:35:17")
nt.assert_equal(md.Signal.quantity, "Electrons (Counts)")
nt.assert_equal(md.Signal.signal_type, "EELS")
def test_load_diffraction_line_scan(self):
fname0 = os.path.join(
self.dirpathnew, '16x16-line_profile_horizontal_5x128x128_EDS.emi')
s0 = load(fname0)
# s0[0] contains EDS
assert s0[0].data.shape == (5, 4000)
assert s0[0].axes_manager.signal_dimension == 1
assert (
s0[0].metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(s0[0].axes_manager[0].scale, 3.68864, atol=1E-5)
assert s0[0].axes_manager[0].units == 'nm'
assert_allclose(s0[0].axes_manager[1].scale, 5.0, atol=1E-5)
assert s0[0].axes_manager[1].units == 'eV'
assert (s0[0].axes_manager[0].name == 'x')
assert (s0[0].axes_manager[1].name == 'Energy')
# s0[1] contains diffraction patterns
assert s0[1].data.shape == (5, 128, 128)
assert s0[1].axes_manager.signal_dimension == 2
assert (
s0[1].metadata.Acquisition_instrument.TEM.acquisition_mode == 'STEM')
assert_allclose(s0[1].axes_manager[0].scale, 3.68864, atol=1E-5)
assert s0[1].axes_manager[0].units == 'nm'
assert s0[1].axes_manager[1].units == '1/nm'
assert (s0[1].axes_manager[0].name == 'x')
assert_allclose(s0[1].axes_manager[1].scale, 0.17435, atol=1E-5)
assert_allclose(s0[1].axes_manager[2].scale, 0.17435, atol=1E-5)
assert s0[1].axes_manager[2].units == '1/nm'
assert (s0[1].axes_manager[1].units == '1/nm')
assert (s0[1].axes_manager[1].name == 'x')
assert (s0[1].axes_manager[2].name == 'y')
def test_read_EDS_metadata():
fname = os.path.join(MY_PATH, "dm3_1D_data", "test-EDS_spectrum.dm3")
s = load(fname)
md = s.metadata
assert md.Acquisition_instrument.TEM.acquisition_mode == "STEM"
assert_allclose(
md.Acquisition_instrument.TEM.Detector.EDS.azimuth_angle, 45.0)
assert_allclose(
md.Acquisition_instrument.TEM.Detector.EDS.elevation_angle, 18.0)
assert_allclose(
md.Acquisition_instrument.TEM.Detector.EDS.energy_resolution_MnKa, 130.0)
assert_allclose(
md.Acquisition_instrument.TEM.Detector.EDS.live_time, 3.806)
assert_allclose(
md.Acquisition_instrument.TEM.Detector.EDS.real_time, 4.233)
assert_allclose(md.Acquisition_instrument.TEM.tilt_stage, 24.95,
atol=1E-2)
assert_allclose(md.Acquisition_instrument.TEM.beam_energy, 200.0)
assert md.Acquisition_instrument.TEM.microscope == "FEI Titan"
assert_allclose(md.Acquisition_instrument.TEM.camera_length, 135.0)
assert_allclose(
md.Acquisition_instrument.TEM.magnification,
320000.0)
assert md.General.date == "2016-08-08"
assert md.General.original_filename == "test-EDS_spectrum.dm3"
assert md.General.title == "EDS Spectrum"
assert md.General.time == "21:46:19"
assert md.Signal.quantity == "X-rays (Counts)"
assert md.Signal.signal_type == "EDS_TEM"
assert_allclose(
md.Signal.Noise_properties.Variance_linear_model.gain_factor,
1.0)
assert_allclose(
md.Signal.Noise_properties.Variance_linear_model.gain_offset,
0.0)
def test_load_units_scale(self):
# TEM image
fname0 = os.path.join(self.dirpathold, '64x64_TEM_images_acquire.emi')
s0 = load(fname0)
nt.assert_almost_equal(s0.axes_manager[0].scale, 6.28183, places=5)
nt.assert_equal(s0.axes_manager[0].units, 'nm')
# TEM diffraction
fname1 = os.path.join(self.dirpathold, '64x64_diffraction_acquire.emi')
s1 = load(fname1)
nt.assert_almost_equal(s1.axes_manager[0].scale, 0.10157, places=4)
nt.assert_equal(s1.axes_manager[0].units, '1/nm')
# STEM diffraction
fname2 = os.path.join(self.dirpathold, '16x16_STEM_BF_DF_acquire.emi')
s2 = load(fname2)
nt.assert_equal(s2[0].axes_manager[0].units, 'nm')
nt.assert_almost_equal(s2[0].axes_manager[0].scale, 21.5100, places=4)
def test_save_and_load_model(self):
m = self.m
m.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
assert hasattr(l.models, 'a')
n = l.models.restore('a')
assert n.components.something.A.value == 13
def test_load_stackbuilder_imagestack(self):
image_stack = load(os.path.join(my_path, "dm_stackbuilder_plugin",
"test_stackbuilder_imagestack.dm3"))
data_dimensions = image_stack.data.ndim
am = image_stack.axes_manager
axes_dimensions = am.signal_dimension + am.navigation_dimension
assert data_dimensions == axes_dimensions
md = image_stack.metadata
assert md.Acquisition_instrument.TEM.acquisition_mode == "STEM"
assert_allclose(md.Acquisition_instrument.TEM.beam_current, 0.0)
assert_allclose(md.Acquisition_instrument.TEM.beam_energy, 200.0)
assert_allclose(md.Acquisition_instrument.TEM.camera_length, 15.0)
assert_allclose(
md.Acquisition_instrument.TEM.dwell_time, 0.03000005078125)
assert_allclose(md.Acquisition_instrument.TEM.magnification, 200000.0)
assert md.Acquisition_instrument.TEM.microscope == "JEM-ARM200F"
assert md.General.date == "2015-05-17"
assert md.General.original_filename == "test_stackbuilder_imagestack.dm3"
assert md.General.title == "stackbuilder_test4_16x2"
assert md.General.time == "17:00:16"
assert md.Sample.description == "DWNC"
assert md.Signal.quantity == "Electrons (Counts)"
assert md.Signal.signal_type == ""
assert md.Signal.binned == False
assert_allclose(md.Signal.Noise_properties.Variance_linear_model.gain_factor,
0.15674974)
assert_allclose(md.Signal.Noise_properties.Variance_linear_model.gain_offset,
2228741.5)
def test_numpy_only_inner_lists(self):
s = self.s
s.metadata.set_item("test", [[1.0, 2], ("3", 4)])
s.save("tmp.hdf5", overwrite=True)
l = load("tmp.hdf5")
nt.assert_is_instance(l.metadata.test, list)
nt.assert_is_instance(l.metadata.test[0], list)
nt.assert_is_instance(l.metadata.test[1], tuple)
def test_numpy_only_inner_lists(self):
s = self.s
s.metadata.set_item('test', [[1., 2], ('3', 4)])
s.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
nt.assert_is_instance(l.metadata.test, list)
nt.assert_is_instance(l.metadata.test[0], list)
nt.assert_is_instance(l.metadata.test[1], tuple)
def test_load_stackbuilder_imagestack(self):
image_stack = load(
my_path +
"/dm_stackbuilder_plugin/test_stackbuilder_imagestack.dm3")
data_dimensions = image_stack.data.ndim
am = image_stack.axes_manager
axes_dimensions = am.signal_dimension + am.navigation_dimension
assert_equal(data_dimensions, axes_dimensions)
def test_minimum_metadata_example():
s = load(os.path.join(my_path, "msa_files", "minimum_metadata.msa"))
assert minimum_md_om == s.original_metadata.as_dictionary()
def test_with_title_loading():
signal = load(os.path.join(my_path, 'unf_files', 'example_with_title.unf'))
np.testing.assert_equal(signal.data, data_image)
np.testing.assert_equal(signal.original_metadata.IFORM, 2) # float
np.testing.assert_equal(signal.metadata.General.title, test_title)
assert isinstance(signal, Signal2D)
def setup_class(cls):
cls.spc = load(os.path.join(TMP_DIR.name, "spc0_61-ipr333_xrf.spc"))
cls.spc_loadAll = load(os.path.join(TMP_DIR.name,
"spc0_61-ipr333_xrf.spc"),
load_all_spc=True)
def test_fei_no_frametime():
signal = load(
os.path.join(my_path, 'emd_files', 'fei_example_tem_stack.emd'))
assert isinstance(signal, Signal2D)
assert signal.data.shape == (2, 3, 3)
assert signal.axes_manager["Time"].scale == 0.8
def test_load_with_dataset_name_several(self):
dataset_name = self.dataset_name_list[0:2]
s = load(self.hdf5_dataset_path, dataset_name=dataset_name)
assert len(s) == len(dataset_name)
assert s[0].metadata.General.title in dataset_name
assert s[1].metadata.General.title in dataset_name
def test_wrong_dataset_name(self):
with pytest.raises(IOError):
load(self.hdf5_dataset_path, dataset_name='a_wrong_name')
with pytest.raises(IOError):
load(self.hdf5_dataset_path,
dataset_name=[self.dataset_name_list[0], 'a_wrong_name'])
def test_load_file(self):
s = load(self.hdf5_dataset_path)
assert len(s) == len(self.group_path_list)
title_list = [s_temp.metadata.General.title for s_temp in s]
assert sorted(self.group_path_list) == sorted(title_list)
def test_image_2d_loading():
signal = load(os.path.join(my_path, 'emd_files', 'example_image.emd'))
np.testing.assert_equal(signal.data, data_image)
assert isinstance(signal, Signal2D)
def test_spectrum_1d_loading():
signal = load(os.path.join(my_path, 'emd_files', 'example_spectrum.emd'))
np.testing.assert_equal(signal.data, data_spectrum)
assert isinstance(signal, Signal1D)
def compareSaveLoad(self,
testShape,
dtype='int8',
compressor=None,
clevel=1,
lazy=False,
do_async=False,
**kwargs):
# This is the main function which reads and writes from disk.
mrcName = os.path.join(tmpDir,
"testMage_{}_lazy_{}.mrcz".format(dtype, lazy))
dtype = np.dtype(dtype)
if dtype == 'float32' or dtype == 'float64':
testData = np.random.normal(size=testShape).astype(dtype)
elif dtype == 'complex64' or dtype == 'complex128':
testData = np.random.normal(size=testShape).astype(
dtype) + 1.0j * np.random.normal(size=testShape).astype(dtype)
else: # integers
testData = np.random.randint(10, size=testShape).astype(dtype)
testSignal = signals.Signal2D(testData)
if lazy:
testSignal = testSignal.as_lazy()
# Unfortunately one cannot iterate over axes_manager in a Pythonic way
# for axis in testSignal.axes_manager:
testSignal.axes_manager[0].name = 'z'
testSignal.axes_manager[0].scale = np.random.uniform(low=0.0, high=1.0)
testSignal.axes_manager[0].units = 'nm'
testSignal.axes_manager[1].name = 'x'
testSignal.axes_manager[1].scale = np.random.uniform(low=0.0, high=1.0)
testSignal.axes_manager[1].units = 'nm'
testSignal.axes_manager[2].name = 'y'
testSignal.axes_manager[2].scale = np.random.uniform(low=0.0, high=1.0)
testSignal.axes_manager[2].units = 'nm'
# Meta-data that goes into MRC fixed header
testSignal.metadata.set_item('Acquisition_instrument.TEM.beam_energy',
300.0)
# Meta-data that goes into JSON extended header
testSignal.metadata.set_item(
'Acquisition_instrument.TEM.magnification', 25000)
testSignal.metadata.set_item(
'Signal.Noise_properties.Variance_linear_model.gain_factor', 1.0)
save(mrcName,
testSignal,
compressor=compressor,
clevel=clevel,
do_async=do_async,
**kwargs)
if do_async:
# Poll file on disk since we don't return the
# concurrent.futures.Future
t_stop = perf_counter() + MAX_ASYNC_TIME
sleep(0.005)
while (perf_counter() < t_stop):
try:
fh = open(mrcName, 'a')
fh.close()
break
except IOError:
sleep(0.001)
print("Time to save file: {} s".format(perf_counter() -
(t_stop - MAX_ASYNC_TIME)))
sleep(0.005)
reSignal = load(mrcName)
try:
os.remove(mrcName)
except IOError:
print("Warning: file {} left on disk".format(mrcName))
npt.assert_array_almost_equal(testSignal.data.shape,
reSignal.data.shape)
npt.assert_array_almost_equal(testSignal.data, reSignal.data)
npt.assert_almost_equal(
testSignal.metadata.Acquisition_instrument.TEM.beam_energy,
reSignal.metadata.Acquisition_instrument.TEM.beam_energy)
npt.assert_almost_equal(
testSignal.metadata.Acquisition_instrument.TEM.magnification,
reSignal.metadata.Acquisition_instrument.TEM.magnification)
for aName in ['x', 'y', 'z']:
npt.assert_equal(testSignal.axes_manager[aName].size,
reSignal.axes_manager[aName].size)
npt.assert_almost_equal(testSignal.axes_manager[aName].scale,
reSignal.axes_manager[aName].scale)
if dtype == 'complex64':
assert isinstance(reSignal, signals.ComplexSignal2D)
else:
assert isinstance(reSignal, signals.Signal2D)
assert_deep_almost_equal(testSignal.axes_manager.as_dictionary(),
reSignal.axes_manager.as_dictionary())
assert_deep_almost_equal(testSignal.metadata.as_dictionary(),
reSignal.metadata.as_dictionary())
return reSignal
def test_image_int32_loading():
signal = load(os.path.join(my_path, 'unf_files',
'example_image_int32.unf'))
np.testing.assert_equal(signal.data, data_image_int32)
np.testing.assert_equal(signal.original_metadata.IFORM, 4) # int32
assert isinstance(signal, Signal2D)
def test_signal_3d_loading():
signal = load(os.path.join(my_path, 'unf_files', 'example_signal_3d.unf'))
np.testing.assert_equal(signal.data, data_signal)
np.testing.assert_equal(signal.original_metadata.IFORM, 2) # float
assert isinstance(signal, BaseSignal)
def setup_class(cls):
cls.spd = load(os.path.join(TMP_DIR.name, "spc0_61-ipr333_xrf.spd"),
convert_units=True)
def setup_method(self, method):
self.s = load(os.path.join(my_path, "msa_files", "example2.msa"))
def setUp(self):
self.s = load(os.path.join(my_path, "msa_files", "example1.msa"))
def test_data_axis_length_1():
filename = os.path.join(my_path, 'emd_files', 'example_axis_len_1.emd')
signal = load(filename)
assert signal.data.shape == (5, 1, 5)
def check_load(filename, subfolder, key):
print('loading %s\\test-%i' % (subfolder, key))
s = load(filename)
# Store the data for the next tests
data_dict[subfolder][key] = s.data
def test_signal_3d_loading():
signal = load(os.path.join(my_path, 'emd_files', 'example_signal.emd'))
np.testing.assert_equal(signal.data, data_signal)
assert isinstance(signal, BaseSignal)
def test_fei_emd_si_non_square_10frames(self):
s = load(
os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'))
signal = s[1]
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'X-ray energy'
assert signal.axes_manager[2].size == 4096
assert signal.axes_manager[2].units == 'keV'
assert_allclose(signal.axes_manager[2].scale, 0.005, atol=1E-5)
assert signal.metadata.Acquisition_instrument.TEM.Detector.EDS.number_of_frames == 10
signal0 = s[0]
assert isinstance(signal0, Signal2D)
assert signal0.axes_manager[0].name == 'x'
assert signal0.axes_manager[0].size == 10
assert signal0.axes_manager[0].units == 'nm'
assert_allclose(signal0.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal0.axes_manager[1].name == 'y'
assert signal0.axes_manager[1].size == 50
assert signal0.axes_manager[1].units == 'nm'
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
SI_dtype=np.uint8,
rebin_energy=256)
signal = s[1]
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 10)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 10
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
assert signal.metadata.Acquisition_instrument.TEM.Detector.EDS.number_of_frames == 10
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
last_frame=5,
SI_dtype=np.uint8,
rebin_energy=256)
signal = s[1]
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 5)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 5
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
assert signal.metadata.Acquisition_instrument.TEM.Detector.EDS.number_of_frames == 5
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
first_frame=4,
SI_dtype=np.uint8,
rebin_energy=256)
signal = s[1]
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 6)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 6
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
assert signal.metadata.Acquisition_instrument.TEM.Detector.EDS.number_of_frames == 6
def test_fei_emd_si_non_square_10frames(self, lazy):
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
lazy=lazy)
signal = s[1]
if lazy:
assert signal._lazy
signal.compute(close_file=True)
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'X-ray energy'
assert signal.axes_manager[2].size == 4096
assert signal.axes_manager[2].units == 'keV'
assert_allclose(signal.axes_manager[2].scale, 0.005, atol=1E-5)
signal0 = s[0]
if lazy:
assert signal0._lazy
signal0.compute(close_file=True)
assert isinstance(signal0, Signal2D)
assert signal0.axes_manager[0].name == 'x'
assert signal0.axes_manager[0].size == 10
assert signal0.axes_manager[0].units == 'nm'
assert_allclose(signal0.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal0.axes_manager[1].name == 'y'
assert signal0.axes_manager[1].size == 50
assert signal0.axes_manager[1].units == 'nm'
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
SI_dtype=np.uint8,
rebin_energy=256,
lazy=lazy)
signal = s[1]
if lazy:
assert signal._lazy
signal.compute(close_file=True)
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 10)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 10
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
last_frame=5,
SI_dtype=np.uint8,
rebin_energy=256,
lazy=lazy)
signal = s[1]
if lazy:
assert signal._lazy
signal.compute(close_file=True)
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 5)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 5
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
s = load(os.path.join(self.fei_files_path,
'fei_SI_SuperX-HAADF_10frames_10x50.emd'),
sum_frames=False,
first_frame=4,
SI_dtype=np.uint8,
rebin_energy=256,
lazy=lazy)
signal = s[1]
if lazy:
assert signal._lazy
signal.compute(close_file=True)
assert isinstance(signal, EDSTEMSpectrum)
assert signal.axes_manager.navigation_shape == (10, 50, 6)
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].size == 10
assert signal.axes_manager[0].units == 'nm'
assert_allclose(signal.axes_manager[0].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].size == 50
assert signal.axes_manager[1].units == 'nm'
assert_allclose(signal.axes_manager[1].scale, 1.234009, atol=1E-5)
assert signal.axes_manager[2].name == 'Time'
assert signal.axes_manager[2].size == 6
assert signal.axes_manager[2].units == 's'
assert_allclose(signal.axes_manager[2].scale, 0.76800, atol=1E-5)
assert signal.axes_manager[3].name == 'X-ray energy'
assert signal.axes_manager[3].size == 16
assert signal.axes_manager[3].units == 'keV'
assert_allclose(signal.axes_manager[3].scale, 1.28, atol=1E-5)
def test_fei_emd_si(self):
signal = load(os.path.join(self.fei_files_path, 'fei_emd_si.emd'))
fei_si = np.load(os.path.join(self.fei_files_path, 'fei_emd_si.npy'))
np.testing.assert_equal(signal[1].data, fei_si)
assert isinstance(signal[1], Signal1D)
def test_fei_emd_image(self, lazy):
stage = {
'tilt_alpha': 0.006,
'tilt_beta': 0.000,
'x': -0.000009,
'y': 0.000144,
'z': 0.000029
}
md = {
'Acquisition_instrument': {
'TEM': {
'beam_energy': 200.0,
'camera_length': 98.0,
'magnification': 40000.0,
'microscope': 'Talos',
'Stage': stage
}
},
'General': {
'original_filename': 'fei_emd_image.emd',
'date': '2017-03-06',
'time': '09:56:41',
'time_zone': 'BST',
'title': 'HAADF'
},
'Signal': {
'binned': False,
'signal_type': 'image'
},
'_HyperSpy': {
'Folding': {
'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False
}
}
}
# Update time and time_zone to local ones
md['General']['time_zone'] = tz.tzlocal().tzname(datetime.today())
dt = datetime.fromtimestamp(1488794201, tz=tz.tzutc())
date, time = dt.astimezone(
tz.tzlocal()).isoformat().split('+')[0].split('T')
md['General']['date'] = date
md['General']['time'] = time
signal = load(os.path.join(self.fei_files_path, 'fei_emd_image.emd'),
lazy=lazy)
if lazy:
assert signal._lazy
signal.compute(close_file=True)
fei_image = np.load(
os.path.join(self.fei_files_path, 'fei_emd_image.npy'))
assert signal.axes_manager[0].name == 'x'
assert signal.axes_manager[0].units == 'µm'
assert_allclose(signal.axes_manager[0].scale, 0.00530241, rtol=1E-5)
assert signal.axes_manager[1].name == 'y'
assert signal.axes_manager[1].units == 'µm'
assert_allclose(signal.axes_manager[1].scale, 0.00530241, rtol=1E-5)
assert_allclose(signal.data, fei_image)
assert_deep_almost_equal(signal.metadata.as_dictionary(), md)
assert isinstance(signal, Signal2D)
def test_fei_complex_loading():
signal = load(
os.path.join(my_path, 'emd_files', 'fei_example_complex_fft.emd'))
assert isinstance(signal, ComplexSignal2D)
def test_data_numpy_object_dtype():
filename = os.path.join(my_path, 'emd_files',
'example_object_dtype_data.emd')
signal = load(filename)
np.testing.assert_equal(signal.data,
np.array([['a, 2, test1', 'a, 2, test1']]))
def test_multi_signal():
fname = os.path.join(MY_PATH, "dm3_2D_data", "multi_signal.dm3")
s = load(fname)
# Make sure file is read as a list, and exactly two signals are found
assert isinstance(s, list)
assert len(s) == 2
s1, s2 = s
# First signal is an image, second is a plot
assert isinstance(s1, Signal2D)
assert isinstance(s2, Signal1D)
s1_md_truth = {
'_HyperSpy': {
'Folding': {
'unfolded': False,
'signal_unfolded': False,
'original_shape': None,
'original_axes_manager': None
}
},
'General': {
'title': 'HAADF',
'original_filename': 'multi_signal.dm3',
'date': '2019-12-10',
'time': '15:32:41',
'authors': 'JohnDoe'
},
'Signal': {
'binned': False,
'signal_type': '',
'quantity': 'Intensity',
'Noise_properties': {
'Variance_linear_model': {
'gain_factor': 1.0,
'gain_offset': 0.0
}
}
},
'Acquisition_instrument': {
'TEM': {
'beam_energy': 300.0,
'Stage': {
'tilt_alpha': 0.001951998453075299,
'x': 0.07872150000000001,
'y': 0.100896,
'z': -0.0895279
},
'acquisition_mode': 'STEM',
'beam_current': 0.0,
'camera_length': 77.0,
'magnification': 10000000.0,
'microscope': 'Example Microscope',
'dwell_time': 3.2400001525878905e-05
}
},
'Sample': {
'description': 'PrecipitateA'
}
}
s2_md_truth = {
'_HyperSpy': {
'Folding': {
'unfolded': False,
'signal_unfolded': False,
'original_shape': None,
'original_axes_manager': None
}
},
'General': {
'title': 'Plot',
'original_filename': 'multi_signal.dm3'
},
'Signal': {
'binned': False,
'signal_type': '',
'quantity': 'Intensity',
'Noise_properties': {
'Variance_linear_model': {
'gain_factor': 1.0,
'gain_offset': 0.0
}
}
}
}
# make sure the metadata dictionaries are as we expect
assert s1.metadata.as_dictionary() == s1_md_truth
assert s2.metadata.as_dictionary() == s2_md_truth
# rather than testing all of original metadata (huge), use length as a proxy
assert len(json.dumps(s1.original_metadata.as_dictionary())) == 17779
assert len(json.dumps(s2.original_metadata.as_dictionary())) == 15024
# simple tests on the data itself:
assert s1.data.sum() == 949490255
assert s1.data.shape == (512, 512)
assert s2.data.sum() == pytest.approx(28.085794, 0.01)
assert s2.data.shape == (512, )
def test_image_complex_loading():
signal = load(
os.path.join(my_path, 'unf_files', 'example_image_complex.unf'))
np.testing.assert_equal(signal.data, data_image_complex)
np.testing.assert_equal(signal.original_metadata.IFORM, 3) # complex
assert isinstance(signal, ComplexSignal)
def test_load_file(self):
s = load(self.hdf5_dataset_path)
assert len(s) == len(self.group_path_list)
title_list = [s_temp.metadata.General.title for s_temp in s]
for _s, path in zip(s, self.group_path_list):
assert _s.metadata.General.title in path
def test_data_numpy_object_dtype():
filename = os.path.join(my_path, 'emd_files',
'example_object_dtype_data.emd')
signal = load(filename)
assert len(signal) == 0
def test_no_label_loading():
signal = load(os.path.join(my_path, 'unf_files', 'example_no_label.unf'))
np.testing.assert_equal(signal.data, data_image)
np.testing.assert_equal(signal.original_metadata.ILABEL, 0)
assert isinstance(signal, Signal2D)
def test_deprecated_dataset_name(self):
with pytest.warns(UserWarning):
dataset_name = os.path.dirname(self.dataset_path_list[0])
load(self.hdf5_dataset_path, dataset_name=dataset_name)
