예제 #1
0
def test_read_unit_from_DM_stack(lazy):
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_DM_stack.tif')
    s = hs.load(fname, lazy=lazy)
    assert s.data.shape == (2, 68, 68)
    assert s.axes_manager[0].units == 's'
    assert s.axes_manager[1].units == 'µm'
    assert s.axes_manager[2].units == 'µm'
    assert_allclose(s.axes_manager[0].scale, 2.5, atol=1E-5)
    assert_allclose(s.axes_manager[1].scale, 0.16867, atol=1E-5)
    assert_allclose(s.axes_manager[2].scale, 1.68674, atol=1E-5)
    with tempfile.TemporaryDirectory() as tmpdir:
        fname2 = os.path.join(
            tmpdir, 'test_loading_image_saved_with_DM_stack2.tif')
        s.save(fname2, overwrite=True)
        s2 = hs.load(fname2)
        _compare_signal_shape_data(s, s2)
        assert s2.axes_manager[0].units == s.axes_manager[0].units
        assert s2.axes_manager[1].units == 'µm'
        assert s2.axes_manager[2].units == 'µm'
        assert_allclose(
            s2.axes_manager[0].scale, s.axes_manager[0].scale, atol=1E-5)
        assert_allclose(
            s2.axes_manager[1].scale, s.axes_manager[1].scale, atol=1E-5)
        assert_allclose(
            s2.axes_manager[2].scale, s.axes_manager[2].scale, atol=1E-5)
        assert_allclose(
            s2.axes_manager[0].offset, s.axes_manager[0].offset, atol=1E-5)
        assert_allclose(
            s2.axes_manager[1].offset, s.axes_manager[1].offset, atol=1E-5)
        assert_allclose(
            s2.axes_manager[2].offset, s.axes_manager[2].offset, atol=1E-5)
예제 #2
0
def test_write_read_unit_imagej_with_description(import_local_tifffile=True):
    fname = os.path.join(my_path, 'tiff_files',
                         'test_loading_image_saved_with_imageJ.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    s.axes_manager[0].units = 'µm'
    s.axes_manager[1].units = 'µm'
    nt.assert_almost_equal(s.axes_manager[0].scale, 0.16867, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 0.16867, places=5)
    fname2 = fname.replace('.tif', '_description.tif')
    s.save(fname2, export_scale=False, overwrite=True, description='test')
    s2 = hs.load(fname2, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s2.axes_manager[0].units, t.Undefined)
    nt.assert_equal(s2.axes_manager[1].units, t.Undefined)
    nt.assert_almost_equal(s2.axes_manager[0].scale, 1.0, places=5)
    nt.assert_almost_equal(s2.axes_manager[1].scale, 1.0, places=5)

    fname3 = fname.replace('.tif', '_description2.tif')
    s.save(fname3, export_scale=True, overwrite=True, description='test')
    s3 = hs.load(fname3, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s3.axes_manager[0].units, 'µm')
    nt.assert_equal(s3.axes_manager[1].units, 'µm')
    nt.assert_almost_equal(s3.axes_manager[0].scale, 0.16867, places=5)
    nt.assert_almost_equal(s3.axes_manager[1].scale, 0.16867, places=5)

    if remove_files:
        os.remove(fname2)
        os.remove(fname3)
예제 #3
0
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
예제 #4
0
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)
예제 #5
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_read_unit_from_DM_stack(import_local_tifffile=False):
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_DM_stack.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s.data.shape, (2, 68, 68))
    nt.assert_equal(s.axes_manager[0].units, 's')
    nt.assert_equal(s.axes_manager[1].units, 'µm')
    nt.assert_equal(s.axes_manager[2].units, 'µm')
    nt.assert_almost_equal(s.axes_manager[0].scale, 2.5, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 0.16867, places=5)
    nt.assert_almost_equal(s.axes_manager[2].scale, 1.68674, places=5)
    with tempfile.TemporaryDirectory() as tmpdir:
        fname2 = os.path.join(
            tmpdir, 'test_loading_image_saved_with_DM_stack2.tif')
        s.save(fname2, overwrite=True)
        s2 = hs.load(fname2)
        _compare_signal_shape_data(s, s2)
        nt.assert_equal(s2.axes_manager[0].units, s.axes_manager[0].units)
        nt.assert_equal(s2.axes_manager[1].units, 'micron')
        nt.assert_equal(s2.axes_manager[2].units, 'micron')
        nt.assert_almost_equal(
            s2.axes_manager[0].scale, s.axes_manager[0].scale, places=5)
        nt.assert_almost_equal(
            s2.axes_manager[1].scale, s.axes_manager[1].scale, places=5)
        nt.assert_almost_equal(
            s2.axes_manager[2].scale, s.axes_manager[2].scale, places=5)
        nt.assert_almost_equal(
            s2.axes_manager[0].offset, s.axes_manager[0].offset, places=5)
        nt.assert_almost_equal(
            s2.axes_manager[1].offset, s.axes_manager[1].offset, places=5)
        nt.assert_almost_equal(
            s2.axes_manager[2].offset, s.axes_manager[2].offset, places=5)
예제 #6
0
def test_save_load_cycle_grayscale(dtype, ext):
    s = hs.signals.Signal2D(np.arange(128*128).reshape(128, 128).astype(dtype))
    with tempfile.TemporaryDirectory() as tmpdir:
        print('Saving-loading cycle for the extension:', ext)
        filename = os.path.join(tmpdir, 'test_image.'+ext)
        s.save(filename)
        hs.load(filename)
    def test_convert_tia_single_item(self):
        self.tia_reader.contrast_streching = True
        self.tia_reader.overwrite = True
        data = np.arange(100).reshape((10,10)).astype("float")
        self.tia_reader._convert_tia_single_item(hs.signals.Signal2D(data))
        assert os.path.exists(self.tia_reader.fname_ext)
        if self.delete_files:
            os.remove(self.tia_reader.fname_ext)

        self.tia_reader.contrast_streching = False
        data = np.arange(100).reshape((10,10)).astype("float")
        self.tia_reader._convert_tia_single_item(hs.signals.Signal2D(data))
        assert os.path.exists(self.tia_reader.fname_ext)
        a = hs.load(self.tia_reader.fname_ext)
        a.data = data
        if self.delete_files:
            os.remove(self.tia_reader.fname_ext)

        self.tia_reader.contrast_streching = False
        self.tia_reader.read(self._get_absolute_path(self.tia_reader.fname))
        self.tia_reader.extension_list = ['tif']
        self.tia_reader._convert_tia_single_item(self.tia_reader.s)
        assert os.path.exists(self.tia_reader.fname_ext)
        fname = self._get_absolute_path(self.tia_reader.fname.replace('.emi', ''))
        s = hs.load(fname+'.tif')
        nt.assert_array_equal(s.data, np.load(fname+'.npy'))
        if self.delete_files:
            os.remove(self.tia_reader.fname_ext)
예제 #8
0
def test_fit_EELS_convolved(convolved):
    dname = os.path.join(my_path, 'data')
    cl = hs.load(os.path.join(dname, 'Cr_L_cl.hspy'))
    cl.metadata.Signal.binned = False
    cl.metadata.General.title = 'Convolved: {}'.format(convolved)
    ll = hs.load(os.path.join(dname, 'Cr_L_ll.hspy')) if convolved else None
    m = cl.create_model(auto_background=False, ll=ll, GOS='hydrogenic')
    m.fit(kind='smart')
    m.plot(plot_components=True)
    return m._plot.signal_plot.figure
예제 #9
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_write_scale_with_um_unit():
    """ Lazy test, still need to open the files in ImageJ or DM to check if the
        scale and unit are correct """
    s = hs.load(os.path.join(MY_PATH, 'tiff_files',
                             'test_dm_image_um_unit.dm3'))
    with tempfile.TemporaryDirectory() as tmpdir:
        fname = os.path.join(tmpdir, 'test_export_um_unit.tif')
        s.save(fname, overwrite=True, export_scale=True)
        s1 = hs.load(fname)
        _compare_signal_shape_data(s, s1)
예제 #10
0
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())
예제 #11
0
def test_different_x_y_scale_units(save_path):
    # perform load and save cycle with changing the scale on y
    signal = hs.load(FILE2)
    signal.axes_manager[0].scale = 50.0
    signal.save(save_path, overwrite=True)
    sig_reload = hs.load(save_path)
    assert_allclose(sig_reload.axes_manager[0].scale, 50.0,
                    atol=1E-2)
    assert_allclose(sig_reload.axes_manager[1].scale, 64.0,
                    atol=1E-2)
    assert_allclose(sig_reload.axes_manager[2].scale, 0.0160616,
                    atol=1E-5)
예제 #12
0
def test_write_read_unit_imagej(import_local_tifffile=True):
    fname = os.path.join(my_path, 'tiff_files',
                         'test_loading_image_saved_with_imageJ.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    s.axes_manager[0].units = 'µm'
    s.axes_manager[1].units = 'µm'
    fname2 = fname.replace('.tif', '2.tif')
    s.save(fname2, export_scale=True, overwrite=True)
    s2 = hs.load(fname2, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s2.axes_manager[0].units, 'µm')
    nt.assert_equal(s2.axes_manager[1].units, 'µm')
    if remove_files:
        os.remove(fname2)
예제 #13
0
def test_write_read_unit_imagej():
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_imageJ.tif')
    s = hs.load(fname, convert_units=True)
    s.axes_manager[0].units = 'µm'
    s.axes_manager[1].units = 'µm'
    with tempfile.TemporaryDirectory() as tmpdir:
        fname2 = os.path.join(
            tmpdir, 'test_loading_image_saved_with_imageJ2.tif')
        s.save(fname2, export_scale=True, overwrite=True)
        s2 = hs.load(fname2)
        assert s2.axes_manager[0].units == 'µm'
        assert s2.axes_manager[1].units == 'µm'
        assert s.data.shape == s.data.shape
예제 #14
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_write_read_unit_imagej(import_local_tifffile=True):
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_imageJ.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    s.axes_manager[0].units = 'µm'
    s.axes_manager[1].units = 'µm'
    with tempfile.TemporaryDirectory() as tmpdir:
        fname2 = os.path.join(
            tmpdir, 'test_loading_image_saved_with_imageJ2.tif')
        s.save(fname2, export_scale=True, overwrite=True)
        s2 = hs.load(fname2, import_local_tifffile=import_local_tifffile)
        nt.assert_equal(s2.axes_manager[0].units, 'micron')
        nt.assert_equal(s2.axes_manager[1].units, 'micron')
        nt.assert_equal(s.data.shape, s.data.shape)
예제 #15
0
def test_save_load_cycle_color(color, ext):
    dim = 4 if "rgba" in color else 3
    dtype = 'uint8' if "8" in color else 'uint16'
    if dim == 4 and ext == 'jpeg':
        # JPEG does not support alpha channel.
        return
    print('color:', color, '; dim:', dim, '; dtype:', dtype)
    s = hs.signals.Signal1D(np.arange(128*128*dim).reshape(128, 128, dim).astype(dtype))
    s.change_dtype(color)
    with tempfile.TemporaryDirectory() as tmpdir:
        print('Saving-loading cycle for the extension:', ext)
        filename = os.path.join(tmpdir, 'test_image.'+ext)
        s.save(filename)
        hs.load(filename)
예제 #16
0
def test_read1():
    s = hs.load(file1)
    np.testing.assert_allclose(s.data, ref_T)
    nt.assert_almost_equal(s.axes_manager[0].scale, 0.33)
    nt.assert_almost_equal(s.axes_manager[0].offset, 50077.68)
    ref_date = datetime(2015, 4, 16, 13, 53)
    nt.assert_equal(s.metadata.General.time, ref_date)
예제 #17
0
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)
예제 #18
0
def test_read_unit_um():
    # Load DM file and save it as tif
    s = hs.load(os.path.join(MY_PATH2, 'test_dm_image_um_unit.dm3'))
    nt.assert_equal(s.axes_manager[0].units, 'µm')
    nt.assert_equal(s.axes_manager[1].units, 'µm')
    nt.assert_almost_equal(s.axes_manager[0].scale, 0.16867, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 0.16867, places=5)
    with tempfile.TemporaryDirectory() as tmpdir:
        fname = os.path.join(tmpdir, 'tiff_files', 'test_export_um_unit.tif')
        s.save(fname, overwrite=True, export_scale=True)
        # load tif file
        s2 = hs.load(fname, import_local_tifffile=True)
        nt.assert_equal(s.axes_manager[0].units, 'µm')
        nt.assert_equal(s.axes_manager[1].units, 'µm')
        nt.assert_almost_equal(s2.axes_manager[0].scale, 0.16867, places=5)
        nt.assert_almost_equal(s2.axes_manager[1].scale, 0.16867, places=5)
예제 #19
0
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)
예제 #20
0
        def _load(self, filename=None, *args, **kargs):
            """HyperSpy Loader file loader routine.

            Args:
                filename (string or bool): File to load. If None then the existing filename is used,
                    if False, then a file dialog will be used.

            Returns:
                A copy of the itself after loading the data.
            """
            if filename is None or not filename:
                self.get_filename("r")
            else:
                self.filename = filename
            # Open the file and read the main file header and unpack into a dict
            try:
                signal = hs.load(self.filename)
                if not isinstance(signal, hs.signals.Signal2D):
                    raise Core.StonerLoadError("Not a 2D signal object - aborting!")
            except Exception as e:  # Pretty generic error catcher
                print("8" * 120, e, "5" * 120)
                raise Core.StonerLoadError("Not readable by HyperSpy error was {}".format(e))
            self.data = signal.data
            self._unpack_meta("", signal.metadata.as_dictionary())
            self._unpack_axes(signal.axes_manager)

            return self
예제 #21
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_write_scale_unit_image_stack():
    """ Lazy test, still need to open the files in ImageJ or DM to check if the
        scale and unit are correct """
    s = hs.signals.Signal2D(
        np.arange(
            5 * 10 * 15,
            dtype=np.uint8).reshape(
            (5,
             10,
             15)))
    s.axes_manager[0].scale = 0.25
    s.axes_manager[1].scale = 0.5
    s.axes_manager[2].scale = 1.5
    s.axes_manager[0].units = 'nm'
    s.axes_manager[1].units = 'um'
    s.axes_manager[2].units = 'mm'
    with tempfile.TemporaryDirectory() as tmpdir:
        fname = os.path.join(tmpdir, 'test_export_scale_unit_stack2.tif')
        s.save(fname, overwrite=True, export_scale=True)
        s1 = hs.load(fname)
        _compare_signal_shape_data(s, s1)
        nt.assert_equal(s1.axes_manager[0].units, 'nm')
        # only one unit can be read
        nt.assert_equal(s1.axes_manager[1].units, 'mm')
        nt.assert_equal(s1.axes_manager[2].units, 'mm')
        nt.assert_almost_equal(
            s1.axes_manager[0].scale, s.axes_manager[0].scale)
        nt.assert_almost_equal(
            s1.axes_manager[1].scale, s.axes_manager[1].scale)
        nt.assert_almost_equal(
            s1.axes_manager[2].scale, s.axes_manager[2].scale)
예제 #22
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_saving_loading_stack_no_scale():
    with tempfile.TemporaryDirectory() as tmpdir:
        fname = os.path.join(tmpdir, 'test_export_scale_unit_stack2.tif')
        s0 = hs.signals.Signal2D(np.zeros((10, 20, 30)))
        s0.save(fname, overwrite=True)
        s1 = hs.load(fname)
        _compare_signal_shape_data(s0, s1)
예제 #23
0
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)
예제 #24
0
def _test_read_unit_from_dm(import_local_tifffile=False):
    fname = os.path.join(my_path2, 'test_loading_image_saved_with_DM.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s.axes_manager[0].units, 'µm')
    nt.assert_equal(s.axes_manager[1].units, 'µm')
    nt.assert_almost_equal(s.axes_manager[0].scale, 0.16867, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 0.16867, places=5)
예제 #25
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_read_Zeiss_SEM_scale_metadata_512_image():
    fname = os.path.join(MY_PATH2, 'test_tiff_Zeiss_SEM_512.tif')
    s = hs.load(fname)
    nt.assert_equal(s.axes_manager[0].units, 'm')
    nt.assert_equal(s.axes_manager[1].units, 'm')
    nt.assert_almost_equal(s.axes_manager[0].scale, 7.4240e-08, places=12)
    nt.assert_almost_equal(s.axes_manager[1].scale, 7.4240e-08, places=12)
    nt.assert_equal(s.data.dtype, 'uint16')
예제 #26
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def _test_read_unit_from_imagej(import_local_tifffile=False):
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_imageJ.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s.axes_manager[0].units, 'micron')
    nt.assert_equal(s.axes_manager[1].units, 'micron')
    nt.assert_almost_equal(s.axes_manager[0].scale, 0.16867, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 0.16867, places=5)
예제 #27
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_read_unit_from_imagej_no_scale(import_local_tifffile=False):
    fname = os.path.join(MY_PATH, 'tiff_files',
                         'test_loading_image_saved_with_imageJ_no_scale.tif')
    s = hs.load(fname, import_local_tifffile=import_local_tifffile)
    nt.assert_equal(s.axes_manager[0].units, t.Undefined)
    nt.assert_equal(s.axes_manager[1].units, t.Undefined)
    nt.assert_almost_equal(s.axes_manager[0].scale, 1.0, places=5)
    nt.assert_almost_equal(s.axes_manager[1].scale, 1.0, places=5)
예제 #28
0
def test_read_convert_units():
    s = hs.load(file1, convert_units=None)
    np.testing.assert_allclose(s.data, ref_T)
    assert_allclose(s.axes_manager[0].scale, 0.33)
    assert_allclose(s.axes_manager[0].offset, 50077.68)
    assert s.axes_manager[0].units == 's'

    s = hs.load(file1, convert_units=False)
    assert_allclose(s.axes_manager[0].scale, 0.33)
    assert_allclose(s.axes_manager[0].offset, 50077.68)
    assert s.axes_manager[0].units == 's'

    s = hs.load(file1, convert_units=True)
    np.testing.assert_allclose(s.data, ref_T)
    assert_allclose(s.axes_manager[0].scale, 330.0)
    assert_allclose(s.axes_manager[0].offset, 50077680.0)
    assert s.axes_manager[0].units == 'ms'
예제 #29
0
파일: test_tiff.py 프로젝트: bm424/hyperspy
def test_read_FEI_SEM_scale_metadata_16bits():
    fname = os.path.join(MY_PATH2, 'FEI-Helios-Ebeam-16bits.tif')
    s = hs.load(fname)
    nt.assert_equal(s.axes_manager[0].units, 'm')
    nt.assert_equal(s.axes_manager[1].units, 'm')
    nt.assert_almost_equal(s.axes_manager[0].scale, 3.3724e-06, places=12)
    nt.assert_almost_equal(s.axes_manager[1].scale, 3.3724e-06, places=12)
    nt.assert_equal(s.data.dtype, 'uint16')
예제 #30
0
def test_save_load_cycle():
    sig_reload = None
    signal = hs.load(file2)
    try:
        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())
        nt.assert_is_instance(signal, hs.signals.Image)
    finally:
        # Delete reference to close memmap file!
        del sig_reload
        gc.collect()
        _remove_file(save_path)
예제 #31
0
def test_read_file2_metadata_keys():
    s = hs.load(file2,
                nxdata_only=True,
                dataset_keys=["rocks"],
                metadata_keys=["energy"])
    assert s.original_metadata.instrument.energy.value == 12.0
예제 #32
0
def test_load2(convert_units):
    s = hs.load(FILE2, convert_units=convert_units)
    assert s.data.shape == (2, 3, 5, 5)
    axes = axes2_converted if convert_units else axes2
    np.testing.assert_equal(s.axes_manager.as_dictionary(), axes)
    np.testing.assert_allclose(s.data, ref_data2)
예제 #33
0
def test_elid(pathname):
    s = hs.load(pathname)
    assert len(s) == 11

    assert s[0].data.shape == (16, 20)
    assert s[0].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 0.9757792598920122, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 0.9757792598920122, 'offset': 0.0, 'size': 20, 'units': 'µm', 'navigate': True, 'is_binned': False}
    }
    assert s[0].metadata['Acquisition_instrument']['SEM']['Stage']['x'] == -2.586744298575455
    assert s[0].metadata['Acquisition_instrument']['SEM']['Stage']['y'] == -0.7322168400784014
    assert s[0].metadata['Acquisition_instrument']['SEM']['beam_energy'] == 15.0
    assert s[0].metadata['Acquisition_instrument']['SEM']['microscope'] == 'MVE027364-0026-L'
    assert s[0].metadata['General']['date'] == '2019-08-07'
    assert s[0].metadata['General']['original_filename'] == os.path.split(pathname)[1]
    assert s[0].metadata['General']['time'] == '09:37:31'
    assert s[0].metadata['General']['title'] == 'Image 1'
    assert s[0].metadata['Signal']['signal_type'] == ''
    assert s[0].original_metadata['acquisition']['scan']['dwellTime']['value'] == '200'
    assert s[0].original_metadata['acquisition']['scan']['dwellTime']['unit'] == 'ns'
    assert s[0].original_metadata['acquisition']['scan']['fieldSize'] == 0.000019515585197840245
    assert s[0].original_metadata['acquisition']['scan']['highVoltage']['value'] == '-15'
    assert s[0].original_metadata['acquisition']['scan']['highVoltage']['unit'] == 'kV'
    assert s[0].original_metadata['pixelWidth']['value'] == '975.7792598920121'
    assert s[0].original_metadata['pixelWidth']['unit'] == 'nm'
    assert s[0].original_metadata['pixelHeight']['value'] == '975.7792598920121'
    assert s[0].original_metadata['pixelHeight']['unit'] == 'nm'
    assert s[0].original_metadata['samplePosition']['x'] == '-0.002586744298575455'
    assert s[0].original_metadata['samplePosition']['y'] == '-0.0007322168400784014'
    assert s[0].original_metadata['workingDistance']['value'] == '8.141749999999993'
    assert s[0].original_metadata['workingDistance']['unit'] == 'mm'
    assert s[0].original_metadata['instrument']['softwareVersion'] == '5.4.5.rc1.bb8fbe3.23039'
    assert s[0].original_metadata['instrument']['type'] == 'PhenomXL'
    assert s[0].original_metadata['instrument']['uniqueID'] == 'MVE027364-0026-L'

    assert s[1].metadata['General']['title'] == 'Image 1, Spot 1'
    assert s[1].data.shape == (2048,)
    assert s[1].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'Energy', 'scale': 0.00988676802994421, 'offset': -0.03634370080990722, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[1].data.tolist()[0:300] == [
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,15,16,19,30,52,61,98,125,
        145,129,114,69,45,22,14,11,18,17,30,26,29,19,16,20,26,29,35,51,59,103,
        139,157,209,220,179,113,99,65,49,31,36,39,42,35,48,37,55,50,45,46,49,
        40,49,54,35,49,57,63,71,64,75,76,92,98,83,81,94,118,120,160,215,325,
        363,368,429,403,376,254,204,173,136,124,102,89,97,84,83,75,83,71,85,
        101,81,72,87,84,90,93,84,68,93,91,82,86,112,85,84,100,110,118,132,118,
        125,138,128,135,143,143,136,148,227,301,538,1077,1946,3319,5108,7249,
        9032,10755,11441,10804,9219,7245,5335,3568,2213,1455,825,543,338,283,
        196,160,123,104,105,92,88,109,89,88,82,95,88,91,87,108,86,85,59,77,72,
        58,66,69,64,76,56,67,58,60,59,71,56,57,62,50,67,59,59,52,45,60,53,57,
        59,39,43,55,54,40,43,37,39,41,52,39,53,41,48,40,41,45,36,45,32,40,44,
        43,55,50,45,59,45,44,66,52,67,74,83,90,92,114,130,131,114,100,100,106,
        103,84,87,77,76,82,83,78,81,63,49,54,64,45,41,40,41,38,50,39,45,44,42,
        44,31,36,38,37,55,40,32,34,32,34,37,27,28,45,35,24,40,22,29,33,33,44,34]
    assert s[1].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 5.7203385
    assert s[1].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 10.162500000000001
    assert s[1].original_metadata['acquisition']['scan']['detectors']['EDS']['fast_peaking_time'] == 100e-9
    assert s[1].original_metadata['acquisition']['scan']['detectors']['EDS']['slow_peaking_time'] == 11.2e-6

    assert s[2].metadata['General']['title'] == 'Image 1, Region 2'
    assert s[2].data.shape == (2048,)
    assert s[2].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'Energy', 'scale': 0.00988676802994421, 'offset': -0.03634370080990722, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[2].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 6.5802053
    assert s[2].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 10.177700000000003

    assert s[3].metadata['General']['title'] == 'Image 1, Map 3'
    assert s[3].data.shape == (16, 16, 2048)
    assert s[3].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 1.2197240748650153, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 1.2197240748650153, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-2': {'_type': 'UniformDataAxis', 'name': 'X-ray energy', 'scale': 0.00988676802994421, 'offset': -0.03634370080990722, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[3].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 4.047052
    assert s[3].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 3.0005599999999997

    assert s[4].metadata['General']['title'] == 'Image 1, Line 4'
    assert s[4].data.shape == (64, 2048)
    assert s[4].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'i', 'scale': 1.0, 'offset': 0.0, 'size': 64, 'units': 'points', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'X-ray energy', 'scale': 0.00988676802994421, 'offset': -0.03634370080990722, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[4].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 5.504343599999998
    assert s[4].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 6.410299999999996

    assert s[5].metadata['General']['title'] == 'Image 1, Map 6'
    assert s[5].data.shape == (16, 16, 2048)
    assert s[5].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 1.2197240748650153, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 1.2197240748650153, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-2': {'_type': 'UniformDataAxis', 'name': 'X-ray energy', 'scale': 0.009886797201840245, 'offset': -0.04478043655810262, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[5].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 4.5919591
    assert s[5].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 3.00056

    assert s[6].metadata['General']['title'] == 'Image 1, Difference 3 - 6'
    assert s[6].data.shape == (2048,)
    assert s[6].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'Energy', 'scale': 0.00988676802994421, 'offset': -0.03634370080990722, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }

    assert s[7].metadata['General']['title'] == '385test - spectrum'
    assert s[7].data.shape == (24, 32)
    assert s[7].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 1.0, 'offset': 0.0, 'size': 24, 'units': 'points', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 1.0, 'offset': 0.0, 'size': 32, 'units': 'points', 'navigate': True, 'is_binned': False}
    }
    assert not 'acquisition' in s[7].original_metadata

    assert s[8].metadata['General']['title'] == '385test - spectrum, MSA 1'
    assert s[8].data.shape == (2048,)
    assert s[8].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'Energy', 'scale': 0.0098868, 'offset': -0.0363437, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[8].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 0.0
    assert s[8].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 5.066

    assert s[9].metadata['General']['title'] == 'Image 1'
    assert s[9].data.shape == (35, 40)
    assert s[9].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 0.8120422280865187, 'offset': 0.0, 'size': 35, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 0.8120422280865187, 'offset': 0.0, 'size': 40, 'units': 'µm', 'navigate': True, 'is_binned': False}
    }
    assert not 'EDS' in s[9].original_metadata['acquisition']['scan']['detectors']

    assert s[10].metadata['General']['title'] == 'Image 1, Map 1'
    assert s[10].data.shape == (16, 16, 2048)
    assert s[10].axes_manager.as_dictionary() == {
        'axis-0': {'_type': 'UniformDataAxis', 'name': 'y', 'scale': 2.0301055702162967, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-1': {'_type': 'UniformDataAxis', 'name': 'x', 'scale': 2.0301055702162967, 'offset': 0.0, 'size': 16, 'units': 'µm', 'navigate': True, 'is_binned': False},
        'axis-2': {'_type': 'UniformDataAxis', 'name': 'X-ray energy', 'scale': 0.009886797201840245, 'offset': -0.04478043655810262, 'size': 2048, 'units': 'keV', 'navigate': False, 'is_binned': True}
    }
    assert s[10].original_metadata['acquisition']['scan']['detectors']['EDS']['live_time'] == 4.821238
    assert s[10].original_metadata['acquisition']['scan']['detectors']['EDS']['real_time'] == 3.0005600000000006
예제 #34
0
def test_load_to_memory():
    s = hs.load(FILE2, lazy=False)
    assert isinstance(s.data, np.ndarray)
    assert not isinstance(s.data, np.memmap)
예제 #35
0
def test_read_file2_dataset_key_test():
    s = hs.load(file2, nxdata_only=True, dataset_keys=["rocks"])
    assert not isinstance(s, list)
예제 #36
0
def load_shift_and_build_area(c_to_o_stem=None,
                              c_to_o_eels=None,
                              o_to_c_stem=None,
                              o_to_c_eels=None,
                              shifts=None,
                              smoothing_parm=0.05,
                              return_unshifted=False,
                              return_uncropped=False,
                              debug=False):
    """
    Load a number of STEM signals and EELS line scans in order to
    build useful area scans out of them for decomposition and other analysis

    If no filenames are supplied, four file chooser dialogs will be opened.
    The files should be chosen in the order of SiC to SiO2 STEM, SiC to SiO2
    EELS, SiO2 to SiC STEM, and then SiO2 to SiC EELS.
    If there are not reversed line scans to analyze (i.e. the scans were
    acquired just in one direction), then select them in the appropriate
    window, and press 'Cancel' on the file selection for the ones that are
    not relevant.

    Note: all line scans must be same dimensions, or there will be an error.

    Parameters
    -----------
    c_to_o_stem: list of str
        If supplied as keyword arguments, this method will not bring up a
        dialog in order to get the file names, and just use those that are
        in the lists instead. This can be useful when combined with
        :py:meth:`get_scans_and_eels_fnames` so the function can be run
        multiple times without having to click through all the dialogs.
    c_to_o_eels: list of str
        See ``c_to_o_stem``
    o_to_c_stem: list of str
        See ``c_to_o_stem``
    o_to_c_eels: list of str
        See ``c_to_o_stem``
    shifts: list of float
        list of shift amounts to use. Allows one to supply custom shifts for 
        each line, which will be applied to both the EELS and STEM scans
        If None, the method will try to figure it out itself
    smoothing_parameter: float or 'ask'
        This is the parameter passed to :py:meth:`determine_shifts` in order to
        figure out how much to smooth the STEM signals before doing all the
        derivative work. Lower values are less smoothing, which will be
        more accurate, but be more susceptible to noise. Typical values are
        on the order of [0.03, 0.1], depending on the signal.
    return_unshifted: bool
        switch whether or not to return the unshifted data (good for
        comparison)
    return_uncropped: bool
        switch whether or not to return the uncropped data (good for
        comparison)
    debug: bool
        switch whether debugging information is printed out to see the shift
        values and everything

    Returns
    -------
    res: tuple
        the results tuple will have the following signals, in the following
        order:
            area_stem: :py:class:`~hyperspy.signal.Signal`
                Hyperspy signal containing shifted and cropped STEM signals
                as an image, rather than a list of profiles
            area_eels: :py:class:`~hyperspy.signal.Signal`
                Hyperspy signal containing the shifted and cropped EELS
                line scans as an area scan, rather than a list of single
                line scans
            file_list: list
                List of the files that were processed
            area_stem_nocrop: :py:class:`~hyperspy.signal.Signal`
                (Optional)
                Hyperspy signal containing shifted but not cropped STEM
                signals as an image, rather than a list of profiles
            area_eels_nocrop: :py:class:`~hyperspy.signal.Signal`
                (Optional)
                Hyperspy signal containing the shifted but not cropped EELS
                line scans as an area scan, rather than a list of single
                line scans
            area_stem_unshifted: :py:class:`~hyperspy.signal.Signal`
                (Optional)
                Hyperspy signal containing the unshifted STEM signals as an
                image, rather than a list of profiles
            area_eels_unshifted: :py:class:`~hyperspy.signal.Signal`
                (Optional)
                Hyperspy signal containing the unshifted EELS line scans
                as an area scan, rather than a list of single line scans
    """

    def _check_list_equal(iterator):
        # will return whether all items in list are the same or not
        return len(set(iterator)) <= 1

    # if no EELS scans are provided, get the information from dialog:
    if c_to_o_eels is None and o_to_c_eels is None:
        # get files from dialog if not supplied:
        (c_to_o_stem,
         c_to_o_eels,
         o_to_c_stem,
         o_to_c_eels) = get_scans_and_eels_fnames()

    # Save filenames in a list for reporting
    file_list = c_to_o_stem + c_to_o_eels + o_to_c_stem + o_to_c_eels

    # load in the files from the list of files:
    c_to_o_scans = [hs.load(x) for x in c_to_o_stem]
    c_to_o_lines = [hs.load(x) for x in c_to_o_eels]
    o_to_c_scans = [hs.load(x) for x in o_to_c_stem]
    o_to_c_lines = [hs.load(x) for x in o_to_c_eels]

    # flip the data in the OtoC scans and lines:
    for i in o_to_c_scans:
        i.data = i.data[::-1]
    for i in o_to_c_lines:
        i.data = i.data[::-1]

    # combine lists to make bigger lists:
    scans = c_to_o_scans + o_to_c_scans
    lines = c_to_o_lines + o_to_c_lines

    scan_sizes = [i.axes_manager.shape for i in scans]
    scan_scales = [i.axes_manager[0].scale for i in scans]
    line_sizes = [i.axes_manager.shape for i in lines]
    line_scales = [i.axes_manager[0].scale for i in lines]

    # Handle some errors related to scan sizes and magnifications
    if not _check_list_equal(scan_sizes):
        print("STEM scans were not all same size.")
        print("")
        print("SiC to SiO2 files were:")
        for i in c_to_o_stem:
            print(i)
        print("")
        print("SiO2 to SiC files were:")
        for i in o_to_c_stem:
            print(i)

        print("")
        print("Sizes were:")
        pprint(scan_sizes)
        raise ValueError("All line scans must be same size for stacking.")

    if not _check_list_equal(scan_scales):
        print("STEM scans were not all same scale (different mag?).")
        print("")
        print("SiC to SiO2 files were:")
        for i in c_to_o_stem:
            print(i)
        print("")
        print("SiO2 to SiC files were:")
        for i in o_to_c_stem:
            print(i)

        print("")
        print("Scales were:")
        pprint(scan_scales)
        raise ValueError("All line scans must be same scale for stacking.")

    if not _check_list_equal(line_sizes):
        print("EELS line scans were not all same size.")
        print("")
        print("SiC to SiO2 files were:")
        for i in c_to_o_eels:
            print(i)
        print("")
        print("SiO2 to SiC files were:")
        for i in o_to_c_eels:
            print(i)

        print("")
        print("Sizes were:")
        pprint(line_sizes)
        raise ValueError("All line scans must be same size for stacking.")

    if not _check_list_equal(line_scales):
        print("EELS line scans were not all same scale (different mag?).")
        print("")
        print("SiC to SiO2 files were:")
        for i in c_to_o_stem:
            print(i)
        print("")
        print("SiO2 to SiC files were:")
        for i in o_to_c_stem:
            print(i)

        print("")
        print("Scales were:")
        pprint(line_scales)
        raise ValueError("All line scans must be same scale for stacking.")

    # smooth scans:
    if shifts is None:
        smoothed_scans = smooth_scans(scans,
                                      progress_label="Smoothing STEM signals:",
                                      smoothing_parm=smoothing_parm)

    # do actual shifting and cropping:
    if shifts is None:
        shifts = determine_shifts(smoothed_scans,
                                  do_smoothing=False,
                                  debug=debug)

    if debug:
        print("Shifts are:")
        pprint(list(shifts))

    # normalize the intensity of the line scans:
    normalize_lines(lines, progress_label='Normalizing EELS line scans:')

    # normalize the intensity of the STEM profiles:
    normalize_lines(scans, progress_label='Normalizing STEM signals:')

    # shift EELS line scans
    shifted_lines = shift_lines(lines,
                                shifts,
                                progress_label='Shifting EELS line scans:')

    # shift HAADF STEM signals
    shifted_scans = shift_lines(scans,
                                shifts,
                                progress_label='Shifting STEM signals:')

    # create area spectrum images from the lines
    area_eels_nocrop = hs.stack(shifted_lines)
    area_eels_nocrop.axes_manager[1].name = 'line scan'
    area_eels_nocrop.axes_manager[1].units = '#'
    area_stem_nocrop = hs.stack(shifted_scans)
    area_stem_nocrop.axes_manager[0].name = 'STEM profile'
    area_stem_nocrop.axes_manager[0].units = '#'

    # Set appropriate titles for the signals
    area_eels_nocrop.metadata.General.title = 'Stacked EELS line scans - ' \
                                              'shifted'
    area_stem_nocrop.metadata.General.title = 'Stacked STEM signals - shifted'

    # crop the area spectrum images so there is no blank data
    area_eels = crop_area_scan(area_eels_nocrop, shifts)
    area_eels.axes_manager[1].name = 'line scan'
    area_eels.axes_manager[1].units = '#'
    area_stem = crop_area_scan(area_stem_nocrop, shifts)
    area_stem.axes_manager[0].name = 'STEM profile'
    area_stem.axes_manager[0].units = '#'

    # Set appropriate titles for the signals
    area_eels.metadata.General.title = 'Stacked EELS line scans - shifted ' \
                                       'and cropped'
    area_stem.metadata.General.title = 'Stacked STEM signals - shifted and ' \
                                       'cropped'

    # initialize the results list with the cropped and shifted data and the
    # list of file names that were analyzed
    res = [area_stem, area_eels, file_list]

    # if we want to return the uncropped data, add it to the list
    if return_uncropped:
        res.append(area_stem_nocrop)
        res.append(area_eels_nocrop)

    # if we want to return the unshifted data, add it to the list
    if return_unshifted:
        area_stem_unshifted = hs.stack(scans)
        area_eels_unshifted = hs.stack(lines)

        # Set appropriate titles for the signals
        area_eels_unshifted.metadata.General.title = 'Stacked EELS line scans'
        area_eels_unshifted.axes_manager[1].name = 'line scan'
        area_eels_unshifted.axes_manager[1].units = '#'
        area_stem_unshifted.metadata.General.title = 'Stacked STEM signals'
        area_stem_unshifted.axes_manager[0].name = 'STEM profile'
        area_stem_unshifted.axes_manager[0].units = '#'

        res.append(area_stem_unshifted)
        res.append(area_eels_unshifted)

    return res
예제 #37
0
파일: io.py 프로젝트: usnistgov/tomotools
def loadhspy(filename, tilts=None):
    """
    Read an MRC file to a TomoStack object using the Hyperspy reader.

    Parameters
    ----------
    filename : string
        Name of file that contains data to be read.  Accepted formats (.MRC,
        .RAW/.RPL pair, .DM3, .DM4)

    tilts : list or NumPy array
        List of floats indicating the specimen tilt at each projection

    Returns
    ----------
    stack : TomoStack object

    """
    stack = hspy.load(filename)
    if not stack.metadata.has_item("Tomography"):
        stack.metadata.add_node("Tomography")
    ext = os.path.splitext(filename)[1]
    if ext.lower() in ['.mrc', '.ali', '.rec']:
        tiltfile = os.path.splitext(filename)[0] + '.rawtlt'
        txtfile = os.path.splitext(filename)[0] + '.txt'
        if stack.original_metadata.fei_header.has_item('a_tilt'):
            tilts = stack.original_metadata.\
                      fei_header['a_tilt'][0:stack.data.shape[0]]
            stack.axes_manager[0].name = 'Tilt'
            stack.axes_manager[0].units = 'degrees'
            stack.axes_manager[0].scale = tilts[1] - tilts[0]
            stack.axes_manager[0].offset = tilts[0]
            stack.metadata.Tomography.tilts = tilts
            logger.info('Tilts found in MRC file header')
        elif os.path.isfile(tiltfile):
            tilts = np.loadtxt(tiltfile)
            logger.info('.rawtlt file detected.')
            stack.axes_manager[0].name = 'Tilt'
            stack.axes_manager[0].units = 'degrees'
            stack.axes_manager[0].scale = tilts[1] - tilts[0]
            stack.axes_manager[0].offset = tilts[0]
            stack.metadata.Tomography.tilts = tilts
            if len(tilts) == stack.data.shape[0]:
                logger.info('Tilts loaded from .rawtlt file')
            else:
                logger.info('Number of tilts in .rawtlt file inconsistent'
                            ' with data shape')
        else:
            logger.info('Unable to find tilt angles. Calibrate axis 0.')
            stack.axes_manager[0].name = 'Tilt'
            stack.axes_manager[0].units = 'degrees'

        if stack.original_metadata.fei_header.has_item('pixel_size'):
            pixel_size = stack.original_metadata.fei_header.pixel_size[0]
            logger.info('Pixel size found in MRC file header')
        elif os.path.isfile(txtfile):
            pixel_line = None
            with open(txtfile, 'r') as h:
                text = h.readlines()
            for i in text:
                if 'Image pixel size' in i:
                    pixel_line = i
            if pixel_line:
                pixel_size = np.float32(pixel_line.split()[-1:])[0]
                pixel_units = pixel_line.split()[-2:-1][0][1:-2]
                stack.axes_manager[1].name = 'x'
                stack.axes_manager[1].units = pixel_units
                stack.axes_manager[1].scale = pixel_size
                stack.axes_manager[1].offset = 0

                stack.axes_manager[2].name = 'y'
                stack.axes_manager[2].units = pixel_units
                stack.axes_manager[2].scale = pixel_size
                stack.axes_manager[2].offset = 0
                logger.info('Pixel size loaded from text file')
            else:
                logger.info('Unable to find pixel size in text file')
        else:
            logger.info('Unable to find pixel size')
            stack.axes_manager[1].name = 'x'
            stack.axes_manager[1].units = 'unknown'

            stack.axes_manager[2].name = 'y'
            stack.axes_manager[2].units = 'unknown'

    elif ext.lower() in ['.hdf5', '.hd5', '.hspy']:
        pass
    else:
        raise ValueError('Cannot read file type: %s' % ext)
    if stack.data.min() < 0:
        stack.data = np.float32(stack.data)
        stack.data += np.abs(stack.data.min())
    axes_list = [
        x for _, x in sorted(stack.axes_manager.as_dictionary().items())
    ]
    metadata_dict = stack.metadata.as_dictionary()
    original_metadata_dict = stack.original_metadata.as_dictionary()
    stack = TomoStack(stack,
                      axes=axes_list,
                      metadata=metadata_dict,
                      original_metadata=original_metadata_dict)
    return stack
예제 #38
0
 def setUp(self):
     self.signal = load(
         my_path +
         "/test_find_peaks1D_ohaver/test_find_peaks1D_ohaver.hdf5")
예제 #39
0
def test_read3():
    with pytest.raises(AssertionError):
        hs.load(file3)
예제 #40
0
 def setup_method(self, method):
     filepath = (Path(__file__).resolve().parent.joinpath(
         "data/test_find_peaks1D_ohaver.hdf5"))
     self.signal = load(filepath)
예제 #41
0
def test_load_inplace():
    with pytest.raises(ValueError):
        hs.load(FILE2, lazy=True, mmap_mode='r+')
예제 #42
0
import sys
import time
import hyperspy.api as hs

emd_filename_list = sys.argv[1:]
emd_filename_list.sort()

for emd_filename in emd_filename_list:
    t0 = time.time()
    s = hs.load(emd_filename).transpose(signal_axes=(2, 3))
    t1 = time.time()
    result = s.sum()
    t2 = time.time()
    delta = t2 - t0
    print(f"\n{emd_filename}")
    print("init", t1 - t0)
    print(delta)
    print(f"{s.data.nbytes / delta / 1024 / 1024} MB/s (overall)")
    print(f"{s.data.nbytes / (t2 - t1) / 1024 / 1024} MB/s (without init)")
예제 #43
0
def test_read_file2_signal1():
    s = hs.load(file2, nxdata_only=True, dataset_keys=["rocks"])
    assert s.metadata.General.title == "rocks"
예제 #44
0
""" Loads hyperspy as a regular python library, loads spectrums from files, does curve fitting, and plotting the model and original spectrum to a png file"""

import hyperspy.api as hs
import matplotlib.pyplot as plt

coreLossSpectrumFileName = "coreloss_spectrum.msa"
lowlossSpectrumFileName = "lowloss_spectrum.msa"

s = hs.load(coreLossSpectrumFileName).to_EELS()
s.add_elements(("Mn", "O"))
s.set_microscope_parameters(beam_energy=300,
                            convergence_angle=24.6,
                            collection_angle=13.6)

ll = hs.load(lowlossSpectrumFileName).to_EELS()

m = s.create_model(ll=ll)
m.enable_fine_structure()
m.multifit(kind="smart")
m.plot()

plt.savefig("model_original_spectrum_plot.png")
예제 #45
0
 def setup_method(self, method):
     self.signal = load(
         my_path +
         "/test_find_peaks1D_ohaver/test_find_peaks1D_ohaver.hdf5")
예제 #46
0
 def setup_method(self, method):
     filename = os.path.join(dirpath, 'protochips_gas_cell.csv')
     self.s_list = hs.load(filename)
fin_1 = h5py.File("data/89109_16_Fe_mantis_norm.hdf5")
data_1 = fin_1["/exchange/data"]
signal_1 = hs.signals.Signal2D(data_1)
signal_1 = signal_1.transpose(signal_axes=(0,2))

fin_2 = h5py.File("data/mantis_55510_55660.hdf5")
data_2 = fin_2["/exchange/data"]
signal_2 = hs.signals.Signal2D(data_2)
signal_2 = signal_2.transpose(signal_axes=(0,2))

fin_3 = h5py.File("data/mantis_raw_55499_55509.hdf5")
data_3 = fin_3["/exchange/data"]
signal_3 = hs.signals.Signal2D(data_3)
signal_3 = signal_3.transpose(signal_axes=(0,2))

signal_4 = hs.load("data/0005-RotSTEM90 ADF1.dm3")
signal_5 = hs.load("data/20_Aligned 20-Stack-5MxHAADF STACK(20).dm3")

signal_1_reduced = hs.signals.Signal2D(signal_1.data[:115][::5])
signal_2_reduced = hs.signals.Signal2D(signal_2.data[::5])

# Generate a very simple synthetic signal for demonstration purposes

height = 38
width = 46

vfield_1 = np.array([np.ones((height, width)) * -2, np.ones((height, width)) * +1])
vfield_2 = np.array([np.ones((height, width)) * -2.7, np.ones((height, width)) * +1.2])

arr_A = utils.make_capital_A((height, width))
signal_A = hs.signals.Signal2D(np.array([arr_A, ip.apply_displacement_field_sitk(vfield_1, arr_A), ip.apply_displacement_field_sitk(vfield_2, arr_A)]))
예제 #48
0
def test_load_lazy():
    from dask.array import Array
    s = hs.load(FILE2, lazy=True)
    assert isinstance(s.data, Array)
예제 #49
0
def test_load_single_dataset(dataset_path):
    filename = os.path.join(FILES_PATH, 'Si100_2D_3D_DPC_potential_2slices.emd')
    s = hs.load(filename, dataset_path=dataset_path)

    assert isinstance(s, hs.signals.Signal2D)
예제 #50
0
def process_data(proc_path, proc_bin_path, proc_dict):
    if 'Overwrite' in proc_dict:
        Overwrite = bool(proc_dict['Overwrite'])
    else:
        Overwrite = False
    print('Overwrite : ', Overwrite)
    #load data lazily
    print('loading : ', proc_path)
    time0 = time.time()
    dp = hs.load(proc_path, lazy=True)
    time1 = time.time()
    print('lazy loaded full data in :', time1 - time0, ' s')
    dp_bin = hs.load(proc_bin_path, lazy=True)
    time2 = time.time()
    print('lazy loaded binned data in :', time2 - time1, 's')
    #flag to tell if bf has already been calculated
    bf_bin_exist = 0
    bf_exist = 0

    #ADF analysis
    if 'ADF' in proc_dict:
        #pass ADF value from config file
        run_ADF = proc_dict['ADF']
        #define file save names
        ADF_file = proc_bin_path.rpartition('.')[0] + '_ADF'
        #print('ADF_file : ', ADF_file)
        if os.path.isfile(ADF_file + '.hspy'):
            #check overwrite flag and skip processing if set to zero
            if Overwrite == False:
                print('ADF data exists, skipping ADF analysis')
                run_ADF = 0
            else:
                print('ADF data exists, overwriting')
        #run adf analysis
        if run_ADF == 1:
            print('Running ADF analysis')
            time_ADF0 = time.time()
            #check if lazy and compute
            #if dp_bin._lazy:
            #dp_bin = dp_bin.compute()
            time_ADF1 = time.time()
            print('loaded binned data into memory in : ',
                  time_ADF1 - time_ADF0)
            if bf_bin_exist == 0:
                #get bf thrershold value
                bf_bin, bf_bin_exist = define_bf_disk(dp_bin, proc_dict)
            #get ADF inner angle
            if 'ADF_expand' in proc_dict:
                ADF_expand = proc_dict['ADF_expand']
            else:
                ADF_expand = 20
            #get ADF image
            ADF = get_adf(dp_bin, bf_bin, ADF_expand)
            #save ADF image
            ADF_file = proc_bin_path.rpartition('.')[0] + '_ADF'
            hs_ADF = hs.signals.Signal2D(ADF)
            hs_ADF.save(ADF_file, overwrite=Overwrite)
            hs_ADF.save(ADF_file, overwrite=Overwrite, extension='png')
            time_ADF2 = time.time()
            print('ADF analysis completed and saved in : ',
                  time_ADF2 - time_ADF0, ' s')
    #CoM analysis
    if 'CoM' in proc_dict:
        run_COM = proc_dict['CoM']
        #define file save names
        if 'bin_CoM' in proc_dict:
            if proc_dict['bin_CoM'] == 1:
                file_path = proc_bin_path.rpartition('.')[0]
            elif proc_dict['bin_CoM'] == 0:
                file_path = proc_path.rpartition('.')[0]
        CoMx_file = file_path + '_CoMx'
        CoMy_file = file_path + '_CoMy'
        #check if file exists
        if os.path.isfile(CoMx_file + '.hspy'):
            #check overwrite flag and skip processing if set to zero
            if Overwrite == False:
                print('CoM data exists, skipping CoM analysis')
                run_COM = 0
            else:
                print('CoM data exists, overwriting')
        #run CoM analysis
        if run_COM == 1:
            print('Running CoM analysis')
            time_CoM1 = time.time()
            if 'bin_CoM' in proc_dict:
                if proc_dict['bin_CoM'] == 1:
                    #if dp_bin._lazy:
                    #dp_bin = dp_bin.compute()
                    if bf_bin_exist == 0:
                        #get BF thrershold value
                        bf_bin, bf_bin_exist = define_bf_disk(
                            dp_bin, proc_dict)
                    bf_CoM = bf_bin
                    dp_CoM = py4DSTEM.file.datastructure.DataCube(dp_bin.data)

                elif proc_dict['bin_CoM'] == 0:
                    if bf_exist == 0:
                        bf, bf_exist = define_bf_disk(dp, proc_dict)
                    bf_CoM = bf
                    dp_CoM = py4DSTEM.file.datastructure.DataCube(dp.data)

            #get BF outer angle
            if 'BF_expand' in proc_dict:
                BF_expand = proc_dict['ADF_expand']
            else:
                BF_expand = 20
            #build mask
            mask = get_mask(dp_CoM, bf_CoM, BF_expand, bf_df='bf')
            #set normalise CoM parameter
            if 'Normalize_CoM' in proc_dict:
                Normalize_CoM = bool(proc_dict['Normalize_CoM'])
            else:
                Normalize_CoM = True
            #get CoM
            CoMx, CoMy = get_CoM_images(dp_CoM,
                                        mask=mask,
                                        normalize=Normalize_CoM)
            #pass to hyperspy and save
            hs_CoMx = hs.signals.Signal2D(CoMx)
            hs_CoMx.save(CoMx_file, overwrite=Overwrite)
            hs_CoMx.save(CoMx_file, overwrite=Overwrite, extension='png')

            hs_CoMy = hs.signals.Signal2D(CoMy)
            hs_CoMy.save(CoMy_file, overwrite=Overwrite)
            hs_CoMy.save(CoMy_file, overwrite=Overwrite, extension='png')
            time_CoM2 = time.time()
            print('CoM analysis completed and saved in : ',
                  time_CoM2 - time_CoM1, ' s')

    if 'DPC' in proc_dict:
        run_DPC = proc_dict['DPC']
        #define file name
        phase_file = file_path + '_phase'
        if os.path.isfile(phase_file + '.hspy'):
            #check overwrite flag and skip processing if set to zero
            if Overwrite == False:
                print('DPC data exists, skipping DPC analysis')
                run_DPC = 0
            else:
                print('DPC data exists, overwriting')
        if run_DPC == 1:
            print('Running DPC analysis')
            time_DPC1 = time.time()
            #get parameters
            theta = proc_dict['DPC_theta']
            flip = bool(proc_dict['DPC_flip'])
            pad_factor = int(proc_dict['DPC_pad'])
            low_pass = proc_dict['DPC_lowpass']
            high_pass = proc_dict['DPC_highpass']
            step_size = proc_dict['DPC_stepsize']
            niter = int(proc_dict['DPC_niter'])
            #load CoMx and CoMy if not already calculated
            try:
                CoMx
            except NameError:
                CoM_flag = False
            else:
                CoM_flag = True
            if CoM_flag == False:
                try:
                    CoMx_file = file_path + '_CoMx.hspy'
                    CoMy_file = file_path + '_CoMy.hspy'
                    CoMx = hs.load(CoMx_file)
                    CoMy = hs.load(CoMy_file)
                    CoMx = CoMx.data
                    CoMy = CoMy.data
                except:
                    print('CoM files do not exist - run CoM caculation')
            #calulate phase from CoM
            phase, error = get_phase_from_CoM(CoMx,
                                              CoMy,
                                              theta=theta,
                                              flip=flip,
                                              paddingfactor=pad_factor,
                                              regLowPass=low_pass,
                                              regHighPass=high_pass,
                                              stepsize=step_size,
                                              n_iter=niter)
            #pass to hyperspy object and save
            phase_file = file_path + '_phase'
            hs_phase = hs.signals.Signal2D(phase)
            hs_phase.save(phase_file, overwrite=Overwrite)
            hs_phase.save(phase_file, overwrite=Overwrite, extension='png')
            time_DPC2 = time.time()
            print('DPC analysis completed and saved in : ',
                  time_DPC2 - time_DPC1, ' s')
    time2 = time.time()
    print('Processing complete in : ', time2 - time0, ' s')
예제 #51
0
def test_loading_invalid_protochips_file():
    filename = os.path.join(dirpath, 'invalid_protochips_file.csv')
    with pytest.raises(IOError) as cm:
        hs.load(filename)
        cm.match(invalid_file_error)
예제 #52
0
def test_read_lazy_file():
    s = hs.load(file3, nxdata_only=True, lazy=True)
    assert s[0]._lazy and s[1]._lazy
예제 #53
0
def _load_and_cast(filepath, x, y, chunk_size):
    """ Loads a chunk of a larger diffraction pattern"""
    s = hs.load(filepath, lazy=True)
    s = s.inav[x:x + chunk_size, y:y + chunk_size]
    s.compute()
    return pxm.ElectronDiffraction2D(s)
예제 #54
0
## Testing ImagePlotter
#Im = np.random.random((2000,2000))
#a = ImagePlotter.ImagePlotter(ax, Im)

#### Testing SIPlotter
#SIdata = np.random.random(size = (20,30,50))
#SIdata[:, :, 10] = 2
#SI = SpectrumImage.EELSSpectrumImage(SIdata, dispersion=0.01)
#plotter=SpectrumImagePlotter.SpectrumImagePlotter(SI)
#plt.show()

###Testing SIPlotter with real data!
folder = '/home/isobel/Documents/McMaster/EELS/2016-07-28/Sq2R_(1,7)/'
filebase = 'EELS Spectrum Image (dark ref corrected).dm3'
s = hp.load(folder+filebase)
eels = SpectrumImage.EELSSpectrumImage(s.data)
#PSF = Spectrum.EELSSpectrum.LoadFromCSV('/home/isobel/Documents/McMaster/EELS/2016-07-27/SI3/Processed/Spectrum_ZLP.csv')
#print np.shape(PSF.intensity)
p1=SpectrumImagePlotter.SpectrumImagePlotter(eels, filepath=folder)
#eels2 = eels.RLDeconvolution(2, PSF)
#p2 = SpectrumImagePlotter.SpectrumImagePlotter(eels2)
p1.ShowPlot()


folderCL = '/home/isobel/Documents/McMaster/CL/T9-3_Sq1A_(1,3)/'
fileCL = 'T9-3_Sq1A_(1,3)h_Gr800at750_30keV_Ap3Spot4_2s_noQWP_noPol_full2.h5'
cl = CLSpectrumData.CLDataSet.LoadFromFile(folderCL + fileCL)

plotter = SpectrumImagePlotter.SpectrumImagePlotter(cl.SI)
예제 #55
0
def load_data(path=None,
              fls_file='',
              al_file='',
              flip=None,
              flip_fls_file=None,
              filtersize=3):
    """Load files in a directory (from a .fls file) using hyperspy. 

    For more information on how to organize the directory and load the data, as 
    well as how to setup the .fls file please refer to the README or the 
    TIE_template.ipynb notebook. 

    Args: 
        path: String. Location of data directory. 
        fls_file: String. Name of the .fls file which contains the image names 
            and defocus values. 
        al_file: String. Name of the aligned stack image file. 
        flip: Bool. Is there a flip stack? If false, it will not assume a 
            uniformly thick film and not reconstruct electrostatic phase shift.
    Optional Args: 
        flip_fls_file: String. Name of the .fls file for the flip images if they
            are not named the same as the unflip files. Will only be applied to 
            the /flip/ directory. 
        filtersize: Int. The images are processed with a median filter to remove
            hot pixels which occur in experimental data. This should be set to 0
            for simulated data, though generally one would only use this 
            function for experimental data. 
    
    Returns: 
        imstack: array of hyperspy signal2D objects (one per image)
        flipstack: array of hyperspy signal2D objects, only if flip
        ptie: TIE_params object holding a reference to the imstack and many
            useful parameters.
    """

    unflip_files = []
    flip_files = []

    if not fls_file.endswith('.fls'):
        fls_file += '.fls'

    if flip_fls_file is None:  # one fls file given
        fls = []
        with open(path + fls_file) as file:
            for line in file:
                fls.append(line.strip())

        num_files = int(fls[0])
        if flip:
            for line in fls[1:num_files + 1]:
                unflip_files.append(path + 'unflip/' + line)
            for line in fls[1:num_files + 1]:
                flip_files.append(path + 'flip/' + line)
        else:
            for line in fls[1:num_files + 1]:
                unflip_files.append(path + 'tfs/' + line)

    else:  # there are 2 fls files given
        if not flip:
            print(
                textwrap.dedent("""
                You probably made a mistake.
                You're defining a flip fls file but saying there is no full tfs for both unflip and flip.
                If just one tfs use one fls file.\n"""))
            sys.exit(1)
        if not flip_fls_file.endswith('.fls'):
            flip_fls_file += '.fls'

        fls = []
        flip_fls = []
        with open(path + fls_file) as file:
            for line in file:
                fls.append(line.strip())

        with open(path + flip_fls_file) as file:
            for line in file:
                flip_fls.append(line.strip())

        assert int(fls[0]) == int(flip_fls[0])
        num_files = int(fls[0])
        for line in fls[1:num_files + 1]:
            unflip_files.append(path + 'unflip/' + line)
        for line in flip_fls[1:num_files + 1]:
            flip_files.append(path + 'flip/' + line)

    # Actually load the data using hyperspy
    imstack = hs.load(unflip_files)
    if flip:
        flipstack = hs.load(flip_files)
    else:
        flipstack = []

    # convert scale dimensions to nm
    for sig in imstack + flipstack:
        sig.axes_manager.convert_units(units=['nm', 'nm'])

    if unflip_files[0][-4:] != '.dm3' and unflip_files[0][-4:] != '.dm4':
        # if not dm3's then they generally don't have the title metadata.
        for sig in imstack + flipstack:
            sig.metadata.General.title = sig.metadata.General.original_filename

    # load the aligned tifs and update the dm3 data to match
    # The data from the dm3's will be replaced with the aligned image data.
    try:
        al_tifs = io.imread(path + al_file)
    except FileNotFoundError as e:
        print('Incorrect aligned stack filename given.')
        raise e

    if flip:
        tot_files = 2 * num_files
    else:
        tot_files = num_files

    for i in range(tot_files):
        # pull slices from correct axis, assumes fewer slices than images are tall
        if al_tifs.shape[0] < al_tifs.shape[2]:
            im = al_tifs[i]
        elif al_tifs.shape[0] > al_tifs.shape[2]:
            im = al_tifs[:, :, i]
        else:
            print("Bad stack\n Or maybe the second axis is slice axis?")
            print('Loading failed.\n')
            sys.exit(1)

        # then median filter to remove "hot pixels"
        im = median_filter(im, size=filtersize)

        # and assign to appropriate stack
        if i < num_files:
            print('loading unflip:', unflip_files[i])
            imstack[i].data = im
        else:
            j = i - num_files
            print('loading flip:', flip_files[j])
            flipstack[j].data = im

    # read the defocus values
    defvals = fls[-(num_files // 2):]
    assert num_files == 2 * len(defvals) + 1
    defvals = [float(i) for i in defvals]  # defocus values +/-

    # Create a TIE_params object
    ptie = TIE_params(imstack, flipstack, defvals, flip, path)
    print('Data loaded successfully.')
    return (imstack, flipstack, ptie)
예제 #56
0
def test_load1():
    s = hs.load(FILE1)
    assert s.data.shape == (3, 2, 144, 144)
    assert s.axes_manager.as_dictionary() == axes1
예제 #57
0
def load_data(path=None,
              fls_file='',
              al_file='',
              flip=None,
              flip_fls_file=None,
              filtersize=3):
    """Load files in a directory (from a .fls file) using hyperspy. 

    For more information on how to organize the directory and load the data, as 
    well as how to setup the .fls file please refer to the README or the 
    TIE_template.ipynb notebook. 

    Args:
        path (str): Location of data directory. 
        fls_file (str): Name of the .fls file which contains the image names and
            defocus values. 
        al_file (str): Name of the aligned stack image file. 
        flip (Bool): True if using a flip stack, False otherwise. Uniformly 
            thick films can be reconstructed without a flip stack. The 
            electrostatic phase shift will not be reconstructed.
        flip_fls_file (str): Name of the .fls file for the flip images if they 
            are not named the same as the unflip files. Will only be applied to 
            the /flip/ directory. 
        filtersize (int): (`optional`) The images are processed with a median 
            filter to remove hot pixels which occur in experimental data. This 
            should be set to 0 for simulated data, though generally one would 
            only use this function for experimental data. 
    
    Returns:
        list: List of length 3, containing the following items: 

        - imstack: array of hyperspy signal2D objects (one per image)
        - flipstack: array of hyperspy signal2D objects, empty array if 
          flip == False  
        - ptie: TIE_params object holding a reference to the imstack and many
          other parameters.  

    """

    unflip_files = []
    flip_files = []

    # Finding the unflip fls file
    path = os.path.abspath(path)
    if not fls_file.endswith('.fls'):
        fls_file += '.fls'
    if os.path.isfile(os.path.join(path, fls_file)):
        fls_full = os.path.join(path, fls_file)
    elif os.path.isfile(os.path.join(path, 'unflip', fls_file)):
        fls_full = os.path.join(path, 'unflip', fls_file)
    elif os.path.isfile(os.path.join(path, 'tfs', fls_file)) and not flip:
        fls_full = os.path.join(path, 'tfs', fls_file)
    else:
        print("fls file could not be found.")
        sys.exit(1)

    if flip_fls_file is None:  # one fls file given
        fls = []
        with open(fls_full) as file:
            for line in file:
                fls.append(line.strip())

        num_files = int(fls[0])
        if flip:
            for line in fls[1:num_files + 1]:
                unflip_files.append(os.path.join(path, 'unflip', line))
            for line in fls[1:num_files + 1]:
                flip_files.append(os.path.join(path, 'flip', line))
        else:
            if os.path.isfile(os.path.join(path, 'tfs', fls[2])):
                tfs_dir = 'tfs'
            else:
                tfs_dir = 'unflip'
            for line in fls[1:num_files + 1]:
                unflip_files.append(os.path.join(path, tfs_dir, line))

    else:  # there are 2 fls files given
        if not flip:
            print(
                textwrap.dedent("""
                You probably made a mistake.
                You're defining both unflip and flip fls files but have flip=False.
                Proceeding anyways, will only load unflip stack (if it doesnt break).\n"""
                                ))
        # find the flip fls file
        if not flip_fls_file.endswith('.fls'):
            flip_fls_file += '.fls'
        if os.path.isfile(os.path.join(path, flip_fls_file)):
            flip_fls_full = os.path.join(path, flip_fls_file)
        elif os.path.isfile(os.path.join(path, 'flip', flip_fls_file)):
            flip_fls_full = os.path.join(path, 'flip', flip_fls_file)

        fls = []
        flip_fls = []
        with open(fls_full) as file:
            for line in file:
                fls.append(line.strip())

        with open(flip_fls_full) as file:
            for line in file:
                flip_fls.append(line.strip())

        assert int(fls[0]) == int(flip_fls[0])
        num_files = int(fls[0])
        for line in fls[1:num_files + 1]:
            unflip_files.append(os.path.join(path, "unflip", line))
        for line in flip_fls[1:num_files + 1]:
            flip_files.append(os.path.join(path, "flip", line))

    # Actually load the data using hyperspy
    imstack = hs.load(unflip_files)
    if flip:
        flipstack = hs.load(flip_files)
    else:
        flipstack = []

    # convert scale dimensions to nm
    for sig in imstack + flipstack:
        sig.axes_manager.convert_units(units=['nm', 'nm'])

    if unflip_files[0][-4:] != '.dm3' and unflip_files[0][-4:] != '.dm4':
        # if not dm3's then they generally don't have the title metadata.
        for sig in imstack + flipstack:
            sig.metadata.General.title = sig.metadata.General.original_filename

    # load the aligned tifs and update the dm3 data to match
    # The data from the dm3's will be replaced with the aligned image data.
    try:
        al_tifs = io.imread(os.path.join(path, al_file))
    except FileNotFoundError as e:
        print('Incorrect aligned stack filename given.')
        raise e

    if flip:
        tot_files = 2 * num_files
    else:
        tot_files = num_files

    for i in range(tot_files):
        # pull slices from correct axis, assumes fewer slices than images are tall
        if al_tifs.shape[0] < al_tifs.shape[2]:
            im = al_tifs[i]
        elif al_tifs.shape[0] > al_tifs.shape[2]:
            im = al_tifs[:, :, i]
        else:
            print("Bad stack\n Or maybe the second axis is slice axis?")
            print('Loading failed.\n')
            sys.exit(1)

        # then median filter to remove "hot pixels"
        im = median_filter(im, size=filtersize)

        # and assign to appropriate stack
        if i < num_files:
            print('loading unflip:', unflip_files[i])
            imstack[i].data = im
        else:
            j = i - num_files
            print('loading flip:', flip_files[j])
            flipstack[j].data = im

    # read the defocus values
    defvals = fls[-(num_files // 2):]
    assert num_files == 2 * len(defvals) + 1
    defvals = [float(i) for i in defvals]  # defocus values +/-

    # Create a TIE_params object
    ptie = TIE_params(imstack, flipstack, defvals, flip, path)
    print('Data loaded successfully.')
    return (imstack, flipstack, ptie)
예제 #58
0
import numpy as np

# hyperspy module
import hyperspy.api as hs
from hyperspy.drawing import widgets

# change working directory path
wd = os.getcwd()
os.chdir(wd)

## To generating calibration factor table as csv file
calibration = []

## read all dm3 fils in the folder
for filepath in sorted(glob.glob('./*.dm3')):
    img = hs.load(filepath)

    # get information from DM3 metadatas
    min = img.original_metadata.DocumentObjectList.TagGroup0.ImageDisplayInfo.LowLimit
    max = img.original_metadata.DocumentObjectList.TagGroup0.ImageDisplayInfo.HighLimit
    res = float(
        img.original_metadata.ImageList.TagGroup0.ImageData.Dimensions.Data0)
    cal = img.original_metadata.ImageList.TagGroup0.ImageData.Calibrations.Dimension.TagGroup0.Scale
    unit = img.original_metadata.ImageList.TagGroup0.ImageData.Calibrations.Dimension.TagGroup0.Units

    ### make a table for calibration factor
    item = [filepath, cal]
    calibration.append(item)
    np.savetxt("./calibration_dm3.csv", calibration, delimiter=",", fmt='%s')

    ## matplotlib export setting for savefig function
예제 #59
0
def test_write_data_line(save_path):
    signal = hs.signals.Signal2D(
        (255 * np.random.rand(3, 5, 5)).astype(np.uint8))
    signal.save(save_path, overwrite=True)
    sig_reload = hs.load(save_path)
    np.testing.assert_equal(signal.data, sig_reload.data)
예제 #60
0
import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from mpl_toolkits.axes_grid1.anchored_artists import AnchoredSizeBar
import matplotlib.font_manager as fm
import matplotlib.patheffects as patheffects
import hyperspy.api as hs

my_path = os.path.join(os.path.dirname(__file__), 'make_nice_figures')
if not os.path.exists(my_path):
    os.makedirs(my_path)

# Load the atomic resolution image
s_adf = hs.load(os.path.join(my_path, 'ADF_image.hdf5'))

# Load the structural data
atoms_A = np.load(os.path.join(my_path, 'sublattice_A.npz'))
atoms_B = np.load(os.path.join(my_path, 'sublattice_B.npz'))
dd_map = hs.load(os.path.join(my_path, 'distance_difference_map.hdf5'))
dd_line = hs.load(os.path.join(my_path, 'dd_line.hdf5'))

# Scaling the data
scale = 0.142
s_adf.axes_manager[0].scale = scale
s_adf.axes_manager[1].scale = scale
# dd_map has twice the amount of pixels, so the scale is half
dd_map.axes_manager[0].scale = scale / 2
dd_map.axes_manager[1].scale = scale / 2

# Crop images