def test_read_Zeiss_SEM_scale_metadata_512_image():
md = {'Acquisition_instrument': {'SEM': {'Stage': {'rotation': 245.8,
'tilt': 0.0,
'x': 62.9961,
'y': 65.3168,
'z': 44.678},
'beam_energy': 5.0,
'magnification': '50.00 K X',
'microscope': 'ULTRA 55-36-06',
'working_distance': 3.9}},
'General': {'authors': 'LIBERATO',
'date': '2018-09-25',
'original_filename': 'test_tiff_Zeiss_SEM_512pix.tif',
'time': '08:20:42',
'title': ''},
'Signal': {'binned': False, 'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
fname = os.path.join(MY_PATH2, 'test_tiff_Zeiss_SEM_512pix.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'um'
assert s.axes_manager[1].units == 'um'
assert_allclose(s.axes_manager[0].scale, 0.011649976, rtol=1E-6)
assert_allclose(s.axes_manager[1].scale, 0.011649976, rtol=1E-6)
assert s.data.dtype == 'uint8'
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
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_read_TVIPS_metadata():
md = {'Acquisition_instrument': {'TEM': {'Detector': {'Camera': {'exposure': 0.4,
'name': 'F416'}},
'Stage': {'tilt_alpha': -0.0070000002,
'tilt_beta': -0.055,
'x': 0.0,
'y': -9.2000000506686774e-05,
'z': 7.0000001350933871e-06},
'beam_energy': 99.0,
'magnification': 32000.0}},
'General': {'original_filename': 'TVIPS_bin4.tif',
'time': '9:01:17',
'title': ''},
'Signal': {'binned': False, 'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
fname = os.path.join(MY_PATH2, 'TVIPS_bin4.tif')
s = hs.load(fname, convert_units=True)
assert s.data.dtype == np.uint8
assert s.data.shape == (1024, 1024)
assert s.axes_manager[0].units == 'nm'
assert s.axes_manager[1].units == 'nm'
assert_allclose(s.axes_manager[0].scale, 1.42080, rtol=1E-5)
assert_allclose(s.axes_manager[1].scale, 1.42080, rtol=1E-5)
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_save_load_cycle():
sig_reload = None
signal = hs.load(file2)
nt.assert_equal(signal.metadata.General.original_filename, 'test2.blo')
nt.assert_equal(signal.metadata.General.date, "2015-12-01")
nt.assert_equal(signal.metadata.General.time, "15:43:09.828057")
nt.assert_equal(
signal.metadata.General.notes,
"Precession angle : \r\nPrecession Frequency : \r\nCamera gamma : on")
signal.save(save_path, overwrite=True)
sig_reload = hs.load(save_path)
np.testing.assert_equal(signal.data, sig_reload.data)
nt.assert_equal(signal.axes_manager.as_dictionary(),
sig_reload.axes_manager.as_dictionary())
nt.assert_equal(signal.original_metadata.as_dictionary(),
sig_reload.original_metadata.as_dictionary())
# change original_filename to make the metadata of both signals equals
sig_reload.metadata.General.original_filename = signal.metadata.General.original_filename
assert_deep_almost_equal(signal.metadata.as_dictionary(),
sig_reload.metadata.as_dictionary())
nt.assert_equal(
signal.metadata.General.date,
sig_reload.metadata.General.date)
nt.assert_equal(
signal.metadata.General.time,
sig_reload.metadata.General.time)
nt.assert_is_instance(signal, hs.signals.Signal2D)
# Delete reference to close memmap file!
del sig_reload
gc.collect()
_remove_file(save_path)
def test_save_load_cycle(save_path):
sig_reload = None
signal = hs.load(FILE2)
serial = signal.original_metadata['blockfile_header']['Acquisition_time']
date, time, timezone = serial_date_to_ISO_format(serial)
assert signal.metadata.General.original_filename == 'test2.blo'
assert signal.metadata.General.date == date
assert signal.metadata.General.time == time
assert signal.metadata.General.time_zone == timezone
assert (
signal.metadata.General.notes ==
"Precession angle : \r\nPrecession Frequency : \r\nCamera gamma : on")
signal.save(save_path, overwrite=True)
sig_reload = hs.load(save_path)
np.testing.assert_equal(signal.data, sig_reload.data)
assert (signal.axes_manager.as_dictionary() ==
sig_reload.axes_manager.as_dictionary())
assert (signal.original_metadata.as_dictionary() ==
sig_reload.original_metadata.as_dictionary())
# change original_filename to make the metadata of both signals equals
sig_reload.metadata.General.original_filename = signal.metadata.General.original_filename
assert_deep_almost_equal(signal.metadata.as_dictionary(),
sig_reload.metadata.as_dictionary())
assert (
signal.metadata.General.date ==
sig_reload.metadata.General.date)
assert (
signal.metadata.General.time ==
sig_reload.metadata.General.time)
assert isinstance(signal, hs.signals.Signal2D)
# Delete reference to close memmap file!
del sig_reload
def test_read_Zeiss_SEM_scale_metadata_1k_image():
md = {'Acquisition_instrument': {'SEM': {'Stage': {'rotation': 10.2,
'tilt': -0.0,
'x': 75.6442,
'y': 60.4901,
'z': 25.193},
'beam_current': 80000.0,
'beam_energy': 25.0,
'dwell_time': 5e-08,
'magnification': 105.0,
'microscope': 'Merlin-61-08',
'working_distance': 14.81}},
'General': {'authors': 'LIM',
'date': '2015-12-23',
'original_filename': 'test_tiff_Zeiss_SEM_1k.tif',
'time': '09:40:32',
'title': ''},
'Signal': {'binned': False, 'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
fname = os.path.join(MY_PATH2, 'test_tiff_Zeiss_SEM_1k.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'um'
assert s.axes_manager[1].units == 'um'
assert_allclose(s.axes_manager[0].scale, 2.614514, rtol=1E-6)
assert_allclose(s.axes_manager[1].scale, 2.614514, rtol=1E-6)
assert s.data.dtype == 'uint8'
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_convert_to_units_unsupported_units(self, same_units):
with assert_warns(
message="not supported for conversion.",
category=UserWarning):
self.am.convert_units('navigation', units='toto',
same_units=same_units)
assert_deep_almost_equal(self.am._get_axes_dicts(),
self.axes_list)
def test_read_FEI_SEM_scale_metadata_8bits():
fname = os.path.join(MY_PATH2, 'FEI-Helios-Ebeam-8bits.tif')
s = hs.load(fname)
assert s.axes_manager[0].units == 'm'
assert s.axes_manager[1].units == 'm'
assert_allclose(s.axes_manager[0].scale, 3.3724e-06, atol=1E-12)
assert_allclose(s.axes_manager[1].scale, 3.3724e-06, atol=1E-12)
assert s.data.dtype == 'uint8'
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_Helios_metadata)
def test_write_load_cycle(self):
with tempfile.TemporaryDirectory() as tmpdir:
fname2 = os.path.join(tmpdir, "example2-export.msa")
self.s.save(fname2)
s2 = load(fname2)
assert (
s2.metadata.General.original_filename == "example2-export.msa")
s2.metadata.General.original_filename = "example2.msa"
assert_deep_almost_equal(self.s.metadata.as_dictionary(),
s2.metadata.as_dictionary())
def test_write_load_cycle(self):
with tempfile.TemporaryDirectory() as tmpdir:
fname2 = os.path.join(tmpdir, "example2-export.msa")
self.s.save(fname2)
s2 = load(fname2)
assert (s2.metadata.General.original_filename ==
"example2-export.msa")
s2.metadata.General.original_filename = "example2.msa"
assert_deep_almost_equal(self.s.metadata.as_dictionary(),
s2.metadata.as_dictionary())
def test_read_FEI_SEM_scale_metadata_16bits():
fname = os.path.join(MY_PATH2, 'FEI-Helios-Ebeam-16bits.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'um'
assert s.axes_manager[1].units == 'um'
assert_allclose(s.axes_manager[0].scale, 3.3724, rtol=1E-5)
assert_allclose(s.axes_manager[1].scale, 3.3724, rtol=1E-5)
assert s.data.dtype == 'uint16'
FEI_Helios_metadata['General'][
'original_filename'] = 'FEI-Helios-Ebeam-16bits.tif'
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_Helios_metadata)
def test_read_FEI_SEM_scale_metadata_16bits():
fname = os.path.join(MY_PATH2, 'FEI-Helios-Ebeam-16bits.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 3.3724, rtol=1E-5)
np.testing.assert_allclose(s.axes_manager[1].scale, 3.3724, rtol=1E-5)
assert s.data.dtype == 'uint16'
FEI_Helios_metadata['General'][
'original_filename'] = 'FEI-Helios-Ebeam-16bits.tif'
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_Helios_metadata)
def test_write_read_intensity_axes_DM():
s = hs.load(os.path.join(MY_PATH2, 'test_dm_image_um_unit.dm3'))
s.metadata.Signal.set_item('quantity', 'Electrons (Counts)')
d = {'gain_factor': 5.0, 'gain_offset': 2.0}
s.metadata.Signal.set_item('Noise_properties.Variance_linear_model', d)
with tempfile.TemporaryDirectory() as tmpdir:
fname = os.path.join(tmpdir, 'tiff_files', 'test_export_um_unit2.tif')
s.save(fname, overwrite=True, export_scale=True)
s2 = hs.load(fname)
assert_deep_almost_equal(s.metadata.Signal.as_dictionary(),
s2.metadata.Signal.as_dictionary())
def test_initialisation_BaseDataAxis(self):
axis = BaseDataAxis(name='named axis', units='s', navigate=True)
assert axis.name == 'named axis'
assert axis.units == 's'
assert axis.navigate
assert not self.axis.is_uniform
assert_deep_almost_equal(axis.get_axis_dictionary(),
{'_type': 'BaseDataAxis',
'name': 'named axis',
'units': 's',
'navigate': True,
'is_binned': False})
def test_read_FEI_navcam_no_IRBeam_bad_floats_metadata(self):
fname = self.path / 'FEI-Helios-navcam-with-no-IRBeam-bad-floats.tif'
s = hs.load(fname, convert_units=True)
# delete timestamp and version from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
del s.metadata.General.FileIO.Number_0.hyperspy_version
FEI_navcam_metadata['General']['original_filename'] = 'FEI-Helios-navcam-with-no-IRBeam-bad-floats.tif'
# working distance in the file was a bogus value, so it shouldn't be in the resulting metadata
del FEI_navcam_metadata['Acquisition_instrument']['SEM']['working_distance']
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_navcam_metadata)
def test_write_read_intensity_axes_DM():
s = hs.load(os.path.join(MY_PATH2, 'test_dm_image_um_unit.dm3'))
s.metadata.Signal.set_item('quantity', 'Electrons (Counts)')
d = {'gain_factor': 5.0,
'gain_offset': 2.0}
s.metadata.Signal.set_item('Noise_properties.Variance_linear_model', d)
with tempfile.TemporaryDirectory() as tmpdir:
fname = os.path.join(tmpdir, 'tiff_files', 'test_export_um_unit2.tif')
s.save(fname, overwrite=True, export_scale=True)
s2 = hs.load(fname, import_local_tifffile=True)
assert_deep_almost_equal(s.metadata.Signal.as_dictionary(),
s2.metadata.Signal.as_dictionary())
def test_hyperspy_wrap():
lxml = pytest.importorskip("lxml")
filename = os.path.join(my_path, 'bcf_data', test_files[0])
print('testing bcf wrap to hyperspy signal...')
hype = load(filename, select_type='spectrum')
assert_allclose(
hype.axes_manager[0].scale,
8.7367850619778,
atol=1E-12)
assert_allclose(
hype.axes_manager[1].scale,
8.7367850619778,
atol=1E-12)
assert hype.axes_manager[1].units == 'µm'
assert_allclose(hype.axes_manager[2].scale, 0.010001)
assert_allclose(hype.axes_manager[2].offset, -0.472397235)
assert hype.axes_manager[2].units == 'keV'
md_ref = {'_HyperSpy': {'Folding': {'original_shape': None,
'unfolded': False,
'original_axes_manager': None,
'signal_unfolded': False}},
'Sample': {'xray_lines': ['Al_Ka', 'Ca_Ka', 'Cl_Ka', 'Fe_Ka', 'K_Ka', 'Mg_Ka', 'Na_Ka', 'O_Ka', 'P_Ka', 'Si_Ka', 'Ti_Ka'],
'elements': ['Al', 'Ca', 'Cl', 'Fe', 'K', 'Mg', 'Na', 'O', 'P', 'Si', 'Ti'],
'name': 'Map data 232'},
'Acquisition_instrument': {'SEM': {'beam_energy': 20.0,
'Detector': {'EDS': {'detector_type': 'XFlash 6|10',
'energy_resolution_MnKa': 130.0,
'elevation_angle': 35.0,
'azimuth_angle': 90.0,
'real_time': 328.8}},
'magnification': 131.1433,
'tilt_stage': 0.5}},
'General': {'title': 'EDX',
'time': '17:05:03',
'original_filename': 'P45_instructively_packed_16bit_compressed.bcf',
'date': '2016-04-01'},
'Signal': {'binned': True,
'quantity': 'X-rays (Counts)',
'signal_type': 'EDS_SEM'}}
md_ref['General']['original_filename'] = hype.metadata.General.original_filename
filename_omd = os.path.join(my_path,
'bcf_data',
'test_original_metadata.json')
with open(filename_omd) as fn:
# original_metadata:
omd_ref = json.load(fn)
assert_deep_almost_equal(hype.metadata.as_dictionary(), md_ref)
assert_deep_almost_equal(hype.original_metadata.as_dictionary(), omd_ref)
assert hype.metadata.General.date == "2016-04-01"
assert hype.metadata.General.time == "17:05:03"
assert hype.metadata.Signal.quantity == "X-rays (Counts)"
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_write_load_cycle(self):
with tempfile.TemporaryDirectory() as tmpdir:
fname2 = os.path.join(tmpdir, "example2-export.msa")
self.s.save(fname2)
s2 = load(fname2)
assert (
s2.metadata.General.original_filename == "example2-export.msa")
s2.metadata.General.original_filename = "example2.msa"
# delete timestamp from metadata since it's runtime dependent
del s2.metadata.General.FileIO.Number_0.timestamp
del self.s.metadata.General.FileIO.Number_1
assert_deep_almost_equal(self.s.metadata.as_dictionary(),
s2.metadata.as_dictionary())
def test_read_FEI_navcam_no_IRBeam_metadata(self):
fname = self.path / 'FEI-Helios-navcam-with-no-IRBeam.tif'
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == t.Undefined
assert s.axes_manager[1].units == t.Undefined
np.testing.assert_allclose(s.axes_manager[0].scale, 1, rtol=0)
np.testing.assert_allclose(s.axes_manager[1].scale, 1, rtol=0)
assert s.data.dtype == 'uint8'
# delete timestamp and version from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
del s.metadata.General.FileIO.Number_0.hyperspy_version
FEI_navcam_metadata['General']['original_filename'] = 'FEI-Helios-navcam-with-no-IRBeam.tif'
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_navcam_metadata)
def test_read_FEI_SEM_scale_metadata_16bits(self):
fname = self.path / 'FEI-Helios-Ebeam-16bits.tif'
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 3.3724, rtol=1E-5)
np.testing.assert_allclose(s.axes_manager[1].scale, 3.3724, rtol=1E-5)
assert s.data.dtype == 'uint16'
# delete timestamp from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
FEI_Helios_metadata['General'][
'original_filename'] = 'FEI-Helios-Ebeam-16bits.tif'
assert_deep_almost_equal(s.metadata.as_dictionary(), FEI_Helios_metadata)
def test_read_Zeiss_SEM_scale_metadata_1k_image():
md = {
'Acquisition_instrument': {
'SEM': {
'Stage': {
'rotation': 10.2,
'tilt': -0.0,
'x': 75.6442,
'y': 60.4901,
'z': 25.193
},
'Detector': {
'detector_type': 'HE-SE2'
},
'beam_current': 1.0,
'beam_energy': 25.0,
'dwell_time': 5e-08,
'magnification': 105.0,
'microscope': 'Merlin-61-08',
'working_distance': 14.808
}
},
'General': {
'authors': 'LIM',
'date': '2015-12-23',
'original_filename': 'test_tiff_Zeiss_SEM_1k.tif',
'time': '09:40:32',
'title': ''
},
'Signal': {
'binned': False,
'signal_type': ''
},
'_HyperSpy': {
'Folding': {
'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False
}
}
}
fname = os.path.join(MY_PATH2, 'test_tiff_Zeiss_SEM_1k.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 2.614514, rtol=1E-6)
np.testing.assert_allclose(s.axes_manager[1].scale, 2.614514, rtol=1E-6)
assert s.data.dtype == 'uint8'
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_read_TVIPS_metadata():
md = {
'Acquisition_instrument': {
'TEM': {
'Detector': {
'Camera': {
'exposure': 0.4,
'name': 'F416'
}
},
'Stage': {
'tilt_alpha': -0.0070000002,
'tilt_beta': -0.055,
'x': 0.0,
'y': -9.2000000506686774e-05,
'z': 7.0000001350933871e-06
},
'beam_energy': 99.0,
'magnification': 32000.0
}
},
'General': {
'original_filename': 'TVIPS_bin4.tif',
'time': '9:01:17',
'title': ''
},
'Signal': {
'binned': False,
'signal_type': ''
},
'_HyperSpy': {
'Folding': {
'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False
}
}
}
fname = os.path.join(MY_PATH2, 'TVIPS_bin4.tif')
s = hs.load(fname, convert_units=True)
assert s.data.dtype == np.uint8
assert s.data.shape == (1024, 1024)
assert s.axes_manager[0].units == 'nm'
assert s.axes_manager[1].units == 'nm'
assert_allclose(s.axes_manager[0].scale, 1.42080, rtol=1E-5)
assert_allclose(s.axes_manager[1].scale, 1.42080, rtol=1E-5)
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_hyperspy_wrap():
if skip_test:
raise SkipTest
filename = os.path.join(my_path, 'bcf_data', test_files[0])
print('testing bcf wrap to hyperspy signal...')
hype = load(filename, select_type='spectrum')
nt.assert_almost_equal(
hype.axes_manager[0].scale,
8.7367850619778,
places=12)
nt.assert_almost_equal(
hype.axes_manager[1].scale,
8.7367850619778,
places=12)
nt.assert_equal(hype.axes_manager[1].units, 'µm')
nt.assert_almost_equal(hype.axes_manager[2].scale, 0.010001)
nt.assert_almost_equal(hype.axes_manager[2].offset, -0.472397235)
nt.assert_equal(hype.axes_manager[2].units, 'keV')
md_ref = {'_HyperSpy': {'Folding': {'original_shape': None,
'unfolded': False,
'original_axes_manager': None,
'signal_unfolded': False}},
'Sample': {'xray_lines': ['Al_Ka', 'Ca_Ka', 'Cl_Ka', 'Fe_Ka', 'K_Ka', 'Mg_Ka', 'Na_Ka', 'O_Ka', 'P_Ka', 'Si_Ka', 'Ti_Ka'],
'elements': ['Al', 'Ca', 'Cl', 'Fe', 'K', 'Mg', 'Na', 'O', 'P', 'Si', 'Ti'],
'name': 'Map data 232'},
'Acquisition_instrument': {'SEM': {'stage_y': 36517.61,
'beam_energy': 20.0,
'Detector': {'EDS': {'detector_type': 'XFlash 6|10',
'energy_resolution_MnKa': 130.0,
'elevation_angle': 35.0,
'azimuth_angle': 90.0}},
'stage_x': 62409.2,
'magnification': 131.1433,
'tilt_stage': 0.0}},
'General': {'title': 'EDX',
'time': '17:05:03',
'original_filename': 'P45_instructively_packed_16bit_compressed.bcf',
'date': '2016-04-01'},
'Signal': {'binned': True,
'quantity': 'X-rays (Counts)',
'signal_type': 'EDS_SEM'}}
md_ref['General']['original_filename'] = hype.metadata.General.original_filename
assert_deep_almost_equal(hype.metadata.as_dictionary(), md_ref)
nt.assert_equal(hype.metadata.General.date, "2016-04-01")
nt.assert_equal(hype.metadata.General.time, "17:05:03")
nt.assert_equal(hype.metadata.Signal.quantity, "X-rays (Counts)")
def test_read_Zeiss_SEM_scale_metadata_512_image():
md = {
'Acquisition_instrument': {
'SEM': {
'Stage': {
'rotation': 245.8,
'tilt': 0.0,
'x': 62.9961,
'y': 65.3168,
'z': 44.678
},
'beam_energy': 5.0,
'magnification': '50.00 K X',
'microscope': 'ULTRA 55-36-06',
'working_distance': 3.9
}
},
'General': {
'authors': 'LIBERATO',
'date': '2018-09-25',
'original_filename': 'test_tiff_Zeiss_SEM_512pix.tif',
'time': '08:20:42',
'title': ''
},
'Signal': {
'binned': False,
'signal_type': ''
},
'_HyperSpy': {
'Folding': {
'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False
}
}
}
fname = os.path.join(MY_PATH2, 'test_tiff_Zeiss_SEM_512pix.tif')
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 0.011649976, rtol=1E-6)
np.testing.assert_allclose(s.axes_manager[1].scale, 0.011649976, rtol=1E-6)
assert s.data.dtype == 'uint8'
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
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 == 'um'
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 == 'um'
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_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_read_Zeiss_SEM_scale_metadata_1k_image(self):
md = {'Acquisition_instrument': {'SEM': {'Stage': {'rotation': 10.2,
'tilt': -0.0,
'x': 75.6442,
'y': 60.4901,
'z': 25.193},
'Detector':{'detector_type':
'HE-SE2'},
'beam_current': 1.0,
'beam_energy': 25.0,
'dwell_time': 5e-08,
'magnification': 105.0,
'microscope': 'Merlin-61-08',
'working_distance': 14.808}},
'General': {'authors': 'LIM',
'date': '2015-12-23',
'original_filename': 'test_tiff_Zeiss_SEM_1k.tif',
'time': '09:40:32',
'title': '',
'FileIO': {'0': {
'operation': 'load',
'hyperspy_version': hs_version,
'io_plugin': 'hyperspy.io_plugins.tiff'
}}
},
'Signal': {'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
fname = self.path / 'test_tiff_Zeiss_SEM_1k.tif'
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 2.614514, rtol=1E-6)
np.testing.assert_allclose(s.axes_manager[1].scale, 2.614514, rtol=1E-6)
assert s.data.dtype == 'uint8'
# delete timestamp from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_save_load_cycle(save_path, convert_units):
sig_reload = None
signal = hs.load(FILE2, convert_units=convert_units)
serial = signal.original_metadata["blockfile_header"]["Acquisition_time"]
date, time, timezone = serial_date_to_ISO_format(serial)
assert signal.metadata.General.original_filename == "test2.blo"
assert signal.metadata.General.date == date
assert signal.metadata.General.time == time
assert signal.metadata.General.time_zone == timezone
assert (
signal.metadata.General.notes ==
"Precession angle : \r\nPrecession Frequency : \r\nCamera gamma : on")
signal.save(save_path, overwrite=True)
sig_reload = hs.load(save_path, convert_units=convert_units)
np.testing.assert_equal(signal.data, sig_reload.data)
assert (signal.axes_manager.as_dictionary() ==
sig_reload.axes_manager.as_dictionary())
assert (signal.original_metadata.as_dictionary() ==
sig_reload.original_metadata.as_dictionary())
# change original_filename to make the metadata of both signals equals
sig_reload.metadata.General.original_filename = (
signal.metadata.General.original_filename)
# assert file reading tests here, then delete so we can compare
# entire metadata structure at once:
plugin = 'hyperspy.io_plugins.blockfile'
assert signal.metadata.General.FileIO.Number_0.operation == 'load'
assert signal.metadata.General.FileIO.Number_0.io_plugin == plugin
assert signal.metadata.General.FileIO.Number_1.operation == 'save'
assert signal.metadata.General.FileIO.Number_1.io_plugin == plugin
assert sig_reload.metadata.General.FileIO.Number_0.operation == 'load'
assert sig_reload.metadata.General.FileIO.Number_0.io_plugin == plugin
del signal.metadata.General.FileIO
del sig_reload.metadata.General.FileIO
assert_deep_almost_equal(signal.metadata.as_dictionary(),
sig_reload.metadata.as_dictionary())
assert signal.metadata.General.date == sig_reload.metadata.General.date
assert signal.metadata.General.time == sig_reload.metadata.General.time
assert isinstance(signal, hs.signals.Signal2D)
# Delete reference to close memmap file!
del sig_reload
def test_read_TVIPS_metadata():
md = {'Acquisition_instrument': {'TEM': {'Detector': {'Camera': {'exposure': 0.4,
'name': 'F416'}},
'Stage': {'tilt_alpha': -0.0070000002,
'tilt_beta': -0.055,
'x': 0.0,
'y': -9.2000000506686774e-05,
'z': 7.0000001350933871e-06},
'beam_energy': 99.0,
'magnification': 32000.0}},
'General': {'original_filename': 'TVIPS_bin4.tif',
'time': '9:01:17',
'title': '',
'FileIO': {'0': {
'operation': 'load',
'hyperspy_version': hs_version,
'io_plugin': 'hyperspy.io_plugins.tiff'
}}
},
'Signal': {'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
zipf = os.path.join(MY_PATH2, "TVIPS_bin4.zip")
path = Path(TMP_DIR.name)
with zipfile.ZipFile(zipf, 'r') as zipped:
zipped.extractall(path)
s = hs.load(path / 'TVIPS_bin4.tif', convert_units=True)
assert s.data.dtype == np.uint8
assert s.data.shape == (1024, 1024)
assert s.axes_manager[0].units == 'nm'
assert s.axes_manager[1].units == 'nm'
np.testing.assert_allclose(s.axes_manager[0].scale, 1.42080, rtol=1E-5)
np.testing.assert_allclose(s.axes_manager[1].scale, 1.42080, rtol=1E-5)
# delete timestamp from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
def test_read_Zeiss_SEM_scale_metadata_512_image(self):
md = {'Acquisition_instrument': {'SEM': {'Stage': {'rotation': 245.8,
'tilt': 0.0,
'x': 62.9961,
'y': 65.3168,
'z': 44.678},
'beam_energy': 5.0,
'magnification': '50.00 K X',
'microscope': 'ULTRA 55-36-06',
'working_distance': 3.9}},
'General': {'authors': 'LIBERATO',
'date': '2018-09-25',
'original_filename': 'test_tiff_Zeiss_SEM_512pix.tif',
'time': '08:20:42',
'title': '',
'FileIO': {'0': {
'operation': 'load',
'hyperspy_version': hs_version,
'io_plugin': 'hyperspy.io_plugins.tiff'
}}
},
'Signal': {'signal_type': ''},
'_HyperSpy': {'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
fname = self.path / 'test_tiff_Zeiss_SEM_512pix.tif'
s = hs.load(fname, convert_units=True)
assert s.axes_manager[0].units == 'µm'
assert s.axes_manager[1].units == 'µm'
np.testing.assert_allclose(s.axes_manager[0].scale, 0.011649976, rtol=1E-6)
np.testing.assert_allclose(s.axes_manager[1].scale, 0.011649976, rtol=1E-6)
assert s.data.dtype == 'uint8'
# delete timestamp from metadata since it's runtime dependent
del s.metadata.General.FileIO.Number_0.timestamp
assert_deep_almost_equal(s.metadata.as_dictionary(), md)
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.1)
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_metadata(self):
assert_deep_almost_equal(self.s.metadata.as_dictionary(),
example2_metadata)
def test_hyperspy_wrap():
lxml = pytest.importorskip("lxml")
filename = os.path.join(my_path, 'bcf_data', test_files[0])
print('testing bcf wrap to hyperspy signal...')
hype = load(filename, select_type='spectrum')
assert_allclose(hype.axes_manager[0].scale, 8.7367850619778, atol=1E-12)
assert_allclose(hype.axes_manager[1].scale, 8.7367850619778, atol=1E-12)
assert hype.axes_manager[1].units == 'µm'
assert_allclose(hype.axes_manager[2].scale, 0.010001)
assert_allclose(hype.axes_manager[2].offset, -0.472397235)
assert hype.axes_manager[2].units == 'keV'
md_ref = {
'_HyperSpy': {
'Folding': {
'original_shape': None,
'unfolded': False,
'original_axes_manager': None,
'signal_unfolded': False
}
},
'Sample': {
'xray_lines': [
'Al_Ka', 'Ca_Ka', 'Cl_Ka', 'Fe_Ka', 'K_Ka', 'Mg_Ka', 'Na_Ka',
'O_Ka', 'P_Ka', 'Si_Ka', 'Ti_Ka'
],
'elements':
['Al', 'Ca', 'Cl', 'Fe', 'K', 'Mg', 'Na', 'O', 'P', 'Si', 'Ti'],
'name':
'Map data 232'
},
'Acquisition_instrument': {
'SEM': {
'beam_energy': 20.0,
'Detector': {
'EDS': {
'detector_type': 'XFlash 6|10',
'energy_resolution_MnKa': 130.0,
'elevation_angle': 35.0,
'azimuth_angle': 90.0,
'real_time': 328.8
}
},
'magnification': 131.1433,
'Stage': {
'tilt_alpha': 0.5,
'rotation': 329.49719,
'x': 62409.2,
'y': 36517.61,
'z': 40234.7
}
},
},
'General': {
'title': 'EDX',
'time': '17:05:03',
'original_filename':
'P45_instructively_packed_16bit_compressed.bcf',
'date': '2016-04-01'
},
'Signal': {
'binned': True,
'quantity': 'X-rays (Counts)',
'signal_type': 'EDS_SEM'
}
}
md_ref['General'][
'original_filename'] = hype.metadata.General.original_filename
filename_omd = os.path.join(my_path, 'bcf_data',
'test_original_metadata.json')
with open(filename_omd) as fn:
# original_metadata:
omd_ref = json.load(fn)
print(hype.metadata)
assert_deep_almost_equal(hype.metadata.as_dictionary(), md_ref)
assert_deep_almost_equal(hype.original_metadata.as_dictionary(), omd_ref)
assert hype.metadata.General.date == "2016-04-01"
assert hype.metadata.General.time == "17:05:03"
assert hype.metadata.Signal.quantity == "X-rays (Counts)"
def test_hyperspy_wrap():
filename = os.path.join(my_path, 'bruker_data', test_files[0])
print('testing bcf wrap to hyperspy signal...')
from hyperspy.exceptions import VisibleDeprecationWarning
with pytest.warns(VisibleDeprecationWarning):
hype = load(filename, select_type='spectrum')
hype = load(filename, select_type='spectrum_image')
np.testing.assert_allclose(
hype.axes_manager[0].scale,
1.66740910949362,
atol=1E-12)
np.testing.assert_allclose(
hype.axes_manager[1].scale,
1.66740910949362,
atol=1E-12)
assert hype.axes_manager[1].units == 'µm'
np.testing.assert_allclose(hype.axes_manager[2].scale, 0.009999)
np.testing.assert_allclose(hype.axes_manager[2].offset, -0.47225277)
assert hype.axes_manager[2].units == 'keV'
assert hype.axes_manager[2].is_binned == True
md_ref = {
'Acquisition_instrument': {
'SEM': {
'beam_energy': 20,
'magnification': 1819.22595,
'Detector': {
'EDS': {
'elevation_angle': 35.0,
'detector_type': 'XFlash 6|10',
'azimuth_angle': 90.0,
'real_time': 70.07298,
'energy_resolution_MnKa': 130.0}},
'Stage': {
'tilt_alpha': 0.0,
'rotation': 326.10089,
'x': 66940.81,
'y': 54233.16,
'z': 39194.77}}},
'General': {
'original_filename':
'30x30_instructively_packed_16bit_compressed.bcf',
'title': 'EDX',
'date': '2018-10-04',
'time': '13:02:07',
'FileIO': {
'0': {
'operation': 'load',
'hyperspy_version': hs_version,
'io_plugin': 'hyperspy.io_plugins.bruker',
}
}},
'Sample': {
'name': 'chevkinite',
'elements': ['Al', 'C', 'Ca', 'Ce', 'Fe', 'Gd', 'K', 'Mg', 'Na',
'Nd', 'O', 'P', 'Si', 'Sm', 'Th', 'Ti'],
'xray_lines': ['Al_Ka', 'C_Ka', 'Ca_Ka', 'Ce_La', 'Fe_Ka',
'Gd_La', 'K_Ka', 'Mg_Ka', 'Na_Ka', 'Nd_La',
'O_Ka', 'P_Ka', 'Si_Ka', 'Sm_La', 'Th_Ma',
'Ti_Ka']},
'Signal': {
'quantity': 'X-rays (Counts)',
'signal_type': 'EDS_SEM'},
'_HyperSpy': {
'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
filename_omd = os.path.join(my_path,
'bruker_data',
'30x30_original_metadata.json')
with open(filename_omd) as fn:
# original_metadata:
omd_ref = json.load(fn)
# delete FileIO timestamp since it's runtime dependent
del hype.metadata.General.FileIO.Number_0.timestamp
assert_deep_almost_equal(hype.metadata.as_dictionary(), md_ref)
assert_deep_almost_equal(hype.original_metadata.as_dictionary(), omd_ref)
assert hype.metadata.General.date == "2018-10-04"
assert hype.metadata.General.time == "13:02:07"
assert hype.metadata.Signal.quantity == "X-rays (Counts)"
def test_convert_to_units_unsupported_units(self, same_units):
with pytest.warns(UserWarning, match="not supported for conversion."):
self.am.convert_units('navigation',
units='toto',
same_units=same_units)
assert_deep_almost_equal(self.am._get_axes_dicts(), self.axes_list)
def test_update_date_time_in_metadata():
md = DictionaryTreeBrowser({'General': {}})
# in case of iso, the exact time is lost, only the time offset is kept
md11 = dtt.update_date_time_in_metadata(iso1, md.deepcopy())
assert_deep_almost_equal(md11.General.date, md1.General.date)
assert_deep_almost_equal(md11.General.time, md1.General.time)
assert_deep_almost_equal(md11.General.time_zone, 'UTC')
md12 = dtt.update_date_time_in_metadata(dt1, md.deepcopy())
assert_deep_almost_equal(md12.General.date, md1.General.date)
assert_deep_almost_equal(md12.General.time, md1.General.time)
import locale
if locale.getlocale()[0] in ['en_GB', 'en_US']:
assert md12.General.time_zone in ('UTC', 'Coordinated Universal Time')
md13 = dtt.update_date_time_in_metadata(iso2, md.deepcopy())
assert_deep_almost_equal(md13.General.date, md2.General.date)
assert_deep_almost_equal(md13.General.time, md2.General.time)
assert_deep_almost_equal(md13.General.time_zone, '-05:00')
assert_deep_almost_equal(dtt.update_date_time_in_metadata(dt2, md.deepcopy()).as_dictionary(),
md2.as_dictionary())
assert_deep_almost_equal(dtt.update_date_time_in_metadata(iso3, md.deepcopy()).as_dictionary(),
md3.as_dictionary())
assert_deep_almost_equal(dtt.update_date_time_in_metadata(dt3, md.deepcopy()).as_dictionary(),
md3.as_dictionary())
def test_hyperspy_wrap():
filename = os.path.join(my_path, 'bruker_data', test_files[0])
print('testing bcf wrap to hyperspy signal...')
from hyperspy.exceptions import VisibleDeprecationWarning
with pytest.warns(VisibleDeprecationWarning):
hype = load(filename, select_type='spectrum')
hype = load(filename, select_type='spectrum_image')
assert_allclose(
hype.axes_manager[0].scale,
1.66740910949362,
atol=1E-12)
assert_allclose(
hype.axes_manager[1].scale,
1.66740910949362,
atol=1E-12)
assert hype.axes_manager[1].units == 'µm'
assert_allclose(hype.axes_manager[2].scale, 0.009999)
assert_allclose(hype.axes_manager[2].offset, -0.47225277)
assert hype.axes_manager[2].units == 'keV'
md_ref = {
'Acquisition_instrument': {
'SEM': {
'beam_energy': 20,
'magnification': 1819.22595,
'Detector': {
'EDS': {
'elevation_angle': 35.0,
'detector_type': 'XFlash 6|10',
'azimuth_angle': 90.0,
'real_time': 70.07298,
'energy_resolution_MnKa': 130.0}},
'Stage': {
'tilt_alpha': 0.0,
'rotation': 326.10089,
'x': 66940.81,
'y': 54233.16,
'z': 39194.77}}},
'General': {
'original_filename':
'30x30_instructively_packed_16bit_compressed.bcf',
'title': 'EDX',
'date': '2018-10-04',
'time': '13:02:07'},
'Sample': {
'name': 'chevkinite',
'elements': ['Al', 'C', 'Ca', 'Ce', 'Fe', 'Gd', 'K', 'Mg', 'Na',
'Nd', 'O', 'P', 'Si', 'Sm', 'Th', 'Ti'],
'xray_lines': ['Al_Ka', 'C_Ka', 'Ca_Ka', 'Ce_La', 'Fe_Ka',
'Gd_La', 'K_Ka', 'Mg_Ka', 'Na_Ka', 'Nd_La',
'O_Ka', 'P_Ka', 'Si_Ka', 'Sm_La', 'Th_Ma',
'Ti_Ka']},
'Signal': {
'binned': True,
'quantity': 'X-rays (Counts)',
'signal_type': 'EDS_SEM'},
'_HyperSpy': {
'Folding': {'original_axes_manager': None,
'original_shape': None,
'signal_unfolded': False,
'unfolded': False}}}
filename_omd = os.path.join(my_path,
'bruker_data',
'30x30_original_metadata.json')
with open(filename_omd) as fn:
# original_metadata:
omd_ref = json.load(fn)
assert_deep_almost_equal(hype.metadata.as_dictionary(), md_ref)
assert_deep_almost_equal(hype.original_metadata.as_dictionary(), omd_ref)
assert hype.metadata.General.date == "2018-10-04"
assert hype.metadata.General.time == "13:02:07"
assert hype.metadata.Signal.quantity == "X-rays (Counts)"
def test_metadata(self):
md = copy.copy(example1_metadata)
del md["General"]["date"]
del md["General"]["time"]
md["General"]["original_filename"] = "example1_wrong_date.msa"
assert_deep_almost_equal(self.s.metadata.as_dictionary(), md)
def test_metadata(self):
assert_deep_almost_equal(self.s.metadata.as_dictionary(),
example2_metadata)
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_update_date_time_in_metadata():
md = DictionaryTreeBrowser({'General': {}})
# in case of iso, the exact time is lost, only the time offset is kept
md11 = dtt.update_date_time_in_metadata(iso1, md.deepcopy())
assert_deep_almost_equal(md11.General.date, md1.General.date)
assert_deep_almost_equal(md11.General.time, md1.General.time)
assert_deep_almost_equal(md11.General.time_zone, 'UTC')
md12 = dtt.update_date_time_in_metadata(dt1, md.deepcopy())
assert_deep_almost_equal(md12.General.date, md1.General.date)
assert_deep_almost_equal(md12.General.time, md1.General.time)
import locale
if locale.getlocale()[0] in ['en_GB', 'en_US']:
assert md12.General.time_zone in ('UTC', 'Coordinated Universal Time')
md13 = dtt.update_date_time_in_metadata(iso2, md.deepcopy())
assert_deep_almost_equal(md13.General.date, md2.General.date)
assert_deep_almost_equal(md13.General.time, md2.General.time)
assert_deep_almost_equal(md13.General.time_zone, '-05:00')
assert_deep_almost_equal(dtt.update_date_time_in_metadata(dt2, md.deepcopy()).as_dictionary(),
md2.as_dictionary())
assert_deep_almost_equal(dtt.update_date_time_in_metadata(iso3, md.deepcopy()).as_dictionary(),
md3.as_dictionary())
assert_deep_almost_equal(dtt.update_date_time_in_metadata(dt3, md.deepcopy()).as_dictionary(),
md3.as_dictionary())
