Beispiel #1
0
def load_atom_lattice_from_hdf5(filename, construct_zone_axes=True):
    """
    Load an Atomap HDF5-file, restoring a saved Atom_Lattice.

    Parameters
    ----------
    filename : string
        Filename of the HDF5-file.
    construct_zone_axes : bool
        If True, find relations between atomic positions by
        constructing atomic planes. Default True.

    Returns
    -------
    Atomap Atom_Lattice object

    """
    h5f = h5py.File(filename, 'r')
    atom_lattice = Atom_Lattice()
    sublattice_list = []
    sublattice_index_list = []
    for group_name in h5f:
        if ('atom_lattice' in group_name) or ('sublattice' in group_name):
            sublattice_set = h5f[group_name]
            modified_image_data = sublattice_set['modified_image_data'][:]
            original_image_data = sublattice_set['original_image_data'][:]
            atom_position_array = sublattice_set['atom_positions'][:]

            if 'sublattice_index' in sublattice_set.attrs.keys():
                sublattice_index_list.append(
                    sublattice_set.attrs['sublattice_index'])

            sublattice = Sublattice(atom_position_array, modified_image_data)
            sublattice.original_image = original_image_data

            if 'sigma_x' in sublattice_set.keys():
                sigma_x_array = sublattice_set['sigma_x'][:]
                for atom, sigma_x in zip(sublattice.atom_list, sigma_x_array):
                    atom.sigma_x = sigma_x
            if 'sigma_y' in sublattice_set.keys():
                sigma_y_array = sublattice_set['sigma_y'][:]
                for atom, sigma_y in zip(sublattice.atom_list, sigma_y_array):
                    atom.sigma_y = sigma_y
            if 'rotation' in sublattice_set.keys():
                rotation_array = sublattice_set['rotation'][:]
                for atom, rotation in zip(sublattice.atom_list,
                                          rotation_array):
                    atom.rotation = rotation
####
            if 'amplitude_max_intensity' in sublattice_set.keys():
                amplitude_max_intensity_array = sublattice_set[
                    'amplitude_max_intensity'][:]
                for atom, amplitude_max_intensity in zip(
                        sublattice.atom_list, amplitude_max_intensity_array):
                    atom.amplitude_max_intensity = amplitude_max_intensity

            if 'amplitude_mean_intensity' in sublattice_set.keys():
                amplitude_mean_intensity_array = sublattice_set[
                    'amplitude_mean_intensity'][:]
                for atom, amplitude_mean_intensity in zip(
                        sublattice.atom_list, amplitude_mean_intensity_array):
                    atom.amplitude_mean_intensity = amplitude_mean_intensity

            if 'amplitude_min_intensity' in sublattice_set.keys():
                amplitude_min_intensity_array = sublattice_set[
                    'amplitude_min_intensity'][:]
                for atom, amplitude_min_intensity in zip(
                        sublattice.atom_list, amplitude_min_intensity_array):
                    atom.amplitude_min_intensity = amplitude_min_intensity

            if 'amplitude_total_intensity' in sublattice_set.keys():
                amplitude_total_intensity_array = sublattice_set[
                    'amplitude_total_intensity'][:]
                for atom, amplitude_total_intensity in zip(
                        sublattice.atom_list, amplitude_total_intensity_array):
                    atom.amplitude_total_intensity = amplitude_total_intensity

            if 'elements' in sublattice_set.keys():
                elements_array = sublattice_set['elements'][:]
                for atom, elements in zip(sublattice.atom_list,
                                          elements_array):
                    atom.elements = elements

            if 'z_height' in sublattice_set.keys():
                z_height_array = sublattice_set['z_height'][:]
                # z_height_array_2 = [] # first loop needed because i can't eval() the z_height itself, don't really know why
                # for i in range(0, len(z_height_array)):
                #   z_h = ast.literal_eval(z_height_array[i])
                #  z_height_array_2.append(z_h)
                for atom, z_height in zip(sublattice.atom_list,
                                          z_height_array):
                    atom.z_height = z_height


####
            sublattice.pixel_size = sublattice_set.attrs['pixel_size']

            if 'tag' in sublattice_set.attrs.keys():
                sublattice.name = sublattice_set.attrs['tag']
            elif 'name' in sublattice_set.attrs.keys():
                sublattice.name = sublattice_set.attrs['name']
            else:
                sublattice.name = ''

            if type(sublattice.name) == bytes:
                sublattice.name = sublattice.name.decode()

            sublattice._plot_color = sublattice_set.attrs['plot_color']

            if type(sublattice._plot_color) == bytes:
                sublattice._plot_color = sublattice._plot_color.decode()

            if 'pixel_separation' in sublattice_set.attrs.keys():
                sublattice._pixel_separation = sublattice_set.attrs[
                    'pixel_separation']
            else:
                sublattice._pixel_separation = 0.0

            if construct_zone_axes:
                construct_zone_axes_from_sublattice(sublattice)

            if 'zone_axis_names_byte' in sublattice_set.keys():
                zone_axis_list_byte = sublattice_set.attrs[
                    'zone_axis_names_byte']
                zone_axis_list = []
                for zone_axis_name_byte in zone_axis_list_byte:
                    zone_axis_list.append(zone_axis_name_byte.decode())
                sublattice.zones_axis_average_distances_names = zone_axis_list

            sublattice_list.append(sublattice)

        if group_name == 'image_data0':
            atom_lattice.image0 = h5f[group_name][:]
            atom_lattice.image = atom_lattice.image0
        if group_name == 'image_data1':
            atom_lattice.image1 = h5f[group_name][:]

    sorted_sublattice_list = []
    if not sublattice_index_list:  # Support for older hdf5 files
        sublattice_index_list = range(len(sublattice_list))
    for sublattice_index in sublattice_index_list:
        sorted_sublattice_list.append(sublattice_list[sublattice_index])
    atom_lattice.sublattice_list.extend(sorted_sublattice_list)
    if 'name' in h5f.attrs.keys():
        atom_lattice.name = h5f.attrs['name']
    elif 'path_name' in h5f.attrs.keys():
        atom_lattice.name = h5f.attrs['path_name']
    if 'pixel_separation' in h5f.attrs.keys():
        atom_lattice._pixel_separation = h5f.attrs['pixel_separation']
    else:
        atom_lattice._pixel_separation = 0.8 / sublattice.pixel_size
    if type(atom_lattice.name) == bytes:
        atom_lattice.name = atom_lattice.name.decode()
    h5f.close()
    return (atom_lattice)
Beispiel #2
0
def make_atom_lattice_from_image(s_image0,
                                 process_parameter=None,
                                 pixel_separation=None,
                                 s_image1=None,
                                 debug_plot=False):
    if s_image0.data.dtype == 'float16':
        raise ValueError(
            "s_image0 has the dtype float16, which is not supported. "
            "Convert it to something else, for example using "
            "s_image0.change_dtype('float64')")
    image0_filename = _get_signal_name(s_image0)

    name = image0_filename

    s_image0 = s_image0.deepcopy()
    s_image0_modified = run_image_filtering(s_image0)

    if process_parameter is None:
        process_parameter = pp.GenericStructure()

    image0_scale = s_image0.axes_manager[0].scale
    if pixel_separation is None:
        if process_parameter.peak_separation is None:
            raise ValueError("pixel_separation is not set.\
                    Either set it in the process_parameter.peak_separation\
                    or pixel_separation parameter")
        else:
            pixel_separation = process_parameter.peak_separation / image0_scale
    initial_atom_position_list = get_atom_positions(
        s_image0_modified, separation=pixel_separation)

    if s_image1 is not None:
        if s_image1.data.dtype == 'float16':
            raise ValueError(
                "s_image1 has the dtype float16, which is not supported. "
                "Convert it to something else, for example using "
                "s_image1.change_dtype('float64')")
        s_image1 = s_image1.deepcopy()
        s_image1.data = 1. / s_image1.data
        image1_data = s_image1.data

    #################################

    image0_data = s_image0.data
    image0_data_modified = s_image0_modified.data

    atom_lattice = Atom_Lattice(name=name)
    atom_lattice._original_filename = image0_filename
    atom_lattice.image0 = image0_data
    if s_image1 is not None:
        atom_lattice.image1 = image1_data
    atom_lattice._pixel_separation = pixel_separation

    for sublattice_index in range(process_parameter.number_of_sublattices):
        sublattice_para = process_parameter.get_sublattice_from_order(
            sublattice_index)

        if sublattice_para.image_type == 0:
            s_image = s_image0
            image_data = image0_data
            image_data_modified = image0_data_modified
        if sublattice_para.image_type == 1:
            if s_image1 is not None:
                s_image = s_image1
                image_data = image1_data
                image_data_modified = image1_data
            else:
                break

        if sublattice_para.sublattice_order == 0:
            sublattice = Sublattice(initial_atom_position_list,
                                    image_data_modified)
        else:
            temp_sublattice = atom_lattice.get_sublattice(
                sublattice_para.sublattice_position_sublattice)
            temp_zone_vector_index = temp_sublattice.get_zone_vector_index(
                sublattice_para.sublattice_position_zoneaxis)
            zone_vector = temp_sublattice.zones_axis_average_distances[
                temp_zone_vector_index]
            atom_list = temp_sublattice.find_missing_atoms_from_zone_vector(
                zone_vector)

            sublattice = Sublattice(atom_list, image_data)

        zone_axis_para_list = False
        if hasattr(sublattice_para, 'zone_axis_list'):
            zone_axis_para_list = sublattice_para.zone_axis_list

        sublattice._plot_color = sublattice_para.color
        sublattice.name = sublattice_para.name
        sublattice.pixel_size = s_image.axes_manager[0].scale
        sublattice._pixel_separation = pixel_separation
        sublattice.original_image = image_data
        atom_lattice.sublattice_list.append(sublattice)
        if debug_plot:
            sublattice.plot_atom_list_on_image_data(figname=sublattice.name +
                                                    "_initial_position.jpg")
        for atom in sublattice.atom_list:
            atom.sigma_x = sublattice._pixel_separation / 10.
            atom.sigma_y = sublattice._pixel_separation / 10.
        if not (sublattice_para.sublattice_order == 0):
            construct_zone_axes_from_sublattice(
                sublattice, zone_axis_para_list=zone_axis_para_list)
            atom_subtract_config = sublattice_para.atom_subtract_config
            image_data = sublattice.image
            for atom_subtract_para in atom_subtract_config:
                temp_sublattice = atom_lattice.get_sublattice(
                    atom_subtract_para['sublattice'])
                neighbor_distance = atom_subtract_para['neighbor_distance']
                image_data = remove_atoms_from_image_using_2d_gaussian(
                    image_data,
                    temp_sublattice,
                    percent_to_nn=neighbor_distance)
            sublattice.image = image_data
            sublattice.original_image = image_data

        refinement_config = sublattice_para.refinement_config
        refinement_neighbor_distance = refinement_config['neighbor_distance']
        refinement_steps = refinement_config['config']
        for refinement_step in refinement_steps:
            if refinement_step[0] == 'image_data':
                refinement_step[0] = sublattice.original_image
            elif refinement_step[0] == 'image_data_modified':
                refinement_step[0] = sublattice.image
            else:
                refinement_step[0] = sublattice.original_image

        refine_sublattice(sublattice, refinement_steps,
                          refinement_neighbor_distance)

        if sublattice_para.sublattice_order == 0:
            sublattice.construct_zone_axes(
                zone_axis_para_list=zone_axis_para_list)

    return (atom_lattice)